Fusion - the Fusion 360 Bridge

@@ -1,18 +1,15 @@-"""Structured, kit-aware mechanical assembly BOM (mirrors Fusion's Manage -> BOM).--The electronics `export_bom` only works on an open PCB board. This is its mechanical-counterpart: it walks the active Design assembly and returns a purchasing BOM that-respects the component hierarchy. It recurses through organizational subassemblies but-counts a physical part or a purchased kit/unit ONCE, so hardware modeled INSIDE a kit-(for example a "... with fasteners" bracket, or a bearing/pulley unit) is not-double-counted the way a flat allOccurrences walk would count it.-"""-+"""Mechanical BOM grouped by resolved component identity, never display name.""" import csv import time+import tempfile+from pathlib import Path  import adsk.core import adsk.fusion+from .mechanical.core import identity, items+from .mechanical.exporting import publish_staged+from .mechanical.assembly_state import metadata+from .physical_properties import own_properties   def _material_name(comp):@@ -21,196 +18,125 @@ def _material_name(comp):             return comp.material.name     except Exception:         pass-    try:-        if comp.bRepBodies.count > 0 and comp.bRepBodies.item(0).material:-            return comp.bRepBodies.item(0).material.name-    except Exception:-        pass     return ""   def _attr(comp, name):-    try:-        v = getattr(comp, name, "") or ""-        return v.strip()-    except Exception:-        return ""+    return (getattr(comp, name, "") or "").strip()   def handle_assembly_bom(app: adsk.core.Application, args: dict) -> dict:-    """Return a structured, kit-aware parts list for the active mechanical design.--    args:-      treatAsUnit  optional list of name substrings whose subassemblies are counted once-                   and NOT exploded (default: ["with fasteners"]).-      exclude      optional list of top-level component-name prefixes to skip entirely.-      includePhysicalProperties  optional bool -- add volume_cm3 / mass_kg per line.-      outputPath   optional str -- also write a CSV to this Windows path.-    """     design = adsk.fusion.Design.cast(app.activeProduct)     if not design:-        return {"success": False, "error": "No active Fusion Design.",-                "_hint": "Open a mechanical design in the Design workspace, then retry."}-+        return {"success": False, "error": "No active Fusion Design."}     args = args or {}-    # Walk budget (issue #659, found by the daily verb suite): an electronics 3D PCB carries an-    # occurrence per pad, so the walk that is instant on mechanical assemblies grinds for minutes,-    # blows the relay window, and blocks the add-in main thread for every later verb. Refuse FAST-    # with a redirect instead: the mechanical walk is the wrong tool for a board anyway.-    budget = float(args.get("maxSeconds", 20))-    deadline = time.time() + budget-    try:-        occ_total = design.rootComponent.allOccurrences.count-    except Exception:-        occ_total = -1-    if occ_total > 3000:-        return {"success": False, "errorCode": "bom_walk_budget_exceeded",-                "occurrences": occ_total,-                "error": "This design has %d occurrences - walking it would block Fusion for minutes." % occ_total,-                "_hint": "This looks like an electronics 3D PCB (an occurrence per pad), and the mechanical "-                         "BOM walk is the wrong tool for a board: use fusion_export_bom for the electronics "-                         "BOM. For a genuinely huge MECHANICAL assembly, re-run with maxSeconds raised "-                         "(e.g. {\"maxSeconds\": 120}) and expect a long wait."}-    kit = [k.lower() for k in (args.get("treatAsUnit") or ["with fasteners", "with fastener"])]+    # Preserve the electronics fast-refusal gate: a 3D PCB contains occurrences+    # per pad and is not a suitable input for this mechanical purchasing BOM.+    if design.rootComponent.allOccurrences.count > 3000:+        return {"success": False, "errorCode": "bom_walk_budget_exceeded", "complete": False,+                "error": "Mechanical BOM occurrence budget exceeded; use fusion_export_bom for a PCB.",+                "occurrences": design.rootComponent.allOccurrences.count}+    raw_kit = args.get("treatAsUnit")+    kit = [k.lower() for k in (["with fasteners", "with fastener"] if raw_kit is None else raw_kit)]     exclude = tuple(args.get("exclude") or [])     include_pp = bool(args.get("includePhysicalProperties", False))+    deadline = time.monotonic() + min(max(float(args.get("maxSeconds", 20)), 0.1), 300)+    parts, collapsed, errors = {}, {}, []++    def add(comp, path, rule=None):+        key = identity(comp)+        if key in parts:+            parts[key]["quantity"] += 1+            parts[key]["occurrencePaths"].append(path)+            return+        row = {"componentId": key, "componentName": comp.name,+               "partNumber": _attr(comp, "partNumber"), "description": _attr(comp, "description"),+               "material": _material_name(comp), "quantity": 1, "bodies": comp.bRepBodies.count,+               "occurrencePaths": [path], "scope": "component_subtree" if rule else "direct_component_bodies"}+        provenance = metadata(comp)+        row.update({name: provenance[name] for name in ("supplier", "supplierPartNumber", "sourceUrl", "sha256", "asPurchased") if name in provenance})+        if include_pp:+            try:+                accuracy = adsk.fusion.CalculationAccuracy.LowCalculationAccuracy+                if rule:+                    pp = comp.getPhysicalProperties(accuracy)+                    row.update(volume_cm3=pp.volume, mass_kg=pp.mass)+                else:+                    row.update({k: v for k, v in own_properties(comp, accuracy).items() if k in ("volume_cm3", "mass_kg")})+            except Exception as exc:+                errors.append({"componentId": key, "error": str(exc)})+                row.update(volume_cm3=None, mass_kg=None)+        parts[key] = row -    def kit_rule(comp):-        n = comp.name.lower()-        for k in kit:-            if k in n:-                return k-        return None--    def is_leaf(comp):-        if kit_rule(comp) is not None:-            return True-        return comp.bRepBodies.count > 0  # a physical part is a leaf--    parts = {}-    # Transparency (issue #25, Oliver + John's call): every heuristic collapse is REPORTED so a-    # name-match on someone's own "bearing test jig" is a visible, correctable decision instead of-    # silently vanishing its internals from the BOM. collapsed = {unitName: {rule, quantity}}.-    collapsed = {}-    # Attribution for the inverse advisory: which DESCENDED subassembly each leaf came from, so a-    # purchased-looking unit that was exploded (240 identical bearing balls) can be flagged.-    sub_stats = {}   # subassembly name -> {part name -> instances}-    sub_stack = []--    class _BudgetExceeded(Exception):-        pass-+    visited = 0     def walk(occs):-        for i in range(occs.count):-            if time.time() > deadline:-                raise _BudgetExceeded()-            occ = occs.item(i)+        nonlocal visited+        for occ in items(occs):+            visited += 1+            if time.monotonic() > deadline or visited > 20000:+                raise TimeoutError("BOM walk budget exceeded.")             comp = occ.component-            name = comp.name-            if any(name.startswith(e) for e in exclude):+            provenance = metadata(comp)+            if provenance.get("excludeFromBom", False):                 continue+            if any(comp.name.startswith(e) for e in exclude):+                continue+            rule = next((k for k in kit if k in comp.name.lower()), None)+            if raw_kit is None and provenance.get("asPurchased", False):+                rule = "asPurchased metadata"             children = occ.childOccurrences-            has_children = children is not None and children.count > 0-            if is_leaf(comp):-                rule = kit_rule(comp)-                if rule is not None and has_children:-                    c = collapsed.setdefault(name, {"unit": name, "matchedRule": rule, "quantity": 0})-                    c["quantity"] += 1-                if sub_stack and rule is None:-                    stats = sub_stats.setdefault(sub_stack[-1], {})-                    stats[name] = stats.get(name, 0) + 1-                row = parts.get(name)-                if row is None:-                    row = {-                        "componentName": name,-                        "partNumber": _attr(comp, "partNumber"),-                        "description": _attr(comp, "description"),-                        "material": _material_name(comp),-                        "quantity": 1,-                        "bodies": comp.bRepBodies.count,-                    }-                    if include_pp:-                        try:-                            pp = comp.getPhysicalProperties(-                                adsk.fusion.CalculationAccuracy.LowCalculationAccuracy)-                            row["volume_cm3"] = round(pp.volume, 4)-                            row["mass_kg"] = round(pp.mass, 6)-                        except Exception:-                            row["volume_cm3"] = None-                            row["mass_kg"] = None-                    parts[name] = row-                else:-                    row["quantity"] += 1-            elif has_children:-                sub_stack.append(name)+            if comp.bRepBodies.count or rule:+                add(comp, occ.fullPathName, rule)+            if rule and children.count:+                row = collapsed.setdefault(identity(comp), {"componentId": identity(comp), "unit": comp.name, "matchedRule": rule, "quantity": 0})+                row["quantity"] += 1+            elif children.count:+                # A component may own bodies AND children. Count both instead of+                # treating every component containing a body as a terminal leaf.                 walk(children)-                sub_stack.pop()      try:-        walk(design.rootComponent.occurrences)-    except _BudgetExceeded:-        return {"success": False, "errorCode": "bom_walk_budget_exceeded",-                "occurrences": occ_total, "budgetSeconds": budget,-                "partialParts": len(parts),-                "error": "BOM walk exceeded its %ds budget (%d part types found so far)." % (budget, len(parts)),-                "_hint": "On an electronics board use fusion_export_bom instead; on a huge mechanical "-                         "assembly re-run with a larger maxSeconds."}+        root = design.rootComponent+        if root.bRepBodies.count:+            add(root, "<root>")+        walk(root.occurrences)+    except Exception as exc:+        return {"success": False, "errorCode": "bom_walk_budget_exceeded" if isinstance(exc, TimeoutError) else "bom_walk_failed", "error": str(exc),+                "complete": False, "partialParts": len(parts)}     rows = list(parts.values())--    doc_name = design.rootComponent.name-    try:-        if design.parentDocument:-            doc_name = design.parentDocument.name-    except Exception:-        pass--    # Inverse advisory (Oliver, PR #38 intent): a DESCENDED subassembly dominated by many-    # identical small parts walks and quacks like a purchased unit that should be one BOM line.-    UNDER_COLLAPSE_MIN = 12-    possible_under = []-    for sub, stats in sub_stats.items():-        part, n = max(stats.items(), key=lambda kv: kv[1])-        if n >= UNDER_COLLAPSE_MIN:-            possible_under.append({-                "subassembly": sub, "dominantPart": part, "instances": n,-                "why": "descended subassembly dominated by %d identical parts; if it is a purchased unit, add a matching substring to treatAsUnit and it becomes one line" % n})--    out = {-        "success": True,-        "design": doc_name,-        "partCount": len(rows),-        "totalInstances": sum(r["quantity"] for r in rows),-        "treatAsUnit": kit,-        "collapsedUnits": sorted(collapsed.values(), key=lambda c: -c["quantity"]),-        "possibleUnderCollapse": sorted(possible_under, key=lambda a: -a["instances"]),-        "parts": rows,-    }-    if collapsed or possible_under:-        bits = []-        if collapsed:-            bits.append("%d subassembly type(s) were COLLAPSED to one line each by treatAsUnit name-matching (see collapsedUnits); if any is one of YOUR designs rather than a purchased unit, re-run with an explicit treatAsUnit list (or []) to explode it" % len(collapsed))-        if possible_under:-            bits.append("%d descended subassembly(ies) look like purchased units (see possibleUnderCollapse); add a matching substring to treatAsUnit to collapse them" % len(possible_under))-        out["_hint"] = ". ".join(bits) + "."---    outpath = args.get("outputPath")-    if outpath:+    out = {"success": not errors, "complete": not errors, "design": design.parentDocument.name,+           "partCount": len(rows), "totalInstances": sum(r["quantity"] for r in rows),+           "treatAsUnit": kit, "collapsedUnits": list(collapsed.values()),+           "possibleUnderCollapse": [], "parts": rows, "errors": errors}+    if collapsed:+        out["_hint"] = "Named purchased-unit rules collapsed subassemblies; inspect collapsedUnits. Pass treatAsUnit:[] to explode all children."+    if args.get("outputPath") and out["success"]:         try:-            cols = ["Part Number", "Part Name", "Description", "Material", "Quantity"]-            if include_pp:-                cols += ["Volume cm3", "Mass kg"]-            with open(outpath, "w", newline="", encoding="utf-8") as f:-                w = csv.writer(f)-                w.writerow(cols)-                for r in rows:-                    line = [r["partNumber"], r["componentName"], r["description"],-                            r["material"], r["quantity"]]+            destination = Path(args["outputPath"])+            if not destination.is_absolute() or destination.suffix.lower() != ".csv":+                raise ValueError("outputPath must be an absolute .csv path.")+            if destination.is_symlink() or destination.is_dir():+                raise ValueError("Destination must be a regular file path.")+            destination.parent.mkdir(parents=True, exist_ok=True)+            with tempfile.TemporaryDirectory(prefix=".adom-bom-", dir=str(destination.parent)) as folder:+                staged = Path(folder) / "bom.csv"+                with staged.open("w", newline="", encoding="utf-8") as stream:+                    writer = csv.writer(stream)+                    columns = ["Component ID", "Part Number", "Part Name", "Description", "Material", "Quantity", "Supplier", "Supplier Part Number", "Source URL", "SHA256"]                     if include_pp:-                        line += [r.get("volume_cm3"), r.get("mass_kg")]-                    w.writerow(line)-            out["outputPath"] = outpath-        except Exception as e:-            out["csvError"] = str(e)-+                        columns += ["Volume cm3", "Mass kg"]+                    writer.writerow(columns)+                    for row in rows:+                        line = [row["componentId"], row["partNumber"], row["componentName"], row["description"], row["material"], row["quantity"]]+                        line += [row.get(name, "") for name in ("supplier", "supplierPartNumber", "sourceUrl", "sha256")]+                        if include_pp:+                            line += [row.get("volume_cm3"), row.get("mass_kg")]+                        # CSV intended for spreadsheet use: text cannot become a formula.+                        writer.writerow([("'" + cell if cell[:1] in "=+-@" else cell) if isinstance(cell, str) and cell else cell for cell in line])+                out.update(publish_staged(staged, destination, args.get("overwrite", True)))+        except Exception as exc:+            if out.get("published"):+                out["cleanupWarning"] = str(exc)+            else:+                out.update(success=False, csvError=str(exc), errorCode="bom_csv_failed", error=str(exc))     return out

@@ -1484,98 +1484,14 @@ def handle_search_cloud_files(app: adsk.core.Application, args: dict) -> dict:   def handle_export_cloud_file(app: adsk.core.Application, args: dict) -> dict:-    """Export the active Fusion document to a local file for transfer.--    Exports the currently open document as STEP, STL, F3D, or other format-    to a local file path. The file can then be pulled back to Docker via pull_file.--    Args:-        args: Dict with:-            - outputPath: Local file path to export to (required).-            - format: Export format (optional, default "step").-                     Supported: "step", "stl", "f3d", "iges", "sat", "smt".-    """-    output_path = args.get("outputPath", "").strip()-    if not output_path:-        return {"success": False, "error": "No outputPath specified."}--    output_path = output_path.replace("\\", "/")+    """Compatibility entry point using the safe shared single-file exporter."""+    from .export import _export     fmt = args.get("format", "step").lower().strip()--    doc = app.activeDocument-    if not doc:-        return {-            "success": False,-            "error": "No active document to export.",-            "_hint": "Call fusion_open_cloud_file to open a file, then retry.",-        }--    # Get the design product-    design = None-    try:-        design = adsk.fusion.Design.cast(app.activeProduct)-    except Exception:-        pass--    if not design:-        return {-            "success": False,-            "error": "Active document is not a Fusion Design. Cannot export.",-            "_hint": "Call fusion_activate_workspace with target='design' or open a Fusion Design document first, then retry.",-            "data": {"hint": "Open a design document first, or switch to the Design workspace."},-        }--    # Ensure output directory exists-    out_dir = os.path.dirname(output_path)-    if out_dir and not os.path.exists(out_dir):-        os.makedirs(out_dir, exist_ok=True)--    root = design.rootComponent-    export_mgr = design.exportManager--    try:-        if fmt in ("step", "stp"):-            options = export_mgr.createSTEPExportOptions(output_path, root)-            export_mgr.execute(options)-        elif fmt == "stl":-            options = export_mgr.createSTLExportOptions(root, output_path)-            export_mgr.execute(options)-        elif fmt in ("iges", "igs"):-            options = export_mgr.createIGESExportOptions(output_path, root)-            export_mgr.execute(options)-        elif fmt == "sat":-            options = export_mgr.createSATExportOptions(output_path, root)-            export_mgr.execute(options)-        elif fmt == "smt":-            options = export_mgr.createSMTExportOptions(output_path, root)-            export_mgr.execute(options)-        elif fmt == "f3d":-            options = export_mgr.createFusionArchiveExportOptions(output_path)-            export_mgr.execute(options)-        else:-            return {-                "success": False,-                "error": f"Unsupported format: {fmt}",-                "data": {"supportedFormats": ["step", "stl", "f3d", "iges", "sat", "smt"]},-            }-    except Exception as e:-        return {"success": False, "error": f"Export failed: {e}"}--    if not os.path.exists(output_path):-        return {"success": False, "error": f"Export file was not created at {output_path}"}--    size = os.path.getsize(output_path)--    return {-        "success": True,-        "output": f"Exported '{doc.name}' as {fmt.upper()} to {output_path} ({size} bytes)",-        "data": {-            "outputPath": output_path,-            "format": fmt,-            "fileSize": size,-            "documentName": doc.name,-        },-    }+    fmt = {"stp": "step", "igs": "iges"}.get(fmt, fmt)+    out = _export(app, args, fmt)+    if out.get("success"):+        out["data"]["documentName"] = app.activeDocument.name+    return out   def handle_walk_cloud_tree(app: adsk.core.Application, args: dict) -> dict:

