draftwright 0.5.0rc7__tar.gz → 0.5.0rc8__tar.gz

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.5.0rc7
+Version: 0.5.0rc8
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/pyproject.toml

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

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/_pmi_linear_geometry.py

@@ -14,7 +14,10 @@ _LINEAR_OBLIQUE_VALUE_ABS_TOL = 0.05
 
 
 def _linear_reference_stations(
-    stations: tuple[tuple[float, float, float] | None, ...], nominal: float
+    stations: tuple[tuple[float, float, float] | None, ...],
+    nominal: float,
+    *,
+    plane_axis: str | None = None,
 ) -> tuple[tuple[tuple[float, float, float], ...], str, tuple[str, ...]]:
     """Prove a truthful principal-axis span from the two authored reference groups.
 
@@ -35,14 +38,20 @@ def _linear_reference_stations(
     first, second = measurable
     delta = tuple(second[index] - first[index] for index in range(3))
     magnitudes = tuple(abs(value) for value in delta)
-    axis_index = max(range(3), key=magnitudes.__getitem__)
+    axis_index = (
+        "XYZ".index(plane_axis)
+        if plane_axis is not None
+        else max(range(3), key=magnitudes.__getitem__)
+    )
     primary = magnitudes[axis_index]
     if primary <= 1e-9:
         return measurable, "?", ("linear reference groups occupy the same station",)
 
     transverse = max(value for index, value in enumerate(magnitudes) if index != axis_index)
     direction_tol = max(_LINEAR_AXIS_ABS_TOL, primary * _LINEAR_AXIS_REL_TOL)
-    oblique = transverse > direction_tol
+    # Parallel planar supports establish their distance along the plane normal.
+    # Their finite face centres can be offset arbitrarily within either plane.
+    oblique = plane_axis is None and transverse > direction_tol
     if oblique and _linear_projection_view(measurable) is None:
         return (
             measurable,
@@ -69,3 +78,22 @@ def _linear_reference_stations(
             ),
         )
     return measurable, axis, ()
+
+
+def _dimension_reference_stations(
+    stations: tuple[tuple[float, float, float] | None, ...],
+    nominal: float,
+    kind: str,
+    *,
+    plane_axis: str | None = None,
+) -> tuple[tuple[tuple[float, float, float], ...], str, tuple[str, ...]]:
+    """Apply the dimension kind's wording to the shared station proof."""
+    points, axis, reasons = _linear_reference_stations(stations, nominal, plane_axis=plane_axis)
+    if kind == "thickness":
+        reasons = tuple(
+            reason.replace("linear dimension", "thickness dimension").replace(
+                "linear reference", "thickness reference"
+            )
+            for reason in reasons
+        )
+    return points, axis, reasons

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/_pmi_support_blockers.py

@@ -141,6 +141,23 @@ def _is_direct_xcaf_angular_failure(reason: str) -> bool:
     return reason.startswith(prefixes)
 
 
+def _direct_xcaf_support_is_incomplete(record) -> bool:
+    """Whether direct XCAF failed to supply all support geometry, independent of rendering."""
+    reasons = (*record.lowering_blockers, *record.rendering_blockers)
+    missing_groups = (
+        "linear dimension needs two measurable authored reference groups",
+        "thickness dimension needs two measurable authored reference groups",
+        "diameter dimension needs a measurable",
+    )
+    return any(
+        _is_direct_xcaf_reference_failure(reason)
+        or _is_direct_xcaf_diameter_failure(reason)
+        or _is_direct_xcaf_angular_failure(reason)
+        or reason.startswith(missing_groups)
+        for reason in reasons
+    )
+
+
 def _without_direct_xcaf_angular_failures(reasons: tuple[str, ...]) -> tuple[str, ...]:
     """Drop angular XCAF failures superseded by exact Part21 member supports."""
     return tuple(reason for reason in reasons if not _is_direct_xcaf_angular_failure(reason))

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/_pmi_topology.py

@@ -6,6 +6,7 @@ B-rep; geometric likeness alone cannot establish source ownership.
 
 from __future__ import annotations
 
+from draftwright._pmi_datum_geometry import _frame_vector
 from draftwright._pmi_support_blockers import _failure_reason
 
 try:
@@ -17,6 +18,83 @@ except ImportError:
     pass
 
 
