draftwright 0.4.20__tar.gz → 0.4.22__tar.gz

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

@@ -154,6 +154,9 @@
 
 ### Changed
 
+- Updated the exact Quiddity runtime and declared-inspection contract to 0.2.5 for the
+  provider's recognition performance improvements.
+
 - Production recognition now consumes published `quiddity==0.2.2`. Unified section-recess
   occurrences and their same-run patterns feed the existing pocket, channel and blind-slot
   drawing grammar. Original occurrence ownership, independent completeness and explicit

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.20
+Version: 0.4.22
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -690,7 +690,7 @@ Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
 Requires-Dist: numpy>=1.24
 Requires-Dist: pillow>=10
 Requires-Dist: pypdfium2>=4
-Requires-Dist: quiddity==0.2.2
+Requires-Dist: quiddity==0.2.5
 Requires-Dist: reportlab>=4.0
 Requires-Dist: steputils==0.1
 Requires-Dist: svglib>=1.5

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

@@ -70,10 +70,11 @@ 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.2 runtime contract
+### Quiddity 0.2.5 runtime contract
 
-[#1471](https://github.com/pzfreo/draftwright/issues/1471) moves production recognition to the
-published `quiddity==0.2.2` package. Its public `quiddity`, `quiddity.evidence` and
+The runtime pins the published `quiddity==0.2.5` 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
 reads. There is one recognition aggregate per build; consumers project that result rather than
 calling the document builder to obtain another run.
@@ -87,8 +88,10 @@ builder is a serialization front door, not another feature family or a productio
 
 The shared adapter reads the published frame, profile, run interval and ends and lowers supported
 principal-axis geometry to the existing pocket, channel and blind-slot IR. It preserves the opening
-direction and edge anchoring and rejects malformed records. Unsupported profiles and sloped ends
-remain explicit unsupported outcomes; they receive no invented dimensions. Pattern members resolve
+direction and edge anchoring and rejects malformed records. Supported rounded rectangular pockets
+retain their corner radius, and supported cylindrical-mouth pockets carry maximum-depth intent
+rather than an invented uniform depth. Valid profiles and end shapes outside the drafting grammar
+remain explicit unsupported outcomes, including the two-plane passage cases. Pattern members resolve
 to the original records in the same aggregate before they share a drawing owner. Missing members,
 duplicate indices, cross-body grouping and inconsistent lattice geometry fail closed.
 
@@ -98,20 +101,24 @@ Recognition refusals retain source provenance and contribute an unsupported outc
 fabricated position. Report and inspection schema v2 name `producer.quiddity`; their v1 schemas
 remain available for existing documents.
 
-The 0.4.20 release includes these known Quiddity 0.2.2 limitations:
-
-- Some mixed line/arc and nested pockets, including the tuner-jig and dense #915 STEP fixtures,
-  are refused: [Quiddity #536](https://github.com/pzfreo/quiddity/issues/536).
-- Bores intersecting channel walls, floors or an edge-open recess can prevent recognition:
-  [Quiddity #538](https://github.com/pzfreo/quiddity/issues/538).
-- A pocket cut into cylindrical stock can be refused:
-  [Quiddity #541](https://github.com/pzfreo/quiddity/issues/541).
-
-These cases can lose automatic annotations that the previous provider emitted. Check recognition
-refusals and lint when using affected geometry. An explicit refusal makes the limitation visible;
-it does not establish drawing completeness. The regression cases remain in the suite as strict
-expected failures linked to the upstream issues. Other recognition, declaration, placement,
-reporting and coverage checks remain release gates.
+The common-part restoration checks the five rounded tuner-jig pockets and their grouped callout,
+corner radii, pitch and absolute locations; pockets cut into cylindrical stock; and the pierced
+U-channel's supported channel measurements. Automatic recognition, declared input and executed
+Sheet scripts retain the supported recess facts. These checks do not turn a successfully rendered
+part into a completeness guarantee.
+
+The preceding Draftwright 0.4.20 / Quiddity 0.2.2 release documented annotation losses for mixed
+and nested pockets ([Quiddity #536](https://github.com/pzfreo/quiddity/issues/536)), bore-intersected
+or edge-open recesses ([#538](https://github.com/pzfreo/quiddity/issues/538)), and pockets in
+cylindrical stock ([#541](https://github.com/pzfreo/quiddity/issues/541)). Those historical limitations
+must not be used to excuse the common cases restored in #1486. Conversely, recognising more source
+profiles does not imply that every profile now has a supported drafting grammar. General complex
+pockets and nonuniform passages can still produce explicit unsupported requirements.
+
+Check the source occurrence outcomes, placed requirements and lint for affected geometry.
+Regression expectations are reassessed per fixture: a restored supported case must pass, while an
+unsupported case must retain its truthful diagnostic rather than an approximate old annotation.
+Recognition, declaration, placement, reporting and coverage checks remain release gates.
 
 `bosses` remains a fully consumed reference family. `repeating-radial-profiles` remains geometry-only
 critique evidence for a separately authored gear declaration, with no inferred gear feature.

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

@@ -37,6 +37,26 @@ or side override. Invalid references, unsupported controls and unsupported place
 separate structured refusal codes in `validate_dimension()`; `dimension_options()` raises on an
 invalid reference.
 
+Hole-size callouts in the plan and side views accept `left` or `right`. The overall
+envelope height accepts `left` or `right` in the front view. These hints can separate
+hole sizes from vertical location dimensions without moving annotation coordinates:
+
+```python
+sheet.dimension(lower_hole, "bore.diameter", side="left")
+sheet.dimension(upper_hole, "bore.diameter", side="left")
+sheet.dimension(envelope, "height.length", side="left")
+sheet.dimension(lower_hole, "location")
+sheet.dimension(upper_hole, "location")
+```
+
+Each side belongs to its named view: the front-view height and side-view hole sizes
+occupy different boundaries. The layout reserves space for the left height and short
+step rises together before choosing scale and page. The shared solver places the
+annotations within those boundaries; generated scripts retain the authored sides.
+An explicit side is a constraint: an infeasible placement reports the affected
+measurement instead of silently choosing the opposite boundary. Repair preserves an
+authored overall-height side, including after a label adjustment.
+
 The explicit `single_dimension_placement_rules` scope means `supported` reports acceptance by
 the current planner placement rules. Both documents set `requires_build_validation: true`:
 whole-part classification can select a different renderer, so this query does not prove actual
@@ -47,8 +67,83 @@ 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.
 
+## Selecting a hole location component
+
+Use `location` alone to request the usual location set. To select one component of a hole
+group or pattern, pair its declared member index with the measured world axis:
+
+```python
+options = sheet.dimension_options(holes, "location")
+print(options["location_components"])  # valid member/axis pairs and their parameter ids
+sheet.dimension(holes, "location", member=1, axis="y")
+```
+
+Member indices start at zero and refer to the declared `members` tuple. A singleton hole
+has member 0. The axis is transverse to the hole's own axis: an X-directed hole can have
+Y and Z location dimensions. A bolt-circle pattern also accepts `member="centre"`.
+Both selectors are required for a fine request; invalid members or axes are refused.
+The existing `validate_dimension()` query accepts the same selectors.
+
+The coarse pattern request keeps its automatic anchor policy: the member nearest the
+datum, or the centre of a bolt circle. Adding a fine request selects that extra component
+without selecting its sibling axis. Repeating a request does not duplicate a measurement.
+Generated scripts carry the member and axis so removing one location declaration omits
+that component. Coincident dimensions can share one mark while recording every approved
+owner.
+
+These indices address one declaration and its generated script. They do not establish
+correspondence across unrelated recognition runs. The shared solver still chooses where
+to place the dimension; location selection supplies no page coordinates.
+
 ## Sheet
 
+### Comparing measurements after a declaration edit
+
+`compare_measurements()` compares named compiled measurements, including their owner,
+parameter, nominal value, tolerance, directional span and rendered claim text. Linear
+dimensions also retain their measured path lengths in model units, so exchanging labels
+between two spans cannot hide behind an unchanged label multiset. Recorded per-annotation
+spans and location components also distinguish equal-valued axes under a coarse parameter
+id. These are provenance claims; independent lint must still check physical targets.
+Reuse the feature objects in a declaration when editing placement intent:
+
+```python
+from dataclasses import replace
+from draftwright import build_drawing
+from draftwright.audit import compare_measurements
+
+original_model = sheet.model()
+edited_model = replace(
+    original_model,
+    authored_dimensions=tuple(
+        replace(request, side="left") if request.role == "height.length" else request
+        for request in original_model.authored_dimensions
+    ),
+)
+before = build_drawing(part, model=original_model)
+after = build_drawing(part, model=edited_model)
+result = compare_measurements(before, after)
+print(result["status"], result["lost"], result["changed"], result["unknown"])
+```
+
+The status is `preserved`, `changed` or `unknown`. An unresolved owner or unconfirmed
+claim prevents `preserved`. For an in-place edit, capture
+`before = drawing.measurement_snapshot()` before changing the drawing, then compare
+that snapshot with the edited drawing. Snapshots retain process-local feature references.
+
+Separately rebuilt declarations do not acquire correspondence from equal geometry or
+inventory order. If the caller knows the correspondence, pass
+`feature_pairs=((old_feature, new_feature), ...)`. Each pair must name exact owners in
+the respective snapshots and the correspondence must be one-to-one. These are caller
+assertions; the comparison checks measurement meaning under them. Output owner numbers
+are positions in the before snapshot for presentation, not durable identities.
+
+`diff_builds()` includes this result as `measurement_comparison` and detects same-kind
+substitutions between shared declared owners. A clear annotation diff can still have
+unknown measurement correspondence. Use independent `lint_summary()["quality"]`
+evidence alongside the comparison: named-measurement preservation does not establish
+physical completeness, pin preservation or release readiness.
+
 ::: draftwright.sheet.Sheet
     options:
       filters: public

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.20"
+version = "0.4.22"
 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.2",
-    "quiddity==0.2.2",
+    "quiddity==0.2.5",
     "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
@@ -81,13 +81,15 @@ include = [
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 timeout = 300
-# `slow` covers the heavy end-to-end builds over the large NIST CTC fixtures
+# `slow` covers end-to-end integration builds, including the large NIST CTC fixtures
 # (minutes each), deselected by default. `smoke` is a curated, build-light subset
 # (~30 s) for a quick local "did I break something obvious" check — run it with
 # `uv run pytest -m smoke`. The default run is the full fast tier (`-m 'not slow'`,
-# ~8 min); CI owns that plus the slow tier across the OS/Python matrix.
+# runtime depends on worker count). CI runs one real-part canary before merge,
+# the full slow tier after merge, and the fast tier across its compatibility matrix.
 markers = [
-    "slow: heavy end-to-end CTC fixture builds (deselected by default)",
+    "slow: end-to-end integration builds, including CTC fixtures (deselected by default)",
+    "real_part_canary: bounded real STEP semantic/export gate, selected once in PR CI",
     "smoke: curated build-light subset for a fast local check (~30 s)",
     "unit: pure-logic inner-loop tier — constructs NO OCC geometry (enforced by conftest, #656)",
 ]
@@ -165,11 +167,14 @@ dev = [
     "jsonschema>=4,<5",
     "mypy>=2.1.0",
     "pytest>=8",
+    # `coverage` is invoked directly by the CI `coverage-report` job (combine/xml/html/
+    # report); it arrives transitively via pytest-cov, but the job depends on the console
+    # script, so declare it.
+    "coverage>=7",
     "pytest-cov>=5",
     "pytest-split>=0.8",
     "pytest-timeout>=2",
     "pytest-xdist>=3",
-    # Released provider used by the migration parity tests; production remains on 0.4.14.
     "ruff>=0.4",
     "tomli>=2; python_version < '3.11'",
 ]

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

@@ -18,7 +18,7 @@ from dataclasses import dataclass
 from decimal import Decimal
 from inspect import signature
 
-from build123d import Compound, GeomType, Shape
+from build123d import Compound, Edge, GeomType, Shape, Vector
 from quiddity import full_cylinders
 
 _log = logging.getLogger(__name__)
@@ -1229,3 +1229,24 @@ def _blend_profile_arcs(faces, radius):
         for edge in face.edges()
         if edge.geom_type != GeomType.LINE
     )
+
+
+def _projected_edge_distance(edge, tip, project):
+    """Distance from a page point's projection line to the actual trimmed OCC edge."""
+    origin = project(0, 0, 0)
+    basis = [project(*(1 if i == j else 0 for i in range(3))) for j in range(3)]
+    u = Vector(*(point[0] - origin[0] for point in basis))
+    v = Vector(*(point[1] - origin[1] for point in basis))
+    normal = u.cross(v).normalized()
+    centre = edge.center()
+    projected = project(*centre)
+    point = (
+        centre
+        + u * ((tip[0] - projected[0]) / u.dot(u))
+        + v * ((tip[1] - projected[1]) / v.dot(v))
+    )
+    # Curve length bounds the distance from its centre to any point on it and
+    # avoids recomputing physical bounding boxes on every repeated lint call.
+    reach = edge.length + 1
+    line = Edge.make_line(point - normal * reach, point + normal * reach)
+    return edge.distance_to(line)

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

@@ -46,6 +46,8 @@ from draftwright.linting.structural import (
     _centerline_extent,
 )
 from draftwright.model.compiled import resolve_feature
+from draftwright.model.ir import HoleFeature, PatternFeature
+from draftwright.model.planner import hole_location_parameter_id
 
 _log = logging.getLogger(__name__)
 
@@ -67,14 +69,21 @@ def _with_hole_location_coverage(annotation, coverage):
 def _hole_location_coverage_fact(location):
     """The directional physical fact rendered by one compiled hole location member.
 
-    ``location.id`` remains ADR 4 (was 0016)'s feature-level addressable ``DimensionId``. The
-    requirement parameter is deliberately separate: critique can distinguish X from Y
-    without resolving #883's open public naming decision or minting a general identity.
+    The physical requirement vocabulary is independent of the public member address.
+    Its point identifies the physical member; the compiler's declaration-local index
+    must not replace that independent evidence.
     """
     feature = resolve_feature(location.ref)
     if feature is None and location.id is not None:
         feature = location.id.feature
     assert feature is not None and location.span is not None
+    if isinstance(feature, HoleFeature | PatternFeature):
+        parameter = (
+            f"{location.role}.{location.discriminator}"
+            if isinstance(feature, HoleFeature) and location.axis != "z"
+            else f"{location.role}.location.{location.discriminator}"
+        )
+        return (feature, parameter, tuple(location.span[1]))
     parameter = location.id.parameter if location.id is not None else location.parameter_id
     if (
         parameter
@@ -189,6 +198,16 @@ def _annotation_hole_features(registry, name, annotation) -> frozenset:
     return frozenset(features)
 
 
+def _table_location_parameters(feature) -> set[str]:
+    if not isinstance(feature, HoleFeature) or feature.frame.axis != "z":
+        return set()
+    return {
+        hole_location_parameter_id(feature, member, axis)
+        for member in range(len(feature.members or (feature.frame.origin,)))
+        for axis in ("x", "y")
+    }
+
+
 def _hole_table_replaceable_annotation(registry, name, annotation) -> bool:
     """Whether a table can replace *all* semantic facts carried by an annotation.
 
@@ -214,6 +233,8 @@ def _hole_table_replaceable_annotation(registry, name, annotation) -> bool:
         "location.location",
         "location_pattern.location",
     }
+    for feature in features:
+        table_parameters.update(_table_location_parameters(feature))
     return all(
         getattr(measurement, "parameter", None) in table_parameters
         for measurement in registry.measurement_of(name)
@@ -233,6 +254,8 @@ def _hole_table_replaceable_location_annotation(registry, name, annotation) -> b
     measurements = tuple(registry.measurement_of(name))
     return bool(measurements) and all(
         getattr(measurement, "parameter", None) == "location.location"
+        or getattr(measurement, "parameter", None)
+        in _table_location_parameters(getattr(measurement, "feature", None))
         for measurement in measurements
     )
 

{draftwright-0.4.20 → draftwright-0.4.22}/src/draftwright/annotations/from_model.py

@@ -875,6 +875,8 @@ def render_locations(dwg, plan, a, *, ctx, only=None, pinned=None) -> int:
     PX, PY = a.proj.plan_x, a.proj.plan_y
     x_refs: list = []
     for r in refs:
+        if r[4] not in (None, "x"):
+            continue
         for u in x_refs:
             if _same_location_ordinate(r[0], u[0]):
                 u[3] = u[3] or r[2] in pinned_set
@@ -932,7 +934,10 @@ def render_locations(dwg, plan, a, *, ctx, only=None, pinned=None) -> int:
         # A single X-location dim shared by two *distinct* features at this X belongs to
         # neither exclusively — leave it unowned so drop() cannot over-strip a sibling's
         # dimension and annotations_of never over-claims it (review #406, ADR 5 (was 0010)).
-        _shared_x = any(_same_location_ordinate(o[0], rx) and o[2] != feat for o in refs)
+        _shared_x = any(
+            o[4] in (None, "x") and _same_location_ordinate(o[0], rx) and o[2] != feat
+            for o in refs
+        )
         _xfeat = None if _shared_x else feat
         # The measurement does NOT follow the feature (#1002 r4). Feature-unowned is an
         # ADR 5 (was 0010) *ownership* rule — it stops drop(feature) stripping a sibling's dim. It
@@ -995,6 +1000,8 @@ def render_locations(dwg, plan, a, *, ctx, only=None, pinned=None) -> int:
     iso_x0, iso_y0, _, _ = _iso_bbox(dwg)
     y_refs: list = []
     for r in refs:
+        if r[4] not in (None, "y"):
+            continue
         for u in y_refs:
             if _same_location_ordinate(r[1], u[1]):
                 u[3] = u[3] or r[2] in pinned_set
@@ -1053,7 +1060,10 @@ def render_locations(dwg, plan, a, *, ctx, only=None, pinned=None) -> int:
             continue
         n += 1
         # Shared-Y location dim → unowned (see the X loop; review #406).
-        _shared_y = any(_same_location_ordinate(o[1], ry) and o[2] != feat for o in refs)
+        _shared_y = any(
+            o[4] in (None, "y") and _same_location_ordinate(o[1], ry) and o[2] != feat
+            for o in refs
+        )
         _yfeat = None if _shared_y else feat
         # Every collapsed feature-level location; the structured facts carry Y (see X above).
         _ymid = tuple(mids)
@@ -2580,7 +2590,7 @@ def _render_radius_callouts(
         # Group by what the drawing will actually print. Authored Blend radii can carry
         # more precision than provider geometry, and two distinct display values must
         # never share one n× label while receiving separate measurement credit (#1433).
-        collapse.setdefault(pd.value_text, []).append((g, pd))
+        collapse.setdefault((pd.value_text, _tol_suffix(pd.tolerance, draft)), []).append((g, pd))
     jobs = []
     ordered_groups = sorted(
         collapse.items(),
@@ -3105,7 +3115,9 @@ def _ray_exit_dist(px, py, ux, uy, rect) -> float:
     return max(min([t for t in ts if t > 0], default=0.0), 0.0)
 
 
-def _pocket_label(width_text, length_text, depth_text, wsfx="", lsfx="", dsfx="") -> str:
+def _pocket_label(
+    width_text, length_text, depth_text, wsfx="", lsfx="", dsfx="", *, maximum_depth=False
+) -> str:
     """The pocket callout string: ``{width} × {length} × {depth} DEEP`` (#148a). The values
     are the PLANNED ones (``pd.param.value``, #728); *wsfx*/*lsfx*/*dsfx* are each value's
     pre-formatted tolerance suffix, interleaved so a tolerance rides its own number. (All
@@ -3115,7 +3127,20 @@ def _pocket_label(width_text, length_text, depth_text, wsfx="", lsfx="", dsfx=""
     helper's hole callouts, not as font text — a plain :class:`Leader` label has no access
     to it, so this uses the font-safe ``DEEP`` word (the vendored Plex Mono lacks ↧).
     Formatting lives in the render layer (ADR 3 (was 0013 §7))."""
-    return f"{width_text}{wsfx} × {length_text}{lsfx} × {depth_text}{dsfx} DEEP"
+    depth_word = "MAX DEEP" if maximum_depth else "DEEP"
+    if all(value is not None for value in (width_text, length_text, depth_text)):
+        label = f"{width_text}{wsfx} × {length_text}{lsfx} × {depth_text}{dsfx} {depth_word}"
+    else:
+        label = "POCKET " + ", ".join(
+            f"{value}{suffix} {role}"
+            for value, suffix, role in (
+                (width_text, wsfx, "WIDE"),
+                (length_text, lsfx, "LONG"),
+                (depth_text, dsfx, depth_word),
+            )
+            if value is not None
+        )
+    return label
 
 
 def _rectangular_blind_slot_label(
@@ -3549,8 +3574,9 @@ def render_pockets(dwg, plan, a, *, ctx, only=None) -> int:
         by_key = {(pd.role, pd.kind): pd for pd in g.dims}
         wpd = by_key.get(("pocket_width", "length"))
         lpd = by_key.get(("pocket_length", "length"))
-        dpd = by_key.get(("pocket_depth", "length"))
-        if wpd is None or lpd is None or dpd is None:
+        dpd = by_key.get(("pocket_depth", "length")) or by_key.get(("pocket_max_depth", "length"))
+        dimensions = tuple(d for d in (wpd, lpd, dpd) if d is not None)
+        if not dimensions:
             continue
         view = view_of.get(pk.depth_axis)
         if view is None:
@@ -3564,12 +3590,13 @@ def render_pockets(dwg, plan, a, *, ctx, only=None) -> int:
                 view,
                 vb,
                 _pocket_label(
-                    wpd.value_text,
-                    lpd.value_text,
-                    dpd.value_text,
-                    wsfx=_tol_suffix(wpd.tolerance, draft),
-                    lsfx=_tol_suffix(lpd.tolerance, draft),
-                    dsfx=_tol_suffix(dpd.tolerance, draft),
+                    wpd.value_text if wpd is not None else None,
+                    lpd.value_text if lpd is not None else None,
+                    dpd.value_text if dpd is not None else None,
+                    wsfx=_tol_suffix(wpd.tolerance, draft) if wpd is not None else "",
+                    lsfx=_tol_suffix(lpd.tolerance, draft) if lpd is not None else "",
+                    maximum_depth=dpd is not None and dpd.role == "pocket_max_depth",
+                    dsfx=_tol_suffix(dpd.tolerance, draft) if dpd is not None else "",
                 ),
                 _radial_candidates(
                     dwg,
@@ -3585,10 +3612,12 @@ def render_pockets(dwg, plan, a, *, ctx, only=None) -> int:
                         width_axis=pk.width_axis,
                         length=lpd.value,
                         width=wpd.value,
-                    ),
+                    )
+                    if wpd is not None and lpd is not None
+                    else None,
                     provenance=g.ref,
                 ),
-                (wpd.id, lpd.id, dpd.id),  # width × length × depth, one callout (#1002)
+                tuple(d.id for d in dimensions),
             )
         )
     return place_machined_leader_jobs(
@@ -5811,9 +5840,9 @@ def ladder_plan_for(plan, *, step_height: bool, overall: bool):
 
 
 def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) -> int:
-    """Front-view right ladder: prismatic step heights stacked inner→outer, then the overall
-    height outermost — registered as :class:`CorridorCandidate`s in the shared
-    ``(front, right)`` corridor (#636). The leapfrog witness cursor (#237) survives as a
+    """Front-view ladder: prismatic step heights stacked inner→outer, then the overall
+    height outermost. The overall height can be authored on the left; candidates enter
+    the shared corridor for their side. The leapfrog witness cursor (#237) survives as a
     *build-time chain*: candidates share a ``solved`` position map, and each dim's witness
     anchors on its nearest already-built predecessor's line (the view edge for the first).
 
@@ -5850,8 +5879,6 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
             frame.project("front", entry.span[1])[1],
         )
 
-    strip = frame.fv_zones.right
-
     rung_set = plan.ladder("step_height")
     rungs = list(rung_set.rungs) if rung_set is not None else []
     # An OPAQUE handle, passed straight through to the corridor candidate and the
@@ -6003,6 +6030,12 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
     _tolerances = {c[0]: c[8] for c in chain}
 
     names = [c[0] for c in chain]
+    sides = {
+        name: (overall.rungs[0].side or "right")
+        if name == "dim_height" and overall is not None
+        else "right"
+        for name in names
+    }
     solved: dict[str, float] = {}
     for k, (
         name,
@@ -6016,6 +6049,21 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
         _rt,
         measurement_span,
     ) in enumerate(chain):
+        side = sides[name]
+        direction = 1 if side == "right" else -1
+        edge = edge2 if side == "right" else _left - 2
+        strip = frame.fv_zones.right if side == "right" else frame.fv_zones.left
+        predecessors = [pn for pn in names[:k] if sides[pn] == side]
+
+        def _witness_base(pos, predecessors=predecessors, direction=direction, edge=edge):
+            base = edge
+            for pn in reversed(predecessors):
+                if pn in solved:
+                    base = solved[pn]
+                    break
+            # A retry can revisit the inner position after a predecessor was built.
+            # Prediction and rendering must use the same non-degenerate witness.
+            return edge if direction * (pos - base) < 0.5 else base
 
         def _build(
             pos,
@@ -6023,22 +6071,23 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
             zbase=zbase,
             ztop=ztop,
             label=label,
-            k=k,
+            witness_base=_witness_base,
+            side=side,
+            direction=direction,
+            authored_side=overall.rungs[0].side
+            if name == "dim_height" and overall is not None
+            else None,
             per_unit=per_unit,
             _tol=_tolerances.get(name),
             measurement_span=measurement_span,
         ):
-            base = edge2
-            for pn in reversed(names[:k]):  # nearest already-built predecessor's line
-                if pn in solved:
-                    base = solved[pn]
-                    break
+            base = witness_base(pos)
             solved[name] = pos
             dim = _dim(
                 (base, zbase, 0),
                 (base, ztop, 0),
-                "right",
-                pos - base,
+                side,
+                direction * (pos - base),
                 draft,
                 label=label + _tol_suffix(_tol, draft),
             )
@@ -6049,6 +6098,8 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
                 # step, while a hole pitch spans the whole run. Same seam as `_dw_scale`.
                 dim._dw_label_value = per_unit
             dim._dw_measurement_span = measurement_span
+            if authored_side is not None:
+                dim._dw_authored_side = authored_side
             return dim
 
         # The footprint measures the RENDERED string, so it carries the same suffix the
@@ -6059,25 +6110,22 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
             zbase=zbase,
             ztop=ztop,
             label=label + _tol_suffix(_tolerances.get(name), draft),
-            k=k,
+            witness_base=_witness_base,
+            side=side,
+            direction=direction,
         ):
             # Predecessor-aware prediction (#689 review): the conservative edge-anchored
             # witness can falsely exhaust the strip when an inner obstacle sits in the
-            # already-traversed region. Use the same solved map the build chain uses.
-            base = edge2
-            for pn in reversed(names[:k]):
-                if pn in solved:
-                    base = solved[pn]
-                    break
-            if pos - base < 0.5:  # degenerate guard: never model a zero-length offset
-                base = edge2
+            # already-traversed region. Use the build chain's witness calculation.
+            base = witness_base(pos)
             return dim_footprint(
-                (base, zbase, 0), (base, ztop, 0), "right", pos - base, draft, label
+                (base, zbase, 0), (base, ztop, 0), side, direction * (pos - base), draft, label
             )
 
         def _drop(
             nm,
-            drop_msg=drop_msg,
+            drop_msg=drop_msg.replace("right strip", f"{side} strip"),
+            strip=strip,
             name=name,
             measurement=mid,
             measurement_span=measurement_span,
@@ -6097,7 +6145,7 @@ def render_height_ladder(dwg, plan, frame, *, ctx, detail_view: bool = False) ->
 
         register_corridor(
             ctx,
-            ("front", "right"),
+            ("front", side),
             strip,
             "front",
             "x",