@@ -1,693 +1,48 @@-"""Export commands — STEP, STL, 3MF, F3D, FBX.+"""Legacy export verbs sharing the guarded single-file staging implementation. -All 3D export commands require an active Fusion Design (3D PCB view or a CAD-design document). Switch to 3D PCB view with fusion_show_3d_board before-exporting from an electronics project.+Legacy callers retain implicit overwrite behavior. The typed mechanical exporter+requires an explicit overwrite:true. Both preserve existing bytes on failure. """- import adsk.core import adsk.fusion-import os-import time-from pathlib import Path---# Shared hint constants — reused across every export handler.-_HINT_NO_OUTPUT_PATH = (-    "Provide an outputPath arg like {\"outputPath\": \"C:\\\\path\\\\out.step\"}. "-    "The path must include the file extension matching the export format."-)-_HINT_FORMAT_UNAVAILABLE = (-    "This format isn't available in this Fusion build. "-    "Use fusion_export_step or fusion_export_stl as a fallback."-)-_HINT_EXPORT_FAILED = (-    "If this persists, call fusion_screenshot_fusion to check for a blocking dialog, "-    "then fusion_send_key with 'escape' or 'enter' to dismiss it. "-    "Wrong-workspace errors: call fusion_show_3d_board first."-)-_HINT_FILE_LOCKED = (-    "Close the file in any viewer (Blender, Windows Explorer preview, etc.), "-    "or call fusion_close_document first if it's open in Fusion, then retry."-)+from .mechanical.exporting import export_design+from .mechanical.core import MechanicalError  -def _get_active_design(app: adsk.core.Application):-    """Get the active Fusion design, or None."""-    product = app.activeProduct-    if product and product.productType == "DesignProductType":-        return adsk.fusion.Design.cast(product)-    return None+def _get_active_design(app):+    return adsk.fusion.Design.cast(app.activeProduct)   def _no_design_error():-    """Standard error when no active design is available."""-    return {-        "success": False,-        "error": "No active design open in Fusion 360.",-        "_hint": "If you're in PCB Editor (2D board), call fusion_show_3d_board to switch to 3D view. Otherwise call fusion_open_cloud_file to open a Design document, then retry.",-        "data": {-            "hint": "3D exports require a Design product. If you're in PCB Editor (2D board), "-                    "switch to 3D view first with fusion_show_3d_board.",-            "recoverySteps": [-                "Run fusion_show_3d_board to switch to 3D PCB view",-                "Or open a .f3d design document",-                "Then retry the export command",-            ],-        },-    }---def _export_success(fmt: str, output_path: str, extra_msg: str = "") -> dict:-    """Standard success response for 3D exports."""-    size = os.path.getsize(output_path) if os.path.exists(output_path) else 0-    return {-        "success": True,-        "output": f"Exported {fmt} to {output_path}",-        "message": f"{fmt} file exported ({size // 1024} KB). "-                   f"{extra_msg}"-                   "Use pull_file to transfer to Docker.",-        "data": {-            "outputPath": output_path,-            "format": fmt.lower(),-            "fileSizeKB": size // 1024,-            "nextSteps": [-                "Use pull_file to transfer the file back to Docker",-                "Export other formats: fusion_export_step, fusion_export_stl, fusion_export_3mf, fusion_export_f3d, fusion_export_fbx",-            ],-        },-    }---def handle_export_step(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a STEP file (.step).--    Industry-standard CAD interchange format. Best for mechanical CAD-    interoperability (SolidWorks, CATIA, Creo, etc.).--    Args:-        outputPath: Full path for the output .step file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    export_mgr = design.exportManager-    options = export_mgr.createSTEPExportOptions(output_path)-    result = export_mgr.execute(options)--    if result:-        return _export_success("STEP", output_path,-                               "Industry-standard CAD interchange — opens in any CAD tool. ")-    return {"success": False, "error": "STEP export failed", "_hint": _HINT_EXPORT_FAILED}---def handle_export_stl(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as an STL file (.stl).--    Mesh-based format for 3D printing and visualization.--    Args:-        outputPath: Full path for the output .stl file (required).-        refinement: "low", "medium", or "high" (default: "medium").-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    root = design.rootComponent-    export_mgr = design.exportManager-    options = export_mgr.createSTLExportOptions(root, output_path)--    refinement = args.get("refinement", "medium").lower()-    refinement_map = {-        "low": adsk.fusion.MeshRefinementSettings.MeshRefinementLow,-        "medium": adsk.fusion.MeshRefinementSettings.MeshRefinementMedium,-        "high": adsk.fusion.MeshRefinementSettings.MeshRefinementHigh,-    }-    options.meshRefinement = refinement_map.get(-        refinement, adsk.fusion.MeshRefinementSettings.MeshRefinementMedium-    )--    result = export_mgr.execute(options)--    if result:-        return _export_success("STL", output_path,-                               f"Mesh refinement: {refinement}. Good for 3D printing. ")-    return {"success": False, "error": "STL export failed", "_hint": _HINT_EXPORT_FAILED}---def handle_export_3mf(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a 3MF file (.3mf).--    Modern 3D printing format — supports color, materials, and multi-body.--    Args:-        outputPath: Full path for the output .3mf file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    root = design.rootComponent-    export_mgr = design.exportManager-    options = export_mgr.createC3MFExportOptions(root, output_path)-    result = export_mgr.execute(options)+    return {"success": False, "errorCode": "no_design", "error": "No active Fusion Design.",+            "_hint": "Open a Design or switch the electronics project to its 3D view."} -    if result:-        return _export_success("3MF", output_path,-                               "Modern 3D printing format with color/material support. ")-    return {"success": False, "error": "3MF export failed", "_hint": _HINT_EXPORT_FAILED}---def handle_export_f3d(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a Fusion 360 archive (.f3d).--    Native Fusion format — preserves all parametric features, sketches,-    timeline history, and component references. Best for archiving or-    sharing with other Fusion 360 users.--    Args:-        outputPath: Full path for the output .f3d file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    export_mgr = design.exportManager-    options = export_mgr.createFusionArchiveExportOptions(output_path)-    result = export_mgr.execute(options)--    if result:-        return _export_success("F3D", output_path,-                               "Fusion 360 native archive — preserves all features and history. ")-    return {"success": False, "error": "F3D export failed", "_hint": _HINT_EXPORT_FAILED}---def handle_export_usdz(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a USDZ file (.usdz).--    Universal Scene Description (USD) — Pixar's scene-graph format adopted-    by Apple, NVIDIA, and Autodesk. Preserves:-    - Full component hierarchy (board, copper layers, soldermask, packages)-    - PBR materials and colors-    - Named nodes for toggling parts on/off in viewers--    Best format for digital twins, AR (Apple Quick Look), and GLB conversion-    via Blender. The component hierarchy maps directly to toggleable nodes-    in GLB viewers.--    Pipeline: Fusion → USDZ → Blender → GLB (or view USDZ directly on iOS)--    Args:-        outputPath: Full path for the output .usdz file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH} +def _export(app, args, fmt):     design = _get_active_design(app)     if not design:         return _no_design_error()--    # Ensure .usdz extension-    if not output_path.lower().endswith(('.usdz', '.usd', '.usda', '.usdc')):-        output_path = str(Path(output_path).with_suffix('.usdz'))--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    # Pre-delete to avoid overwrite dialogs-    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {-                    "hint": "Close the file in any viewer and retry.",-                    "outputPath": output_path,-                },-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createUSDExportOptions(output_path)-    except AttributeError:-        return {-            "success": False,-            "error": "USDZ export not available in this Fusion 360 version.",-            "_hint": _HINT_FORMAT_UNAVAILABLE,-            "data": {-                "hint": "createUSDExportOptions requires a recent Fusion 360 build. "-                        "Export as STEP instead and convert via Blender.",-                "recoverySteps": [-                    "Export STEP: fusion_export_step (then convert in Blender)",-                    "Export OBJ: fusion_export_fbx (falls back to OBJ)",-                ],-            },-        }--    result = export_mgr.execute(options)--    if result and os.path.exists(output_path):-        size = os.path.getsize(output_path)--        # Get component hierarchy for the response-        components = []-        try:-            root = design.rootComponent-            for i in range(root.occurrences.count):-                occ = root.occurrences.item(i)-                components.append(occ.name)-        except Exception:-            pass--        return {-            "success": True,-            "output": f"Exported USDZ to {output_path}",-            "message": f"USDZ exported ({size // 1024} KB) with full component hierarchy. "-                       f"Contains {len(components)} top-level components that map to "-                       f"toggleable nodes in GLB viewers. "-                       f"Use pull_file to transfer to Docker.",-            "data": {-                "outputPath": output_path,-                "format": "usdz",-                "fileSizeKB": size // 1024,-                "components": components,-                "hint": "USDZ preserves PBR materials and scene hierarchy. "-                        "Each component (Board, copper layers, soldermask, Packages) "-                        "becomes a separate toggleable node in the GLB.",-                "nextSteps": [-                    "Use pull_file to transfer the USDZ to Docker",-                    "Convert to GLB: blender --background --python-expr "-                    "\"import bpy; bpy.ops.wm.read_factory_settings(use_empty=True); "-                    "bpy.ops.wm.usd_import(filepath='input.usdz'); "-                    "bpy.ops.export_scene.gltf(filepath='output.glb')\"",-                    "Or view directly on iOS/macOS — USDZ is Apple's native AR format",-                    "Or import into Unity/Unreal Engine for interactive 3D",-                ],-            },-        }--    return {"success": False, "error": "USDZ export failed", "_hint": _HINT_EXPORT_FAILED}---def handle_export_fbx(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as an FBX file (.fbx).--    Autodesk FBX format — widely used for 3D interchange with Blender,-    Unity, Unreal Engine, and other DCC tools.--    NOTE: FBX export is not available in current Fusion 360 builds via the API.-    This command will fail clearly — use fusion_export_usdz or fusion_export_step-    instead. No silent fallbacks.--    Args:-        outputPath: Full path for the output .fbx file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    # Pre-delete to avoid overwrite dialogs-    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {-                    "hint": "The file may be open in another application. Close it and retry.",-                    "outputPath": output_path,-                },-            }--    # Try FBX via exportManager API-    export_mgr = design.exportManager     try:-        options = export_mgr.createFBXExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("FBX", output_path,-                                   "Convert to GLB via Blender: "-                                   "blender --background --python-expr "-                                   "\"import bpy; bpy.ops.import_scene.fbx(filepath='<fbx>'); "-                                   "bpy.ops.export_scene.gltf(filepath='<glb>')\" ")-    except (AttributeError, Exception):-        pass  # createFBXExportOptions doesn't exist in this Fusion build+        data = export_design(design, {**args, "format": fmt, "overwrite": args.get("overwrite", True)})+        data["fileSizeKB"] = data["fileSize"] // 1024+        return {"success": True, "data": data,+                "output": "Exported " + fmt.upper() + " to " + data["outputPath"]}+    except MechanicalError as exc:+        return {"success": False, "errorCode": exc.code, "error": str(exc), **exc.details}+    except Exception as exc:+        return {"success": False, "errorCode": "export_failed", "error": str(exc),+                "destinationPreserved": True} -    # FBX not available — fail clearly, no fallbacks-    return {-        "success": False,-        "error": "FBX export not available in this Fusion 360 build. "-                 "Use fusion_export_usdz or fusion_export_step instead.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "FBX is not supported via the Fusion API in current builds. "-                    "Use fusion_export_usdz (best for Blender/GLB pipeline, preserves "-                    "PBR materials and scene hierarchy) or fusion_export_step "-                    "(highest geometric fidelity).",-            "alternatives": ["fusion_export_usdz", "fusion_export_step", "fusion_export_stl"],-        },-    }---def handle_export_dxf(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a DXF file (.dxf).--    AutoCAD DXF (Drawing Exchange Format) — universal 2D/3D CAD interchange.-    Widely supported by all CAD tools, laser cutters, CNC routers, and-    PCB fabrication houses.--    Args:-        outputPath: Full path for the output .dxf file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {"outputPath": output_path},-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createDXFExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("DXF", output_path,-                                   "Universal CAD interchange — opens in AutoCAD, LibreCAD, etc. ")-    except (AttributeError, Exception):-        pass--    return {-        "success": False,-        "error": "DXF export failed or not available in this Fusion 360 build.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "Try fusion_export_step for CAD interchange instead.",-            "alternatives": ["fusion_export_step", "fusion_export_dwg"],-        },-    }---def handle_export_dwg(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a DWG file (.dwg).--    AutoCAD native format — the industry standard for 2D/3D technical-    drawings. Best for sharing with AutoCAD, BricsCAD, DraftSight users.--    Args:-        outputPath: Full path for the output .dwg file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {"outputPath": output_path},-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createDWGExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("DWG", output_path,-                                   "AutoCAD native format — opens in AutoCAD, BricsCAD, etc. ")-    except (AttributeError, Exception):-        pass--    return {-        "success": False,-        "error": "DWG export failed or not available in this Fusion 360 build.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "Try fusion_export_dxf or fusion_export_step instead.",-            "alternatives": ["fusion_export_dxf", "fusion_export_step"],-        },-    }---def handle_export_iges(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as an IGES file (.igs/.iges).--    Legacy CAD interchange format. Still used by some older CAD systems-    and manufacturing tools. STEP is preferred for modern workflows.--    Args:-        outputPath: Full path for the output .igs file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {"outputPath": output_path},-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createIGESExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("IGES", output_path,-                                   "Legacy CAD interchange — STEP is preferred for modern use. ")-    except (AttributeError, Exception):-        pass--    return {-        "success": False,-        "error": "IGES export failed or not available in this Fusion 360 build.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "Try fusion_export_step instead (modern replacement for IGES).",-            "alternatives": ["fusion_export_step"],-        },-    }---def handle_export_obj(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as an OBJ file (.obj).--    Wavefront OBJ — simple mesh format widely supported by 3D viewers,-    game engines, and DCC tools. No materials or hierarchy.--    Args:-        outputPath: Full path for the output .obj file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {"outputPath": output_path},-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createOBJExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("OBJ", output_path,-                                   "Simple mesh format — opens in Blender, Unity, etc. ")-    except (AttributeError, Exception):-        pass--    return {-        "success": False,-        "error": "OBJ export failed or not available in this Fusion 360 build.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "Try fusion_export_stl or fusion_export_usdz instead.",-            "alternatives": ["fusion_export_stl", "fusion_export_usdz"],-        },-    }---def handle_export_sat(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a SAT file (.sat).--    ACIS SAT — solid modeling kernel format. Used by SolidWorks,-    SpaceClaim, and other ACIS-based CAD tools.--    Args:-        outputPath: Full path for the output .sat file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {"outputPath": output_path},-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createSATExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("SAT", output_path,-                                   "ACIS solid modeling format — opens in SolidWorks, SpaceClaim. ")-    except (AttributeError, Exception):-        pass--    return {-        "success": False,-        "error": "SAT export failed or not available in this Fusion 360 build.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "Try fusion_export_step instead.",-            "alternatives": ["fusion_export_step"],-        },-    }---def handle_export_skp(app: adsk.core.Application, args: dict) -> dict:-    """Export the active design as a SketchUp file (.skp).--    SketchUp format — popular for architectural visualization and-    simple 3D modeling.--    Args:-        outputPath: Full path for the output .skp file (required).-    """-    output_path = args.get("outputPath", "")-    if not output_path:-        return {"success": False, "error": "No outputPath specified", "_hint": _HINT_NO_OUTPUT_PATH}--    design = _get_active_design(app)-    if not design:-        return _no_design_error()--    Path(output_path).parent.mkdir(parents=True, exist_ok=True)--    if os.path.exists(output_path):-        try:-            os.remove(output_path)-        except PermissionError:-            return {-                "success": False,-                "error": f"Cannot overwrite {output_path} — file is locked.",-                "_hint": _HINT_FILE_LOCKED,-                "data": {"outputPath": output_path},-            }--    export_mgr = design.exportManager-    try:-        options = export_mgr.createSKPExportOptions(output_path)-        result = export_mgr.execute(options)-        if result and os.path.exists(output_path):-            return _export_success("SKP", output_path,-                                   "SketchUp format — opens in SketchUp, Trimble viewers. ")-    except (AttributeError, Exception):-        pass -    return {-        "success": False,-        "error": "SketchUp export failed or not available in this Fusion 360 build.",-        "_hint": _HINT_FORMAT_UNAVAILABLE,-        "data": {-            "hint": "Try fusion_export_step or fusion_export_stl instead.",-            "alternatives": ["fusion_export_step", "fusion_export_stl"],-        },-    }+def handle_export_step(app, args): return _export(app, args, "step")+def handle_export_stl(app, args): return _export(app, args, "stl")+def handle_export_3mf(app, args): return _export(app, args, "3mf")+def handle_export_f3d(app, args): return _export(app, args, "f3d")+def handle_export_usdz(app, args): return _export(app, args, "usdz")+def handle_export_fbx(app, args): return _export(app, args, "fbx")+def handle_export_dxf(app, args): return _export(app, args, "dxf")+def handle_export_dwg(app, args): return _export(app, args, "dwg")+def handle_export_iges(app, args): return _export(app, args, "iges")+def handle_export_obj(app, args): return _export(app, args, "obj")+def handle_export_sat(app, args): return _export(app, args, "sat")+def handle_export_skp(app, args): return _export(app, args, "skp")

@@ -0,0 +1,158 @@+"""Guarded mechanical dispatcher and session-scoped operation ledger.++The ledger is independent of HTTP waiters: a timed-out operation can be queried+and retried with the same ID. A restart changes sessionId, so replay fails closed.+"""+import copy+import json+import math+from pathlib import Path+import time+import threading++from .core import SESSION_ID, UNITS, MechanicalError, active, digest, require+from .operations import OPERATIONS, WRITES+from . import transactions, sketches, features, assemblies, purchased, bill_of_materials++for _name, _handler in {**sketches.OPERATIONS, **features.OPERATIONS, **assemblies.OPERATIONS}.items():+    OPERATIONS[_name] = lambda app, args, fn=_handler: transactions.execute(app, args, fn)+    WRITES.add(_name)+OPERATIONS.update(assemblies.READS)+OPERATIONS.update(purchased.OPERATIONS)+OPERATIONS.update(bill_of_materials.OPERATIONS)+WRITES.update(purchased.WRITES | bill_of_materials.WRITES)+OPERATIONS["transaction_probe"] = transactions.probe+WRITES.add("transaction_probe")++_ledger = {}+_ledger_lock = threading.RLock()+MAX_OPERATIONS = 2000+SCHEMA = json.loads((Path(__file__).with_name("schema.json")).read_text(encoding="utf-8"))+++def validate(value, schema, path="args"):+    if "oneOf" in schema:+        variants = schema["oneOf"]+        # Discriminator errors should explain the selected operation/primitive,+        # rather than returning a wall of errors from unrelated variants.+        if isinstance(value, dict):+            for discriminator in ("type", "action"):+                if discriminator in value:+                    matching = [variant for variant in variants if value[discriminator] in+                                variant.get("properties", {}).get(discriminator, {}).get("enum", [])]+                    if len(matching) == 1:+                        validate(value, matching[0], path)+                        variants = []+                        break+        if variants:+            successes = 0+            for variant in variants:+                try:+                    validate(value, variant, path)+                    successes += 1+                except MechanicalError:+                    pass+            require(successes == 1, "invalid_input", path + " must match exactly one supported schema variant")+    kinds = {"object": dict, "string": str, "boolean": bool, "number": (int, float), "integer": int, "array": list}+    kind = schema.get("type")+    if kind:+        require(isinstance(value, kinds[kind]) and not (kind in ("number", "integer") and isinstance(value, bool)),+                "invalid_input", path + " must be " + kind)+    if kind in ("number", "integer"):+        require(math.isfinite(value), "invalid_input", path + " must be finite")+        if "exclusiveMinimum" in schema:+            require(value > schema["exclusiveMinimum"], "invalid_input", path + " is too small")+        if "minimum" in schema:+            require(value >= schema["minimum"], "invalid_input", path + " is too small")+        if "maximum" in schema:+            require(value <= schema["maximum"], "invalid_input", path + " is too large")+    if kind == "array":+        require(schema.get("minItems", 0) <= len(value) <= schema.get("maxItems", 10000), "invalid_input", path + " has an invalid item count")+        for index, item in enumerate(value):+            validate(item, schema.get("items", {}), path + "[" + str(index) + "]")+    if "enum" in schema:+        require(value in schema["enum"], "invalid_input", path + " has an unsupported value")+    if kind == "object":+        require(len(value) >= schema.get("minProperties", 0), "invalid_input", path + " requires at least one property")+        for key in schema.get("required", []):+            require(key in value, "invalid_input", path + "." + key + " is required")+        props = schema.get("properties", {})+        if schema.get("additionalProperties") is False:+            require(not (set(value) - set(props)), "invalid_input", path + " has unknown fields")+        for key in value.keys() & props.keys():+            validate(value[key], props[key], path + "." + key)+        if isinstance(schema.get("additionalProperties"), dict):+            for key in value.keys() - props.keys():+                validate(value[key], schema["additionalProperties"], path + "." + key)+++def capabilities(app, args):+    return {"success": True, "sessionId": SESSION_ID, "schemaVersion": 1, "units": UNITS,+            "operations": SCHEMA, "transactions": {"genericAtomicBatch": False, "typedModelOperations": transactions.capability(),+            "parameterRecovery": "compensating expression restore with semantic readback",+            "newDesignRecovery": "discard only the new unsaved document",+            "externalEffects": "exports publish atomically; model recovery does not undo files"},+            "idempotency": {"scope": "running add-in session", "capacity": MAX_OPERATIONS,+                            "restartBehavior": "old session IDs rejected"}}+++def operation_status(app, args):+    if args.get("sessionId") != SESSION_ID:+        return {"success": False, "errorCode": "session_mismatch", "sessionId": SESSION_ID,+                "error": "Add-in session changed; previous operation outcome is unknown. Inspect before deciding what to do."}+    with _ledger_lock:+        entry = copy.deepcopy(_ledger.get(args.get("operationId")))+    if not entry:+        return {"success": False, "errorCode": "operation_unknown", "sessionId": SESSION_ID,+                "error": "No operation with this ID is recorded in this session.", "outcome": "unknown"}+    return {"success": True, "sessionId": SESSION_ID, "operationId": args["operationId"],+            "state": entry["state"], "result": copy.deepcopy(entry.get("result"))}+++def handle_mechanical(app, args):+    operation_id, entry = None, None+    try:+        require(isinstance(args, dict), "invalid_input", "Arguments must be an object.")+        # Bridge/relay metadata is not an operation argument. Authorization stays+        # in the bridge envelope; changing a transport time budget must not alter+        # an operation's retry fingerprint. Strip only these known-owned keys.+        args = {key: value for key, value in args.items() if key not in ("caller", "_callerBudgetMs")}+        op = args.get("op")+        require(op in OPERATIONS, "unsupported_operation", "Discover supported operations with fusion_mech_capabilities.")+        validate(args, SCHEMA[op])+        # Reject typos before mutating; no silently ignored arguments in the typed layer.+        allowed = set(SCHEMA[op]["properties"]) | {"op", "sessionId", "operationId", "target"}+        require(not (set(args) - allowed), "invalid_input", "Unknown operation arguments: " + ", ".join(sorted(set(args) - allowed)))+        write = op in WRITES or (op == "health" and args.get("recompute", False))+        if write:+            require(args.get("sessionId") == SESSION_ID, "session_mismatch", "Use sessionId from fusion_mech_capabilities; add-in restarts invalidate old requests.")+            operation_id = args.get("operationId")+            require(isinstance(operation_id, str) and 1 <= len(operation_id) <= 128, "operation_id_required", "Every write needs a unique operationId (reuse exactly for retries).")+            fingerprint = digest(args)+            with _ledger_lock:+                existing = _ledger.get(operation_id)+                if existing:+                    require(existing["fingerprint"] == fingerprint, "operation_conflict", "operationId was already used with different arguments.")+                    if existing.get("result") is not None:+                        result = copy.deepcopy(existing["result"])+                        result["replayed"] = True+                        return result+                    return {"success": False, "errorCode": "operation_in_progress", "operationId": operation_id,+                            "sessionId": SESSION_ID, "error": "Operation is already executing; query its status."}+                require(len(_ledger) < MAX_OPERATIONS, "operation_capacity", "Session operation ledger is full; existing results remain queryable.")+                entry = {"fingerprint": fingerprint, "state": "running", "startedAt": time.time()}+                _ledger[operation_id] = entry+        data = OPERATIONS[op](app, args)+        result = {"success": True, "sessionId": SESSION_ID, "operation": op, "data": data}+    except MechanicalError as exc:+        result = {"success": False, "sessionId": SESSION_ID, "errorCode": exc.code,+                  "error": str(exc), **exc.details}+    except Exception as exc:+        result = {"success": False, "sessionId": SESSION_ID, "errorCode": "mechanical_failed",+                  "error": str(exc), "recovery": {"verified": False, "strategy": "none"}}+    if entry is not None:+        result["operationId"] = operation_id+        with _ledger_lock:+            entry["state"] = "succeeded" if result["success"] else "failed"+            entry["result"] = copy.deepcopy(result)+    return result

@@ -0,0 +1,454 @@+"""Typed component definitions, placements, joint motion and interference."""+import math++import adsk.core+import adsk.fusion++from .core import (identity, items, number, point_mm, ref, require, resolve, same, target)+from .assembly_state import GROUP, MOTION_SCALES, joint_data, joint_motion, metadata, rigid_group_data+from .sketches import collection, component, named+++def hybrid(design):+    enum = getattr(adsk.fusion, "DesignIntentTypes", None)+    require(enum is not None and hasattr(design, "designIntent"), "unsupported_capability", "This operation requires an inspectable Hybrid design intent.")+    require(design.designIntent == enum.HybridDesignIntentType, "hybrid_design_required", "Internal components require Hybrid design intent. Create a new Hybrid design; existing intent is never changed implicitly.")+++def transform(spec=None):+    spec = spec or {}+    matrix = adsk.core.Matrix3D.create()+    angle = number(spec.get("angle", 0), "angle")+    axis = spec.get("axis", [0, 0, 1])+    vector = adsk.core.Vector3D.create(*axis)+    require(vector.length > 1e-9, "invalid_input", "Rotation axis must be nonzero.")+    require(matrix.setToRotation(math.radians(angle), vector, adsk.core.Point3D.create(0, 0, 0)), "invalid_transform", "Fusion refused rotation transform.")+    matrix.translation = adsk.core.Vector3D.create(*[number(n, "position") / 10 for n in spec.get("position", [0, 0, 0])])+    return matrix+++def occurrence_data(occ, value):+    matrix = list(occ.transform2.asArray())+    for index in (3, 7, 11):+        matrix[index] *= 10+    return {"ref": ref(occ, value), "component": {"ref": ref(occ.component, value), "id": identity(occ.component), **metadata(occ.component)},+            "path": occ.fullPathName, "transform": matrix, "transformLayout": "row-major", "translationUnit": "mm",+            "space": "assembly_context", "grounded": occ.isGrounded, "groundedToParent": occ.isGroundToParent}+++def require_transform(actual, expected, message):+    require_transform_values(list(actual.asArray()), list(expected.asArray()), message)+++def require_transform_values(actual_values, expected_values, message):+    require(len(actual_values) == len(expected_values) == 16+            and all(math.isfinite(a) and math.isfinite(b) and abs(a-b) < 1e-8+                    for a, b in zip(actual_values, expected_values)), "placement_refused", message)+++def created_occurrence_contexts(design, parent, occurrence):+    """Find placed root proxies without reading a definition-local token."""+    if same(parent, design.rootComponent):+        return [occurrence]+    native = getattr(occurrence, "nativeObject", None) or occurrence+    all_occurrences = items(design.rootComponent.allOccurrences)+    contexts = [o for o in all_occurrences if same(getattr(o, "nativeObject", None) or o, native)]+    if not contexts:+        parents = [o for o in all_occurrences if same(o.component, parent)]+        contexts = [native.createForAssemblyContext(o) for o in parents]+    require(contexts and all(o is not None and o.isValid for o in contexts), "occurrence_context_failed", "Could not obtain placed root-context instances for the new occurrence.")+    return contexts+++def context_placements(design, parent, contexts, expected):+    local_values = list(expected.asArray())+    require_transform_values(local_values, local_values, "Requested transform must be a complete finite matrix.")+    if same(parent, design.rootComponent):+        return [(context, local_values) for context in contexts]+    parents_by_path = {}+    for candidate in items(design.rootComponent.allOccurrences):+        if same(candidate.component, parent):+            parents_by_path.setdefault(candidate.fullPathName, []).append(candidate)+    placements, seen_parents = [], set()+    for context in contexts:+        parent_context = context.assemblyContext+        parent_matches = parents_by_path.get(parent_context.fullPathName, []) if parent_context is not None else []+        require(parent_context is not None and same(parent_context.component, parent)+                and len(parent_matches) == 1 and same(parent_matches[0], parent_context),+                "occurrence_context_failed", "New occurrence's parent must identify an exact root-context instance.")+        require(parent_context.fullPathName not in seen_parents, "occurrence_context_failed", "New occurrence has duplicate parent contexts.")+        seen_parents.add(parent_context.fullPathName)+        parent_values = list(parent_context.transform2.asArray())+        require_transform_values(parent_values, parent_values, "Parent transform must be a complete finite matrix.")+        # Row-major matrices: parent root pose composed with requested local pose.+        world_values = [sum(parent_values[row*4+k] * local_values[k*4+column] for k in range(4))+                        for row in range(4) for column in range(4)]+        placements.append((context, world_values))+    require(seen_parents == set(parents_by_path), "occurrence_context_failed", "New occurrence must resolve in every placed parent instance.")+    return placements+++def place_created_occurrence(design, parent, occurrence, expected):+    # Paste New may leave a pending pose and reused parent instances can inherit+    # the source pose. Transform overrides must use root proxies, never the local+    # occurrence. Apply every instance and capture once before shared recompute.+    contexts = created_occurrence_contexts(design, parent, occurrence)+    for context, values in context_placements(design, parent, contexts, expected):+        matrix = expected+        if not same(parent, design.rootComponent):+            matrix = adsk.core.Matrix3D.create()+            require(matrix.setWithArray(values), "placement_failed", "Could not construct the requested root-context placement.")+        context.transform2 = matrix+        require_transform_values(list(context.transform2.asArray()), values, "Fusion refused the requested occurrence transform.")+    captured = False+    if design.snapshots.hasPendingSnapshot:+        require(design.snapshots.add() is not None, "placement_failed", "Could not capture the new occurrence positions.")+        captured = True+    return captured+++def created_occurrence_result(design, parent, occurrence, value, expected=None):+    """Return and verify every placed instance in root assembly coordinates.++    The local transform can retain its base pose even when captured positions+    are correct. Verify the computed root proxies, each against its exact parent.+    """+    contexts = created_occurrence_contexts(design, parent, occurrence)+    if expected is not None:+        for context, values in context_placements(design, parent, contexts, expected):+            require_transform_values(list(context.transform2.asArray()), values,+                                     "Recompute did not retain the requested placement in every parent instance.")+    rows = [occurrence_data(o, value) for o in contexts]+    return {"occurrence": rows[0], "affectedOccurrences": rows,+            "placementSpace": "parent_component", "referenceSpace": "root_assembly",+            "placementScope": "all_current_parent_instances", "editScope": "parent_component_definition"}+++def parent_component(design, value, args):+    return component(design, value, {"component": args["parent"]} if "parent" in args else {})+++def component_create(design, value, args):+    hybrid(design)+    parent = parent_component(design, value, args)+    expected = transform(args.get("transform"))+    occ = parent.occurrences.addNewComponent(expected)+    require(occ and occ.isValid, "creation_failed", "Component creation failed.")+    named(occ.component, args)+    if args.get("metadata"):+        apply_metadata(occ.component, args["metadata"])+    captured = place_created_occurrence(design, parent, occ, expected)+    return lambda fresh: {**created_occurrence_result(design, parent, occ, fresh, expected), "positionCaptured": captured}+++def occurrence_insert(design, value, args):+    hybrid(design)+    parent = parent_component(design, value, args)+    comp = resolve(design, value, args["component"], ("Component",))+    require(not same(comp, design.rootComponent), "invalid_component", "Root component cannot be instanced.")+    # Avoid cyclic containment before asking the kernel to insert.+    descendants = [comp] + [o.component for o in items(comp.allOccurrences)]+    require(not any(same(parent, c) for c in descendants), "cyclic_assembly", "A component cannot contain itself or its ancestor.")+    method = parent.occurrences.addNewComponentCopy if args.get("independentCopy", False) else parent.occurrences.addExistingComponent+    expected = transform(args.get("transform"))+    occ = method(comp, expected)+    require(occ and occ.isValid, "creation_failed", "Occurrence insertion failed.")+    captured = place_created_occurrence(design, parent, occ, expected)+    return lambda fresh: {**created_occurrence_result(design, parent, occ, fresh, expected), "positionCaptured": captured}+++def occurrence_update(design, value, args):+    require(any(k in args for k in ("transform", "grounded", "groundedToParent")), "invalid_input", "Occurrence update requires a placement or grounding change.")+    occ = resolve(design, value, args["occurrence"], ("Occurrence",))+    if "grounded" in args:+        occ.isGrounded = args["grounded"]+    if "groundedToParent" in args:+        occ.isGroundToParent = args["groundedToParent"]+    if "transform" in args:+        require(not occ.isGrounded and not occ.isGroundToParent, "grounded_occurrence", "Unground the occurrence explicitly before moving it.")+        expected = transform(args["transform"])+        occ.transform2 = expected+        actual = occ.transform2.asArray()+        require(all(abs(a-b) < 1e-8 for a,b in zip(actual, expected.asArray())), "placement_refused", "Constraints prevented the requested occurrence transform.")+        if design.snapshots.hasPendingSnapshot:+            require(design.snapshots.add() is not None, "placement_failed", "Could not capture occurrence position in the timeline.")+    require("grounded" not in args or occ.isGrounded == args["grounded"], "grounding_refused", "Grounding did not match the request.")+    require("groundedToParent" not in args or occ.isGroundToParent == args["groundedToParent"], "grounding_refused", "Parent grounding did not match the request.")+    def result(fresh):+        if "transform" in args:+            expected = transform(args["transform"])+            require(all(abs(a-b) < 1e-8 for a,b in zip(occ.transform2.asArray(), expected.asArray())),+                    "placement_refused", "Recompute did not retain the requested occurrence transform.")+        require("grounded" not in args or occ.isGrounded == args["grounded"], "grounding_refused", "Recompute did not retain grounding.")+        require("groundedToParent" not in args or occ.isGroundToParent == args["groundedToParent"], "grounding_refused", "Recompute did not retain parent grounding.")+        return {"occurrence": occurrence_data(occ, fresh)}+    return result+++def occurrence_delete(design, value, args):+    occ = resolve(design, value, args["occurrence"], ("Occurrence",))+    path = occ.fullPathName+    require(occ.deleteMe(), "delete_failed", "Fusion refused occurrence deletion.")+    return {"deletedPath": path}+++def apply_metadata(comp, changes):+    for key in ("name", "partNumber", "description"):+        if key in changes:+            setattr(comp, key, changes[key])+    import json+    for key in changes.keys() - {"name", "partNumber", "description"}:+        require(comp.attributes.add(GROUP, key, json.dumps(changes[key], sort_keys=True)) is not None, "metadata_failed", "Could not persist " + key)+++def component_metadata(design, value, args):+    comp = component(design, value, args)+    apply_metadata(comp, args["changes"])+    return lambda fresh: {"component": {"ref": ref(comp, fresh), **metadata(comp)}}+++def require_root_context(design, entity):+    context = entity if entity.objectType.endswith("::Occurrence") else getattr(entity, "assemblyContext", None)+    if context is not None:+        require(any(same(o, context) and o.fullPathName == context.fullPathName for o in items(design.rootComponent.allOccurrences)),+                "root_context_required", "Assembly analysis and joints require a root-context occurrence reference from inspect.")+    else:+        owner = getattr(entity, "parentComponent", None) or getattr(entity, "component", None)+        if hasattr(entity, "body"):+            owner = entity.body.parentComponent+        if hasattr(entity, "parentSketch"):+            owner = entity.parentSketch.parentComponent+        require(owner is not None and same(owner, design.rootComponent), "occurrence_context_required", "Non-root geometry requires a specific occurrence-context reference.")+++def joint_geometry(design, value, raw):+    entity = resolve(design, value, raw["entity"], ("SketchPoint", "ConstructionPoint", "BRepVertex", "BRepEdge", "BRepFace"))+    require_root_context(design, entity)+    kind = entity.objectType.split("::")[-1]+    default = "middle" if kind == "BRepFace" and entity.geometry.objectType.endswith(("::Cylinder", "::Cone")) else "center"+    key = getattr(adsk.fusion.JointKeyPointTypes, {"center": "CenterKeyPoint", "start": "StartKeyPoint", "middle": "MiddleKeyPoint", "end": "EndKeyPoint"}[raw.get("keyPoint", default)])+    if kind in ("SketchPoint", "ConstructionPoint", "BRepVertex"):+        result = adsk.fusion.JointGeometry.createByPoint(entity)+    elif kind == "BRepEdge":+        result = adsk.fusion.JointGeometry.createByCurve(entity, key)+    elif entity.geometry.objectType.endswith("::Plane"):+        result = adsk.fusion.JointGeometry.createByPlanarFace(entity, None, key)+    else:+        result = adsk.fusion.JointGeometry.createByNonPlanarFace(entity, key)+    require(result is not None, "invalid_joint_geometry", "Fusion could not infer the joint origin.")+    return result+++def set_limits(motion, name, values, scale):+    require(hasattr(motion, name), "wrong_joint_type", "Joint does not support " + name)+    limits = getattr(motion, name)+    minimum = values.get("minimum", limits.minimumValue * scale)+    maximum = values.get("maximum", limits.maximumValue * scale)+    minimum_enabled = values.get("minimumEnabled", "minimum" in values or limits.isMinimumValueEnabled)+    maximum_enabled = values.get("maximumEnabled", "maximum" in values or limits.isMaximumValueEnabled)+    require(not (minimum_enabled and maximum_enabled) or minimum <= maximum, "invalid_limits", "Minimum joint limit must not exceed maximum.")+    rest = values.get("rest", limits.restValue * scale)+    rest_enabled = values.get("restEnabled", "rest" in values or limits.isRestValueEnabled)+    require(not rest_enabled or (not minimum_enabled or rest >= minimum) and (not maximum_enabled or rest <= maximum), "invalid_limits", "Rest position must lie within enabled limits.")+    limits.isMinimumValueEnabled = False+    limits.isMaximumValueEnabled = False+    for key in ("minimum", "maximum", "rest"):+        if key in values:+            setattr(limits, key + "Value", number(values[key], key) / scale)+    limits.isMinimumValueEnabled = minimum_enabled+    limits.isMaximumValueEnabled = maximum_enabled+    limits.isRestValueEnabled = rest_enabled+++def configure_joint(design, joint, args):+    if "name" in args:+        joint.name = args["name"]+    if "suppressed" in args:+        joint.isSuppressed = args["suppressed"]+    motion = joint_motion(joint)+    for prefix, scale in MOTION_SCALES.items():+        if prefix + "Limits" in args:+            set_limits(motion, prefix + "Limits", args[prefix + "Limits"], scale)+        if prefix + "Value" in args:+            require(hasattr(motion, prefix + "Value"), "wrong_joint_type", "Joint does not support " + prefix)+            number_value = number(args[prefix + "Value"], prefix + "Value") / scale+            limits = getattr(motion, prefix + "Limits")+            require(not limits.isMinimumValueEnabled or number_value >= limits.minimumValue, "joint_limit_exceeded", "Drive value is below minimum.")+            require(not limits.isMaximumValueEnabled or number_value <= limits.maximumValue, "joint_limit_exceeded", "Drive value is above maximum.")+            setattr(motion, prefix + "Value", number_value)+    # Joint value and suppression setters alter pending assembly state. Capture+    # once, after all requested changes, so computeAll replays that state instead+    # of resetting it. Rest values and limit flags stay intact.+    captured = False+    if ("suppressed" in args or any(prefix + "Value" in args for prefix in MOTION_SCALES)) and design.snapshots.hasPendingSnapshot:+        require(design.snapshots.add() is not None, "joint_capture_failed", "Could not capture the edited assembly state.")+        captured = True+    return captured+++def joint_result(joint, value, args):+    result = joint_data(joint, value)+    for field in ("name", "suppressed"):+        if field in args:+            require(result[field] == args[field], "joint_edit_refused", "Joint did not retain requested " + field + ".")+    for prefix in MOTION_SCALES:+        for suffix in ("Value", "Limits"):+            key = prefix + suffix+            if key in args:+                require(key in result, "joint_readback_failed", "Joint motion readback is unavailable.")+                if suffix == "Value":+                    require(math.isclose(result[key], args[key], rel_tol=1e-8, abs_tol=1e-6), "joint_drive_refused", "Joint did not reach the requested drive value.")+                else:+                    expected_limits = dict(args[key])+                    for field in ("minimum", "maximum", "rest"):+                        if field in expected_limits and field + "Enabled" not in expected_limits:+                            expected_limits[field + "Enabled"] = True+                    for field, expected in expected_limits.items():+                        actual = result[key][field]+                        require(actual == expected if isinstance(expected, bool) else math.isclose(actual, expected, rel_tol=1e-8, abs_tol=1e-6), "joint_limits_refused", "Joint limit did not read back: " + field)+    return {"joint": result}+++def rigid_group_result(group, value, args):+    result = rigid_group_data(group, value)+    for field in ("name", "suppressed"):+        if field in args:+            require(result[field] == args[field], "rigid_group_edit_refused", "Rigid group did not retain requested " + field + ".")+    return {"rigidGroup": result}+++def joint_create(design, value, args):+    first, second = [resolve(design, value, args[key], ("Occurrence",)) for key in ("occurrenceOne", "occurrenceTwo")]+    require(not same(first, second), "invalid_joint", "Joint requires two distinct occurrences.")+    for occurrence in (first, second):+        require_root_context(design, occurrence)+    geometry = joint_geometry(design, value, args["geometry"]) if args["type"] != "rigid" else None+    group = design.rootComponent.asBuiltJoints+    inp = group.createInput(first, second, geometry)+    method = getattr(inp, {"rigid": "setAsRigidJointMotion", "revolute": "setAsRevoluteJointMotion", "slider": "setAsSliderJointMotion", "cylindrical": "setAsCylindricalJointMotion", "pin_slot": "setAsPinSlotJointMotion", "planar": "setAsPlanarJointMotion", "ball": "setAsBallJointMotion"}[args["type"]])+    direction = getattr(adsk.fusion.JointDirections, args.get("axis", "z").upper() + "AxisJointDirection")+    if args["type"] == "rigid":+        ok = method()+    elif args["type"] == "ball":+        ok = method(adsk.fusion.JointDirections.ZAxisJointDirection, adsk.fusion.JointDirections.XAxisJointDirection)+    elif args["type"] == "pin_slot":+        require(args.get("axis", "z") != args.get("slideAxis", "x"), "invalid_joint_axes", "Pin-slot rotation and slide directions must differ.")+        ok = method(direction, getattr(adsk.fusion.JointDirections, args.get("slideAxis", "x").upper() + "AxisJointDirection"))+    else:+        ok = method(direction)+    require(ok, "joint_failed", "Joint motion definition failed.")+    joint = group.add(inp)+    require(joint and joint.isValid, "joint_failed", "As-built joint creation failed.")+    captured = configure_joint(design, joint, args)+    return lambda fresh: {**joint_result(joint, fresh, args), "positionCaptured": captured}+++def joint_edit(design, value, args):+    require(any(k in args for k in ("name", "suppressed")) or any(prefix + suffix in args for prefix in MOTION_SCALES for suffix in ("Limits", "Value")), "invalid_input", "Joint edit requires a change.")+    joint = resolve(design, value, args["joint"], ("Joint", "AsBuiltJoint"))+    captured = configure_joint(design, joint, args)+    return lambda fresh: {**joint_result(joint, fresh, args), "positionCaptured": captured}+++def joint_delete(design, value, args):+    joint = resolve(design, value, args["joint"], ("Joint", "AsBuiltJoint"))+    name = joint.name+    require(joint.deleteMe(), "delete_failed", "Fusion refused joint deletion.")+    return {"deletedJoint": name}+++def rigid_group_create(design, value, args):+    occurrences = [resolve(design, value, raw, ("Occurrence",)) for raw in args["occurrences"]]+    require(len({identity(o) for o in occurrences}) == len(occurrences), "duplicate_selection", "Rigid group occurrences must be distinct.")+    for occurrence in occurrences:+        require_root_context(design, occurrence)+    group = design.rootComponent.rigidGroups.add(collection(occurrences), args.get("includeChildren", True))+    named(group, args)+    return lambda fresh: rigid_group_result(group, fresh, args)+++def rigid_group_edit(design, value, args):+    require("name" in args or "suppressed" in args, "invalid_input", "Rigid group edit requires a change.")+    group = resolve(design, value, args["group"], ("RigidGroup",))+    if "name" in args:+        group.name = args["name"]+    if "suppressed" in args:+        group.isSuppressed = args["suppressed"]+    captured = False+    if "suppressed" in args and design.snapshots.hasPendingSnapshot:+        require(design.snapshots.add() is not None, "rigid_group_capture_failed", "Could not capture the edited rigid group state.")+        captured = True+    return lambda fresh: {**rigid_group_result(group, fresh, args), "positionCaptured": captured}+++def rigid_group_delete(design, value, args):+    group = resolve(design, value, args["group"], ("RigidGroup",))+    name = group.name+    require(group.deleteMe(), "delete_failed", "Fusion refused rigid group deletion.")+    return {"deletedRigidGroup": name}+++def assembly_properties(app, args):+    _, design, value = target(app, args)+    entity = resolve(design, value, args["entity"], ("Component", "Occurrence", "BRepBody")) if args.get("entity") else design.rootComponent+    props = entity.getPhysicalProperties(adsk.fusion.CalculationAccuracy.HighCalculationAccuracy)+    volume = props.volume * 1000+    is_occurrence = entity.objectType.endswith("::Occurrence")+    return {"target": value, "entity": ref(entity, value), "mass": props.mass, "volume": volume,+            "area": props.area * 100, "centerOfMass": point_mm(props.centerOfMass),+            "averageDensity": props.mass / volume if volume else None,+            "units": {"mass": "kg", "volume": "mm3", "area": "mm2", "centerOfMass": "mm", "averageDensity": "kg/mm3"},+            "scope": "body" if entity.objectType.endswith("::BRepBody") else "component_subtree",+            "space": "assembly_context" if is_occurrence or getattr(entity, "assemblyContext", None) else "component",+            "materialBasis": "Fusion assigned/default material; supplier provenance does not certify modeled material density"}+++def interference(app, args):+    _, design, value = target(app, args)+    entities = [resolve(design, value, r, ("Occurrence", "BRepBody")) for r in args["entities"]]+    selected_bodies = set()+    walked = 0+    def body_instances(entity, depth=0):+        nonlocal walked+        walked += 1+        require(depth <= 100 and walked <= 20000, "inspection_budget", "Interference assembly exceeds traversal budget.")+        if entity.objectType.endswith("::BRepBody"):+            native = getattr(entity, "nativeObject", None) or entity+            context = getattr(entity, "assemblyContext", None)+            return {(identity(native), context.fullPathName if context else "<root>")}+        result = set()+        for body in items(entity.bRepBodies):+            walked += 1+            require(walked <= 20000, "inspection_budget", "Interference assembly exceeds shared body traversal budget.")+            native = getattr(body, "nativeObject", None) or body+            result.add((identity(native), entity.fullPathName))+        for child in items(entity.childOccurrences):+            result.update(body_instances(child, depth + 1))+        require(len(result) <= 20000, "inspection_budget", "Interference assembly exceeds body budget.")+        return result+    for index, entity in enumerate(entities):+        require(not any(same(entity, earlier) for earlier in entities[:index]), "duplicate_selection", "Interference entities must be distinct.")+        require_root_context(design, entity)+        instances = body_instances(entity)+        require(not selected_bodies.intersection(instances), "overlapping_selection", "Selections include the same physical body instance more than once; choose disjoint occurrences/bodies.")+        selected_bodies.update(instances)+        require(len(selected_bodies) <= 20000, "inspection_budget", "Interference selection exceeds physical body instance budget.")+    inp = design.createInterferenceInput(collection(entities))+    inp.areCoincidentFacesIncluded = args.get("includeTouching", False)+    results = design.analyzeInterference(inp)+    require(results is not None, "interference_failed", "Fusion did not return an interference result.")+    rows = []+    for result in items(results):+        body = result.interferenceBody+        volume = body.volume * 1000 if body else 0.0+        rows.append({"entityOne": ref(result.entityOne, value), "entityTwo": ref(result.entityTwo, value),+                     "volume": volume, "classification": "overlap" if volume > args.get("volumeTolerance", 1e-6) else "touching"})+    return {"target": value, "complete": True, "results": rows, "volumeUnit": "mm3", "bodiesCreated": False}+++OPERATIONS = {"component_create": component_create, "occurrence_insert": occurrence_insert,+              "occurrence_update": occurrence_update, "occurrence_delete": occurrence_delete,+              "component_metadata": component_metadata, "joint_create": joint_create, "joint_edit": joint_edit,+              "joint_delete": joint_delete, "rigid_group_create": rigid_group_create,+              "rigid_group_edit": rigid_group_edit, "rigid_group_delete": rigid_group_delete}+READS = {"interference": interference, "assembly_properties": assembly_properties}

@@ -0,0 +1,94 @@+"""Assembly readback shared by inspection, stale guards and recovery witnesses."""+import json+import math+import adsk.fusion++from .core import identity, items, ref, require++GROUP = "AdomMechanical"+MOTION_SCALES = {"rotation": 180 / math.pi, "slide": 10, "primarySlide": 10, "secondarySlide": 10,+                 "pitch": 180 / math.pi, "roll": 180 / math.pi, "yaw": 180 / math.pi}+++def attributes(entity):+    attrs = getattr(entity, "attributes", None)+    return {attr.name: attr.value for attr in items(attrs) if attr.groupName == GROUP} if attrs else {}+++def metadata(component):+    raw = attributes(component)+    result = {"name": component.name, "partNumber": getattr(component, "partNumber", ""),+              "description": getattr(component, "description", ""), "attributes": raw}+    for name in ("supplier", "supplierPartNumber", "sourceUrl", "sourceFile", "sha256", "asPurchased", "excludeFromBom"):+        if name in raw:+            result[name] = json.loads(raw[name])+    material = getattr(component, "material", None)+    result["material"] = {"id": material.id, "name": material.name} if material else None+    return result+++def limits_data(limits, scale):+    return {"minimumEnabled": limits.isMinimumValueEnabled, "minimum": limits.minimumValue * scale,+            "maximumEnabled": limits.isMaximumValueEnabled, "maximum": limits.maximumValue * scale,+            "restEnabled": limits.isRestValueEnabled, "rest": limits.restValue * scale}+++def joint_motion(joint):+    base = joint.jointMotion+    kind = base.objectType.split("::")[-1]+    require(kind in ("RigidJointMotion", "RevoluteJointMotion", "SliderJointMotion", "CylindricalJointMotion",+                     "PinSlotJointMotion", "PlanarJointMotion", "BallJointMotion"), "unsupported_joint_motion", "Cannot inspect joint motion type: " + kind)+    cls = getattr(adsk.fusion, kind, None)+    require(cls is not None, "unsupported_joint_motion", "Fusion motion wrapper is unavailable: " + kind)+    motion = cls.cast(base)+    require(motion is not None, "unsupported_joint_motion", "Fusion could not cast joint motion: " + kind)+    return motion+++def joint_data(joint, value=None):+    motion = joint_motion(joint)+    result = {"name": joint.name, "type": joint.objectType, "motionType": motion.objectType,+              "suppressed": joint.isSuppressed,+              "occurrenceOneId": identity(joint.occurrenceOne) if joint.occurrenceOne else None,+              "occurrenceTwoId": identity(joint.occurrenceTwo) if joint.occurrenceTwo else None}+    for name, scale in MOTION_SCALES.items():+        if hasattr(motion, name + "Limits"):+            result[name + "Limits"] = limits_data(getattr(motion, name + "Limits"), scale)+        if hasattr(motion, name + "Value"):+            result[name + "Value"] = getattr(motion, name + "Value") * scale+    for name in ("rotationAxisVector", "slideDirectionVector", "normalDirectionVector", "primarySlideDirectionVector", "secondarySlideDirectionVector"):+        if hasattr(motion, name):+            vector = getattr(motion, name)+            result[name] = [vector.x, vector.y, vector.z] if vector else None+    if hasattr(joint, "transform"):+        matrix = joint.transform+        result["transform"] = list(matrix.asArray()) if matrix else None+    if value:+        result["ref"] = ref(joint, value)+        result["units"] = {"length": "mm", "angle": "deg", "transformTranslation": "cm"}+    return result+++def rigid_group_data(group, value=None):+    result = {"name": group.name, "suppressed": group.isSuppressed,+              "occurrenceIds": [identity(o) for o in items(group.occurrences)]}+    if value:+        result["ref"] = ref(group, value)+        result["occurrenceRefs"] = [ref(o, value) for o in items(group.occurrences)]+    return result+++def component_state(comp):+    result = metadata(comp)+    result["joints"] = [joint_data(joint) for name in ("joints", "asBuiltJoints")+                        for joint in items(getattr(comp, name))] if hasattr(comp, "joints") else []+    result["rigidGroups"] = [rigid_group_data(group) for group in items(comp.rigidGroups)] if hasattr(comp, "rigidGroups") else []+    result["bodyMaterials"] = [{"id": body.material.id, "name": body.material.name} if body.material else None+                               for body in items(comp.bRepBodies)] if all(hasattr(b, "material") for b in items(comp.bRepBodies)) else []+    return result+++def occurrence_state(occurrence):+    return {"name": getattr(occurrence, "name", None), "grounded": occurrence.isGrounded,+            "groundedToParent": getattr(occurrence, "isGroundToParent", None),+            "attributes": attributes(occurrence)}

@@ -0,0 +1,116 @@+"""Definition identity, nested instance quantities, purchased collapse and CSV."""+import csv+from pathlib import Path+import tempfile+import adsk.fusion++from .assembly_state import metadata+from .core import identity, items, occurrence_suppression, ref, require, target+from .exporting import publish_staged+++def generate(design, value, args):+    parts, instances, excluded = {}, [], []+    physical = {"mass": 0.0, "volume": 0.0, "bodyInstances": 0}+    accuracy = adsk.fusion.CalculationAccuracy.HighCalculationAccuracy+    budget = {"visited": 0}+    def visit(comp, depth, ancestry):+        budget["visited"] += 1+        require(depth <= 100 and budget["visited"] <= 20000, "bom_budget", "Assembly exceeds combined purchasing/physical traversal budget.")+        key = identity(comp)+        require(key not in ancestry, "cyclic_assembly", "Assembly contains cyclic component containment.")+        return key+    # Physical totals are independent of purchasing collapse. Count direct bodies+    # once per physical instance, including root bodies and repeated children.+    def physical_walk(comp, occurrence=None, depth=0, ancestry=()):+        key = visit(comp, depth, ancestry)+        bodies = items(occurrence.bRepBodies if occurrence else comp.bRepBodies)+        for body in bodies:+            props = body.getPhysicalProperties(accuracy)+            physical["mass"] += props.mass+            physical["volume"] += props.volume * 1000+            physical["bodyInstances"] += 1+        children = items(occurrence.childOccurrences if occurrence else comp.occurrences)+        for child in children:+            if occurrence_suppression(child) is not True:+                physical_walk(child.component, child, depth + 1, ancestry + (key,))++    def walk(comp, occurrence=None, parent_path=None, depth=0, ancestry=()):+        key = visit(comp, depth, ancestry)+        path = occurrence.fullPathName if occurrence else "<root>"+        data = metadata(comp)+        if occurrence and occurrence_suppression(occurrence) is True:+            excluded.append({"path": path, "reason": "suppressed"})+            return+        if data.get("excludeFromBom", False):+            excluded.append({"path": path, "reason": "excludeFromBom"})+            return+        children = items(occurrence.childOccurrences if occurrence else comp.occurrences)+        purchased = bool(data.get("asPurchased", False)) and not args.get("explodePurchased", False)+        row = {"path": path, "parentPath": parent_path, "depth": depth, "componentId": key, "metadata": data,+               "bodyCount": comp.bRepBodies.count, "childCount": len(children), "asPurchased": purchased,+               "componentRef": ref(comp, value), "occurrenceRef": ref(occurrence, value) if occurrence else None}+        instances.append(row)+        if comp.bRepBodies.count or purchased:+            if key not in parts:+                props = comp.getPhysicalProperties(accuracy) if purchased else None+                direct_properties = [] if purchased else [b.getPhysicalProperties(accuracy) for b in items(comp.bRepBodies)]+                parts[key] = {"componentId": key, **data, "quantity": 0, "occurrencePaths": [],+                              "scope": "component_subtree" if purchased else "direct_component_bodies",+                              "unitMass": props.mass if props else sum(p.mass for p in direct_properties),+                              "unitVolume": props.volume * 1000 if props else sum(p.volume * 1000 for p in direct_properties)}+            parts[key]["quantity"] += 1+            parts[key]["occurrencePaths"].append(path)+        if not purchased:+            for child in children:+                walk(child.component, child, path, depth + 1, ancestry + (key,))++    walk(design.rootComponent)+    physical_walk(design.rootComponent)+    rows = list(parts.values())+    return {"target": value, "complete": True, "parts": rows, "instances": instances, "excluded": excluded,+            "partCount": len(rows), "totalPurchasingInstances": sum(r["quantity"] for r in rows),+            "physical": {**physical, "scope": "all unsuppressed direct-body instances; BOM exclusions do not remove physical mass",+                         "materialBasis": "Fusion assigned/default material; supplier provenance does not certify modeled material density"},+            "units": {"mass": "kg", "volume": "mm3"}, "calculationAccuracy": "high",+            "identityScope": "running add-in session; supplier metadata persists in native archives"}+++def bom(app, args):+    _, design, value = target(app, args)+    return generate(design, value, args)+++def bom_export(app, args):+    _, design, value = target(app, args, True)+    destination = Path(args["filename"])+    require(destination.is_absolute() and destination.suffix.lower() == ".csv" and not destination.is_symlink() and not destination.is_dir(), "invalid_destination", "BOM destination must be an absolute regular .csv path.")+    require(args.get("overwrite", False) or not destination.exists(), "destination_exists", "Pass overwrite:true to replace an existing CSV.")+    result = generate(design, value, args)+    destination.parent.mkdir(parents=True, exist_ok=True)+    published = {}+    try:+        with tempfile.TemporaryDirectory(prefix=".adom-bom-", dir=str(destination.parent)) as folder:+            staged = Path(folder) / "bom.csv"+            keys = ["componentId", "partNumber", "name", "description", "quantity", "supplier", "supplierPartNumber", "sourceUrl", "sha256", "unitMass", "unitVolume", "scope"]+            rows = result["parts"]+            if args.get("mode", "flat") == "structured":+                keys = ["path", "parentPath", "depth", "componentId", "name", "partNumber", "description", "quantity", "bodyCount", "childCount", "asPurchased", "supplier", "supplierPartNumber", "sourceUrl", "sha256"]+                rows = [{**row["metadata"], **row, "quantity": 1} for row in result["instances"]]+            with staged.open("w", encoding="utf-8", newline="") as stream:+                writer = csv.writer(stream)+                writer.writerow(keys)+                for part in rows:+                    values = [part.get(key, "") for key in keys]+                    writer.writerow(["'" + v if isinstance(v, str) and v[:1] in ("=", "+", "-", "@") else v for v in values])+            published.update(publish_staged(staged, destination, args.get("overwrite", False)))+    except Exception as exc:+        if not published.get("published"):+            raise+        published["cleanupWarning"] = str(exc)+    return {"target": value, "partCount": result["partCount"], "mode": args.get("mode", "flat"),+            "calculationAccuracy": result["calculationAccuracy"], **published}+++OPERATIONS = {"bom": bom, "bom_export": bom_export}+WRITES = {"bom_export"}

@@ -0,0 +1,287 @@+"""Main-thread mechanical identity, revisions, references and health.++Session IDs are capabilities for this running add-in, not persistent CAD IDs. Tokens+are only resolver inputs: they are never compared to decide entity identity.+"""+import hashlib+import json+import math+import threading+import uuid++import adsk.core+import adsk.fusion++SESSION_ID = str(uuid.uuid4())+_documents = []+_entities = []+MAX_ENTITIES = 20000+UNITS = {"length": "mm", "angle": "deg", "mass": "kg", "area": "mm2", "volume": "mm3"}+++class MechanicalError(Exception):+    def __init__(self, code, message, **details):+        super().__init__(message)+        self.code, self.details = code, details+++def require(condition, code, message, **details):+    if not condition:+        raise MechanicalError(code, message, **details)+++def items(collection):+    require(collection.count <= MAX_ENTITIES, "inspection_budget", "Collection exceeds inspection budget.")+    return [collection.item(i) for i in range(collection.count)]+++def same(a, b):+    return a is b or a == b+++def identity(entity):+    """Object equality, never name or token equality. Retained for this session only."""+    for obj, key in _entities:+        if obj.isValid and same(obj, entity):+            return key+    require(len(_entities) < MAX_ENTITIES, "identity_budget", "Session entity budget exhausted.")+    key = str(uuid.uuid4())+    _entities.append((entity, key))+    return key+++def active(app):+    require(threading.current_thread() is threading.main_thread(), "wrong_thread", "Mechanical API requires the Fusion main thread.")+    doc = app.activeDocument+    design = adsk.fusion.Design.cast(app.activeProduct)+    require(doc and design, "no_design", "The active product must be a Fusion Design.")+    require(same(design.parentDocument, doc), "wrong_document", "Active product and document disagree.")+    for previous, key in _documents:+        if previous.isValid and same(previous, doc):+            return doc, design, key+    key = SESSION_ID + ":" + str(uuid.uuid4())+    _documents.append((doc, key))+    return doc, design, key+++def digest(value):+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()).hexdigest()+++def revision(design):+    """Aggregate every component, body, sketch, parameter and occurrence transform.++    Fail closed when any required API read fails. A root revision alone misses edits+    to child definitions. Native revision IDs catch equal-volume topology changes.+    """+    from .assembly_state import component_state, occurrence_state+    from .readback import feature_data+    components = []+    for comp in items(design.allComponents):+        components.append([identity(comp), str(comp.revisionId), comp.name,+                           [[identity(b), str(b.revisionId)] for b in items(comp.bRepBodies)],+                           [[identity(s), str(s.revisionId)] for s in items(comp.sketches)],+                           component_state(comp), [feature_data(f, order=i) for i, f in enumerate(items(comp.features))] if hasattr(comp, "features") else []])+    occurrences = [[identity(o), identity(o.component), list(o.transform2.asArray()),+                    occurrence_suppression(o), occurrence_state(o)] for o in items(design.rootComponent.allOccurrences)]+    params = [[p.name, p.expression, p.unit] for p in items(design.allParameters)]+    return digest([components, occurrences, params, design.timeline.count, design.timeline.markerPosition])+++def occurrence_suppression(occurrence):+    timeline = occurrence.timelineObject+    return bool(timeline.isSuppressed) if timeline is not None else None+++def target(app, args, write=False):+    doc, design, key = active(app)+    wanted = args.get("target")+    require(isinstance(wanted, dict), "target_required", "Pass target from mechanical inspect.")+    require(wanted.get("documentId") == key, "wrong_document", "Target is not the active document.", activeDocumentId=key)+    rev = revision(design)+    if write or "revision" in wanted:+        require(wanted.get("revision") == rev, "stale_revision", "The model changed; inspect it before a new operation.", currentRevision=rev)+    return doc, design, {"documentId": key, "revision": rev}+++def current_target(app):+    doc, design, key = active(app)+    return {"documentId": key, "revision": revision(design)}+++def ref(entity, target_value, occurrence=None):+    if entity.objectType == "adsk::fusion::Profile":+        from .readback import profile_ref+        sketch = entity.parentSketch+        matches = [index for index, profile in enumerate(items(sketch.profiles)) if same(profile, entity)]+        require(len(matches) == 1, "ambiguous_reference", "Profile must belong uniquely to its sketch.")+        return profile_ref(sketch, entity, matches[0], target_value)+    is_occurrence = entity.objectType.endswith("::Occurrence")+    native = entity if is_occurrence else (getattr(entity, "nativeObject", None) or entity)+    context = None if is_occurrence else (occurrence or getattr(entity, "assemblyContext", None))+    result = {"documentId": target_value["documentId"], "revision": target_value["revision"],+            "token": native.entityToken, "objectType": native.objectType,+            "occurrenceToken": context.entityToken if context else None,+            "occurrencePath": context.fullPathName if context else (entity.fullPathName if is_occurrence else None)}+    if native.objectType == "adsk::fusion::Component" and same(native, native.parentDesign.rootComponent):+        # Fusion can emit a root token that findEntityByToken cannot resolve.+        # Bind this explicit root reference to its live API identity instead.+        result["rootComponentId"] = identity(native)+    return result+++def occurrence_context(design, entity, path):+    require(entity.objectType.endswith("::Occurrence"), "invalid_context", "Context must resolve to an occurrence.")+    native = getattr(entity, "nativeObject", None) or entity+    candidates = [o for o in items(design.rootComponent.allOccurrences)+                  if o.fullPathName == path and same(getattr(o, "nativeObject", None) or o, native)]+    if candidates:+        require(len(candidates) == 1, "ambiguous_context", "Occurrence path must identify one instance.")+        return candidates[0]+    # Native definition references have a path relative to their owner. Only+    # retain that context when the token and saved path both resolve exactly.+    require(entity.fullPathName == path, "invalid_context", "Occurrence path changed.")+    return entity+++def resolve(design, target_value, value, allowed=()):+    require(isinstance(value, dict), "invalid_reference", "An entity reference object is required.")+    require(value.get("documentId") == target_value["documentId"] and value.get("revision") == target_value["revision"],+            "stale_reference", "Reference is from another document or revision.")+    if value.get("objectType") == "adsk::fusion::Profile":+        # Bind profile selection to a uniquely+        # resolved sketch, this exact aggregate revision and geometric witness.+        from .readback import profile_signature+        require(not allowed or "Profile" in allowed, "wrong_entity_type", "Operation does not accept profiles.")+        require(isinstance(value.get("sketchToken"), str), "invalid_reference", "Profile sketch token is required.")+        sketches = design.findEntityByToken(value["sketchToken"])+        require(len(sketches) == 1 and sketches[0].objectType.endswith("::Sketch"), "ambiguous_reference", "Profile sketch must resolve uniquely.")+        index = value.get("profileIndex")+        require(isinstance(index, int) and not isinstance(index, bool) and 0 <= index < sketches[0].profiles.count,+                "invalid_reference", "Profile index is no longer valid.")+        profile = sketches[0].profiles.item(index)+        require(digest(profile_signature(profile)) == value.get("fingerprint"), "stale_reference", "Profile geometry changed.")+        return profile+    if "rootComponentId" in value:+        entity = design.rootComponent+        require(value.get("objectType") == "adsk::fusion::Component"+                and value["rootComponentId"] == identity(entity)+                and not value.get("occurrenceToken") and not value.get("occurrencePath"),+                "invalid_reference", "Root reference does not identify this active design's root component.")+    else:+        require(isinstance(value.get("token"), str) and value["token"], "invalid_reference", "Reference token is missing.")+        matches = design.findEntityByToken(value["token"])+        require(len(matches) <= MAX_ENTITIES, "inspection_budget", "Token lookup exceeds inspection budget.")+        if len(matches) > 1 and value.get("objectType") == "adsk::fusion::Component":+            # Repeated definitions can return duplicate API wrappers. Only+            # actual Component equality makes them one entity; face splits and+            # occurrence instances retain the strict one-result rule below.+            first = matches[0]+            for candidate in matches:+                require(candidate.isValid and candidate.objectType == "adsk::fusion::Component"+                        and same(first, candidate), "ambiguous_reference",+                        "Component token resolves to distinct or invalid entities.", matchCount=len(matches))+            matches = [first]+        require(len(matches) == 1, "ambiguous_reference", "Token must resolve to exactly one live entity.", matchCount=len(matches))+        entity = matches[0]+    require(entity.isValid and entity.objectType == value.get("objectType"), "invalid_reference", "Entity type or validity changed.")+    require(not allowed or entity.objectType.split("::")[-1] in allowed, "wrong_entity_type", "Operation does not accept this entity type.")+    if entity.objectType.endswith("::Occurrence") and value.get("occurrencePath"):+        entity = occurrence_context(design, entity, value["occurrencePath"])+    if value.get("occurrenceToken"):+        contexts = design.findEntityByToken(value["occurrenceToken"])+        require(len(contexts) == 1, "ambiguous_context", "Occurrence context must resolve uniquely.")+        context = occurrence_context(design, contexts[0], value.get("occurrencePath"))+        owner = getattr(entity, "parentComponent", None)+        if owner is None and hasattr(entity, "component"):+            owner = entity.component+        if owner is None and hasattr(entity, "parentSketch"):+            owner = entity.parentSketch.parentComponent+        if owner is None and hasattr(entity, "body"):+            owner = entity.body.parentComponent+        require(owner and same(owner, context.component), "invalid_context", "Entity is not owned by this occurrence component.")+        entity = entity.createForAssemblyContext(context)+        require(entity and entity.isValid, "invalid_context", "Could not create occurrence-context proxy.")+    return entity+++def health(design, recompute=False):+    computed = None+    if recompute:+        computed = bool(design.computeAll())+    faults, unknown, suppressed = [], [], []+    pending = [(str(index), item) for index, item in enumerate(items(design.timeline))]+    while pending:+        index, item = pending.pop(0)+        try:+            if getattr(item, "isGroup", False):+                group = adsk.fusion.TimelineGroup.cast(item)+                pending.extend((index + "." + str(i), child) for i, child in enumerate(items(group)))+                continue+            if getattr(item, "isSuppressed", False):+                suppressed.append({"index": index, "name": item.name})+                continue+            state = item.healthState+            if state != adsk.fusion.FeatureHealthStates.HealthyFeatureHealthState:+                faults.append({"index": index, "name": item.name, "state": int(state),+                               "message": item.errorOrWarningMessage})+        except Exception as exc:+            unknown.append({"index": index, "error": str(exc)})+    return {"healthy": computed is not False and not faults and not unknown,+            "computeSucceeded": computed, "complete": not unknown, "faults": faults,+            "unknown": unknown, "suppressed": suppressed, "timelineCount": design.timeline.count}+++def require_healthy(design, recompute=True):+    state = health(design, recompute)+    require(state["healthy"], "unhealthy_model", "Recompute or feature health check failed.", health=state)+    return state+++def point_mm(point):+    return [point.x * 10, point.y * 10, point.z * 10]+++def body_data(body):+    pp = body.physicalProperties+    box = body.boundingBox+    return {"name": body.name, "volume": pp.volume * 1000, "area": pp.area * 100,+            "mass": pp.mass, "centerOfMass": point_mm(pp.centerOfMass),+            "bounds": {"min": point_mm(box.minPoint), "max": point_mm(box.maxPoint)},+            "faces": body.faces.count, "edges": body.edges.count, "isSolid": body.isSolid,+            "space": "component", "units": UNITS}+++def parameter_data(design, parameter):+    unit = parameter.unit+    # Fusion numeric values always use its internal units (cm/rad/kg), regardless+    # of the display unit. Conversion occurs here, never in individual handlers.+    value, normalized = None, unit+    for canonical in ("mm", "deg", "kg", ""):+        try:+            if design.unitsManager.isValidExpression("1 " + canonical, unit):+                value = design.unitsManager.convert(parameter.value, "internalUnits", canonical)+                normalized = canonical or "unitless"+                break+        except Exception:+            continue+    return {"name": parameter.name, "expression": parameter.expression,+            "value": value, "unit": normalized, "displayUnit": unit}+++def recovery_snapshot(design):+    """Semantic recovery witness; native revision IDs legitimately change on undo."""+    from .readback import feature_data, sketch_data, topology_witness+    from .assembly_state import component_state, occurrence_state+    return {"parameters": [[p.name, p.expression, p.unit] for p in items(design.allParameters)],+            "components": [[identity(c), c.name, [topology_witness(b) for b in items(c.bRepBodies)],+                            [sketch_data(s) for s in items(c.sketches)],+                            [feature_data(f, order=i) for i, f in enumerate(items(c.features))], component_state(c)] for c in items(design.allComponents)],+            "occurrences": [[identity(o), list(o.transform2.asArray()), occurrence_state(o)] for o in items(design.rootComponent.allOccurrences)],+            "timeline": design.timeline.count, "health": health(design)}+++def number(value, name, positive=False):+    require(isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value), "invalid_input", name + " must be a finite number.")+    require(not positive or value > 0, "invalid_input", name + " must be positive.")+    return float(value)

@@ -0,0 +1,93 @@+"""Single-file exports: preflight, isolated staging, verified atomic publication."""+import hashlib+import os+from pathlib import Path+import tempfile++import adsk.fusion++from .core import MechanicalError, require++FORMATS = {+    "step": ("createSTEPExportOptions", (".step", ".stp"), "file"),+    "stl": ("createSTLExportOptions", (".stl",), "entity"),+    "3mf": ("createC3MFExportOptions", (".3mf",), "entity"),+    "f3d": ("createFusionArchiveExportOptions", (".f3d",), "file"),+    "iges": ("createIGESExportOptions", (".igs", ".iges"), "file"),+    "sat": ("createSATExportOptions", (".sat",), "file"),+    "smt": ("createSMTExportOptions", (".smt",), "file"),+    "usdz": ("createUSDExportOptions", (".usdz",), "file"),+    "fbx": ("createFBXExportOptions", (".fbx",), "file"),+    "skp": ("createSketchUpExportOptions", (".skp",), "file"),+}+++def publish_staged(staged, destination, overwrite):+    require(staged.is_file() and staged.stat().st_size > 0, "empty_export", "Exporter produced no nonempty file.")+    size = staged.stat().st_size+    sha = hashlib.sha256(staged.read_bytes()).hexdigest()+    result = {"outputPath": str(destination), "fileSize": size, "sha256": sha,+              "published": True, "overwrite": overwrite}+    if overwrite:+        os.replace(str(staged), str(destination))+    else:+        # Atomic exclusive publication. Checking exists then replace has a race that+        # could overwrite another writer's file. A hardlink never replaces it.+        os.link(str(staged), str(destination))+        try:+            staged.unlink()+        except OSError as exc:+            # The hardlink is the publication commit point. A leftover staging+            # link is cleanup work, not a failed export or preserved destination.+            result["cleanupWarning"] = str(exc)+    return result+++def export_design(design, args):+    fmt = args.get("format", "step").lower()+    require(fmt in FORMATS, "unsupported_format", "Single-file export format is unavailable. Sketch DXF requires an explicit sketch; OBJ sidecars need a bundle exporter.")+    method, suffixes, mode = FORMATS[fmt]+    manager = design.exportManager+    factory = getattr(manager, method, None)+    require(callable(factory), "unsupported_capability", method + " is unavailable in this Fusion build.")+    raw = args.get("outputPath")+    require(isinstance(raw, str) and raw, "invalid_path", "outputPath is required.")+    destination = Path(raw)+    require(destination.is_absolute(), "invalid_path", "outputPath must be absolute on the Fusion host.")+    require(destination.suffix.lower() in suffixes, "extension_mismatch", "File extension does not match requested format.")+    overwrite = args.get("overwrite", False)+    require(isinstance(overwrite, bool), "invalid_input", "overwrite must be a boolean.")+    require(not destination.exists() or overwrite, "destination_exists", "Destination exists; pass overwrite:true to atomically replace it.")+    require(not destination.is_symlink() and not destination.is_dir(), "invalid_path", "Destination must be a regular file path.")+    destination.parent.mkdir(parents=True, exist_ok=True)+    # Entire unique directory prevents the exporter seeing an existing file and+    # raising an overwrite dialog. Same filesystem permits atomic publication.+    out = None+    try:+        with tempfile.TemporaryDirectory(prefix=".adom-export-", dir=str(destination.parent)) as folder:+            staged = Path(folder) / ("model" + destination.suffix)+            options = factory(design.rootComponent, str(staged)) if mode == "entity" else factory(str(staged))+            require(options is not None, "export_preflight_failed", "Exporter did not create options.")+            if hasattr(options, "isViewFit"):+                options.isViewFit = False+            if fmt in ("stl", "3mf"):+                options.sendToPrintUtility = False+                options.isOneFilePerBody = False+            if fmt == "stl":+                refinement = args.get("refinement", "medium")+                settings = {"low": "MeshRefinementLow", "medium": "MeshRefinementMedium", "high": "MeshRefinementHigh"}+                require(refinement in settings, "invalid_input", "refinement must be low, medium or high.")+                options.meshRefinement = getattr(adsk.fusion.MeshRefinementSettings, settings[refinement])+                # STL has no embedded unit declaration; request millimetres explicitly.+                require(hasattr(options, "unitType"), "unsupported_capability", "STL millimetre unit selection is unavailable.")+                options.unitType = adsk.fusion.DistanceUnits.MillimeterDistanceUnits+            require(bool(manager.execute(options)), "export_failed", "Fusion exporter returned false; destination was preserved.")+            out = publish_staged(staged, destination, overwrite)+            out.update({"format": fmt, "externalEffect": "file_published", "modelRollbackApplies": False})+            if fmt == "stl":+                out["lengthUnit"] = "mm"+    except Exception as exc:+        if out is None:+            raise+        out["cleanupWarning"] = str(exc)+    return out

@@ -0,0 +1,238 @@+"""Solid feature operations; selection always resolves against the guarded model."""+import math++import adsk.core+import adsk.fusion++from .core import items, parameter_data, ref, require, resolve, same+from .readback import feature_data, topology_data+from .sketches import axis, collection, component, named, plane, point, quantity+++def owner(entity):+    if hasattr(entity, "body"):+        return entity.body.parentComponent+    if hasattr(entity, "parentComponent"):+        return entity.parentComponent+    if hasattr(entity, "parentSketch"):+        return entity.parentSketch.parentComponent+    return None+++def selected(design, value, args, name, types, comp):+    raw = args.get(name, [])+    require(isinstance(raw, list) and raw, "invalid_selection", name + " requires at least one reference.")+    result = [resolve(design, value, r, types) for r in raw]+    for entity in result:+        require(getattr(entity, "assemblyContext", None) is None, "definition_reference_required", "Feature authoring requires native definition references.")+        require(same(owner(entity), comp), "wrong_component", "Selected entity belongs to another component; pass its component reference.")+    return result+++def operation(value):+    return getattr(adsk.fusion.FeatureOperations, {"new_body": "NewBodyFeatureOperation", "join": "JoinFeatureOperation",+                   "cut": "CutFeatureOperation", "intersect": "IntersectFeatureOperation"}[value])+++def factory(features, name):+    result = getattr(features, name, None)+    require(result is not None, "unsupported_capability", name + " is unavailable in this Fusion build.")+    return result+++def feature_create(design, value, args):+    comp = component(design, value, args)+    features, kind = comp.features, args["type"]+    q = lambda key, unit="mm", positive=True: quantity(design, args[key], unit, positive)+    select = lambda key, types: selected(design, value, args, key, types, comp)+    operation_name = args.get("operation", "new_body")+    if operation_name == "join" and kind in ("extrude", "revolve", "loft", "sweep"):+        require(comp.bRepBodies.count == 1, "ambiguous_join", "Join requires one existing body in the component; create a new body then use combine for explicit multi-body selection.")+    if kind == "extrude":+        profiles = select("profiles", ("Profile",))+        group = factory(features, "extrudeFeatures")+        inp = group.createInput(collection(profiles), operation(operation_name))+        if args.get("direction", "positive") == "symmetric":+            require(inp.setSymmetricExtent(q("distance"), True, quantity(design, args.get("taper", 0), "deg")), "invalid_extent", "Symmetric extrusion extent was refused.")+        else:+            extent = adsk.fusion.DistanceExtentDefinition.create(q("distance"))+            direction = getattr(adsk.fusion.ExtentDirections, "NegativeExtentDirection" if args.get("direction") == "negative" else "PositiveExtentDirection")+            require(inp.setOneSideExtent(extent, direction, quantity(design, args.get("taper", 0), "deg")), "invalid_extent", "Extrusion extent was refused.")+        if operation_name in ("cut", "intersect"):+            inp.participantBodies = select("bodies", ("BRepBody",))+    elif kind == "revolve":+        profiles = select("profiles", ("Profile",))+        group = factory(features, "revolveFeatures")+        inp = group.createInput(collection(profiles), axis(design, value, comp, args["axis"]), operation(operation_name))+        require(inp.setAngleExtent(False, q("angle", "deg")), "invalid_extent", "Revolve angle was refused.")+        if operation_name in ("cut", "intersect"):+            inp.participantBodies = select("bodies", ("BRepBody",))+    elif kind == "fillet":+        group = factory(features, "filletFeatures")+        inp = group.createInput()+        inp.edgeSetInputs.addConstantRadiusEdgeSet(collection(select("edges", ("BRepEdge",))), q("radius"), args.get("tangentChain", False))+    elif kind == "chamfer":+        group = factory(features, "chamferFeatures")+        require(hasattr(group, "createInput2"), "unsupported_capability", "Modern chamfer input API unavailable.")+        inp = group.createInput2()+        inp.chamferEdgeSets.addEqualDistanceChamferEdgeSet(collection(select("edges", ("BRepEdge",))), q("distance"), args.get("tangentChain", False))+    elif kind == "shell":+        group = factory(features, "shellFeatures")+        inp = group.createInput(collection(select("faces", ("BRepFace",))), args.get("tangentChain", False))+        inp.insideThickness = q("thickness")+    elif kind == "hole":+        group = factory(features, "holeFeatures")+        inp = group.createSimpleInput(q("diameter"))+        require(inp.setPositionBySketchPoints(collection(select("points", ("SketchPoint",)))), "hole_position_failed", "Hole positions were refused.")+        require(inp.setDistanceExtent(q("depth")), "invalid_extent", "Hole depth was refused.")+        inp.participantBodies = select("bodies", ("BRepBody",))+    elif kind == "loft":+        group = factory(features, "loftFeatures")+        inp = group.createInput(operation(operation_name))+        profiles = select("profiles", ("Profile",))+        require(len(profiles) >= 2, "invalid_selection", "Loft requires at least two profiles.")+        for profile in profiles:+            inp.loftSections.add(profile)+        inp.isSolid = True+        if operation_name in ("cut", "intersect"):+            inp.participantBodies = select("bodies", ("BRepBody",))+    elif kind == "sweep":+        group = factory(features, "sweepFeatures")+        profiles = select("profiles", ("Profile",))+        require(len(profiles) == 1, "invalid_selection", "Sweep requires exactly one profile.")+        path = adsk.fusion.Path.create(collection(select("path", ("SketchLine", "SketchArc", "SketchFittedSpline", "BRepEdge"))), adsk.fusion.ChainedCurveOptions.noChainedCurves)+        require(path is not None, "invalid_path", "Sweep path must form a connected curve chain.")+        inp = group.createInput(profiles[0], path, operation(operation_name))+        if operation_name in ("cut", "intersect"):+            inp.participantBodies = select("bodies", ("BRepBody",))+    elif kind == "combine":+        group = factory(features, "combineFeatures")+        target_body = resolve(design, value, args["body"], ("BRepBody",))+        require(getattr(target_body, "assemblyContext", None) is None, "definition_reference_required", "Combine requires a native target body reference.")+        require(same(owner(target_body), comp), "wrong_component", "Target body is in another component.")+        tools = select("tools", ("BRepBody",))+        require(not any(same(target_body, tool) for tool in tools), "invalid_selection", "Target cannot also be a tool body.")+        inp = group.createInput(target_body, collection(tools))+        require(operation_name in ("join", "cut", "intersect"), "invalid_input", "Combine operation must be join, cut or intersect.")+        inp.operation = operation(operation_name)+        inp.isKeepToolBodies = args.get("keepTools", True)+    elif kind == "split":+        group = factory(features, "splitBodyFeatures")+        bodies = select("bodies", ("BRepBody",))+        require(len(bodies) == 1, "invalid_selection", "Split requires one body.")+        tool = plane(design, value, comp, args["plane"])+        inp = group.createInput(bodies[0], tool, args.get("extend", True))+    elif kind == "move":+        group = factory(features, "moveFeatures")+        require(hasattr(group, "createInput2"), "unsupported_capability", "Modern move input API unavailable.")+        inp = group.createInput2(collection(select("bodies", ("BRepBody",))))+        matrix = adsk.core.Matrix3D.create()+        if args.get("angle", 0):+            vector = args.get("axis", [0, 0, 1])+            rotation_axis = adsk.core.Vector3D.create(*vector)+            require(rotation_axis.length > 1e-9, "invalid_input", "Rotation axis must be nonzero.")+            angle_value = design.unitsManager.evaluateExpression(str(args["angle"]) + " deg", "deg")+            require(matrix.setToRotation(angle_value, rotation_axis, point(args.get("origin", [0, 0, 0]))), "invalid_transform", "Rotation matrix creation failed.")+        translation = point(args.get("translation", [0, 0, 0]))+        existing = matrix.translation+        matrix.translation = adsk.core.Vector3D.create(existing.x + translation.x, existing.y + translation.y, existing.z + translation.z)+        require(inp.defineAsFreeMove(matrix), "invalid_transform", "Move transform was refused.")+    elif kind == "mirror":+        group = factory(features, "mirrorFeatures")+        inp = group.createInput(collection(select("bodies", ("BRepBody",))), plane(design, value, comp, args["plane"]))+        inp.isCombine = False+    elif kind == "rectangular_pattern":+        if any(key in args for key in ("axis2", "count2", "spacing2")):+            require("count2" in args and "spacing2" in args, "invalid_input", "Second pattern direction requires count2 and spacing2; axis2 defaults to y.")+        group = factory(features, "rectangularPatternFeatures")+        inp = group.createInput(collection(select("bodies", ("BRepBody",))), axis(design, value, comp, args["axis"]),+                                q("count", ""), q("spacing"), adsk.fusion.PatternDistanceType.SpacingPatternDistanceType)+        inp.quantityTwo = quantity(design, 1, "", True)+        inp.isSymmetricInDirectionOne = False+        inp.isSymmetricInDirectionTwo = False+        if "count2" in args:+            require(inp.setDirectionTwo(axis(design, value, comp, args.get("axis2", "y")), q("count2", ""), q("spacing2")), "pattern_failed", "Second pattern direction was refused.")+    elif kind == "circular_pattern":+        group = factory(features, "circularPatternFeatures")+        inp = group.createInput(collection(select("bodies", ("BRepBody",))), axis(design, value, comp, args["axis"]))+        inp.quantity = q("count", "")+        inp.totalAngle = quantity(design, args.get("angle", 360), "deg", True)+        inp.isSymmetric = False+    elif kind == "draft":+        group = factory(features, "draftFeatures")+        inp = group.createInput(select("faces", ("BRepFace",)), plane(design, value, comp, args["plane"]), args.get("tangentChain", False))+        require(inp.setSingleAngle(False, q("angle", "deg", False)), "draft_failed", "Draft angle was refused.")+    elif kind == "thread":+        group = factory(features, "threadFeatures")+        create_info = getattr(getattr(adsk.fusion, "ThreadInfo", None), "create", None)+        require(callable(create_info), "unsupported_capability", "ThreadInfo.create is unavailable.")+        info = create_info(False, args["internal"], args["threadType"], args["designation"], args["threadClass"], True)+        require(info is not None, "invalid_thread", "Requested thread standard/designation/class is unavailable.")+        inp = group.createInput(collection(select("faces", ("BRepFace",))), info)+        inp.isModeled = args.get("modeled", False)+        inp.isFullLength = True+    else:+        require(False, "unsupported_feature", "This feature type is not supported.")+    feature = named(group.add(inp), args)+    return lambda fresh: {"feature": feature_data(feature, fresh),+                           "bodies": [topology_data(body, fresh) for body in items(feature.bodies)]}+++def feature_edit(design, value, args):+    require(any(key in args for key in ("name", "suppressed", "parameters")), "invalid_input", "Specify a feature property to edit.")+    feature = resolve(design, value, args["feature"])+    timeline = getattr(feature, "timelineObject", None)+    require(timeline is not None, "wrong_entity_type", "Feature must have a timeline object.")+    if "name" in args:+        feature.name = args["name"]+    if "suppressed" in args:+        timeline.isSuppressed = args["suppressed"]+    for name, expression in args.get("parameters", {}).items():+        parameter = design.allParameters.itemByName(name)+        require(parameter is not None and same(getattr(parameter, "createdBy", None), feature), "wrong_parameter", "Parameter is not owned by this feature: " + name)+        require(design.unitsManager.isValidExpression(expression, parameter.unit), "invalid_expression", "Invalid parameter expression.")+        parameter.expression = expression+    return lambda fresh: {"feature": feature_data(feature, fresh)}+++def entity_delete(design, value, args):+    entity = resolve(design, value, args["entity"])+    kind = entity.objectType.split("::")[-1]+    require(kind in ("Sketch", "SketchLine", "SketchCircle", "SketchArc", "SketchPoint", "SketchFittedSpline", "ConstructionPlane") or kind.endswith("Feature"),+            "unsupported_delete", "Delete supports sketches, sketch geometry, construction planes and timeline features.")+    description = {"name": getattr(entity, "name", None), "type": entity.objectType}+    timeline = getattr(entity, "timelineObject", None)+    if timeline:+        require(timeline.isDeletable, "delete_refused", "Fusion reports this timeline entity cannot be deleted independently.")+        require(timeline.deleteObject(), "delete_failed", "Feature deletion failed.")+    else:+        require(entity.deleteMe(), "delete_failed", "Entity deletion failed.")+    return {"deleted": description}+++def parameter_batch(design, value, args):+    changed = []+    for change in args["changes"]:+        name, action = change["name"], change["action"]+        parameter = design.allParameters.itemByName(name)+        if action == "create":+            require(parameter is None, "parameter_exists", "Parameter exists: " + name)+            parameter = design.userParameters.add(name, quantity(design, change["expression"], change["unit"]), change["unit"], change.get("comment", ""))+            require(parameter is not None, "parameter_create_failed", "Parameter creation failed.")+        else:+            require(parameter is not None, "parameter_missing", "Parameter not found: " + name)+            if action == "delete":+                user = design.userParameters.itemByName(name)+                require(user is not None, "delete_refused", "Only user parameters can be deleted.")+                require(user.deleteMe(), "delete_refused", "Parameter is in use or cannot be deleted.")+                changed.append({"name": name, "deleted": True})+                continue+            expression = change["expression"]+            require(design.unitsManager.isValidExpression(expression, parameter.unit), "invalid_expression", "Invalid expression for " + name)+            parameter.expression = expression+        changed.append(parameter_data(design, parameter))+    return {"parameters": changed}+++OPERATIONS = {"feature_create": feature_create, "feature_edit": feature_edit,+              "entity_delete": entity_delete, "parameter_batch": parameter_batch}

@@ -0,0 +1,219 @@+"""Typed mechanical operations. Add new operations here behind shared guards."""+import re++import adsk.core+import adsk.fusion++from .core import (MechanicalError, active, body_data, current_target, health,+                   identity, items, number, parameter_data, recovery_snapshot,+                   ref, require, require_healthy, resolve, target, UNITS)+from .exporting import export_design+++def inspect(app, args):+    from .assembly_state import metadata, joint_data, rigid_group_data+    doc, design, key = active(app)+    value = target(app, args)[2] if args.get("target") else current_target(app)+    bodies, components, occurrences, sketches, features = [], [], [], [], []+    for comp in items(design.allComponents):+        components.append({"id": identity(comp), **metadata(comp), "ref": ref(comp, value),+                           "bodyCount": comp.bRepBodies.count, "sketchCount": comp.sketches.count})+        for body in items(comp.bRepBodies):+            row = body_data(body)+            row.update({"ref": ref(body, value), "componentId": identity(comp)})+            bodies.append(row)+        for sketch in items(comp.sketches):+            sketches.append({"ref": ref(sketch, value), "name": sketch.name, "componentId": identity(comp),+                             "profileCount": sketch.profiles.count, "fullyConstrained": sketch.isFullyConstrained})+        for index, feature in enumerate(items(comp.features)):+            from .readback import feature_data+            features.append(feature_data(feature, value, order=index))+    for occ in items(design.rootComponent.allOccurrences):+        matrix = list(occ.transform2.asArray())+        # Matrix4x4.asArray is row-major; translation lies at 3,7,11.+        for i in (3, 7, 11):+            matrix[i] *= 10+        occurrences.append({"ref": ref(occ, value), "componentId": identity(occ.component),+                            "path": occ.fullPathName, "transform": matrix,+                            "transformLayout": "row-major", "translationUnit": "mm",+                            "space": "root", "grounded": occ.isGrounded})+    return {"target": value, "document": {"name": doc.name, "creationId": doc.creationId,+            "saved": doc.isSaved}, "designIntent": str(getattr(design, "designIntent", "unavailable")),+            "units": UNITS, "components": components, "bodies": bodies, "occurrences": occurrences,+            "sketches": sketches, "features": features,+            "joints": [joint_data(j, value) for comp in items(design.allComponents)+                       for name in ("joints", "asBuiltJoints") for j in items(getattr(comp, name))],+            "rigidGroups": [rigid_group_data(g, value) for comp in items(design.allComponents) for g in items(comp.rigidGroups)],+            "parameters": [parameter_data(design, p) for p in items(design.allParameters)],+            "health": health(design), "complete": True}+++def inspect_entity(app, args):+    _, design, value = target(app, args)+    entity = resolve(design, value, args.get("entity"))+    result = {"ref": ref(entity, value), "objectType": entity.objectType, "name": getattr(entity, "name", None)}+    if entity.objectType.endswith("::BRepBody"):+        from .readback import topology_data+        result.update(topology_data(entity, value))+        result["space"] = "assembly_context" if args["entity"].get("occurrenceToken") else "component"+        result["faceRefs"] = [ref(f, value) for f in items(entity.faces)]+        result["edgeRefs"] = [ref(e, value) for e in items(entity.edges)]+    elif entity.objectType.endswith("::Sketch"):+        from .readback import sketch_data+        result.update(sketch_data(entity, value))+    elif entity.objectType.endswith("::Occurrence"):+        result["bodyRefs"] = [ref(b, value, entity) for b in items(entity.component.bRepBodies)]+        result["childRefs"] = [ref(o, value) for o in items(entity.childOccurrences)]+    elif entity.objectType.endswith(("::AsBuiltJoint", "::Joint")):+        from .assembly_state import joint_data+        result.update(joint_data(entity, value))+    elif entity.objectType.endswith("::Component"):+        from .assembly_state import metadata+        result.update(metadata(entity))+    elif entity.objectType.endswith("::RigidGroup"):+        from .assembly_state import rigid_group_data+        result.update(rigid_group_data(entity, value))+    return {"target": value, "entity": result}+++def new_design(app, args):+    name = args.get("name", "Adom mechanical")+    require(isinstance(name, str) and 0 < len(name) <= 120, "invalid_input", "name must be 1..120 characters.")+    box = args.get("box")+    if box is not None:+        require(isinstance(box, dict), "invalid_input", "box must contain width, height and depth in mm.")+        dims = [number(box.get(n), n, positive=True) for n in ("width", "height", "depth")]+    previous = app.activeDocument+    doc = None+    try:+        doc = app.documents.add(adsk.core.DocumentTypes.FusionDesignDocumentType)+        require(doc is not None, "create_failed", "Fusion did not create a document.")+        design = adsk.fusion.Design.cast(doc.products.itemByProductType("DesignProductType"))+        require(design is not None, "create_failed", "Created document has no Design product.")+        design.designType = adsk.fusion.DesignTypes.ParametricDesignType+        from . import transactions+        if not transactions.capability()["verified"]:+            transactions.probe(app, {"target": current_target(app)})+        if box is not None:+            create_box(design, dims)+        require_healthy(design)+        # Naming a never-saved Fusion document makes close(False) capable of+        # raising a save dialog. Keep the scratch document unnamed and store the+        # requested label as model metadata until an explicit save operation.+        design.rootComponent.attributes.add("AdomMechanical", "requestedName", name)+        result = inspect(app, {})+        result["document"]["requestedName"] = name+        return result+    except Exception as exc:+        recovery = {"strategy": "discard_new_unsaved_document", "verified": False}+        if doc is not None:+            try:+                require(not doc.isSaved, "recovery_refused", "New document unexpectedly saved.")+                require(doc.name.lower().startswith("untitled"), "recovery_refused", "Document was renamed; refusing a close that could prompt.")+                doc.close(False)+                recovery["verified"] = not doc.isValid+                if previous and previous.isValid:+                    previous.activate()+            except Exception as close_error:+                recovery["error"] = str(close_error)+        raise MechanicalError("create_failed", str(exc), recovery=recovery)+++def create_box(design, dimensions):+    root = design.rootComponent+    for name, value in zip(("width", "height", "depth"), dimensions):+        design.userParameters.add(name, adsk.core.ValueInput.createByString(str(value) + " mm"), "mm", "Adom driving dimension")+    width, height, _ = [n / 10 for n in dimensions]+    sketch = root.sketches.add(root.xYConstructionPlane)+    sketch.name = "Base rectangle"+    origin = adsk.core.Point3D.create(0, 0, 0)+    lines = sketch.sketchCurves.sketchLines.addTwoPointRectangle(origin, adsk.core.Point3D.create(width, height, 0))+    first = lines.item(0)+    second = lines.item(1)+    orient = adsk.fusion.DimensionOrientations+    sx = sketch.sketchDimensions.addDistanceDimension(first.startSketchPoint, first.endSketchPoint,+            orient.HorizontalDimensionOrientation, adsk.core.Point3D.create(width / 2, -height / 3, 0))+    sy = sketch.sketchDimensions.addDistanceDimension(second.startSketchPoint, second.endSketchPoint,+            orient.VerticalDimensionOrientation, adsk.core.Point3D.create(width * 1.3, height / 2, 0))+    sx.parameter.expression, sy.parameter.expression = "width", "height"+    # addTwoPointRectangle at the origin supplies the origin coincidence itself.+    feature_input = root.features.extrudeFeatures.createInput(sketch.profiles.item(0), adsk.fusion.FeatureOperations.NewBodyFeatureOperation)+    extent = adsk.fusion.DistanceExtentDefinition.create(adsk.core.ValueInput.createByString("depth"))+    feature_input.setOneSideExtent(extent, adsk.fusion.ExtentDirections.PositiveExtentDirection)+    feature = root.features.extrudeFeatures.add(feature_input)+    feature.name = "Base extrusion"+    feature.bodies.item(0).name = "Block"+++def parameter_set(app, args):+    _, design, before_target = target(app, args, True)+    require_healthy(design, False)+    name, expression = args.get("name"), args.get("expression")+    require(isinstance(name, str) and isinstance(expression, str) and expression.strip(), "invalid_input", "name and expression are required strings.")+    parameter = design.allParameters.itemByName(name)+    require(parameter is not None, "parameter_missing", "No parameter named " + name)+    require(design.unitsManager.isValidExpression(expression, parameter.unit), "invalid_expression", "Expression is invalid for the parameter's unit.")+    before, old = recovery_snapshot(design), parameter.expression+    try:+        parameter.expression = expression+        state = require_healthy(design)+    except Exception as exc:+        recovery = {"strategy": "restore_parameter_expression", "verified": False,+                    "scope": "parameter expressions, body metrics, occurrence transforms, counts and health"}+        try:+            parameter.expression = old+            require_healthy(design)+            recovery["verified"] = recovery_snapshot(design) == before+        except Exception as restore_error:+            recovery["error"] = str(restore_error)+        raise MechanicalError("parameter_edit_failed", str(exc), recovery=recovery, target=current_target(app))+    return {"target": current_target(app), "parameter": parameter_data(design, parameter),+            "health": state, "recoveryStrategy": "restore_parameter_expression", "transactional": False}+++def parameter_create(app, args):+    _, design, _ = target(app, args, True)+    require_healthy(design, False)+    name, expression, unit = args.get("name"), args.get("expression"), args.get("unit")+    require(isinstance(name, str) and re.fullmatch(r"[A-Za-z][A-Za-z0-9_]{0,63}", name), "invalid_input", "Use a short parameter identifier.")+    require(unit in ("mm", "deg", "kg", ""), "invalid_input", "unit must be mm, deg, kg or empty for unitless.")+    require(isinstance(expression, str) and design.unitsManager.isValidExpression(expression, unit), "invalid_expression", "Expression must match the declared unit.")+    require(design.allParameters.itemByName(name) is None, "parameter_exists", "Parameter already exists.")+    before = recovery_snapshot(design)+    parameter = None+    try:+        parameter = design.userParameters.add(name, adsk.core.ValueInput.createByString(expression), unit, args.get("comment", ""))+        require(parameter is not None, "parameter_create_failed", "Fusion returned no parameter.")+        state = require_healthy(design)+    except Exception as exc:+        recovery = {"strategy": "delete_created_parameter", "verified": False}+        try:+            created = parameter or design.userParameters.itemByName(name)+            if created:+                created.deleteMe()+            require_healthy(design)+            recovery["verified"] = recovery_snapshot(design) == before+        except Exception as restore_error:+            recovery["error"] = str(restore_error)+        raise MechanicalError("parameter_create_failed", str(exc), recovery=recovery)+    return {"target": current_target(app), "parameter": parameter_data(design, parameter), "health": state, "transactional": False}+++def check_health(app, args):+    _, design, _ = target(app, args, args.get("recompute", False))+    state = health(design, args.get("recompute", False))+    return {"target": current_target(app), "health": state}+++def export(app, args):+    _, design, value = target(app, args, True)+    require_healthy(design, False)+    result = export_design(design, args)+    result["target"] = value+    return result+++OPERATIONS = {"inspect": inspect, "inspect_entity": inspect_entity, "new_design": new_design,+              "parameter_set": parameter_set, "parameter_create": parameter_create,+              "health": check_health, "export": export}+WRITES = {"new_design", "parameter_set", "parameter_create", "export"}

@@ -0,0 +1,137 @@+"""Local supplier CAD ingestion and Fusion's native McMaster command."""+import hashlib+from pathlib import Path+from urllib.parse import urlparse++import adsk.core++from . import transactions+from .assemblies import apply_metadata, created_occurrence_result, hybrid, parent_component, place_created_occurrence, transform+from .assembly_state import metadata+from .core import MechanicalError, active, current_target, items, ref, require, resolve, target++MCM_COMMAND = "InsertMcMasterCarrComponentCommand"+++def file_hash(path):+    result = hashlib.sha256()+    with path.open("rb") as stream:+        for block in iter(lambda: stream.read(1024 * 1024), b""):+            result.update(block)+    return result.hexdigest()+++def preflight_file(args):+    path = Path(args["filename"])+    require(path.is_absolute() and path.is_file() and not path.is_symlink(), "invalid_source", "Supplier CAD must be an absolute regular local file.")+    require(path.suffix.lower() in (".step", ".stp", ".sat"), "unsupported_format", "Local supplier ingestion supports STEP and SAT.")+    require(0 < path.stat().st_size <= 512 * 1024 * 1024, "invalid_source", "Supplier CAD must be nonempty and no larger than 512 MiB.")+    provenance = args["provenance"]+    url = urlparse(provenance["sourceUrl"])+    require(url.scheme == "https" and url.hostname and not url.username and not url.password, "invalid_provenance", "sourceUrl must be an HTTPS supplier URL without credentials.")+    if provenance["supplier"].lower() in ("mcmaster", "mcmaster-carr"):+        require(url.hostname.lower() == "mcmaster.com" or url.hostname.lower().endswith(".mcmaster.com"), "invalid_provenance", "McMaster provenance must use the supplier's domain.")+    sha = file_hash(path)+    if "sha256" in args:+        require(args["sha256"].lower() == sha, "source_hash_mismatch", "Downloaded CAD does not match the expected SHA-256.")+    return path, sha+++def cad_import(app, args):+    # Source preflight runs before any transaction/model mutation. The importer+    # only reads this file; no cloud upload, browser download or file rewrite.+    target(app, args, True)+    path, sha = preflight_file(args)+    document_count = app.documents.count+    manager = app.importManager+    factory = manager.createSATImportOptions if path.suffix.lower() == ".sat" else manager.createSTEPImportOptions+    options = factory(str(path))+    require(options is not None, "import_unavailable", "Fusion refused import options.")+    options.isViewFit = False++    def mutate(design, value, request):+        hybrid(design)+        parent = parent_component(design, value, request)+        expected = transform(request.get("transform"))+        occurrence = parent.occurrences.addNewComponent(expected)+        require(occurrence is not None, "import_failed", "Could not create import wrapper component.")+        comp = occurrence.component+        comp.name = request.get("name", path.stem)+        imported = manager.importToTarget2(options, comp)+        require(imported is not None and imported.count > 0, "import_failed", "Fusion returned no imported objects.")+        require(app.documents.count == document_count, "import_document_side_effect", "Importer changed the document set; inspect documents before continuing.")+        components = [comp] + [o.component for o in items(comp.allOccurrences)]+        require(any(c.bRepBodies.count for c in components), "import_empty", "Imported CAD contains no BRep bodies.")+        require(file_hash(path) == sha, "source_changed", "Supplier CAD changed while import was running.")+        provenance = {**request["provenance"], "sourceFile": str(path), "sha256": sha,+                      "asPurchased": request.get("asPurchased", True), "partNumber": request["provenance"]["supplierPartNumber"]}+        apply_metadata(comp, provenance)+        captured = place_created_occurrence(design, parent, occurrence, expected)+        return lambda fresh: {**created_occurrence_result(design, parent, occurrence, fresh, expected), "positionCaptured": captured,+                              "source": {"filename": str(path), "sha256": sha},+                              "importedObjectCount": imported.count, "externalEffects": "read-only source file; no cloud or document creation requested"}+    try:+        return transactions.execute(app, args, mutate)+    except MechanicalError as exc:+        exc.details["sourceFileModified"] = False+        exc.details["documentSetUnchanged"] = app.documents.count == document_count+        raise+++def mcmaster_discover(app, args):+    _, design, _ = active(app)+    command = app.userInterface.commandDefinitions.itemById(MCM_COMMAND)+    return {"target": current_target(app), "commandId": MCM_COMMAND, "available": command is not None,+            "name": command.name if command else None, "designIntent": str(getattr(design, "designIntent", "unavailable")),+            "requirements": ["Hybrid design", "online supplier access", "interactive selection and download"],+            "downloadedCadAlternative": "cad_import with local STEP/SAT and supplier provenance"}+++def mcmaster_open(app, args):+    _, design, value = target(app, args, True)+    hybrid(design)+    command = app.userInterface.commandDefinitions.itemById(MCM_COMMAND)+    require(command is not None, "mcmaster_unavailable", "Fusion's native McMaster command is not installed.")+    require(command.execute(), "mcmaster_launch_failed", "Fusion refused the native McMaster command.")+    return {"commandId": MCM_COMMAND, "launchRequested": True, "targetAtLaunch": value,+            "completion": "interactive; inspect after inserting or cancelling", "refreshRequired": True,+            "transactional": False, "recovery": "native command controls its own user interaction"}+++def material_list(app, args):+    _, design, value = target(app, args)+    libraries = [{"id": library.id, "name": library.name, "count": library.materials.count} for library in items(app.materialLibraries)]+    source = design.materials+    if args.get("libraryId"):+        matches = [lib for lib in items(app.materialLibraries) if lib.id == args["libraryId"]]+        require(len(matches) == 1, "material_library_missing", "Material library ID must identify one loaded library.")+        source = matches[0].materials+    query = args.get("query", "").lower()+    rows = [{"id": material.id, "name": material.name} for material in items(source) if query in material.name.lower()]+    limit = args.get("limit", 100)+    return {"target": value, "libraries": libraries, "materials": rows[:limit], "complete": len(rows) <= limit,+            "matchingCount": len(rows), "libraryId": args.get("libraryId")}+++def material_assign(app, args):+    def mutate(design, value, request):+        entity = resolve(design, value, request["entity"], ("Component", "BRepBody"))+        require(getattr(entity, "assemblyContext", None) is None, "definition_reference_required", "Material assignment affects a native component or body definition.")+        source = design.materials+        if request.get("libraryId"):+            matches = [lib for lib in items(app.materialLibraries) if lib.id == request["libraryId"]]+            require(len(matches) == 1, "material_library_missing", "Material library ID must identify one loaded library.")+            source = matches[0].materials+        material = source.itemById(request["materialId"])+        require(material is not None, "material_missing", "Material ID was not found in the selected source.")+        entity.material = material+        def result(fresh):+            require(entity.material is not None and entity.material.id == material.id, "material_failed", "Assigned material ID did not read back; same display names are not material identity.")+            return {"entity": ref(entity, fresh), "material": {"id": entity.material.id, "name": entity.material.name}}+        return result+    return transactions.execute(app, args, mutate)+++OPERATIONS = {"cad_import": cad_import, "mcmaster_open": mcmaster_open, "material_assign": material_assign,+              "mcmaster_discover": mcmaster_discover, "material_list": material_list}+WRITES = {"cad_import", "mcmaster_open", "material_assign"}

