draftwright 0.4.22__tar.gz → 0.4.24__tar.gz

{draftwright-0.4.22 → draftwright-0.4.24}/CHANGELOG.md

@@ -478,6 +478,10 @@
 
 ### Fixed
 
+- Overall height and envelope width remain dimensioned when approved turned-step lengths
+  cover only part of the respective extent. Redundancy suppression now requires adjoining
+  measurements on one profile to reach both overall endpoints; STC618 retains its missing
+  62 mm height (#1509).
 - Non-1:1 orthographic and isometric projection now scales extracted solids about the world
   origin, matching the view-coordinate mapper and solver zones. Solids carrying a non-zero
   build123d `Location` no longer shift their silhouette away from dimensions and callouts.

{draftwright-0.4.22 → draftwright-0.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.22
+Version: 0.4.24
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -687,10 +687,12 @@ Requires-Dist: antlr4-python3-runtime<4.10
 Requires-Dist: build123d-drafting-helpers>=0.14.2
 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: cadquery-ocp-novtk!=7.9.3.1.1; python_full_version >= '3.13'
 Requires-Dist: numpy>=1.24
+Requires-Dist: ocp-gordon<0.3
 Requires-Dist: pillow>=10
 Requires-Dist: pypdfium2>=4
-Requires-Dist: quiddity==0.2.5
+Requires-Dist: quiddity==0.2.6
 Requires-Dist: reportlab>=4.0
 Requires-Dist: steputils==0.1
 Requires-Dist: svglib>=1.5

{draftwright-0.4.22 → draftwright-0.4.24}/docs/reference/recogniser-capabilities.md

@@ -70,9 +70,9 @@ issue. The contract test derives package record outputs, converter registries, l
 and emitter branches independently, so copying a new name into the declaration alone cannot make CI
 pass.
 
-### Quiddity 0.2.5 runtime contract
+### Quiddity 0.2.6 runtime contract
 
-The runtime pins the published `quiddity==0.2.5` package, following the 0.2.4 adoption in
+The runtime pins the published `quiddity==0.2.6` package, following the 0.2.4 adoption in
 [#1486](https://github.com/pzfreo/draftwright/pull/1486) and the migration in
 [#1471](https://github.com/pzfreo/draftwright/issues/1471). Its public `quiddity`, `quiddity.evidence` and
 `quiddity.inspection` surfaces supply recognition, exact occurrence evidence and declared geometry

{draftwright-0.4.22 → draftwright-0.4.24}/docs/reference/sheet.md

@@ -67,6 +67,86 @@ build. Build and lint still assess the resulting Sheet. A
 query never replaces an existing dimension request. Keep the original feature handle for edits;
 these reports do not introduce persistent feature identities or new lane, route or pin controls.
 
+## Angular measurements
+
+`Sheet.angle()` derives an included angle from a vertex and two witness points
+in model coordinates. Select its canonical `included.angle` measurement with
+`dimension()`. The engine chooses a true-angle principal view and places the arc,
+arrows and complete compiler-owned label through the shared corridor solver.
+
+```python
+from math import sqrt
+from build123d import Polygon, extrude
+from draftwright import Sheet
+
+part = extrude(Polygon((0, 0), (30, 0), (15, 15 * sqrt(3)), align=None), amount=3)
+sheet = Sheet(part).authored_dimensions()
+angle = sheet.angle(
+    vertex=(0, 0, 3), first=(15, 0, 3), second=(7.5, 7.5 * sqrt(3), 3),
+)
+angle.tolerance(0.05, on="included.angle")
+sheet.dimension(angle, "included.angle")
+drawing = sheet.build()
+for finding in drawing.lint():
+    print(finding.code, finding.message)
+```
+
+The default `sector="minor"` is the non-reflex angle towards the two witness
+points. `sector="opposite"` selects the vertically opposite sector, extending
+both supports through the vertex. It preserves the numerical angle and can keep
+an exterior dimension beside its corner. The engine never silently switches
+between these sectors or substitutes a supplementary angle.
+Reversing witness order preserves the selected angle. For extended supports meeting beyond
+a rounded corner, use `virtual_vertex=True`; this declares the virtual
+intersection without asserting that the vertex lies on a physical edge.
+Zero-length or collinear rays, oblique planes and unsupported sectors are
+rejected. Insufficient page space produces `angular_dimension_dropped` against
+the named measurement. Symmetric tolerances and lower/upper deviation magnitudes
+retain degree units, including small deviations when the nominal display is
+coarse. Omitting the dimension request suppresses the angle; generated scripts
+retain its reference geometry and tolerances.
+
+After building, `drawing.dimension(feature, "included.angle", pin=True, priority=2)`
+uses the shared corridor in live and deferred edits. As with other edits, use an
+exact feature from `drawing.model()`. Measurement comparison records the angular
+references, so equal-valued support substitutions cannot appear preserved merely
+because the labels match.
+
+`Sheet.angle_pattern(*references)` declares repeated coplanar corners using
+`AngularReference` values from `draftwright.model`. Each corner remains independently
+addressable as `included.angle.member1`, `included.angle.member2`, and so on, in
+declaration order. Request every member with `dimension()` to permit one quantity
+label such as `3× 60°`. Different member tolerances or side preferences produce
+individual labels; omitting one member suppresses that measurement without renumbering
+the others. The generated script retains the full member geometry and each request.
+
+After the conservative strip solve, curved dimensions have up to three
+corner-local radius alternatives at the existing tier spacing. The shared
+placement stage accepts a shorter radius or recovers a dropped candidate only
+when its actual lines and label clear fixed and same-batch ink and fit the page.
+Pinned dimensions retain their solved position.
+
+The lower-level `measured_dimension(kind="angular", ...)` route retains nominal
+author-supplied text. Its explicit `AngularReference` supplies the same ray
+geometry; plain Sheet-authored three-point `ref_pts` use `(first, vertex, second)`.
+Imported PMI requires explicit ordering. Structured tolerances on that raw route
+remain unsupported; use the canonical declaration for new authored angles.
+Lint compares degree values at their displayed resolution, inspects the visible
+angular ink and checks complete canonical labels against the compiler. Physical
+critique checks each claimed corner against finite supports in the cached provider
+evidence, including members represented by a quantity label. Unprovable correspondence
+produces `angular_support_unverifiable`; contradictory supports produce
+`angular_support_mismatch`.
+
+Automatic drawings derive outside-profile angular requirements from ordered face
+supports in Quiddity 0.2.6. Angles already defined by a recognised chamfer or
+regular-polygon callout do not add duplicate automatic requirements. This requires
+the same run's exact face or shared-edge evidence, not matching numerical angles;
+explicit angle declarations remain available on those corners.
+Verified profile repetitions can share a quantity label;
+equal numerical angles alone do not establish a pattern. The requirement audit retains
+one outcome per physical corner even when several share one mark.
+
 ## Selecting a hole location component
 
 Use `location` alone to request the usual location set. To select one component of a hole
@@ -171,6 +251,12 @@ omission suppresses a view. `add_view(...)`, `add_section_view(...)` and
 `column(...)` are shorthand for whole-view relations. A principal-view handle's `pin((x, y))`
 anchors its projection origin in page millimetres; it never positions an annotation.
 
+A detail around a turned step with an approved `step.length` uses a profile view
+and redraws that length through the shared dimension pass. For example,
+`s.detail_view("A", around=shoulder).scale(3)` retains its measurement identity and
+tolerance at three times the sheet scale. Omitted measurements stay omitted. An
+authored recovery detail that cannot place its dimension raises an error.
+
 Principal orthographic views share the sheet scale and reject `.scale(...)`. Detail and
 isometric handles may carry an independent positive factor. Infeasible relations, scales and
 pins raise with their declaration source; unsupported pins on derived or pictorial views are

{draftwright-0.4.22 → draftwright-0.4.24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.22"
+version = "0.4.24"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -17,8 +17,13 @@ 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'",
+    # Supported build123d releases use OCP 7.x; ocp_gordon 0.3 requires OCP 8.x.
+    "ocp_gordon<0.3",
+    # This novtk release lacks OCP.GccEnt on macOS. The exclusion must reach
+    # published wheels, not only uv's development resolver constraints.
+    "cadquery-ocp-novtk!=7.9.3.1.1 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.14.2",
-    "quiddity==0.2.5",
+    "quiddity==0.2.6",
     "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
@@ -187,12 +192,3 @@ skip = "*.stp,*.step,*.svg,*.dxf,*.pdf,uv.lock,.git,*.ttf,*.otf,src/draftwright/
 # `nd` a Dijkstra distance var, `tread` a real word (stair-tread faces), `accreting`
 # a real word, `testof` the `TestOf` class name, and the valid hyphenated re-* forms.
 ignore-words-list = "nd,tread,accreting,testof,re-using,re-declare,re-declared,re-declaring"
-
-[tool.uv]
-# On Python 3.13/3.14, build123d resolves to 0.11, whose OCP kernel is
-# cadquery-ocp-novtk (VTK dropped from the transitive tree — fine here, draftwright
-# renders headless and never imports VTK). Its 7.9.3.1.1 release ships a broken macOS
-# wheel (no OCP.GccEnt module → build123d fails to import), so pin it out. Only bites
-# when novtk is actually resolved (build123d 0.11); harmless on 0.10/cadquery-ocp.
-# Mirrors pzfreo/build123d-mcp. Remove once upstream fixes the wheel.
-constraint-dependencies = ["cadquery-ocp-novtk!=7.9.3.1.1"]

{draftwright-0.4.22 → draftwright-0.4.24}/src/draftwright/_geometry.py

@@ -585,6 +585,30 @@ def _fmt(v: float, decimals: int | None = None) -> str:
     return str(r) if abs(v - r) < 1e-6 else f"{v:.1f}"
 
 
+def _fmt_angle(value, decimals=None, tolerance=None) -> str:
+    """Complete angular text shared by footprint sizing and compilation.
+
+    This pure formatter approves no content and needs no feature or compiled plan.
+    """
+    nominal = f"{_fmt(value, decimals)}°"
+    if tolerance is None:
+        return nominal
+
+    def magnitude(value):
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            raise ValueError("angular tolerance must be a nonnegative degree magnitude")
+        if not math.isfinite(value) or value < 0:
+            raise ValueError("angular tolerance must be finite and nonnegative")
+        # Keep small authored deviations even when nominal display precision is
+        # coarse; formatting a nonzero tolerance as zero would change the claim.
+        return format(Decimal(str(value)), "f")
+
+    if isinstance(tolerance, tuple) and len(tolerance) == 2:
+        lower, upper = tolerance
+        return f"{nominal} +{magnitude(upper)}° -{magnitude(lower)}°"
+    return f"{nominal} ±{magnitude(tolerance)}°"
+
+
 def _boxes_overlap(a, b) -> bool:
     """True when two ``(x0, y0, x1, y1)`` AABBs overlap (strict: a touch is not
     an overlap). The one pairwise test behind both the placement-side

draftwright-0.4.24/src/draftwright/angular_geometry.py

@@ -0,0 +1,146 @@
+"""Analytic angular footprints shared by composition and rendered dimensions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from math import atan2, cos, hypot, pi, sin
+
+
+@dataclass(frozen=True)
+class AngularStyle:
+    """Fixed paper-space dimensions needed for analytic angular ink."""
+
+    arrow_length: float
+    extension_gap: float
+    pad_around_text: float
+    line_width: float
+
+
+def _box(points, padding=0.0):
+    xs, ys = zip(*points, strict=True)
+    return min(xs) - padding, min(ys) - padding, max(xs) + padding, max(ys) + padding
+
+
+def _rotate(point, angle):
+    c, s = cos(angle), sin(angle)
+    x, y = point
+    return c * x - s * y, s * x + c * y
+
+
+class AngularGeometry:
+    """One projected angular intent; only its radius varies during placement.
+
+    Coordinates belong to the already selected true-angle projection. The two
+    directed rays fix the sector: moving an annotation cannot turn an acute
+    dimension into its supplementary angle or move it to the opposite sector.
+    """
+
+    def __init__(self, vertex, first, second, text_size, draft, *, sector="minor"):
+        if sector not in ("minor", "opposite"):
+            raise ValueError("angular ink needs a minor or opposite sector")
+        self.sector = sector
+        self.vertex = tuple(vertex[:2])
+        points = (tuple(first[:2]), tuple(second[:2]))
+        rays = [tuple(p - v for p, v in zip(point, self.vertex, strict=True)) for point in points]
+        lengths = tuple(hypot(*ray) for ray in rays)
+        # Page-fit bisection can project valid model rays far below a nanometre.
+        # Their directions still define the same angle and fixed-size label;
+        # rejecting them here turns an infeasible sheet into a render exception.
+        if min(lengths) == 0:
+            raise ValueError("angular ink needs two nonzero projected rays")
+        rays = [tuple(c / length for c in ray) for ray, length in zip(rays, lengths, strict=True)]
+        if sector == "opposite":
+            rays = [tuple(-component for component in ray) for ray in rays]
+            lengths = tuple(-length for length in lengths)
+        first_ray, second_ray = rays
+        signed = atan2(
+            first_ray[0] * second_ray[1] - first_ray[1] * second_ray[0],
+            sum(a * b for a, b in zip(first_ray, second_ray, strict=True)),
+        )
+        self.sweep = abs(signed)
+        if not 1e-9 < self.sweep < pi - 1e-9:
+            raise ValueError("angular ink needs a nondegenerate minor sector")
+        if signed < 0:
+            first_ray, second_ray = second_ray, first_ray
+            points = points[::-1]
+            lengths = lengths[::-1]
+        self.start = atan2(first_ray[1], first_ray[0])
+        self.middle = self.start + self.sweep / 2
+        self.rays = (first_ray, second_ray)
+        self.witnesses = points
+        self.lengths = lengths
+        self.draft = draft
+        self.text_size = text_size
+        tangent = (self.middle + pi / 2) % (2 * pi)
+        self.text_angle = tangent - pi if pi / 2 < tangent <= 3 * pi / 2 else tangent
+        width, height = self.text_size
+        # This bound leaves room for both arrow shafts and the full text. It also
+        # keeps extension lines beyond their physical witness points. Opposite
+        # witnesses have negative stations: their extensions cross the vertex.
+        self.minimum_radius = max(
+            max(lengths) + draft.extension_gap + draft.arrow_length,
+            (width + height + 2 * draft.pad_around_text + 4 * draft.arrow_length) / self.sweep
+            + height / 2
+            + draft.pad_around_text,
+        )
+
+    @property
+    def bisector(self):
+        return cos(self.middle), sin(self.middle)
+
+    def point(self, radius, angle):
+        x, y = self.vertex
+        return x + radius * cos(angle), y + radius * sin(angle)
+
+    def label_polygon(self, radius):
+        width, height = self.text_size
+        centre = self.point(radius, self.middle)
+        return tuple(
+            tuple(a + b for a, b in zip(centre, _rotate(point, self.text_angle), strict=True))
+            for point in (
+                (-width / 2, -height / 2),
+                (width / 2, -height / 2),
+                (width / 2, height / 2),
+                (-width / 2, height / 2),
+            )
+        )
+
+    def extension_segments(self, radius):
+        end_radius = radius + self.draft.extension_gap
+        return tuple(
+            (
+                self.point(length + self.draft.extension_gap, angle),
+                self.point(end_radius, angle),
+            )
+            for length, angle in zip(
+                self.lengths, (self.start, self.start + self.sweep), strict=True
+            )
+        )
+
+    def arc_intervals(self, radius):
+        width, height = self.text_size
+        gap = atan2(
+            width / 2 + self.draft.pad_around_text,
+            radius - height / 2 - self.draft.pad_around_text,
+        )
+        intervals = ((self.start, self.middle - gap), (self.middle + gap, self.start + self.sweep))
+        if any((end - start) * radius <= self.draft.arrow_length for start, end in intervals):
+            raise ValueError("angular radius cannot carry the complete label and arrows")
+        return intervals
+
+    def footprint(self, radius):
+        """Conservative analytic ink box, including arc extrema and arrow heads.
+
+        The perpendicular extent changes with radius. Supplying this function to
+        the corridor prevents its straight-dimension translation model from
+        hiding obstacles from an angular candidate.
+        """
+        angles = [self.start, self.start + self.sweep]
+        for index in range(-4, 9):
+            angle = index * pi / 2
+            if self.start < angle < self.start + self.sweep:
+                angles.append(angle)
+        points = [self.point(radius, angle) for angle in angles]
+        points.extend(point for segment in self.extension_segments(radius) for point in segment)
+        points.extend(self.label_polygon(radius))
+        return _box(points, self.draft.arrow_length + self.draft.line_width)

{draftwright-0.4.22 → draftwright-0.4.24}/src/draftwright/annotations/_common.py

@@ -13,6 +13,7 @@ import logging
 import math
 import os
 from dataclasses import dataclass, field
+from itertools import chain
 from pathlib import Path
 from typing import Any
 
@@ -33,6 +34,7 @@ from draftwright._geometry import (  # noqa: F401
     _segment_crosses_box,
     _segments_cross_or_overlap,
 )
+from draftwright.annotations.angular import AngularDimension
 from draftwright.layout import StripCandidate, plan_strip
 from draftwright.linting.ink_overlap import (
     MIN_CROSSING_MM,
@@ -44,6 +46,8 @@ from draftwright.linting.issues import LintIssue
 from draftwright.linting.structural import (
     _ann_box,
     _centerline_extent,
+    _edges_intersect_rect,
+    _view_edge_entries,
 )
 from draftwright.model.compiled import resolve_feature
 from draftwright.model.ir import HoleFeature, PatternFeature
@@ -616,6 +620,12 @@ class SolveTrace:
         (with *label*) for a pass-local strip placement outside any corridor."""
         rec: dict = {
             "force": force,
+            # A fallback can use another axis/view while its parent corridor is
+            # still open. Every pass therefore owns its coordinate frame.
+            "label": label,
+            "view": view,
+            "axis": axis,
+            "strip": self._strip_rec(strip),
             "obstacles": [],
             "free_segments": [],
             "placed": [],
@@ -628,10 +638,6 @@ class SolveTrace:
             rec = {
                 "seq": self._next_seq(),
                 "phase": self._phase,
-                "label": label,
-                "view": view,
-                "axis": axis,
-                "strip": self._strip_rec(strip),
                 **rec,
                 "items": [],
             }
@@ -1504,7 +1510,7 @@ def box_within_page_and_clear(bb, page_box, obstacles) -> bool:
     )
 
 
-def annotation_ink_clear(dwg, candidate, *, view=None) -> bool:
+def annotation_ink_clear(dwg, candidate, *, view=None, additional=()) -> bool:
     """Whether *candidate* clears exact decomposable ink and conservative fixed furniture.
 
     A diagonal dimension cannot use the strip system's conservative AABB occupancy as its
@@ -1528,8 +1534,8 @@ def annotation_ink_clear(dwg, candidate, *, view=None) -> bool:
     )
     if candidate_region is None:
         return False
-    for name, annotation in dwg.iter_annotations():
-        owner = dwg.view_of(name)
+    for name, annotation in chain(dwg.iter_annotations(), ((None, item) for item in additional)):
+        owner = dwg.view_of(name) if name is not None else view
         if view is not None and owner is not None and owner != view:
             continue
         annotation_segments = segments_of(annotation)
@@ -1542,9 +1548,9 @@ def annotation_ink_clear(dwg, candidate, *, view=None) -> bool:
             item=annotation,
             segments=annotation_segments,
         )
-        crossable_strokes = isinstance(annotation, (Dimension, SafeDimension)) or (
-            type(annotation).__name__ in CROSSABLE_TYPES
-        )
+        crossable_strokes = isinstance(
+            annotation, (Dimension, SafeDimension, AngularDimension)
+        ) or (type(annotation).__name__ in CROSSABLE_TYPES)
         if annotation_label is not None and annotation_region is None:
             try:
                 conservative_label_hit = _boxes_overlap(candidate_label, annotation_label) or any(
@@ -1593,6 +1599,19 @@ def annotation_ink_clear(dwg, candidate, *, view=None) -> bool:
     return True
 
 
+def view_label_clearance(dwg, view):
+    """A label guard over the same projected edges the structural critic reads.
+
+    Prepare the edges once per batch, outside candidate evaluation. Missing view
+    geometry supplies no guard; unreadable geometry cannot establish clearance.
+    """
+    placed = getattr(dwg, "views", {}).get(view)
+    if not placed or placed[0] is None:
+        return None
+    entries = _view_edge_entries(placed[0], {})
+    return lambda box: entries is not None and not _edges_intersect_rect(entries, box)
+
+
 def prevent_dimension_label_ink(
     dimensions,
     *,
@@ -1600,6 +1619,7 @@ def prevent_dimension_label_ink(
     immutable=(),
     obstacles=(),
     perpendicular_step=None,
+    label_clear=None,
 ):
     """Choose small along-line label offsets for a just-built dimension batch.
 
@@ -1627,12 +1647,14 @@ def prevent_dimension_label_ink(
     whose line-work cannot be cleared by moving labels along their measured spans.
     Fixed *obstacles* do not make an existing contact this local batch's responsibility, but
     no selected move may introduce a new label contact with one.
+    ``label_clear`` optionally checks labels against projected part ink. Unlike
+    pre-existing annotation contacts, these are conflicts to resolve in this batch.
 
     Returns ``[(name, dimension), ...]`` in input order.
     """
 
     original = list(dimensions)
-    if len(original) < 2:
+    if not original or (len(original) < 2 and label_clear is None):
         return original
     immutable = set(immutable)
     obstacles = tuple(obstacles)
@@ -1729,6 +1751,8 @@ def prevent_dimension_label_ink(
         for target, (label, region) in enumerate(zip(labels, regions, strict=True)):
             if label is None or region is None:
                 continue
+            if label_clear is not None and not label_clear(label):
+                found.add(("view", target))
             # Helpers expose no arrow polygons.  The foreign dimension's exact
             # attachment tips still participate, closing the line-metadata gap without
             # guessing the orientation of this dimension's own inside/outside arrows.
@@ -1907,6 +1931,8 @@ def prevent_dimension_label_ink(
                 involved.update((conflict[1], conflict[2]))  # source + crossed label
             elif conflict[0] == "fixed":
                 involved.add(conflict[2])
+            elif conflict[0] == "view":
+                involved.add(conflict[1])
             else:  # label/label
                 involved.update((conflict[1], conflict[2]))
         best = None
@@ -2053,6 +2079,13 @@ class CorridorCandidate:
     # 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
+    # A candidate can need a minimum geometric clearance (e.g. an angular arc
+    # must carry its complete label). Reject an infeasible tier before building
+    # OCC ink; the caller's normal drop/fallback path remains authoritative.
+    valid_position: object | None = None
+    # Bounded curved-ink alternatives, checked against actual ink after the
+    # conservative strip solve. They preserve the approved content and sector.
+    compact_candidates: object | None = None
 
 
 def solve_corridor(dwg, strip, view, axis, cands, tier, corner_reserves=(), *, key=None, ctx=None):
@@ -2210,6 +2243,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier, corner_reserves=(), *, k
     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)
+    valid_positions = {c.name: c.valid_position for c in kept if c.valid_position is not None}
+    compactions = {c.name: c.compact_candidates for c in kept if c.compact_candidates is not None}
     left = {
         n
         for n, _ in place_strip_candidates(
@@ -2229,6 +2264,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier, corner_reserves=(), *, k
             anchored=anchored,
             naturals=naturals,
             footprints=foots,
+            valid_positions=valid_positions,
+            compact_candidates=compactions,
             corner_reserves=corner_reserves,
             trace=trace,
         )
@@ -2247,6 +2284,8 @@ def solve_corridor(dwg, strip, view, axis, cands, tier, corner_reserves=(), *, k
                 ctx=ctx,
                 force=True,
                 footprints=foots,
+                valid_positions=valid_positions,
+                compact_candidates=compactions,
                 corner_reserves=corner_reserves,
                 features=feats,
                 measurements=meas,
@@ -2538,6 +2577,8 @@ def place_strip_candidates(
     anchored=None,
     naturals=None,
     footprints=None,
+    valid_positions=None,
+    compact_candidates=None,
     corner_reserves=(),
     trace=None,
     trace_label=None,
@@ -2777,6 +2818,11 @@ def place_strip_candidates(
                 _reject(name, "over_capacity")
                 rejected.append((name, build))
                 continue
+            valid_position = (valid_positions or {}).get(name)
+            if valid_position is not None and not valid_position(pos):
+                _reject(name, "geometric_clearance")
+                rejected.append((name, build))
+                continue
             # 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.
@@ -2867,6 +2913,48 @@ def place_strip_candidates(
                 continue
             real = _geom_box(dim)
             solved.append((name, natural if _real_box_conflict(name, real) else dim))
+    # Curved ink can enclose large empty rectangles. After the shared strip
+    # solve, try a bounded contraction using actual segments and labels against
+    # both committed ink and this batch. Never move an anchored dimension.
+    active_names = {name for name, _build in cands}
+    for name, alternatives in (compact_candidates or {}).items():
+        if name not in active_names:
+            continue
+        if (anchored or {}).get(name, False):
+            continue
+        index = next((i for i, (key, _dim) in enumerate(solved) if key == name), None)
+        original = solved[index][1] if index is not None else None
+        others = [item for key, item in solved if key != name]
+        for candidate in alternatives():
+            if original is not None and candidate.arc_radius >= original.arc_radius - 1e-6:
+                break
+            box = _geom_box(candidate)
+            if (
+                box is None
+                or box[0] < _MARGIN
+                or box[1] < _MARGIN
+                or box[2] > dwg.page_w - _MARGIN
+                or box[3] > dwg.page_h - _MARGIN
+                or ((forbid or {}).get(name) is not None and _box_hits(box, (forbid[name],)))
+                or not annotation_ink_clear(dwg, candidate, additional=others)
+            ):
+                continue
+            if index is None:
+                solved.append((name, candidate))
+                todo = [(key, build) for key, build in todo if key != name]
+                if tp is not None:
+                    label = candidate.label_bbox
+                    tp["placed"].append({"name": name, "pos": (label[idx] + label[idx + 2]) / 2})
+            else:
+                solved[index] = (name, candidate)
+                if tp is not None:
+                    entry = next(item for item in tp["placed"] if item["name"] == name)
+                    label = candidate.label_bbox
+                    entry["strip_pos"] = entry["pos"]
+                    entry["pos"] = (label[idx] + label[idx + 2]) / 2
+            if tp is not None:
+                tp.setdefault("angular_contractions", []).append(name)
+            break
     for name, dim in solved:
         # Record feature provenance (ADR 5 (was 0010)): the drain-time seam for corridor-placed
         # dims — `features` maps this batch's names to their source IR feature.