draftwright 0.5.0rc7__tar.gz → 0.5.0rc9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.5.0rc7
+Version: 0.5.0rc9
 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.0rc9}/pyproject.toml

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

draftwright-0.5.0rc9/src/draftwright/_pmi_linear_geometry.py

@@ -0,0 +1,145 @@
+"""Prove authored PMI linear reference stations before dimension lowering."""
+
+from __future__ import annotations
+
+import math
+
+from draftwright._pmi_topology import (
+    _is_mixed_planar_bore,
+    _parallel_planar_reference_witness,
+    _planar_bore_axis_witness,
+)
+from draftwright.model.ir import _linear_projection_view
+
+_LINEAR_AXIS_ABS_TOL = 0.005
+_LINEAR_AXIS_REL_TOL = 1e-3
+_LINEAR_VALUE_ABS_TOL = 0.01
+_LINEAR_VALUE_REL_TOL = 5e-4
+_LINEAR_OBLIQUE_VALUE_ABS_TOL = 0.05
+
+
+def _proved_planar_linear(groups, stations, nominal, kind, frame, shape_bbox):
+    """Resolve the normal span and a face-supported projected witness together."""
+    axis, view, witness = _parallel_planar_reference_witness(groups, frame, shape_bbox)
+    if witness is None:
+        return (
+            tuple(point for point in stations if point is not None),
+            "?",
+            None,
+            ("parallel planar source faces have no proven shared witness",),
+        )
+    if axis is None and kind == "linear" and _is_mixed_planar_bore(groups):
+        bore_support = _planar_bore_axis_witness(groups, frame, shape_bbox)
+        if bore_support is None:
+            points, dominant, reasons = _dimension_reference_stations(
+                tuple(stations), nominal, kind
+            )
+            return (
+                points,
+                dominant,
+                None,
+                (
+                    *reasons,
+                    "plane-to-bore location has no proven face-supported axis witness",
+                ),
+            )
+        stations, axis, view = bore_support
+    if witness:
+        stations = tuple(
+            tuple(
+                next((value for index, value in witness if index == i), point[i]) for i in range(3)
+            )
+            if point is not None
+            else None
+            for point in stations
+        )
+    points, dominant, reasons = _dimension_reference_stations(
+        tuple(stations), nominal, kind, plane_axis=axis
+    )
+    return points, dominant, view, reasons
+
+
+def _linear_reference_stations(
+    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.
+
+    A merged bbox answers how large the referenced faces are, not which direction relates
+    them. Circular end faces in GRM-03 are wider than their axial separation, which made
+    short X dimensions render across Y. Conversely, CTC-04 includes a genuinely oblique
+    relationship and one dimension whose second group XCAF does not transfer. Those must
+    remain explicit omissions rather than being guessed from the nominal value (#1209).
+    """
+    measurable = tuple(station for station in stations if station is not None)
+    if len(stations) != 2 or len(measurable) != 2:
+        return (
+            measurable,
+            "?",
+            ("linear dimension needs two measurable authored reference groups",),
+        )
+
+    first, second = measurable
+    delta = tuple(second[index] - first[index] for index in range(3))
+    magnitudes = tuple(abs(value) for value in delta)
+    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)
+    # 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,
+            "?",
+            (
+                "linear reference relationship does not lie in a principal projection plane "
+                f"(delta=({delta[0]:.6g}, {delta[1]:.6g}, {delta[2]:.6g}) mm)",
+            ),
+        )
+
+    axis = "?" if oblique else "XYZ"[axis_index]
+    span = math.hypot(*delta) if oblique else primary
+    value_tol = max(
+        _LINEAR_OBLIQUE_VALUE_ABS_TOL if oblique else _LINEAR_VALUE_ABS_TOL,
+        abs(nominal) * _LINEAR_VALUE_REL_TOL,
+    )
+    if abs(span - nominal) > value_tol:
+        return (
+            measurable,
+            axis,
+            (
+                f"linear reference-station span {span:.6g} mm differs from nominal "
+                f"{nominal:.6g} mm",
+            ),
+        )
+    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.0rc9}/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.0rc9/src/draftwright/_pmi_topology.py

@@ -0,0 +1,481 @@
+"""Exact Part21 support resolvers for imported AP242 PMI topology.
+
+Native STEP transfer binders prove source items match the originally imported
+B-rep; geometric likeness alone cannot establish source ownership.
+"""
+
+from __future__ import annotations
+
+from draftwright._pmi_datum_geometry import _frame_point, _frame_vector
+from draftwright._pmi_support_blockers import _failure_reason
+
+try:
+    from OCP.TopAbs import TopAbs_COMPOUND, TopAbs_EDGE, TopAbs_FACE
+    from OCP.TopExp import TopExp
+    from OCP.TopTools import TopTools_IndexedMapOfShape
+except ImportError:
+    # The extractor reports unavailable OCP capability before using these resolvers.
+    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."""
+    axis, view, _witness = _parallel_planar_reference_witness(groups, frame, shape_bbox)
+    return axis, view
+
+
+def _parallel_planar_reference_witness(groups, frame, shape_bbox):
+    """Prove a view and, when its default midpoint misses, a shared face witness."""
+    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 = []
+    group_faces = []
+    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)
+        group_faces.append(shapes)
+    if axes[0] != axes[1]:
+        return None, None, ()
+    axis = "XYZ"[axes[0]]
+    if axis == "X":
+        return _principal_x_planar_witness(group_boxes, group_faces, frame)
+    view_axis, view = _supported_planar_view(axis, group_boxes)
+    return view_axis, view, ()
+
+
+def _principal_x_planar_witness(group_boxes, group_faces, frame):
+    # A front projection only needs both planes represented at the same Z;
+    # parallel face patches may be offset in Y (#2184). The plan fallback,
+    # however, claims one shared Y/Z point and must prove it on both trims.
+    if _midpoint_witness_supported(group_boxes, 2):
+        return "X", None, ()
+    common = _common_x_face_witness(group_boxes, group_faces, frame)
+    if common is not None:
+        y, z = common
+        return "X", "plan", ((1, y), (2, z))
+    return None, None, None
+
+
+def _common_x_face_witness(group_boxes, group_faces, frame):
+    """Find a point in the interiors of both exact, trimmed X faces."""
+    candidates = [
+        (
+            (min(a[4], b[4]) - max(a[1], b[1])) * (min(a[5], b[5]) - max(a[2], b[2])),
+            max(a[1], b[1]),
+            max(a[2], b[2]),
+            min(a[4], b[4]),
+            min(a[5], b[5]),
+            a,
+            b,
+            group_faces[0][i],
+            group_faces[1][j],
+        )
+        for i, a in enumerate(group_boxes[0])
+        for j, b in enumerate(group_boxes[1])
+        if min(a[4], b[4]) >= max(a[1], b[1]) and min(a[5], b[5]) >= max(a[2], b[2])
+    ]
+    for _area, y0, z0, y1, z1, a, b, first, second in sorted(
+        candidates, key=lambda item: (-item[0], item[1], item[2])
+    ):
+        # Start at the overlap centre, then sample its interior deterministically.
+        # A bounding box may contain a face hole or a concavity; only OCC's
+        # trimmed-face classifier can establish a real common witness.
+        for y_fraction, z_fraction in ((0.5, 0.5),) + tuple(
+            (i / 10, j / 10) for i in range(1, 10) for j in range(1, 10)
+        ):
+            y = y0 + (y1 - y0) * y_fraction
+            z = z0 + (z1 - z0) * z_fraction
+            if all(
+                _point_inside_x_face(face, (box[0] + box[3]) / 2, y, z, frame)
+                for face, box in ((first, a), (second, b))
+            ):
+                return y, z
+    return None
+
+
+def _point_inside_x_face(face, x, y, z, frame):
+    from OCP.BRepClass import BRepClass_FaceClassifier
+    from OCP.gp import gp_Pnt
+    from OCP.TopAbs import TopAbs_IN
+    from OCP.TopoDS import TopoDS
+
+    local = (x, y, z)
+    world = local if frame is None else frame.to_world(local)
+    classifier = BRepClass_FaceClassifier()
+    try:
+        classifier.Perform(TopoDS.Face_s(face), gp_Pnt(*world), 1e-7)
+        return classifier.State() == TopAbs_IN
+    except Exception:
+        return False
+
+
+def _planar_bore_axis_witness(groups, frame, shape_bbox):
+    """Prove a location from one principal plane to one finite Z-bore axis.
+
+    A cylindrical face's bbox centre is its axial *height*, not the location
+    station. The plane must actually contain the axis-aligned witness point;
+    a bounding-box overlap alone would invent a witness through a trimmed face.
+    """
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.BRepClass import BRepClass_FaceClassifier
+    from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane
+    from OCP.gp import gp_Pnt
+    from OCP.TopAbs import TopAbs_IN, TopAbs_ON
+    from OCP.TopoDS import TopoDS
+
+    if len(groups) != 2 or any(len(group) != 1 for group in groups):
+        return None
+    try:
+        faces = tuple(TopoDS.Face_s(group[0]) for group in groups)
+        surfaces = tuple(BRepAdaptor_Surface(face) for face in faces)
+        kinds = tuple(surface.GetType() for surface in surfaces)
+        if kinds not in ((GeomAbs_Plane, GeomAbs_Cylinder), (GeomAbs_Cylinder, GeomAbs_Plane)):
+            return None
+        plane_i = kinds.index(GeomAbs_Plane)
+        bore_i = 1 - plane_i
+        normal = surfaces[plane_i].Plane().Axis().Direction()
+        normal = _frame_vector((normal.X(), normal.Y(), normal.Z()), frame)
+        axis = max(range(3), key=lambda index: abs(normal[index]))
+        if axis not in (0, 1) or abs(abs(normal[axis]) - 1) > 1e-6:
+            return None
+        bore = surfaces[bore_i].Cylinder().Axis()
+        direction = bore.Direction()
+        direction = _frame_vector((direction.X(), direction.Y(), direction.Z()), frame)
+        if abs(abs(direction[2]) - 1) > 1e-6 or max(abs(value) for value in direction[:2]) > 1e-6:
+            return None
+        point = bore.Location()
+        centre = _frame_point((point.X(), point.Y(), point.Z()), frame)
+        boxes = tuple(
+            shape_bbox(group[0]) if frame is None else shape_bbox(group[0], frame)
+            for group in groups
+        )
+        plane_box, bore_box = boxes[plane_i], boxes[bore_i]
+        z0 = max(plane_box[2], bore_box[2])
+        z1 = min(plane_box[5], bore_box[5])
+        if z1 - z0 <= 1e-6:
+            return None
+        station = (plane_box[axis] + plane_box[axis + 3]) / 2
+        if plane_box[axis + 3] - plane_box[axis] > 1e-5:
+            return None
+        witness = list(centre)
+        witness[axis] = station
+        witness[2] = (z0 + z1) / 2
+        world = witness if frame is None else frame.to_world(tuple(witness))
+        classifier = BRepClass_FaceClassifier()
+        classifier.Perform(faces[plane_i], gp_Pnt(*world), 1e-7)
+        if classifier.State() not in (TopAbs_IN, TopAbs_ON):
+            return None
+        points = [tuple(witness), tuple(witness)]
+        bore_point = list(witness)
+        bore_point[axis] = centre[axis]
+        points[bore_i] = tuple(bore_point)
+        return tuple(points), "XYZ"[axis], "plan"
+    except Exception:
+        return None
+
+
+def _is_mixed_planar_bore(groups):
+    """Recognise the mixed support even when its location proof fails."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane
+    from OCP.TopoDS import TopoDS
+
+    if len(groups) != 2 or any(len(group) != 1 for group in groups):
+        return False
+    try:
+        kinds = tuple(BRepAdaptor_Surface(TopoDS.Face_s(group[0])).GetType() for group in groups)
+        return kinds in ((GeomAbs_Plane, GeomAbs_Cylinder), (GeomAbs_Cylinder, GeomAbs_Plane))
+    except Exception:
+        return False
+
+
+def _common_principal_cylinder_axis(references):
+    """Return a shared principal axis only when every exact cylinder proves it."""
+    axes = []
+    for reference in references:
+        vector = reference.axis_direction
+        axis = max(range(3), key=lambda index: abs(vector[index]))
+        if abs(abs(vector[axis]) - 1.0) > 1e-6 or any(
+            abs(vector[index]) > 1e-6 for index in range(3) if index != axis
+        ):
+            return ""
+        axes.append("XYZ"[axis])
+    return axes[0] if axes and len(set(axes)) == 1 else ""
+
+
+def _optional_cylinder_support(probe):
+    """Keep an optional axis probe from erasing otherwise valid source PMI."""
+    try:
+        references, reasons = probe()
+        return references if not reasons else ()
+    except Exception:
+        return ()
+
+
+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.
+
+    ``TransferOne(rank)`` stays inside C++, avoiding the OCP wrapper's loss of pointer
+    identity when a STEP entity is returned to Python.  It reuses the existing transfer
+    binder.  ``FindIndex`` then proves that result is ``IsSame`` to a face in the original
+    imported topology; no geometric comparison participates in correspondence.
+    """
+
+    _dynamic_type = "StepShape_AdvancedFace"
+    _part21_noun = "advanced face"
+    _shape_noun = "face"
+    _exclusive_claims = True
+
+    def _expected_shape_type(self):
+        return TopAbs_FACE
+
+    def __init__(self, step_reader, imported_faces):
+        self._reader = step_reader
+        self._model = step_reader.StepModel()
+        self._imported_faces = imported_faces
+        self._items: dict[str, tuple[object, int]] = {}
+        self._definitions: dict[str, tuple[object, ...]] = {}
+        self._claims: dict[int, str] = {}
+
+    def _transfer_face(self, item_id: str):
+        cached = self._items.get(item_id)
+        if cached is not None:
+            return cached, ""
+        rank = self._model.NextNumberForLabel(item_id, 0, True)
+        if rank <= 0:
+            return None, f"Part21 representation item {item_id} is unavailable"
+        entity = self._model.Value(rank)
+        if entity.DynamicType().Name() != self._dynamic_type:
+            return None, f"Part21 representation item {item_id} is not an {self._part21_noun}"
+        before = self._reader.NbShapes()
+        try:
+            transferred = self._reader.TransferOne(rank)
+        except Exception as exc:
+            return None, (
+                f"Part21 representation item {item_id} could not be transferred "
+                f"({_failure_reason(exc)})"
+            )
+        after = self._reader.NbShapes()
+        if not transferred or after != before + 1:
+            return None, f"Part21 representation item {item_id} could not be transferred"
+        shape = self._reader.Shape(after)
+        if shape is None or shape.IsNull() or shape.ShapeType() != self._expected_shape_type():
+            return None, (
+                f"Part21 representation item {item_id} did not transfer to one {self._shape_noun}"
+            )
+        face_index = self._imported_faces.FindIndex(shape)
+        if face_index <= 0:
+            return None, (
+                f"Part21 representation item {item_id} is not a {self._shape_noun} in the "
+                "imported topology"
+            )
+        result = (shape, face_index)
+        self._items[item_id] = result
+        return result, ""
+
+    def resolve(
+        self,
+        definition_id: str,
+        item_ids: tuple[str, ...],
+        *,
+        noun: str = "datum feature",
+    ):
+        """Return exact imported faces, or reasons that make the definition unsafe."""
+        cached = self._definitions.get(definition_id)
+        if cached is not None:
+            return cached, ()
+        if not item_ids:
+            return (), (f"{noun} has no Part21 representation items",)
+
+        resolved = []
+        reasons: list[str] = []
+        for item_id in item_ids:
+            result, reason = self._transfer_face(item_id)
+            if reason:
+                reasons.append(reason)
+            elif result is not None:
+                resolved.append(result)
+        if reasons:
+            return (), tuple(dict.fromkeys(reasons))
+
+        indices = [face_index for _shape, face_index in resolved]
+        if len(set(indices)) != len(indices):
+            return (), (
+                f"{noun} representation items resolve to the same imported {self._shape_noun}",
+            )
+        if self._exclusive_claims:
+            for face_index in indices:
+                owner = self._claims.get(face_index)
+                if owner is not None and owner != definition_id:
+                    reasons.append(
+                        f"one imported {self._shape_noun} is already claimed by {noun} {owner}"
+                    )
+            if reasons:
+                return (), tuple(dict.fromkeys(reasons))
+
+        shapes = tuple(shape for shape, _face_index in resolved)
+        if self._exclusive_claims:
+            for face_index in indices:
+                self._claims[face_index] = definition_id
+        self._definitions[definition_id] = shapes
+        return shapes, ()
+
+
+class _SurfaceLabelTopologyResolver(_DatumTopologyResolver):
+    """Resolve surface-label edge items through the same identity-proof boundary."""
+
+    _dynamic_type = "StepShape_EdgeCurve"
+    _part21_noun = "edge curve"
+    _shape_noun = "edge"
+    _exclusive_claims = False
+
+    def _expected_shape_type(self):
+        return TopAbs_EDGE
+
+
+class _CommonLabelTopologyResolver(_DatumTopologyResolver):
+    """Resolve common-label face items without claiming them away from other PMI."""
+
+    _exclusive_claims = False
+
+
+class _DimensionSupportResolver:
+    """Transfer exact dimension supports and prove B-rep items belong to the imported part."""
+
+    def __init__(self, step_reader):
+        self._reader = step_reader
+        self._model = step_reader.StepModel()
+        self._faces = TopTools_IndexedMapOfShape()
+        self._edges = TopTools_IndexedMapOfShape()
+        TopExp.MapShapes_s(step_reader.OneShape(), TopAbs_FACE, self._faces)
+        TopExp.MapShapes_s(step_reader.OneShape(), TopAbs_EDGE, self._edges)
+        self._items: dict[str, object] = {}
+        self._groups: dict[str, tuple[tuple[str, ...], tuple[object, ...]]] = {}
+
+    def _transfer(self, item_id: str):
+        cached = self._items.get(item_id)
+        if cached is not None:
+            return cached, ""
+        rank = self._model.NextNumberForLabel(item_id, 0, True)
+        if rank <= 0:
+            return None, f"Part21 dimension support item {item_id} is unavailable"
+        entity = self._model.Value(rank)
+        dynamic_type = entity.DynamicType().Name()
+        expected = {
+            "StepShape_AdvancedFace": (TopAbs_FACE, self._faces, "face"),
+            "StepShape_EdgeCurve": (TopAbs_EDGE, self._edges, "edge"),
+            "StepShape_GeometricCurveSet": (TopAbs_COMPOUND, None, "geometric curve set"),
+        }.get(dynamic_type)
+        if expected is None:
+            return None, (
+                f"Part21 dimension support item {item_id} has unsupported type {dynamic_type}"
+            )
+        before = self._reader.NbShapes()
+        try:
+            transferred = self._reader.TransferOne(rank)
+        except Exception as exc:
+            return None, (
+                f"Part21 dimension support item {item_id} could not be transferred "
+                f"({_failure_reason(exc)})"
+            )
+        after = self._reader.NbShapes()
+        if not transferred or after != before + 1:
+            return None, f"Part21 dimension support item {item_id} could not be transferred"
+        shape = self._reader.Shape(after)
+        expected_type, imported, noun = expected
+        if shape is None or shape.IsNull() or shape.ShapeType() != expected_type:
+            return None, f"Part21 dimension support item {item_id} did not transfer to one {noun}"
+        # Faces and edge curves are topology claims, so identity with the imported solid is
+        # mandatory. A geometric-curve-set is authored construction geometry rather than a
+        # B-rep subshape; its exact Part21 identity and successful transfer are the evidence.
+        if imported is not None and imported.FindIndex(shape) <= 0:
+            return None, f"Part21 dimension support item {item_id} is not in the imported topology"
+        self._items[item_id] = shape
+        return shape, ""
+
+    def resolve_group(self, aspect_id: str, item_ids: tuple[str, ...]):
+        cached = self._groups.get(aspect_id)
+        if cached is not None:
+            cached_item_ids, cached_shapes = cached
+            if cached_item_ids != item_ids:
+                return (), (f"dimension support group {aspect_id} has conflicting Part21 items",)
+            return cached_shapes, ()
+        if not item_ids:
+            return (), (f"dimension support group {aspect_id} has no Part21 items",)
+        shapes = []
+        reasons = []
+        for item_id in item_ids:
+            shape, reason = self._transfer(item_id)
+            if reason:
+                reasons.append(reason)
+            elif shape is not None:
+                shapes.append(shape)
+        if reasons:
+            return (), tuple(dict.fromkeys(reasons))
+        result = tuple(shapes)
+        self._groups[aspect_id] = (item_ids, result)
+        return result, ()