@@ -0,0 +1,119 @@+"""Detailed topology and sketch readback using resolvable guarded references."""+import json+from .core import body_data, digest, items, point_mm, ref, require, same+++def geometry_data(geometry):+    result = {"type": geometry.objectType}+    for name in ("startPoint", "endPoint", "center", "origin"):+        if hasattr(geometry, name):+            result[name] = point_mm(getattr(geometry, name))+    for name in ("normal", "direction", "majorAxis", "minorAxis"):+        if hasattr(geometry, name):+            p = getattr(geometry, name)+            result[name] = [p.x, p.y, p.z]+    for name in ("radius", "majorRadius", "minorRadius"):+        if hasattr(geometry, name):+            result[name] = getattr(geometry, name) * 10+    return result+++def edge_geometry_data(edge):+    geometry = edge.geometry+    if geometry is not None:+        return geometry_data(geometry)+    require(edge.isDegenerate, "unavailable_geometry", "Nondegenerate BRep edge has no readable curve geometry.")+    vertices = [point_mm(vertex.geometry) for vertex in (edge.startVertex, edge.endVertex) if vertex is not None]+    require(vertices, "unavailable_geometry", "Degenerate BRep edge has no readable vertex position.")+    return {"type": "degenerate", "isDegenerate": True, "vertices": vertices}+++def profile_signature(profile):+    props = profile.areaProperties()+    return {"area": props.area * 100, "centroid": point_mm(props.centroid), "loops": profile.profileLoops.count}+++def profile_ref(sketch, profile, index, value):+    return {**value, "objectType": "adsk::fusion::Profile", "sketchToken": sketch.entityToken,+            "profileIndex": index, "fingerprint": digest(profile_signature(profile))}+++def curve_data(curve, value=None):+    result = {"type": curve.objectType, "construction": curve.isConstruction,+              "fixed": curve.isFixed, "geometry": geometry_data(curve.geometry)}+    if value:+        result["ref"] = ref(curve, value)+    for name in ("startSketchPoint", "endSketchPoint", "centerSketchPoint"):+        if hasattr(curve, name):+            point = getattr(curve, name)+            result[name] = {"position": point_mm(point.geometry)}+            if value:+                result[name]["ref"] = ref(point, value)+    if hasattr(curve, "fitPoints"):+        result["fitPoints"] = [point_mm(p.geometry) for p in items(curve.fitPoints)]+    return result+++def sketch_data(sketch, value=None):+    result = {"name": sketch.name, "space": "sketch", "lengthUnit": "mm",+              "fullyConstrained": sketch.isFullyConstrained,+              "curves": [curve_data(curve, value) for curve in items(sketch.sketchCurves)],+              "points": [{"position": point_mm(p.geometry), "fixed": p.isFixed, **({"ref": ref(p, value)} if value else {})}+                         for p in items(sketch.sketchPoints)],+              "constraints": [{"type": constraint.objectType} for constraint in items(sketch.geometricConstraints)],+              "dimensions": [{"type": dimension.objectType, "name": dimension.parameter.name,+                               "expression": dimension.parameter.expression, "driving": dimension.isDriving}+                              for dimension in items(sketch.sketchDimensions)]}+    if value:+        result["ref"] = ref(sketch, value)+        result["originRef"] = ref(sketch.originPoint, value)+        result["profiles"] = [{**profile_signature(profile), "ref": profile_ref(sketch, profile, index, value)}+                              for index, profile in enumerate(items(sketch.profiles))]+    return result+++def topology_data(body, value):+    result = body_data(body)+    result["ref"] = ref(body, value)+    result["faces"] = [{"ref": ref(face, value), "area": face.area * 100,+                         "point": point_mm(face.pointOnFace), "surface": geometry_data(face.geometry),+                         "edges": [ref(edge, value) for edge in items(face.edges)]}+                        for face in items(body.faces)]+    result["edges"] = [{"ref": ref(edge, value), "length": edge.length * 10,+                         "curve": edge_geometry_data(edge)} for edge in items(body.edges)]+    return result+++def topology_witness(body):+    result = body_data(body)+    # Compare geometry rather than revision or transient topology IDs after undo.+    result["faceGeometry"] = sorted([+        {"area": f.area * 100, "point": point_mm(f.pointOnFace), "surface": geometry_data(f.geometry)}+        for f in items(body.faces)], key=lambda row: json.dumps(row, sort_keys=True))+    result["edgeGeometry"] = sorted([+        {"length": e.length * 10, "curve": edge_geometry_data(e)} for e in items(body.edges)],+        key=lambda row: json.dumps(row, sort_keys=True))+    return result+++def feature_data(feature, value=None, order=None):+    result = {"name": feature.name, "type": feature.objectType}+    if order is not None:+        result["componentFeatureOrder"] = order+    if value:+        result["ref"] = ref(feature, value)+    timeline = getattr(feature, "timelineObject", None)+    if timeline:+        result["suppressed"] = timeline.isSuppressed+        try:+            result["index"] = timeline.index+        except RuntimeError as exc:+            # Imported/native grouped features can have a valid timeline object+            # whose index getter rejects its documented non-indexed position.+            # Only this known getter failure is optional; retain name, type,+            # suppression and component collection order in semantic witnesses.+            if "InternalValidationError : res >= 0" not in str(exc):+                raise+            require(timeline.isValid, "invalid_timeline", "Feature timeline object is no longer valid.")+            result.update(index=None, indexUnavailable="native_timeline_position_unavailable")+    return result

