solidworks-mcp-python 1.5.0__py3-none-any.whl

solidworks_mcp/adapters/mock_adapter.py

@@ -0,0 +1,4016 @@
+"""Mock SolidWorks adapter for testing and development.
+
+This adapter simulates SolidWorks operations for testing on non-Windows platforms or
+when SolidWorks is not available.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import math
+import os
+import random
+import uuid
+from collections.abc import Callable
+from datetime import datetime
+from typing import Any
+
+from ..exceptions import SolidWorksOperationError
+from .base import (
+    AdapterHealth,
+    AdapterResult,
+    AdapterResultStatus,
+    ExtrusionParameters,
+    LoftParameters,
+    MassProperties,
+    RevolveParameters,
+    SolidWorksAdapter,
+    SolidWorksFeature,
+    SolidWorksModel,
+    SweepParameters,
+)
+from .solidworks.drawing_standard import gtol_problem
+from .solidworks.features import _AXIS_PLANE_PAIRS
+from .solidworks.io import _normalise_unit_system as _normalise_mock_unit_system
+from .solidworks.sketch import RELATION_NAME_MAP
+
+#: Orientations the mock accepts for a drawing view. Kept in step with
+#: ``_NAMED_VIEWS`` in ``adapters/solidworks/io.py`` by a test — the two lists
+#: are maintained separately, and an orientation accepted live but rejected
+#: here could never be covered, since the suite runs against the mock.
+_MOCK_NAMED_VIEWS: frozenset[str] = frozenset(
+    {
+        "front",
+        "back",
+        "left",
+        "right",
+        "top",
+        "bottom",
+        "isometric",
+        "iso",
+        "trimetric",
+        "dimetric",
+        "current",
+    }
+)
+
+
+#: Canned assembly component tree used by ``list_features`` when a mock
+#: Assembly's ``_assembly_components`` hasn't been configured by a test.
+#: Two top-level Part components plus one nested sub-assembly one level
+#: deep, per ``docs/agents`` / OpenSpec change ``assembly-aware-list-features``.
+_DEFAULT_ASSEMBLY_COMPONENTS: dict[str, dict[str, Any]] = {
+    "PartA": {
+        "type": "Part",
+        "path": "Mock://PartA.sldprt",
+        "features": [
+            {"name": "Boss-Extrude1", "type": "Extrusion", "suppressed": False},
+            {"name": "Fillet1", "type": "Fillet", "suppressed": False},
+        ],
+    },
+    "PartB": {
+        "type": "Part",
+        "path": "Mock://PartB.sldprt",
+        "features": [
+            {"name": "Cut-Extrude1", "type": "Cut", "suppressed": False},
+        ],
+    },
+    "SubAssembly1": {
+        "type": "Assembly",
+        "path": "Mock://SubAssembly1.sldasm",
+        "features": [
+            {"name": "Mate1", "type": "Mate", "suppressed": False},
+        ],
+        "components": {
+            "PartC": {
+                "type": "Part",
+                "path": "Mock://PartC.sldprt",
+                "features": [
+                    {"name": "Boss-Extrude1", "type": "Extrusion", "suppressed": False},
+                ],
+            },
+        },
+    },
+}
+
+
+class _BoolCallable:
+    """Compatibility shim that behaves as both bool and callable.
+
+    Args:
+        getter (Callable[[], bool]): The getter value.
+
+    Attributes:
+        _getter (Any): The getter value.
+    """
+
+    def __init__(self, getter: Callable[[], bool]) -> None:
+        """Initialize the bool callable.
+
+        Args:
+            getter (Callable[[], bool]): The getter value.
+
+        Returns:
+            None: None.
+        """
+        self._getter = getter
+
+    def __call__(self) -> bool:
+        """Build internal call.
+
+        Returns:
+            bool: True if call, otherwise False.
+        """
+        return bool(self._getter())
+
+    def __bool__(self) -> bool:
+        """Build internal bool.
+
+        Returns:
+            bool: True if bool, otherwise False.
+        """
+        return bool(self._getter())
+
+
+class MockSolidWorksAdapter(SolidWorksAdapter):
+    """Mock adapter that simulates SolidWorks operations.
+
+    Args:
+        config (object | None): Configuration values for the operation. Defaults to None.
+
+    Attributes:
+        _connected (Any): The connected value.
+        _delays (Any): The delays value.
+        _is_connected_proxy (Any): The is connected proxy value.
+        _operation_count (Any): The operation count value.
+        _simulate_errors (Any): The simulate errors value.
+    """
+
+    @property
+    def _current_model(self) -> SolidWorksModel | None:
+        """The active mock document."""
+        return self.__dict__.get("_active_model")
+
+    @_current_model.setter
+    def _current_model(self, model: SolidWorksModel | None) -> None:
+        # Switching documents drops the selection, as in real SolidWorks:
+        # edges selected on one part must never feed an empty-edge_names
+        # fillet/chamfer on another.
+        if model is not self.__dict__.get("_active_model"):
+            self.__dict__.get("_selection", []).clear()
+        self.__dict__["_active_model"] = model
+
+    def __init__(self, config: object | None = None) -> None:
+        """Initialize the mock solid works adapter.
+
+        Args:
+            config (object | None): Configuration values for the operation. Defaults to None.
+
+        Returns:
+            None: None.
+        """
+        super().__init__(config)
+        cfg: dict[str, Any] = dict(self.config_dict)
+        self._connected = False
+        self._current_model = None
+        self._models: dict[str, SolidWorksModel] = {}
+        self._features: dict[str, SolidWorksFeature] = {}
+        # Names suppressed via suppress_feature. Kept beside _features rather
+        # than on SolidWorksFeature, which has no suppression field.
+        self._suppressed_features: set[str] = set()
+        # Component tree for an Assembly-type current model, keyed by
+        # component name. See ``_flatten_assembly_components`` for shape.
+        # Empty means "use the canned default fixture" (see list_features).
+        self._assembly_components: dict[str, dict[str, Any]] = {}
+        self._sketches: dict[str, str] = {}
+        self._current_sketch: str | None = None
+        # Names currently "selected" via select_feature / select_face_edges,
+        # so append and selection_count behave like the real selection set.
+        self._selection: list[str] = []
+        # Test hook: RawRebuildIssue objects rebuild_model should report, so
+        # the error/warning paths can be exercised without real geometry.
+        self.injected_rebuild_issues: list[Any] = []
+        # Tracks IDs returned by add_line/add_arc/add_circle/add_centerline/
+        # add_rectangle/add_spline so add_sketch_constraint can validate
+        # entity1/entity2 the same way the real adapter validates against
+        # its sketch-entity registry.
+        self._sketch_entity_ids: set[str] = set()
+        self._dimensions: dict[str, float] = {}
+        # Assembly components inserted via insert_component, keyed by
+        # insertion order. See insert_component/list_components/add_mate.
+        self._components: list[str] = []
+        # Mates added via add_mate, in order, so the geometry summary can
+        # report a mate count without real geometry.
+        self._mates: list[dict[str, Any]] = []
+        # Drawing views placed via create_drawing_view / add_drawing_view /
+        # create_technical_drawing, in sheet order. See list_drawing_views.
+        self._drawing_views: list[str] = []
+        # Reference planes created via create_reference_plane, in creation
+        # order, used to invent sequential "PlaneN" names. Shared feature
+        # tree counter with create_axis mirrors the live adapter's
+        # features_before/features_after pair (see _feature_count in
+        # solidworks/features.py).
+        self._reference_planes: list[str] = []
+        # Axes created via create_axis, in creation order, used to invent
+        # sequential "AxisN" names the same way self._reference_planes
+        # invents "PlaneN" names, and to validate the axis name passed to
+        # pattern_circular the same way known_sources validates mirror
+        # sources.
+        self._axes: list[str] = []
+        # Reference points created via create_reference_point, in creation
+        # order, invented "PointN" names on the same pattern as _axes.
+        self._reference_points: list[str] = []
+        # Centre-mark count per drawing-view name, grown by auto_center_marks.
+        self._center_marks: dict[str, int] = {}
+        self._feature_tree_count = 0
+        # Volume tracked for mirror_feature, in mm^3. Seeded at the
+        # live-measured 1819569.1 mm^3 wing volume from
+        # _mirror_feature_impl in solidworks/features.py, then doubled on
+        # each successful mirror so volume_before/volume_after/volume_ratio
+        # stay self-consistent without a real geometry engine.
+        self._mirror_volume: float = 1819569.1
+        # Volume tracked for pattern_circular, in mm^3. Seeded at the
+        # live-measured 48431.5 mm^3 hub+blade volume from
+        # _pattern_circular_impl in solidworks/features.py, then grown by
+        # _PATTERN_BLADE_VOLUME per extra instance on each successful
+        # pattern so volume_before/volume_after/volume_ratio stay
+        # self-consistent without a real geometry engine.
+        self._pattern_volume: float = 48431.5
+        self._operation_count = 0
+
+        # Configurable simulation delays (in seconds)
+        self._delays = {
+            "connect": cfg.get("mock_connect_delay", 0.1),
+            "model_operation": cfg.get("mock_model_delay", 0.02),
+            "feature_operation": cfg.get("mock_feature_delay", 0.03) if cfg else 0.03,
+            "sketch_operation": cfg.get("mock_sketch_delay", 0.1),
+        }
+        self._is_connected_proxy = _BoolCallable(lambda: self._connected)
+        self._simulate_errors = bool(cfg.get("simulate_errors", False))
+
+    def __getattribute__(self, name: str) -> Any:
+        """Build internal getattribute.
+
+        Args:
+            name (str): The name value.
+
+        Returns:
+            Any: The result produced by the operation.
+        """
+        if name == "is_connected":
+            return object.__getattribute__(self, "_is_connected_proxy")
+        return object.__getattribute__(self, name)
+
+    async def connect(self) -> None:
+        """Mock connection to SolidWorks.
+
+        Returns:
+            None: None.
+        """
+        await asyncio.sleep(self._delays["connect"])
+        self._connected = True
+
+        # Initialize some sample data
+        self._dimensions = {
+            "D1@Sketch1": 10.0,
+            "D2@Sketch1": 20.0,
+            "D1@Boss-Extrude1": 50.0,
+        }
+
+    async def disconnect(self) -> None:
+        """Mock disconnection from SolidWorks.
+
+        Returns:
+            None: None.
+        """
+        self._connected = False
+        self._current_model = None
+        self._models.clear()
+        self._features.clear()
+        self._sketches.clear()
+        self._current_sketch = None
+        self._selection.clear()
+
+    def is_connected(self) -> bool:
+        """Check if mock connection is active.
+
+        Returns:
+            bool: True if connected, otherwise False.
+        """
+        return self._connected
+
+    async def health_check(self) -> AdapterHealth:
+        """Get mock health status.
+
+        Returns:
+            AdapterHealth: The result produced by the operation.
+        """
+        error_count = int(self._metrics["errors_count"])
+        success_count = int(
+            self._metrics["operations_count"] - self._metrics["errors_count"]
+        )
+        return AdapterHealth(
+            healthy=self._connected,
+            last_check=datetime.now(),
+            error_count=error_count,
+            success_count=success_count,
+            average_response_time=self._metrics["average_response_time"],
+            connection_status="connected" if self._connected else "disconnected",
+            metrics={
+                "adapter_type": "mock",
+                "operations_count": self._operation_count,
+                "models_count": len(self._models),
+                "features_count": len(self._features),
+                "sketches_count": len(self._sketches),
+            },
+        )
+
+    async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
+        """Mock opening a SolidWorks model.
+
+        Args:
+            file_path (str): Path to the target file.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+
+        Raises:
+            SolidWorksOperationError: Simulated adapter failure.
+        """
+        if not self._connected:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        if self._simulate_errors:
+            raise SolidWorksOperationError("Simulated adapter failure")
+
+        await asyncio.sleep(self._delays["model_operation"])
+        self._operation_count += 1
+
+        # Determine model type from file extension
+        file_path_lower = file_path.lower()
+        if file_path_lower.endswith(".sldprt"):
+            model_type = "Part"
+        elif file_path_lower.endswith(".sldasm"):
+            model_type = "Assembly"
+        elif file_path_lower.endswith(".slddrw"):
+            model_type = "Drawing"
+        else:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Unsupported file type: {file_path}",
+            )
+
+        # Create mock model
+        model_name = file_path.split("/")[-1].split("\\")[-1]
+        model = SolidWorksModel(
+            path=file_path,
+            name=model_name,
+            type=model_type,
+            is_active=True,
+            configuration="Default",
+            properties={
+                "created": datetime.now().isoformat(),
+                "model_id": model_name or f"Part{len(self._models) + 1}",
+                "file_size": random.randint(100000, 5000000),
+            },
+        )
+
+        self._current_model = model
+        self._models[file_path] = model
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=model,
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def close_model(self, save: bool = False) -> AdapterResult[None]:
+        """Mock closing the current model.
+
+        Args:
+            save (bool): The save value. Defaults to False.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.WARNING, error="No active model to close"
+            )
+
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        self._operation_count += 1
+
+        if save:
+            # Simulate save operation
+            await asyncio.sleep(self._delays["model_operation"])
+
+        self._current_model = None
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=None,
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
+        """Mock metadata for the currently active model.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        self._operation_count += 1
+
+        model = self._current_model
+        feature_count = len(self._features)
+        info = {
+            "title": model.name,
+            "path": model.path,
+            "type": model.type,
+            "configuration": model.configuration or "Default",
+            "is_dirty": False,
+            "feature_count": feature_count,
+            "rebuild_status": 0,
+        }
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=info,
+            execution_time=self._delays["model_operation"] / 2,
+        )
+
+    async def list_features(
+        self, include_suppressed: bool = False, max_assembly_depth: int = 2
+    ) -> AdapterResult[list[dict[str, Any]]]:
+        """Mock feature tree listing for the active model.
+
+        For an Assembly model, flattens in every configured component's
+        features (see ``_assembly_components``) alongside the document's own
+        features, tagged with ``component``/``component_path`` the same way
+        the real adapter does. Falls back to a small canned two-component
+        fixture (plus one nested sub-assembly) when no components have been
+        configured, mirroring the existing "seed realistic feature names"
+        behavior for an empty Part.
+
+        Args:
+            include_suppressed (bool): The include suppressed value. Defaults to False.
+            max_assembly_depth (int): Sub-assembly recursion budget. Ignored
+                for non-Assembly models. Defaults to 2.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"] / 2)
+        self._operation_count += 1
+
+        is_assembly = self._current_model.type == "Assembly"
+
+        # Seed realistic feature names for empty mock state.
+        if not self._features:
+            seeded: list[dict[str, Any]] = [
+                {
+                    "name": "Origin",
+                    "type": "OriginProfileFeature",
+                    "suppressed": False,
+                    "component": None,
+                    "component_path": None,
+                    "component_parent": None,
+                },
+                {
+                    "name": "Front Plane",
+                    "type": "RefPlane",
+                    "suppressed": False,
+                    "component": None,
+                    "component_path": None,
+                    "component_parent": None,
+                },
+                {
+                    "name": "Right Plane",
+                    "type": "RefPlane",
+                    "suppressed": False,
+                    "component": None,
+                    "component_path": None,
+                    "component_parent": None,
+                },
+                {
+                    "name": "Top Plane",
+                    "type": "RefPlane",
+                    "suppressed": False,
+                    "component": None,
+                    "component_path": None,
+                    "component_parent": None,
+                },
+                {
+                    "name": "Sketch1",
+                    "type": "ProfileFeature",
+                    "suppressed": False,
+                    "component": None,
+                    "component_path": None,
+                    "component_parent": None,
+                },
+            ]
+            if is_assembly:
+                components = self._assembly_components or _DEFAULT_ASSEMBLY_COMPONENTS
+                seeded.extend(
+                    self._flatten_assembly_components(
+                        components, include_suppressed, max_assembly_depth - 1, None
+                    )
+                )
+            return AdapterResult(
+                status=AdapterResultStatus.SUCCESS,
+                data=seeded,
+                execution_time=self._delays["feature_operation"] / 2,
+            )
+
+        feature_rows: list[dict[str, Any]] = []
+        for i, feature in enumerate(self._features.values()):
+            row = {
+                "name": feature.name,
+                "type": feature.type,
+                "suppressed": bool((feature.properties or {}).get("suppressed", False)),
+                "position": i,
+                "component": None,
+                "component_path": None,
+                "component_parent": None,
+            }
+            if include_suppressed or not row["suppressed"]:
+                feature_rows.append(row)
+
+        if is_assembly:
+            components = self._assembly_components or _DEFAULT_ASSEMBLY_COMPONENTS
+            feature_rows.extend(
+                self._flatten_assembly_components(
+                    components,
+                    include_suppressed,
+                    max_assembly_depth - 1,
+                    None,
+                )
+            )
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=feature_rows,
+            execution_time=self._delays["feature_operation"] / 2,
+        )
+
+    def _flatten_assembly_components(
+        self,
+        components: dict[str, dict[str, Any]],
+        include_suppressed: bool,
+        depth_remaining: int,
+        parent_component: str | None,
+    ) -> list[dict[str, Any]]:
+        """Flatten a mock component tree into tagged feature descriptors.
+
+        Mirrors the real adapter's recursion rules: a sub-assembly component
+        is expanded (its own features plus a recursive pass over its
+        components) only while ``depth_remaining > 0``; beyond that it is
+        represented by a single bare descriptor. An unresolvable component
+        (``type: "Unresolved"`` in the fixture) always produces one
+        ``UnresolvedComponent`` descriptor.
+
+        Args:
+            components: Mapping of component name to a fixture dict with
+                ``type`` ("Part", "Assembly", or "Unresolved"), ``path``,
+                ``features`` (list of ``{name, type, suppressed}``), and,
+                for "Assembly" components, a nested ``components`` mapping.
+            include_suppressed: Include suppressed entries when ``True``.
+            depth_remaining: Sub-assembly recursion budget remaining.
+            parent_component: Name of the component this level of
+                ``components`` is nested inside, or ``None`` for top-level.
+
+        Returns:
+            list[dict[str, Any]]: Flattened, component-tagged descriptors.
+        """
+        results: list[dict[str, Any]] = []
+        for name, comp in components.items():
+            comp_type = comp.get("type")
+            path = comp.get("path")
+
+            if comp_type == "Unresolved":
+                results.append(
+                    {
+                        "name": name,
+                        "type": "UnresolvedComponent",
+                        "suppressed": False,
+                        "position": -1,
+                        "component": name,
+                        "component_path": None,
+                        "component_parent": parent_component,
+                    }
+                )
+                continue
+
+            if comp_type == "Assembly" and depth_remaining <= 0:
+                results.append(
+                    {
+                        "name": name,
+                        "type": "Component",
+                        "suppressed": False,
+                        "position": -1,
+                        "component": name,
+                        "component_path": path,
+                        "component_parent": parent_component,
+                    }
+                )
+                continue
+
+            for i, feature in enumerate(comp.get("features", [])):
+                suppressed = bool(feature.get("suppressed", False))
+                if not include_suppressed and suppressed:
+                    continue
+                results.append(
+                    {
+                        "name": feature["name"],
+                        "type": feature["type"],
+                        "suppressed": suppressed,
+                        "position": i,
+                        "component": name,
+                        "component_path": path,
+                        "component_parent": parent_component,
+                    }
+                )
+
+            if comp_type == "Assembly":
+                results.extend(
+                    self._flatten_assembly_components(
+                        comp.get("components", {}),
+                        include_suppressed,
+                        depth_remaining - 1,
+                        name,
+                    )
+                )
+
+        return results
+
+    #: Default tree items every new part has, selectable like the real ones.
+    _DEFAULT_SELECTABLE = ("Front Plane", "Top Plane", "Right Plane", "Origin")
+
+    async def select_feature(
+        self, feature_name: str, append: bool = False
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock feature selection, mirroring the real adapter's contract.
+
+        Succeeds only for names the mock is tracking for the active model
+        (created features, sketches, default planes); anything else is an
+        ERROR naming the feature - never SUCCESS with ``selected: False``.
+
+        Args:
+            feature_name (str): The feature name, optionally ``@doc`` qualified.
+            append (bool): Add to the current selection. Defaults to False.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+        await asyncio.sleep(self._delays["feature_operation"] / 4)
+        self._operation_count += 1
+
+        bare = feature_name.split("@", 1)[0].strip()
+        known = (
+            {f.name for f in self._features.values()}
+            | set(self._sketches)
+            | set(self._DEFAULT_SELECTABLE)
+        )
+        if bare not in known:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Feature not found or could not be selected: {feature_name}",
+            )
+        if not append:
+            self._selection.clear()
+        if bare not in self._selection:
+            self._selection.append(bare)
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "selected": True,
+                "feature_name": feature_name,
+                "selected_name": bare,
+                "entity_type": "mock",
+                "selection_count": len(self._selection),
+            },
+            execution_time=self._delays["feature_operation"] / 4,
+        )
+
+    async def get_selected_entities(self) -> AdapterResult[list[dict[str, Any]]]:
+        """Mock UI selection — always reports one canned face and one canned edge.
+
+        There's no real UI to read a selection from in mock mode, so this
+        returns a stable, plausible-shaped fixture rather than an empty list,
+        so callers exercising this tool in tests get realistic field names.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+        await asyncio.sleep(self._delays["feature_operation"] / 4)
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=[
+                {
+                    "index": 1,
+                    "type": "FACE",
+                    "bounding_box_mm": {
+                        "min": [0.0, 0.0, 0.0],
+                        "max": [30.0, 30.0, 0.0],
+                    },
+                    "center_mm": [15.0, 15.0, 0.0],
+                    "area_mm2": 900.0,
+                    "normal": [0.0, 0.0, 1.0],
+                },
+                {
+                    "index": 2,
+                    "type": "EDGE",
+                    "start_mm": [0.0, 0.0, -15.0],
+                    "end_mm": [30.0, 0.0, -15.0],
+                    "length_mm": 30.0,
+                },
+            ],
+            execution_time=self._delays["feature_operation"] / 4,
+        )
+
+    async def select_face_edges(
+        self,
+        point: list[float] | None = None,
+        side: str | None = None,
+        plane: str | None = None,
+        edge_type: str = "all",
+        append: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock face-edge multi-selection on a canned 10 mm block.
+
+        Mirrors the real adapter's contract: the same input validation, the
+        same payload shape, and the same failure cases. The block spans
+        0..10 mm on every axis; the +Z/-Z faces carry a 2 mm radius hole rim
+        once any circle has been sketched, so ``edge_type="circular"``
+        behaves like a real drilled part. ``Front Plane`` (z = 0) is the only
+        reference plane with a face on it.
+        """
+        from .solidworks.face_selection import side_vector, validate_face_query
+
+        problem = validate_face_query(point, side, plane, edge_type)
+        if problem:
+            return AdapterResult(status=AdapterResultStatus.ERROR, error=problem)
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        if getattr(self._current_model, "type", "Part") != "Part":
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="select_face_edges requires an active part document.",
+            )
+        await asyncio.sleep(self._delays["feature_operation"] / 4)
+
+        if point is not None:
+            normal = self._mock_face_at(point)
+            if normal is None:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=f"No face found at point {list(point)} mm.",
+                )
+        elif side is not None:
+            normal = side_vector(side)
+        elif plane == "Front Plane":
+            normal = (0.0, 0.0, -1.0)
+        else:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"No body face lies on {plane!r}.",
+            )
+
+        center = [5.0 + 5.0 * c for c in normal]
+        has_hole = any(e.startswith("Circle") for e in self._sketch_entity_ids)
+        edges: list[dict[str, Any]] = [
+            {"curve": "linear", "length_mm": 10.0, "face_index": 0} for _ in range(4)
+        ]
+        if has_hole and normal[2] != 0:
+            edges.append(
+                {
+                    "curve": "circular",
+                    "center_mm": [5.0, 5.0, center[2]],
+                    "axis": [0.0, 0.0, 1.0],
+                    "radius_mm": 2.0,
+                    "face_index": 0,
+                }
+            )
+        edges = [e for e in edges if edge_type == "all" or e["curve"] == edge_type]
+        if not edges:
+            kind = "" if edge_type == "all" else f"{edge_type} "
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"The selected face has no {kind}edges (face centre {center} mm).",
+            )
+
+        if not append:
+            self._selection.clear()
+        self._selection.extend(f"Edge{i}" for i in range(len(edges)))
+        face = {
+            "index": 0,
+            "center_mm": center,
+            "normal": [float(c) for c in normal],
+            "area_mm2": 100.0,
+            "planar": True,
+        }
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "face": face,
+                "faces": [face],
+                "edge_type": edge_type,
+                "edges": edges,
+                "selected_edges": len(edges),
+                "selection_count": len(self._selection),
+            },
+            execution_time=self._delays["feature_operation"] / 4,
+        )
+
+    async def add_fillet(
+        self, radius: float, edge_names: list[str]
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Mock constant-radius fillet (see :meth:`_mock_edge_feature`)."""
+        return await self._mock_edge_feature("Fillet", radius, edge_names)
+
+    async def add_chamfer(
+        self, distance: float, edge_names: list[str]
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Mock equal-distance chamfer (see :meth:`_mock_edge_feature`)."""
+        return await self._mock_edge_feature("Chamfer", distance, edge_names)
+
+    async def _mock_edge_feature(
+        self, kind: str, size: float, edge_names: list[str]
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Create a mock fillet/chamfer on named edges or the live selection.
+
+        Mirrors the real contract: an empty ``edge_names`` acts on whatever is
+        currently selected (e.g. after ``select_face_edges``), and is an error
+        when nothing is.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        if size <= 0:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"{kind} size must be positive",
+            )
+        edges = list(edge_names) or list(self._selection)
+        if not edges:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"No edges given and nothing is selected for the {kind.lower()}",
+            )
+        await asyncio.sleep(self._delays["feature_operation"] / 4)
+        count = sum(1 for f in self._features.values() if f.type == kind) + 1
+        feature = SolidWorksFeature(
+            name=f"{kind}{count}",
+            type=kind,
+            id=f"{kind.lower()}_{uuid.uuid4().hex[:8]}",
+            parameters={"size": size, "edges": edges},
+            properties={"created": datetime.now().isoformat(), "mock": True},
+        )
+        self._features[feature.id or feature.name] = feature
+        self._selection.clear()
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=feature,
+            execution_time=self._delays["feature_operation"] / 4,
+        )
+
+    async def rebuild_model(
+        self, top_level_only: bool = False
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock rebuild with the real adapter's diagnostics contract.
+
+        Clean by default; issues placed in ``injected_rebuild_issues`` are
+        explained with the same ``rebuild_diagnostics`` logic the real
+        adapter uses, so ERROR-with-data / warnings-only behave identically.
+        """
+        from .solidworks.rebuild_diagnostics import explain, summarize
+
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        await asyncio.sleep(self._delays["model_operation"] / 4)
+        entries = [explain(i) for i in self.injected_rebuild_issues]
+        error_count, warning_count, summary = summarize(entries)
+        data = {
+            "rebuilt": True,
+            "top_level_only": top_level_only,
+            "errors": entries,
+            "error_count": error_count,
+            "warning_count": warning_count,
+            "summary": summary,
+        }
+        return AdapterResult(
+            status=(
+                AdapterResultStatus.ERROR
+                if error_count
+                else AdapterResultStatus.SUCCESS
+            ),
+            data=data,
+            error=summary if error_count else None,
+            execution_time=self._delays["model_operation"] / 4,
+        )
+
+    @staticmethod
+    def _mock_face_at(point: list[float]) -> tuple[float, float, float] | None:
+        """Return the outward normal of the mock block face containing ``point``."""
+        if not all(-1e-6 <= c <= 10.0 + 1e-6 for c in point):
+            return None
+        for axis in range(3):
+            for value, sign in ((0.0, -1.0), (10.0, 1.0)):
+                if abs(point[axis] - value) <= 1e-6:
+                    normal = [0.0, 0.0, 0.0]
+                    normal[axis] = sign
+                    return (normal[0], normal[1], normal[2])
+        return None
+
+    async def list_configurations(self) -> AdapterResult[list[str]]:
+        """Mock configuration listing for the active model.
+
+        Returns:
+            AdapterResult[list[str]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        self._operation_count += 1
+
+        active = self._current_model.configuration or "Default"
+        configs = [active] if active == "Default" else ["Default", active]
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=configs,
+            execution_time=self._delays["model_operation"] / 2,
+        )
+
+    async def create_part(
+        self,
+        name: str | None = None,
+        units: str | None = None,
+        template: str | None = None,
+    ) -> AdapterResult[SolidWorksModel]:
+        """Mock creating a new part.
+
+        Args:
+            name (str | None): The name value. Defaults to None.
+            units (str | None): The units value. Defaults to None.
+            template (str | None): Template file path. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        if not self._connected:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        token = "mm"
+        if units is not None and str(units).strip():
+            token = _normalise_mock_unit_system(str(units))
+            if token is None:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unrecognised units {units!r}. "
+                        "Expected one of: mm, cm, m, in, ft."
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["model_operation"])
+        self._operation_count += 1
+
+        model_id = name or f"Part{len(self._models) + 1}"
+        model = SolidWorksModel(
+            path=f"Mock://{model_id}.sldprt",
+            name=f"{model_id}",
+            type="Part",
+            is_active=True,
+            configuration="Default",
+            properties={
+                "created": datetime.now().isoformat(),
+                "mock": True,
+                "units": token,
+                "template": template,
+            },
+        )
+
+        self._current_model = model
+        self._models[model.path] = model
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=model,
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def create_assembly(
+        self, name: str | None = None, template: str | None = None
+    ) -> AdapterResult[SolidWorksModel]:
+        """Mock creating a new assembly.
+
+        Args:
+            name (str | None): The name value. Defaults to None.
+            template (str | None): Template file path. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        if not self._connected:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        await asyncio.sleep(self._delays["model_operation"])
+        self._operation_count += 1
+
+        model_id = name or f"Assembly{len(self._models) + 1}"
+        model = SolidWorksModel(
+            path=f"Mock://{model_id}.sldasm",
+            name=f"{model_id}",
+            type="Assembly",
+            is_active=True,
+            configuration="Default",
+            properties={
+                "created": datetime.now().isoformat(),
+                "mock": True,
+                "template": template,
+            },
+        )
+
+        self._current_model = model
+        self._models[model.path] = model
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=model,
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def create_drawing(
+        self, name: str | None = None, template: str | None = None
+    ) -> AdapterResult[SolidWorksModel]:
+        """Mock creating a new drawing.
+
+        Args:
+            name (str | None): The name value. Defaults to None.
+            template (str | None): Template file path. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: The result produced by the operation.
+        """
+        if not self._connected:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        await asyncio.sleep(self._delays["model_operation"])
+        self._operation_count += 1
+
+        model_id = name or f"Drawing{len(self._models) + 1}"
+        model = SolidWorksModel(
+            path=f"Mock://{model_id}.slddrw",
+            name=f"{model_id}",
+            type="Drawing",
+            is_active=True,
+            configuration="Default",
+            properties={
+                "created": datetime.now().isoformat(),
+                "mock": True,
+                "template": template,
+            },
+        )
+
+        self._current_model = model
+        self._models[model.path] = model
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=model,
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def create_extrusion(
+        self,
+        params: ExtrusionParameters | str,
+        depth: float | None = None,
+        direction: str | None = None,
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Mock creating an extrusion feature.
+
+        Args:
+            params (ExtrusionParameters | str): The params value.
+            depth (float | None): The depth value. Defaults to None.
+            direction (str | None): The direction value. Defaults to None.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        if isinstance(params, str):
+            params = ExtrusionParameters(depth=depth or 0.0)
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        feature_id = f"Boss-Extrude{len(self._features) + 1}"
+        feature = SolidWorksFeature(
+            name=feature_id,
+            type="Extrusion",
+            id=str(uuid.uuid4()),
+            parameters={
+                "depth": params.depth,
+                "direction": direction or "blind",
+                "draft_angle": params.draft_angle,
+                "reverse_direction": params.reverse_direction,
+                "both_directions": params.both_directions,
+                "thin_feature": params.thin_feature,
+                "thin_thickness": params.thin_thickness,
+            },
+            properties={"created": datetime.now().isoformat(), "mock": True},
+        )
+
+        feature_key = feature.id or feature.name
+        self._features[feature_key] = feature
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=feature,
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def create_revolve(
+        self, params: RevolveParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Mock creating a revolve feature.
+
+        Args:
+            params (RevolveParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        feature_id = f"Boss-Revolve{len(self._features) + 1}"
+        feature = SolidWorksFeature(
+            name=feature_id,
+            type="Revolve",
+            id=str(uuid.uuid4()),
+            parameters={
+                "angle": params.angle,
+                "reverse_direction": params.reverse_direction,
+                "both_directions": params.both_directions,
+                "thin_feature": params.thin_feature,
+                "thin_thickness": params.thin_thickness,
+            },
+            properties={"created": datetime.now().isoformat(), "mock": True},
+        )
+
+        feature_key = feature.id or feature.name
+        self._features[feature_key] = feature
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=feature,
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def create_sweep(
+        self, params: SweepParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Mock creating a sweep feature.
+
+        Args:
+            params (SweepParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        feature_id = f"Boss-Sweep{len(self._features) + 1}"
+        feature = SolidWorksFeature(
+            name=feature_id,
+            type="Sweep",
+            id=str(uuid.uuid4()),
+            parameters={
+                "path": params.path,
+                "twist_along_path": params.twist_along_path,
+                "twist_angle": params.twist_angle,
+            },
+            properties={"created": datetime.now().isoformat(), "mock": True},
+        )
+
+        feature_key = feature.id or feature.name
+        self._features[feature_key] = feature
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=feature,
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def create_loft(
+        self, params: LoftParameters
+    ) -> AdapterResult[SolidWorksFeature]:
+        """Mock creating a loft feature.
+
+        Args:
+            params (LoftParameters): The params value.
+
+        Returns:
+            AdapterResult[SolidWorksFeature]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        feature_id = f"Boss-Loft{len(self._features) + 1}"
+        feature = SolidWorksFeature(
+            name=feature_id,
+            type="Loft",
+            id=str(uuid.uuid4()),
+            parameters={
+                "profiles": params.profiles,
+                "guide_curves": params.guide_curves,
+                "start_tangent": params.start_tangent,
+                "end_tangent": params.end_tangent,
+            },
+            properties={"created": datetime.now().isoformat(), "mock": True},
+        )
+
+        feature_key = feature.id or feature.name
+        self._features[feature_key] = feature
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=feature,
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def create_sketch(self, plane: str) -> AdapterResult[dict[str, Any]]:  # type: ignore[override]
+        """Mock creating a sketch.
+
+        Args:
+            plane (str): The plane value.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            # Legacy tests start sketching immediately after connect.
+            await self.create_part()
+
+        await asyncio.sleep(self._delays["sketch_operation"])
+        self._operation_count += 1
+
+        sketch_id = f"Sketch{len(self._sketches) + 1}"
+        self._sketches[sketch_id] = plane
+        self._current_sketch = sketch_id
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "id": sketch_id,
+                "name": sketch_id,
+                "sketch_name": sketch_id,
+                "plane": plane,
+            },
+            execution_time=self._delays["sketch_operation"],
+        )
+
+    async def add_sketch_line(
+        self,
+        x1: float,
+        y1: float,
+        x2: float,
+        y2: float,
+        construction: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Legacy compatibility wrapper around add_line.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+            construction (bool): The construction value. Defaults to False.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        result = await self.add_line(x1, y1, x2, y2)
+        if not result.is_success:
+            return AdapterResult(
+                status=result.status,
+                error=result.error,
+                execution_time=result.execution_time,
+            )
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "id": result.data,
+                "start": {"x": x1, "y": y1},
+                "end": {"x": x2, "y": y2},
+                "construction": construction,
+            },
+            execution_time=result.execution_time,
+        )
+
+    async def save_file(
+        self, file_path: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Legacy compatibility save operation for tests.
+
+        Args:
+            file_path (str | None): Path to the target file. Defaults to None.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+        await asyncio.sleep(0.02)
+        self._operation_count += 1
+        resolved_path = file_path or self._current_model.path
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={"file_path": resolved_path, "saved": True},
+            execution_time=0.02,
+        )
+
+    async def add_line(
+        self, x1: float, y1: float, x2: float, y2: float
+    ) -> AdapterResult[str]:
+        """Mock adding a line to sketch.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        line_id = f"Line{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(line_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=line_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_centerline(
+        self, x1: float, y1: float, x2: float, y2: float
+    ) -> AdapterResult[str]:
+        """Mock adding a construction centerline to sketch.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        centerline_id = f"Centerline_{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(centerline_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=centerline_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_spline(self, points: list[dict[str, float]]) -> AdapterResult[str]:
+        """Mock adding a NURBS spline through the supplied points.
+
+        Args:
+            points (list[dict[str, float]]): Ordered control points with
+                ``"x"`` / ``"y"`` keys. Minimum 2 points.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+        if len(points) < 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="add_spline requires at least 2 points",
+            )
+        # Match the real adapter's point contract: each dict must carry
+        # both ``x`` and ``y`` keys, or the live impl raises KeyError on
+        # ``point["x"]``. Validating here keeps mock/live parity so tests
+        # that pass against the mock won't fail live on malformed input.
+        for index, point in enumerate(points):
+            if not isinstance(point, dict) or "x" not in point or "y" not in point:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"add_spline point at index {index} is missing "
+                        "required 'x' and/or 'y' keys"
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        spline_id = f"Spline_{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(spline_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=spline_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_circle(
+        self, center_x: float, center_y: float, radius: float
+    ) -> AdapterResult[str]:
+        """Mock adding a circle to sketch.
+
+        Args:
+            center_x (float): The center x value.
+            center_y (float): The center y value.
+            radius (float): The radius value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        circle_id = f"Circle{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(circle_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=circle_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_arc(
+        self,
+        center_x: float,
+        center_y: float,
+        start_x: float,
+        start_y: float,
+        end_x: float,
+        end_y: float,
+    ) -> AdapterResult[str]:
+        """Mock adding a circular arc to sketch.
+
+        Args:
+            center_x (float): Arc centre X.
+            center_y (float): Arc centre Y.
+            start_x (float): Arc start point X.
+            start_y (float): Arc start point Y.
+            end_x (float): Arc end point X.
+            end_y (float): Arc end point Y.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        arc_id = f"Arc_{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(arc_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=arc_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_rectangle(
+        self, x1: float, y1: float, x2: float, y2: float
+    ) -> AdapterResult[str]:
+        """Mock adding a rectangle to sketch.
+
+        Args:
+            x1 (float): The x1 value.
+            y1 (float): The y1 value.
+            x2 (float): The x2 value.
+            y2 (float): The y2 value.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"])
+        self._operation_count += 1
+
+        rect_id = f"Rectangle{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(rect_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=rect_id,
+            execution_time=self._delays["sketch_operation"],
+        )
+
+    async def add_ellipse(
+        self,
+        center_x: float,
+        center_y: float,
+        major_axis: float,
+        minor_axis: float,
+    ) -> AdapterResult[str]:
+        """Mock adding an axis-aligned ellipse to sketch.
+
+        Args:
+            center_x (float): Ellipse centre X in millimetres.
+            center_y (float): Ellipse centre Y in millimetres.
+            major_axis (float): Full major-axis length in millimetres.
+            minor_axis (float): Full minor-axis length in millimetres.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        ellipse_id = f"Ellipse_{random.randint(1000, 9999)}"
+        self._sketch_entity_ids.add(ellipse_id)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=ellipse_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_polygon(
+        self, center_x: float, center_y: float, radius: float, sides: int
+    ) -> AdapterResult[str]:
+        """Mock adding a regular polygon to sketch.
+
+        Args:
+            center_x (float): Polygon centre X in millimetres.
+            center_y (float): Polygon centre Y in millimetres.
+            radius (float): Circumradius in millimetres (distance from centre
+                to each vertex; matches the real adapter's
+                ``CreatePolygon(..., Inscribed=True)`` semantics).
+            sides (int): Number of polygon sides.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        # ID format mirrors the real PyWin32 adapter, which uses
+        # ``_register_sketch_entity("Polygon", ...)`` (counter-based) so the
+        # returned ID is a valid input to downstream sketch_linear_pattern /
+        # sketch_circular_pattern / sketch_mirror / sketch_offset calls.
+        polygon_id = f"Polygon_{len(self._sketch_entity_ids) + 1}"
+        self._sketch_entity_ids.add(polygon_id)
+        _ = sides  # informational only; the sides count is no longer part of the ID
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=polygon_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def sketch_linear_pattern(
+        self,
+        entities: list[str],
+        direction_x: float,
+        direction_y: float,
+        spacing: float,
+        count: int,
+    ) -> AdapterResult[str]:
+        """Mock creating a linear sketch pattern.
+
+        Mirrors the real adapter's validation rules — empty entities,
+        count < 2, non-positive spacing, and a zero direction vector each
+        produce a clear error without "creating" a pattern.
+
+        Args:
+            entities (list[str]): Seed entity IDs.
+            direction_x (float): Pattern direction X component.
+            direction_y (float): Pattern direction Y component.
+            spacing (float): Distance between instances in millimetres.
+            count (int): Total number of instances (including the seed).
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+        if not entities:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_linear_pattern requires at least one entity",
+            )
+        if count < 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_linear_pattern requires count >= 2",
+            )
+        if spacing <= 0:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_linear_pattern requires spacing > 0",
+            )
+        if math.hypot(direction_x, direction_y) < 1e-9:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=("sketch_linear_pattern requires a non-zero direction vector"),
+            )
+        for ent in entities:
+            if ent not in self._sketch_entity_ids:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unknown sketch entity '{ent}'. Use IDs returned by "
+                        "add_line/add_arc/add_circle/add_spline/add_centerline."
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        pattern_id = f"LinearPattern_{count}x{spacing}_{random.randint(1000, 9999)}"
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=pattern_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def sketch_circular_pattern(
+        self,
+        entities: list[str],
+        angle: float,
+        count: int,
+    ) -> AdapterResult[str]:
+        """Mock creating a circular sketch pattern around the sketch origin.
+
+        Args:
+            entities (list[str]): Seed entity IDs.
+            angle (float): Total swept angle in degrees.
+            count (int): Total number of instances (including the seed).
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+        if not entities:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_circular_pattern requires at least one entity",
+            )
+        if count < 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_circular_pattern requires count >= 2",
+            )
+        if angle <= 0:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_circular_pattern requires angle > 0",
+            )
+        for ent in entities:
+            if ent not in self._sketch_entity_ids:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unknown sketch entity '{ent}'. Use IDs returned by "
+                        "add_line/add_arc/add_circle/add_spline/add_centerline."
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        pattern_id = f"CircularPattern_{count}x{angle}deg_{random.randint(1000, 9999)}"
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=pattern_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def sketch_mirror(
+        self, entities: list[str], mirror_line: str
+    ) -> AdapterResult[str]:
+        """Mock mirroring sketch entities about a centerline.
+
+        Args:
+            entities (list[str]): IDs of segments to mirror.
+            mirror_line (str): ID of the centerline to mirror across.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+        if not entities:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_mirror requires at least one entity",
+            )
+        if not mirror_line:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "sketch_mirror requires a mirror_line entity ID (add_centerline)"
+                ),
+            )
+        if mirror_line not in self._sketch_entity_ids:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown mirror_line entity '{mirror_line}'. Use the "
+                    "ID returned by add_centerline."
+                ),
+            )
+        # Mirror the real adapter — IModelDoc2::SketchMirror needs a
+        # centreline as the mirror axis; other segments silently no-op.
+        if not mirror_line.startswith("Centerline_"):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"mirror_line must be a centerline (from add_centerline), "
+                    f"got '{mirror_line}'"
+                ),
+            )
+        for ent in entities:
+            if ent not in self._sketch_entity_ids:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unknown sketch entity '{ent}'. Use IDs returned by "
+                        "add_line/add_arc/add_circle/add_spline/add_centerline."
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        mirror_id = f"Mirror_{mirror_line}_{random.randint(1000, 9999)}"
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=mirror_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def sketch_offset(
+        self,
+        entities: list[str],
+        offset_distance: float,
+        reverse_direction: bool,
+    ) -> AdapterResult[str]:
+        """Mock offsetting sketch entities by a fixed distance.
+
+        Args:
+            entities (list[str]): IDs of segments to offset.
+            offset_distance (float): Distance in millimetres. Must be > 0.
+            reverse_direction (bool): Flip the offset direction.
+
+        Returns:
+            AdapterResult[str]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+        if not entities:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="sketch_offset requires at least one entity",
+            )
+        if offset_distance <= 0:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "sketch_offset requires offset_distance > 0 — use "
+                    "reverse_direction to flip the side"
+                ),
+            )
+        for ent in entities:
+            if ent not in self._sketch_entity_ids:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unknown sketch entity '{ent}'. Use IDs returned by "
+                        "add_line/add_arc/add_circle/add_spline/add_centerline."
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        direction = "inward" if reverse_direction else "outward"
+        offset_id = f"Offset_{offset_distance}_{direction}_{random.randint(1000, 9999)}"
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=offset_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def add_sketch_constraint(
+        self,
+        entity1: str,
+        entity2: str | None,
+        relation_type: str,
+        entity3: str | None = None,
+    ) -> AdapterResult[str]:
+        """Mock adding a geometric constraint between sketch entities.
+
+        Args:
+            entity1 (str): Primary sketch-entity ID.
+            entity2 (str | None): Secondary sketch-entity ID, or None for
+                single-entity relations (horizontal, vertical, fix).
+            relation_type (str): Constraint name (see RELATION_NAME_MAP).
+            entity3 (str | None): Third entity ID — only used by the
+                ``symmetric`` relation (the centerline of symmetry). All
+                other relation types reject a non-null ``entity3``.
+
+        Returns:
+            AdapterResult[str]: SUCCESS with a placeholder constraint ID, or
+                ERROR if no active sketch, the relation_type is unsupported,
+                arity is wrong, or an entity ID is unknown.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active sketch"
+            )
+
+        rt_norm = (relation_type or "").strip().lower()
+        if rt_norm not in RELATION_NAME_MAP:
+            supported = ", ".join(sorted(RELATION_NAME_MAP))
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unsupported relation type '{relation_type}'. "
+                    f"Supported: {supported}"
+                ),
+            )
+
+        # Arity validation — mirror the real adapter
+        if rt_norm == "symmetric":
+            if entity2 is None or entity3 is None:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Relation '{relation_type}' requires entity1, "
+                        "entity2, and entity3 (the centerline of symmetry)"
+                    ),
+                )
+        elif entity3 is not None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Relation '{relation_type}' does not accept entity3 — "
+                    "only 'symmetric' takes a third entity (the centerline)"
+                ),
+            )
+
+        # Validate entity IDs against the in-process sketch-entity registry
+        # so the mock surfaces the same "Unknown sketch entity" error as the
+        # real adapter (which checks adapter._sketch_entities).
+        for ent in (entity1, entity2, entity3):
+            if ent is not None and ent not in self._sketch_entity_ids:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unknown sketch entity '{ent}'. Use IDs returned by "
+                        "add_line/add_arc/add_circle/add_spline/add_centerline."
+                    ),
+                )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._operation_count += 1
+
+        constraint_id = f"Constraint_{relation_type}_{random.randint(1000, 9999)}"
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=constraint_id,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def exit_sketch(self) -> AdapterResult[None]:
+        """Mock exiting sketch mode.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        if not self._current_sketch:
+            return AdapterResult(
+                status=AdapterResultStatus.WARNING, error="No active sketch to exit"
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 2)
+        self._current_sketch = None
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=None,
+            execution_time=self._delays["sketch_operation"] / 2,
+        )
+
+    async def check_sketch_fully_defined(
+        self, sketch_name: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock check for sketch definition status.
+
+        Args:
+            sketch_name (str | None): Optional sketch name to inspect. Defaults to None.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Definition status payload.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+
+        await asyncio.sleep(self._delays["sketch_operation"] / 3)
+        self._operation_count += 1
+
+        resolved_name = sketch_name or self._current_sketch or "Sketch1"
+        if sketch_name and sketch_name not in self._sketches:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Sketch not found: {sketch_name}",
+            )
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "sketch_name": resolved_name,
+                "is_fully_defined": True,
+                "definition_state": "fully_defined",
+                "source": "mock",
+                "raw_status": True,
+            },
+            execution_time=self._delays["sketch_operation"] / 3,
+        )
+
+    async def get_mass_properties(self) -> AdapterResult[MassProperties]:
+        """Mock getting mass properties.
+
+        Returns:
+            AdapterResult[MassProperties]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        # Generate realistic mock data
+        properties = MassProperties(
+            volume=random.uniform(1000, 100000),  # mm³
+            surface_area=random.uniform(1000, 50000),  # mm²
+            mass=random.uniform(0.1, 50.0),  # kg (assuming typical density)
+            center_of_mass=[
+                random.uniform(-100, 100),
+                random.uniform(-100, 100),
+                random.uniform(-100, 100),
+            ],
+            moments_of_inertia={
+                "Ixx": random.uniform(1e6, 1e9),
+                "Iyy": random.uniform(1e6, 1e9),
+                "Izz": random.uniform(1e6, 1e9),
+                "Ixy": random.uniform(-1e8, 1e8),
+                "Ixz": random.uniform(-1e8, 1e8),
+                "Iyz": random.uniform(-1e8, 1e8),
+            },
+        )
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=properties,
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def export_image(self, payload: dict) -> AdapterResult[dict]:
+        """Mock export of a PNG/JPG viewport screenshot.
+
+        Args:
+            payload (dict): The payload value.
+
+        Returns:
+            AdapterResult[dict]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        import pathlib
+
+        file_path = payload.get("file_path", "")
+        width = int(payload.get("width", 1280))
+        height = int(payload.get("height", 720))
+        orientation = str(payload.get("view_orientation", "current"))
+
+        await asyncio.sleep(0.3)
+        self._operation_count += 1
+
+        out = pathlib.Path(file_path)
+        out.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write a valid 1×1 white PNG binary so UI image tags don't break
+        _PNG_1X1_WHITE = (
+            b"\x89PNG\r\n\x1a\n"  # PNG signature
+            b"\x00\x00\x00\rIHDR"  # IHDR chunk length+type
+            b"\x00\x00\x00\x01\x00\x00\x00\x01"  # 1x1
+            b"\x08\x02\x00\x00\x00\x90wS\xde"  # 8-bit RGB + CRC
+            b"\x00\x00\x00\x0cIDATx\x9cc\xf8\xff\xff\xff\x00\x05\xfe\x02\xfe\xdc\xcaY\xe7"  # IDAT
+            b"\x00\x00\x00\x00IEND\xaeB`\x82"  # IEND
+        )
+        out.write_bytes(_PNG_1X1_WHITE)
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "file_path": file_path,
+                "format": "PNG",
+                "dimensions": f"{width}x{height}",
+                "view": orientation,
+            },
+            execution_time=0.3,
+            metadata={"mock": True, "orientation": orientation},
+        )
+
+    async def pack_and_go_assembly(
+        self,
+        source_path: str,
+        target_dir: str,
+    ) -> AdapterResult[dict]:
+        """Mock Pack-and-Go: simulate copying an assembly to a target directory.
+
+        Args:
+            source_path (str): Path to the source .sldasm file.
+            target_dir (str): Directory to copy files into.
+
+        Returns:
+            AdapterResult[dict]: Simulated pack-and-go result.
+        """
+        import pathlib
+
+        await asyncio.sleep(0.05)
+        self._operation_count += 1
+
+        source = pathlib.Path(source_path)
+        out_dir = pathlib.Path(target_dir)
+        mock_parts = [f"MockPart{i}.SLDPRT" for i in range(1, 3)]
+        source_files = [str(source)] + [str(source.parent / p) for p in mock_parts]
+        copied_files = [str(out_dir / source.name)] + [
+            str(out_dir / p) for p in mock_parts
+        ]
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "source_assembly": str(source),
+                "target_dir": str(out_dir),
+                "copied_files": copied_files,
+                "source_files": source_files,
+                "save_statuses": [0] * (len(mock_parts) + 1),
+                "all_files_saved": True,
+            },
+            execution_time=0.05,
+            metadata={"mock": True},
+        )
+
+    async def export_file(
+        self, file_path: str, format_type: str
+    ) -> AdapterResult[None]:
+        """Mock exporting a file.
+
+        Args:
+            file_path (str): Path to the target file.
+            format_type (str): The format type value.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        if not self._current_model:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        # Simulate export time based on format
+        export_times = {
+            "step": 2.0,
+            "iges": 1.5,
+            "stl": 1.0,
+            "pdf": 0.5,
+            "jpg": 0.3,
+            "glb": 1.2,
+            "gltf": 1.2,
+        }
+
+        format_lower = format_type.lower()
+        delay = export_times.get(format_lower, 1.0)
+
+        await asyncio.sleep(delay)
+        self._operation_count += 1
+
+        # Write a minimal placeholder file so callers that check existence get a valid result
+        if format_lower == "stl":
+            import pathlib
+
+            out = pathlib.Path(file_path)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            # Minimal ASCII STL — a single unit triangle (mock geometry placeholder)
+            out.write_text(
+                "solid mock\n"
+                "  facet normal 0 0 1\n"
+                "    outer loop\n"
+                "      vertex 0 0 0\n"
+                "      vertex 10 0 0\n"
+                "      vertex 5 10 0\n"
+                "    endloop\n"
+                "  endfacet\n"
+                "  facet normal 0 0 1\n"
+                "    outer loop\n"
+                "      vertex 0 0 0\n"
+                "      vertex 10 0 0\n"
+                "      vertex 5 0 10\n"
+                "    endloop\n"
+                "  endfacet\n"
+                "endsolid mock\n",
+                encoding="utf-8",
+            )
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=None,
+            execution_time=delay,
+            metadata={"exported_format": format_type, "file_path": file_path},
+        )
+
+    async def get_dimension(self, name: str) -> AdapterResult[float]:
+        """Mock getting a dimension value.
+
+        Args:
+            name (str): The name value.
+
+        Returns:
+            AdapterResult[float]: The result produced by the operation.
+        """
+        await asyncio.sleep(0.05)  # Very fast operation
+        self._operation_count += 1
+
+        if name in self._dimensions:
+            return AdapterResult(
+                status=AdapterResultStatus.SUCCESS,
+                data=self._dimensions[name],
+                execution_time=0.05,
+            )
+        else:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error=f"Dimension '{name}' not found"
+            )
+
+    async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
+        """Mock setting a dimension value.
+
+        Args:
+            name (str): The name value.
+            value (float): The value value.
+
+        Returns:
+            AdapterResult[None]: The result produced by the operation.
+        """
+        await asyncio.sleep(0.1)  # Fast operation
+        self._operation_count += 1
+
+        self._dimensions[name] = value
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS, data=None, execution_time=0.1
+        )
+
+    async def set_units(self, unit_system: str) -> AdapterResult[dict[str, Any]]:
+        """Mock setting the active document's linear unit system.
+
+        Mirrors the real adapter: an unrecognised token is an error, and the
+        applied token is recorded on the current model's ``properties``.
+
+        Args:
+            unit_system (str): One of ``mm``, ``cm``, ``m``, ``in``, ``ft``
+                (aliases such as ``inch`` / ``millimeters`` accepted).
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(0.1)
+
+        token = _normalise_mock_unit_system(unit_system)
+        if token is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unrecognised unit system {unit_system!r}. "
+                    "Expected one of: mm, cm, m, in, ft."
+                ),
+            )
+        if self._current_model is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        self._operation_count += 1
+        props = dict(self._current_model.properties or {})
+        props["units"] = token
+        self._current_model.properties = props
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={"unit_system": token, "verified": True},
+            execution_time=0.1,
+        )
+
+    async def list_open_documents(self) -> AdapterResult[list[dict[str, Any]]]:
+        """Mock enumerating the currently open documents.
+
+        Returns every model the mock has created or opened this session, with
+        ``is_active`` reflecting ``self._current_model``.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: The result produced by the
+            operation.
+        """
+        await asyncio.sleep(0.05)
+        if not self._connected:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        active_path = (
+            self._current_model.path if self._current_model is not None else None
+        )
+        docs = [
+            {
+                "title": model.name,
+                "path": model.path,
+                "type": model.type,
+                "is_active": model.path == active_path,
+            }
+            for model in self._models.values()
+        ]
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS, data=docs, execution_time=0.05
+        )
+
+    async def activate_document(
+        self, title_or_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock making an already-open document active.
+
+        Args:
+            title_or_path (str): Title, full path, or file name of an open
+                document.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(0.05)
+        if not self._connected:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+        target = (title_or_path or "").strip()
+        if not target:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="title_or_path is required"
+            )
+
+        needle = target.lower()
+        match = None
+        for model in self._models.values():
+            names = {
+                model.name.lower(),
+                model.path.lower(),
+                model.path.rsplit("/", 1)[-1].lower(),
+            }
+            if needle in names:
+                match = model
+                break
+        if match is None:
+            open_titles = ", ".join(m.name for m in self._models.values()) or "none"
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"No open document matches {target!r}. Open: {open_titles}",
+            )
+
+        self._current_model = match
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={"activated": match.name, "verified": True},
+            execution_time=0.05,
+        )
+
+    async def insert_component(
+        self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock inserting a component into the active assembly.
+
+        Records the component in ``self._components`` so repeated inserts
+        accumulate and ``list_components`` reflects them.
+
+        Args:
+            file_path (str): Path to the part or sub-assembly to insert.
+            x (float): X position in millimetres. Defaults to 0.0.
+            y (float): Y position in millimetres. Defaults to 0.0.
+            z (float): Z position in millimetres. Defaults to 0.0.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        self._operation_count += 1
+
+        self._components.append(f"component-{len(self._components) + 1}")
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "component": self._components[-1],
+                "file_path": file_path,
+                "position": {"x": x, "y": y, "z": z},
+                "components_before": len(self._components) - 1,
+                "components_after": len(self._components),
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def list_components(self) -> AdapterResult[list[str]]:
+        """Mock listing the top-level components of the active assembly.
+
+        Returns:
+            AdapterResult[list[str]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=list(self._components),
+            execution_time=self._delays["model_operation"] / 2,
+        )
+
+    async def get_model_geometry_summary(self) -> AdapterResult[dict[str, Any]]:
+        """Mock summary of the active part or assembly.
+
+        The mock has no geometry, so volume, bounding box and body count are
+        ``None`` ("not determinable") rather than invented numbers a caller
+        could mistake for a measurement. Component and mate counts are real:
+        they come from ``insert_component`` and ``add_mate`` this session.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        guard = self._mock_doc_error({"Part", "Assembly"}, "get_model_geometry_summary")
+        if guard is not None:
+            return guard
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        self._operation_count += 1
+
+        is_assembly = self._current_model.type == "Assembly"
+        summary: dict[str, Any] = {
+            "document_type": "assembly" if is_assembly else "part",
+            "volume_mm3": None,
+            "bounding_box_mm": None,
+            "bounding_box_method": None,
+            "solid_body_count": None,
+        }
+        if is_assembly:
+            summary["component_count"] = len(self._components)
+            summary["mate_count"] = len(self._mates)
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=summary,
+            execution_time=self._delays["model_operation"] / 2,
+        )
+
+    # Drawing Operations
+    def _mock_place_view(self, payload: Any) -> AdapterResult[dict[str, Any]]:
+        """Record a drawing view so ``list_drawing_views`` reflects it.
+
+        Args:
+            payload (Any): Tool payload, as the real adapter receives it.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        data = payload if isinstance(payload, dict) else {}
+        model_path = data.get("model_path") or data.get("model_file")
+        if not model_path:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="A model path is required (model_path or model_file)",
+            )
+
+        orientation = str(data.get("orientation") or data.get("view_type") or "front")
+        if orientation.strip().lower() not in _MOCK_NAMED_VIEWS:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown orientation '{orientation}'. Use one of: "
+                    f"{', '.join(sorted(_MOCK_NAMED_VIEWS))}."
+                ),
+            )
+
+        before = len(self._drawing_views)
+        self._drawing_views.append(f"Drawing View{before + 1}")
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": self._drawing_views[-1],
+                "model_path": model_path,
+                "orientation": orientation,
+                "position": {
+                    "x": float(data.get("position_x", 100.0)),
+                    "y": float(data.get("position_y", 150.0)),
+                },
+                "views_before": before,
+                "views_after": len(self._drawing_views),
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def create_drawing_view(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock placing a view of a model on the active drawing sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the model path and orientation.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        return self._mock_place_view(payload)
+
+    async def add_drawing_view(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock adding a view of a model to the active drawing sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the model path and orientation.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        return self._mock_place_view(payload)
+
+    async def create_technical_drawing(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock laying out the three standard views of a model.
+
+        Args:
+            payload (Any): Tool payload carrying the model path and projection.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        data = payload if isinstance(payload, dict) else {}
+        model_path = data.get("model_path") or data.get("model_file")
+        if not model_path:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="A model path is required (model_path or model_file)",
+            )
+
+        third_angle = bool(data.get("third_angle", True))
+        if str(data.get("projection", "")).lower() in {"first", "first_angle"}:
+            third_angle = False
+
+        before = len(self._drawing_views)
+        added = [f"Drawing View{before + offset}" for offset in (1, 2, 3)]
+        self._drawing_views.extend(added)
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "views": added,
+                "model_path": model_path,
+                "projection": "third_angle" if third_angle else "first_angle",
+                "views_before": before,
+                "views_after": len(self._drawing_views),
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def add_note(self, payload: Any = None) -> AdapterResult[dict[str, Any]]:
+        """Mock placing a text note on the active drawing sheet.
+
+        Args:
+            payload (Any): Tool payload carrying the text and position.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        data = payload if isinstance(payload, dict) else {}
+        text = data.get("text")
+        if not text:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="add_note requires text"
+            )
+
+        self._operation_count += 1
+        font_points = float(data.get("font_size") or 0.0)
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "text": text,
+                "position": {
+                    "x": float(data.get("position_x", 100.0)),
+                    "y": float(data.get("position_y", 50.0)),
+                },
+                # The real adapter sets this from IAnnotation::SetPosition's
+                # return. Mock mode has no sheet to place anything on, so it
+                # reports "not determinable" rather than claiming success at a
+                # check it never performed.
+                "positioned": None,
+                "font_size_points": font_points or None,
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def list_drawing_views(self) -> AdapterResult[list[str]]:
+        """Mock listing the views on the active drawing.
+
+        Returns:
+            AdapterResult[list[str]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=list(self._drawing_views),
+            execution_time=self._delays["model_operation"] / 2,
+        )
+
+    async def auto_center_marks(
+        self,
+        view_name: str,
+        mark_holes: bool = True,
+        mark_fillets: bool = False,
+        mark_slots: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock auto-inserting centre marks on a drawing view.
+
+        The mock has no geometry, so it cannot know how many circular
+        features a view holds - it mirrors the live adapter's refusals (not
+        a drawing, no feature type selected, unknown view) and, on a valid
+        request, records a nominal centre-mark increase per view so
+        before/after deltas stay monotonic across calls.
+
+        Args:
+            view_name (str): Name of a view on the active drawing.
+            mark_holes (bool): Mark holes / bores.
+            mark_fillets (bool): Mark fillets.
+            mark_slots (bool): Mark slots.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The view, the feature types acted
+            on, and before/after centre-mark counts, or an error.
+        """
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+
+        model = self._current_model
+        if model is None or getattr(model, "type", None) != "Drawing":
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="auto_center_marks requires an active drawing document",
+            )
+        if not (mark_holes or mark_fillets or mark_slots):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "Select at least one feature type: mark_holes, "
+                    "mark_fillets or mark_slots."
+                ),
+            )
+        if view_name not in self._drawing_views:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"No view named {view_name!r} on the active drawing. "
+                    f"Views: {', '.join(self._drawing_views) or 'none'}"
+                ),
+            )
+
+        self._operation_count += 1
+        before = self._center_marks.get(view_name, 0)
+        # Nominal: two marks per selected feature type, added once.
+        added = 0 if before else 2 * sum((mark_holes, mark_fillets, mark_slots))
+        after = before + added
+        self._center_marks[view_name] = after
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "view": view_name,
+                "feature_types": [
+                    label
+                    for label, on in (
+                        ("holes", mark_holes),
+                        ("fillets", mark_fillets),
+                        ("slots", mark_slots),
+                    )
+                    if on
+                ],
+                "center_marks_before": before,
+                "center_marks_after": after,
+                "center_marks_added": added,
+            },
+            execution_time=self._delays["model_operation"] / 2,
+        )
+
+    async def save_body_as_part(
+        self, body_name: str, file_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock extracting a solid body from the active part to a new file.
+
+        The mock has no bodies, so it cannot validate ``body_name`` against
+        real geometry - it mirrors the live adapter's other refusals (no
+        model, not a part, blank arguments, missing parent directory) and, on
+        a valid request, writes an empty placeholder file so callers and
+        tests can observe the side effect.
+
+        Args:
+            body_name (str): Name of a solid body in the active part.
+            file_path (str): Absolute path for the new ``.sldprt``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The body, the written path, and a
+            single-element body list, or an error.
+        """
+        import os as _os
+
+        await asyncio.sleep(self._delays["model_operation"])
+
+        model = self._current_model
+        if model is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        if getattr(model, "type", None) != "Part":
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="save_body_as_part requires an active part document",
+            )
+        if not str(body_name or "").strip():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="body_name is required"
+            )
+        target = str(file_path or "").strip()
+        if not target:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="file_path is required"
+            )
+        target = _os.path.abspath(target)
+        parent = _os.path.dirname(target)
+        if not _os.path.isdir(parent):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Parent directory does not exist: {parent}",
+            )
+
+        with open(target, "w", encoding="utf-8"):
+            pass
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "body": body_name,
+                "file_path": target,
+                "feature": f"Save Bodies{self._operation_count}",
+                "solid_bodies": [body_name],
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def check_interference(
+        self, params: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock checking the active assembly for interfering components.
+
+        Args:
+            params (Any): Optional settings; ``coincident``, ``components``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        options = params if isinstance(params, dict) else {}
+
+        if len(self._components) < 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "Interference detection needs at least two components; the "
+                    f"assembly has {len(self._components)}."
+                ),
+            )
+
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                # The real adapter gets this from SolidWorks' interference
+                # engine. The mock has no geometry, so it cannot know whether
+                # anything overlaps and says so rather than reporting a clean
+                # assembly it never checked - a mock that always answered
+                # False would make this tool useless wherever mock mode runs.
+                "interference_found": None,
+                "interference_count": None,
+                "interferences": [],
+                "coincident_treated_as_interference": bool(
+                    options.get("coincident", False)
+                ),
+                "scope": "whole assembly",
+                "tolerance_applied": None,
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    # Feature Editing
+    async def delete_feature(self, name: str) -> AdapterResult[dict[str, Any]]:
+        """Mock deleting a named feature from the active model.
+
+        Args:
+            name (str): Feature or sketch name.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+
+        # _features is keyed by an internal id, so resolve by feature name.
+        before = [f.name for f in self._features.values()]
+        key = next((k for k, f in self._features.items() if f.name == name), None)
+        if key is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Feature not found: {name}. "
+                    f"Available: {', '.join(before) or 'none'}"
+                ),
+            )
+
+        del self._features[key]
+        self._suppressed_features.discard(name)
+        self._operation_count += 1
+        after = [f.name for f in self._features.values()]
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "deleted": name,
+                "removed_features": [n for n in before if n not in after],
+                "features_before": len(before),
+                "features_after": len(after),
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def suppress_feature(
+        self, name: str, suppress: bool = True
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock suppressing or unsuppressing a named feature.
+
+        Args:
+            name (str): Feature name.
+            suppress (bool): True to suppress, False to unsuppress.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+
+        known = any(f.name == name for f in self._features.values())
+        if not known:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error=f"Feature not found: {name}"
+            )
+
+        was = name in self._suppressed_features
+        if suppress:
+            self._suppressed_features.add(name)
+        else:
+            self._suppressed_features.discard(name)
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "feature": name,
+                "requested": suppress,
+                "suppressed": bool(suppress),
+                "was_suppressed": was,
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def rename_feature(
+        self, old_name: str, new_name: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock renaming a named feature in the active model.
+
+        Mirrors the real adapter: an empty target name, an unknown feature, or
+        a target name already in use are all errors; renaming to the current
+        name is a no-op success.
+
+        Args:
+            old_name (str): Current feature name.
+            new_name (str): New feature name.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+
+        new = new_name.split("@", 1)[0].strip()
+        if not new:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="new_name must not be empty"
+            )
+
+        key = next((k for k, f in self._features.items() if f.name == old_name), None)
+        if key is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Feature not found: {old_name}",
+            )
+        if new == old_name:
+            return AdapterResult(
+                status=AdapterResultStatus.SUCCESS,
+                data={
+                    "renamed": False,
+                    "old_name": old_name,
+                    "new_name": new,
+                    "reason": "old and new names are the same",
+                },
+                execution_time=self._delays["model_operation"],
+            )
+        if any(f.name == new for f in self._features.values()):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Cannot rename to '{new}': a feature with that name already exists"
+                ),
+            )
+
+        self._features[key].name = new
+        if old_name in self._suppressed_features:
+            self._suppressed_features.discard(old_name)
+            self._suppressed_features.add(new)
+        self._operation_count += 1
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={"renamed": True, "old_name": old_name, "new_name": new},
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def undo(self, count: int = 1) -> AdapterResult[dict[str, Any]]:
+        """Mock undoing the last operations in the active model.
+
+        Removes the most recently added features, mirroring what an undo of
+        feature-creation steps does to the tree. ``tree_changed`` is ``False``
+        when there was nothing left to undo, which is what the real adapter
+        reports too - SolidWorks accepts an undo on an empty stack quietly.
+
+        Args:
+            count (int): Number of steps to undo.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        await asyncio.sleep(self._delays["model_operation"])
+        steps = max(1, int(count))
+
+        keys = list(self._features)
+        before = [self._features[k].name for k in keys]
+        doomed = keys[-steps:] if steps <= len(keys) else list(keys)
+        removed = [self._features[k].name for k in doomed]
+        for key in doomed:
+            self._suppressed_features.discard(self._features[key].name)
+            del self._features[key]
+        self._operation_count += 1
+        after = [f.name for f in self._features.values()]
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "requested_steps": steps,
+                "features_before": len(before),
+                "features_after": len(after),
+                "removed_features": removed,
+                "tree_changed": before != after,
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def add_mate(
+        self,
+        component_a: str,
+        component_b: str,
+        entity_a: str = "Front Plane",
+        entity_b: str = "Front Plane",
+        mate_type: str = "coincident",
+        alignment: str = "aligned",
+        distance: float = 0.0,
+        angle: float = 0.0,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock mating two components in the active assembly.
+
+        Args:
+            component_a (str): First component instance name.
+            component_b (str): Second component instance name.
+            entity_a (str): Named feature on the first component. Defaults to
+                "Front Plane".
+            entity_b (str): Named feature on the second component. Defaults to
+                "Front Plane".
+            mate_type (str): Mate type. Defaults to "coincident".
+            alignment (str): Mate alignment. Defaults to "aligned".
+            distance (float): Distance in millimetres, for a distance mate.
+                Defaults to 0.0.
+            angle (float): Angle in degrees, for an angle mate. Defaults to 0.0.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The result produced by the operation.
+        """
+        known_mate_types = {
+            "coincident",
+            "concentric",
+            "perpendicular",
+            "parallel",
+            "tangent",
+            "distance",
+            "angle",
+        }
+        if mate_type not in known_mate_types:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown mate type '{mate_type}'. "
+                    f"Use one of: {', '.join(sorted(known_mate_types))}."
+                ),
+            )
+
+        await asyncio.sleep(self._delays["model_operation"])
+        self._operation_count += 1
+        self._mates.append(
+            {"mate_type": mate_type, "components": [component_a, component_b]}
+        )
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "mate_type": mate_type,
+                "alignment": alignment,
+                "components": [component_a, component_b],
+                "entities": [entity_a, entity_b],
+                "distance": distance or None,
+                "angle": angle or None,
+                # The real adapter fills these by comparing every component's
+                # Transform2 before and after the mate. The mock has no
+                # geometry to move, so it reports "not determinable" rather
+                # than True: this field exists precisely so a caller can tell
+                # a mate that positioned something from one SolidWorks
+                # accepted and ignored, and a mock that always answers True
+                # would make that check useless wherever mock mode is used.
+                "moved_components": [],
+                "geometry_moved": None,
+            },
+            execution_time=self._delays["model_operation"],
+        )
+
+    async def create_reference_plane(
+        self,
+        reference: str,
+        offset: float = 0.0,
+        angle: float = 0.0,
+        flip: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock creating a reference plane offset from an existing plane.
+
+        Mirrors the live adapter's refusals rather than fabricating a
+        result it cannot know: an angled plane needs a second reference this
+        signature cannot supply, and an offset of zero would be coincident
+        with its reference. See ``_create_reference_plane_impl`` in
+        ``solidworks/features.py`` for the live contract this mirrors.
+
+        On success, invents a sequential ``PlaneN`` name tracked on
+        ``self._reference_planes`` and advances the shared mock feature-tree
+        counter so ``features_before``/``features_after`` differ by exactly
+        one, the same signal the live adapter derives from
+        ``IFeatureManager::GetFeatureCount``.
+
+        Args:
+            reference (str): Name of the reference plane or planar face.
+            offset (float): Offset distance in millimetres. Defaults to 0.0.
+            angle (float): Angle in degrees; unsupported (non-zero errors).
+                Defaults to 0.0.
+            flip (bool): Reverse the offset direction. Defaults to False.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new plane's name and
+            parameters, or error.
+        """
+        if angle:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "create_reference_plane does not support 'angle' yet: an "
+                    "angled plane needs a second reference (an axis or edge "
+                    "to rotate about) which this signature cannot take. Use "
+                    "'offset' for parallel planes."
+                ),
+            )
+
+        if not offset:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "create_reference_plane requires a non-zero offset - a "
+                    "plane coincident with its reference is not useful"
+                ),
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        before = self._feature_tree_count
+        self._feature_tree_count += 1
+        after = self._feature_tree_count
+
+        self._reference_planes.append(f"Plane{len(self._reference_planes) + 1}")
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": self._reference_planes[-1],
+                "reference": reference,
+                "offset": offset,
+                "angle": None,
+                "flip": flip,
+                "features_before": before,
+                "features_after": after,
+            },
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def create_axis(self, reference: str) -> AdapterResult[dict[str, Any]]:
+        """Mock creating a reference axis along a principal direction.
+
+        Mirrors the live adapter's plane-pair mapping (``_AXIS_PLANE_PAIRS``
+        in ``solidworks/features.py``, imported here directly so the two can
+        never drift apart) and validation: only ``x``/``y``/``z``
+        (case-insensitive, leading +/- stripped) are accepted.
+
+        Args:
+            reference (str): "x", "y" or "z" (case-insensitive; leading +/-
+                stripped).
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The plane pair used and the
+            feature counter before/after, or error for an unknown reference.
+        """
+        key = str(reference or "").strip().lower().lstrip("+-")
+        if key not in _AXIS_PLANE_PAIRS:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown axis reference '{reference}'. "
+                    f"Use one of: {', '.join(sorted(_AXIS_PLANE_PAIRS))}."
+                ),
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        before = self._feature_tree_count
+        self._feature_tree_count += 1
+        after = self._feature_tree_count
+
+        plane_a, plane_b = _AXIS_PLANE_PAIRS[key]
+
+        # Invent a sequential "AxisN" name, tracked on self._axes, the same
+        # way create_reference_plane invents "PlaneN" names on
+        # self._reference_planes. InsertAxis2 returns only a bool, so the
+        # live adapter cannot report a name either - but pattern_circular
+        # needs some name to validate the axis argument against, and this
+        # keeps the mock's bookkeeping consistent with the plane convention.
+        self._axes.append(f"Axis{len(self._axes) + 1}")
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": self._axes[-1],
+                "reference": key,
+                "planes": [plane_a, plane_b],
+                "features_before": before,
+                "features_after": after,
+            },
+            execution_time=self._delays["feature_operation"],
+        )
+
+    async def create_reference_point(
+        self,
+        mode: str,
+        x: float,
+        y: float,
+        z: float,
+        distance: float | None = None,
+        percent: float | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock creating a reference point on the active part.
+
+        The mock has no geometry, so it cannot resolve a coordinate to an
+        edge/face - it mirrors the live adapter's *validation* (unknown mode,
+        the distance/percent XOR, range checks) and, on a valid request,
+        bumps the feature counter the way ``InsertReferencePoint`` would.
+
+        Args:
+            mode (str): "along_curve" or "face_center".
+            x (float): X of a point on the target entity, in millimetres.
+            y (float): Y of a point on the target entity, in millimetres.
+            z (float): Z of a point on the target entity, in millimetres.
+            distance (float | None): For "along_curve", offset from the edge
+                start in millimetres.
+            percent (float | None): For "along_curve", 0-100 of edge length.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The mode and feature counts, or an
+            error matching the live adapter's refusals.
+        """
+        key = str(mode or "").strip().lower()
+        if key not in ("along_curve", "face_center"):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(f"Unknown mode {mode!r}. Use 'along_curve' or 'face_center'."),
+            )
+        if key == "along_curve":
+            if (distance is None) == (percent is None):
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error="along_curve needs exactly one of distance or percent",
+                )
+            if distance is not None and float(distance) <= 0.0:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error="distance must be positive",
+                )
+            if percent is not None and not 0.0 < float(percent) < 100.0:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error="percent must be between 0 and 100 (exclusive)",
+                )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+        before = self._feature_tree_count
+        self._feature_tree_count += 1
+        self._reference_points.append(f"Point{len(self._reference_points) + 1}")
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": self._reference_points[-1],
+                "mode": key,
+                "at_mm": [x, y, z],
+                "distance_mm": distance if key == "along_curve" else None,
+                "percent": percent if key == "along_curve" else None,
+                "features_before": before,
+                "features_after": self._feature_tree_count,
+            },
+            execution_time=self._delays["feature_operation"],
+        )
+
+    #: Built-in planes every SolidWorks part starts with. Combined with
+    #: ``self._reference_planes`` (planes created via create_reference_plane)
+    #: this is the set of plane names ``mirror_feature`` will accept.
+    _BUILTIN_PLANES = frozenset({"Front Plane", "Top Plane", "Right Plane"})
+
+    async def mirror_feature(
+        self,
+        features: list[str],
+        mirror_plane: str,
+        merge: bool = True,
+        mirror_bodies: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock mirroring solid bodies or features about a plane.
+
+        The mock has no geometry engine, so it cannot measure a real volume
+        change - it mirrors the live adapter's refusals instead of
+        fabricating a result it cannot know. An empty source list or plane
+        name is rejected outright (matching ``_mirror_feature_impl`` in
+        ``solidworks/features.py`` verbatim), and a source or plane name
+        that was never created in this session is rejected the same way
+        ``_select_named_feature`` / ``_select_reference_entity`` would fail
+        to select it there.
+
+        On success, the tracked ``self._mirror_volume`` figure (seeded at
+        the live-measured 1819569.1 mm^3 wing volume) is doubled, matching
+        the ~2.0 ratio a correct mirror produces (measured live: 1.998528
+        for a lofted wing, exactly 2.0 for a boss whose sketch sits on the
+        plane).
+
+        Args:
+            features (list[str]): Body or feature names to mirror.
+            mirror_plane (str): Plane name to mirror about.
+            merge (bool): Merge the mirrored result with the original. Defaults to True.
+            mirror_bodies (bool): Mirror whole bodies rather than features. Defaults to True.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The mirror feature's name, inputs
+            and volume before/after, or error.
+        """
+        names = [n for n in (features or []) if n]
+        if not names:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="mirror_feature requires at least one body or feature name",
+            )
+        if not mirror_plane:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="mirror_feature requires a mirror plane name",
+            )
+
+        known_sources = {feature.name for feature in self._features.values()} | set(
+            self._components
+        )
+        for name in names:
+            if name not in known_sources:
+                kind = "body" if mirror_bodies else "feature"
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=f"Failed to select {kind} to mirror: {name}",
+                )
+
+        known_planes = self._BUILTIN_PLANES | set(self._reference_planes)
+        if mirror_plane not in known_planes:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Failed to select mirror plane: {mirror_plane}",
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        volume_before = self._mirror_volume
+        volume_after = volume_before * 2
+        self._mirror_volume = volume_after
+
+        self._feature_tree_count += 1
+        feature_name = f"Mirror{self._feature_tree_count}"
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": feature_name,
+                "mirrored": names,
+                "mirror_plane": mirror_plane,
+                "merge": bool(merge),
+                "mirror_bodies": bool(mirror_bodies),
+                "volume_before": volume_before,
+                "volume_after": volume_after,
+                "volume_ratio": round(volume_after / volume_before, 6),
+            },
+            execution_time=self._delays["feature_operation"],
+        )
+
+    #: Live-measured "volume added per extra circular-pattern instance", in
+    #: mm^3: a hub+blade part measured 48431.5 mm3 for hub + 1 blade, and
+    #: 75916.4 mm3 once patterned to 4 blades (3 extra instances) - see
+    #: ``_pattern_circular_impl`` in ``solidworks/features.py``. Dividing the
+    #: growth by the 3 extra instances gives the per-instance figure used
+    #: below to scale ``self._pattern_volume`` by roughly ``count`` without a
+    #: real geometry engine.
+    _PATTERN_BLADE_VOLUME = (75916.4 - 48431.5) / 3
+
+    async def pattern_circular(
+        self,
+        features: list[str],
+        axis: str,
+        count: int,
+        angle: float = 360.0,
+        equal_spacing: bool = True,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock patterning features around an axis.
+
+        The mock has no geometry engine, so it cannot measure a real volume
+        change - it mirrors the live adapter's refusals instead of
+        fabricating a result it cannot know (matching
+        ``_pattern_circular_impl`` in ``solidworks/features.py`` verbatim
+        for the three argument checks below). An axis name that was never
+        created via ``create_axis`` in this session is rejected the same
+        way ``SelectByID2`` would fail to select it there.
+
+        On success, the tracked ``self._pattern_volume`` figure (seeded at
+        the live-measured 48431.5 mm^3 hub+blade volume) grows by
+        ``_PATTERN_BLADE_VOLUME * (count - 1)``, the live-derived
+        per-instance volume, so volume_before/volume_after/volume_ratio
+        stay self-consistent and scale with ``count`` roughly the way
+        adding more blades to the hub would - reproducing the live
+        48431.5 -> 75916.4 mm^3 measurement exactly for ``count=4``.
+
+        Args:
+            features (list[str]): Names of the features to pattern.
+            axis (str): Name of the axis to rotate about.
+            count (int): Total number of instances including the original.
+            angle (float): Total angle in degrees to spread them over. Defaults to 360.0.
+            equal_spacing (bool): Space instances evenly across ``angle``. Defaults to True.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The pattern's name, inputs and
+            volume before/after, or error.
+        """
+        names = [n for n in (features or []) if n]
+        if not names:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="pattern_circular requires at least one feature name",
+            )
+        if not axis:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="pattern_circular requires an axis name to rotate about",
+            )
+        if int(count) < 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"pattern_circular needs a count of at least 2 (got {count}); "
+                    "a pattern of one is just the original feature"
+                ),
+            )
+
+        known_axes = set(self._axes)
+        if axis not in known_axes:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Failed to select axis '{axis}'. Create one with "
+                    "create_axis first, and pass the name it returns."
+                ),
+            )
+
+        await asyncio.sleep(self._delays["feature_operation"])
+        self._operation_count += 1
+
+        volume_before = self._pattern_volume
+        volume_after = volume_before + self._PATTERN_BLADE_VOLUME * (int(count) - 1)
+        self._pattern_volume = volume_after
+
+        self._feature_tree_count += 1
+        pattern_name = f"CirPattern{self._feature_tree_count}"
+
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": pattern_name,
+                "patterned": names,
+                "axis": axis,
+                "count": int(count),
+                "angle": float(angle),
+                "equal_spacing": bool(equal_spacing),
+                "volume_before": volume_before,
+                "volume_after": volume_after,
+                "volume_ratio": round(volume_after / volume_before, 6),
+            },
+            execution_time=self._delays["feature_operation"],
+        )
+
+    # --- Engineering-data and drawing-documentation methods ---
+    # Mirrors SolidWorksDocumentationMixin (solidworks/documentation.py): the
+    # same refusals for wrong document types and unknown views, with
+    # self-consistent state so set/get pairs round-trip.
+
+    _MOCK_MATERIALS: tuple[dict[str, str], ...] = (
+        {
+            "name": "AISI 1020",
+            "classification": "Steel",
+            "database": "solidworks materials",
+        },
+        {
+            "name": "AISI 304",
+            "classification": "Steel",
+            "database": "solidworks materials",
+        },
+        {
+            "name": "6061-T6 (SS)",
+            "classification": "Aluminium Alloys",
+            "database": "solidworks materials",
+        },
+        {
+            "name": "ABS",
+            "classification": "Plastics",
+            "database": "solidworks materials",
+        },
+    )
+    _MOCK_MATERIAL_FOLDER = "mock://sldmaterials"
+
+    def _mock_doc_error(
+        self, allowed: set[str], operation: str
+    ) -> AdapterResult[Any] | None:
+        """Return an error unless the active mock document type is allowed."""
+        model = self._current_model
+        doc_type = getattr(model, "type", None)
+        if model is None or doc_type not in allowed:
+            wanted = " or ".join(sorted(t.lower() for t in allowed))
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"{operation} needs an active {wanted} document",
+            )
+        return None
+
+    def _mock_doc_key(self) -> str:
+        """Key per-document mock state by path, falling back to name."""
+        model = self._current_model
+        return str(
+            getattr(model, "path", "") or getattr(model, "name", "") or "untitled"
+        )
+
+    async def list_model_dimensions(
+        self, feature_name: str | None = None
+    ) -> AdapterResult[list[dict[str, Any]]]:
+        """Mock listing model dimensions from the tracked dimension table."""
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        guard = self._mock_doc_error({"Part", "Assembly"}, "list_model_dimensions")
+        if guard is not None:
+            return guard
+        self._operation_count += 1
+        dims = []
+        for full_name, value in self._dimensions.items():
+            feature = full_name.split("@", 1)[1] if "@" in full_name else ""
+            if feature_name and feature.lower() != feature_name.lower():
+                continue
+            dims.append(
+                {
+                    "full_name": full_name,
+                    "feature": feature,
+                    "value": value,
+                    "system_value": value / 1000.0,
+                    "read_only": False,
+                }
+            )
+        if feature_name and not dims:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"No dimensions found on feature {feature_name!r}",
+            )
+        return AdapterResult(status=AdapterResultStatus.SUCCESS, data=dims)
+
+    async def measure_entities(
+        self, entities: list[str]
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock measuring: nominal values with the live adapter's validation."""
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        guard = self._mock_doc_error({"Part", "Assembly"}, "measure_entities")
+        if guard is not None:
+            return guard
+        if not entities or len(entities) > 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="measure_entities takes one or two entity specs",
+            )
+        self._operation_count += 1
+        data: dict[str, Any] = {"selected": list(entities)}
+        if len(entities) == 1:
+            data.update({"area_m2": 0.0025, "perimeter_m": 0.2})
+        else:
+            data.update({"distance_m": 0.05, "angle_rad": 0.0, "is_parallel": True})
+        return AdapterResult(status=AdapterResultStatus.SUCCESS, data=data)
+
+    async def get_material(
+        self, configuration: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock reading the active part material."""
+        guard = self._mock_doc_error({"Part"}, "get_material")
+        if guard is not None:
+            return guard
+        assigned = getattr(self, "_materials", {}).get(self._mock_doc_key())
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "material": assigned["name"] if assigned else None,
+                "database": assigned["database"] if assigned else None,
+                "configuration": configuration,
+            },
+        )
+
+    async def set_material(
+        self,
+        material_name: str,
+        database: str | None = None,
+        configuration: str | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock assigning a material; unknown names fail as they do live."""
+        guard = self._mock_doc_error({"Part"}, "set_material")
+        if guard is not None:
+            return guard
+        wanted = material_name.strip().lower()
+        match = next(
+            (m for m in self._MOCK_MATERIALS if m["name"].lower() == wanted), None
+        )
+        if match is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Material {material_name!r} not found in "
+                    f"{database or 'SOLIDWORKS Materials'!r}; use "
+                    "list_available_materials for the exact name and library."
+                ),
+            )
+        if not hasattr(self, "_materials"):
+            self._materials: dict[str, dict[str, str]] = {}
+        self._materials[self._mock_doc_key()] = match
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "material": match["name"],
+                "database": database or "SOLIDWORKS Materials",
+                "configuration": configuration,
+            },
+        )
+
+    async def list_available_materials(
+        self, search: str | None = None
+    ) -> AdapterResult[list[dict[str, str]]]:
+        """Mock listing the material library, with the live ``metadata``."""
+        needle = (search or "").strip().lower()
+        items = [
+            dict(m)
+            for m in self._MOCK_MATERIALS
+            if not needle
+            or needle in m["name"].lower()
+            or needle in m["classification"].lower()
+        ]
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=items,
+            metadata={
+                "folders": [self._MOCK_MATERIAL_FOLDER],
+                "total": len(self._MOCK_MATERIALS),
+            },
+        )
+
+    async def get_custom_properties(
+        self, configuration: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock reading custom properties."""
+        if self._current_model is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        store = getattr(self, "_custom_properties", {})
+        props = store.get((self._mock_doc_key(), configuration or ""), {})
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "configuration": configuration or "",
+                "properties": {
+                    k: {"value": v, "resolved": v} for k, v in props.items()
+                },
+            },
+        )
+
+    async def set_custom_property(
+        self, name: str, value: str, configuration: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock writing one custom property."""
+        if self._current_model is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        if not name.strip():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="name is required"
+            )
+        if not hasattr(self, "_custom_properties"):
+            self._custom_properties: dict[tuple[str, str], dict[str, str]] = {}
+        key = (self._mock_doc_key(), configuration or "")
+        self._custom_properties.setdefault(key, {})[name] = str(value)
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "name": name,
+                "value": str(value),
+                "resolved": str(value),
+                "configuration": configuration or "",
+            },
+        )
+
+    async def export_flat_pattern(
+        self, file_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock flat-pattern export: validates the target, writes nothing."""
+        guard = self._mock_doc_error({"Part"}, "export_flat_pattern")
+        if guard is not None:
+            return guard
+        if not file_path.lower().endswith((".dxf", ".dwg")):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="file_path must end in .dxf or .dwg",
+            )
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={"file_path": file_path, "size_bytes": 0, "mock": True},
+        )
+
+    async def insert_model_dimensions(
+        self, view_name: str | None = None, include_hole_wizard: bool = True
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock importing model dimensions: three per view, never twice.
+
+        Mirrors the live result shape (``views``, ``dimensions_added``,
+        ``unique_dimensions``, ``skipped_pictorial_views``, ``method``,
+        ``autodimension_status``) and its refusals.
+        """
+        await asyncio.sleep(self._delays["model_operation"] / 2)
+        guard = self._mock_doc_error({"Drawing"}, "insert_model_dimensions")
+        if guard is not None:
+            return guard
+        names = [view_name] if view_name else list(self._drawing_views)
+        unknown = [n for n in names if n not in self._drawing_views]
+        if unknown or not names:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"No view named {unknown[0]!r}. Views: "
+                    f"{', '.join(self._drawing_views) or 'none'}"
+                    if unknown
+                    else "No drawing views found to dimension; add views with "
+                    "create_technical_drawing or create_drawing_view"
+                ),
+            )
+        if not hasattr(self, "_view_dimensions"):
+            self._view_dimensions: dict[str, int] = {}
+        per_view = []
+        for name in names:
+            before = self._view_dimensions.get(name, 0)
+            after = before or 3
+            self._view_dimensions[name] = after
+            per_view.append(
+                {
+                    "view": name,
+                    "dimensions_before": before,
+                    "dimensions_after": after,
+                    "dimensions_added": after - before,
+                    "duplicates_removed": 0,
+                }
+            )
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "views": per_view,
+                "dimensions_added": sum(v["dimensions_added"] for v in per_view),
+                "unique_dimensions": sum(self._view_dimensions.values()),
+                "skipped_pictorial_views": [],
+                "method": "insert_model_annotations",
+                "autodimension_status": None,
+            },
+        )
+
+    async def arrange_dimensions(
+        self, view_name: str | None = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock arranging drawing dimensions: reports a clean layout."""
+        guard = self._mock_doc_error({"Drawing"}, "arrange_dimensions")
+        if guard is not None:
+            return guard
+        if view_name and view_name not in self._drawing_views:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"No view named {view_name!r}. Views: "
+                    f"{', '.join(self._drawing_views) or 'none'}"
+                ),
+            )
+        counts = getattr(self, "_view_dimensions", {})
+        total = sum(n for v, n in counts.items() if not view_name or v == view_name)
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "dimensions": total,
+                "moved": total,
+                "unplaced": [],
+                "overlaps_before": total,
+                "overlaps_after": 0,
+                "remaining_overlaps": [],
+                "sheet_size_m": [0.42, 0.297],
+            },
+        )
+
+    async def insert_bom_table(
+        self,
+        view_name: str,
+        template_path: str | None = None,
+        bom_type: str = "top_level_only",
+        x_mm: float | None = None,
+        y_mm: float | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock inserting a BOM table."""
+        guard = self._mock_doc_error({"Drawing"}, "insert_bom_table")
+        if guard is not None:
+            return guard
+        if bom_type not in {"top_level_only", "parts_only", "indented"}:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="bom_type must be top_level_only, parts_only or indented",
+            )
+        if view_name not in self._drawing_views:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"No view named {view_name!r}. Views: "
+                    f"{', '.join(self._drawing_views) or 'none'}"
+                ),
+            )
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "view": view_name,
+                "bom_type": bom_type,
+                "template": template_path,
+                "row_count": 2,
+                "table_box_mm": [0.0, 0.0, 60.0, 15.0],
+                "moved_onto_sheet": False,
+            },
+        )
+
+    async def add_gtol(
+        self,
+        characteristic: str,
+        tolerance: float,
+        x_mm: float,
+        y_mm: float,
+        diameter_zone: bool = False,
+        material_condition: str = "none",
+        datums: list[str] | None = None,
+        attach_at_mm: tuple[float, float] | None = None,
+        dimension: tuple[str, str] | None = None,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock adding a feature control frame; refuses what the real one refuses."""
+        guard = self._mock_doc_error({"Drawing"}, "add_gtol")
+        if guard is not None:
+            return guard
+        problem = gtol_problem(characteristic, tolerance, material_condition, datums)
+        if problem is not None:
+            return AdapterResult(status=AdapterResultStatus.ERROR, error=problem)
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "characteristic": characteristic,
+                "tolerance": f"{tolerance:g}",
+                "diameter_zone": diameter_zone,
+                "material_condition": material_condition,
+                "datums": [d.strip().upper() for d in datums or []],
+                "attached": (
+                    dimension[1] if dimension is not None else attach_at_mm is not None
+                ),
+                "position_mm": None if dimension is not None else [x_mm, y_mm],
+                "layout": None,
+            },
+        )
+
+    async def add_datum_tag(
+        self,
+        label: str,
+        attach_at_mm: tuple[float, float],
+        x_mm: float,
+        y_mm: float,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock adding a datum tag; refuses what the real one refuses."""
+        guard = self._mock_doc_error({"Drawing"}, "add_datum_tag")
+        if guard is not None:
+            return guard
+        letter = label.strip().upper()
+        if len(letter) != 1 or not letter.isalpha():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="label must be a single letter, e.g. 'A'",
+            )
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={"label": letter, "position_mm": [x_mm, y_mm]},
+        )
+
+    async def set_sheet_scale(
+        self, numerator: float, denominator: float
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock setting the sheet scale."""
+        guard = self._mock_doc_error({"Drawing"}, "set_sheet_scale")
+        if guard is not None:
+            return guard
+        if numerator <= 0 or denominator <= 0:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Scale values must be positive"
+            )
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "sheet": "Sheet1",
+                "scale": f"{numerator:g}:{denominator:g}",
+                "requested": f"{numerator:g}:{denominator:g}",
+            },
+        )
+
+    async def create_standard_drawing(
+        self,
+        model_path: str,
+        output_dir: str | None = None,
+        title: str | None = None,
+        subtitle: str | None = None,
+        drawing_number: str | None = None,
+        author: str = "",
+        revision: str = "A",
+        company: str = "",
+        drawn_date: str | None = None,
+        notes: list[str] | None = None,
+        include_isometric: bool = True,
+        write_model_properties: bool = True,
+        title_block_text_height_mm: float | None = None,
+        include_bom: bool = False,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Mock standard A3 drawing: validates inputs, writes nothing to disk."""
+        if not os.path.isfile(model_path):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Model file not found: {model_path}",
+            )
+        stem = os.path.splitext(os.path.basename(model_path))[0]
+        number = drawing_number or f"{stem.upper().replace(' ', '-')}-Rev{revision}-01"
+        out_dir = output_dir or os.path.dirname(model_path)
+        views = {
+            "Drawing View1": {"role": "front", "caption": "FRONT VIEW"},
+            "Drawing View2": {"role": "plan", "caption": "TOP VIEW"},
+            "Drawing View3": {"role": "side", "caption": "SIDE VIEW"},
+        }
+        if include_isometric:
+            views["Drawing View4"] = {"role": "iso", "caption": "ISOMETRIC VIEW"}
+        self._operation_count += 1
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data={
+                "scale": "1:1",
+                "isometric_scale": "1:1" if include_isometric else None,
+                "views": views,
+                "hidden_lines_visible": {
+                    n: True for n, v in views.items() if v["role"] != "iso"
+                },
+                "bom": {"bom_type": "top_level_only", "table_box_mm": None}
+                if include_bom
+                else None,
+                "overlap_check": {"overlaps_after": 0, "annotation_overlaps": []},
+                "drawing_number": number,
+                "drawing_path": os.path.join(out_dir, f"{number}.SLDDRW"),
+                "pdf_path": os.path.join(out_dir, f"{number}.pdf"),
+                "properties_written": {
+                    "model": {"Description": title or stem}
+                    if write_model_properties
+                    else {},
+                    "drawing": {"DrawnBy": author, "Revision": revision},
+                },
+                "notes": ["NOTES", *[n.upper() for n in (notes or [])]],
+                "title_block": {
+                    "drawing number": {"found": True, "fits": True},
+                    "title": {"found": True, "fits": True},
+                },
+                "mock": True,
+            },
+        )