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

solidworks_mcp/adapters/solidworks/io.py

@@ -0,0 +1,3649 @@
+"""Model I/O mixin for PyWin32 SolidWorks operations."""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import re
+import shutil
+import uuid
+from datetime import datetime
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, cast
+
+from .. import sw_type_info as _sw_type_info
+from ..base import AdapterResult, AdapterResultStatus, MassProperties, SolidWorksModel
+
+try:
+    import pythoncom
+    import win32com.client
+    import win32com.client.dynamic as _dynamic
+except ImportError:
+    pythoncom = SimpleNamespace()
+    win32com = SimpleNamespace(client=SimpleNamespace())
+    _dynamic = SimpleNamespace(Dispatch=lambda *_a, **_kw: None)
+
+try:
+    import comtypes  # type: ignore[import-untyped]
+    import comtypes.client as _comtypes_client  # type: ignore[import-untyped]
+
+    _COMTYPES_AVAILABLE = True
+except ImportError:
+    _COMTYPES_AVAILABLE = False
+
+# SolidWorks type library GUID (stable across SW versions)
+_SW_TLB_GUID = "{83A33D31-27C5-11CE-BFD4-00400513BB57}"
+# Cached comtypes wrapper module (loaded once per process)
+_sw_comtypes_lib: Any = None
+
+
+def _get_sw_comtypes_lib() -> Any:
+    """Return the comtypes wrapper for the SolidWorks type library.
+
+    Tries SW version numbers 35..30 (newest to oldest). Returns ``None`` when
+    comtypes is unavailable or the TLB cannot be found in the registry.
+    """
+    global _sw_comtypes_lib
+    if _sw_comtypes_lib is not None:
+        return _sw_comtypes_lib
+    if not _COMTYPES_AVAILABLE:
+        return None
+    for major in (35, 34, 33, 32, 31, 30):
+        try:
+            _sw_comtypes_lib = _comtypes_client.GetModule(
+                (comtypes.GUID(_SW_TLB_GUID), major, 0)
+            )
+            return _sw_comtypes_lib
+        except Exception:
+            continue
+    return None
+
+
+def _bridge_com_to_comtypes(pywin32_obj: Any, iface: Any) -> Any:
+    """Bridge a pywin32 CDispatch/COM object to a comtypes interface pointer.
+
+    Extracts the raw IUnknown pointer from pywin32's repr string, then
+    QueryInterface-es for *iface* via comtypes.  The AddRef keeps the object
+    alive through the Python reference.
+    """
+    unk = pywin32_obj._oleobj_.QueryInterface(pythoncom.IID_IUnknown)
+    m = re.search(r"obj at (0x[0-9a-fA-F]+)", repr(unk))
+    if not m:
+        raise RuntimeError(f"Could not extract COM pointer from {repr(unk)!r}")
+    ptr_int = int(m.group(1), 16)
+    ct_unk = ctypes.cast(ptr_int, ctypes.POINTER(comtypes.IUnknown))
+    ct_unk.AddRef()
+    return ct_unk.QueryInterface(iface)
+
+
+_MATE_TYPES: dict[str, int] = {
+    "coincident": 0,
+    "concentric": 1,
+    "perpendicular": 2,
+    "parallel": 3,
+    "tangent": 4,
+    "distance": 5,
+    "angle": 6,
+}
+
+
+_MATE_ALIGNMENTS: dict[str, int] = {
+    "aligned": 0,
+    "anti_aligned": 1,
+    "closest": 2,
+}
+
+
+#: ``swDwgTemplates_e`` / ``swDwgPaperSizes_e`` values (read from swconst.tlb).
+_SW_DWG_TEMPLATE_NONE = 13
+_SW_DWG_PAPER_A_SIZE = 0
+_SW_DWG_PAPERS_USER_DEFINED = 12
+
+
+#: SolidWorks named views. The leading asterisk is part of the name and
+#: ``CreateDrawViewFromModelView3`` rejects the name without it.
+_NAMED_VIEWS: dict[str, str] = {
+    "front": "*Front",
+    "back": "*Back",
+    "left": "*Left",
+    "right": "*Right",
+    "top": "*Top",
+    "bottom": "*Bottom",
+    "isometric": "*Isometric",
+    "iso": "*Isometric",
+    "trimetric": "*Trimetric",
+    "dimetric": "*Dimetric",
+    "current": "*Current",
+}
+
+
+#: Points to millimetres. Note schemas express text height in points.
+_POINTS_TO_MM = 25.4 / 72.0
+
+
+def _payload(data: Any) -> dict[str, Any]:
+    """Coerce a tool payload into a plain dict.
+
+    The drawing tools hand the adapter either a ``model_dump()`` result or a
+    raw dict, depending on the tool. Accept a Pydantic model too, so a direct
+    adapter call from a test or script behaves the same as one through a tool.
+
+    Args:
+        data: A dict, a Pydantic model, or an object with attributes.
+
+    Returns:
+        dict[str, Any]: The payload as a dict; empty when nothing was given.
+    """
+    if data is None:
+        return {}
+    if isinstance(data, dict):
+        return data
+    dump = getattr(data, "model_dump", None)
+    if callable(dump):
+        return cast("dict[str, Any]", dump())
+    return {key: value for key, value in vars(data).items() if not key.startswith("_")}
+
+
+def _first(payload: dict[str, Any], *keys: str, default: Any = None) -> Any:
+    """Return the first key present and not None.
+
+    The drawing tools disagree on field names for the same thing — a model is
+    ``model_path`` on one schema and ``model_file`` on another — so each
+    adapter method accepts every spelling its callers use.
+
+    Args:
+        payload: The tool payload.
+        *keys: Candidate key names, in priority order.
+        default: Returned when no key is present.
+
+    Returns:
+        Any: The first value found, otherwise ``default``.
+    """
+    for key in keys:
+        value = payload.get(key)
+        if value is not None:
+            return value
+    return default
+
+
+def _view_names(adapter: Any, drawing: Any) -> list[str]:
+    """Return the drawing's view names, excluding sheet formats.
+
+    ``CreateDrawViewFromModelView3`` returns ``None`` for a model SolidWorks
+    could not resolve, and ``Create3rdAngleViews2`` returns a bare boolean, so
+    the view list is the ground truth for whether views were really added.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        drawing: The drawing document, flagged for ``IDrawingDoc``.
+
+    Returns:
+        list[str]: View names in sheet order.
+    """
+    sheets = adapter._attempt(lambda: drawing.GetViews(), default=None)
+    if not isinstance(sheets, (list, tuple)):
+        return []
+
+    names: list[str] = []
+    for sheet in sheets:
+        views = sheet if isinstance(sheet, (list, tuple)) else [sheet]
+        for index, view in enumerate(views):
+            # GetViews returns (sheet, view, view, ...) per sheet; entry 0 is
+            # the sheet itself, not a drawing view.
+            if index == 0 and isinstance(sheet, (list, tuple)):
+                continue
+            wrapped = _as_com(adapter, view, "IView")
+            if wrapped is None:
+                continue
+            name = adapter._attempt(lambda w=wrapped: w.GetName2(), default=None)
+            if name:
+                names.append(str(name))
+    return names
+
+
+def _component_transforms(adapter: Any, assembly: Any) -> dict[str, tuple[float, ...]]:
+    """Snapshot every component's placement, for before/after comparison.
+
+    ``IComponent2.Transform2`` is the component's position relative to the
+    assembly root, as a ``MathTransform`` whose ``ArrayData`` is 16 doubles
+    (a 3x3 rotation, a translation, and a scale). Comparing the snapshot
+    before and after a mate is what distinguishes a mate that actually
+    positioned geometry from one that SolidWorks accepted and ignored.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        assembly: The ``IAssemblyDoc`` dispatch to snapshot.
+
+    Returns:
+        dict[str, tuple[float, ...]]: Component name to transform matrix.
+        Components whose transform cannot be read are omitted rather than
+        recorded as unchanged — an unreadable transform is not evidence of
+        anything, and treating it as "same" would fake a passing comparison.
+    """
+    snapshot: dict[str, tuple[float, ...]] = {}
+    for name, component in _component_pairs(adapter, assembly):
+        if component is None:
+            continue
+        transform = adapter._attempt(lambda c=component: c.Transform2, default=None)
+        if transform is None:
+            continue
+        data = adapter._attempt(lambda t=transform: t.ArrayData, default=None)
+        if not isinstance(data, (list, tuple)):
+            continue
+        try:
+            snapshot[name] = tuple(round(float(value), 9) for value in data)
+        except (TypeError, ValueError):
+            continue
+    return snapshot
+
+
+class _ByrefFallback:
+    """Stand-in for a byref VARIANT when pywin32 is unavailable.
+
+    The callers' contract for a byref holder is "an object whose ``.value``
+    the COM call fills in". Returning a bare ``0`` or ``""`` broke that: on any
+    machine without pywin32 (Linux CI, mock runs) ``_read_material_name`` could
+    never read its database out-parameter back, so it silently reported
+    ``None``. This keeps the contract on both platforms.
+    """
+
+    __slots__ = ("value",)
+
+    def __init__(self, value: Any) -> None:
+        self.value = value
+
+    def __eq__(self, other: Any) -> bool:
+        """Compare equal to the seeded value, so callers can treat it as one."""
+        if isinstance(other, _ByrefFallback):
+            return bool(self.value == other.value)
+        return bool(self.value == other)
+
+    def __hash__(self) -> int:
+        """Hash as the seeded value."""
+        return hash(self.value)
+
+    def __bool__(self) -> bool:
+        """Truthiness follows the seeded value."""
+        return bool(self.value)
+
+    def __repr__(self) -> str:
+        """Show the seeded value for readable assertion output."""
+        return f"_ByrefFallback({self.value!r})"
+
+
+def _byref_bstr() -> Any:
+    """Return a byref string VARIANT for a SolidWorks ``String`` out-parameter.
+
+    Under forced late binding an omitted out-parameter raises "Parameter not
+    optional", and ``pythoncom.Missing`` cannot be converted to a COM VARIANT,
+    so pass ``VARIANT(VT_BYREF | VT_BSTR, "")`` and read ``.value`` afterwards
+    (e.g. ``IPartDoc::GetMaterialPropertyName2``'s ``Database``; confirmed live
+    on R2026x).
+
+    Returns:
+        Any: The byref VARIANT, or a ``_ByrefFallback("")`` without pywin32.
+    """
+    variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+    if not callable(variant_ctor):
+        return _ByrefFallback("")
+    return variant_ctor(
+        int(getattr(pythoncom, "VT_BYREF", 0)) | int(getattr(pythoncom, "VT_BSTR", 0)),
+        "",
+    )
+
+
+def _byref_int() -> Any:
+    """Return a byref long VARIANT for a SolidWorks out-parameter.
+
+    See :func:`_byref_bstr` for why ``pythoncom.Missing`` does not work.
+
+    Returns:
+        Any: A ``VARIANT(VT_BYREF | VT_I4, 0)``, or ``0`` when pywin32 is
+        unavailable (test/mock environments).
+    """
+    variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+    if not callable(variant_ctor):
+        return _ByrefFallback(0)
+    return variant_ctor(
+        int(getattr(pythoncom, "VT_BYREF", 0)) | int(getattr(pythoncom, "VT_I4", 0)), 0
+    )
+
+
+def _byref_variant() -> Any:
+    """Return a byref VARIANT for an array/variant out-parameter.
+
+    ``IModelDocExtension::GetWhatsWrong`` fills three of these (features,
+    error codes, warning flags); confirmed live on R2026x that late binding
+    accepts ``VARIANT(VT_BYREF | VT_VARIANT, None)`` and exposes the result on
+    ``.value``. ``pythoncom.Missing`` is rejected ("can not be converted to a
+    COM VARIANT").
+
+    Returns:
+        Any: The byref VARIANT, or a ``_ByrefFallback(None)`` without pywin32.
+    """
+    variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+    if not callable(variant_ctor):
+        return _ByrefFallback(None)
+    return variant_ctor(
+        int(getattr(pythoncom, "VT_BYREF", 0))
+        | int(getattr(pythoncom, "VT_VARIANT", 0)),
+        None,
+    )
+
+
+def _byref_bool() -> Any:
+    """Return a byref bool VARIANT (e.g. ``IFeature::GetErrorCode2(IsWarning)``).
+
+    Returns:
+        Any: The byref VARIANT, or a ``_ByrefFallback(False)`` without pywin32.
+    """
+    variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+    if not callable(variant_ctor):
+        return _ByrefFallback(False)
+    return variant_ctor(
+        int(getattr(pythoncom, "VT_BYREF", 0)) | int(getattr(pythoncom, "VT_BOOL", 0)),
+        False,
+    )
+
+
+def _byref_double() -> Any:
+    """Return a byref double VARIANT for a SolidWorks ``Double`` out-parameter.
+
+    ``IBody2::GetExtremePoint`` reports its point through three of these. See
+    :func:`_byref_bstr` for why ``pythoncom.Missing`` does not work.
+
+    Returns:
+        Any: A ``VARIANT(VT_BYREF | VT_R8, 0.0)``, or a ``_ByrefFallback(0.0)``
+        without pywin32.
+    """
+    variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+    if not callable(variant_ctor):
+        return _ByrefFallback(0.0)
+    return variant_ctor(
+        int(getattr(pythoncom, "VT_BYREF", 0)) | int(getattr(pythoncom, "VT_R8", 0)),
+        0.0,
+    )
+
+
+def _doc_type(adapter: Any) -> int | None:
+    """Return the active document's type: 1 part, 2 assembly, 3 drawing.
+
+    ``GetType`` is one of the members pywin32 late binding may expose as either
+    a bound method or a plain value, so calling it directly returns ``None`` on
+    some documents.  ``_get_attr_or_call`` handles both shapes.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+
+    Returns:
+        int | None: The document type, or ``None`` when it cannot be read.
+    """
+    value = adapter._attempt(
+        lambda: adapter._get_attr_or_call(adapter.currentModel, "GetType"),
+        default=None,
+    )
+    return int(value) if isinstance(value, (int, float)) else None
+
+
+def _payload_dict(data: Any) -> dict[str, Any]:
+    """Coerce a tool payload into a plain dict.
+
+    ``tools/analysis.py`` hands the adapter ``input_data.model_dump()``, but a
+    direct call from a test or script may pass the model itself or nothing.
+
+    Args:
+        data: A dict, a Pydantic model, or ``None``.
+
+    Returns:
+        dict[str, Any]: The payload as a dict; empty when nothing was given.
+    """
+    if data is None:
+        return {}
+    if isinstance(data, dict):
+        return data
+    dump = getattr(data, "model_dump", None)
+    if callable(dump):
+        return cast("dict[str, Any]", dump())
+    return {key: value for key, value in vars(data).items() if not key.startswith("_")}
+
+
+def _interference_details(adapter: Any, interferences: Any) -> list[dict[str, Any]]:
+    """Describe each interference: the components involved and the overlap.
+
+    ``IInterference::Volume`` is in cubic metres and is converted to mm^3 to
+    match every other volume this adapter reports.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        interferences: The sequence returned by ``GetInterferences``.
+
+    Returns:
+        list[dict[str, Any]]: One entry per interference. Empty when the
+        sequence is absent, which is what SolidWorks returns for a clean
+        assembly.
+    """
+    if not isinstance(interferences, (list, tuple)):
+        return []
+
+    details: list[dict[str, Any]] = []
+    for item in interferences:
+        wrapped = _as_com(adapter, item, "IInterference")
+        if wrapped is None:
+            continue
+
+        volume_m3 = adapter._attempt(lambda w=wrapped: w.Volume, default=None)
+        try:
+            volume_mm3 = (
+                round(float(volume_m3) * 1e9, 6) if volume_m3 is not None else None
+            )
+        except (TypeError, ValueError):
+            volume_mm3 = None
+
+        component_count = adapter._attempt(
+            lambda w=wrapped: w.GetComponentCount(), default=None
+        )
+        # ``Components`` is a property, not a method. ``GetComponents()``
+        # does not exist on IInterference and ``IGetComponents(n)`` rejects
+        # its own documented argument with "Invalid number of parameters".
+        raw_components = adapter._attempt(lambda w=wrapped: w.Components, default=None)
+
+        names: list[str] = []
+        if isinstance(raw_components, (list, tuple)):
+            for component in raw_components:
+                comp = _as_com(adapter, component, "IComponent2")
+                if comp is None:
+                    continue
+                name = adapter._attempt(lambda c=comp: c.Name2, default=None)
+                names.append(str(name) if name else "<unnamed>")
+
+        details.append(
+            {
+                "components": names,
+                "component_count": int(component_count)
+                if component_count
+                else len(names),
+                "volume_mm3": volume_mm3,
+            }
+        )
+    return details
+
+
+def _component_pairs(adapter: Any, assembly: Any) -> list[tuple[str, Any]]:
+    """Return an assembly's top-level components as ``(name, dispatch)``.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        assembly: The assembly document, flagged for ``IAssemblyDoc``.
+
+    Returns:
+        list[tuple[str, Any]]: Component name and its ``IComponent2``
+        dispatch. A component whose dispatch cannot be wrapped is reported
+        as ``("<unnamed>", None)`` so callers still see the correct count.
+    """
+    components = adapter._attempt(lambda: assembly.GetComponents(True), default=None)
+    if not isinstance(components, (list, tuple)):
+        return []
+
+    pairs: list[tuple[str, Any]] = []
+    for component in components:
+        wrapped = _as_com(adapter, component, "IComponent2")
+        if wrapped is None:
+            pairs.append(("<unnamed>", None))
+            continue
+        name = adapter._attempt(lambda c=wrapped: c.Name2, default=None)
+        if not name:
+            name = adapter._attempt(lambda c=wrapped: c.GetPathName(), default=None)
+        pairs.append((str(name) if name else "<unnamed>", wrapped))
+    return pairs
+
+
+def _component_names(adapter: Any, assembly: Any) -> list[str]:
+    """Return the names of an assembly's top-level components.
+
+    ``AddComponent*`` can return an object having added nothing, so the
+    component list is the ground truth for whether an insert worked.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        assembly: The assembly document, flagged for ``IAssemblyDoc``.
+
+    Returns:
+        list[str]: Component names, empty when the assembly holds none.
+    """
+    return [name for name, _ in _component_pairs(adapter, assembly)]
+
+
+def _as_com(adapter: Any, obj: Any, interface: str) -> Any:
+    """Wrap a raw dispatch and flag its methods for an interface.
+
+    Objects handed back inside arrays (``GetViews`` and friends) arrive as raw
+    ``PyIDispatch``.  Method flagging is a no-op on those, so every call
+    against them raises until they are wrapped through ``dynamic.Dispatch``.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        obj: The raw dispatch.
+        interface: Interface name, e.g. ``"IView"``.
+
+    Returns:
+        Any: The wrapped, flagged object, or ``None``.
+    """
+    wrapped = adapter._attempt(lambda: _dynamic.Dispatch(obj), default=None)
+    if wrapped is None:
+        return None
+    adapter._attempt(
+        lambda: _sw_type_info.flag_methods(wrapped, interface), default=None
+    )
+    return wrapped
+
+
+# --- Document unit system -------------------------------------------------
+# swUserPreferenceIntegerValue_e - values transcribed from swconst.tlb on a
+# live SW 2026 (3DEXPERIENCE R2026x) install; the published API help does not
+# print the integers and they are NOT the "obvious" small numbers.
+_SW_PREF_UNIT_SYSTEM = 263
+_SW_PREF_UNITS_LINEAR = 47
+_SW_PREF_UNITS_LINEAR_DECIMALS = 49
+# swUserPreferenceOption_e.swDetailingNoOptionSpecified
+_SW_PREF_OPTION_NONE = 0
+# swUnitSystem_e.swUnitSystem_Custom
+_SW_UNIT_SYSTEM_CUSTOM = 4
+
+# unit-system token -> (swUnitSystem_e, swLengthUnit_e)
+#   swUnitSystem_e: CGS=1 MKS=2 IPS=3 Custom=4 MMGS=5
+#   swLengthUnit_e: swMM=0 swCM=1 swMETER=2 swINCHES=3 swFEET=4
+_SW_UNIT_SYSTEMS: dict[str, tuple[int, int]] = {
+    "mm": (5, 0),
+    "cm": (1, 1),
+    "m": (2, 2),
+    "in": (3, 3),
+    "ft": (4, 4),
+}
+# Accepted aliases normalised to the canonical token above.
+_SW_UNIT_ALIASES: dict[str, str] = {
+    "mm": "mm",
+    "millimeter": "mm",
+    "millimeters": "mm",
+    "millimetre": "mm",
+    "millimetres": "mm",
+    "cm": "cm",
+    "centimeter": "cm",
+    "centimeters": "cm",
+    "m": "m",
+    "meter": "m",
+    "meters": "m",
+    "metre": "m",
+    "metres": "m",
+    "in": "in",
+    "inch": "in",
+    "inches": "in",
+    '"': "in",
+    "ft": "ft",
+    "foot": "ft",
+    "feet": "ft",
+    "'": "ft",
+}
+
+
+def _normalise_unit_system(unit_system: str) -> str | None:
+    """Map a user-supplied unit token onto a canonical key of ``_SW_UNIT_SYSTEMS``.
+
+    Args:
+        unit_system: e.g. ``"mm"``, ``"inch"``, ``"Millimeters"``.
+
+    Returns:
+        str | None: ``"mm" | "cm" | "m" | "in" | "ft"``, or ``None`` when
+        the token is not recognised.
+    """
+    return _SW_UNIT_ALIASES.get((unit_system or "").strip().lower())
+
+
+def _pref_int(adapter: Any, ext: Any, pref: int) -> int | None:
+    """Read one ``IModelDocExtension`` integer user preference.
+
+    Args:
+        adapter: A connected adapter (for ``_attempt``).
+        ext: The document's ``IModelDocExtension`` dispatch.
+        pref: A ``swUserPreferenceIntegerValue_e`` value.
+
+    Returns:
+        int | None: The preference value, or ``None`` when the COM call
+        fails or returns a non-numeric result.
+    """
+    value = adapter._attempt(
+        lambda: ext.GetUserPreferenceInteger(pref, _SW_PREF_OPTION_NONE),
+        default=None,
+    )
+    return int(value) if isinstance(value, (int, float)) else None
+
+
+def _apply_unit_system(adapter: Any, model: Any, unit_system: str) -> dict[str, Any]:
+    """Set a document's linear unit system and confirm it actually took.
+
+    ``IModelDocExtension::SetUserPreferenceInteger`` accepts the
+    ``swUnitSystem`` write and returns quietly even on builds where the
+    document's unit system does not move (observed on SW 2026 / 3DEXPERIENCE
+    against an assembly). The change is therefore verified by reading the
+    *unit-system preference itself* (``swUnitSystem`` = slot 263) back after
+    a rebuild - not the ``swUnitsLinear`` slot, which echoes whatever was
+    written regardless of whether the document honoured it.
+
+    For the ``mm`` / ``cm`` / ``m`` / ``in`` presets only ``swUnitSystem`` is
+    set and the preset drives the linear unit. ``ft`` has no preset, so it is
+    applied as ``swUnitSystem_Custom`` plus an explicit ``swUnitsLinear``.
+
+    Args:
+        adapter: A connected adapter.
+        model: The ``IModelDoc2`` to modify.
+        unit_system: Already-normalised token (key of ``_SW_UNIT_SYSTEMS``).
+
+    Returns:
+        dict[str, Any]: ``unit_system``; ``applied_unit_system`` /
+        ``applied_length_unit`` (the swUnitSystem_e / swLengthUnit_e targets);
+        ``observed_unit_system`` / ``observed_length_unit`` (what the document
+        reports afterwards); ``set_call_ok`` (bool the COM call returned);
+        and ``verified`` (``True`` only when the document's own unit-system
+        preference now equals the target; ``None`` when it could not be read).
+
+    Raises:
+        Exception: When the extension is unavailable, or the readback shows
+            the document did not adopt the requested unit system.
+    """
+    system_value, length_value = _SW_UNIT_SYSTEMS[unit_system]
+    is_custom = system_value == _SW_UNIT_SYSTEM_CUSTOM
+    ext = adapter._attempt(lambda: model.Extension, default=None)
+    if ext is None:
+        raise Exception("Document has no Extension; cannot set units")
+
+    before_system = _pref_int(adapter, ext, _SW_PREF_UNIT_SYSTEM)
+    before_linear = _pref_int(adapter, ext, _SW_PREF_UNITS_LINEAR)
+
+    set_system_ok = adapter._attempt(
+        lambda: ext.SetUserPreferenceInteger(
+            _SW_PREF_UNIT_SYSTEM, _SW_PREF_OPTION_NONE, system_value
+        ),
+        default=None,
+    )
+    set_linear_ok: Any = None
+    if is_custom:
+        set_linear_ok = adapter._attempt(
+            lambda: ext.SetUserPreferenceInteger(
+                _SW_PREF_UNITS_LINEAR, _SW_PREF_OPTION_NONE, length_value
+            ),
+            default=None,
+        )
+
+    # Nudge SolidWorks to apply and to flag the document dirty.
+    adapter._attempt(lambda: model.EditRebuild3(), default=None)
+    adapter._attempt(lambda: model.GraphicsRedraw2(), default=None)
+    adapter._attempt(lambda: model.SetSaveFlag(), default=None)
+
+    after_system = _pref_int(adapter, ext, _SW_PREF_UNIT_SYSTEM)
+    after_linear = _pref_int(adapter, ext, _SW_PREF_UNITS_LINEAR)
+
+    if after_system is None:
+        verified: bool | None = None
+    else:
+        verified = after_system == system_value
+        if is_custom and verified:
+            verified = after_linear == length_value
+
+    result = {
+        "unit_system": unit_system,
+        "applied_unit_system": system_value,
+        "applied_length_unit": length_value,
+        "observed_unit_system": after_system,
+        "observed_length_unit": after_linear,
+        "unit_system_before": before_system,
+        "length_unit_before": before_linear,
+        "set_call_ok": bool(set_system_ok) if set_system_ok is not None else None,
+        "set_linear_call_ok": (
+            bool(set_linear_ok) if set_linear_ok is not None else None
+        ),
+        "verified": verified,
+    }
+
+    if verified is False:
+        raise Exception(
+            f"Unit system '{unit_system}' (swUnitSystem={system_value}) was not "
+            f"adopted: SetUserPreferenceInteger returned {result['set_call_ok']!r}, "
+            f"and the document still reports swUnitSystem={after_system}, "
+            f"swUnitsLinear={after_linear} (was {before_system}/{before_linear})."
+        )
+
+    return result
+
+
+# --- Open-document enumeration ------------------------------------------
+_DOC_TYPE_NAMES: dict[int, str] = {1: "Part", 2: "Assembly", 3: "Drawing"}
+
+# --- Multibody / drawing detailing -------------------------------------
+# swBodyType_e.swSolidBody
+_SW_SOLID_BODY = 0
+# swAutoInsertCenterMarkTypes_e - bitmask for IView::AutoInsertCenterMarks2
+_SW_CM_TYPE_HOLE = 1
+_SW_CM_TYPE_FILLET = 2
+_SW_CM_TYPE_SLOT = 4
+# swCenterMarkStyle_e.swCenterMark_Single
+_SW_CM_STYLE_SINGLE = 2
+
+# swAnnotationType_e.swCenterMarkSym — annotation type value for centre-mark
+# annotations auto-inserted by IView::AutoInsertCenterMarks2. There is no
+# member literally named "swAnnotationCenterMark" in swAnnotationType_e; that
+# name was a guess and 17 is actually swWeldBeadSymbol, which would have
+# reproduced the 0/0/0 bug on drawings with no weld beads (and silently
+# miscounted weld bead symbols as centre marks on drawings that have any).
+# Value confirmed against the published swconst enum (swAnnotationType_e):
+# https://help.solidworks.com/2026/english/api/swconst/SolidWorks.Interop.swconst~SolidWorks.Interop.swconst.swAnnotationType_e.html
+_SW_ANNOTATION_CENTER_MARK = 13
+
+
+def _variant_array(element_vt: int, values: Any) -> Any:
+    """Wrap a Python sequence as a SAFEARRAY VARIANT for a SolidWorks call.
+
+    pywin32 late binding otherwise unpacks a bare list into positional
+    arguments, so SolidWorks array parameters (``CreateSaveBodyFeature``'s
+    bodies/paths, sketch entity lists, ...) need a single ``VT_ARRAY``
+    VARIANT.
+
+    Args:
+        element_vt: The element type flag, e.g. ``pythoncom.VT_DISPATCH`` or
+            ``pythoncom.VT_BSTR``.
+        values: The sequence of elements.
+
+    Returns:
+        Any: ``VARIANT(VT_ARRAY | element_vt, list(values))``, or the plain
+        list when pywin32 is unavailable (test/mock environments).
+    """
+    variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+    array_flag = getattr(pythoncom, "VT_ARRAY", 0)
+    if not callable(variant_ctor) or not array_flag:
+        return list(values)
+    return variant_ctor(int(array_flag) | int(element_vt), list(values))
+
+
+def _resolve_drawing_view(adapter: Any, drawing: Any, view_name: str) -> Any:
+    """Return the ``IView`` on the active drawing whose name matches.
+
+    Walks ``IDrawingDoc::GetViews`` (a list of sheets, each shaped
+    ``(sheet, view, view, ...)``) the same way :func:`_view_names` does. The
+    match is case-insensitive.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        drawing: The drawing document, flagged for ``IDrawingDoc``.
+        view_name: The drawing-view name to look for.
+
+    Returns:
+        Any: The flagged ``IView`` dispatch, or ``None`` when nothing matches.
+    """
+    target = str(view_name or "").strip().lower()
+    if not target:
+        return None
+    sheets = adapter._attempt(lambda: drawing.GetViews(), default=None)
+    if not isinstance(sheets, (list, tuple)):
+        return None
+    for sheet in sheets:
+        views = sheet if isinstance(sheet, (list, tuple)) else [sheet]
+        for index, view in enumerate(views):
+            if index == 0 and isinstance(sheet, (list, tuple)):
+                continue
+            wrapped = _as_com(adapter, view, "IView")
+            if wrapped is None:
+                continue
+            name = adapter._attempt(lambda w=wrapped: w.GetName2(), default=None)
+            if name and str(name).lower() == target:
+                return wrapped
+    return None
+
+
+def _coerce_dispatch_sequence(raw: Any) -> list[Any]:
+    """Normalise ``ISldWorks::GetDocuments`` output into a list of dispatches.
+
+    Depending on the SolidWorks build and how many documents are open,
+    ``GetDocuments`` returns ``None``, a single ``IModelDoc2``, or a
+    tuple/list of them.
+
+    Args:
+        raw: Whatever ``GetDocuments()`` returned.
+
+    Returns:
+        list[Any]: Zero or more non-``None`` dispatches.
+    """
+    if raw is None:
+        return []
+    if isinstance(raw, (list, tuple)):
+        return [d for d in raw if d is not None]
+    return [raw]
+
+
+def _describe_open_document(
+    adapter: Any,
+    doc: Any,
+    active_title: str | None,
+    active_path: str | None,
+) -> dict[str, Any]:
+    """Summarise one open document: title, path, type and whether it is active.
+
+    Args:
+        adapter: A connected adapter (for ``_get_attr_or_call``).
+        doc: An ``IModelDoc2`` dispatch.
+        active_title: Title of ``ISldWorks::ActiveDoc``, if known.
+        active_path: Path of ``ISldWorks::ActiveDoc``, if known.
+
+    Returns:
+        dict[str, Any]: ``title``, ``path``, ``type`` and ``is_active``.
+    """
+    title = adapter._attempt(
+        lambda: adapter._get_attr_or_call(doc, "GetTitle"), default=None
+    )
+    path = adapter._attempt(
+        lambda: adapter._get_attr_or_call(doc, "GetPathName"), default=None
+    )
+    type_raw = adapter._attempt(
+        lambda: adapter._get_attr_or_call(doc, "GetType"), default=None
+    )
+    type_name = _DOC_TYPE_NAMES.get(
+        int(type_raw) if isinstance(type_raw, (int, float)) else -1, "Unknown"
+    )
+    is_active = False
+    if title and active_title:
+        is_active = str(title) == str(active_title)
+    elif path and active_path:
+        is_active = str(path).lower() == str(active_path).lower()
+    return {
+        "title": str(title) if title else None,
+        "path": str(path) if path else "",
+        "type": type_name,
+        "is_active": is_active,
+    }
+
+
+# --- Geometry summary ------------------------------------------------------
+# Read-only helpers for ``get_model_geometry_summary``. None of them rebuilds
+# the model or touches the selection (COM pitfall #23), so the summary can be
+# read immediately before a feature call.
+
+_FEATURE_WALK_MEMBERS = (
+    "GetTypeName2",
+    "GetNextFeature",
+    "GetFirstSubFeature",
+    "GetNextSubFeature",
+    "IsSuppressed",
+)
+
+#: The six ``GetExtremePoint`` directions, as (axis, is_max, direction).
+_EXTREME_DIRECTIONS = (
+    (0, False, (-1.0, 0.0, 0.0)),
+    (0, True, (1.0, 0.0, 0.0)),
+    (1, False, (0.0, -1.0, 0.0)),
+    (1, True, (0.0, 1.0, 0.0)),
+    (2, False, (0.0, 0.0, -1.0)),
+    (2, True, (0.0, 0.0, 1.0)),
+)
+
+
+def _box_from_metres(raw: Any, method: str) -> dict[str, Any] | None:
+    """Turn a SolidWorks ``[x1, y1, z1, x2, y2, z2]`` box in metres into mm.
+
+    Args:
+        raw: The six-value box, or anything else.
+        method: How the box was measured, reported back to the caller.
+
+    Returns:
+        dict[str, Any] | None: ``min``, ``max``, ``size`` (mm) and ``method``,
+        or ``None`` when ``raw`` is not a six-number box.
+    """
+    if not isinstance(raw, (list, tuple)) or len(raw) < 6:
+        return None
+    if not all(isinstance(v, (int, float)) for v in raw[:6]):
+        return None
+    values = [float(v) * 1000.0 for v in raw[:6]]
+    low = [min(values[i], values[i + 3]) for i in range(3)]
+    high = [max(values[i], values[i + 3]) for i in range(3)]
+    return {
+        "min": [round(v, 4) for v in low],
+        "max": [round(v, 4) for v in high],
+        "size": [round(high[i] - low[i], 4) for i in range(3)],
+        "method": method,
+    }
+
+
+def _solid_bodies(adapter: Any, part: Any) -> list[Any] | None:
+    """Return the part's solid bodies as wrapped ``IBody2`` dispatches.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        part: The part document, flagged for ``IPartDoc``.
+
+    Returns:
+        list[Any] | None: The bodies (possibly empty), or ``None`` when
+        ``GetBodies2`` could not be read at all. A part with no bodies yet
+        answers null rather than an empty array, so null without an error
+        is an empty list.
+    """
+    raw, error = adapter._attempt_with_error(
+        lambda: part.GetBodies2(_SW_SOLID_BODY, False)
+    )
+    if error is not None:
+        return None
+    if raw is None:
+        return []
+    items = list(raw) if isinstance(raw, (list, tuple)) else [raw]
+    return [_as_com(adapter, body, "IBody2") or body for body in items if body]
+
+
+def _extreme_point_box(adapter: Any, bodies: list[Any]) -> dict[str, Any] | None:
+    """Tight bounding box from each body's six extreme points.
+
+    ``GetPartBox`` can be loose on curved faces; ``GetExtremePoint`` returns
+    the actual farthest point of the body in a direction.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        bodies: Wrapped ``IBody2`` dispatches.
+
+    Returns:
+        dict[str, Any] | None: The box, or ``None`` when there are no bodies
+        or any extreme point could not be read.
+    """
+    if not bodies:
+        return None
+    low = [float("inf")] * 3
+    high = [float("-inf")] * 3
+    for body in bodies:
+        for axis, is_max, direction in _EXTREME_DIRECTIONS:
+            out = (_byref_double(), _byref_double(), _byref_double())
+            found = adapter._attempt(
+                lambda b=body, d=direction, o=out: b.GetExtremePoint(*d, *o),
+                default=None,
+            )
+            value = out[axis].value
+            if not found or not isinstance(value, (int, float)):
+                return None
+            if is_max:
+                high[axis] = max(high[axis], float(value))
+            else:
+                low[axis] = min(low[axis], float(value))
+    return _box_from_metres([*low, *high], "extreme_points")
+
+
+def _bodies_volume_mm3(adapter: Any, bodies: list[Any] | None) -> float | None:
+    """Sum the solid bodies' volumes, independent of the selection.
+
+    ``IModelDocExtension.CreateMassProperty`` computes for the current
+    selection and returns no volume while a sketch or plane is selected,
+    which is the state a feature call runs in. ``IBody2.GetMassProperties``
+    reads each body directly; element 3 of its array is the volume in m³.
+    The density argument only affects mass, which is not used here.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        bodies: Wrapped ``IBody2`` dispatches, ``[]`` for an empty part.
+
+    Returns:
+        float | None: Volume in mm³ (``0.0`` for no bodies), or ``None`` when
+        the bodies or any body's volume could not be read.
+    """
+    if bodies is None:
+        return None
+    total = 0.0
+    for body in bodies:
+        props = adapter._attempt(lambda b=body: b.GetMassProperties(1.0), default=None)
+        if not isinstance(props, (list, tuple)) or len(props) < 4:
+            return None
+        volume = props[3]
+        if not isinstance(volume, (int, float)):
+            return None
+        total += float(volume)
+    return round(total * 1e9, 4)
+
+
+def _model_volume_mm3(adapter: Any, model: Any) -> float | None:
+    """Read the model's volume without forcing a rebuild.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        model: The active ``IModelDoc2``.
+
+    Returns:
+        float | None: Volume in mm³, or ``None`` when it cannot be read.
+    """
+    mass_props = adapter._attempt(
+        lambda: model.Extension.CreateMassProperty(), default=None
+    )
+    if mass_props is None:
+        return None
+    volume = adapter._attempt(lambda: mass_props.Volume, default=None)
+    if not isinstance(volume, (int, float)):
+        return None
+    return round(float(volume) * 1e9, 4)
+
+
+def _sub_features(adapter: Any, parent: Any) -> list[Any]:
+    """Return a feature's sub-features, each flagged for the tree walk.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        parent: The parent ``IFeature``.
+
+    Returns:
+        list[Any]: The sub-features in tree order.
+    """
+    children: list[Any] = []
+    child = adapter._attempt(lambda: parent.GetFirstSubFeature(), default=None)
+    while child is not None and len(children) < 10000:
+        adapter._attempt(
+            lambda c=child: _sw_type_info.flag_members(c, *_FEATURE_WALK_MEMBERS),
+            default=0,
+        )
+        children.append(child)
+        child = adapter._attempt(lambda c=child: c.GetNextSubFeature(), default=None)
+    return children
+
+
+def _count_mates(adapter: Any, mate_group: Any) -> int:
+    """Count the unsuppressed mates under the assembly's mate group.
+
+    Mates are sub-features whose type name starts with ``Mate``; a mate
+    folder (any ``...Folder`` type) is entered one level deep.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        mate_group: The ``MateGroup`` feature.
+
+    Returns:
+        int: The number of unsuppressed mates.
+    """
+    count = 0
+    for child in _sub_features(adapter, mate_group):
+        kind = str(adapter._attempt(lambda c=child: c.GetTypeName2(), default="") or "")
+        members = _sub_features(adapter, child) if kind.endswith("Folder") else [child]
+        for mate in members:
+            mate_kind = str(
+                adapter._attempt(lambda m=mate: m.GetTypeName2(), default="") or ""
+            )
+            suppressed = adapter._attempt(
+                lambda m=mate: m.IsSuppressed(), default=False
+            )
+            if mate_kind.startswith("Mate") and not suppressed:
+                count += 1
+    return count
+
+
+def _assembly_mate_count(adapter: Any, model: Any) -> int | None:
+    """Find the ``MateGroup`` feature and count its mates.
+
+    Args:
+        adapter: A connected ``PyWin32Adapter``.
+        model: The active assembly ``IModelDoc2``.
+
+    Returns:
+        int | None: The mate count (``0`` when there is no mate group), or
+        ``None`` when the feature tree could not be read.
+    """
+    feature = adapter._attempt(lambda: model.FirstFeature(), default=None)
+    if feature is None:
+        return None
+    guard = 0
+    while feature is not None and guard < 10000:
+        guard += 1
+        adapter._attempt(
+            lambda f=feature: _sw_type_info.flag_members(f, *_FEATURE_WALK_MEMBERS),
+            default=0,
+        )
+        if adapter._attempt(lambda f=feature: f.GetTypeName2(), default="") == (
+            "MateGroup"
+        ):
+            return _count_mates(adapter, feature)
+        feature = adapter._attempt(lambda f=feature: f.GetNextFeature(), default=None)
+    return 0
+
+
+class SolidWorksIOMixin:
+    """Expose model open/save/create/configuration methods through a mixin."""
+
+    @staticmethod
+    def _adapter(obj: Any) -> Any:
+        """Return the runtime adapter object for dynamic attribute access."""
+        return cast(Any, obj)
+
+    @staticmethod
+    def _is_success(value: Any) -> bool:
+        """Interpret SolidWorks save API return values consistently.
+
+        Args:
+            value: Return value from ``Save*`` COM calls.
+
+        Returns:
+            bool: ``True`` when return value indicates success.
+        """
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, (int, float)):
+            return value == 0
+        return bool(value)
+
+    def _resolve_template_path(
+        self, preferred_indices: list[int], extension: str
+    ) -> str | None:
+        """Resolve a template path from SolidWorks user preference slots.
+
+        Args:
+            preferred_indices: Preference indices to probe in order.
+            extension: Expected template extension such as ``.prtdot``.
+
+        Returns:
+            str | None: First existing template match, otherwise first non-empty
+            path candidate, or ``None`` if nothing is configured.
+        """
+        adapter = self._adapter(self)
+        existing_match: str | None = None
+        first_non_empty: str | None = None
+        app = adapter.swApp
+        if app is None:
+            return None
+
+        for index in preferred_indices:
+            template = adapter._attempt(
+                lambda idx=index: app.GetUserPreferenceStringValue(idx)
+            )
+            if not template or not isinstance(template, str):
+                continue
+            if first_non_empty is None:
+                first_non_empty = template
+            if template.lower().endswith(extension.lower()) and os.path.exists(
+                template
+            ):
+                existing_match = template
+                break
+
+        return existing_match or first_non_empty
+
+    def _explicit_template_path(
+        self, template: str | None, extension: str
+    ) -> str | None:
+        """Validate a template path the caller passed explicitly.
+
+        A bad explicit template is an error rather than a silent fall back to
+        the configured default, so the caller learns their template was not
+        used.
+
+        Args:
+            template: Caller-supplied template path, or ``None``/blank.
+            extension: Required template extension such as ``.prtdot``.
+
+        Returns:
+            str | None: The stripped path, or ``None`` when no template was
+            given.
+
+        Raises:
+            Exception: When the path has the wrong extension or is not an
+                existing file.
+        """
+        if template is None or not str(template).strip():
+            return None
+        path = str(template).strip()
+        if not path.lower().endswith(extension):
+            raise Exception(f"Template {path!r} is not a {extension} file")
+        if not os.path.isfile(path):
+            raise Exception(f"Template not found: {path}")
+        return path
+
+    def _read_model_title(self, model: Any) -> str:
+        """Read a model title regardless of COM exposing method or property.
+
+        Args:
+            model: SolidWorks model COM object.
+
+        Returns:
+            str: Best-effort model title, defaulting to ``"Untitled"``.
+        """
+        adapter = self._adapter(self)
+        title = adapter._attempt(lambda: adapter._get_attr_or_call(model, "GetTitle"))
+        if isinstance(title, str) and title:
+            return title
+
+        title_value = getattr(model, "Title", None)
+        if isinstance(title_value, str) and title_value:
+            return title_value
+
+        return "Untitled"
+
+    def _sync_current_model_from_active(self) -> Any:
+        """Point ``adapter.currentModel`` at ``ISldWorks::ActiveDoc``.
+
+        The adapter only tracks ``currentModel`` for documents opened or
+        activated *through* a tool this session. When the user opens or
+        switches documents in the SolidWorks UI, ``currentModel`` goes stale
+        (or stays ``None``), so any tool that reads it first must resync -
+        exactly what ``get_model_info`` already does after issue #91.
+
+        ``ActiveDoc`` is a fresh, unflagged dispatch; it is flagged for its
+        document type here so downstream zero-arg accessors (``GetTitle`` and
+        friends) resolve as methods rather than property values that then
+        raise when called (COM pitfall #5).
+
+        Returns:
+            Any: The active document dispatch, or ``None`` when nothing is
+            open.
+        """
+        adapter = self._adapter(self)
+        active_model = (
+            getattr(adapter.swApp, "ActiveDoc", None) if adapter.swApp else None
+        )
+        if active_model is not None:
+            doc_type = adapter._get_attr_or_call(active_model, "GetType")
+            adapter._attempt(
+                lambda: _sw_type_info.flag_doc(
+                    active_model,
+                    int(doc_type) if isinstance(doc_type, (int, float)) else 1,
+                ),
+                default=0,
+            )
+            adapter.currentModel = active_model
+        return adapter.currentModel
+
+    async def open_model(self, file_path: str) -> AdapterResult[SolidWorksModel]:
+        """Open a SolidWorks model file and set it as active on the adapter.
+
+        Args:
+            file_path: Path to a ``.sldprt``, ``.sldasm``, or ``.slddrw`` file.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: Model metadata for the opened document.
+        """
+        adapter = self._adapter(self)
+        if not adapter.is_connected():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        def _open() -> SolidWorksModel:
+            """Open the model document."""
+            resolved_path = os.path.abspath(file_path)
+            file_path_lower = resolved_path.lower()
+            if file_path_lower.endswith(".sldprt"):
+                doc_type = adapter.constants["swDocPART"]
+                model_type = "Part"
+            elif file_path_lower.endswith(".sldasm"):
+                doc_type = adapter.constants["swDocASSEMBLY"]
+                model_type = "Assembly"
+            elif file_path_lower.endswith(".slddrw"):
+                doc_type = adapter.constants["swDocDRAWING"]
+                model_type = "Drawing"
+            else:
+                raise ValueError(f"Unsupported file type: {resolved_path}")
+
+            app = adapter.swApp
+            variant_ctor = getattr(getattr(win32com, "client", None), "VARIANT", None)
+            vt_byref = int(getattr(pythoncom, "VT_BYREF", 0))
+            vt_i4 = int(getattr(pythoncom, "VT_I4", 0))
+            if callable(variant_ctor):
+                errors = variant_ctor(vt_byref | vt_i4, 0)
+                warnings = variant_ctor(vt_byref | vt_i4, 0)
+            else:
+                errors = 0
+                warnings = 0
+            model = app.OpenDoc6(resolved_path, doc_type, 1, "", errors, warnings)
+            if not model:
+                raise Exception(f"Failed to open model: {resolved_path}")
+
+            adapter._attempt(
+                lambda: _sw_type_info.flag_doc(model, int(doc_type)), default=0
+            )
+
+            adapter.currentModel = model
+            title = self._read_model_title(model)
+
+            # OpenDoc6 with swOpenDocOptions_Silent opens the file but does not
+            # make it the active document - SolidWorks keeps the previously
+            # focused window active. Without this, get_model_info and every
+            # later tool call (exports especially) target the wrong document
+            # (issue #91). ActivateDoc3 takes the titlebar name, not the path.
+            if title:
+                activated = adapter._attempt(
+                    lambda: app.ActivateDoc3(title, False, 0, _byref_int())
+                )
+                if activated is not None:
+                    adapter._attempt(
+                        lambda: _sw_type_info.flag_doc(activated, int(doc_type)),
+                        default=0,
+                    )
+                    adapter.currentModel = activated
+            active_config = adapter._attempt(lambda: model.GetActiveConfiguration())
+            config = (
+                adapter._attempt(lambda: active_config.GetName(), default="Default")
+                if active_config
+                else "Default"
+            )
+
+            return SolidWorksModel(
+                path=resolved_path,
+                name=title,
+                type=model_type,
+                is_active=True,
+                configuration=config,
+                properties={
+                    "last_modified": (
+                        model.GetSaveTime()
+                        if callable(getattr(model, "GetSaveTime", None))
+                        else None
+                    ),
+                },
+            )
+
+        return cast(
+            AdapterResult[SolidWorksModel],
+            adapter._handle_com_operation("open_model", _open),
+        )
+
+    async def close_model(self, save: bool = False) -> AdapterResult[None]:
+        """Close the current SolidWorks model and optionally save first.
+
+        Args:
+            save: When ``True``, calls ``Save`` before closing.
+
+        Returns:
+            AdapterResult[None]: Result of the close operation.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.WARNING, error="No active model to close"
+            )
+        model = adapter.currentModel
+        app = adapter.swApp
+        if model is None or app is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="SolidWorks application is not connected",
+            )
+
+        def _close() -> None:
+            """Close the model document.
+
+            ``currentModel`` may be a raw ``swApp.ActiveDoc`` dispatch that was
+            never run through ``flag_doc`` (``get_model_info`` assigns it
+            straight from ``ActiveDoc``). On such a dispatch, late binding
+            returns zero-arg accessors property-style, so ``model.GetTitle()``
+            tries to *call* the returned string and raises
+            ``'str' object is not callable`` (issue #91, COM pitfall #5).
+            Read them through ``_get_attr_or_call`` which works either way.
+            """
+            if save:
+                adapter._get_attr_or_call(model, "Save")
+            title = adapter._get_attr_or_call(model, "GetTitle")
+            app.CloseDoc(title)
+            adapter.currentModel = None
+
+        return cast(
+            AdapterResult[None],
+            adapter._handle_com_operation("close_model", _close),
+        )
+
+    async def create_part(
+        self,
+        name: str | None = None,
+        units: str | None = None,
+        template: str | None = None,
+    ) -> AdapterResult[SolidWorksModel]:
+        """Create a new part document and set it as active.
+
+        Args:
+            name: Reserved for future naming policy.
+            units: Optional linear unit system for the new part - ``mm``,
+                ``cm``, ``m``, ``in`` or ``ft`` (aliases such as ``inch``
+                accepted). Applied after creation; the outcome is recorded
+                under ``properties["units"]`` (or ``properties["units_error"]``
+                if it could not be applied). An unrecognised token is an error.
+            template: Optional ``.prtdot`` path. When given the part is made
+                from it with ``NewDocument``; otherwise ``NewPart`` and then
+                the user-preference default templates are tried.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: Metadata for the new part document.
+        """
+        adapter = self._adapter(self)
+        if not adapter.is_connected():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        unit_token: str | None = None
+        if units is not None and str(units).strip():
+            unit_token = _normalise_unit_system(str(units))
+            if unit_token is None:
+                return AdapterResult(
+                    status=AdapterResultStatus.ERROR,
+                    error=(
+                        f"Unrecognised units {units!r}. "
+                        "Expected one of: mm, cm, m, in, ft."
+                    ),
+                )
+
+        def _create() -> SolidWorksModel:
+            """Create a new part."""
+            _ = name
+            model = None
+            app = adapter.swApp
+            if app is None:
+                raise Exception("SolidWorks application is not connected")
+
+            explicit = self._explicit_template_path(template, ".prtdot")
+            if explicit:
+                model = app.NewDocument(explicit, 0, 0, 0)
+            else:
+                new_part = getattr(app, "NewPart", None)
+                if callable(new_part):
+                    model = adapter._attempt(new_part)
+
+                if not model:
+                    part_template = self._resolve_template_path(
+                        [8, 0, 1, 2, 3], ".prtdot"
+                    )
+                    if not part_template:
+                        raise Exception(
+                            "No part template configured in SolidWorks; "
+                            "pass template with the path of a .prtdot file"
+                        )
+                    model = app.NewDocument(part_template, 0, 0, 0)
+
+            if not model:
+                if explicit:
+                    raise Exception(f"Failed to create new part from {explicit!r}")
+                raise Exception("Failed to create new part")
+
+            adapter._attempt(lambda: _sw_type_info.flag_doc(model, 1), default=0)
+            adapter.currentModel = model
+            title = self._read_model_title(model)
+            properties: dict[str, Any] = {"created": datetime.now().isoformat()}
+            if unit_token is not None:
+                # A units failure must not lose the part that was just made;
+                # record it and carry on.
+                try:
+                    properties["units"] = _apply_unit_system(adapter, model, unit_token)
+                except Exception as exc:  # noqa: BLE001 - surfaced, not raised
+                    properties["units_error"] = str(exc)
+            return SolidWorksModel(
+                path="",
+                name=title,
+                type="Part",
+                is_active=True,
+                configuration="Default",
+                properties=properties,
+            )
+
+        return cast(
+            AdapterResult[SolidWorksModel],
+            adapter._handle_com_operation("create_part", _create),
+        )
+
+    async def create_assembly(
+        self, name: str | None = None, template: str | None = None
+    ) -> AdapterResult[SolidWorksModel]:
+        """Create a new assembly document and set it as active.
+
+        Args:
+            name: Reserved for future naming policy.
+            template: Optional ``.asmdot`` path. When given the assembly is
+                made from it with ``NewDocument``; otherwise ``NewAssembly``
+                and then the user-preference default templates are tried.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: Metadata for the new assembly document.
+        """
+        adapter = self._adapter(self)
+        if not adapter.is_connected():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        def _create() -> SolidWorksModel:
+            """Create a new assembly."""
+            _ = name
+            model = None
+            app = adapter.swApp
+            if app is None:
+                raise Exception("SolidWorks application is not connected")
+
+            explicit = self._explicit_template_path(template, ".asmdot")
+            if explicit:
+                model = app.NewDocument(explicit, 0, 0, 0)
+            else:
+                new_assembly = getattr(app, "NewAssembly", None)
+                if callable(new_assembly):
+                    model = adapter._attempt(new_assembly)
+
+                if not model:
+                    asm_template = self._resolve_template_path(
+                        [9, 2, 3, 1, 0], ".asmdot"
+                    )
+                    if not asm_template:
+                        raise Exception(
+                            "No assembly template configured in SolidWorks; "
+                            "pass template with the path of a .asmdot file"
+                        )
+                    model = app.NewDocument(asm_template, 0, 0, 0)
+
+            if not model:
+                if explicit:
+                    raise Exception(f"Failed to create new assembly from {explicit!r}")
+                raise Exception("Failed to create new assembly")
+
+            adapter._attempt(lambda: _sw_type_info.flag_doc(model, 2), default=0)
+            adapter.currentModel = model
+            title = self._read_model_title(model)
+            return SolidWorksModel(
+                path="",
+                name=title,
+                type="Assembly",
+                is_active=True,
+                configuration="Default",
+                properties={"created": datetime.now().isoformat()},
+            )
+
+        return cast(
+            AdapterResult[SolidWorksModel],
+            adapter._handle_com_operation("create_assembly", _create),
+        )
+
+    async def create_drawing(
+        self, name: str | None = None, template: str | None = None
+    ) -> AdapterResult[SolidWorksModel]:
+        """Create a new drawing document and set it as active.
+
+        Args:
+            name: Reserved for future naming policy.
+            template: Optional ``.drwdot`` path, used in place of the
+                user-preference default. An explicit template that fails is
+                an error; it does not fall back to a blank drawing.
+
+        Returns:
+            AdapterResult[SolidWorksModel]: Metadata for the new drawing document.
+        """
+        adapter = self._adapter(self)
+        if not adapter.is_connected():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        def _create() -> SolidWorksModel:
+            """Create a new drawing."""
+            _ = name
+            app = adapter.swApp
+            if app is None:
+                raise Exception("SolidWorks application is not connected")
+
+            # Slot 10 is swDefaultTemplateDrawing. Slot 1 was read here
+            # before and comes back empty on SW 2025, after which the
+            # fallback did GetUserPreferenceStringValue(0).replace("Part",
+            # "Drawing") on another empty string - so NewDocument got "" and
+            # every drawing operation was unreachable. Measured live on
+            # SW 2025: 8=Part.prtdot, 9=Assembly.asmdot, 10=Drawing.drwdot,
+            # 0-3 all empty.
+            explicit = self._explicit_template_path(template, ".drwdot")
+            drw_template = explicit or self._resolve_template_path(
+                [10, 1, 0, 2, 3], ".drwdot"
+            )
+            model = None
+            if drw_template:
+                model = app.NewDocument(
+                    drw_template, _SW_DWG_PAPERS_USER_DEFINED, 0.2794, 0.2159
+                )
+            if not model and explicit:
+                raise Exception(f"Failed to create a drawing from {explicit!r}")
+            if not model:
+                # No usable template (a settings reset blanks the slot, or it
+                # names a deleted file). Like create_part's NewPart fallback,
+                # let SolidWorks make a blank A-size drawing with no sheet
+                # format; views can still be placed on it.
+                model = adapter._attempt(
+                    lambda: app.NewDrawing2(
+                        _SW_DWG_TEMPLATE_NONE, "", _SW_DWG_PAPER_A_SIZE, 0.2794, 0.2159
+                    )
+                )
+            if not model:
+                if drw_template:
+                    tried = f"template {drw_template!r}"
+                else:
+                    tried = "no drawing template is configured"
+                raise Exception(
+                    f"Failed to create a drawing: {tried}, and a blank drawing "
+                    "without a template (NewDrawing2) also failed"
+                )
+
+            adapter._attempt(lambda: _sw_type_info.flag_doc(model, 3), default=0)
+            adapter.currentModel = model
+            title = self._read_model_title(model)
+            return SolidWorksModel(
+                path="",
+                name=title,
+                type="Drawing",
+                is_active=True,
+                configuration="Default",
+                properties={"created": datetime.now().isoformat()},
+            )
+
+        return cast(
+            AdapterResult[SolidWorksModel],
+            adapter._handle_com_operation("create_drawing", _create),
+        )
+
+    async def get_dimension(self, name: str) -> AdapterResult[float]:
+        """Read a named model dimension in millimetres.
+
+        Args:
+            name: Fully-qualified dimension name.
+
+        Returns:
+            AdapterResult[float]: Dimension value in millimetres.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        def _get() -> float:
+            """Get the dimension value."""
+            dimension = adapter.currentModel.Parameter(name)
+            if not dimension:
+                raise Exception(f"Dimension '{name}' not found")
+            # SystemValue is reliable on SW 2025 (in meters, convert to mm)
+            value = adapter._attempt(lambda: dimension.SystemValue, default=None)
+            if value is None:
+                # Fall back to GetValue3 for older SW versions
+                value = adapter._attempt(
+                    lambda: dimension.GetValue3(0, 0), default=None
+                )
+            if value is None:
+                raise Exception(f"Failed to read dimension '{name}'")
+            return float(value) * 1000
+
+        return cast(
+            AdapterResult[float],
+            adapter._handle_com_operation("get_dimension", _get),
+        )
+
+    async def set_dimension(self, name: str, value: float) -> AdapterResult[None]:
+        """Set a named model dimension in millimetres and rebuild.
+
+        Args:
+            name: Fully-qualified dimension name.
+            value: New value in millimetres.
+
+        Returns:
+            AdapterResult[None]: Result of the set operation.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        def _set() -> None:
+            """Set the dimension value."""
+            dimension = adapter.currentModel.Parameter(name)
+            if not dimension:
+                raise Exception(f"Dimension '{name}' not found")
+
+            # SetValue3 has gen_py parameter mapping issues on SW 2025.
+            # SystemValue (in meters) is reliable.
+            value_m = value / 1000.0
+            adapter._attempt(
+                lambda: setattr(dimension, "SystemValue", value_m),
+                default=None,
+            )
+
+            # Rebuild: try EditRebuild3 first, fall back to ForceRebuild3
+            rebuilt = adapter._attempt(
+                lambda: adapter.currentModel.EditRebuild3(), default=None
+            )
+            if rebuilt is None:
+                rebuilt = adapter._attempt(
+                    lambda: adapter.currentModel.ForceRebuild3(True), default=None
+                )
+            if rebuilt is None:
+                raise Exception("Failed to set dimension")
+
+        return cast(
+            AdapterResult[None],
+            adapter._handle_com_operation("set_dimension", _set),
+        )
+
+    async def set_units(self, unit_system: str) -> AdapterResult[dict[str, Any]]:
+        """Set the active document's linear unit system.
+
+        Accepts ``mm``, ``cm``, ``m``, ``in`` or ``ft`` (plus common aliases
+        such as ``inch`` / ``millimeters``). The choice is applied by setting
+        both ``swUnitSystem`` and the exact ``swUnitsLinear`` preference, then
+        reading the linear unit back - a mismatch is reported as an error.
+
+        Args:
+            unit_system: The target unit token.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: What was applied and whether the
+            readback confirmed it. ``ERROR`` when there is no active model or
+            the token is not recognised.
+        """
+        adapter = self._adapter(self)
+        # Resync from ActiveDoc in case the user switched documents in the UI.
+        self._sync_current_model_from_active()
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        token = _normalise_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."
+                ),
+            )
+
+        def _apply() -> dict[str, Any]:
+            return _apply_unit_system(adapter, adapter.currentModel, token)
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("set_units", _apply),
+        )
+
+    async def save_file(self, file_path: str | None = None) -> AdapterResult[None]:
+        """Save the active model to its current path or to a new file path.
+
+        Args:
+            file_path: Optional target path for Save As.
+
+        Returns:
+            AdapterResult[None]: Result of the save operation.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        def _save() -> None:
+            """Save the model."""
+            if file_path:
+                resolved_path = os.path.abspath(file_path)
+                directory = os.path.dirname(resolved_path)
+                if directory:
+                    os.makedirs(directory, exist_ok=True)
+
+                current_path = adapter._attempt(
+                    lambda: adapter._get_attr_or_call(
+                        adapter.currentModel, "GetPathName"
+                    ),
+                    default="",
+                )
+                same_file = bool(current_path) and os.path.normcase(
+                    os.path.abspath(str(current_path))
+                ) == os.path.normcase(resolved_path)
+
+                if same_file:
+                    # Saving a document over its own path is a plain Save.
+                    # It used to fall through to the Save-As branch below, which
+                    # closed the document and deleted the file before calling
+                    # SaveAs3 on the now-closed doc. That wrote an empty part and
+                    # lost the geometry.
+                    save_result = adapter._attempt(
+                        lambda: adapter.currentModel.Save3(1, None, None)
+                    )
+                    if save_result is None:
+                        save_fn = getattr(adapter.currentModel, "Save", None)
+                        if callable(save_fn):
+                            save_fn()
+                    if not os.path.exists(resolved_path):
+                        raise Exception(f"File not written after save: {resolved_path}")
+                    return
+
+                # A *different* document may be holding the target path open.
+                # Close that one by name only - never the document being saved.
+                if adapter.swApp:
+                    adapter._attempt(
+                        lambda: adapter.swApp.CloseDoc(os.path.basename(resolved_path))
+                    )
+
+                # Deliberately no os.remove here: SaveAs3 overwrites, and
+                # deleting first meant a failed save destroyed the old file too.
+                save_as3_result = adapter.currentModel.SaveAs3(resolved_path, 0, 0)
+                if not self._is_success(save_as3_result):
+                    save_as = getattr(adapter.currentModel, "SaveAs", None)
+                    if callable(save_as):
+                        fallback_result = save_as(resolved_path)
+                        if not self._is_success(fallback_result):
+                            raise Exception(f"Failed to save as: {resolved_path}")
+                    else:
+                        raise Exception(f"Failed to save as: {resolved_path}")
+
+                if not os.path.exists(resolved_path):
+                    raise Exception(f"File not written after save: {resolved_path}")
+                return
+
+            save_result = adapter._attempt(
+                lambda: adapter.currentModel.Save3(1, None, None)
+            )
+            if save_result is None:
+                save_fn = getattr(adapter.currentModel, "Save", None)
+                if callable(save_fn):
+                    save_result = save_fn()
+                else:
+                    raise Exception("Failed to save file")
+
+            if self._is_success(save_result):
+                return
+
+            path_attr = getattr(adapter.currentModel, "GetPathName", "")
+            model_path = path_attr() if callable(path_attr) else path_attr
+            if model_path and os.path.exists(model_path):
+                return
+            raise Exception("Failed to save file")
+
+        return cast(
+            AdapterResult[None],
+            adapter._handle_com_operation("save_file", _save),
+        )
+
+    async def rebuild_model(
+        self, top_level_only: bool = False
+    ) -> AdapterResult[dict[str, Any]]:
+        """Force a rebuild and report exactly which features fail and why.
+
+        Args:
+            top_level_only: Rebuild only the top level of an assembly.
+                Defaults to False (full rebuild).
+
+        Returns:
+            AdapterResult[dict[str, Any]]: ``rebuilt``, ``top_level_only``,
+            ``errors`` (see ``rebuild_diagnostics.explain``), ``error_count``,
+            ``warning_count`` and a one-line ``summary``. ERROR - still
+            carrying that ``data`` - when any error-severity entry remains or
+            SolidWorks reports the rebuild itself failed.
+        """
+        from .com_utils import strip_op_prefix
+        from .rebuild_diagnostics import explain, summarize
+        from .rebuild_inspector import collect_rebuild_issues
+
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        def _rebuild() -> dict[str, Any]:
+            model = adapter.currentModel
+            # ForceRebuild3 returns False whenever a feature fails to rebuild
+            # (confirmed live 2026-10-13), so False is not "the rebuild call
+            # broke" - collect the per-feature issues either way and only fall
+            # back to a generic failure when SolidWorks names none.
+            rebuilt = bool(model.ForceRebuild3(top_level_only))
+            entries = [explain(i) for i in collect_rebuild_issues(adapter, model)]
+            error_count, warning_count, summary = summarize(entries)
+            if not rebuilt and not error_count:
+                # Keep any warnings in data; only the cause is unnamed.
+                summary = (
+                    "SolidWorks reported that the rebuild failed (ForceRebuild3 "
+                    "returned False) but listed no failing feature."
+                    + (f" Warnings: {summary}" if warning_count else "")
+                )
+            return {
+                "rebuilt": rebuilt,
+                "top_level_only": top_level_only,
+                "errors": entries,
+                "error_count": error_count,
+                "warning_count": warning_count,
+                "summary": summary,
+            }
+
+        result = cast(
+            "AdapterResult[dict[str, Any]]",
+            adapter._handle_com_operation("rebuild_model", _rebuild),
+        )
+        if not result.is_success:
+            result.error = strip_op_prefix(result.error, "rebuild_model")
+        elif result.data and (result.data["error_count"] or not result.data["rebuilt"]):
+            result.status = AdapterResultStatus.ERROR
+            result.error = result.data["summary"]
+        return result
+
+    async def get_model_info(self) -> AdapterResult[dict[str, Any]]:
+        """Collect summary metadata about the active model.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Model information payload.
+        """
+        adapter = self._adapter(self)
+        # Resync from ActiveDoc: the user may have opened or switched
+        # documents in the SolidWorks UI since the last tool call (issue #91).
+        self._sync_current_model_from_active()
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        def _get_info() -> dict[str, Any]:
+            """Get model information."""
+            # With late-bound SolidWorks COM, GetActiveConfiguration is
+            # exposed as an object-valued property even though the API names
+            # it like a method. Calling that COM object raises "member not
+            # found", so read it directly.
+            active_config = getattr(
+                adapter.currentModel, "GetActiveConfiguration", None
+            )
+            # 'Name' on Configuration is a property, not a method.
+            config_name = (
+                getattr(active_config, "Name", "Default")
+                if active_config
+                else "Default"
+            )
+            # Try GetSaveFlag (method) first, fallback to property
+            is_dirty_raw = adapter._attempt(
+                lambda: adapter._get_attr_or_call(adapter.currentModel, "GetSaveFlag"),
+                default=None,
+            )
+            is_dirty = bool(is_dirty_raw) if is_dirty_raw is not None else None
+            feature_count = adapter._attempt(
+                lambda: int(
+                    adapter.currentModel.FeatureManager.GetFeatureCount(True) or 0
+                ),
+                default=0,
+            )
+            rebuild_status_raw = adapter._attempt(
+                lambda: adapter.currentModel.GetRebuildStatus(), default=None
+            )
+            # GetRebuildStatus returns 0=ok, 1=needs rebuild, or None=failed
+            rebuild_status = (
+                rebuild_status_raw if rebuild_status_raw is not None else None
+            )
+            return {
+                "title": adapter._get_attr_or_call(adapter.currentModel, "GetTitle"),
+                "path": adapter._get_attr_or_call(adapter.currentModel, "GetPathName"),
+                "type": adapter._get_document_type(),
+                "configuration": config_name,
+                "is_dirty": is_dirty,
+                "feature_count": feature_count,
+                "rebuild_status": rebuild_status,
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("get_model_info", _get_info),
+        )
+
+    async def list_open_documents(self) -> AdapterResult[list[dict[str, Any]]]:
+        """Enumerate every document currently open in SolidWorks.
+
+        Read-only: uses ``ISldWorks::GetDocuments`` and does not touch the
+        active-document selection. Each entry carries ``title``, ``path``,
+        ``type`` (``Part`` / ``Assembly`` / ``Drawing`` / ``Unknown``) and
+        ``is_active``.
+
+        Returns:
+            AdapterResult[list[dict[str, Any]]]: One entry per open document
+            (possibly empty). ``ERROR`` only when not connected.
+        """
+        adapter = self._adapter(self)
+        if not adapter.is_connected():
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="Not connected to SolidWorks"
+            )
+
+        def _list() -> list[dict[str, Any]]:
+            app = adapter.swApp
+
+            docs = _coerce_dispatch_sequence(
+                adapter._attempt(lambda: app.GetDocuments(), default=None)
+            )
+            active = adapter._attempt(
+                lambda: getattr(app, "ActiveDoc", None), default=None
+            )
+            active_title = (
+                adapter._attempt(
+                    lambda: adapter._get_attr_or_call(active, "GetTitle"), default=None
+                )
+                if active is not None
+                else None
+            )
+            active_path = (
+                adapter._attempt(
+                    lambda: adapter._get_attr_or_call(active, "GetPathName"),
+                    default=None,
+                )
+                if active is not None
+                else None
+            )
+            return [
+                _describe_open_document(adapter, d, active_title, active_path)
+                for d in docs
+            ]
+
+        return cast(
+            AdapterResult[list[dict[str, Any]]],
+            adapter._handle_com_operation("list_open_documents", _list),
+        )
+
+    async def activate_document(
+        self, title_or_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Make an already-open document the active one.
+
+        Matches ``title_or_path`` against the open documents by exact title,
+        by full path, or by file name (all case-insensitive), then calls
+        ``ISldWorks::ActivateDoc3`` and updates the adapter's tracked
+        ``currentModel``. The resulting ``ActiveDoc`` is read back and a
+        mismatch is reported as an error.
+
+        Args:
+            title_or_path: A window title (``"bracket.SLDPRT"``), a full path,
+                or a bare file name of a document that is already open.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: ``activated`` (the title switched
+            to) and ``verified`` (bool, or ``None`` when the readback could
+            not be performed). ``ERROR`` when not connected, the argument is
+            blank, or nothing open matches.
+        """
+        adapter = self._adapter(self)
+        if not adapter.is_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"
+            )
+
+        def _activate() -> dict[str, Any]:
+            app = adapter.swApp
+
+            docs = _coerce_dispatch_sequence(
+                adapter._attempt(lambda: app.GetDocuments(), default=None)
+            )
+            needle = target.lower()
+            match: Any = None
+            match_title: str | None = None
+            open_titles: list[str] = []
+            for doc in docs:
+                title = adapter._attempt(
+                    lambda d=doc: adapter._get_attr_or_call(d, "GetTitle"),
+                    default=None,
+                )
+                path = adapter._attempt(
+                    lambda d=doc: adapter._get_attr_or_call(d, "GetPathName"),
+                    default=None,
+                )
+                if title:
+                    open_titles.append(str(title))
+                candidates = {
+                    str(title).lower() if title else "",
+                    str(path).lower() if path else "",
+                    Path(str(path)).name.lower() if path else "",
+                }
+                candidates.discard("")
+                if needle in candidates:
+                    match = doc
+                    match_title = str(title) if title else None
+                    break
+
+            if match is None:
+                raise Exception(
+                    f"No open document matches {target!r}. Open: "
+                    + (", ".join(open_titles) or "none")
+                )
+            if not match_title:
+                match_title = adapter._attempt(
+                    lambda: adapter._get_attr_or_call(match, "GetTitle"), default=None
+                )
+            if not match_title:
+                raise Exception(
+                    "Matched an open document but could not read its title to "
+                    "activate it"
+                )
+
+            activated = adapter._attempt(
+                lambda: app.ActivateDoc3(match_title, False, 0, _byref_int()),
+                default=None,
+            )
+            model = activated or adapter._attempt(
+                lambda: getattr(app, "ActiveDoc", None), default=None
+            )
+            if model is not None:
+                type_raw = adapter._attempt(
+                    lambda: adapter._get_attr_or_call(model, "GetType"), default=1
+                )
+                adapter._attempt(
+                    lambda: _sw_type_info.flag_doc(
+                        model,
+                        int(type_raw) if isinstance(type_raw, (int, float)) else 1,
+                    ),
+                    default=0,
+                )
+                adapter.currentModel = model
+
+            active_after = adapter._attempt(
+                lambda: getattr(app, "ActiveDoc", None), default=None
+            )
+            now_title = (
+                adapter._attempt(
+                    lambda: adapter._get_attr_or_call(active_after, "GetTitle"),
+                    default=None,
+                )
+                if active_after is not None
+                else None
+            )
+            if now_title is None:
+                verified: bool | None = None
+            else:
+                verified = str(now_title) == str(match_title)
+                if not verified:
+                    raise Exception(
+                        f"Requested {match_title!r} but ActiveDoc is "
+                        f"{now_title!r} after ActivateDoc3; activation did not take."
+                    )
+            return {"activated": str(match_title), "verified": verified}
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("activate_document", _activate),
+        )
+
+    async def list_configurations(self) -> AdapterResult[list[str]]:
+        """List all configuration names on the active model.
+
+        Returns:
+            AdapterResult[list[str]]: Configuration names, or empty list when unavailable.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="No active model",
+            )
+
+        def _list() -> list[str]:
+            """List configurations."""
+            raw_names = getattr(adapter.currentModel, "GetConfigurationNames", None)
+            names = raw_names() if callable(raw_names) else raw_names
+            if names is None:
+                names = []
+            if isinstance(names, str):
+                return [names]
+
+            normalized_names = [str(name) for name in names]
+            if normalized_names:
+                return normalized_names
+
+            active_config = adapter._attempt(
+                lambda: adapter.currentModel.GetActiveConfiguration(), default=None
+            )
+            active_name = adapter._attempt(
+                lambda: active_config.GetName(), default=None
+            )
+            if active_name:
+                return [str(active_name)]
+            return []
+
+        return cast(
+            AdapterResult[list[str]],
+            adapter._handle_com_operation("list_configurations", _list),
+        )
+
+    async def get_mass_properties(self) -> AdapterResult[MassProperties]:
+        """Get mass properties for the active model.
+
+        Returns:
+            AdapterResult[MassProperties]: Computed mass, volume, area, COM, and inertia.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        def _get() -> MassProperties:
+            """Get mass properties."""
+            adapter._attempt(
+                lambda: adapter.currentModel.ForceRebuild3(False), default=None
+            )
+
+            # Primary: Extension.CreateMassProperty() object API (most detailed)
+            mass_props = adapter._attempt(
+                lambda: adapter.currentModel.Extension.CreateMassProperty(),
+                default=None,
+            )
+
+            if mass_props:
+                volume = mass_props.Volume * 1e9
+                surface_area = mass_props.SurfaceArea * 1e6
+                mass = mass_props.Mass
+
+                center_of_mass = [0.0, 0.0, 0.0]
+                com = adapter._attempt(lambda: mass_props.CenterOfMass, default=None)
+                if isinstance(com, (list, tuple)) and len(com) >= 3:
+                    center_of_mass = [com[0] * 1000, com[1] * 1000, com[2] * 1000]
+
+                moi = adapter._attempt(
+                    lambda: mass_props.GetMomentOfInertia(0), default=None
+                )
+                if not isinstance(moi, (list, tuple)) or len(moi) < 9:
+                    moi = [0.0] * 9
+            else:
+                # Fallback: GetMassProperties as attribute (tuple) or callable (SW 2022)
+                gmp = getattr(adapter.currentModel, "GetMassProperties", None)
+                if callable(gmp):
+                    raw = adapter._attempt(gmp, default=None)
+                elif isinstance(gmp, (list, tuple)):
+                    raw = gmp
+                else:
+                    raw = None
+
+                if not isinstance(raw, (list, tuple)) or len(raw) < 6:
+                    raise Exception("Failed to get mass properties")
+
+                center_of_mass = [
+                    raw[0] * 1000.0,
+                    raw[1] * 1000.0,
+                    raw[2] * 1000.0,
+                ]
+                volume = raw[3] * 1e9
+                surface_area = raw[4] * 1e6
+                mass = raw[5]
+
+                moi = [0.0] * 9
+                if len(raw) >= 12:
+                    moi[0] = raw[6]
+                    moi[4] = raw[7]
+                    moi[8] = raw[8]
+                    moi[1] = raw[9]
+                    moi[5] = raw[10]
+                    moi[2] = raw[11]
+
+            return MassProperties(
+                volume=volume,
+                surface_area=surface_area,
+                mass=mass,
+                center_of_mass=center_of_mass,
+                moments_of_inertia={
+                    "Ixx": moi[0],
+                    "Iyy": moi[4],
+                    "Izz": moi[8],
+                    "Ixy": moi[1],
+                    "Ixz": moi[2],
+                    "Iyz": moi[5],
+                },
+            )
+
+        return cast(
+            AdapterResult[MassProperties],
+            adapter._handle_com_operation("get_mass_properties", _get),
+        )
+
+    async def get_model_geometry_summary(self) -> AdapterResult[dict[str, Any]]:
+        """Summarise the active part or assembly without rebuilding it.
+
+        Unlike ``get_mass_properties`` this never calls ``ForceRebuild3``, so
+        it leaves the live selection intact (COM pitfall #23) and can be read
+        right before a feature call. A value that cannot be read is ``None``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: See
+            ``SolidWorksAdapter.get_model_geometry_summary``.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        doc_type = _doc_type(adapter)
+        if doc_type not in (1, 2):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "get_model_geometry_summary needs an active part or assembly "
+                    f"(active document type is {doc_type!r})"
+                ),
+            )
+
+        def _summarise() -> dict[str, Any]:
+            model = adapter.currentModel
+            summary: dict[str, Any] = {}
+            if doc_type == 1:
+                part = _sw_type_info.flagged(model, "IPartDoc")
+                bodies = _solid_bodies(adapter, part)
+                volume = _bodies_volume_mm3(adapter, bodies)
+                summary["volume_mm3"] = (
+                    volume if volume is not None else _model_volume_mm3(adapter, model)
+                )
+                box = _extreme_point_box(adapter, bodies or [])
+                if box is None:
+                    box = _box_from_metres(
+                        adapter._attempt(lambda: part.GetPartBox(True), default=None),
+                        "part_box",
+                    )
+                summary["document_type"] = "part"
+                summary["solid_body_count"] = None if bodies is None else len(bodies)
+            else:
+                assembly = _sw_type_info.flagged(model, "IAssemblyDoc")
+                summary["volume_mm3"] = _model_volume_mm3(adapter, model)
+                box = _box_from_metres(
+                    adapter._attempt(lambda: assembly.GetBox(0), default=None),
+                    "assembly_box",
+                )
+                summary["document_type"] = "assembly"
+                summary["solid_body_count"] = None
+                summary["component_count"] = len(_component_names(adapter, assembly))
+                summary["mate_count"] = _assembly_mate_count(adapter, model)
+            summary["bounding_box_method"] = box.pop("method") if box else None
+            summary["bounding_box_mm"] = box
+            return summary
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("get_model_geometry_summary", _summarise),
+        )
+
+    async def pack_and_go_assembly(
+        self,
+        source_path: str,
+        target_dir: str,
+    ) -> AdapterResult[dict[str, Any]]:
+        """Copy an assembly and all its referenced components to a self-contained folder.
+
+        Uses ``IModelDocExtension.GetPackAndGo()`` → ``IPackAndGo`` via the
+        comtypes vtable interface (bypassing the broken IDispatch path present
+        in SolidWorks 2026's late-binding layer), then calls
+        ``IModelDocExtension.SavePackAndGo()`` to execute the copy.  All file
+        paths inside the copied assembly are automatically updated by
+        SolidWorks — this is the native Pack-and-Go mechanism.
+
+        Args:
+            source_path: Absolute path to the source ``.sldasm`` file.
+            target_dir: Directory where the assembly and parts will be copied.
+                        Created if it does not exist.
+
+        Returns:
+            AdapterResult[dict]: On success, ``data`` is a dict with keys:
+            ``source_assembly``, ``target_dir``, ``copied_files``,
+            ``source_files``, ``save_statuses``, and ``all_files_saved``.
+        """
+        adapter = self._adapter(self)
+        source = Path(source_path)
+        out_dir = Path(target_dir)
+
+        def _do_pack_and_go() -> dict[str, Any]:
+            # Load comtypes TLB (cached after first call)
+            sw_lib = _get_sw_comtypes_lib()
+            if sw_lib is None:
+                raise RuntimeError(
+                    "comtypes SolidWorks type library not available. "
+                    "Ensure comtypes is installed and SolidWorks is registered."
+                )
+
+            # Prepare a clean target directory. SW holds file locks on previously
+            # opened assemblies so rmtree raises WinError 32. We rename the old
+            # dir aside (Windows allows rename with open handles) and delete the
+            # backup afterwards; if rename also fails we just proceed and let SW
+            # overwrite existing files.
+            if out_dir.exists():
+                backup = out_dir.parent / f"{out_dir.name}_bak_{uuid.uuid4().hex[:8]}"
+                try:
+                    os.rename(out_dir, backup)
+                    try:
+                        shutil.rmtree(backup)
+                    except Exception:
+                        pass  # best-effort cleanup; stale backup is harmless
+                except OSError:
+                    pass  # rename also failed — proceed; SW will overwrite files
+            out_dir.mkdir(parents=True, exist_ok=True)
+
+            # Open the source assembly
+            err, warn = _byref_int(), _byref_int()
+            model = adapter.swApp.OpenDoc6(str(source), 2, 1, "", err, warn)
+            if model is None and err.value == 65536:
+                adapter.swApp.CloseAllDocuments(False)
+                err, warn = _byref_int(), _byref_int()
+                model = adapter.swApp.OpenDoc6(str(source), 2, 1, "", err, warn)
+            if model is None:
+                raise RuntimeError(f"OpenDoc6 failed err={err.value} warn={warn.value}")
+            _sw_type_info.flag_doc(model, 2)
+            adapter.currentModel = model
+
+            # Bridge model.Extension → IModelDocExtension via comtypes vtable
+            ext_ct = _bridge_com_to_comtypes(model.Extension, sw_lib.IModelDocExtension)
+
+            # GetPackAndGo() via vtable (IDispatch path broken in SW 2026)
+            pg = ext_ct.GetPackAndGo()
+
+            # Configure: flatten all files to root of target directory
+            pg.FlattenToSingleFolder = True
+            pg.SetSaveToName(True, str(out_dir) + "\\")
+
+            # Record what files will be packed
+            names_result = pg.GetDocumentNames()
+            source_files: list[str] = list(names_result[0]) if names_result[0] else []
+
+            # Execute Pack and Go — SavePackAndGo returns a tuple of per-file status codes
+            ext_ct2 = _bridge_com_to_comtypes(
+                model.Extension, sw_lib.IModelDocExtension
+            )
+            status_arr = ext_ct2.SavePackAndGo(pg)
+            save_statuses: list[int] = list(status_arr) if status_arr else []
+
+            copied_files = sorted(
+                str(p)
+                for p in out_dir.rglob("*")
+                if p.is_file() and p.suffix.lower() in {".sldasm", ".sldprt", ".slddrw"}
+            )
+            return {
+                "source_assembly": str(source),
+                "target_dir": str(out_dir),
+                "copied_files": copied_files,
+                "source_files": source_files,
+                "save_statuses": save_statuses,
+                "all_files_saved": all(s == 0 for s in save_statuses),
+            }
+
+        result = adapter._handle_com_operation("pack_and_go_assembly", _do_pack_and_go)
+        if not result.is_success:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Pack and Go failed: {result.error}",
+            )
+        return AdapterResult(
+            status=AdapterResultStatus.SUCCESS,
+            data=result.data,
+            execution_time=result.execution_time,
+        )
+
+    async def insert_component(
+        self, file_path: str, x: float = 0.0, y: float = 0.0, z: float = 0.0
+    ) -> AdapterResult[dict[str, Any]]:
+        """Insert a part or sub-assembly into the active assembly.
+
+        Wraps ``IAssemblyDoc::AddComponent4(CompName, ConfigName, X, Y, Z)``,
+        falling back to ``AddComponent5``.  Position is in **millimetres**.
+
+        **The component file must contain solid geometry.**  SolidWorks
+        silently refuses to insert an empty part — every overload returns
+        ``None`` and the component count stays put.  That behaviour is what
+        made this look unimplementable until the ``save_file`` bug that was
+        writing empty parts got fixed.
+
+        Success is confirmed by the assembly's component count going up, since
+        ``AddComponent*`` gives no usable failure signal.
+
+        Args:
+            file_path (str): Absolute path to the ``.sldprt`` or ``.sldasm``.
+            x (float): X position in millimetres.
+            y (float): Y position in millimetres.
+            z (float): Z position in millimetres.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: Component name and before/after
+            counts.  ``ERROR`` when the active document is not an assembly, the
+            file is missing, or nothing was inserted.
+
+        Raises:
+            Exception: Propagated through ``_handle_com_operation``.
+
+        Example::
+
+            await adapter.insert_component(r"C:\\parts\\bracket.sldprt", 0, 0, 0)
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        path = os.path.abspath(file_path)
+        if not os.path.exists(path):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Component file not found: {file_path}",
+            )
+
+        doc_type = _doc_type(adapter)
+        if doc_type != 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "insert_component requires an assembly document "
+                    f"(active document type is {doc_type!r}, expected 2). "
+                    "Call create_assembly first."
+                ),
+            )
+
+        def _insert() -> dict[str, Any]:
+            assembly = _sw_type_info.flagged(adapter.currentModel, "IAssemblyDoc")
+            before = _component_names(adapter, assembly)
+
+            # The document has to be loaded before it can be inserted, and the
+            # errors/warnings out-parameters must be byref VARIANTs: with
+            # pythoncom.Missing OpenDoc6 returns None and the part stays
+            # unloaded, after which every AddComponent overload does nothing.
+            app = adapter.swApp
+            opened = adapter._attempt(
+                lambda: app.OpenDoc6(
+                    path,
+                    2 if path.lower().endswith(".sldasm") else 1,
+                    1,
+                    "",
+                    _byref_int(),
+                    _byref_int(),
+                ),
+                default=None,
+            )
+            if not opened:
+                raise Exception(
+                    f"Could not load '{file_path}' - OpenDoc6 returned nothing."
+                )
+
+            title = adapter._attempt(
+                lambda: _sw_type_info.flagged(
+                    adapter.currentModel, "IModelDoc2"
+                ).GetTitle(),
+                default=None,
+            )
+            if title:
+                adapter._attempt(
+                    lambda: app.ActivateDoc3(title, False, 0, _byref_int()),
+                    default=None,
+                )
+
+            component = adapter._attempt(
+                lambda: assembly.AddComponent4(
+                    path, "", x / 1000.0, y / 1000.0, z / 1000.0
+                ),
+                default=None,
+            )
+            if component is None:
+                component = adapter._attempt(
+                    lambda: assembly.AddComponent5(
+                        path,
+                        0,
+                        "",
+                        False,
+                        "",
+                        x / 1000.0,
+                        y / 1000.0,
+                        z / 1000.0,
+                    ),
+                    default=None,
+                )
+
+            adapter._attempt(lambda: assembly.EditRebuild3(), default=None)
+
+            after = _component_names(adapter, assembly)
+            if len(after) <= len(before):
+                raise Exception(
+                    f"Component was not inserted - the assembly still has "
+                    f"{len(after)} component(s). The most common cause is a "
+                    f"part with no solid geometry: SolidWorks refuses those "
+                    f"silently. Check '{file_path}' opens with a body."
+                )
+
+            added = [n for n in after if n not in before]
+            return {
+                "component": added[-1] if added else after[-1],
+                "file_path": path,
+                "position": {"x": x, "y": y, "z": z},
+                "components_before": len(before),
+                "components_after": len(after),
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("insert_component", _insert),
+        )
+
+    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]]:
+        """Mate two components together.
+
+        Wraps ``IAssemblyDoc::AddMate5``.  The two entities are selected via
+        ``IComponent2::FeatureByName`` + ``IFeature::Select2`` rather than
+        ``SelectByID2``, which raises ``Type mismatch`` on this build.
+
+        That restricts the entities to *named tree features* — the reference
+        planes and axes of each component.  Plane-to-plane mating covers
+        alignment and stacking, which is the common case; mating to a specific
+        face or edge needs entity names this adapter cannot enumerate.
+
+        Args:
+            component_a (str): First component instance name, as reported by
+                :meth:`list_components`.
+            component_b (str): Second component instance name.
+            entity_a (str): Named feature on the first component.
+            entity_b (str): Named feature on the second component.
+            mate_type (str): ``coincident``, ``concentric``, ``perpendicular``,
+                ``parallel``, ``tangent``, ``distance`` or ``angle``.
+            alignment (str): ``aligned``, ``anti_aligned`` or ``closest``.
+            distance (float): Distance in millimetres, for a distance mate.
+            angle (float): Angle in degrees, for an angle mate.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The mate created, plus the bounding
+            box before and after so the caller can see what moved.  ``ERROR``
+            when the entities cannot be selected or SolidWorks rejects the
+            mate.
+
+        Raises:
+            Exception: Propagated through ``_handle_com_operation``.
+
+        Example::
+
+            await adapter.add_mate("plate-1", "plate-2")
+        """
+        adapter = self._adapter(self)
+        if _doc_type(adapter) != 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="add_mate requires an assembly document",
+            )
+
+        mate_key = str(mate_type).strip().lower()
+        if mate_key not in _MATE_TYPES:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown mate type '{mate_type}'. "
+                    f"Use one of: {', '.join(sorted(_MATE_TYPES))}."
+                ),
+            )
+        align_key = str(alignment).strip().lower()
+        if align_key not in _MATE_ALIGNMENTS:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown alignment '{alignment}'. "
+                    f"Use one of: {', '.join(sorted(_MATE_ALIGNMENTS))}."
+                ),
+            )
+
+        def _mate() -> dict[str, Any]:
+            import math
+
+            model = adapter.currentModel
+            assembly = _sw_type_info.flagged(model, "IAssemblyDoc")
+
+            components = adapter._attempt(
+                lambda: assembly.GetComponents(True), default=None
+            )
+            if not isinstance(components, (list, tuple)):
+                raise Exception("Could not read the assembly's components")
+
+            wanted = {component_a: entity_a, component_b: entity_b}
+            found: dict[str, Any] = {}
+            for component in components:
+                wrapped = _as_com(adapter, component, "IComponent2")
+                if wrapped is None:
+                    continue
+                name = adapter._attempt(lambda w=wrapped: w.Name2, default=None)
+                if name and str(name) in wanted:
+                    found[str(name)] = wrapped
+
+            missing = [n for n in (component_a, component_b) if n not in found]
+            if missing:
+                available = [
+                    str(
+                        adapter._attempt(
+                            lambda c=c: _as_com(adapter, c, "IComponent2").Name2,
+                            default="?",
+                        )
+                    )
+                    for c in components
+                ]
+                raise Exception(
+                    f"Component(s) not found: {', '.join(missing)}. "
+                    f"The assembly holds: {', '.join(available)}."
+                )
+
+            adapter._attempt(lambda: model.ClearSelection2(True), default=None)
+            for index, component_name in enumerate((component_a, component_b)):
+                wrapped = found[component_name]
+                entity_name = wanted[component_name]
+                feature = adapter._attempt(
+                    lambda w=wrapped, e=entity_name: w.FeatureByName(e), default=None
+                )
+                if feature is None:
+                    raise Exception(
+                        f"'{entity_name}' not found on {component_name}. "
+                        "Only named tree features (reference planes and axes) "
+                        "can be selected here."
+                    )
+                flagged = _as_com(adapter, feature, "IFeature")
+                if flagged is None or not adapter._attempt(
+                    lambda f=flagged, a=index > 0: f.Select2(a, 0), default=False
+                ):
+                    raise Exception(
+                        f"Failed to select '{entity_name}' on {component_name}"
+                    )
+
+            selected = adapter._attempt(
+                lambda: model.SelectionManager.GetSelectedObjectCount2(-1), default=0
+            )
+            if selected != 2:
+                raise Exception(
+                    f"Expected 2 selected entities for the mate, got {selected}"
+                )
+
+            transforms_before = _component_transforms(adapter, assembly)
+            status = _byref_int()
+            mate = adapter._attempt(
+                lambda: assembly.AddMate5(
+                    _MATE_TYPES[mate_key],
+                    _MATE_ALIGNMENTS[align_key],
+                    False,  # Flip
+                    distance / 1000.0,  # Distance (m)
+                    distance / 1000.0,  # upper limit
+                    distance / 1000.0,  # lower limit
+                    0.0,  # gear ratio numerator
+                    0.0,  # gear ratio denominator
+                    math.radians(float(angle)),
+                    math.radians(float(angle)),
+                    math.radians(float(angle)),
+                    False,  # ForPositioningOnly
+                    False,  # LockRotation
+                    0,  # WidthMateOption
+                    status,
+                ),
+                default=None,
+            )
+            adapter._attempt(lambda: model.EditRebuild3(), default=None)
+
+            error_status = getattr(status, "value", None)
+            # swAddMateError_e reports 1 for success on this build (measured:
+            # a mate that demonstrably moved a component returned 1).
+            if mate is None or (error_status not in (None, 1)):
+                raise Exception(
+                    f"SolidWorks rejected the {mate_key} mate "
+                    f"(error status {error_status!r}). Check the two entities "
+                    "can actually satisfy this mate type."
+                )
+
+            transforms_after = _component_transforms(adapter, assembly)
+            moved = sorted(
+                name
+                for name, matrix in transforms_after.items()
+                if name in transforms_before and transforms_before[name] != matrix
+            )
+            # An empty snapshot means no transform could be read, which is
+            # not the same as "nothing moved" - report it as unknown rather
+            # than as a negative result the caller would read as fact.
+            comparable = bool(transforms_before and transforms_after)
+            return {
+                "mate_type": mate_key,
+                "alignment": align_key,
+                "components": [component_a, component_b],
+                "entities": [entity_a, entity_b],
+                "distance": distance or None,
+                "angle": angle or None,
+                "moved_components": moved,
+                "geometry_moved": bool(moved) if comparable else None,
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("add_mate", _mate),
+        )
+
+    async def list_components(self) -> AdapterResult[list[str]]:
+        """List the top-level components of the active assembly.
+
+        Returns:
+            AdapterResult[list[str]]: Component names, or an error when the
+            active document is not an assembly.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        doc_type = _doc_type(adapter)
+        if doc_type != 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "list_components requires an assembly document "
+                    f"(active document type is {doc_type!r}, expected 2)"
+                ),
+            )
+
+        def _list() -> list[str]:
+            assembly = _sw_type_info.flagged(adapter.currentModel, "IAssemblyDoc")
+            return _component_names(adapter, assembly)
+
+        return cast(
+            AdapterResult[list[str]],
+            adapter._handle_com_operation("list_components", _list),
+        )
+
+    def _require_drawing(self) -> AdapterResult[Any] | None:
+        """Return an error result unless the active document is a drawing.
+
+        Returns:
+            AdapterResult[Any] | None: ``None`` when the active document is a
+            drawing, otherwise the error to hand back.
+        """
+        adapter = self._adapter(self)
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        doc_type = _doc_type(adapter)
+        if doc_type != 3:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "This operation requires a drawing document "
+                    f"(active document type is {doc_type!r}, expected 3). "
+                    "Call create_drawing first."
+                ),
+            )
+        return None
+
+    def _place_view(self, payload: Any) -> AdapterResult[dict[str, Any]]:
+        """Place one named view of a model on the active drawing sheet.
+
+        Shared by ``create_drawing_view`` and ``add_drawing_view``, which are
+        two registered tools reaching the same operation through different
+        input schemas.
+
+        Wraps ``IDrawingDoc::CreateDrawViewFromModelView3(ModelName, ViewName,
+        LocX, LocY, LocZ)``. Position is accepted in millimetres and converted
+        to metres. Success is confirmed by the sheet's view count going up:
+        the call returns ``None`` for a model SolidWorks could not resolve, so
+        its return value proves nothing on its own.
+
+        Args:
+            payload: Tool payload. Reads ``model_path``/``model_file``,
+                ``orientation``/``view_type``, ``position_x``/``position_y``
+                (or a two-element ``position``), and ``scale``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new view's name and position.
+        """
+        adapter = self._adapter(self)
+        guard = self._require_drawing()
+        if guard is not None:
+            return cast("AdapterResult[dict[str, Any]]", guard)
+
+        data = _payload(payload)
+        model_path = _first(data, "model_path", "model_file", "path")
+        if not model_path:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="A model path is required (model_path or model_file)",
+            )
+
+        path = os.path.abspath(str(model_path))
+        if not os.path.exists(path):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Model file not found: {model_path}",
+            )
+
+        position = data.get("position")
+        if isinstance(position, (list, tuple)) and len(position) >= 2:
+            x, y = float(position[0]), float(position[1])
+        else:
+            x = float(_first(data, "position_x", "x", default=100.0))
+            y = float(_first(data, "position_y", "y", default=150.0))
+
+        requested = str(_first(data, "orientation", "view_type", default="front"))
+        view_name = _NAMED_VIEWS.get(requested.strip().lower())
+        if view_name is None and requested.startswith("*"):
+            view_name = requested
+        if view_name is None:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    f"Unknown orientation '{requested}'. Use one of: "
+                    f"{', '.join(sorted(_NAMED_VIEWS))}, or a raw '*Name'."
+                ),
+            )
+
+        try:
+            scale = float(_first(data, "scale", default=0.0) or 0.0)
+        except (TypeError, ValueError):
+            # The DrawingCreationInput schema types scale as a string ratio
+            # ("1:1"), which is not a view scale factor. Ignore it rather than
+            # failing the whole call over a display preference.
+            scale = 0.0
+
+        def _add() -> dict[str, Any]:
+            drawing = _sw_type_info.flagged(adapter.currentModel, "IDrawingDoc")
+            before = _view_names(adapter, drawing)
+
+            # The model has to be loaded before a view of it can be placed,
+            # and OpenDoc6's errors/warnings out-params must be byref VARIANTs
+            # - with pythoncom.Missing it returns None, the model stays
+            # unloaded, and CreateDrawViewFromModelView3 then silently makes
+            # no view.
+            app = adapter.swApp
+            doc_type = 2 if path.lower().endswith(".sldasm") else 1
+            opened = adapter._attempt(
+                lambda: app.OpenDoc6(path, doc_type, 1, "", _byref_int(), _byref_int()),
+                default=None,
+            )
+            if not opened:
+                raise Exception(
+                    f"Could not load '{model_path}' - OpenDoc6 returned nothing."
+                )
+
+            # Opening the model made it active; the drawing has to be active
+            # again before a view can be added to it.
+            drawing_title = adapter._attempt(
+                lambda: _sw_type_info.flagged(
+                    adapter.currentModel, "IModelDoc2"
+                ).GetTitle(),
+                default=None,
+            )
+            if drawing_title:
+                adapter._attempt(
+                    lambda: app.ActivateDoc3(drawing_title, False, 0, _byref_int()),
+                    default=None,
+                )
+
+            view = adapter._attempt(
+                lambda: drawing.CreateDrawViewFromModelView3(
+                    path, view_name, x / 1000.0, y / 1000.0, 0.0
+                ),
+                default=None,
+            )
+
+            after = _view_names(adapter, drawing)
+            if len(after) <= len(before):
+                raise Exception(
+                    f"View was not created - the sheet still has {len(after)} "
+                    f"view(s). Check that '{model_path}' opens on its own and "
+                    f"that '{view_name}' is a valid named view for it."
+                )
+
+            added = [n for n in after if n not in before]
+            new_view = added[-1] if added else after[-1]
+
+            scale_applied = False
+            if scale and view is not None:
+                wrapped = _as_com(adapter, view, "IView")
+                if wrapped is not None:
+                    scale_applied = (
+                        adapter._attempt(
+                            lambda: setattr(wrapped, "ScaleRatio", [scale, 1.0]),
+                            default=None,
+                        )
+                        is not None
+                    )
+
+            return {
+                "name": new_view,
+                "model_path": path,
+                "orientation": view_name,
+                "position": {"x": x, "y": y},
+                "scale": scale or None,
+                "scale_applied": scale_applied if scale else None,
+                "views_before": len(before),
+                "views_after": len(after),
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("create_drawing_view", _add),
+        )
+
+    async def create_drawing_view(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Place a view of a model on the active drawing sheet.
+
+        Args:
+            payload: Tool payload; see ``_place_view``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new view's name and position.
+
+        Example::
+
+            await adapter.create_drawing_view(
+                {"model_path": r"C:\\parts\\bracket.sldprt", "orientation": "front"}
+            )
+        """
+        return self._place_view(payload)
+
+    async def add_drawing_view(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Add a view of a model to the active drawing sheet.
+
+        The same operation as ``create_drawing_view``; both tool entry points
+        exist upstream and reach this one implementation.
+
+        Args:
+            payload: Tool payload; see ``_place_view``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The new view's name and position.
+        """
+        return self._place_view(payload)
+
+    async def create_technical_drawing(
+        self, payload: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Lay out the three standard views of a model on the active sheet.
+
+        Wraps ``IDrawingDoc::Create3rdAngleViews2`` (or
+        ``Create1stAngleViews2``), which places front, top and side in one
+        call. Both return a bare boolean, so the view list before and after is
+        what actually confirms the views exist.
+
+        Args:
+            payload: Tool payload. Reads ``model_path``/``model_file`` and
+                ``third_angle`` (default ``True``; ``projection`` set to
+                ``"first_angle"`` selects the other).
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The view names that appeared.
+
+        Example::
+
+            await adapter.create_technical_drawing(
+                {"model_file": r"C:\\parts\\bracket.sldprt"}
+            )
+        """
+        adapter = self._adapter(self)
+        guard = self._require_drawing()
+        if guard is not None:
+            return cast("AdapterResult[dict[str, Any]]", guard)
+
+        data = _payload(payload)
+        model_path = _first(data, "model_path", "model_file", "path")
+        if not model_path:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="A model path is required (model_path or model_file)",
+            )
+
+        path = os.path.abspath(str(model_path))
+        if not os.path.exists(path):
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=f"Model file not found: {model_path}",
+            )
+
+        third_angle = bool(data.get("third_angle", True))
+        if str(data.get("projection", "")).lower() in {"first", "first_angle"}:
+            third_angle = False
+
+        def _standard() -> dict[str, Any]:
+            drawing = _sw_type_info.flagged(adapter.currentModel, "IDrawingDoc")
+            before = _view_names(adapter, drawing)
+
+            created = adapter._attempt(
+                lambda: (
+                    drawing.Create3rdAngleViews2(path)
+                    if third_angle
+                    else drawing.Create1stAngleViews2(path)
+                ),
+                default=False,
+            )
+
+            after = _view_names(adapter, drawing)
+            added = [n for n in after if n not in before]
+            if not added:
+                raise Exception(
+                    f"No views were created from '{model_path}' (the call "
+                    f"returned {created!r}). Check the model has solid "
+                    "geometry and opens on its own."
+                )
+
+            return {
+                "views": added,
+                "model_path": path,
+                "projection": "third_angle" if third_angle else "first_angle",
+                "views_before": len(before),
+                "views_after": len(after),
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("create_technical_drawing", _standard),
+        )
+
+    async def add_note(self, payload: Any = None) -> AdapterResult[dict[str, Any]]:
+        """Place a text note on the active drawing sheet.
+
+        Wraps ``IModelDoc2::InsertNote(Text)`` and then positions the returned
+        annotation: ``InsertNote`` places the note wherever SolidWorks likes,
+        so the position is applied afterwards via ``IAnnotation::SetPosition``.
+
+        Args:
+            payload: Tool payload. Reads ``text``, ``position_x``/``position_y``
+                (or a two-element ``position``) in millimetres, and
+                ``font_size`` in **points**, matching the tool schema.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The note text and where it landed.
+
+        Example::
+
+            await adapter.add_note(
+                {"text": "MATERIAL: AISI 1018", "position_x": 200.0,
+                 "position_y": 50.0}
+            )
+        """
+        adapter = self._adapter(self)
+        guard = self._require_drawing()
+        if guard is not None:
+            return cast("AdapterResult[dict[str, Any]]", guard)
+
+        data = _payload(payload)
+        text = _first(data, "text", "note", default="")
+        if not text:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error="add_note requires text",
+            )
+
+        position = data.get("position")
+        if isinstance(position, (list, tuple)) and len(position) >= 2:
+            x, y = float(position[0]), float(position[1])
+        else:
+            x = float(_first(data, "position_x", "x", default=100.0))
+            y = float(_first(data, "position_y", "y", default=50.0))
+
+        # The schema expresses font size in points, not millimetres.
+        font_points = float(_first(data, "font_size", default=0.0) or 0.0)
+        font_mm = font_points * _POINTS_TO_MM
+
+        def _add_note() -> dict[str, Any]:
+            model = adapter.currentModel
+            adapter._attempt(lambda: model.ClearSelection2(True), default=None)
+
+            note = adapter._attempt(lambda: model.InsertNote(str(text)), default=None)
+            if note is None:
+                raise Exception(
+                    "InsertNote returned nothing - the note was not created."
+                )
+
+            positioned = False
+            annotation = adapter._attempt(
+                lambda: _sw_type_info.flagged(note, "INote").GetAnnotation(),
+                default=None,
+            )
+            if annotation is not None:
+                positioned = bool(
+                    adapter._attempt(
+                        lambda: _sw_type_info.flagged(
+                            annotation, "IAnnotation"
+                        ).SetPosition(x / 1000.0, y / 1000.0, 0.0),
+                        default=False,
+                    )
+                )
+
+            if font_mm:
+                adapter._attempt(
+                    lambda: _sw_type_info.flagged(note, "INote").SetTextFormat(
+                        0, False, font_mm / 1000.0
+                    ),
+                    default=None,
+                )
+
+            adapter._attempt(lambda: model.EditRebuild3(), default=None)
+            return {
+                "text": text,
+                "position": {"x": x, "y": y},
+                "positioned": positioned,
+                "font_size_points": font_points or None,
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("add_note", _add_note),
+        )
+
+    async def list_drawing_views(self) -> AdapterResult[list[str]]:
+        """List the views on the active drawing.
+
+        Returns:
+            AdapterResult[list[str]]: View names, sheet formats excluded.
+        """
+        adapter = self._adapter(self)
+        guard = self._require_drawing()
+        if guard is not None:
+            return cast("AdapterResult[list[str]]", guard)
+
+        def _list_views() -> list[str]:
+            drawing = _sw_type_info.flagged(adapter.currentModel, "IDrawingDoc")
+            return _view_names(adapter, drawing)
+
+        return cast(
+            AdapterResult[list[str]],
+            adapter._handle_com_operation("list_drawing_views", _list_views),
+        )
+
+    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]]:
+        """Auto-insert centre marks on circular features in a drawing view.
+
+        Wraps ``IView::AutoInsertCenterMarks2`` (falling back to
+        ``AutoInsertCenterMarks`` on older builds) using the document's
+        default size/gap/font. ``IView::GetCenterMarkCount()`` returns 0
+        regardless of marks actually present on SW 3DEXPERIENCE R2026x, so
+        the count is derived instead from ``IView::GetAnnotations()``: the
+        view's annotations are enumerated and those flagged as
+        ``swCenterMarkSym`` (``swAnnotationType_e``) are counted.
+        ``center_marks_before == center_marks_after == 0`` is reported when
+        the annotation enumeration cannot be performed (COM unavailable or
+        older builds).
+
+        Adding nothing is still a success - the view may simply have no
+        un-marked circular features.
+
+        Args:
+            view_name: Name of a view on the active drawing.
+            mark_holes: Mark holes / bores. Defaults to ``True``.
+            mark_fillets: Mark fillets. Defaults to ``False``.
+            mark_slots: Mark slots. Defaults to ``True``.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The view, the feature types acted
+            on, and ``center_marks_before`` / ``center_marks_after`` /
+            ``center_marks_added``. ``ERROR`` when the active document is not
+            a drawing, no feature type is selected, or the view is not found.
+        """
+        adapter = self._adapter(self)
+        guard = self._require_drawing()
+        if guard is not None:
+            return cast("AdapterResult[dict[str, Any]]", guard)
+
+        insert_type = (
+            (_SW_CM_TYPE_HOLE if mark_holes else 0)
+            | (_SW_CM_TYPE_FILLET if mark_fillets else 0)
+            | (_SW_CM_TYPE_SLOT if mark_slots else 0)
+        )
+        if insert_type == 0:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "Select at least one feature type: mark_holes, "
+                    "mark_fillets or mark_slots."
+                ),
+            )
+
+        def _auto_marks() -> dict[str, Any]:
+            drawing = _sw_type_info.flagged(adapter.currentModel, "IDrawingDoc")
+            view = _resolve_drawing_view(adapter, drawing, view_name)
+            if view is None:
+                raise Exception(
+                    f"No view named {view_name!r} on the active drawing. "
+                    f"Views: {', '.join(_view_names(adapter, drawing)) or 'none'}"
+                )
+
+            def _center_mark_count() -> int:
+                """Count annotations on the view flagged as swCenterMarkSym.
+
+                Enumerates ``IView::GetAnnotations()`` and inspects each
+                annotation's type via ``IAnnotation::GetType()``. Returns 0 when
+                the enumeration cannot be performed (COM unavailable, older
+                builds, or the annotation type is unknown). This is the count
+                source for both ``center_marks_before`` and ``center_marks_after``.
+                """
+                raw_annos = adapter._attempt(
+                    lambda: view.GetAnnotations(), default=None
+                )
+                if not isinstance(raw_annos, (list, tuple)):
+                    return 0
+                count = 0
+                for raw in raw_annos:
+                    anno = _as_com(adapter, raw, "IAnnotation")
+                    if anno is None:
+                        continue
+                    anno_type = adapter._attempt(
+                        lambda anno=anno: anno.GetType(), default=None
+                    )
+                    if (
+                        isinstance(anno_type, (int, float))
+                        and anno_type == _SW_ANNOTATION_CENTER_MARK
+                    ):
+                        count += 1
+                return count
+
+            before = _center_mark_count()
+
+            ran = adapter._attempt(
+                lambda: view.AutoInsertCenterMarks2(
+                    insert_type,
+                    _SW_CM_STYLE_SINGLE,
+                    True,  # LinearSlotCenter
+                    True,  # ArcSlotCenter
+                    True,  # UseDocumentDefaults
+                    0.0,  # Size (ignored when UseDocumentDefaults)
+                    0.0,  # Gap
+                    True,  # ExtendedLines
+                    False,  # CenterLineFont
+                    0.0,  # Angle
+                ),
+                default=None,
+            )
+            if ran is None:
+                ran = adapter._attempt(
+                    lambda: view.AutoInsertCenterMarks(
+                        insert_type,
+                        _SW_CM_STYLE_SINGLE,
+                        True,
+                        True,
+                        True,
+                        0.0,
+                        True,
+                        False,
+                        0.0,
+                    ),
+                    default=None,
+                )
+
+            adapter._attempt(lambda: adapter.currentModel.EditRebuild3(), default=None)
+
+            after = _center_mark_count()
+
+            return {
+                "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": after - before,
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("auto_center_marks", _auto_marks),
+        )
+
+    async def save_body_as_part(
+        self, body_name: str, file_path: str
+    ) -> AdapterResult[dict[str, Any]]:
+        """Extract one solid body from the active multibody part to a new file.
+
+        Wraps ``IFeatureManager::CreateSaveBodyFeature`` - the API behind
+        Insert > Features > Save Bodies. ``body_name`` is matched against
+        ``IPartDoc::GetBodies2(swSolidBody)`` by ``IBody2::Name``; a Save
+        Bodies feature is added and the standalone part is written to
+        ``file_path``. ``CreateSaveBodyFeature`` returns the feature (or
+        ``None``) but no write status, so success is confirmed by the file
+        existing afterwards.
+
+        Args:
+            body_name: Name of a solid body in the active part.
+            file_path: Absolute path for the new ``.sldprt``; its parent
+                directory must already exist.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: The body, the written path, the new
+            feature's name, and every solid-body name found. ``ERROR`` when
+            the active document is not a part, the body is absent, the parent
+            directory is missing, or no file was written.
+        """
+        adapter = self._adapter(self)
+        self._sync_current_model_from_active()
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+        if _doc_type(adapter) != 1:
+            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}",
+            )
+
+        def _save_body() -> dict[str, Any]:
+            model = adapter.currentModel
+            part = _sw_type_info.flagged(model, "IPartDoc")
+            raw_bodies = adapter._attempt(
+                lambda: part.GetBodies2(_SW_SOLID_BODY, False), default=None
+            )
+            bodies = (
+                list(raw_bodies)
+                if isinstance(raw_bodies, (list, tuple))
+                else ([raw_bodies] if raw_bodies else [])
+            )
+            if not bodies:
+                raise Exception("The active part has no solid bodies")
+
+            names: list[str] = []
+            match = None
+            for body in bodies:
+                flagged = _sw_type_info.flagged(body, "IBody2")
+                name = adapter._attempt(
+                    lambda f=flagged: adapter._get_attr_or_call(f, "Name"),
+                    default=None,
+                )
+                if name is not None:
+                    names.append(str(name))
+                    if str(name) == body_name:
+                        match = flagged
+            if match is None:
+                raise Exception(
+                    f"Body {body_name!r} not found. Solid bodies: "
+                    + (", ".join(names) or "none")
+                )
+
+            manager = adapter._attempt(lambda: model.FeatureManager, default=None)
+            if manager is None:
+                raise Exception("Part has no FeatureManager")
+            manager = _sw_type_info.flagged(manager, "IFeatureManager")
+
+            if os.path.exists(target):
+                os.remove(target)
+
+            feature = adapter._attempt(
+                lambda: manager.CreateSaveBodyFeature(
+                    _variant_array(pythoncom.VT_DISPATCH, [match]),
+                    _variant_array(pythoncom.VT_BSTR, [target]),
+                    "",
+                    False,
+                    True,
+                ),
+                default=None,
+            )
+            adapter._attempt(lambda: model.EditRebuild3(), default=None)
+
+            if not os.path.exists(target):
+                raise Exception(
+                    f"CreateSaveBodyFeature did not write a file to {target}; "
+                    "the Save Bodies feature was rejected."
+                )
+
+            feat_name = (
+                adapter._attempt(
+                    lambda: adapter._get_attr_or_call(feature, "Name"),
+                    default=None,
+                )
+                if feature is not None
+                else None
+            )
+            return {
+                "body": body_name,
+                "file_path": target,
+                "feature": str(feat_name) if feat_name else None,
+                "solid_bodies": names,
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("save_body_as_part", _save_body),
+        )
+
+    async def check_interference(
+        self, params: Any = None
+    ) -> AdapterResult[dict[str, Any]]:
+        """Run SolidWorks' interference detection on the active assembly.
+
+        Uses ``IAssemblyDoc::InterferenceDetectionManager``
+        (``IInterferenceDetectionMgr``), **not** the older
+        ``ToolsCheckInterference2``. That call is declared ``Sub`` with two
+        ``ByRef`` out-parameters, and on SW 2025 through pywin32 late binding
+        it could not be made to report anything: ``pythoncom.Missing`` raises
+        ``PyOleMissing can not be converted to a COM VARIANT``, a plain
+        ``None`` or a typed array VARIANT raises ``Type mismatch``, passing a
+        component array throws server-side, and a byref ``VT_VARIANT`` pair is
+        accepted but leaves both out-parameters ``None`` for an assembly that
+        demonstrably interferes. An inspection tool that always answers "no
+        interference" is worse than one that refuses.
+
+        ``GetInterferenceCount`` is an ordinary return value, so ``0`` is a
+        real measurement rather than a swallowed failure, and each
+        ``IInterference`` carries the overlap ``Volume``.
+
+        Args:
+            params (Any): Optional settings. ``coincident`` (bool, default
+                ``False``) treats touching faces as interference;
+                ``include_multibody`` (bool, default ``True``);
+                ``ignore_hidden`` (bool, default ``False``). A ``components``
+                list filters which interferences are reported. ``tolerance``
+                is accepted and ignored - SolidWorks' interference detection
+                has no tolerance setting - and the payload says so.
+
+        Returns:
+            AdapterResult[dict[str, Any]]: ``interference_found``,
+            ``interference_count``, and per-interference component pairs with
+            overlap volumes in mm^3. ``ERROR`` when there is no active model
+            or the active document is not an assembly.
+
+        Raises:
+            Exception: Propagated through ``_handle_com_operation``.
+
+        Example::
+
+            await adapter.check_interference({"coincident": False})
+        """
+        adapter = self._adapter(self)
+        options = _payload_dict(params)
+
+        if not adapter.currentModel:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR, error="No active model"
+            )
+
+        doc_type = _doc_type(adapter)
+        if doc_type != 2:
+            return AdapterResult(
+                status=AdapterResultStatus.ERROR,
+                error=(
+                    "Interference detection requires an assembly document "
+                    f"(active document type is {doc_type!r}, expected 2)"
+                ),
+            )
+
+        coincident = bool(options.get("coincident", False))
+        include_multibody = bool(options.get("include_multibody", True))
+        ignore_hidden = bool(options.get("ignore_hidden", False))
+        wanted = options.get("components") or []
+        wanted_names = {str(name) for name in wanted} if wanted else set()
+
+        def _check() -> dict[str, Any]:
+            assembly = _sw_type_info.flagged(adapter.currentModel, "IAssemblyDoc")
+            manager = adapter._attempt(
+                lambda: assembly.InterferenceDetectionManager, default=None
+            )
+            if manager is None:
+                raise Exception(
+                    "InterferenceDetectionManager is unavailable on this "
+                    "assembly, so no interference check was performed."
+                )
+            manager = _sw_type_info.flagged(manager, "IInterferenceDetectionMgr")
+
+            for name, value in (
+                ("TreatCoincidenceAsInterference", coincident),
+                ("IncludeMultibodyPartInterferences", include_multibody),
+                ("IgnoreHiddenBodies", ignore_hidden),
+                ("MakeInterferingPartsTransparent", False),
+            ):
+                adapter._attempt(
+                    lambda n=name, v=value: setattr(manager, n, v), default=None
+                )
+
+            try:
+                # A real return value: 0 means SolidWorks found nothing, and a
+                # COM failure raises instead of flattening into a false clean
+                # result.
+                count = int(manager.GetInterferenceCount() or 0)
+                interferences = (
+                    adapter._attempt(lambda: manager.GetInterferences(), default=None)
+                    if count
+                    else None
+                )
+                details = _interference_details(adapter, interferences)
+            finally:
+                # Leaves the assembly out of interference-display mode even
+                # when the read above fails.
+                adapter._attempt(lambda: manager.Done(), default=None)
+
+            if wanted_names:
+                details = [
+                    item
+                    for item in details
+                    if wanted_names & set(item.get("components", []))
+                ]
+
+            return {
+                "interference_found": bool(details) if wanted_names else count > 0,
+                "interference_count": len(details) if wanted_names else count,
+                "interferences": details,
+                "coincident_treated_as_interference": coincident,
+                "scope": sorted(wanted_names) if wanted_names else "whole assembly",
+                # Said plainly rather than silently dropped: a caller passing a
+                # tolerance would otherwise assume it was applied.
+                "tolerance_applied": None,
+            }
+
+        return cast(
+            AdapterResult[dict[str, Any]],
+            adapter._handle_com_operation("check_interference", _check),
+        )