+def _parallel_planar_reference_support(groups, frame, shape_bbox) -> tuple[str | None, str | None]:
+    """Find the common principal normal and any required witness view."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.GeomAbs import GeomAbs_Plane
+    from OCP.TopoDS import TopoDS
+
+    if len(groups) != 2 or not all(groups):
+        return None, None
+    axes: list[int] = []
+    group_boxes = []
+    for shapes in groups:
+        group_axis = None
+        group_station = None
+        boxes = []
+        for shape in shapes:
+            try:
+                if shape.ShapeType() != TopAbs_FACE:
+                    return None, None
+                surface = BRepAdaptor_Surface(TopoDS.Face_s(shape))
+                if surface.GetType() != GeomAbs_Plane:
+                    return None, None
+                direction = surface.Plane().Axis().Direction()
+                local = _frame_vector((direction.X(), direction.Y(), direction.Z()), frame)
+                axis_index = max(range(3), key=lambda index: abs(local[index]))
+                if abs(abs(local[axis_index]) - 1.0) > 1e-6:
+                    return None, None
+                if any(abs(local[index]) > 1e-6 for index in range(3) if index != axis_index):
+                    return None, None
+                box = shape_bbox(shape) if frame is None else shape_bbox(shape, frame)
+                boxes.append(box)
+                station = (box[axis_index] + box[axis_index + 3]) / 2
+                if box[axis_index + 3] - box[axis_index] > 1e-5:
+                    return None, None
+            except Exception:
+                return None, None
+            if group_axis is not None and group_axis != axis_index:
+                return None, None
+            if group_station is not None and abs(group_station - station) > 1e-5:
+                return None, None
+            group_axis, group_station = axis_index, station
+        assert group_axis is not None  # Each validated source group contains a face.
+        axes.append(group_axis)
+        group_boxes.append(boxes)
+    if axes[0] != axes[1]:
+        return None, None
+    return _supported_planar_view("XYZ"[axes[0]], group_boxes)
+
+
+def _supported_planar_view(axis: str, group_boxes) -> tuple[str | None, str | None]:
+    """Select only projection views whose shared witness touches both groups."""
+    if axis in {"X", "Z"}:
+        return (
+            (axis, None)
+            if _midpoint_witness_supported(group_boxes, 2 if axis == "X" else 0)
+            else (None, None)
+        )
+    side = _midpoint_witness_supported(group_boxes, 2)
+    plan = _midpoint_witness_supported(group_boxes, 0)
+    if side and plan:
+        return axis, None
+    if side or plan:
+        return axis, "side" if side else "plan"
+    return None, None
+
+
+def _midpoint_witness_supported(group_boxes, index: int) -> bool:
+    """Require a projected face in each group at the renderer's bbox midpoint."""
+    all_boxes = [box for boxes in group_boxes for box in boxes]
+    midpoint = (
+        min(box[index] for box in all_boxes) + max(box[index + 3] for box in all_boxes)
+    ) / 2
+    return all(
+        any(box[index] - 1e-6 <= midpoint <= box[index + 3] + 1e-6 for box in boxes)
+        for boxes in group_boxes
+    )
+
+
 class _DatumTopologyResolver:
     """Resolve Part21 face labels through OCCT's native transfer binders.
 

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/analysis.py

@@ -1566,6 +1566,33 @@ def _with_blind_axial_bore_support(model: PartModel, cyls) -> PartModel:
     )
 
 
+def _sizing_model_pmi_visibility(model, cyls, layout_model, pmi_mode, document_input):
+    hidden = (
+        frozenset(id(feature) for feature in document_input.source_annotations())
+        if document_input is not None and pmi_mode != "annotate"
+        else frozenset()
+    )
+    prepared = _with_blind_axial_bore_support(model, cyls)
+    enabled = layout_model is not None or pmi_mode == "annotate"
+    if (
+        prepared.pmi_annotations_enabled != enabled
+        or prepared.hidden_authored_dimension_ids != hidden
+    ):
+        prepared = replace(
+            prepared,
+            pmi_annotations_enabled=enabled,
+            hidden_authored_dimension_ids=hidden,
+        )
+    if not enabled or not any(
+        feature.kind == "authored_dimension" and id(feature) not in hidden
+        for feature in prepared.features
+    ):
+        return prepared
+    from draftwright.model.pmi_lowering import add_authored_step_positions
+
+    return add_authored_step_positions(prepared)
+
+
 def _build_sizing_model(r: _AnalysisRequest, s: _SourceState) -> _ModelState:
     text_position = r.metadata.text_position
     text_orientation = r.metadata.text_orientation
@@ -1732,7 +1759,9 @@ def _build_sizing_model(r: _AnalysisRequest, s: _SourceState) -> _ModelState:
             cyls=shared_cyls,
         )
     )
-    sizing_model = _with_blind_axial_bore_support(sizing_model, shared_cyls)
+    sizing_model = _sizing_model_pmi_visibility(
+        sizing_model, shared_cyls, layout_model, pmi_mode, _document_input
+    )
     recognition_ownership = (
         None
         if layout_model is not None

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/annotations/_step_lengths.py

@@ -425,6 +425,7 @@ def _render_single_profile(
 ) -> int:
     """Place one axial profile and request details for crowded shoulders."""
     rows: list[tuple[str, _StepChainSegment]] = []
+    has_baseline_position = False
     step_origins = []
     step_geometry = []
     for g in plan.of_kind("step"):
@@ -435,6 +436,9 @@ def _render_single_profile(
         length = g.dim(kind="length")
         if length is None or length.span is None:
             continue
+        has_baseline_position |= (
+            length.id is not None and length.id.parameter == "step_position.length"
+        )
         rows.append(
             (
                 g.facts.frame.axis,
@@ -512,6 +516,21 @@ def _render_single_profile(
         else _profile_bounds_hint
     )
 
+    if has_baseline_position:
+        # The crowded-head and repeated-run transforms describe a contiguous
+        # step chain. A datum-to-shoulder baseline has different witnesses.
+        return _draw_step_chain(
+            dwg,
+            view,
+            fsegs,
+            "m_steplen",
+            allow_collapse=False,
+            ctx=ctx,
+            start=start,
+            profile_bounds=profile_bounds,
+            placement_bounds=_profile_bounds_hint,
+        )
+
     y_result = _render_y_profile(
         dwg,
         view,

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/builder.py

@@ -723,6 +723,49 @@ def _assembly_model(a: Analysis, model, decorations, requested, authored) -> Par
                         else ()
                     ),
                 )
+    if model is not None or a.model is None:
+        pm = replace(
+            pm,
+            pmi_annotations_enabled=model is not None or a.pmi_mode == "annotate",
+            hidden_authored_dimension_ids=(
+                frozenset(id(feature) for feature in a.document_source_annotations)
+                if a.document_member and a.pmi_mode != "annotate"
+                else frozenset()
+            ),
+        )
+    # A caller may supply a PartModel that already contains raw imported PMI. That
+    # path skips the extraction/lowering branch above but still needs baseline gap
+    # identities before the compiled plan is built.
+    if any(feature.kind == "authored_dimension" for feature in pm.features):
+        from draftwright.model.pmi_lowering import add_authored_step_positions
+
+        identities = pm.declaration_identities
+        identity_by_feature = {
+            id(feature): identity
+            for feature, identity in (
+                zip(pm.features, identities, strict=True) if identities else ()
+            )
+            if identity is not None
+        }
+        step_remapped_identities: dict[int, DeclarationIdentity] = {}
+
+        def preserve_step_identity(source, replacements, _member_groups) -> None:
+            identity = identity_by_feature.get(id(source))
+            if identity is not None and replacements:
+                step_remapped_identities[id(replacements[0])] = identity
+
+        updated = add_authored_step_positions(
+            pm, feature_remap=preserve_step_identity if identities else None
+        )
+        if updated is not pm and identities:
+            updated = replace(
+                updated,
+                declaration_identities=tuple(
+                    identity_by_feature.get(id(feature), step_remapped_identities.get(id(feature)))
+                    for feature in updated.features
+                ),
+            )
+        pm = updated
     return _with_blind_axial_bore_support(pm, a.cyls)
 
 

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/drawing.py

@@ -735,6 +735,16 @@ class Drawing:
 
         return self._diagnostics().report()
 
+    def dimension_sources(self) -> list[dict[str, object]]:
+        """Placed measurements and their exact AP242 or planner provenance.
+
+        One row is returned per measured term, including each term of a compound
+        callout. This is a read-only inventory for inspection-list consumers.
+        """
+        from draftwright.reporting import placed_dimension_sources
+
+        return placed_dimension_sources(self._part_model, self._registry)
+
     def requirement_snapshot(self, *, include_lint=False):
 
         return self._diagnostics().requirement_snapshot(include_lint=include_lint)

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/linting/coverage.py

@@ -1909,18 +1909,122 @@ def _profile_projection(dwg, view: str, origin, axis: str) -> tuple[bool, float]
 
 
 def _step_length_owners(dwg, name: str) -> tuple[object, ...]:
-    """Exact step features whose compiled length claim produced annotation *name*."""
+    """Exact step features whose axial claim produced annotation *name*."""
     registry = getattr(dwg, "registry", None)
     if registry is None:
         return ()
     return tuple(
         identity.feature
         for identity in registry.measurement_of(name)
-        if getattr(identity, "parameter", None) == "step.length"
+        if getattr(identity, "parameter", None) in {"step.length", "step_position.length"}
         and getattr(identity.feature, "kind", None) == "step"
     )
 
 
+def _authored_axial_witness_on_profile(dwg, name: str, prof, origin, tol: float) -> bool:
+    """Check a source dimension's two witnesses against this profile's shoulder faces."""
+    feature = dwg.registry.feature_of(name)
+    points: tuple = tuple(getattr(feature, "ref_pts", ()))
+    if (
+        getattr(feature, "kind", None) != "authored_dimension"
+        or getattr(feature, "dimension_kind", None) != "linear"
+        or getattr(feature, "dominant_axis", None) != prof.axis.upper()
+        or len(points) != 2
+    ):
+        return False
+    axis = "xyz".index(prof.axis)
+    if abs(abs(float(points[1][axis]) - float(points[0][axis])) - float(feature.value)) > tol:
+        return False
+    transverse = tuple(index for index in range(3) if index != axis)
+    for point in points:
+        station = float(point[axis])
+        touching = [
+            step
+            for step in prof.steps
+            if abs(float(step.lo) - station) <= tol or abs(float(step.hi) - station) <= tol
+        ]
+        if not touching:
+            return False
+        radius = max(float(step.diameter) / 2 for step in touching)
+        radial = sqrt(
+            sum((float(point[index]) - float(origin[index])) ** 2 for index in transverse)
+        )
+        if radial > radius + tol:
+            return False
+    return True
+
+
+def _axial_view_dimensions(part, dwg, prof, view, base, shoulder_c, sibling_profiles, tol):
+    horizontal, own_cross = _profile_projection(dwg, view, base, prof.axis)
+    eligible = []
+    station_edges = set()
+    for name, ann in dwg.annotations_in_view(view):
+        if not isinstance(ann, Dimension):
+            continue
+        vertices = _dim_vertices(ann, dwg.registry.dimension_spec_of(name))
+        cs = {x if horizontal else y for x, y in vertices}
+        cross_coords = {y if horizontal else x for x, y in vertices}
+        owners = _step_length_owners(dwg, name)
+        if owners and not any(_feature_on_turned_axis(owner, prof) for owner in owners):
+            continue
+        authored = getattr(dwg.registry.feature_of(name), "kind", None) == "authored_dimension"
+        if authored and not _authored_axial_witness_on_profile(dwg, name, prof, base, tol):
+            continue
+        if not owners and getattr(prof, "profile", None) is not None and cross_coords:
+            dim_cross = sum(cross_coords) / len(cross_coords)
+            own_distance = abs(dim_cross - own_cross)
+            sibling_distances = [
+                abs(
+                    dim_cross
+                    - _profile_projection(
+                        dwg, view, _turned_axis_origin(part, sibling), sibling.axis
+                    )[1]
+                )
+                for sibling in sibling_profiles
+                if sibling is not prof and sibling.axis == prof.axis
+            ]
+            if any(distance <= own_distance + tol for distance in sibling_distances):
+                continue
+        eligible.append((name, str(getattr(ann, "label", "") or ""), cs))
+        if len(cs) != 2 or not (owners or authored):
+            continue
+        stations = []
+        for coordinate in sorted(cs):
+            matches = [
+                station
+                for station, projected in shoulder_c.items()
+                if abs(coordinate - projected) <= tol
+            ]
+            if len(matches) != 1:
+                break
+            stations.append(matches[0])
+        if len(stations) == 2 and stations[0] != stations[1]:
+            station_edges.add(tuple(sorted(stations)))
+    return eligible, station_edges
+
+
+def _axial_connected_steps(prof, station_edges) -> set[int]:
+    linked = {station: {station} for station in prof.shoulders}
+    for first, second in station_edges:
+        linked[first].add(second)
+        linked[second].add(first)
+    connected = set()
+    for index, step in enumerate(prof.steps):
+        start, end = float(step.lo), float(step.hi)
+        if start not in linked or end not in linked:
+            continue
+        reached = {start}
+        pending = [start]
+        while pending:
+            current = pending.pop()
+            for neighbour in linked[current] - reached:
+                reached.add(neighbour)
+                pending.append(neighbour)
+        if end in reached:
+            connected.add(index)
+    return connected
+
+
 def _axial_covered_from_drawing(
     part, dwg, prof, *, sibling_profiles=(), tol: float = 0.6
 ) -> set[int]:
@@ -1934,12 +2038,6 @@ def _axial_covered_from_drawing(
     idx = "xyz".index(prof.axis)
     base = list(_turned_axis_origin(part, prof))
 
-    def profile_cross(profile, view: str) -> float:
-        _horizontal, cross = _profile_projection(
-            dwg, view, _turned_axis_origin(part, profile), profile.axis
-        )
-        return cross
-
     def shoulder_coord(view: str, s: float, *, horizontal: bool) -> float:
         pt = list(base)
         pt[idx] = s
@@ -1952,26 +2050,14 @@ def _axial_covered_from_drawing(
     views = [view for view in _turned_profile_views(prof.axis) if view in dwg.views]
     views += sorted(v for v in dwg.views if v.startswith("detail_"))
     covered_steps: set[int] = set()
+    station_edges: set[tuple[float, float]] = set()
     for view in views:
         horizontal, _own_cross = _profile_projection(dwg, view, base, prof.axis)
         shoulder_c = {s: shoulder_coord(view, s, horizontal=horizontal) for s in prof.shoulders}
-        dims = [
-            (
-                name,
-                str(getattr(ann, "label", "") or ""),
-                {
-                    (x if horizontal else y)
-                    for x, y in _dim_vertices(ann, dwg.registry.dimension_spec_of(name))
-                },
-                {
-                    (y if horizontal else x)
-                    for x, y in _dim_vertices(ann, dwg.registry.dimension_spec_of(name))
-                },
-                _step_length_owners(dwg, name),
-            )
-            for name, ann in dwg.annotations_in_view(view)
-            if isinstance(ann, Dimension)
-        ]
+        eligible, edges = _axial_view_dimensions(
+            part, dwg, prof, view, base, shoulder_c, sibling_profiles, tol
+        )
+        station_edges.update(edges)
         for i, step in enumerate(prof.steps):
             clo, chi = shoulder_c.get(step.lo), shoulder_c.get(step.hi)
             if clo is None or chi is None:
@@ -1984,26 +2070,9 @@ def _axial_covered_from_drawing(
                 # An end-on detail projects both shoulder stations onto one
                 # point. Coincident witnesses cannot establish an axial length.
                 continue
-            for name, label, cs, cross_coords, owners in dims:
+            for name, label, cs in eligible:
                 if not cs:
                     continue
-                if owners and not any(_feature_on_turned_axis(owner, prof) for owner in owners):
-                    continue
-                # Parallel profiles can have identical axial ordinates. A dimension belongs to
-                # the nearest visible axis line in this profile view; without this gate one
-                # shaft's two witnesses would certify every sibling at the same stations.
-                if not owners and getattr(prof, "profile", None) is not None and cross_coords:
-                    dim_cross = sum(cross_coords) / len(cross_coords)
-                    own_distance = abs(dim_cross - profile_cross(prof, view))
-                    sibling_distances = [
-                        abs(dim_cross - profile_cross(sibling, view))
-                        for sibling in sibling_profiles
-                        if sibling is not prof and sibling.axis == prof.axis
-                    ]
-                    if any(distance < own_distance - tol for distance in sibling_distances) or any(
-                        abs(distance - own_distance) <= tol for distance in sibling_distances
-                    ):
-                        continue
                 # A plain dim locates the step when it has a witness at each shoulder.
                 if any(abs(v - clo) <= tol for v in cs) and any(abs(v - chi) <= tol for v in cs):
                     covered_steps.add(i)
@@ -2022,7 +2091,7 @@ def _axial_covered_from_drawing(
                 ):
                     covered_steps.add(i)
                     break
-    return covered_steps
+    return covered_steps | _axial_connected_steps(prof, station_edges)
 
 
 def _overall_axial_extent_is_dimensioned(

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/linting/turned_step_coverage.py

@@ -272,10 +272,16 @@ def physical_turned_steps(recognition: RecognitionResult) -> tuple[tuple[object,
 
 def _has_parameters(feature) -> bool:
     try:
-        return {parameter.parameter_id for parameter in feature.parameters()} == {
-            "step.length",
-            "step.diameter",
-        }
+        parameters = {parameter.parameter_id for parameter in feature.parameters()}
+        return (
+            {"step.length", "step.diameter"}
+            <= parameters
+            <= {
+                "step.length",
+                "step.diameter",
+                "step_position.length",
+            }
+        )
     except (AttributeError, TypeError):
         return False
 

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/model/callout.py

@@ -102,6 +102,8 @@ def _merge_member_pattern_batches(batches: list[HoleCalloutBatch]) -> list[HoleC
 
 def bore_callout_value(spec: dict, tolerance_suffix=lambda _value: "") -> str:
     """Format the bore value after the callout's leading diameter symbol."""