@@ -0,0 +1,4880 @@+{+  "inspect": {+    "type": "object",+    "required": [+      "op"+    ],+    "properties": {},+    "description": "Inspect the active Design without mutation. Returns target identity/revision, native component-space bodies and occurrence transforms, parameters and feature health."+  },+  "inspect_entity": {+    "type": "object",+    "required": [+      "op",+      "target",+      "entity"+    ],+    "properties": {+      "entity": {+        "type": "object",+        "description": "Exact reference returned by inspect; resolves uniquely with document/revision/type/occurrence guards."+      }+    }+  },+  "new_design": {+    "type": "object",+    "required": [+      "op",+      "sessionId",+      "operationId"+    ],+    "properties": {+      "name": {+        "type": "string"+      },+      "box": {+        "type": "object",+        "required": [+          "width",+          "height",+          "depth"+        ],+        "additionalProperties": false,+        "properties": {+          "width": {+            "type": "number",+            "exclusiveMinimum": 0+          },+          "height": {+            "type": "number",+            "exclusiveMinimum": 0+          },+          "depth": {+            "type": "number",+            "exclusiveMinimum": 0+          }+        }+      }+    },+    "description": "Create an unnamed unsaved parametric hybrid Design; name is retained as requestedName metadata to keep failure recovery free of save dialogs. Optional box dimensions in mm create a driving-parameter fixture. Never edits an existing document."+  },+  "parameter_set": {+    "type": "object",+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "name",+      "expression"+    ],+    "properties": {+      "name": {+        "type": "string"+      },+      "expression": {+        "type": "string"+      }+    },+    "description": "Set an expression, recompute and inspect health. Failure restores old expression and reports a semantic recovery witness; not an atomic transaction."+  },+  "parameter_create": {+    "type": "object",+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "name",+      "expression",+      "unit"+    ],+    "properties": {+      "name": {+        "type": "string"+      },+      "expression": {+        "type": "string"+      },+      "unit": {+        "enum": [+          "mm",+          "deg",+          "kg",+          ""+        ]+      },+      "comment": {+        "type": "string"+      }+    }+  },+  "health": {+    "type": "object",+    "required": [+      "op",+      "target"+    ],+    "properties": {+      "recompute": {+        "type": "boolean",+        "default": false+      }+    },+    "description": "Read timeline warnings/errors. recompute:true also requires current target revision, sessionId and operationId."+  },+  "export": {+    "type": "object",+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "outputPath"+    ],+    "properties": {+      "format": {+        "enum": [+          "step",+          "stl",+          "3mf",+          "f3d",+          "iges",+          "sat",+          "smt",+          "usdz",+          "fbx",+          "skp"+        ],+        "default": "step"+      },+      "outputPath": {+        "type": "string"+      },+      "overwrite": {+        "type": "boolean",+        "default": false+      },+      "refinement": {+        "enum": [+          "low",+          "medium",+          "high"+        ],+        "default": "medium"+      }+    },+    "description": "Export entire design using runtime-checked API. Preflight and unique same-filesystem staging preserve the destination on failure; publish only nonempty verified output. Availability differs by Fusion build. STL numeric coordinates use mm."+  },+  "transaction_probe": {+    "type": "object",+    "properties": {},+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target"+    ],+    "description": "Verify runtime PTransaction abort+commit using temporary user parameters, remove probe data and compare semantic restoration. Required once per running add-in session before feature/sketch/atomic-batch writes. Returns fresh target; inspect again for current references."+  },+  "sketch_create": {+    "type": "object",+    "properties": {+      "plane": {+        "oneOf": [+          {+            "enum": [+              "xy",+              "xz",+              "yz"+            ]+          },+          {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          }+        ]+      },+      "component": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "name": {+        "type": "string"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target"+    ],+    "description": "Create a native component-definition sketch on an origin/construction plane or planar face. Coordinates in subsequent geometry are sketch-space mm."+  },+  "sketch_geometry": {+    "type": "object",+    "properties": {+      "sketch": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "items": {+        "type": "array",+        "items": {+          "oneOf": [+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "point"+                  ]+                },+                "position": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                }+              },+              "required": [+                "type",+                "position"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "line"+                  ]+                },+                "start": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "end": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "start",+                "end"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "rectangle"+                  ]+                },+                "start": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "end": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "start",+                "end"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "circle"+                  ]+                },+                "center": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "radius": {+                  "type": "number",+                  "exclusiveMinimum": 0+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "center",+                "radius"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "arc"+                  ]+                },+                "center": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "start": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "sweep": {+                  "type": "number"+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "center",+                "start",+                "sweep"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "polygon"+                  ]+                },+                "center": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "radius": {+                  "type": "number",+                  "exclusiveMinimum": 0+                },+                "sides": {+                  "type": "integer",+                  "minimum": 3,+                  "maximum": 128+                },+                "angle": {+                  "type": "number"+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "center",+                "radius",+                "sides"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "slot"+                  ]+                },+                "start": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "end": {+                  "type": "array",+                  "items": {+                    "type": "number"+                  },+                  "minItems": 2,+                  "maxItems": 3+                },+                "width": {+                  "type": "number",+                  "exclusiveMinimum": 0+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "start",+                "end",+                "width"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "type": {+                  "enum": [+                    "spline"+                  ]+                },+                "points": {+                  "type": "array",+                  "items": {+                    "type": "array",+                    "items": {+                      "type": "number"+                    },+                    "minItems": 2,+                    "maxItems": 3+                  },+                  "minItems": 2,+                  "maxItems": 128+                },+                "closed": {+                  "type": "boolean"+                },+                "construction": {+                  "type": "boolean"+                }+              },+              "required": [+                "type",+                "points"+              ],+              "additionalProperties": false+            }+          ]+        },+        "minItems": 1,+        "maxItems": 128+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "sketch",+      "items"+    ],+    "description": "Create a transactionally grouped set of sketch primitives. Numeric geometry uses mm and arc sweeps/polygon angles use deg."+  },+  "sketch_constraint": {+    "type": "object",+    "properties": {+      "sketch": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "type": {+        "enum": [+          "horizontal",+          "vertical",+          "coincident",+          "parallel",+          "perpendicular",+          "tangent",+          "equal",+          "concentric",+          "collinear",+          "midpoint",+          "symmetry",+          "fix"+        ]+      },+      "entities": {+        "type": "array",+        "items": {+          "type": "object",+          "required": [+            "documentId",+            "revision",+            "objectType"+          ],+          "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+        },+        "minItems": 1,+        "maxItems": 256+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "sketch",+      "type",+      "entities"+    ],+    "description": "Constrain entities in one sketch. midpoint order is point,line; symmetry order entity1,entity2,symmetryLine. fix sets one entity fixed."+  },+  "sketch_dimension": {+    "type": "object",+    "properties": {+      "sketch": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "type": {+        "enum": [+          "distance",+          "horizontal",+          "vertical",+          "radius",+          "diameter",+          "angle"+        ]+      },+      "entities": {+        "type": "array",+        "items": {+          "type": "object",+          "required": [+            "documentId",+            "revision",+            "objectType"+          ],+          "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+        },+        "minItems": 1,+        "maxItems": 256+      },+      "expression": {+        "oneOf": [+          {+            "type": "number"+          },+          {+            "type": "string"+          }+        ]+      },+      "position": {+        "type": "array",+        "items": {+          "type": "number"+        },+        "minItems": 2,+        "maxItems": 3+      },+      "parameterName": {+        "type": "string"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "sketch",+      "type",+      "entities",+      "expression",+      "position"+    ],+    "description": "Add driving dimensions. Distance uses two point references; radius/diameter one curve; angle two lines. Numeric expressions use mm or deg."+  },+  "sketch_project": {+    "type": "object",+    "properties": {+      "sketch": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "entities": {+        "type": "array",+        "items": {+          "type": "object",+          "required": [+            "documentId",+            "revision",+            "objectType"+          ],+          "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+        },+        "minItems": 1,+        "maxItems": 256+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "sketch",+      "entities"+    ],+    "description": "Project selected topology into a sketch with Fusion associative projection."+  },+  "sketch_edit": {+    "type": "object",+    "properties": {+      "sketch": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "entity": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "changes": {+        "type": "object",+        "properties": {+          "position": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 2,+            "maxItems": 3+          },+          "start": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 2,+            "maxItems": 3+          },+          "end": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 2,+            "maxItems": 3+          },+          "center": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 2,+            "maxItems": 3+          },+          "radius": {+            "type": "number"+          },+          "construction": {+            "type": "boolean"+          },+          "fixed": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "sketch",+      "entity",+      "changes"+    ],+    "description": "Move sketch points/endpoints/centers in sketch-space mm, change radius or construction/fixed flags; solver failure aborts the operation."+  },+  "plane_create": {+    "type": "object",+    "properties": {+      "type": {+        "enum": [+          "offset",+          "angle"+        ]+      },+      "plane": {+        "oneOf": [+          {+            "enum": [+              "xy",+              "xz",+              "yz"+            ]+          },+          {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          }+        ]+      },+      "component": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "offset": {+        "oneOf": [+          {+            "type": "number"+          },+          {+            "type": "string"+          }+        ]+      },+      "axis": {+        "oneOf": [+          {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          }+        ]+      },+      "angle": {+        "oneOf": [+          {+            "type": "number"+          },+          {+            "type": "string"+          }+        ]+      },+      "name": {+        "type": "string"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "type"+    ],+    "description": "Create offset plane (offset in mm) or angled plane around axis (angle in deg).",+    "oneOf": [+      {+        "type": "object",+        "required": [+          "type",+          "offset"+        ],+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ]+          },+          "plane": {+            "oneOf": [+              {+                "enum": [+                  "xy",+                  "xz",+                  "yz"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "type": {+            "enum": [+              "offset"+            ]+          },+          "offset": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          }+        },+        "additionalProperties": false+      },+      {+        "type": "object",+        "required": [+          "type",+          "axis",+          "angle"+        ],+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ]+          },+          "plane": {+            "oneOf": [+              {+                "enum": [+                  "xy",+                  "xz",+                  "yz"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "type": {+            "enum": [+              "angle"+            ]+          },+          "axis": {+            "oneOf": [+              {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "angle": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          }+        },+        "additionalProperties": false+      }+    ]+  },+  "feature_create": {+    "type": "object",+    "properties": {+      "type": {+        "enum": [+          "extrude",+          "revolve",+          "fillet",+          "chamfer",+          "shell",+          "hole",+          "loft",+          "sweep",+          "combine",+          "split",+          "move",+          "mirror",+          "rectangular_pattern",+          "circular_pattern",+          "draft",+          "thread"+        ]+      },+      "component": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "name": {+        "type": "string"+      },+      "profiles": {},+      "distance": {},+      "direction": {},+      "taper": {},+      "bodies": {},+      "operation": {},+      "axis": {},+      "angle": {},+      "edges": {},+      "radius": {},+      "tangentChain": {},+      "faces": {},+      "thickness": {},+      "points": {},+      "diameter": {},+      "depth": {},+      "path": {},+      "body": {},+      "tools": {},+      "keepTools": {},+      "plane": {},+      "extend": {},+      "translation": {},+      "origin": {},+      "count": {},+      "spacing": {},+      "axis2": {},+      "count2": {},+      "spacing2": {},+      "internal": {},+      "threadType": {},+      "designation": {},+      "threadClass": {},+      "modeled": {}+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "type"+    ],+    "description": "Create a typed native solid feature. All length quantities are mm (or expressions), angles deg. Cut/intersect require explicit participant bodies. Join needs a single existing component body; combine selects multiple bodies explicitly. Feature availability is runtime-checked; missing APIs fail before commit.",+    "oneOf": [+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "extrude"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "profiles": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "distance": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "direction": {+            "enum": [+              "positive",+              "negative",+              "symmetric"+            ]+          },+          "taper": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "operation": {+            "enum": [+              "new_body",+              "join",+              "cut",+              "intersect"+            ]+          }+        },+        "required": [+          "type",+          "profiles",+          "distance"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "revolve"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "profiles": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "axis": {+            "oneOf": [+              {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "angle": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "operation": {+            "enum": [+              "new_body",+              "join",+              "cut",+              "intersect"+            ]+          }+        },+        "required": [+          "type",+          "profiles",+          "axis",+          "angle"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "fillet"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "edges": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "radius": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "tangentChain": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "edges",+          "radius"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "chamfer"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "edges": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "distance": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "tangentChain": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "edges",+          "distance"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "shell"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "faces": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "thickness": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "tangentChain": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "faces",+          "thickness"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "hole"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "points": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "diameter": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "depth": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          }+        },+        "required": [+          "type",+          "points",+          "diameter",+          "depth",+          "bodies"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "loft"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "profiles": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "operation": {+            "enum": [+              "new_body",+              "join",+              "cut",+              "intersect"+            ]+          }+        },+        "required": [+          "type",+          "profiles"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "sweep"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "profiles": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "path": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "operation": {+            "enum": [+              "new_body",+              "join",+              "cut",+              "intersect"+            ]+          }+        },+        "required": [+          "type",+          "profiles",+          "path"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "combine"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "body": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "tools": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "operation": {+            "enum": [+              "join",+              "cut",+              "intersect"+            ]+          },+          "keepTools": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "body",+          "tools",+          "operation"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "split"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "plane": {+            "oneOf": [+              {+                "enum": [+                  "xy",+                  "xz",+                  "yz"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "extend": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "bodies",+          "plane"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "move"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "translation": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 2,+            "maxItems": 3+          },+          "axis": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "angle": {+            "type": "number"+          },+          "origin": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 2,+            "maxItems": 3+          }+        },+        "required": [+          "type",+          "bodies"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "mirror"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "plane": {+            "oneOf": [+              {+                "enum": [+                  "xy",+                  "xz",+                  "yz"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          }+        },+        "required": [+          "type",+          "bodies",+          "plane"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "rectangular_pattern"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "axis": {+            "oneOf": [+              {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "count": {+            "type": "integer",+            "minimum": 2,+            "maximum": 1000+          },+          "spacing": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "axis2": {+            "oneOf": [+              {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "count2": {+            "type": "integer",+            "minimum": 1,+            "maximum": 1000+          },+          "spacing2": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          }+        },+        "required": [+          "type",+          "bodies",+          "axis",+          "count",+          "spacing"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "circular_pattern"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "bodies": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "axis": {+            "oneOf": [+              {+                "enum": [+                  "x",+                  "y",+                  "z"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "count": {+            "type": "integer",+            "minimum": 2,+            "maximum": 1000+          },+          "angle": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          }+        },+        "required": [+          "type",+          "bodies",+          "axis",+          "count"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "draft"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "faces": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "plane": {+            "oneOf": [+              {+                "enum": [+                  "xy",+                  "xz",+                  "yz"+                ]+              },+              {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+              }+            ]+          },+          "angle": {+            "oneOf": [+              {+                "type": "number"+              },+              {+                "type": "string"+              }+            ]+          },+          "tangentChain": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "faces",+          "plane",+          "angle"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "type": {+            "enum": [+              "thread"+            ]+          },+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object",+            "required": [+              "documentId",+              "revision"+            ],+            "properties": {+              "documentId": {+                "type": "string"+              },+              "revision": {+                "type": "string"+              }+            },+            "additionalProperties": false+          },+          "component": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+          },+          "name": {+            "type": "string"+          },+          "faces": {+            "type": "array",+            "items": {+              "type": "object",+              "required": [+                "documentId",+                "revision",+                "objectType"+              ],+              "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+            },+            "minItems": 1,+            "maxItems": 256+          },+          "internal": {+            "type": "boolean"+          },+          "threadType": {+            "type": "string"+          },+          "designation": {+            "type": "string"+          },+          "threadClass": {+            "type": "string"+          },+          "modeled": {+            "type": "boolean"+          }+        },+        "required": [+          "type",+          "faces",+          "internal",+          "threadType",+          "designation",+          "threadClass"+        ],+        "additionalProperties": false+      }+    ]+  },+  "feature_edit": {+    "type": "object",+    "properties": {+      "feature": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      },+      "name": {+        "type": "string"+      },+      "suppressed": {+        "type": "boolean"+      },+      "parameters": {+        "type": "object",+        "additionalProperties": {+          "type": "string"+        }+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "feature"+    ],+    "description": "Rename/suppress a feature or change expressions of model parameters whose createdBy is that exact feature; read health and abort on downstream errors."+  },+  "entity_delete": {+    "type": "object",+    "properties": {+      "entity": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Reference returned by inspect/inspect_entity in this document revision; native component-definition references for authoring."+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "entity"+    ],+    "description": "Delete sketch geometry or independently deletable timeline features. Model transaction and semantic recovery cover downstream failures; document and external file deletion are excluded."+  },+  "parameter_batch": {+    "type": "object",+    "properties": {+      "changes": {+        "type": "array",+        "items": {+          "oneOf": [+            {+              "type": "object",+              "properties": {+                "action": {+                  "enum": [+                    "create"+                  ]+                },+                "name": {+                  "type": "string"+                },+                "expression": {+                  "type": "string"+                },+                "unit": {+                  "enum": [+                    "mm",+                    "deg",+                    "kg",+                    ""+                  ]+                },+                "comment": {+                  "type": "string"+                }+              },+              "required": [+                "action",+                "name",+                "expression",+                "unit"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "action": {+                  "enum": [+                    "set"+                  ]+                },+                "name": {+                  "type": "string"+                },+                "expression": {+                  "type": "string"+                }+              },+              "required": [+                "action",+                "name",+                "expression"+              ],+              "additionalProperties": false+            },+            {+              "type": "object",+              "properties": {+                "action": {+                  "enum": [+                    "delete"+                  ]+                },+                "name": {+                  "type": "string"+                }+              },+              "required": [+                "action",+                "name"+              ],+              "additionalProperties": false+            }+          ]+        },+        "minItems": 1,+        "maxItems": 128+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "changes"+    ],+    "description": "Atomic sequential create/set/delete parameter edits with one recompute+health gate; delete supports user parameters only. Any failure aborts all edits and reports semantic recovery."+  },+  "component_create": {+    "type": "object",+    "properties": {+      "parent": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "name": {+        "type": "string"+      },+      "transform": {+        "type": "object",+        "properties": {+          "position": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "axis": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "angle": {+            "type": "number"+          }+        },+        "required": [],+        "additionalProperties": false,+        "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context."+      },+      "metadata": {+        "type": "object",+        "properties": {+          "name": {+            "type": "string"+          },+          "partNumber": {+            "type": "string"+          },+          "description": {+            "type": "string"+          },+          "supplier": {+            "type": "string"+          },+          "supplierPartNumber": {+            "type": "string"+          },+          "sourceUrl": {+            "type": "string"+          },+          "asPurchased": {+            "type": "boolean"+          },+          "excludeFromBom": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "name"+    ],+    "description": "Create a native internal component and its first occurrence in a Hybrid design. parent is a component definition; edits to it affect every instance. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused."+  },+  "occurrence_insert": {+    "type": "object",+    "properties": {+      "component": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "parent": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "transform": {+        "type": "object",+        "properties": {+          "position": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "axis": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "angle": {+            "type": "number"+          }+        },+        "required": [],+        "additionalProperties": false,+        "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context."+      },+      "independentCopy": {+        "type": "boolean"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "component"+    ],+    "description": "Insert another occurrence of an existing definition; independentCopy:true uses Paste New to create a separate definition. Nested placement is in parent component coordinates. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused."+  },+  "occurrence_update": {+    "type": "object",+    "properties": {+      "occurrence": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "transform": {+        "type": "object",+        "properties": {+          "position": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "axis": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "angle": {+            "type": "number"+          }+        },+        "required": [],+        "additionalProperties": false,+        "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context."+      },+      "grounded": {+        "type": "boolean"+      },+      "groundedToParent": {+        "type": "boolean"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "occurrence"+    ],+    "description": "Set occurrence pose in its assembly context and capture position; explicit grounding/ungrounding. Grounded or constrained transforms fail with recovery."+  },+  "occurrence_delete": {+    "type": "object",+    "properties": {+      "occurrence": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "occurrence"+    ],+    "description": "Delete one selected occurrence through the shared transaction executor."+  },+  "component_metadata": {+    "type": "object",+    "properties": {+      "component": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "changes": {+        "type": "object",+        "properties": {+          "name": {+            "type": "string"+          },+          "partNumber": {+            "type": "string"+          },+          "description": {+            "type": "string"+          },+          "supplier": {+            "type": "string"+          },+          "supplierPartNumber": {+            "type": "string"+          },+          "sourceUrl": {+            "type": "string"+          },+          "asPurchased": {+            "type": "boolean"+          },+          "excludeFromBom": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "changes"+    ],+    "description": "Update component-definition name/part number/description and persistent supplier or BOM attributes. Shared occurrences all see this metadata."+  },+  "joint_create": {+    "type": "object",+    "properties": {+      "type": {+        "enum": [+          "rigid",+          "revolute",+          "slider",+          "cylindrical",+          "pin_slot",+          "planar",+          "ball"+        ]+      },+      "occurrenceOne": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "occurrenceTwo": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "geometry": {+        "type": "object",+        "properties": {+          "entity": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "keyPoint": {+            "enum": [+              "center",+              "start",+              "middle",+              "end"+            ]+          }+        },+        "required": [+          "entity"+        ],+        "additionalProperties": false+      },+      "axis": {+        "enum": [+          "x",+          "y",+          "z"+        ]+      },+      "name": {+        "type": "string"+      },+      "suppressed": {+        "type": "boolean"+      },+      "rotationLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "slideLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "rotationValue": {+        "type": "number"+      },+      "slideValue": {+        "type": "number"+      },+      "primarySlideLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "primarySlideValue": {+        "type": "number"+      },+      "secondarySlideLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "secondarySlideValue": {+        "type": "number"+      },+      "pitchLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "pitchValue": {+        "type": "number"+      },+      "rollLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "rollValue": {+        "type": "number"+      },+      "yawLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "yawValue": {+        "type": "number"+      },+      "slideAxis": {+        "enum": [+          "x",+          "y",+          "z"+        ]+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "type",+      "occurrenceOne",+      "occurrenceTwo"+    ],+    "description": "Create an as-built joint without moving occurrences. Non-rigid motion requires explicit joint geometry; x/y/z are joint-coordinate directions. Limits and drive values use mm/deg. Seven native motion types; ball uses joint Z pitch/X yaw; planar uses native primary slide direction reported on readback. Geometry-moving regular joint creation is not exposed.",+    "oneOf": [+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "rigid"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          }+        },+        "required": [+          "type"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "revolute"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          },+          "geometry": {+            "type": "object",+            "properties": {+              "entity": {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+              },+              "keyPoint": {+                "enum": [+                  "center",+                  "start",+                  "middle",+                  "end"+                ]+              }+            },+            "required": [+              "entity"+            ],+            "additionalProperties": false+          },+          "axis": {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          "rotationLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "rotationValue": {+            "type": "number"+          }+        },+        "required": [+          "type",+          "geometry"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "slider"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          },+          "geometry": {+            "type": "object",+            "properties": {+              "entity": {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+              },+              "keyPoint": {+                "enum": [+                  "center",+                  "start",+                  "middle",+                  "end"+                ]+              }+            },+            "required": [+              "entity"+            ],+            "additionalProperties": false+          },+          "axis": {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          "slideLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "slideValue": {+            "type": "number"+          }+        },+        "required": [+          "type",+          "geometry"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "cylindrical"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          },+          "geometry": {+            "type": "object",+            "properties": {+              "entity": {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+              },+              "keyPoint": {+                "enum": [+                  "center",+                  "start",+                  "middle",+                  "end"+                ]+              }+            },+            "required": [+              "entity"+            ],+            "additionalProperties": false+          },+          "axis": {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          "rotationLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "rotationValue": {+            "type": "number"+          },+          "slideLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "slideValue": {+            "type": "number"+          }+        },+        "required": [+          "type",+          "geometry"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "pin_slot"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          },+          "geometry": {+            "type": "object",+            "properties": {+              "entity": {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+              },+              "keyPoint": {+                "enum": [+                  "center",+                  "start",+                  "middle",+                  "end"+                ]+              }+            },+            "required": [+              "entity"+            ],+            "additionalProperties": false+          },+          "axis": {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          "slideAxis": {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          "rotationLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "rotationValue": {+            "type": "number"+          },+          "slideLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "slideValue": {+            "type": "number"+          }+        },+        "required": [+          "type",+          "geometry"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "planar"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          },+          "geometry": {+            "type": "object",+            "properties": {+              "entity": {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+              },+              "keyPoint": {+                "enum": [+                  "center",+                  "start",+                  "middle",+                  "end"+                ]+              }+            },+            "required": [+              "entity"+            ],+            "additionalProperties": false+          },+          "axis": {+            "enum": [+              "x",+              "y",+              "z"+            ]+          },+          "rotationLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "rotationValue": {+            "type": "number"+          },+          "primarySlideLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "primarySlideValue": {+            "type": "number"+          },+          "secondarySlideLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "secondarySlideValue": {+            "type": "number"+          }+        },+        "required": [+          "type",+          "geometry"+        ],+        "additionalProperties": false+      },+      {+        "type": "object",+        "properties": {+          "op": {+            "type": "string"+          },+          "sessionId": {+            "type": "string"+          },+          "operationId": {+            "type": "string"+          },+          "target": {+            "type": "object"+          },+          "type": {+            "enum": [+              "ball"+            ]+          },+          "occurrenceOne": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "occurrenceTwo": {+            "type": "object",+            "required": [+              "documentId",+              "revision",+              "objectType"+            ],+            "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+          },+          "name": {+            "type": "string"+          },+          "suppressed": {+            "type": "boolean"+          },+          "geometry": {+            "type": "object",+            "properties": {+              "entity": {+                "type": "object",+                "required": [+                  "documentId",+                  "revision",+                  "objectType"+                ],+                "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+              },+              "keyPoint": {+                "enum": [+                  "center",+                  "start",+                  "middle",+                  "end"+                ]+              }+            },+            "required": [+              "entity"+            ],+            "additionalProperties": false+          },+          "pitchLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "pitchValue": {+            "type": "number"+          },+          "rollLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "rollValue": {+            "type": "number"+          },+          "yawLimits": {+            "type": "object",+            "properties": {+              "minimum": {+                "type": "number"+              },+              "maximum": {+                "type": "number"+              },+              "rest": {+                "type": "number"+              },+              "minimumEnabled": {+                "type": "boolean"+              },+              "maximumEnabled": {+                "type": "boolean"+              },+              "restEnabled": {+                "type": "boolean"+              }+            },+            "required": [],+            "additionalProperties": false,+            "minProperties": 1+          },+          "yawValue": {+            "type": "number"+          }+        },+        "required": [+          "type",+          "geometry"+        ],+        "additionalProperties": false+      }+    ]+  },+  "joint_edit": {+    "type": "object",+    "properties": {+      "joint": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "name": {+        "type": "string"+      },+      "suppressed": {+        "type": "boolean"+      },+      "rotationLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "slideLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "rotationValue": {+        "type": "number"+      },+      "slideValue": {+        "type": "number"+      },+      "primarySlideLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "primarySlideValue": {+        "type": "number"+      },+      "secondarySlideLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "secondarySlideValue": {+        "type": "number"+      },+      "pitchLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "pitchValue": {+        "type": "number"+      },+      "rollLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "rollValue": {+        "type": "number"+      },+      "yawLimits": {+        "type": "object",+        "properties": {+          "minimum": {+            "type": "number"+          },+          "maximum": {+            "type": "number"+          },+          "rest": {+            "type": "number"+          },+          "minimumEnabled": {+            "type": "boolean"+          },+          "maximumEnabled": {+            "type": "boolean"+          },+          "restEnabled": {+            "type": "boolean"+          }+        },+        "required": [],+        "additionalProperties": false,+        "minProperties": 1+      },+      "yawValue": {+        "type": "number"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "joint"+    ],+    "description": "Edit joint name/suppression, enabled limits, rest and drive values; wrong motion type or out-of-limit values fail with recovery."+  },+  "joint_delete": {+    "type": "object",+    "properties": {+      "joint": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "joint"+    ],+    "description": "Delete one selected Joint or AsBuiltJoint with recovery verification."+  },+  "interference": {+    "type": "object",+    "properties": {+      "entities": {+        "type": "array",+        "items": {+          "type": "object",+          "required": [+            "documentId",+            "revision",+            "objectType"+          ],+          "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+        },+        "minItems": 2,+        "maxItems": 256+      },+      "includeTouching": {+        "type": "boolean"+      },+      "volumeTolerance": {+        "type": "number",+        "minimum": 0+      }+    },+    "required": [+      "op",+      "target",+      "entities"+    ],+    "description": "Analyze root-context occurrences/body proxies; returns overlap volume mm3 or touching. Does not create interference bodies."+  },+  "bom": {+    "type": "object",+    "properties": {+      "explodePurchased": {+        "type": "boolean"+      }+    },+    "required": [+      "op",+      "target"+    ],+    "description": "Structured component-definition and instance BOM; quantities by actual identity, root bodies plus nested children; purchased metadata collapses subtrees unless exploded. Physical mass includes all unsuppressed bodies exactly once per instance."+  },+  "bom_export": {+    "type": "object",+    "properties": {+      "filename": {+        "type": "string"+      },+      "overwrite": {+        "type": "boolean"+      },+      "explodePurchased": {+        "type": "boolean"+      },+      "mode": {+        "enum": [+          "flat",+          "structured"+        ]+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "filename"+    ],+    "description": "Export flat grouped purchasing rows or structured parent/path/depth instance rows and supplier provenance to CSV with exclusive/atomic publication. This external effect is separate from model transactions."+  },+  "cad_import": {+    "type": "object",+    "properties": {+      "filename": {+        "type": "string"+      },+      "sha256": {+        "type": "string"+      },+      "name": {+        "type": "string"+      },+      "parent": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "transform": {+        "type": "object",+        "properties": {+          "position": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "axis": {+            "type": "array",+            "items": {+              "type": "number"+            },+            "minItems": 3,+            "maxItems": 3+          },+          "angle": {+            "type": "number"+          }+        },+        "required": [],+        "additionalProperties": false,+        "description": "Absolute rotation about the given nonzero axis through origin (deg), then translation (mm). Create/insert use parent component coordinates; updates use the selected occurrence assembly context."+      },+      "provenance": {+        "type": "object",+        "properties": {+          "supplier": {+            "type": "string"+          },+          "supplierPartNumber": {+            "type": "string"+          },+          "sourceUrl": {+            "type": "string"+          },+          "description": {+            "type": "string"+          }+        },+        "required": [+          "supplier",+          "supplierPartNumber",+          "sourceUrl"+        ],+        "additionalProperties": false+      },+      "asPurchased": {+        "type": "boolean"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "filename",+      "provenance"+    ],+    "description": "Import a pre-downloaded local STEP/SAT into a new wrapper component in Hybrid design. Validate optional expected SHA-256, record actual source/hash/supplier metadata, preserve camera, measure model recovery. Does not fetch URLs or create cloud documents. Returns a representative root-context occurrence and all affectedOccurrences when the parent definition is reused."+  },+  "mcmaster_discover": {+    "type": "object",+    "properties": {},+    "required": [+      "op"+    ],+    "description": "Discover Fusion native Insert McMaster-Carr command and requirements in the active design."+  },+  "mcmaster_open": {+    "type": "object",+    "properties": {},+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target"+    ],+    "description": "Invoke Fusion native McMaster UI in the targeted Hybrid design. Interactive external operation: completion/insert/cancel stays with Fusion; inspect afterward. Idempotency records launch only."+  },+  "material_list": {+    "type": "object",+    "properties": {+      "libraryId": {+        "type": "string"+      },+      "query": {+        "type": "string"+      },+      "limit": {+        "type": "integer",+        "minimum": 1,+        "maximum": 1000+      }+    },+    "required": [+      "op",+      "target"+    ],+    "description": "List loaded material libraries and matching materials by stable library/material IDs. Omit libraryId for document materials."+  },+  "material_assign": {+    "type": "object",+    "properties": {+      "entity": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "libraryId": {+        "type": "string"+      },+      "materialId": {+        "type": "string"+      }+    },+    "required": [+      "op",+      "sessionId",+      "operationId",+      "target",+      "entity",+      "materialId"+    ],+    "description": "Assign a loaded library or document material to an exact native Component/BRepBody; verify material ID readback with model transaction recovery. Query assembly_properties for resulting mass."+  },+  "rigid_group_create": {+    "type": "object",+    "properties": {+      "occurrences": {+        "type": "array",+        "items": {+          "type": "object",+          "required": [+            "documentId",+            "revision",+            "objectType"+          ],+          "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+        },+        "minItems": 2,+        "maxItems": 256+      },+      "includeChildren": {+        "type": "boolean"+      },+      "name": {+        "type": "string"+      }+    },+    "required": [+      "op",+      "target",+      "sessionId",+      "operationId",+      "occurrences"+    ],+    "description": "Create a native rigid group from exact occurrence instances; includeChildren defaults true."+  },+  "rigid_group_edit": {+    "type": "object",+    "properties": {+      "group": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      },+      "name": {+        "type": "string"+      },+      "suppressed": {+        "type": "boolean"+      }+    },+    "required": [+      "op",+      "target",+      "sessionId",+      "operationId",+      "group"+    ],+    "description": "Rename or suppress an exact rigid group with transaction recovery."+  },+  "rigid_group_delete": {+    "type": "object",+    "properties": {+      "group": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      }+    },+    "required": [+      "op",+      "target",+      "sessionId",+      "operationId",+      "group"+    ],+    "description": "Delete an exact rigid group with transaction recovery."+  },+  "assembly_properties": {+    "type": "object",+    "properties": {+      "entity": {+        "type": "object",+        "required": [+          "documentId",+          "revision",+          "objectType"+        ],+        "description": "Guarded reference from inspect in this document/revision; occurrence references retain instance context."+      }+    },+    "required": [+      "op",+      "target"+    ],+    "description": "High-accuracy physical properties of whole root assembly (default) or an exact Component/Occurrence/BRepBody. Returns mass kg, volume mm3, area mm2, center of mass mm, mean density kg/mm3 and definition/instance coordinate scope."+  }+}