+    if spec.get("authored_diameter_label") and spec.get("tolerance") is None:
+        return str(spec["authored_diameter_label"])[1:]
     if limits := spec.get("diameter_limits"):
         lower, upper = limits
         nominal = spec["diameter"]
@@ -797,6 +799,7 @@ def hole_callout_spec(
     )
     spec = {
         "diameter": bore,
+        "authored_diameter_label": bore_pd.param.source_label if bore_pd is not None else None,
         "diameter_decimals": _display_decimals(group, "diameter", "bore"),
         "count": count if count and count > 1 else None,
         "through": hole.through,  # the feature's fact, not the param list's shape (#868)

{draftwright-0.5.0rc7 → draftwright-0.5.0rc8}/src/draftwright/model/compiled.py

@@ -65,6 +65,7 @@ from draftwright.measurement_support import coincident_location_axes
 from draftwright.model.callout import resolved_through_indicator
 from draftwright.model.ir import (
     AngularReference,
+    AuthoredDimension,
     ChamferFeature,
     CircularChannelFeature,
     EnvelopeFeature,
@@ -89,6 +90,9 @@ from draftwright.model.planner import (
     CORRELATED_SETS,
     DimensionId,
     _authored_for,
+    _authored_linear_stations,
+    _authored_location_matches,
+    _authored_same_span,
     _decorated,
     _extent_can_convey,
     _is_zero_step_position,
@@ -1212,7 +1216,9 @@ def _compile_overall_height(
         return None, None, []
     mark = marked.get((id(env), "height.length")) if env is not None else None
     if env is not None:
-        if mark is not None and mark[1] == _AUTHORED_OMISSION:
+        if mark is not None and (
+            mark[1] == _AUTHORED_OMISSION or mark[1].startswith("authored PMI dimension ")
+        ):
             return None, None, [Omission(env, "height.length", mark[0], mark[1])]
     elif model.authored_dimensions is not None:
         # No `EnvelopeFeature`, so the height falls back to the bounding box and no
@@ -2062,6 +2068,50 @@ def compile_dimensions(
     off_axis, off_axis_omissions = _compile_off_axis_hole_locations(model)
     locations.extend(off_axis)
     location_omissions.extend(off_axis_omissions)
+    # A source location may cover one directional component without covering its
+    # orthogonal sibling. Only exact witness correspondence can remove that component.
+    sources = tuple(
+        f
+        for f in model.features
+        if isinstance(f, AuthoredDimension)
+        and model.pmi_annotations_enabled
+        and id(f) not in model.hidden_authored_dimension_ids
+    )
+    if sources and model.authored_dimensions is None:
+        unique_cover: dict[int, list[AuthoredDimension]] = {}
+        for source in sources:
+            stations = _authored_linear_stations(source)
+            if stations is None:
+                continue
+            matching = [
+                location
+                for location in locations
+                if location.discriminator == "xyz"[stations[0]]
+                and location.span is not None
+                and (
+                    _authored_same_span(source, location.span, location.value)
+                    or _authored_location_matches(
+                        source, location.span, location.discriminator, location.value
+                    )
+                )
+            ]
+            if len(matching) == 1:
+                unique_cover.setdefault(id(matching[0]), []).append(source)
+        uncovered = []
+        for location in locations:
+            covering = unique_cover.get(id(location), [])
+            if len(covering) != 1 or location.id is None:
+                uncovered.append(location)
+            else:
+                location_omissions.append(
+                    Omission(
+                        location.id.feature,
+                        location.id.parameter,
+                        location.value,
+                        f"authored PMI dimension {covering[0].source_id} covers this location",
+                    )
+                )
+        locations = uncovered
     result = RenderableDimensionPlan(
         groups=tuple(groups_out),
         ladders=tuple(ladders),