SOLIDWORKS Bridge

@@ -0,0 +1,292 @@+# This file is automatically @generated by Cargo.+# It is not intended for manual editing.+version = 3++[[package]]+name = "ascii"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"++[[package]]+name = "cfg-if"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"++[[package]]+name = "chunked_transfer"+version = "1.5.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"++[[package]]+name = "httpdate"+version = "1.0.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"++[[package]]+name = "itoa"+version = "1.0.18"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"++[[package]]+name = "log"+version = "0.4.34"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"++[[package]]+name = "memchr"+version = "2.8.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"++[[package]]+name = "proc-macro2"+version = "1.0.107"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "quote"+version = "1.0.47"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"+dependencies = [+ "proc-macro2",+]++[[package]]+name = "serde"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"+dependencies = [+ "serde_core",+ "serde_derive",+]++[[package]]+name = "serde_core"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"+dependencies = [+ "serde_derive",+]++[[package]]+name = "serde_derive"+version = "1.0.229"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 3.0.4",+]++[[package]]+name = "serde_json"+version = "1.0.151"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"+dependencies = [+ "itoa",+ "memchr",+ "serde",+ "serde_core",+ "zmij",+]++[[package]]+name = "swx-bridge"+version = "0.3.3"+dependencies = [+ "serde",+ "serde_json",+ "tiny_http",+ "windows",+ "winreg",+]++[[package]]+name = "syn"+version = "2.0.119"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "syn"+version = "3.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "tiny_http"+version = "0.12.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "389915df6413a2e74fb181895f933386023c71110878cd0825588928e64cdc82"+dependencies = [+ "ascii",+ "chunked_transfer",+ "httpdate",+ "log",+]++[[package]]+name = "unicode-ident"+version = "1.0.24"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"++[[package]]+name = "windows"+version = "0.62.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"+dependencies = [+ "windows-collections",+ "windows-core",+ "windows-future",+ "windows-numerics",+]++[[package]]+name = "windows-collections"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"+dependencies = [+ "windows-core",+]++[[package]]+name = "windows-core"+version = "0.62.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"+dependencies = [+ "windows-implement",+ "windows-interface",+ "windows-link",+ "windows-result",+ "windows-strings",+]++[[package]]+name = "windows-future"+version = "0.3.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"+dependencies = [+ "windows-core",+ "windows-link",+ "windows-threading",+]++[[package]]+name = "windows-implement"+version = "0.60.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "windows-interface"+version = "0.59.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"+dependencies = [+ "proc-macro2",+ "quote",+ "syn 2.0.119",+]++[[package]]+name = "windows-link"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"++[[package]]+name = "windows-numerics"+version = "0.3.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"+dependencies = [+ "windows-core",+ "windows-link",+]++[[package]]+name = "windows-result"+version = "0.4.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"+dependencies = [+ "windows-link",+]++[[package]]+name = "windows-strings"+version = "0.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"+dependencies = [+ "windows-link",+]++[[package]]+name = "windows-sys"+version = "0.61.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"+dependencies = [+ "windows-link",+]++[[package]]+name = "windows-threading"+version = "0.2.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"+dependencies = [+ "windows-link",+]++[[package]]+name = "winreg"+version = "0.56.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "7d6f32a0ff4a9f6f01231eb2059cc85479330739333e0e58cadf03b6af2cca10"+dependencies = [+ "cfg-if",+ "windows-sys",+]++[[package]]+name = "zmij"+version = "1.0.23"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

@@ -0,0 +1,193 @@+{+  "manifest_version": 1,+  "name": "solidworks",+  "displayName": "SOLIDWORKS",+  "version": "0.3.3",+  "description": "Bridge for SOLIDWORKS desktop CAD \u2014 create and open documents, a modeling DSL, file management (find/open/save/export/Pack and Go), custom properties, BOM generation, design analysis (mass properties, bodies, parameters, interference, rebuild health) and background window/dialog etiquette, over the SOLIDWORKS COM API. Single native binary: no interpreter, no PowerShell, ~10ms cold start.",+  "author": "Adom Inc.",+  "license": "MIT",+  "homepage": "https://wiki.adom.inc/adom/adom-bridge",+  "docs": "https://wiki.adom.inc/adom/solidworks-bridge",+  "spawn": {+    "kind": "exe",+    "entrypoint": "swx-bridge.exe",+    "port": 0,+    "healthEndpoint": "/status",+    "stopMethod": "kill",+    "killImageName": "swx-bridge.exe"+  },+  "verbPrefixes": [+    "swx_"+  ],+  "verbs": [+    "swx_bom",+    "swx_close_doc",+    "swx_com_eval",+    "swx_describe",+    "swx_docs",+    "swx_export",+    "swx_find_files",+    "swx_interference",+    "swx_mass_properties",+    "swx_open",+    "swx_pack_and_go",+    "swx_progress",+    "swx_props_get",+    "swx_props_set",+    "swx_readiness",+    "swx_rebuild_check",+    "swx_save",+    "swx_screenshot",+    "swx_start",+    "swx_state",+    "swx_status",+    "swx_stop",+    "swx_uninstall",+    "swx_new_document",+    "swx_import",+    "swx_save_as",+    "swx_get_app_state",+    "swx_document_info",+    "swx_activate_document",+    "swx_close_all_documents",+    "swx_reset_workspace",+    "swx_kill",+    "swx_window_info",+    "swx_dismiss_blocking_dialogs",+    "swx_close_window",+    "swx_check_recovery",+    "swx_action_ledger",+    "swx_verb_times",+    "swx_set_driving_badge",+    "swx_design_info",+    "swx_get_parameters",+    "swx_set_parameter",+    "swx_inspect_bodies",+    "swx_run_macro",+    "swx_run_script",+    "swx_add_component",+    "swx_get_preferences",+    "swx_set_preference",+    "swx_cloud_status",+    "swx_show_part",+    "swx_show_assembly",+    "swx_show_drawing",+    "swx_export_step",+    "swx_export_iges",+    "swx_export_stl",+    "swx_export_3mf",+    "swx_export_glb",+    "swx_export_sat",+    "swx_export_parasolid",+    "swx_export_pdf",+    "swx_export_dxf",+    "swx_export_dwg"+  ],+  "statusVerb": "swx_status",+  "risk": "exec",+  "uninstall": "swx_uninstall",+  "updateManifestUrl": "https://wiki.adom.inc/api/v1/pages/solidworks-bridge/files/adom-bridge-solidworks-manifest.json",+  "timeouts": {+    "default": 120,+    "verbs": {+      "start": 300,+      "open": 300,+      "export": 300,+      "pack_and_go": 600,+      "bom": 300,+      "interference": 600,+      "rebuild_check": 300,+      "find_files": 180,+      "new_document": 180,+      "import": 420,+      "save_as": 420,+      "run_script": 420,+      "inspect_bodies": 180,+      "design_info": 180,+      "get_parameters": 240,+      "set_parameter": 420,+      "activate_document": 180,+      "close_all_documents": 240,+      "reset_workspace": 420,+      "show_part": 600,+      "show_assembly": 600,+      "show_drawing": 600,+      "state": 180,+      "export_step": 300,+      "export_iges": 300,+      "export_stl": 300,+      "export_3mf": 300,+      "export_glb": 300,+      "export_sat": 300,+      "export_parasolid": 300,+      "export_pdf": 300,+      "export_dxf": 300,+      "export_dwg": 300,+      "kill": 240,+      "window_info": 120,+      "dismiss_blocking_dialogs": 180,+      "close_window": 120,+      "check_recovery": 180,+      "cloud_status": 90,+      "get_preferences": 90,+      "set_preference": 90,+      "get_app_state": 90,+      "document_info": 120,+      "action_ledger": 20,+      "verb_times": 20,+      "set_driving_badge": 120,+      "close_doc": 180+    }+  },+  "detect": {+    "hostApp": "SOLIDWORKS",+    "appPathsExe": "SLDWORKS.exe",+    "paths": {+      "windows": [+        "%ProgramFiles%\\SOLIDWORKS Corp\\SOLIDWORKS\\SLDWORKS.exe",+        "%ProgramFiles%\\SOLIDWORKS Corp\\*\\SOLIDWORKS\\SLDWORKS.exe",+        "%ProgramFiles%\\Dassault Systemes\\SOLIDWORKS\\SLDWORKS.exe",+        "%ProgramFiles%\\Dassault Systemes\\SOLIDWORKS 3DEXPERIENCE*\\SOLIDWORKS\\SLDWORKS.exe",+        "%ProgramFiles%\\Dassault Systemes\\*\\SOLIDWORKS\\SLDWORKS.exe"+      ]+    },+    "hostAppOptionalVerbs": [+      "readiness",+      "describe",+      "status",+      "find_files",+      "progress",+      "uninstall",+      "state",+      "action_ledger",+      "verb_times"+    ]+  },+  "dependencies": {+    "solidworks": ">=2024"+  },+  "category": "MCAD",+  "tags": [+    "solidworks",+    "mcad",+    "cad",+    "bom",+    "step",+    "mass-properties",+    "modeling",+    "fusion-parity"+  ],+  "platforms": {+    "windows": {+      "supported": true+    },+    "macos": {+      "supported": false,+      "reason": "SOLIDWORKS desktop is Windows-only; the bridge drives its COM API."+    },+    "linux": {+      "supported": false,+      "reason": "SOLIDWORKS desktop is Windows-only; the bridge drives its COM API."+    }+  }+}

@@ -0,0 +1,236 @@+# Where swx stands in the ecosystem++**swx v0.3.0** measured against the Adom **Fusion 360 bridge v1.9.341** (the gold standard we mirror)+and against every public SOLIDWORKS MCP server we could find · written 2026-09-03++## Executive summary++- **swx is the only SOLIDWORKS implementation here with a published live-run record.** Three runs+  against a real *SOLIDWORKS Design Professional for Makers 2026* install (22-aborted, 120/9, then+  **125 passed / 5 failed**), 19 verbs proven end to end, with measured p90 timings. One competitor+  (SolidPilot) also claims live validation and is credible about it; the other three are explicit that+  most or all of their tools are unvalidated, mock, or hobby-grade.+- **On raw modeling breadth we are behind SolidPilot** — its sketch/feature/assembly/drawing surface is+  deeper than ours and it is the most mature project in this space by a wide margin.+- **On safety we are ahead of all five, and alone.** No other project has a write gate. swx writes are+  deny-by-default at a single choke point, enforced *independently* at two layers, hardened over eight+  adversarial review rounds, and the posture held through every live run — three times the bridge failed+  CLOSED rather than touch the wrong document.+- **Our other unique strengths:** BOM-first and configuration-aware design (BOM aggregates per+  *(file, configuration)* pair — nobody else models this); native GLB with no optimisation service;+  an action ledger plus measured per-verb timings; census-not-dismiss dialog etiquette with+  `neverAutoAnswer` classes; and real host-ecosystem integration (Adom Bridge verbs, the user's+  Activity Log, a shipped skill) where every competitor is a bare MCP server for Claude Desktop.+- **Our real gaps, stated plainly:** no cloud/3DEXPERIENCE document access (21 Fusion verbs; a separate+  OAuth project of roughly the size of the Fusion bridge's APS work); assemblies-with-components,+  drawings and 2D exports are mock-only because the Makers edition would not let an assembly be+  populated; and there is no in-process scripting host — a typed JSON DSL stands in.+- **Launch was our headline "cannot", and that changed today.** `CoCreateInstance` returns+  `CO_E_SERVER_EXEC_FAILURE` on the Connected editions, but a sanctioned launch path via the+  3DEXPERIENCE shortcut chain (`CATSTART.exe` → `SWXDesktopLauncher`) was discovered 2026-09-03.+  Implementation is in progress and **not yet live-proven**.+- **Scripting has a second route now too:** SOLIDWORKS `RunMacro2` for `.swp` VBA macros, VSTA, and C#+  add-ins are **under investigation** — with the caveat that the Makers edition restricts third-party+  add-ins while still running macros. Four of the five competitors already lean on VBA; we do not yet.+- **Licensing is simple and decision-relevant:** exactly **one** copyleft player — SolidPilot is+  **AGPL-3.0** with a paid commercial option — and everything else, ours included, is **MIT**. We can+  read and learn from SolidPilot; we must not vendor its code.+- **Electronics is not a gap.** 51 of the Fusion bridge's 132 verbs are Fusion Electronics, EAGLE+  libraries, or Autodesk-specific plumbing. SOLIDWORKS has no concept to bridge to, and no competitor+  attempts it either.++## How to read the cells++| Mark | Means |+|---|---|+| **✓ live** | Executed against a real, licensed CAD install and observed to do what it claims. |+| **✓** | Built and shipped, or claimed by the project's own README. Evidence level is stated per row. |+| **⚠ mock** | Built and mock-tested only; never executed live in any form. |+| **partial** | Some of the capability, materially incomplete. |+| **✗** | Absent. |+| **n/a** | No concept exists to bridge to in that product. |+| **WIP** | Route identified, implementation in progress, not yet proven. |+| **?** | Could not be determined from the repository. |++Evidence discipline: for **Fusion bridge** and **swx**, cells come from source we hold — the Fusion+bridge's own `describe.py` catalog (133 entries, 132 real verbs) and `docs/FUSION-PARITY-REPORT.md`.+For every competitor column, cells are **read-from-README** unless the row note says otherwise. Nobody+in the competitor set was installed or run. Licences and star counts were verified against the GitHub+API on 2026-09-03, not read off a badge.++## The master table++35 capability rows × 7 implementations. Verb counts: Fusion bridge **132**, swx **60**,+SolidPilot ~**46 tools**, vespo92 ~**30+**, bartels **122**, Schildkraut **~16 tools + 100+ VBA+templates**, alisamsam **22**.++| # | Capability | Fusion bridge | **swx v0.3** | SolidPilot **(AGPL-3.0!)** | vespo92 (MIT) | bartels (MIT) | Schildkraut (MIT) | alisamsam (MIT) |+|---:|---|---|---|---|---|---|---|---|+| 1 | Session lifecycle — attach, stop, kill | ✓ | **✓ live** attach · ⚠ mock stop/kill | ✓ attach | ? | ✓ attach | ? | ✓ attach |+| 2 | Launch the CAD application (and install it) | ✓ launch + silent install | **WIP** — refused by SOLIDWORKS; 3DEXPERIENCE chain found 2026-09-03 | ✓ claims COM launch | ✗ | ✗ needs SW already open | ? | ✗ needs running instance |+| 3 | Requires an in-app add-in | yes (3 verbs to manage it) | **no — out-of-process COM** | no (C# COM server) | no | no | no | no |+| 4 | Open a local file · disk discovery | ✓ open · ✗ discovery (cloud-native) | **✓ live** open · **✓** `find_files` | ✓ open · ✗ | ✓ (untested) | ✓ | ✓ | ✓ open · ✗ |+| 5 | Create a new document | ✗ (docs arrive from cloud/import) | **✓ live** | ✓ part + assembly | ✓ (untested) | ✓ | ✓ | ✓ part + assembly |+| 6 | Save / Save As **with overwrite protection** | ✓ cloud save · ✗ overwrite guard | **✓ live** save_as · **✓ overwrite guard (unique)** | ✓ save · ✗ guard | ✓ (untested) · ✗ guard | ✓ · ✗ guard | ✓ · ✗ guard | ✓ · ✗ guard |+| 7 | Cloud document store — search, list, open, up/download | ✓ 21 verbs (APS Data Management) | **✗ lacking** — `swx_cloud_status` returns the honest probe | ✗ | ✗ | ✗ | ✗ | ✗ |+| 8 | Cloud / vendor sign-in + OAuth | ✓ 9 verbs (incl. 2FA, web sign-in) | ✗ lacking | ✗ | ✗ | ✗ | ✗ | ✗ |+| 9 | Parametric modeling — sketch → feature | ✓ (Python script in-process) | **✓ live** typed DSL (50×30×20 solid, p90 10.2s) | **✓ live** — deepest surface here | partial (basic ops only) | ✓ claimed | ✓ via VBA templates | ✓ basic |+| 10 | In-process scripting host (arbitrary code) | ✓ Python `eval` inside Fusion | **adapted** — typed JSON DSL, validated pre-COM; `swx_com_eval` escape hatch | ✗ by design (deterministic compiler) | ✗ | ✗ | ✗ | ✓ `execute_python` in SW context |+| 11 | Macros / VBA — generate, record, execute | n/a (Fusion has no VBA) | **WIP** — `RunMacro2` / VSTA / C# add-in under investigation | ✗ explicitly unsupported | partial (gen works, exec untested) | ✓ | **✓ strongest** (record/export/execute + 100+ templates) | ✗ |+| 12 | Assemblies — insert components, mates | ✓ via script | ⚠ mock — `AddComponent5` returned Nothing on this edition | **✓ live** insert + mate + diff | ✗ | ✓ claimed | ✓ via VBA | partial (create doc only) |+| 13 | Drawings — create, views, dimensions | ✗ no drawing verbs | partial — creation **✓ live**, views/dims not built | **✓ live** 9 tools; 9 real drawings reconstructed | ✓ (untested) | ✓ claimed | ✓ via VBA | ✗ |+| 14 | Import neutral CAD (STEP etc.) | ✓ | **✓ live** (p90 7.8s) | ✓ via 3D Interconnect | ? | ? | ? | ✗ |+| 15 | Export 3D — STEP/IGES/STL/3MF/SAT/Parasolid | ✓ 8 formats | **✓ live** 6 proven; 17 formats in table; OBJ refused by SOLIDWORKS | ✓ STEP/IGES/STL | ✓ (untested) | ✓ | ✓ | ✗ none |+| 16 | Export **native GLB** (web 3D) | ✓ but needs an optimisation service | **✓ live, direct — unique** | ✗ | ✗ | ✗ | ✗ | ✗ |+| 17 | Export 2D / document — PDF, DXF, DWG | ✓ DXF/DWG · ✗ PDF | ⚠ mock all three (refused for a part; untested from a drawing) | ✓ PDF/DWG/DXF | ✓ (untested) | ✓ | ✓ PDF | ✗ |+| 18 | BOM | ✓ assembly + electronics BOM | ⚠ mock — **but per *(file, configuration)*, the richest design here** | ✗ on the roadmap | ✗ | ✗ | ✓ table insertion | ✗ |+| 19 | Mass / physical properties | ✓ | **✓ live** (aluminium, 81 g agreeing) | **✓ live** (verified ≤1%) | ✓ (untested) | ✓ claimed | ✓ claimed | ✗ |+| 20 | Design-health — interference detection, rebuild census | ✗ neither | partial — interference ⚠ mock (object confirmed live), `rebuild_check` built | partial (`analyze_model`/`verify_state`; no interference) | ✓ (untested) | ✗ explicitly not yet | ✓ via VBA | ✗ |+| 21 | Parameters / dimensions — read **and drive** | ✓ read | **✓ live** — drove a dimension to 25 mm, model moved | ✓ `modify_dimension` | ✓ (untested) | ✓ claimed | ✓ equations | ✗ |+| 22 | Custom properties (file and per-configuration) | partial (buried in the attribute model) | **✓** `props_get`/`props_set` | ✗ | ✗ | ? | ✓ | ✗ |+| 23 | Configurations / design tables | ✗ no equivalent concept | ✓ configuration-aware (BOM, properties) · ✗ design tables | ✗ | partial (`vba_configurations`, untested) | partial | **✓ strongest** (design tables + SQL) | ✗ |+| 24 | Pack and Go — collect a design + all references | ✗ | ✓ built (gated), ⚠ mock | ✗ | ✗ | ✗ | partial (batch ops) | ✗ |+| 25 | PDM / vault integration | n/a | ✗ not built | ✗ | ✗ | ✗ | **✓ only one** (5 tools) | ✗ |+| 26 | Application preferences — read and write | ✓ incl. driving the settings modal | **✓ live** (written, then read back) · modal driving declined by design | ✗ | ✗ | ✗ | ✗ | partial (`set_units`) |+| 27 | Screenshots + window management | ✓ | ⚠ mock (delegated to ab; SKIPPED in live runs) | ✗ | ✗ | ✗ | ✗ | ✗ |+| 28 | Blocking-dialog handling | ✓ dismisses them | **adapted — censuses by default**; `neverAutoAnswer` classes never closed | ✗ | ✗ | ✗ | ✗ | ✗ |+| 29 | Electronics — schematic, PCB, Gerbers, CPL, design rules | ✓ 15 verbs | n/a | n/a | n/a | n/a | n/a | n/a |+| 30 | Component libraries / 3D packages (EAGLE `.lbr`) | ✓ 23 verbs | n/a | ✗ | ✗ | ✗ | ✗ | ✗ |+| 31 | Vendor MCP-server proxy | ✓ 6 verbs (Autodesk ships one) | n/a — Dassault ships none | n/a (is itself an MCP server) | n/a | n/a | n/a | n/a |+| 32 | Bridge infrastructure — self-describe, shipped docs, guided demo, uninstall | ✓ all four | ✓ describe/docs/uninstall · ✗ demo (deferred v0.4) | partial (13 MCP resources) | ✗ | partial (docs audit) | partial (resource registry) | ✗ |+| 33 | **Action ledger + measured per-verb timings** | ✓ ledger, verb times, live feed, alerts | **✓ ledger + timings recorded live** | ✗ (dev log only) | ✗ | ✗ logging only | partial ("enhanced logging") | ✗ |+| 34 | **Deny-by-default write gate** | ✗ no gate, no confirm/reason in its catalog | **✓ live — unique. Two independent layers, 8 adversarial rounds, held in all 3 live runs** | ✗ | ✗ | partial ("adapter safety wrappers") | partial (macro exec needs permission) | ✗ |+| 35 | Host-ecosystem integration (Adom Bridge, Activity Log, skill) | ✓ native | **✓ native** | ✗ MCP clients only | ✗ | ✗ | ✗ | ✗ |++*(35 numbered rows; rows 29–31 are the N/A block that accounts for most of the Fusion verb-count gap.)*++## Per-competitor notes++### SolidPilot — eyfel/mcp-server-solidworks · **AGPL-3.0** + paid commercial · 265★ · C# + Python++The one to take seriously. Four-layer architecture: an AI planner emits a CAD-neutral **Feature Graph+IR**, a deterministic Python compiler lowers it to ordered tool calls, and a **single C# .NET 4.8+execution layer on one STA thread is the only code that touches COM**. ~46 tools, 13 MCP resources.+Its README makes verifiable-shaped claims — production parts round-tripped `analyze_model` → IR →+`rebuild_from_ir` → `compare_parts` to a `verified` match on exact topology and mass properties, nine+real manufacturing drawings reconstructed to ≤0.02% weight match. Deeper than us on modeling,+assemblies, sheet metal and drawings. Has **no** BOM (on the roadmap), no configurations, no custom+properties, no preferences, no screenshots, no macros (deliberately — the compiler replaces scripting),+no write gate, and no ecosystem beyond Claude Desktop. Its `ensure_ready` claims to launch SOLIDWORKS+via COM, which is plausible on a classic desktop install and would fail exactly as ours does on+Connected/Makers. **Evidence: README only. Not installed, not run.**++### vespo92/SolidworksMCP-TS — **MIT** · 222★ · TypeScript + `winax`++Second-most-starred and the most candid: labelled **"Alpha / Experimental"**, with the README stating+that *"most tools have not been validated against a live SolidWorks instance"* and that no real+integration tests exist. Its own coverage table grades Modeling "Partially tested" and Drawing, Export,+Analysis and Macro all **"Untested"**. Broad tool surface on paper (modeling, sketch, drawing, export,+analysis with `check_interference` and `get_mass_properties`, VBA generation, macro recording); no+assemblies, no BOM. Last pushed 2026-05. Useful as a naming/API reference, not as evidence that+anything works.++### andrewbartels1/SolidworksMCP-python — **MIT** · 67★ · Python++**122 tools** per today's README (the figure was 109 earlier — it is moving; pushed 2026-09-02), across+modeling, sketching, drawing, analysis, export, automation, templates and macros. Self-described+**"hobby/research product"** and "under active construction", and it ships an explicit mock warning:+*"Mock adapter output is simulated and should not be treated as engineering truth."* Runs in mock mode+unless started with `--real`, and `--real` **requires SOLIDWORKS to already be open** — the same+attach-only constraint we have, arrived at without comment. Explicitly does *not* do checkpoint-level+interference validation. Highest tool count in the field, lowest evidence-per-tool.++### Adam-Schildkraut/solidworks-mcp — **MIT** · 1★ · TypeScript · last push 2025-08++Small but oddly complementary: it is the **only** project with **PDM tools** (configure, check-in,+check-out, workflow, folder structure), the only one with **SQL-driven design tables** for+configurations, and it leans hardest on VBA — macro record/stop/export/execute plus a claimed **100++VBA generation templates** covering part features, assembly mates and interference, drawing views and+tables, custom properties and batch/PDM operations. No validation statement of any kind, one star,+and its README's support links point at a different org (`vinnieespo/solidworks-mcp-server`), so treat+it as derived work of uncertain provenance. **The template library is the interesting artefact here,+not the server.**++### alisamsam/Solidworks-MCP — **MIT (verified)** · 108★ · Python · 22 tools++Task brief listed its licence as unknown; the GitHub API confirms **MIT**, 108★, last pushed 2026-03.+Deliberately minimal and honest about it: connect to a *running* instance, part/assembly documents,+six sketch primitives, extrude/cut/fillet/chamfer, list features, set units — and `execute_python`,+which makes it the only project besides ours to offer a scripting escape hatch into a live SOLIDWORKS+session. **It has no export tools at all**, no drawings, no assembly mates, no BOM, no properties. It+is a clean starter kit, not a competitor for real work.++## Licensing++**This is the section with a decision in it.**++**SolidPilot (eyfel/mcp-server-solidworks) — AGPL-3.0, dual-licensed commercially.** Verified from the+repository's own licence metadata, not a badge. AGPL-3.0 is the strongest common copyleft: it extends+GPL's obligations to network use, so **anything we distribute that links or incorporates AGPL code must+itself be released under AGPL, source included** — and under the network clause, even offering it as a+hosted service to users triggers the same obligation. For a bridge that ships inside Adom Bridge to+customers, that is not a licence we can absorb. The author offers a **paid commercial licence** as the+escape hatch. **Conclusion: read it, learn from its architecture — the Feature Graph IR and the+single-STA-thread C# COM boundary are both good ideas — and copy neither its code nor its files.** Any+IR-shaped work of ours must be independently written. If we ever want its code proper, that is a+procurement conversation, not an engineering one.++**vespo92/SolidworksMCP-TS — MIT.** Verified. Permissive; we could vendor or adapt code with attribution.+Given the project's own "most tools not validated" disclaimer there is little worth vendoring, but its+tool naming is a fair reference.++**andrewbartels1/SolidworksMCP-python — MIT.** Verified. Permissive. Same caveat: mock-simulated output+by default, so its value is as a map of the COM surface rather than as working code.++**Adam-Schildkraut/solidworks-mcp — MIT.** Verified. Permissive, and the **VBA template library is the+one asset in the whole survey that MIT actually makes attractive to us** — if the macros route+(`RunMacro2`) proves out, 100+ MIT-licensed VBA templates are a legitimate head start. Provenance is+murky enough that we should check the templates' own headers before reusing them.++**alisamsam/Solidworks-MCP — MIT.** Verified (previously unknown to us).++**swx — MIT** (`bridge.json`, `LICENSE`). We are on the permissive side of the field with everyone+except SolidPilot. Exactly one copyleft player; everything else MIT.++## Additional items we can pull off++Capabilities **nobody** in this field has, which swx could add at low cost, roughly in order of+value-per-effort:++1. **Drawing-sheet outputs — PDF + BOM tables from a `.slddrw`.** Our DXF/DWG/PDF exports are already+   built and refused for a part, which is the expected behaviour; the drawing is their real story and+   it is untested. SolidPilot builds drawings but does not ship a BOM; Schildkraut inserts BOM tables+   but has no evidence. **A live-proven drawing → PDF-with-BOM path would be unique in this field.**+2. **Sanctioned launch via the 3DEXPERIENCE chain** (`CATSTART.exe` → `SWXDesktopLauncher`, found+   2026-09-03). Closes our loudest documented "cannot", and no competitor has solved launch on a+   Connected edition — bartels and alisamsam simply require the app to be open already.+3. **A macros bridge** (`RunMacro2` for `.swp`, then VSTA / C# add-ins). Buys back most of the+   in-process-scripting gap and would let us reuse an MIT template corpus. Caveat to settle first: the+   Makers edition restricts third-party add-ins but does run macros — which is precisely why macros,+   not add-ins, are the first move.+4. **Configurations as a first-class surface.** We are already configuration-aware in BOM and+   properties; enumerating, activating and diffing configurations is a small step, and Fusion has no+   equivalent concept at all. Design tables (Schildkraut's SQL trick) are the stretch goal.+5. **Pack and Go, proven live.** Built and gated already; it needs an assembly with references to+   exercise. Nobody else has it.+6. **The action ledger and measured verb timings as a product feature, not plumbing.** We have p90s from+   real hardware (`run_script` 10.2s, `new_document` 9.2s, `import` 7.8s, `save_as` 2.7s, all far inside+   budget). No competitor can tell a user what an operation will cost.+7. **Wiki / molecule integration.** Native GLB export already works live; the pipeline from a+   SOLIDWORKS part to a published molecule is ours to connect and is not even conceivable for a bare+   MCP server.+8. **Ship the deny-by-default posture as the marketed differentiator.** It is the single strongest+   claim we have and it is *evidenced*: eight adversarial rounds, two independently-enforcing layers,+   and three live runs in which the bridge refused to touch the user's own open document — including+   one abort where it removed every file it had written. Every competitor in this survey will, on+   request, write to a path the user owns with no confirmation and no record.+9. **Per-component mass properties** — small, and blocked only on being able to populate an assembly.++## What is still unproven, and where++Nothing above changes the standing recommendation: **run `tools/live-smoke.py`** once SOLIDWORKS is+back up, started from the 3DEXPERIENCE Platform. It is what converts the ⚠ mock cells in column B into+✓ live — or finds the next bug, which is what happened all three previous times. The assembly verbs+(`swx_bom`, `swx_interference`, per-component mass properties) need a real multi-component assembly or a+classic desktop install; the 2D exports need a real `.slddrw`. And no competitor cell in this table is+better than read-from-README, because none of them was installed or run.

@@ -0,0 +1,1223 @@+# Fusion-parity brief — solidworks-bridge v0.3 (swx)++Drew's ask (2026-09-02): "Build the functionality to open an existing file or create a+new one. Learn EVERY capability of the Fusion bridge (wiki.adom.inc/adom/fusion-bridge),+build a SW alternative for all of them, and tell me what is lacking when done."++Quality bar is unchanged: kicad/pup/native-browser. Every response carries a `_hint`;+stable `errorCode`s; background etiquette; progress on slow verbs; a suite that cannot lie.+The v0.2 codebase (Rust, single exe, killable COM child) is the base — extend, don't rewrite.++## What is PROVEN LIVE on Drew's machine (2026-09-02) — build on these facts++- SOLIDWORKS 3DEXPERIENCE R2026x ("SOLIDWORKS Design Professional for Makers 2026 SP3.0",+  sldworks.exe v34.3.0.0150) at+  `C:\Program Files\Dassault Systemes\SOLIDWORKS 3DEXPERIENCE R2026x\SOLIDWORKS\sldworks.exe`.+- **Out-of-process COM attach WORKS** (GetActiveObject → `swx_com_eval $sw.RevisionNumber()` →+  "34.3.0"). PowerShell's late-binding adapter FAILS the same call (TYPE_E_ELEMENTNOTFOUND); our+  raw GetIDsOfNames+Invoke path works. Never reintroduce a PowerShell layer.+- **Creating documents:** `$sw.NewPart()` HANGS (>110s, killed by the watchdog; no dialog left).+  The working recipe is `NewDocument(template, 0, 0, 0)` with the stock templates:+  `$sw.GetDocumentTemplate(1,"",0,0,0)` → `C:\ProgramData\SolidWorks\SOLIDWORKS 2026\templates\Part.prtdot`+  `$sw.GetUserPreferenceStringValue(9)` → `...\templates\Assembly.asmdot` (swDefaultAssemblyTemplate=9;+  swDefaultPartTemplate=8 returned "" — so resolve part templates via GetDocumentTemplate, and+  drawing templates via GetDocumentTemplate(3,...)). Live: NewDocument(Part.prtdot) → "Part1";+  swx_docs sees it; swx_mass_properties runs (mass 0 on an empty part); swx_close_doc {save:false}+  discards it; swx_docs is empty again.+- No local .sldprt/.sldasm exist on the box (Connected keeps documents in the 3DEXPERIENCE cloud),+  so every document-verb test must CREATE its own scratch document, exercise it, and close it+  WITHOUT saving. Files saved to disk for tests go under the bridge scratch dir and are removed.+- 13/13 no-document verbs pass live; crash recovery (kill+respawn of the COM child) proven live.+- Two detection bugs were found live and are fixed (partial-component glob; case-insensitive+  tasklist match). Lesson: mock-only green is not green — validate every new verb LIVE.++## Dev loop that works (use it; do not invent another)++```+cargo build --release --target x86_64-pc-windows-gnu     # exe ~850K+# the container already serves target/x86_64-pc-windows-gnu/release/ on :8877 via python http.server+#   -> https://drew2-gallia-7g17dw3vho0f.adom.cloud/proxy/8877/swx-bridge.exe (anonymous OK)+# on the desktop (ALWAYS --target adom_drew2; 2 bridge clients are on the relay):+adom-bridge --target adom_drew2 --ai-thread "SolidWorks Bridge" shell_execute '{"command":"powershell -NoProfile -Command \"Invoke-WebRequest -Uri https://drew2-gallia-7g17dw3vho0f.adom.cloud/proxy/8877/swx-bridge.exe -OutFile \\\"$env:LOCALAPPDATA\\Adom Bridge\\bridges-cache\\solidworks-dev\\swx-bridge.exe\\\" -UseBasicParsing\"","timeoutSeconds":180,"reason":"..."}'+adom-bridge --target adom_drew2 --ai-thread "SolidWorks Bridge" process_kill '{"pid":<old>,"reason":"..."}'   # old dev bridge (pid was 95412)+adom-bridge --target adom_drew2 --ai-thread "SolidWorks Bridge" launch_process '{"path":"%LOCALAPPDATA%\\Adom Bridge\\bridges-cache\\solidworks-dev\\swx-bridge.exe","args":["--port","24695"],"window":"hidden","env":{"ADOM_BIND_HOST":"127.0.0.1"},"reason":"..."}'+python3 tools/swx-live.py <verb> '<json>' [timeoutSec]     # calls POST /command on the desktop via curl.exe+```+Every gated ab verb (shell_execute, launch_process, process_kill, write_file) needs a `reason`+written for the human. `tools/swx-live.py` already does this.++## HARD RULES while driving Drew's live SOLIDWORKS++- NEVER call `swx_stop` / ExitApp / process_kill on sldworks.exe. Drew is using it.+- NEVER close or save a document you did not create. Scratch docs you create are closed with+  save:false. Never leave a scratch doc open at the end of a test.+- NEVER foreground SOLIDWORKS; never send keys/clicks to it. COM only.+- A verb that can hang gets a bounded timeout; the COM child watchdog is the safety net, not+  the plan. Test any NEW COM call first via `swx_com_eval` with a short timeout.+- Keep the 23 existing verbs' shapes backward compatible. Bump version to 0.3.0 (Cargo.toml ++  BRIDGE_VERSION + bridge.json + package.json in lockstep — lib.rs asserts it).++## The Fusion bridge's capability surface (inventory) → the SW plan++Source: wiki page adom/fusion-bridge v1.9.341 (bridge.json 57 manifest verbs; describe.py+catalog ~110 verbs; README_VERBS.md categories). Cloned at+/tmp/claude-1001/-home-adom-project/ca530728-41cc-4f93-a92d-d32d4afe1153/scratchpad/fusion-bridge/+(read VERBS.md, README_VERBS.md, describe.py, SKILL.md, README.md, docs/*.md for exact+arg/response shapes — mirror arg NAMES where the concept is the same so an AI that knows+fusion_* can drive swx_* with no relearning).++### A. Lifecycle & app state — BUILD (full parity)+| Fusion | SW verb | Notes |+|---|---|---|+| fusion_start / fusion_launch | swx_start (exists) | add `visible`, `stillLaunching` polling semantics + measured cold/warm history (SDK progress rule) |+| fusion_stop | swx_stop (exists) | keep; refuse when `unsavedDocs>0` unless `force:true` |+| fusion_kill | swx_kill | taskkill /F sldworks.exe — gated, requires `reason` + `confirm:true` |+| fusion_readiness | swx_readiness (exists) | add `addinStale:false`-style parity fields: `comAttachable`, `version`, `hostPid` |+| fusion_get_app_state | swx_get_app_state | = today's swx_status+state merged into Fusion's shape: running, activeDocument{name,type,path,dirty}, documents[], workspace(part/assembly/drawing), busy, blockingDialogs[] |+| fusion_state | swx_state (exists) | ADD the screenshot: base64 PNG of every SOLIDWORKS window via ab desktop_screenshot_base64 {hwnd} (callback), plus dialog census |+| fusion_document_info | swx_document_info | active doc metadata: name, type, path, isSaved/dirty, configurations, units, custom-prop count |+| fusion_activate_document | swx_activate_document | `$sw.ActivateDoc3(name, useUserPref, option, errors)` — by name or path |+| fusion_close_document | swx_close_doc (exists) | add `name` arg parity; `save:false` default silent |+| fusion_close_all_documents | swx_close_all_documents | `$sw.CloseAllDocuments(includeUnsaved)`; DESTRUCTIVE → require `confirm:true`; skips dirty unless `closeUnsaved:true` |+| fusion_reset_workspace | swx_reset_workspace | close all scratch docs the bridge created (track them in a ledger) |+| fusion_dismiss_blocking_dialogs / fusion_close_window / fusion_dismiss_recovery | swx_dismiss_blocking_dialogs, swx_close_window | enumerate SOLIDWORKS-owned dialog windows (via ab desktop_list_windows callback, owner pid = sldworks), classify by title (Save changes?, Recovery, license, update), WM_CLOSE by hwnd via ab desktop verbs; never auto-answer "Save changes?" |+| fusion_window_info / screenshot_fusion / screenshot_all / take_screenshot | swx_window_info, swx_screenshot (exists) | screenshot_all = every SW-owned window; use ab generic verbs only |+| fusion_action_ledger | swx_action_ledger | append-only ledger of background actions (docs created/closed, dialogs dismissed, child respawns) in the scratch dir |+| fusion_verb_times | swx_verb_times | measured per-verb timings store (p50/p90, cold vs warm) — feeds `progress` blocks |+| fusion_live_feed | swx_live_feed | LATER (v0.4) — note as lacking |+| fusion_install_fusion / signin / signin_2fa / set_auto_update / set_seat_takeover / set_window_sizing / set_driving_badge | — | NOT APPLICABLE / DEFER: SW has no silent free installer (reseller/Makers store), sign-in is the 3DEXPERIENCE launcher's. Driving badge (taskbar overlay via ab) is CHEAP → build `swx_set_driving_badge` if time allows; report the rest as lacking with reasons |++### B. Files: open / create / save / cloud — BUILD (Drew's explicit ask)+| Fusion | SW verb | Notes |+|---|---|---|+| fusion_open_design (local) | swx_open (exists) | already silent OpenDoc6; add `activate:false` option, `readOnly`, return `progress` (measured) |+| NEW (no Fusion twin, Drew asked) | **swx_new_document** | `{type:"part"|"assembly"|"drawing", template?, name?}` via NewDocument(template,0,0,0) with the stock templates resolved at runtime (GetDocumentTemplate). Returns doc info. Record in the scratch ledger. |+| fusion_import_step | swx_import | open STEP/IGES/Parasolid/STL as a new part via `$sw.LoadFile4(path, "r", null, errors)` (import) — live-test; fall back to OpenDoc6 for native |+| fusion_save_to_cloud | swx_save_as | `$doc.Extension.SaveAs3(path, 0, 1, null, null, errs, warns)` local save-as (Connected also supports "Save to 3DEXPERIENCE" — expose `swx_save_to_cloud` only if provable live via API; else report lacking) |+| fusion_export_{step,iges,stl,3mf,obj,dxf,dwg,sat,f3d,usdz,fbx,skp} | swx_export (exists, one verb) | add per-format aliases swx_export_step/iges/stl/3mf/dxf/dwg/pdf/parasolid so the arg surface matches; verify each format LIVE on the scratch part (SaveAs3 keys off extension; 3MF/OBJ may need swExportOptions — test; report unsupported ones as lacking) |+| fusion_aps_search / browse / recent / open / file_info / versions / download / upload / create_folder / list_cloud_projects / list_cloud_files / walk / search_cloud_files | swx_cloud_* | **RESEARCH + STUB**: 3DEXPERIENCE has the 3DSpace/3DDrive REST APIs (tenant https://oi000616940-usw1-makers-ifwe.3dexperience.3ds.com, CAS/passport auth). This is the Fusion APS trail. Build `swx_cloud_status` (auth state) + `swx_cloud_search` + `swx_cloud_open` (OpenDoc7 / PLMObjectSpecification via COM) ONLY if you can prove ONE call live; otherwise ship a clear `errorCode:"cloud_not_configured"` scaffold + document exactly what auth/API is needed. Report as lacking. |+| fusion_cleanup_cloud_files / delete_cloud_file / export_cloud_file | — | lacking (cloud) |+| fusion_check_recovery | swx_check_recovery | detect the SOLIDWORKS Document Recovery pane/dialog |+| fusion_find (n/a) | swx_find_files (exists) | keep |+| fusion_pack_and_go (n/a) | swx_pack_and_go (exists) | live-test it |++### C. Design intelligence & modeling — BUILD (the MCAD strength)+| Fusion | SW verb | Notes |+|---|---|---|+| fusion_get_design_info | swx_design_info | feature count, body count, sketch count, units, configurations, material, referenced files (assemblies), rebuild state |+| fusion_get_parameters / set_parameter | swx_get_parameters / swx_set_parameter | global variables + dimensions: `$doc.GetEquationMgr()` (Equation, GetCount, Equation(i) get/put) and `$doc.Parameter(name)` / IDimension.SystemValue. Live-test on a scratch part with one extruded box (create via swx_run_script? see below) |+| fusion_inspect_bodies | swx_inspect_bodies | per body: bbox (mm), volume, area, faceCount, material, visible — `$doc.GetBodies2(0,true)` + IBody2.GetMassProperties / GetBodyBox |+| fusion_physical_properties | swx_mass_properties (exists) | add per-component breakdown for assemblies (parity with Fusion's per-component list) |+| fusion_assembly_bom | swx_bom (exists) | add `indented:true` (level column, parent path), `kitAware` no-op, and CSV column ordering parity |+| fusion_run_modeling_script / execute_text_command | swx_run_script | THE escape hatch with teeth: a small, safe, deterministic modeling DSL executed on the COM child — at minimum `new_part`, `sketch_rect(w,h,plane)`, `extrude(depth)`, `set_material(name)`, `set_prop(k,v)`, `save_as(path)` so tests can build a real solid (the mass-properties/BOM/export tests NEED a body). Implement via the standard API: SketchManager.InsertSketch / CreateCornerRectangle / FeatureManager.FeatureExtrusion3 (test the exact late-bound signatures live; document the ones that work). Also keep swx_com_eval. |+| fusion_mcp_* (Autodesk MCP proxy) | — | NOT APPLICABLE (no SOLIDWORKS MCP from Dassault); note the community MCP servers exist (research from 2026-09-01) — lacking by design |+| fusion_board_stackup / electronics | — | not applicable (MCAD) |++### D. Preferences & UI — BUILD (cheap parity)+| Fusion | SW verb | Notes |+|---|---|---|+| fusion_get_preferences / set_preference | swx_get_preferences / swx_set_preference | units (GetUserPreferenceIntegerValue swUnitsLinear), theme not applicable (report), background/appearance where API allows; keep the set small and PROVEN |+| fusion_prefs_open / prefs_close | — | lacking (UI-driven) |+| fusion_click_fusion / send_key | — | deliberately NOT built (COM-first; foreground etiquette). Report as lacking-by-design with the etiquette rationale |++### E. Show / eight-surfaces analog — BUILD the MCAD set+| Fusion | SW verb | Notes |+|---|---|---|+| fusion_show_project / show_2d_board / show_3d_board / show_schematic | swx_show_part, swx_show_assembly, swx_show_drawing | open+activate+zoom-to-fit (`$doc.ViewZoomtofit2()`) in the BACKGROUND, return via swx_state screenshot |+| fusion_show_symbol / footprint / 3d_package / library | — | not applicable (electronics) |++### F. Manufacturing / electronics / libraries / demo — mostly NOT APPLICABLE+gerbers, CPL, design rules, layers, EAGLE/Electron commands, .lbr libraries, managed libraries,+package generation, molecule/GLB pipeline, fusion_demo tour: report each as not applicable+to MCAD or as "lacking, candidate for v0.4" (e.g. swx_export_drawing_pdf, swx_demo tour).++## Testing (app-testing discipline, adapted) — REQUIRED++1. Mock parity: every new verb gets a MockBackend implementation with the same response shape,+   e2e coverage in tests/e2e.rs, and the verb-coverage gate keeps passing (bridge.json ⇔+   describe ⇔ calls made, three ways). No test reads source as strings.+2. LIVE smoke suite: `tools/live-smoke.py` (python, runs from the container via+   tools/swx-live.py) that: creates a scratch part via swx_new_document → builds a real solid via+   swx_run_script → exercises design_info, parameters get/set, inspect_bodies, mass_properties,+   props get/set, export (step, stl, iges, pdf-for-drawing where possible) with files under the+   scratch dir → verifies bytes on disk → creates a scratch assembly, inserts the part twice+   (if provable) → swx_bom → interference → closes everything without saving → asserts swx_docs+   is back to the pre-run set → prints a PASS/FAIL table. It must leave Drew's SOLIDWORKS exactly+   as it found it. The Verifier runs this suite; the Builder runs it before claiming done.+3. Error paths for every new verb (missing args, wrong doc type, unsafe paths).++## Deliverables++- Code + tests green (`cargo test`, cross-compile), version 0.3.0, committed.+- Updated README.md / SKILL.md / docs (verb families, the NewDocument recipe, cloud status).+- **docs/FUSION-PARITY-REPORT.md**: for EVERY Fusion capability (all ~110 catalog verbs): SW verb+  built (live-proven ✓ / mock-only ⚠) | adapted | NOT APPLICABLE (why) | LACKING (why + what it+  would take). Drew reads this; be honest and specific.+- Append "## Build notes — <date>" to this brief for every plan deviation.++## Build notes — 2026-09-02 (v0.3 build)++Every deviation from the plan above, with the assumption that turned out to be wrong.+The full verdict-per-verb picture is in `docs/FUSION-PARITY-REPORT.md`; this is the+record of where the BRIEF was wrong, which is a different (and more useful) list.++### The brief's biggest wrong assumption: that SOLIDWORKS can be started++Section A said `swx_start (exists)` and asked for polling semantics. It cannot exist on+this machine. `CoCreateInstance(SldWorks.Application)` returns `CO_E_SERVER_EXEC_FAILURE`+(`0x80080005`), and launching `sldworks.exe` directly spawns a process that puts up+*"SOLIDWORKS Design must be launched from the 3DEXPERIENCE Platform or from the desktop+shortcut created from the Platform"* and never becomes a drivable COM server. Both were+observed live. `GetActiveObject` attach is the only working path.++`swx_start` is now attach-first and, when nothing is attachable, returns+`errorCode:"host_app_launch_blocked"` with instructions written for the human. The+CoCreateInstance path survives for classic desktop SOLIDWORKS, behind+`Detection::edition()` / `can_launch()` (the install path carries `3DEXPERIENCE` /+`Dassault Systemes`). `swx_stop` now refuses while documents are unsaved and its hint+warns that on Connected it cannot start the app again — stopping is close to a one-way+door here, which the brief did not anticipate.++**Cost of learning this:** one stray refused `sldworks.exe` (identified by the pid+`launch_process` returned, and removed) and one modal briefly on the user's screen. The+constraint is now encoded in code, SKILL.md, README.md and the report so it cannot be+rediscovered the same way.++### Four v0.2 COM bugs the live probes found (none visible to 49 mock tests)++1. **`SaveAs3` returns `swFileSaveError_e`, not a bool.** `0` is success. v0.2 read it as+   a bool, so every successful export reported failure. Probes wrote a 15,836-byte STEP+   and a 22,304-byte IGES that the bridge called refusals. Now decoded, bit flags and all.+2. **Exports were renaming the user's open document.** `swSaveAsOptions_Silent` (1) alone+   is a real Save As. Observed live: a scratch part came back titled `probe.SLDPRT` after+   an export. Exports now use `Silent|Copy` (3), and `swx_export` asserts the title+   survived (`documentRenamed`).+3. **`InterferenceDetectionManager` is on `IAssemblyDoc`, not `ModelDocExtension`.** Every+   interference check in v0.2 failed with "unavailable". Confirmed live on the assembly doc.+4. **`Feature::GetErrorCode2` is uncallable late-bound on this build** (it wants a single+   byref BSTR; every arity we can express is rejected), so v0.2's feature walk marked+   EVERY feature unreadable — an empty assembly reported 16 errors. `GetErrorCode()` (no+   args) works and returned 0 live; `Extension.GetWhatsWrongCount()` is the cross-check.++### Where the brief's proposed COM calls were wrong or incomplete++- **`GetUserPreferenceStringValue(8)` DOES work** (the brief said it returned ""). All+  three template preferences (8/9/10) and all three `GetDocumentTemplate(1|2|3,...)` calls+  resolve on this install. `template_for()` tries GetDocumentTemplate first and falls back.+- **`SelectByID` (the 5-arg legacy form) is enough** for plane selection and is proven+  live. The brief implied `Extension.SelectByID2` with its null callout argument; the+  legacy form needs no null, so there is one less thing to marshal wrong. (`null` was+  added to the `swx_com_eval` grammar anyway — it is needed for `LoadFile4`.)+- **`FeatureExtrusion3` takes 23 arguments and consumes the sketch that `InsertSketch`+  just closed** — no re-selection needed. Proven live end to end: `NewDocument` →+  `SelectByID("Front Plane","PLANE",0,0,0)` → `InsertSketch(true)` →+  `CreateCornerRectangle` → `InsertSketch(true)` → `FeatureExtrusion3(...)` →+  `GetBodies2(0,true)` returned 1 body, and `swx_mass_properties` read back exactly+  3.0e-5 m³ for a 50×30×20 mm box.+- **`GetMaterialPropertyName2` needs a byref BSTR** for its second parameter; the+  two-plain-string form is rejected. `SetMaterialPropertyName2(config, db, name)` works+  as documented (mass went from 0.03 kg at density 1000 to 0.081 kg at 2700).+- **`ISldWorks::NewPart()` hangs** — confirmed again; `NewDocument` is the only route.++### Section B: export formats, measured rather than assumed++The brief asked for per-format aliases and said to verify each live. Done, by exporting a+real solid and checking the bytes:++- **Work from a part:** STEP, STP, IGES, STL, X_T, X_B, SAT, 3MF, **GLB**, PLY, AMF,+  3DXML, PNG, JPG, TIF, XAML, PDF.+- **Refused for a part** (`swFileSaveError_e` 256, nothing written): OBJ, DXF, DWG, U3D.+  DXF/DWG are drawing formats; aliases still ship for them because a `.slddrw` is the+  right target and could not be tested.+- **VRML (`.wrl`) HANGS**: it raises a modal option sheet, the COM call never returns, and+  the watchdog killed the host after 110s — leaving the dialog on screen. `swx_export`+  now refuses it before it reaches COM (`errorCode:"format_blocked"`). This is a+  capability the brief did not anticipate needing to *remove*.++GLB working natively is a genuine advantage over Fusion, which needs an optimisation+service for its GLB. Ten aliases ship (step, iges, stl, 3mf, glb, sat, parasolid, pdf,+dxf, dwg); OBJ deliberately does not, because it does not work here.++### Section C: `swx_run_script` is a typed DSL, not a script host++The brief called for "a small, safe, deterministic modeling DSL", and that is right — but+worth stating why it is not a port of `fusion_run_modeling_script`: Fusion hosts Python+in-process, SOLIDWORKS' scripting is VBA (a macro *file* format driven through a UI), so+there is nothing to `eval`. `script` is a JSON array of typed steps, parsed and validated+on the SERVER before the first COM call — a script that cannot work never half-runs on a+live session. Millimetres in, metres at the COM boundary, one conversion point.+`cut` (`FeatureCut4`) ships but was never executed live and says so in its result+(`proven:false`).++### Section C: the assembly verbs could not be live-proven — and why++`IAssemblyDoc::AddComponent5` returns `Nothing` on this install for every combination+tried: all `swAddComponentConfigOptions_e` values, a saved and an unsaved assembly, an+open and a closed part, and the older `AddComponent4`. No error, no dialog. The most+likely explanation is that SOLIDWORKS **Connected** does not permit local-file component+references (documents belong in 3DSpace), but that is inference. The brief's plan to+"create a scratch assembly, insert the part twice, swx_bom, interference" is therefore+**not achievable on this machine**, and `swx_bom` / `swx_interference` / per-component+mass properties remain mock-only. Re-test them on a classic desktop install, or against+an assembly the user already has.++### Section B: the cloud is not a stub, it is a documented absence++The brief said "build `swx_cloud_status` + `swx_cloud_search` + `swx_cloud_open` ONLY if+you can prove ONE call live". Nothing is provable: `IsPLMConnected` and+`GetPLMConnection` do not exist on this build, and `GetSearchFolders` / `EnumDocuments2`+are rejected. So only `swx_cloud_status` ships — and it RUNS THAT PROBE ON DEMAND and+returns the results (`probedMembers`), so the answer is evidence rather than an assertion.+No `swx_cloud_search`/`swx_cloud_open` stubs: a verb that can only fail is worse than no+verb, because an AI will keep trying it.++### Section A: dialogs are censused, not dismissed++The brief asked for `swx_dismiss_blocking_dialogs` that classifies and closes. Half of+that was a mistake, learned the hard way: closing a stuck SOLIDWORKS modal through ab's+UIA `WindowPattern.close` **took the whole application down**. So the verb REPORTS by+default; closing needs `close:true` + `reason` + `confirm`; and a dialog classified+`neverAutoAnswer` (Save changes?, Document Recovery, licence) is never closed at all.+Attribution is honest too: ab's flat window list carries no owner pid, so a bare `#32770`+is reported with `ownerConfirmed:false` rather than silently claimed as SOLIDWORKS'.+The COM-reported `Frame().GetHWnd()` (proven live) is what identifies the app window+exactly.++### Additions the brief did not ask for, that the work demanded++- **`tools/swx-batch.py`.** Each `shell_execute` round trip to the desktop costs 10-20s;+  discovering a late-bound signature takes dozens of probes. Batching them into one round+  trip is what made live-first development practical. (It stages the call list with ab's+  `write_file` — inlining it as an `EncodedCommand` blows the Windows command-line limit.)+- **`swx_action_ledger` is the audit log; the SWEEP list is separate and in memory.**+  The first cut had `swx_reset_workspace` read the ledger for `document_created` titles.+  That is unsafe: SOLIDWORKS names new documents `Part1`/`Assem1`, so a title recorded+  days ago would eventually match an unsaved document the USER made this morning, and the+  sweep would close it. The registry now lives in `Ctx::scratch_docs` (in memory,+  per-process) and is emptied by `swx_close_doc` too; a bridge restart forgets, so the+  sweep closes nothing rather than the wrong thing. The ledger keeps being the durable+  record of what happened — which is what it is for.+- **`name` as a document handle.** A document from `swx_new_document` has no path until it+  is saved, so `swx_close_doc` / the com host's `resolve()` now accept a title. (Watch the+  namespace collision: `swx_set_parameter` and `swx_set_preference` also take `name`,+  meaning something else entirely — those resolve their document from `path` alone.)+- **`swx_stop` / `swx_kill` refuse on unsaved work**, which the brief did not specify.+  Quitting a CAD application with dirty documents strands it on a save dialog nobody can+  answer, and on Connected editions the bridge cannot restart it.++### Smaller hardening from the self-review pass++- **A failed sketch step used to leave SOLIDWORKS in sketch-edit mode.**+  `sketch_rect` / `sketch_circle` open a sketch, draw, then close it; the draw used `?`,+  so an error returned with the sketch still open and a half-drawn profile on the user's+  screen. `open_sketch` now returns the SketchManager it opened and both ops close it on+  every path before propagating the error.+- `swx_kill`'s unsaved-document probe can itself fail when COM is wedged — the exact case+  the verb exists for. It now reports `unsavedKnown:false` and a null count instead of a+  reassuring zero.+- `swx_get_parameters` walks the feature tree asking each feature for its dimensions, at+  a COM round trip apiece. Bounded to 500 features with `truncated` reported, so a+  thousand-feature model cannot turn a read verb into a minute of blocked CAD.++### What is still owed++**How to finish it** (the exe is already built and served on :8877 from+`target/x86_64-pc-windows-gnu/release/`; restart that server there if it has died):++```bash+# 0. the user must start SOLIDWORKS from the 3DEXPERIENCE Platform first — the+#    bridge cannot, and must not try.+adom-bridge --target adom_drew2 --ai-thread "SolidWorks Bridge" shell_execute '{"command":"powershell -NoProfile -Command \"Invoke-WebRequest -Uri https://drew2-gallia-7g17dw3vho0f.adom.cloud/proxy/8877/swx-bridge.exe -OutFile \\\"$env:LOCALAPPDATA\\Adom Bridge\\bridges-cache\\solidworks-dev\\swx-bridge.exe\\\" -UseBasicParsing\"","timeoutSeconds":180,"reason":"..."}'+adom-bridge --target adom_drew2 --ai-thread "SolidWorks Bridge" process_kill '{"pid":<old swx-bridge pid>,"reason":"..."}'+adom-bridge --target adom_drew2 --ai-thread "SolidWorks Bridge" launch_process '{"path":"%LOCALAPPDATA%\\Adom Bridge\\bridges-cache\\solidworks-dev\\swx-bridge.exe","args":["--port","24695"],"window":"hidden","env":{"ADOM_BIND_HOST":"127.0.0.1"},"reason":"..."}'+python3 tools/live-smoke.py+```++`tools/live-smoke.py` is written and has **not been run**: Drew's desktop dropped off the+ab relay before the v0.3 exe could be redeployed. Nothing in v0.3 has been executed+end-to-end against SOLIDWORKS — only the COM sequences underneath it, individually,+through v0.2's `swx_com_eval`. The suite is the thing that closes that gap; it needs the+desktop back and SOLIDWORKS started from the 3DEXPERIENCE Platform.++## Build notes — 2026-09-02 (round 2: adversarial review)++The review found that three of the four headline safety guarantees were bypassable, two of+them proven by running the binary. It was right about all three, and about a fourth that+was worse: the live-smoke suite itself was the most dangerous artifact in the repo.++### The four bypasses, and why each one existed++**The VRML block tested the wrong noun.** The guard checked the `format` ARGUMENT; `SaveAs3`+keys the export off the DESTINATION EXTENSION. So `swx_export_step {outputPath:"x.wrl"}`+went straight into the call that hung SOLIDWORKS for 110 seconds — and because the+per-format aliases hard-code `format`, the guard could never fire for them at all. Fixed on+the extension, in three places (server, `save_as3`, DSL parse) because there are three roads+to `SaveAs3` and the DSL road had already been shown to skip a check. Tested the way it+breaks, on all five roads.++**`swx_run_script` had no notion of whose document it was building into.** `validate(ops,+has_doc)` accepted a script with no `new_part` whenever anything was open, so a sketch and an+extrude landed in the user's part. Worse, the verb's own `_hint` recommended+`swx_close_doc {save:false}` as the undo — i.e. discard their document. There is now an+ownership gate (`Ctx::scratch_docs` is the authority) on `swx_run_script`, `swx_set_parameter`,+`swx_save_as`-as-rename and `swx_close_doc`-on-dirty-work, overridable only with+`confirm:true` AND a `reason`, which is recorded in the ledger. The hint no longer offers a+destructive undo for a document that is not ours.++**DSL `save_as` bypassed `safe_out` and renamed in place.** The standalone verb had always+validated its destination; the DSL reached `SaveAs3` by a different road. Now validated at+parse time (absolute, no `..`, not a blocked extension), written in Copy mode, and refusing+to overwrite. A test asserts the two blocked-extension lists cannot drift apart.++**Dialogs and windows were closed on a guess.** `is_solidworks_window` marks any top-level+`#32770` as a candidate with `ownerConfirmed:false`, and the close path ignored that flag —+so `swx_dismiss_blocking_dialogs {close:true}` could have closed Word's Save dialog. The unit+test even encoded an unattributed "Export" dialog as closable. Both fixed; the regression+test now asserts the opposite of what it used to.++### The launch guard was a hope, not a guard++One untested path substring, on a registry value never observed on the target machine, that+answered `"desktop"` — meaning *launch it* — for anything unrecognised. Now three independent+signals (install path, registry version strings, the 3DEXPERIENCE Launcher's presence),+`"desktop"` requires POSITIVE evidence, and `"unknown"` fails safe. Both real layouts are+unit-tested, and `SWX_TEST_NO_LAUNCH` makes the `host_app_launch_blocked` branch reachable+from a test for the first time — it had never executed anywhere.++### live-smoke.py was a data-loss path++Phase 1 batched new_document → run_script → set_parameter → props_set → save_as; the+PowerShell loop had no abort-on-failure and `main()` never checked whether `new_document`+succeeded. On a Connected edition — where a failure is entirely plausible — every later step+would have hit the ACTIVE document, then `save_as` (plain Silent) would have renamed and+relocated the user's part into a scratch folder, cleanup would have closed it `save:false`,+and `Remove-Item -Recurse -Force` would have deleted the folder.++Rewritten around structure rather than care: a `Doc` registry of what the suite created,+`mutate()` as the only door to a mutating verb (refusing anything not ours), `Abort` on any+preflight or setup failure, `stop_on_failure` in the batch runner so a dead step stops the+trip, per-file deletion instead of a recursive tree removal, and the document-set invariant+as a GATE that runs even on an early abort. It also now proves the refusals — including that+a `.wrl` never reaches COM, which is the one that would hang the user's SOLIDWORKS.++### Rebutted, with reasons++**`swx_props_set` is NOT ownership-gated, deliberately.** It is in a different risk class from+`swx_run_script`: it writes a named metadata field the caller explicitly specified, in memory,+reversible by not calling `swx_save` — and annotating the user's existing parts with+PartNo/Material is the bridge's core BOM workflow, not an accident. Gating every property+write behind `confirm` would make the most common legitimate use unusable while preventing+nothing that `swx_save` does not already make explicit. It is a v0.2 verb with a v0.2+contract, and this is a decision rather than an oversight.++**`fusion_export_f3d` stays ➖ not applicable** while `skp`/`fbx`/`usdz` moved to ❌ lacking.+F3D is Autodesk's own archive format — SOLIDWORKS will never write it, and no translator+could exist. The others are formats with real translators that this install simply does not+have, which is a gap rather than an impossibility.++### Smaller items++Import can no longer run twice (the fallback is now decided by whether a document actually+appeared, not by the shape of LoadFile4's return). `stop` matches only the specific+RPC-disconnect HRESULTs and re-probes `GetActiveObject` to VERIFY the application went away.+`get_parameters` is bounded by COM round trips, not just feature count. Sketch ops clear the+selection before and after. The DSL pins its target document instead of re-resolving "whatever+is active now". Timeout budgets raised to cover worst-case server paths. `bridge.json`+detect paths synced with the code's globs. Stale catalog summaries fixed.++The coverage gate now requires an ASSERTION per verb, not just a call — the harness credits+each `check!` to the most recent verb, and the gate fails on any shipped verb that was POSTed+and never looked at. Mock fidelity: real untitled names (`Assem1`, not `Assembly1`),+`swFileSaveError_e` 256 for formats a part cannot produce, and injectable rename so+report-bug #2 has coverage for the first time.++## Build notes — 2026-09-02 (round 3: adversarial review)++The centrepiece of round 2 — the ownership gate — had a Critical flaw, and it is the most+instructive defect of the whole build.++### `targetDocument` authorized one document and the bridge mutated another++The gate resolved its target from `targetDocument` and decided ownership from that. But only+`swx_run_script` FORWARDED the argument; `swx_save_as`, `swx_set_parameter`, `swx_props_set`+and `swx_export` all sent `path` (usually null), so the com host fell back to `ActiveDoc`.+With a user part in front, `swx_save_as {outputPath:"…", targetDocument:"Part1"}` passed the+gate on Part1 and then renamed and relocated the USER'S document — the v0.2 data-loss bug,+resurrected by its own fix. The refusal message even handed the caller the value that+triggered it, in `bridgeDocuments`.++The lesson is not "check harder", it is that **a check and the action it guards must not be+able to disagree about their subject.** The fix is structural: `resolve_target()` produces a+`Target` ONCE, and `Target::args()` is the only way a mutating verb addresses a document —+`docName` (a dedicated key that cannot collide with the `name` meaning a dimension on+`set_parameter` or a preference on `set_preference`), plus the path. Whatever the gate+approved is literally what the com host is told to open. A `targetDocument` naming nothing+open is `document_not_open`, never a fall back; naming two different documents two ways is+`ambiguous_target`.++Verified against the running binary with the reviewer's exact call: Part1 is renamed,+`IMPORTANT.sldprt` is untouched.++**Rebuttal, stated because the review asked for a different test.** The requested case was+"retry with `targetDocument` from `bridgeDocuments` → must STILL refuse". It does not, and+should not: with the fix, naming Part1 operates on Part1, which is correct and safe. The test+that ships asserts the thing that actually matters — the retry acts on the named document AND+the user's document is provably still open and unchanged — plus the ambiguity and+not-open refusals that close the door the old bug went through.++### Ownership failed OPEN on title reuse++Entries were keyed on title alone, and forgotten only on paths that run through this bridge —+never by `CloseAllDocuments`, a crash, or the user closing a document in the SOLIDWORKS UI.+The comment claiming "a restart forgets" was simply false: the bridge SERVER outlives+SOLIDWORKS. And SOLIDWORKS restarts its `Part1`/`Assem1` numbering with every session, so a+remembered `Part1` would eventually match a fresh `Part1` the user made — which the bridge+would then treat as its own and build geometry into, ungated.++An entry is now `(title, SOLIDWORKS session, path-once-saved)`, where the session is+SOLIDWORKS' own process id. Ownership additionally requires the document to be OPEN RIGHT NOW,+which is what covers every close path the bridge cannot see. An unknown session fails CLOSED.+The mock models both facts — a new process id and a reset Part counter after `stop`/`start` —+so the suite can prove it rather than assert it.++### Two more unguarded roads to the same COM calls++`swx_open` passed `launch:true` unconditionally: the only such call outside `swx_start`, and+untouched by every previous fix. On a Connected edition one `swx_open` would have put the+"launch me from the 3DEXPERIENCE Platform" modal back on Drew's screen — the exact incident+this whole effort exists to prevent. The server now makes that decision with `may_launch`.++`swx_com_eval` reached `SaveAs3` directly, skipping the guarded helper, the extension block,+Copy mode and the ownership gate. It now refuses the members that write, close or delete. A+denylist is the right shape here: an allowlist of readable members would have to enumerate the+SOLIDWORKS API to be useful, while the members that DESTROY are a short, well-known list.++### The persist step is where permission belongs++Round 2 rebutted gating `swx_props_set` on the grounds that it is in-memory. That argument+only holds if nothing can commit it — and `swx_save` was ungated in the same surface. The+rebuttal was hollow, so `swx_save` is gated now (confirm + reason on a document the bridge did+not create, recorded in the ledger) and `props_set` stays open, which keeps the BOM workflow+usable while closing the path to the user's file.++### Smaller, and one that was embarrassing++The extension guard was a raw string compare: `a.wrl.`, `a.wrl ` and `a.wrl::$DATA` all+resolve to `a.wrl` under Windows canonicalisation and all sailed through. Now normalised.+Window attribution treated a title merely CONTAINING "SOLIDWORKS" as proof of ownership, which+the Installation Manager and any 3DEXPERIENCE launcher dialog also satisfy — and with COM down+the title is the ONLY test, precisely when being wrong is most likely; a real owner-pid match+is now required. `close_all_documents {closeUnsaved:true}` discarded every dirty document on+one flag; it now needs a reason, discards only the bridge's own, and lists the user's in+`skipped`. Import fails closed when the document count is unknowable. The coverage gate binds+each assertion to the verb its NAME mentions rather than the last verb called.++### live-smoke, again++Three more holes: `swx-batch.py` called `sys.exit(1)` on a staging failure, and `SystemExit`+is not `Abort` — it would have sailed straight through the `finally` that runs the+"documents unchanged" gate, so the one run where the invariant matters most was the run that+skipped it. Fixed by returning `None` and catching `BaseException`. `mutate()` checked+ownership once per phase while `ActiveDoc` follows window focus, so the eight-export batch is+now eight calls with the active document re-read before each. And `phase_ownership_refusal`+fired three mutating verbs at Drew's real document to prove a gate that had just been shown+capable of failing open — it now proves the same refusal without aiming anything mutating at+his data, unless `--touch-user-doc` is passed.++The suite's docstring now says what round 3 made explicit: **restart the bridge process before+a live run**, so ownership starts empty rather than inheriting a stale claim.++## Build notes — 2026-09-03 (round 4: adversarial review)++Round 3's Critical was half fixed, and the half that was missing was the important half.++### A title is not an identity++Ownership was `(title, session)`, and `Target::args()` sent `docName:<title>` which the com host+preferred over the `path` the Target was already carrying. Two open documents named+`thing.sldprt` in different folders is completely ordinary. Reproduced: with the user's dirty+`C:\users\thing.sldprt` and the bridge's own `C:\bridge\thing.sldprt` both open,+`swx_save_as {targetDocument:"thing.sldprt"}` — **no confirm, no reason** — passed the gate+against the bridge's copy and renamed and relocated the USER's document.++Three changes: `com.rs::resolve()` prefers **`path`** over `docName` (a title is only the handle+for a document that has never been saved, and SOLIDWORKS will not issue the same untitled name+twice in one session); `Ctx::owns_doc` keys on the path wherever there is one; and a title+matching more than one open document is `ambiguous_target` on **every** verb, read or write, with+the candidates and their paths in the response.++### `swx_close_doc` was the one destructive verb that resolved nothing++Its unsaved-work guard compared a title against `scratch_titles()` with no session scoping and no+pruning, and it ignored `targetDocument` entirely. Reproduced: it closed and discarded the user's+dirty `thing.sldprt` while the bridge's identically-titled document survived. It now goes through+the same resolver as everything else.++### My round-3 rebuttal was unsound, and worth recording as such++I argued the "retry from `bridgeDocuments` must still refuse" test was wrong because naming+Part1 correctly operates on Part1. That holds **only while titles are unique**, which I asserted+rather than checked — and the refusal handed the AI a TITLE to retry with, which is precisely how+the collision was reached. `bridgeDocuments` now carries `{targetDocument, path}` per entry and+the hint says to retry with the **path**, not the title. The e2e asserts `(title, path)` IDENTITY+of the user's document, not that it is still open: in the bug it WAS still open — under a new+name, at a new path, inside the bridge's folder.++### The denylist was the wrong shape++`swx_com_eval` blocked members that write. It did not block `SendMsgToUser2` (a modal on the+user's screen that wedges the com host for the full timeout — the exact disruption class this+whole effort exists to prevent), `SetUserPreferenceToggle`, `SetSaveFlag`, `ForceRebuild3` or+`EditRebuild3`, because nobody thought of them. A denylist has to anticipate every dangerous+member of an API with thousands. It is now an **allowlist** of reads: `Get*`/`Is*`/`Has*`/`Can*`/+`Enum*` plus a short list of navigation properties. A member nobody has thought of is refused, and+the message says how to add it if it is genuinely a read.++### live-smoke was still a weapon++Three more, all in the file whose entire job is to be safe:++- `phase_ownership_refusal` was **not** opt-in as I had claimed — only the `run_script` variant was+  gated; the default still sent a real `swx_save_as` at the user's own document through `call()`,+  on the premise that "a refusal is a read". C1 made that premise false. The default now proves+  the refusal against scratch documents and error paths that name nothing real.+- `cleanup()` unconditionally deleted `stolen.sldprt` — a file it never writes. If the gate had+  failed, that file **is** the user's relocated document, and the suite would have `Remove-Item+  -Force`d it out from under an open SOLIDWORKS window, destroying both the document and the+  evidence. It now deletes only names in `FILES_WRITTEN`, and the existence of `stolen.sldprt` is+  a hard FAIL that says not to delete it.+- The invariant gate was the LAST statement in cleanup, after `listing()` and a dozen `shell()`+  round trips, any of which could raise into the outer handler — so the runs that most needed+  "documents unchanged" were the runs that skipped it. It now runs FIRST, in its own try, and+  SKIPS rather than fails when no baseline was captured (a preflight abort fires before the+  baseline exists, and a spurious failure there teaches the reader to ignore the one check that+  matters).++Also: the units probe and the taskbar badge register their restore BEFORE changing anything, so an+abort or a dropped relay cannot leave the user's settings flipped; `mutate()`'s docstring no longer+claims to be the only door (`batch()` sends two vetted-target mutating calls, and says so); and the+resolver reads the open-document list ONCE instead of a COM round trip per document with the active+document re-read each time.++### The pattern, stated plainly++Four rounds, and every defect was **a guard that existed and could be walked around** — never a+guard nobody had thought of. Three times the fix introduced the next one. Whatever is still wrong+is most likely the same shape, which is the argument for `tools/live-smoke.py` over any further+assurance from me.++## Build notes — 2026-09-03 (round 5: the design change)++Five rounds, five Criticals, all in one surface: the bridge writing to something the user+owns, through a route whose guard had been forgotten. Round 5 found two more — an ungated+`Save3` behind `close_doc {save:true}`, and no overwrite protection on three of four write+destinations. At that point the strategy, not the code, was what needed replacing.++### Writes are deny-by-default, at one choke point++`src/writes.rs::authorize` is the only thing that decides whether this bridge may write.+Every write goes through it and it refuses unless BOTH: the document is one this bridge+created in this SOLIDWORKS session, AND the destination path does not already exist. The+escape is `SWX_ALLOW_USER_WRITES=1` on the process PLUS `allowUserWrites:true` + `confirm` ++`reason` on the call, and every grant is ledgered.++Three properties make this different from the four previous attempts:++- **It is one function, not N guards.** A new write verb cannot forget to call it and still+  work, because it has no other way to reach the com host with a mutating command.+- **The com host holds an independent veto.** It keeps its own record of the documents it+  created (it creates them, so it knows) and reads the opt-in from the environment it+  inherited — not from anything the server said. Rounds 3 and 5 both turned on the+  server-authorizes / host-acts split; a server-side check is a claim. Now two independent+  systems must agree, and `the_com_host_refuses_a_write_the_server_would_have_allowed` drives+  the raw stdio protocol to prove the host says no to a forged authorization.+- **The default is the safe subset, and the suite runs in it.** `live-smoke.py` passes with+  the opt-in OFF, which is the strongest available statement that read + create + model ++  export-to-new-paths is genuinely the whole useful surface.++The MOCK backend models the host veto too. A mock that omits the security-relevant behaviour+makes the test covering it prove nothing — the lesson of every previous round.++### Also fixed++`resolve_target` and `resolve_target_for_read` collapsed into ONE `resolve_document`:+identity is now a separate concern from permission, which is why the choke point could be+made total. Ambiguity is enforced on PATH as well as title (`save_as` can put two open+documents at the same path, so round 4's defect was re-expressible with the key that replaced+it). Every document-addressing verb — `bom`, `mass_properties`, `interference`,+`rebuild_check`, `props_get`, `props_set`, `document_info`, `design_info`, `get_parameters`,+`inspect_bodies`, `get_preferences` — now goes through it; a BOM off the wrong same-titled+part is a bill of materials somebody orders from.++`swx_props_set` no longer writes a reason THE BRIDGE AUTHORED FOR ITSELF into the ledger+("swx_props_set is in-memory until swx_save, which is gated") — a self-authored justification+in the user's audit trail, and one that the `close_doc{save:true}` bypass made false. It+records an honest `user_document_properties_set` entry instead. `swx_close_doc` now records+in the ledger at all, which both docs had promised and neither delivered.++### live-smoke, round 5++`ab()` caught only `json.loads`, so a `subprocess.TimeoutExpired` propagated out of+`cleanup()` past the invariant gate AND every restore — on exactly the runs (wedged+SOLIDWORKS, dropped relay) where putting the machine back matters most. The invariant now+runs FIRST in its own try, with `atexit` and SIGTERM/SIGINT handlers so a kill cannot skip it.+The landmine check (`stolen.sldprt` and friends) now HALTS deletion and returns instead of+printing and carrying on into `Remove-Item` eight lines later. `FILES_WRITTEN` records+authorship rather than intent, and preflight ABORTS if the shared `C:\Users\Public\swx-smoke`+is non-empty, since nine fixed filenames could otherwise collide with somebody else's.++### The honest summary++Four rounds of route-by-route gating did not converge. Denying by default at one choke point,+enforced twice, removes the class rather than the instance. That should have been the design+from the start, and the reason it was not is worth stating: each individual gate looked+sufficient when it was written.++## Build notes — 2026-09-03 (round 6: applying the design completely)++Round 5's design was right and its APPLICATION was not. `authorize` was wired into seven+verbs; three more wrote around it, and one of those destroyed a file on disk in the default+posture. The lesson repeats the shape of every previous round — a guard that exists, and a+route that does not reach it — with one difference: this time the fix is structural on the+host side rather than another verb-by-verb sweep.++### The host now authorizes on its DISPATCH LOOP, keyed off what is safe++The first host veto covered a remembered list of seven commands. Proven by forged raw stdio:+a forged `save` was correctly vetoed while a forged `run_script` — the entire modelling DSL,+`InsertSketch`/`FeatureExtrusion3`/`SetMaterialPropertyName2`/`Add3` — with no+`targetDocument` resolved to the user's ActiveDoc and mutated it. `props_set`,+`rebuild_check`, `eval`, `close_doc{save:false}`, `close_all_documents` and `stop` were+equally absent.++`Backend::authorize_command` is now part of the trait and the host's main loop calls it for+every command not on `READ_ONLY_COMMANDS`. Listing what is SAFE rather than what is dangerous+is the whole point: a command nobody has classified is refused, and one added tomorrow is+deny-by-default. `eval` additionally re-checks the read allowlist in the host, because the one+verb that can call any COM member had no host-side guard at all.++### The three routes that wrote around the choke point++- **`swx_bom {format:"csv"}`** did `std::fs::write` on the SERVER with no authorization+  anywhere — `safe_out` only checks "absolute, no `..`". It overwrote a pre-existing file and+  returned `success:true`. Because the write is server-side, both "independent vetoes" were+  structurally irrelevant to it. And SKILL called the verb a read.+- **`swx_props_set`** was left ungated on the argument that it is "in memory until a gated+  save". That ignored the persist route that cannot be gated: **the user**. It leaves their+  document dirty, so SOLIDWORKS prompts "Save changes?" on close and their own Ctrl+S commits+  bridge-authored data. Modifying the document is the harm, whoever eventually writes it.+- **`swx_rebuild_check`** called `ForceRebuild3` freely — a member on this bridge's OWN+  `NAMED_HAZARDS` list, which `com_eval` refuses as "rebuilds the user's model". A first-class+  verb doing what the escape hatch forbids is not a defensible split.++### Session changes are writes too++`swx_stop`, `swx_close_all_documents` and `swx_close_doc` on a document the bridge did not+create now need the process-level opt-in. Closing someone's document costs them their window,+their undo history and their place in the work even when it is clean; quitting is close to a+one-way door on a Connected edition, which this bridge cannot restart. `Kind::EndSession` is+gated unconditionally — there is no foreign document and no clobbered file to trigger on.++### Smaller, and one that was mine to notice++`swx_pack_and_go` had the server and the host DISAGREEING: the server passed+`destination:None` for an empty directory, which skipped the ownership question entirely,+while the real com host refused. The verb was dead on a real machine and green in the suite —+and the mock had no authorize in `pack_and_go` at all, so the tests proved the opposite of what+would happen live. `create_dir_all` also ran BEFORE authorization, leaving a directory on the+user's disk after a refusal. All three fixed, and `Kind::CollectFiles` now `touches_document`,+because Pack and Go copies the whole reference tree — a bulk extraction of the design, not one+export.++`ComBackend::created` was per-process, and the com host is killed and respawned BY DESIGN.+So a respawn started refusing writes to the BRIDGE'S OWN documents: fail-closed, but silently+broken, exactly after the recovery path the architecture exists for. It is persisted now+(`comhost/created_store.rs`), written and read only by the HOST so the veto stays independent,+and cleared when the SOLIDWORKS session ends.++### On the reversion claim++I reported "stubbing the choke point fails 2 tests". That was measured with a broken mutation+and was wrong in both directions — and there was no test at all for five of the routes above.+Every route now has one, verified by mutating `writes::authorize` to wave that verb through:+bom 1, props_set 2, rebuild_check 2, pack_and_go 2, stop/close_all 2, save 2, close_doc 2,+run_script 3, set_parameter 2, set_preference 2, export 1; the host dispatch veto 2.++### live-smoke++One real hole: `swx_rebuild_check {}` sat in `phase_build`'s batch, targeted the ACTIVE+document, and was not in `MUTATING`, so `mutate()` never vetted it. If Drew clicked his own+model mid-batch, `ForceRebuild3` would have run on it. It is pinned to the scratch document,+moved out of the batch, and added to `MUTATING` along with `bom` and `pack_and_go`. Preflight+also now asserts the DEFAULT posture, because the suite passing without the opt-in is the+strongest statement that the safe subset is genuinely useful.++## Build notes — 2026-09-03 (round 7: the half that never speaks to the com host)++Round 6 closed the write surface — every mutating command forged over raw stdio was refused by+the host's own veto. Round 7 found the remaining hole in the OTHER half of the bridge: the+verbs that go out through ab, where the com host's veto is not in the path at all and the+server-side choke point was never wired in.++### `swx_kill` force-killed SOLIDWORKS in the default posture++Its gates were `confirm:true` + `reason` — both things a caller writes for itself — plus an+unsaved-documents guard that `force:true` overrode AND that silently no-opped when COM was+wedged (`unsaved_known=false → unsaved=0 → guard skipped`), which is *exactly* the case the+verb exists for. Proven against an ab stub: `taskkill /F /IM SLDWORKS.exe` dispatched.++It goes through `writes::authorize` as `Kind::EndSession` now, so the process-level opt-in is+required exactly as it is for `swx_stop`. And `kill_is_unsafe` treats an unanswerable probe as+UNSAFE: an unanswerable question is not permission. That decision is a pure function with its+own unit test, because a mock cannot make COM fail convincingly.++### `swx_close_window` would close the application FRAME++`ownerConfirmed` is true precisely when a window is most provably SOLIDWORKS' — and the main+window is the most provable window there is. So the "this is not a general window killer"+guard PASSED on the one window it must never pass on, and `mainHwnd` is handed to callers by+`swx_status` and `swx_window_info`, which makes it the obvious thing to try. UIA Close on a+frame quits the application, with Save-changes modals on the way out.++The COM-reported main hwnd is now refused before ab is consulted at all (otherwise an+unreachable ab gives `window_not_attributed` — the right answer for the wrong reason, which+would flip to allowed the moment ab could see the window), and any non-dialog window class is+treated as a frame. `swx_window_info` reports `isFrame` and `closable` per window.++### Every dialog close now needs the opt-in — including the bridge's own++The reviewer asked for a narrow bridge-caused allowlist. I built it, then took it out. The+argument against my own first answer: on 2026-09-02 closing a stuck SOLIDWORKS modal through+the window manager TOOK THE WHOLE APPLICATION DOWN. A verb that can do that should not act on+`confirm` + `reason`. `BRIDGE_CAUSED_DIALOGS` survives as a REPORTED flag — a caller can see+which dialogs are the bridge's own mess — but it licenses nothing.++### The test gap that let all of this survive six reviews++With no ab reachable, the ab-delegated verbs only ever ran their "ab is unreachable" branch.+A guard on that side could be deleted and every test would stay green. `common::AbStub` is a+real HTTP stand-in for ab's direct API that reports windows WITH pids (so attribution+genuinely succeeds) and RECORDS what was dispatched — because "the refusal returned an error"+and "nothing was sent" are different claims, and only the second one matters. The new e2e+asserts `ab.destructive_calls().is_empty()`.++### Smaller++`created_store` now stamps the SOLIDWORKS session, and a record from another session confers+nothing (round 6 traded fail-closed for fail-open here: the file was cleared only on a clean+`stop`, so a crash, a kill or the user quitting left it claiming their next `Part1`). The mock+had the same bug in reverse — it keyed its "SOLIDWORKS session" to the com host's own pid, so+a respawned host saw a different SOLIDWORKS and discarded its own record; the session now+lives in a file, as a real process id does. `pack_and_go`'s two vetoes were answering+different questions (server: "is the directory non-empty?", host: `exists()`); both use+existence now. `swx_open` is READ-ONLY by default, so the bridge does not hold a write lock on+the user's file and an older-version document is not converted-and-dirtied just by being+looked at.++`READ_ONLY_COMMANDS` keeps `show`, `activate_document` and `interference`, and now says why in+the code: they change the VIEW, not the work — nothing they touch reaches disk, geometry or+saved state, and `interference`'s three `try_put`s are on a manager object that `Done()` tears+down on every path via a drop guard. A list called "read only" containing them without that+note would have been a lie; gating them would make `swx_show_*` useless on the user's own+documents, which is the one thing it is for.++### live-smoke++`M2`: the default-posture check was `check()`, not `require()` — with the env var set the+suite would have recorded one FAIL and then run the whole mutating suite in the ENABLED+posture. It is the single precondition the live run rests on, and it is a gate now. `M3`:+`set_preference` escaped `mutate()`, had no `targetDocument`, and so aimed at whatever was+ACTIVE — the same class of miss as round 6's `rebuild_check`. Pinned, routed through+`mutate()`, and its RESTORE lambda pinned too.++## Build notes — 2026-09-03 (round 8: the sibling that was never gated)++Round 7 gated `swx_kill` and taught `swx_close_window` to refuse application frames. It did not+gate `swx_close_window` itself — so of the four session-enders, three went through the choke+point and one did not.++### `swx_close_window` closed the user's "Save changes?" modal, in the default posture++No `writes::authorize_in`, and no `neverAutoAnswer` check, while+`swx_dismiss_blocking_dialogs` — operating on the SAME window list — had both. Proven with a+recording ab stub: posture `disabled`, `{hwnd: 9001, reason:"tidying", confirm:true}` on+"Save changes to gearbox?" → `success:true`, `desktop_ui_window {action:"close"}` dispatched.++The impact is the largest this bridge can cause. By its own live evidence from 2026-09-02,+closing a modal SOLIDWORKS is blocked on takes the whole application down — and this is the+modal that stands between the user and every unsaved document they have. It was also+DISCOVERABLE: `swx_window_info` reported that dialog `closable:true`, the same shape as round+7's `mainHwnd`.++The reasoning I used to justify removing the bridge-caused-dialog allowlist in round 7 —+*"a verb that can do that should not act on confirm+reason, both of which a caller writes for+itself"* — applied verbatim to this verb, and I applied it only to the sibling. Both refusals+are now on both verbs, and `closable` folds in ALL THREE (frame, attribution, never-auto-answer)+so a caller can act on the field rather than re-deriving the rules.++### `is_frame_window` inverted its own fail-safe++`!class.is_empty() && class != DIALOG_CLASS` — a window ab reports with no `className` was+therefore "not a frame", and closable. Proven: a SOLIDWORKS-pid window titled `bracket.SLDPRT`+with no class was closed and dispatched. It is `class != DIALOG_CLASS` now: unknown means+frame, the same rule `kill_is_unsafe` applies to an unanswerable probe.++### Three of round 7's seven fixes introduced their own defect++`swx_open` is the third. Round 7 changed the DEFAULT to read-only and left `readOnly:false`+caller-settable — on the com host's safe list, where `authorize_command` never runs. By the+comment I wrote in the same commit, that takes a write lock on the user's file and+converts-and-dirties an older-version document in memory. `is_mutating` now takes the args, so+`open {readOnly:false}` is authorized on both sides; the host decides ownership on the PATH+against its own record.++That pattern is worth naming: the fixes that introduced defects were all fixes that changed a+DEFAULT while leaving the dangerous mode reachable. Changing a default is not closing a hole.++### `swx_screenshot` was a general desktop capture tool++`titleContains` was forwarded straight to ab, so `{"titleContains":"1Password"}` captured+whatever matched, from a verb catalogued as "screenshot the SOLIDWORKS window". Not a write,+but it is the user's data and it had no test. It captures BY HANDLE now — the one COM reports,+or an hwnd `swx_window_info` attributes to SOLIDWORKS.++### `swx_uninstall` could erase the audit log++It takes no gate (ab calls it on app uninstall) and removed `ledger.jsonl` with the rest of the+scratch subtree — so an AI could erase the record of what it did by asking the bridge to tidy+up. The ledger is now the one artifact `uninstall` leaves behind; removing the folder is the+user's to do.++### Ownership means "open AND ours", on both sides++Writing the `readOnly` test surfaced a disagreement I had introduced: the host's persisted+record kept a path after the document closed, while the server's registry pruned it. So a+closed bridge-created file was ours to the host and not to the server. The host now drops the+entry on `close_doc` too. The rule both sides state: a document this session created and STILL+HOLDS — not a file this bridge once wrote, which is the reading that could drift onto someone+else's file after a rename.++### Mutation results++Twelve targeted mutations, twelve killed, including the four the review found unkilled. The+three that needed new coverage were all cases the stub made unreachable: the main-hwnd shortcut+(every stub frame also had a non-dialog class), the `ownerConfirmed` guard (every stub window+carried the SOLIDWORKS pid, so nothing was ever unattributable), and the host's+`is_mutating("open")` (the server refused first, so the host's veto was never exercised). The+lesson is the same one as round 7: a stub that only ever presents the easy case tests the easy+case.++Also done: the interference `Done()` drop guard is armed BEFORE the three `try_put`s, so a+panic inside a put cannot leak the session; the dead `isFrame` check in `dismiss` is a real one;+`live-smoke`'s `swx_show_drawing` is pinned; and the e2e assertion that accepted+`window_not_attributed` as an alternative to `window_is_application_frame` — and so pinned+nothing — now requires the frame code.++## Build notes — 2026-09-03 (round 9: the first live run)++The suite ran against Drew's real SOLIDWORKS. **22 passed, 4 failed, aborted** — and the four+failures were all one functional bug, in the exact place eight rounds of security review never+looked.++### What held up++Everything the previous eight rounds built. Drew had his own `Part1` open; the suite created+`Part2`, never touched `Part1`, aborted on the first failure, removed every file it wrote, and+left SOLIDWORKS running. `swx_reset_workspace` reported+`skipped: [{title:"Part1", why:"not created by this bridge in this SOLIDWORKS session"}]` —+session-scoped ownership, working on a real machine against a real user's document. The+"documents unchanged" invariant correctly FAILED and named the orphan. The+`host_app_launch_blocked` finding was confirmed live: *"this IS the Connected edition, which+cannot be launched programmatically."*++### The bug: an unsaved document was unaddressable by every verb++`swx_docs` listed `Part2`; `swx_design_info`, `swx_close_doc` and `swx_reset_workspace` all+reported "document not open: Part2" — **including with no target at all**, on the ACTIVE+document.++Root cause: `GetOpenDocumentByName` wants a FULL PATH. An unsaved document has none, so it+cannot be found by title — and since round 3 the server ALWAYS sends a resolved identity, so+even the no-target case went through it instead of falling back to `ActiveDoc`. The whole+create → model → export flow — the thing Drew actually asked for — was dead for new documents.++The host now resolves a TITLE by walking `GetDocuments()` and comparing `GetTitle()`. That+works for saved and unsaved alike and lets the ambiguity rule be enforced at the host rather+than trusting whichever document SOLIDWORKS hands back first. Paths still win where a path+exists.++**My round-3 rebuttal was right for this case, and the round-4 fix over-corrected.** I argued+then that a pathless document's title IS its identity because SOLIDWORKS will not issue the+same untitled name twice in a session. Round 4 found a real title-collision bug in SAVED+documents and I made path the identity everywhere — including where there is no path. Both+halves are now true at once: path first when there is one, title when there is not.++### Why 89 mock tests passed++The mock resolved titles out of its own map, so it could never express the failure. It now+mirrors the real resolution exactly: a PATH matches only a document that actually has one+(`reported_path` is `""` until saved, and the internal key is not a path), and a TITLE is+resolved by walking the open documents. That change alone makes the old behaviour fail 9 tests.++This is the fourth time a mock that modelled the easy case hid a real defect. The rule I should+have been applying: **the mock must model the API's CONSTRAINTS, not just its results.**++### Also++`HostError` carries a branchable `code` now, propagated through the protocol into+`errorCode` — the live failures came back with `errorCode: None` and prose only, and a caller+cannot branch on "document not open: Part2". `document_not_open`, `ambiguous_target` and+`no_target_document` are the codes.++`live-smoke.py`'s cleanup retries a close by the title SOLIDWORKS is actually reporting, and if+a document still cannot be closed it says so in one line, names it, and says plainly that it is+the suite's own unsaved scratch — not the user's. The live run left an orphan `Part2` and said+nothing about it beyond a failed check.++### An honest limit++`com.rs` is `cfg(windows)` and never executes in the mock suite, so no Linux test can kill a+mutation in it — I verified this by mutating the title-walk and watching every test stay green.+Its correctness rests on the cross-compile, on the mock mirroring its logic, and on the live+run. That is the gap the live run exists to close, and it is why the run found this and the+suite did not.++## Build notes — 2026-09-03 (round 10: live run 2)++**120 passed, 9 failed, no abort** — up from 22-and-aborted. The create → model → export flow+ran end to end on real hardware, which makes report-bugs #1 and #2 PROVEN FIXED rather than+diagnosed: eight formats exported with `saveErrorCode` clean, `documentRenamed:false`, the title+unchanged and real bytes on disk. The `Silent|Copy` path has now actually executed.++### The bug: one letter of case++`swx_save_as` was asked for `…\smoke.sldprt`. SOLIDWORKS reported the document at+`…\smoke.SLDPRT`. The ownership record kept the path we ASKED for; `prune_scratch` compared it+against the path SOLIDWORKS REPORTED; the exact string compare failed; the bridge disowned the+scratch document it had just created and then refused to close or clean it up. Four of the nine+failures cascaded from that, and an orphan was left on the machine.++Two fixes, because either alone would leave the class open:++- **`same_path`** compares Windows paths the way Windows does — case-insensitively, with+  separators normalised. Used by `owns_doc`, `prune_scratch`, `by_path`, and both backends'+  `host_owns`.+- **The record stores the path SOLIDWORKS REPORTS**, not the one we asked for.++And the principle the reviewer named, which is the actual lesson: **ownership follows the+DOCUMENT, not the string that used to name it.** A non-copy `save_as` retitles and re-paths in+place, so the host moves its claim with it; `remember_created` now evicts by IDENTITY rather+than by title, which is what let an imported document displace the record of a saved one that+happened to share its name.++This is the mirror image of round 9's bug. Both came from identity being DERIVED at each use+instead of TRACKED through the document's life.++### Three mock-fidelity gaps, all of the same family++The mock could not express any of this, which is why 89 tests passed:++1. It did not **uppercase the extension** on save, so requested and reported paths always+   matched exactly.+2. It titled an **imported** document by bare stem, not `<stem>.SLDPRT`, so it could not produce+   the title collision the live run hit.+3. Its `open` **duplicated** an already-open document instead of returning it, an artifact that+   masked the ownership defect in the one test that came closest.++Fixing (1) alone broke three tests immediately — those were the tests that should have caught+the live bug. Fourth round running, the same lesson: **the mock must model the API's behaviour+and constraints, not just its happy-path results.**++### `ambiguous_target` was correct, and the situation was the bridge's fault++`swx_import` of the STEP the suite had just exported produced a second document with the same+title, so close-by-title refused — right answer, self-inflicted problem. Close-by-PATH now+resolves before the title-ambiguity check can fire (a path identifies exactly one document),+and `live-smoke` imports from a different stem so it stops manufacturing the collision.++### "ab is unreachable" must not read as "there are no windows"++Three failures were `ADOM_DIRECT_API_URL not in env` — the dev bridge was launched by hand, so+it never inherited ab's direct-API environment. `swx_window_info` returned `[]`, which is+indistinguishable from a real absence and made a launch artifact look like three bridge bugs.+It now returns `windows: null` with `abAvailable:false` and a hint naming the cause; `swx_status`+reports `abAvailable` up front; and `live-smoke` SKIPS the ab-dependent checks with a clear note+rather than failing them.++## Build notes — 2026-09-03 (round 11: live run 3)++**125 passed, 5 failed** (22-and-aborted → 120/9 → 125/5). The ownership fix held: `save_as`+retitles and the document stays ours, so everything the disown-on-save cascade had blocked now+runs — `CreateCircleByRadius`, `FeatureCut4` and `SetUserPreferenceInteger`, all three previously+shipped-but-never-executed, plus complete file cleanup.++### The bug: `swx_import` registered ownership on the server but not on the host++Three of the five failures were this one cause. `cmd_import` has THREE success paths — LoadFile4+returning a dispatch, a handle recovered from ActiveDoc, and the LoadFile2 fallback — and only+the first called `remember_created`. The live machine took one of the others, so the host's+independent veto refused to close the document the bridge had just imported.++Same shape as run 2's bug, one layer down: an ownership record that does not follow the document+through an operation the bridge itself performed.++**The fix is structural, per the reviewer's ask.** Registration is no longer a per-verb call. The+dispatch loop reads the `{created}` / `{imported}` document out of any successful result and+registers it via `Backend::register_created`, so no branch of no command can forget — and a verb+added tomorrow is registered by existing into the same result shape. `opened` is deliberately NOT+in `CREATED_KEYS`: opening the USER'S file does not make it ours, and a mutation adding it fails+two tests.++That is the third time a defect has come from identity being handled per-site rather than in one+place. The pattern across runs 1-3 is worth stating plainly: **all three live defects were+ownership records failing to follow a document through an operation the bridge performed**, and+none was a safety failure — the deny-by-default posture held throughout, and in every case the+bridge failed CLOSED, refusing to touch a document rather than touching the wrong one.++### A test-isolation defect found while fixing it++Two raw-stdio host tests spawned a com host with no `SWX_SCRATCH_DIR`, so they used the+developer's real scratch root — and the com host PERSISTS its created-document record. They+therefore inherited whatever had run before them, and passed or failed by accident; a mutation+run was what exposed it. Both have isolated scratch dirs now, and the suite is verified+repeatable across consecutive runs.++### The ab surface is now honestly reported as untested++The last two failures were deployment, not the bridge: a hand-launched exe never inherits+`ADOM_DIRECT_API_URL`. The preflight probe and `swx_dismiss_blocking_dialogs` now SKIP with a+note naming the cause, so a hand-launched bridge scores a clean sheet and the ab-delegated+surface reads as UNTESTED rather than broken — which is what it is.++### Re-grading++Nineteen verbs move to ✅ live-proven on run-3 evidence. Two that the evidence does NOT support+were held back: `fusion_close_window` (its ab path was SKIPPED, not exercised) and `fusion_state`+(it ran with `screenshot:false`, so the render-me half is still untested). Overclaiming those+would be exactly the failure this report exists to avoid.++## Build notes — 2026-09-03 (round 12: the launch answer, and an escape hatch nobody could open)++Three defects and one capability. Version **0.3.1** — a new verb and a new capability+change the surface, so lockstep moved.++### The gate was closed in the wrong direction++Drew authorized closing every leftover document from three live runs, including his own+blank `Part1`. The bridge was restarted with `SWX_ALLOW_USER_WRITES=1`, every call+carried `allowUserWrites` + `confirm` + `reason`, and it closed **3 of 5**:++- `swx_close_doc` → *"the com host refuses to close_doc: this document was not created+  by this bridge"*+- `swx_close_all_documents {closeUnsaved:true}` → skipped the dirty foreign documents+  unconditionally+- `swx_stop {force:true}` → `success:true, stopped:false`, declined silently++Twelve rounds have been spent making sure this bridge cannot write to somebody's data by+accident. This round is the other half of that, and it took three live failures to see+it: **an escape hatch nobody can open is not a safety property, it is a bug.** Every one+of these had the same cause — the server AUTHORIZED the action and then failed to tell+the host, or told it something weaker than what it had checked itself.++`swx_close_doc` built a `Grant` only on the `save:true` branch, so `close_doc+{save:false}` on a foreign document reached the com host carrying no evidence of the+permission at all; the host, holding its own independent veto, correctly refused. And the+host's veto re-checked `allowUserWrites` **alone** while the server checked all three+elements — so "two independent vetoes" was not two applications of one test, it was a+strong test and a weak one that happened to disagree in the direction that blocked the+user. Both sides now call `writes::missing_opt_in`, one function, and a `Grant` carries+the whole chain to the host so it has the same evidence to re-check.++`swx_stop` was the same class of dishonesty pointed the other way: the host does the+right thing (it re-attaches after `ExitApp` and reports that SOLIDWORKS is still there)+and the server dressed that up as a success. It is now `host_app_stop_declined`, with the+host's own reason preserved and a hint that points at the unanswered *"Save changes?"*+modal — explicitly **not** at `swx_kill`, which would discard exactly the work the dialog+is asking about.++### Two more found while proving the fixes++**A refused bulk close was closing things.** `swx_close_all_documents` ran its discard+loop and only then asked whether it was allowed to end the session — so in the default+posture it closed the bridge's own dirty documents, discarding their contents, and+returned a refusal. Side effects on the way to "no". Authorization moved to the top,+where it also supplies the grant the per-document closes need; the reordering is now+structurally enforced, because a mutation that moves it back **does not compile**.++**A document SOLIDWORKS will not answer for was being called clean.** The dirty flag was+read with `unwrap_or(false)`, so a document whose state could not be established never+entered the discard loop, `CloseAllDocuments(false)` then left it alone because it did in+fact need saving, and it came back in the host's `remaining` — left open by a call told to+close everything, with nothing anywhere saying why. That is one of the two documents live+run 3's cleanup could not shift. Same rule as everywhere else now: an unanswerable+question is not permission. Every document still open when the verb returns is named in+`skipped` with a reason, reconciled from the host's own after-the-fact view rather than+from the server's expectations.++The mock could not report unknown dirtiness at all, which is why that guard had no test —+the fourth time this round-by-round pattern has repeated: **the mock modelled the easy+case and hid a real defect.**++### THE LAUNCH ANSWER++For two rounds this bridge reported that SOLIDWORKS Connected "cannot be launched+programmatically", on live evidence: `CoCreateInstance` spawns a process that puts up+*"SOLIDWORKS Design must be launched from the 3DEXPERIENCE Platform"* and never attaches.+The evidence was real and the conclusion was wrong, because it was drawn from the wrong+experiment. The Start-Menu shortcut the Platform installs does not run `sldworks.exe`:++```+CATSTART.exe -run "SWXDesktopLauncher.exe"+             -object "--AppName=\"SWXCSWK_AP\" -tenant=<TENANT> -monoapp+                      -3DRegistryURL=https://<region>-makers-registry.3dexperience.3ds.com"+             -nowindow+```++The refusal was **ours**, for bypassing the launcher chain. `swx_start` now invokes that+shortcut — deliberately the `.lnk` itself and never a hand-assembled CATSTART command+line, because the shortcut is the sanctioned artefact and carries that user's own tenant,+whereas a command line we built would be a guess at it.++Design notes worth keeping: the shortcut is chosen by a **ranked** pure function, not+"first `.lnk` found", because a Start-Menu group holds an uninstaller and a pile of side+tools next to the application, and no shortcut at all resolves to `Blocked` (which asks+the user) rather than to a guess. The route decision does not require `installed`, since a+shortcut IS evidence of an install and the exe globs miss the Connected layouts. And the+attach poll is **bounded** — a cold Connected start runs 1-3 minutes and the com host is+the server's only channel, so holding it would freeze `swx_progress` and every other verb;+the first version waited 45 seconds and did exactly that to its own test suite. It answers+`started:true, stillLaunching:true`, never a failure, because a failure invites a second+launch and that means two sign-in windows on somebody's desktop.++`host_app_launch_blocked` now means one thing only: **no shortcut could be found.**++### `swx_run_macro` — scaffolding, labelled as such++`ISldWorks::RunMacro2`, written from the documented signature. NOT run live; the response+says `provenLive:false` and the report grades it accordingly, because that line is the only+thing this report is for.++Its gate is the interesting part. Every other write here is bounded by two questions — is+the document ours, is the destination clear — and a macro answers neither: it is a VBA+project with the whole API in scope and the filesystem behind it. So `Kind::RunMacro` is+**always gated with no carve-out**, and gated *first*, before even the existence check, so+an unauthorized caller does not learn what is on somebody's disk. What is being authorized+is arbitrary code execution on a person's desktop, and the only honest gate for that is the+human saying so each time.++The bundled `resources/macros/adom-hello.swp` is a placeholder that says so in its own+comments. The real template will be **recorded** from SOLIDWORKS' macro recorder — the only+way to be sure of the module and procedure names it expects — and notably the obvious+hello-world, `SendMsgToUser2`, raises a modal, which this bridge must never do.++### Verification++61 verbs · 0.3.1 in lockstep · lib 74 · e2e 28 · protocol 11 (+1 ignored) · 0 failed ·+zero warnings on both targets · 3 consecutive clean runs · **14 mutations, 14 killed**+(one of them uncompilable, which is stronger than a test).++`tools/live-smoke.py` no longer aborts when the write opt-in is on — it could not+otherwise test the paths this round fixed — and every posture-sensitive check is explicitly+two-sided. It proves the launch route was FOUND but never fires it, because firing the+launcher while SOLIDWORKS is up is the one thing that must not happen; and there is no+posture in which it executes a macro.

@@ -0,0 +1,546 @@+# SOLIDWORKS ↔ Fusion 360 bridge — parity report++**swx v0.3.0** vs the Adom Fusion 360 bridge v1.9.341 · written 2026-09-02++Drew asked for three things: open an existing file, create a new one, and *"learn EVERY capability of+the Fusion bridge, build a SW alternative for all of them, and tell me what is lacking when done."*+This is the third part. Every one of the **133 entries** in the Fusion bridge's `describe.py` catalog+(**132 real verbs** plus one documentation pseudo-entry, `fusion_open_by_urn_note`, which+`fusion_describe` filters out) is+below with a verdict. Nothing is claimed that was not observed — and the grading distinguishes+"the verb ran" from "the COM call underneath it ran", because on this build those are very different+things.++## The scoreboard++| Verdict | Count | Means |+|---|---:|---|+| ✅ **built, live-proven** | 19 | The SOLIDWORKS verb itself was RUN against the user's live install and did what it claims. |+| 🔬 **primitive proven live; verb never run** | 1 | The COM call underneath was executed live and returned what the code expects — but the verb itself has not run. |+| 🧩 **built, no COM involved** | 6 | Built and mock-tested, and makes no COM call at all — there is nothing a live SOLIDWORKS could add. |+| ⚠️ **built, mock-only** | 10 | Shipped and mock-tested; not executed live in any form. |+| 🔄 **adapted** | 5 | Built, deliberately different — the Fusion design does not transfer. Each says why. |+| ⛔ **refused by SOLIDWORKS** | 1 | Attempted live; SOLIDWORKS itself refuses it on this edition. |+| 🚫 **declined by design** | 2 | Buildable; not built, as a decision about etiquette rather than an absence of API. |+| ❌ **lacking** | 38 | Would make sense; not built. Each says what it would take. |+| ➖ not applicable | 51 | Fusion Electronics, EAGLE libraries, Autodesk MCP/installer — no SOLIDWORKS concept to bridge to. |++The SOLIDWORKS bridge ships **60 verbs**. The Fusion bridge advertises **57** in its `bridge.json`;+its `describe.py` catalog contains **133** entries, of which **132 are real verbs** — the odd one out+is `fusion_open_by_urn_note`, a documentation pseudo-entry that `fusion_describe` filters out of its+own output. Both numbers are below, and `describe.py` is the exact source. The gap is almost entirely **Fusion Electronics**: schematics, PCBs, EAGLE `.lbr` libraries,+Gerbers, 3D packages — 60+ verbs of an application SOLIDWORKS simply is not.++**The ✅ column now means what it says.** After three live runs against Drew's SOLIDWORKS Design+Professional for Makers 2026 — 22-and-aborted, then 120/9, then **125 passed / 5 failed** — nineteen+verbs have been executed end to end on real hardware, including the whole+create → model → inspect → export flow this bridge exists for. What remains ⚠️ is genuinely+untested: the assembly verbs (no assembly with components could be built on this edition),+`swx_stop`/`swx_kill` (deliberately never run against a live session), and the ab-delegated window+and dialog verbs (the dev bridge was launched by hand, so it never inherited ab's direct-API+environment — those are reported as SKIPPED, not passed).++## Live-run status — read this before trusting a ✅++🔬 means: **the exact COM call was executed against the user's live SOLIDWORKS Design Professional for+Makers 2026 (3DEXPERIENCE R2026x, sldworks.exe 34.3.0)** during this build, through the v0.2 bridge's+`swx_com_eval` escape hatch, and returned what the v0.3 code expects. That is how all four v0.2 bugs+below were found. It is real evidence, and it is **not** the same as the verb having run.++✅ is reserved for the handful of verbs whose v0.3 code path was itself exercised live — which today+means the v0.2 verbs that ran during the probe session and are unchanged.++**This has now happened.** Three live runs (2026-09-03) drove the v0.3 binary against the real+application. What follows is the record of the first attempt, kept because it is where the+edition-launch constraint was found:++1. Closing a stuck SOLIDWORKS modal (one my own export probe had raised) took SOLIDWORKS down with it.+   No documents were open and nothing was lost.+2. Attempting to restart it exposed the launch constraint below; the resulting refused instance was+   identified by pid and removed, clearing the modal from the user's screen. Shortly after, the desktop+   disconnected from the ab relay entirely.++`tools/live-smoke.py` is the suite that closes this gap. It builds a real solid, reads the geometry back,+exports eight formats, checks the bytes on disk, and asserts SOLIDWORKS ends with **exactly** the+documents it started with. Run it once the desktop is back and SOLIDWORKS has been started from the+3DEXPERIENCE Platform:++```bash+python3 tools/live-smoke.py+```++## The four v0.2 bugs the live probes found++All four shipped in v0.2 and all four were invisible to 49 passing mock tests. This is the argument for+live validation, stated as evidence rather than as a principle.++**One caveat that applies to two of these.** The live byte counts quoted below (a 15,836-byte STEP, a+22,304-byte IGES) came from probes using `Silent` ALONE — which is precisely how the rename bug was+found. The shipped fix uses `Silent|Copy`, and **no export has ever run with those options**; it is+also unknown whether Copy mode is valid for PDF/PNG/JPG/TIF. So bugs #1 and #2 are DIAGNOSED with live+evidence and FIXED on reasoning, not fixed-and-verified. `tools/live-smoke.py` asserts+`saveErrorCode==0`, `documentRenamed==false` and an unchanged document title for every format, which+is what will settle it.++| # | Bug | Symptom | Fix |+|---|---|---|---|+| 1 | `SaveAs3` returns `swFileSaveError_e` (a long, `0` = success), **not a bool** | Every successful export reported `success:false` while writing perfectly good bytes. Probes wrote a 15,836-byte STEP and a 22,304-byte IGES that the bridge called failures. | Read the return as an error code; decode the bit flags into English. |+| 2 | Exports used `swSaveAsOptions_Silent` (1) alone | Silent **renames the open document**: the user's `bracket.sldprt` silently became `bracket.step` in memory. Observed live — a scratch part came back titled `probe.SLDPRT` after an export. | Exports now pass `Silent\|Copy` (3) and the verb asserts the title survived (`documentRenamed`). Only a deliberate `swx_save_as` uses plain Silent. |+| 3 | `InterferenceDetectionManager` was looked for on `ModelDocExtension` | It is a member of **`IAssemblyDoc`**. Every interference check failed with "unavailable". | `$doc.InterferenceDetectionManager()` — confirmed live to return the object. |+| 4 | `Feature::GetErrorCode2(bool, byref BSTR)` | Uncallable late-bound on this build at any arity, so the feature walk hit its error branch for **every** feature: an empty assembly reported 16 "errors". | `GetErrorCode()` (no arguments) — confirmed live to return 0 — plus `Extension.GetWhatsWrongCount()` as a cross-check. |++## What five rounds of adversarial review found — and the design change that ended it++Worth stating plainly, because it calibrates everything above: the safety guarantees this bridge+advertises were each wrong at least once, and were caught by review rather than by the test suite.++| Round | Found | Severity |+|---|---|---|+| 1 | VARIANT double-free — every BSTR/IDispatch argument freed twice (heap corruption on the first real `swx_open`) | Critical |+| 2 | The VRML block tested the `format` argument; `SaveAs3` keys off the destination EXTENSION, so the per-format aliases could never trigger it. `swx_run_script` silently built geometry into the user's open document. The DSL's `save_as` bypassed path validation and renamed in place. Dialogs were closed without proving they belonged to SOLIDWORKS. | 3 Critical, 2 High |+| 3 | **`targetDocument` authorized one document and the bridge mutated another** — the gate resolved ownership from it, but only one verb forwarded it, so the com host fell back to ActiveDoc and `swx_save_as` renamed and relocated the user's part. Ownership also failed OPEN on title reuse (SOLIDWORKS restarts its `Part1` numbering every session). `swx_open` and `swx_com_eval` were unguarded roads to the same COM calls. | 2 Critical, 4 High |+| 4 | **A title is not an identity.** Ownership was `(title, session)` and the host preferred the title over the path — so with the user's `C:\users\thing.sldprt` and the bridge's `C:\bridge\thing.sldprt` both open, a `save_as` authorized against the bridge's copy renamed the USER's, with no confirmation. `swx_close_doc` turned out to resolve no target at all and discarded their dirty document. | 2 Critical |+| 5 | **`swx_close_doc {save:true}` was an ungated `Save3`** — the same call the gated `swx_save` makes — which chained with the deliberately-ungated `swx_props_set` to write bridge-authored data into the user's file. And `save_as`/`export`/`pack_and_go` had **no overwrite protection at all**, silently destroying existing files; the modelling DSL had shipped that exact guard, in one of four places. | 2 Critical, 4 High |++Every one of those defects is in **one surface**: the bridge writing to something the user owns,+through a route whose guard had been forgotten. Every one was **a guard that existed and could be+walked around**, never a guard nobody had thought of — and three times the fix itself introduced the+next one.++### The design change++After five rounds, gating routes was abandoned as a strategy, because there is always another route.+**Writes are now DENY-BY-DEFAULT at a single choke point** (`src/writes.rs`). `save`, `save_as`, all+ten `export` aliases, `bom {format:"csv"}`, `pack_and_go`, `close_doc`, `props_set`,+`set_parameter`, `set_preference`, `run_script`, `rebuild_check`, `stop` and+`close_all_documents` all pass through one function that refuses unless **both**:++1. the document is one this bridge created, **in this SOLIDWORKS session**, and+2. the destination path **does not already exist**.++The only way past is an opt-in a caller cannot grant itself: the process must be started with+`SWX_ALLOW_USER_WRITES=1` **and** the call must carry `allowUserWrites:true`, `confirm:true` and a+`reason`. Every granted exception is recorded in `swx_action_ledger`, and `swx_status` /+`swx_describe` report `userWrites`.++Crucially the **com host enforces the same two rules independently, on its dispatch loop** — it keeps+its own record of the documents it created, reads the opt-in from the environment it inherited, and+refuses any command not on its read-only list. Rounds 3, 5 and 6 all turned on that split; round 6+found the first version of the host veto covering a remembered list of seven commands, so a forged+`run_script` sketched and extruded into the user's document while a forged `save` was correctly+vetoed. Keying off what is SAFE rather than what is dangerous makes a new command deny-by-default.++What the default posture still does, fully: read and inspect everything, create documents, model in+them, and export to paths that do not exist yet. What it cannot do is touch data the user already+had. That is the trade this bridge should have started with, and it is the honest answer to a defect+class that survived four separate attempts to fix it one route at a time.++An eighth round found `swx_close_window` closing the user's "Save changes?" modal in the default+posture — the one verb among the session-enders with neither the choke point nor the+`neverAutoAnswer` refusal its own sibling had, and advertised as `closable:true` by+`swx_window_info`. Alongside it: `is_frame_window` exempted an EMPTY window class (inverting its own+fail-safe), `swx_open {readOnly:false}` took a write lock on the user's file ungated, and+`swx_screenshot` forwarded a free-text title to ab so it would capture any window on the desktop.++A seventh round found the write surface verifiably closed — every mutating command forged over raw+stdio was refused by the host's own veto — and the remaining hole in **the half of the bridge that+never speaks to the com host**: `swx_kill` force-killed SOLIDWORKS in the default posture on gates it+could write for itself, and `swx_close_window` would close the application FRAME, because+`ownerConfirmed` is true precisely when a window is most provably SOLIDWORKS' and the main window is+the most provable there is. Both now go through the choke point; a frame is refused outright.++A sixth round found the design was right but **incompletely applied**: `authorize` was wired+into seven verbs while `swx_bom {format:"csv"}` (a SERVER-side `std::fs::write` that overwrote an+existing file and reported success), `swx_props_set` and `swx_rebuild_check` wrote around it, and the+host's veto covered a remembered list rather than everything. All are fixed, with one regression test+per route.++None of this replaces running `tools/live-smoke.py`. "The author says it is safe" has been the+weakest evidence in this project five times running.++## What the three live runs proved++| Run | Result | What it established |+|---|---|---|+| 1 | 22 passed, **aborted** | The safety machinery works on real hardware: Drew's own `Part1` was open, the suite created its own document, never touched his, aborted on the first failure, removed every file it wrote, and `swx_reset_workspace` reported his document `skipped: "not created by this bridge in this SOLIDWORKS session"`. Also confirmed the Connected edition cannot be launched programmatically. Found: an unsaved document was unaddressable by every verb. |+| 2 | 120 passed, 9 failed | The **create → model → export** flow ran end to end. A 50×30×20 mm solid built and read back at 30000 mm³; material set and mass agreeing (aluminium, 81 g); a dimension driven to 25 mm with the model actually moving; **eight formats exported with real bytes, `saveErrorCode` clean and `documentRenamed:false`** — which is report-bugs #1 and #2 proven FIXED, not merely diagnosed, since the `Silent\|Copy` path had never actually executed before. Found: ownership did not survive the bridge's own `save_as`. |+| 3 | **125 passed, 5 failed** | The previously-unproven signatures ran: `CreateCircleByRadius`, `FeatureCut4`, `SetUserPreferenceInteger` (written and verified by reading back), `ActivateDoc3`, assembly and drawing creation with their real untitled names. Cleanup removed every file it wrote. Found: `swx_import` did not register ownership host-side. |++Measured on that machine, all far inside their `bridge.json` budgets: `run_script` p90 10.2s (budget 420),+`new_document` 9.2s (180), `import` 7.8s (420), `save_as` 2.7s (420).++Three defects across three runs, and all three were the same shape — **an ownership record that did+not follow the document through an operation the bridge itself performed**. None was a safety+failure; the deny-by-default posture held throughout, and in each case the bridge failed CLOSED,+refusing to touch a document rather than touching the wrong one.++## The headline: what SOLIDWORKS genuinely cannot do that Fusion can++### 1. It cannot be launched. (SOLIDWORKS Connected / Makers)++`fusion_start` launches Fusion and waits for its add-in. The SOLIDWORKS equivalent **does not exist on+this edition**. `CoCreateInstance(SldWorks.Application)` returns `CO_E_SERVER_EXEC_FAILURE`+(`0x80080005`), and launching `sldworks.exe` directly produces a process that puts up:++> *SOLIDWORKS Design must be launched from the 3DEXPERIENCE Platform or from the desktop shortcut created+> from the Platform. Do you want to go to the 3DEXPERIENCE Platform?*++…and never becomes a drivable COM server. Verified twice, live. Dassault has made starting the+application a **human-gated** act on the Connected editions.++Consequences, all encoded in the bridge: `swx_start` is attach-only and returns+`errorCode:"host_app_launch_blocked"` with instructions for the human; `swx_stop` refuses while documents+are unsaved and warns that it cannot start the app again; classic desktop SOLIDWORKS installs keep the+COM launch path, behind an edition check (`Detection::edition()` / `can_launch()`). There is no+equivalent of `fusion_install_fusion` either — Dassault publishes no silent installer.++### 2. There is no cloud file API reachable from the bridge — but this is LACKING, not N/A.++Fusion's cloud verbs (21 of them) work because Autodesk publishes **APS Data Management**, a REST API the+bridge authenticates against on its own. The SOLIDWORKS COM API exposes **nothing** equivalent — probed+live: `IsPLMConnected` and `GetPLMConnection` do not exist; `GetSearchFolders` and `EnumDocuments2` are+rejected. `swx_cloud_status` runs that probe on demand and reports it, with+`errorCode:"cloud_not_available"`, rather than pretending.++**What it would take:** 3DEXPERIENCE exposes 3DSpace/3DDrive REST behind a tenant-specific CAS/passport+login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`). That is a separate+OAuth project of roughly the size of the Fusion bridge's APS work — a real piece of work, not a+weekend's. Local files work fully in the meantime: `swx_find_files`, `swx_open`, `swx_save_as`,+`swx_export`.++All 21 cloud verbs are therefore filed **❌ lacking**, not "not applicable". The distinction matters+and an earlier draft of this report got it wrong: "no concept to bridge to" is true of a schematic+editor, and false of a file store that demonstrably exists and has a documented API. Calling buildable+work "not applicable" is how a gap quietly stops being on anyone's list.++### 3. There is no in-process scripting host.++`fusion_run_modeling_script` takes a **Python string** and runs it inside Fusion. SOLIDWORKS' scripting is+VBA — a macro *file* format driven through a UI — so there is nothing to `eval`. `swx_run_script` is a+typed JSON DSL instead. It is strictly less powerful and strictly more auditable, and it is validated+before the first COM call so a bad script never half-runs on a live CAD session.++### 4. There is no official MCP server.++Autodesk ships one and the Fusion bridge proxies it (5 verbs). Dassault ships none. Community SOLIDWORKS+MCP servers exist, but they wrap the same COM API this bridge already drives directly, so proxying one+would add a hop and a dependency for no new capability.++### 5. Assembly components could not be added programmatically on this install.++`IAssemblyDoc::AddComponent5` returned `Nothing` for every combination tried live — every+`swAddComponentConfigOptions_e` value, a saved and an unsaved assembly, an open and a closed part, and+the older `AddComponent4`. No error, no dialog: just nothing. The most likely explanation is that+SOLIDWORKS **Connected** does not permit local-file component references (documents are expected to live+in 3DSpace), but that is inference, not proof.++**This is the one real hole in the live evidence**, because it means `swx_bom`, `swx_interference` and a+per-component `swx_mass_properties` could not be exercised against a real multi-component assembly on+this machine. They remain ⚠️ mock-only. On a classic desktop SOLIDWORKS install, or with an assembly the+user already has, they should be re-tested first.++## What Fusion cannot do that SOLIDWORKS can++Worth stating, because the parity exercise is not one-directional:++- **No add-in to install, update or repair.** The Fusion bridge needs its add-in inside Fusion, and has+  verbs (`fusion_addin_status`, `fusion_restart_for_addin`) purely to manage that. This bridge drives+  SOLIDWORKS entirely out-of-process over COM. Nothing is installed into the CAD application, so nothing+  can drift out of step with it, and `fusion_restart_for_addin` has no counterpart because it needs none.+- **A far richer native export set, with no optimisation service.** Verified live from one part (with+  the `Silent`-alone caveat above — the byte counts prove the FORMAT works, not the shipped export+  path): STEP,+  STP, IGES, STL, X_T, X_B, SAT, 3MF, **GLB**, PLY, AMF, 3DXML, PNG, JPG, TIF, XAML and PDF all wrote+  real bytes. (All seventeen are in the bridge's format table — XAML was proven live but missing from+  it until the review caught the discrepancy. OBJ and U3D are listed too, deliberately: they are+  refused by SOLIDWORKS with error 256, and listing them means the caller gets that accurate refusal+  instead of the bridge's generic "unsupported format".) Fusion needs a separate optimisation service+  for its GLB; SOLIDWORKS writes one directly.+- **Configurations.** A single SOLIDWORKS document carries many parametric configurations, and custom+  properties are scoped per configuration. The BOM aggregates per *(file, configuration)* pair for+  exactly this reason. Fusion has no equivalent first-class concept.+- **Pack and Go.** One call collects a design plus every reference into a portable folder.+- **Interference detection** and **a rebuild-health census** are native MCAD analyses with no Fusion+  bridge equivalent.++## What this bridge will not do, on purpose++These are not gaps; they are decisions, and each has a reason earned during this build.++- **No foreground, no clicks, no keystrokes.** Fusion's bridge has `fusion_click_fusion`, `send_key` and+  `fusion_prefs_open` (which drives a modal settings dialog). This bridge is COM-only. The user is+  working in that application.+- **Dialogs are censused, not dismissed.** `swx_dismiss_blocking_dialogs` reports by default. Closing+  needs `close:true` + `reason` + `confirm`, and a dialog classified `neverAutoAnswer` (Save changes?,+  Document Recovery, licence) is never closed at all. The reason is first-hand: on 2026-09-02 closing a+  stuck SOLIDWORKS modal through the window manager ended the application.+- **VRML export is blocked outright.** `.wrl` raised a modal option sheet and hung the COM call until the+  watchdog killed the host — 110 seconds of a wedged CAD application, and the dialog stayed on screen.+  `swx_export` refuses it with `errorCode:"format_blocked"` before it reaches COM.+- **Unsaved work is never discarded silently.** `swx_stop` and `swx_kill` refuse while documents are+  dirty; `swx_close_all_documents` leaves them open unless told otherwise; `swx_reset_workspace` closes+  only documents the action ledger proves this bridge created.++## Verb-by-verb++All 133 verbs in the Fusion bridge's `describe.py` catalog, grouped by its own sections.++### A. Lifecycle & app state — 15 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_addin_status` | ➖ not applicable | — | As above — no add-in, so no add-in health. `swx_status.com.attached` is the equivalent liveness fact. |+| `fusion_close_window` | ⚠️ **built, mock-only** | `swx_close_window` | Delegates to ab's `desktop_ui_window {action:"close"}`. Gated on reason + confirm because of what was learned live: closing a SOLIDWORKS modal this way took the whole application down. |+| `fusion_demo` | ❌ **lacking** | — | A guided tour verb. Deferred to v0.4 — worth having once the verb surface settles. |+| `fusion_demo_progress` | ❌ **lacking** | — | Companion to fusion_demo. |+| `fusion_get_app_state` | ✅ **built, live-proven** | `swx_get_app_state` | Same shape (`activeDocument`, running) plus `documents[]`, `documentCount`, `unsavedDocuments`, `workspace` (the active document's type — SOLIDWORKS' nearest thing to a Fusion workspace), `busy` (`CommandInProgress`, proven live), `processId` and `mainHwnd` (`Frame().GetHWnd()`, proven live → 1836650). **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_install_fusion` | ➖ not applicable | — | Autodesk publishes a silent Client Downloader; **Dassault publishes no equivalent**. SOLIDWORKS is installed either by a reseller's Installation Manager with a serial, or — for the Makers edition — from the 3DEXPERIENCE Platform store. There is no unattended install to wrap. |+| `fusion_kill` | ⚠️ **built, mock-only** | `swx_kill` | `taskkill /F /IM SLDWORKS.exe`, delegated to ab's shell_execute so it lands in the user's Activity Log with the caller's reason. Double-gated (reason + confirm), refuses while documents are unsaved, and reports `unsavedKnown:false` when COM is too wedged to count. **Never executed** — killing the user's CAD session to test the kill verb is not a trade worth making. |+| `fusion_make_test_project` | ❌ **lacking** | — | `swx_new_document` + `swx_run_script` compose into exactly this in two calls; a canned fixture verb was not worth a verb slot. |+| `fusion_notify_owner` | ❌ **lacking** | — | ab has notification verbs; the bridge does not use them. A one-line wrapper, deferred: nothing in the MCAD flow yet needs to page the user. |+| `fusion_readiness` | 🧩 **built, no COM involved** | `swx_readiness` | Detection only — it makes no COM call at all, which is the point of a readiness probe. v0.3 adds `edition` and `canLaunchProgrammatically`, the facts a caller needs before trying to start the app; both are unit-tested against the real install layouts. |+| `fusion_restart_for_addin` | ➖ not applicable | — | This bridge ships **no add-in**. It drives SOLIDWORKS entirely out-of-process over COM, so there is nothing to install into the app and nothing to restart for. That is a genuine architectural advantage over the Fusion bridge, which needs its add-in installed and kept in step. |+| `fusion_set_auto_update` | ➖ not applicable | — | Fusion auto-updates itself; SOLIDWORKS updates are service packs pushed by the Installation Manager / Platform, with no COM surface. |+| `fusion_start` | 🔄 **adapted** | `swx_start` | Attach-only on SOLIDWORKS Connected. **This is the single biggest divergence.** `CoCreateInstance(SldWorks.Application)` spawns an sldworks.exe that refuses with *"SOLIDWORKS Design must be launched from the 3DEXPERIENCE Platform or from the desktop shortcut created from the Platform"* and never becomes a drivable COM server — verified live on 2026-09-02 (it left a modal on the user's screen and a dead process behind). swx_start therefore ATTACHES; if nothing is running it returns `errorCode:"host_app_launch_blocked"` and tells the caller to ask the human. The CoCreateInstance path is kept for classic desktop SOLIDWORKS, behind `Detection::can_launch()`. |+| `fusion_stop` | ⚠️ **built, mock-only** | `swx_stop` | `ExitApp`. **Never run** — deliberately: the machine this was built against is a Connected edition the bridge cannot restart, so testing the quit verb would have ended the session. v0.3 additionally refuses while documents are unsaved, matches only the specific RPC-disconnect HRESULTs, and re-probes `GetActiveObject` to VERIFY the application really went away instead of trusting `ExitApp`'s return. |+| `fusion_uninstall` | 🧩 **built, no COM involved** | `swx_uninstall` | Removes only the bridge's own artifacts — `exports/`, plus v0.3's `ledger.jsonl`, `timings.json`, `settings.json` — never ab's cache root, never SOLIDWORKS.. Touches only the bridge's own scratch directory. The v0.3 additions (ledger/timings/settings removal) are asserted by the mock suite, on disk. |++### B. Documents & modelling — 13 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_activate_document` | ✅ **built, live-proven** | `swx_activate_document` | `ActivateDoc3(name, false, 0, byref errors)`. Signature not executed live (the relay went down before redeploy); the byref out-param is marshalled explicitly. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_assembly_bom` | ⚠️ **built, mock-only** | `swx_bom` | Quantities per (file, configuration) with custom-property columns, JSON or CSV. **Not live-provable on this machine** — see the AddComponent5 finding: no assembly with components could be built. |+| `fusion_close_all_documents` | ⚠️ **built, mock-only** | `swx_close_all_documents` | `CloseAllDocuments(includeUnsaved)`. Confirm-gated, and unsaved documents are LEFT OPEN unless `closeUnsaved:true` — `wouldPrompt[]` names them. Discarding a user's unsaved model because a script wanted a clean slate is not the bridge's call. |+| `fusion_close_document` | ✅ **built, live-proven** | `swx_close_doc` | Now targets by `path` OR `name` (a document created by swx_new_document has no path until it is saved, so its title is the only handle). **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_document_info` | ✅ **built, live-proven** | `swx_document_info` | `name`/`productType`/`isSaved` mirrored, plus `configurations`, `customPropertyCount`, `needsRebuild`, `dirty`. `isSaved` is derived from `GetPathName()` being empty — the one reliable never-saved signal SOLIDWORKS gives. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_execute_text_command` | 🔄 **adapted** | `swx_com_eval` | Fusion's raw internal-command escape hatch; ours is a late-bound `$sw`/`$doc` call chain with string/number/boolean/**null** literals (null added in v0.3 for optional object params). Reason-gated. This is what every live finding in this report was discovered with. |+| `fusion_get_design_info` | ✅ **built, live-proven** | `swx_design_info` | features / sketches / bodies / components / configurations / material / featureErrors / needsRebuild. Every underlying call was run live. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_get_parameters` | ✅ **built, live-proven** | `swx_get_parameters` | Two sources merged: the equation manager (`GetEquationMgr`, live) for global variables, and named dimensions (`Parameter("D1@Boss-Extrude1").SystemValue` → 0.02, live) for model dimensions. Values in SI metres AND `valueMm`. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_inspect_bodies` | ✅ **built, live-proven** | `swx_inspect_bodies` | `GetBodies2(0,true)` proven live (returned 1 body on the built solid). Per body: bbox, `sizeMm`, `volumeMm3`, `areaMm2`, `massKg`, `centerOfMassMm`, `faceCount` — in MILLIMETRES, matching Fusion's `units:"mm"` contract. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_open_design` | ✅ **built, live-proven** | `swx_open` | `OpenDoc6` with `swOpenDocOptions_Silent`. Ran live and unchanged in v0.3. Arg is `path`; `filePath` is the spelling on `swx_import`. |+| `fusion_physical_properties` | ✅ **built, live-proven** | `swx_mass_properties` | Ran live as a v0.2 verb and is unchanged in v0.3: the 50×30×20 mm test box read back 3.0e-5 m³ and 0.03 kg at density 1000, then 0.081 kg at 2700 after `SetMaterialPropertyName2`. SI units (kg/m³/m²/m), not Fusion's cm³/cm². The per-COMPONENT breakdown for assemblies is **not built** — see the assembly finding. |+| `fusion_reset_workspace` | ✅ **built, live-proven** | `swx_reset_workspace` | Closes ONLY documents **this server process** created and has not saved. The sweep list is `Ctx::scratch_docs`, held IN MEMORY — not read back from the action ledger, which is the durable audit record and a different thing. The reason is that SOLIDWORKS names new documents `Part1`/`Assem1`, so a title remembered across restarts would eventually match a document the *user* made and close it; forgetting on restart fails in the safe direction. `titles:[...]` to be surgical, `skipped[]` says why each survivor survived. Stronger than Fusion's "close the Untitled scratch" heuristic. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_run_modeling_script` | 🔄 **adapted** | `swx_run_script` | Fusion evaluates a **Python string** because Fusion hosts Python in-process. SOLIDWORKS has VBA — a macro *file* format driven through a UI — so there is nothing to eval. Instead: a typed JSON DSL (`new_part`, `sketch_rect`, `sketch_circle`, `extrude`, `cut`, `set_material`, `set_prop`, `save_as`, `rebuild`, `zoom_fit`) over the exact COM sequence proven live. Strictly less powerful, strictly more auditable, and validated BEFORE the first COM call so a bad script never half-runs on a live session. |++### C. Export & import — 15 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_export_3mf` | ✅ **built, live-proven** | `swx_export_3mf` | LIVE: 6,672 bytes. **Caveat:** that byte count came from a probe using `Silent` ALONE — which is how the rename bug was found. The shipped path uses `Silent|Copy`, and **no export has ever run with those options**; whether Copy is even valid for PDF/PNG/JPG/TIF is unknown. `tools/live-smoke.py` asserts `saveErrorCode==0`, `documentRenamed==false` and an unchanged title for every format. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_export_dwg` | ⚠️ **built, mock-only** | `swx_export_dwg` | Same as DXF. |+| `fusion_export_dxf` | ⚠️ **built, mock-only** | `swx_export_dxf` | Alias ships. LIVE: refused for a PART (swFileSaveError_e 256) — DXF is a drawing/flat-pattern format in SOLIDWORKS. Expected to work from a `.slddrw`; **untested**, because no drawing was available. |+| `fusion_export_f3d` | ➖ not applicable | — | Autodesk's native archive format. |+| `fusion_export_fbx` | ❌ **lacking** | — | No FBX translator surfaced. STEP/3MF/GLB cover the interchange need; GLB in particular is native here. |+| `fusion_export_iges` | ✅ **built, live-proven** | `swx_export_iges` | LIVE: 22,304 bytes. **Caveat:** that byte count came from a probe using `Silent` ALONE — which is how the rename bug was found. The shipped path uses `Silent|Copy`, and **no export has ever run with those options**; whether Copy is even valid for PDF/PNG/JPG/TIF is unknown. `tools/live-smoke.py` asserts `saveErrorCode==0`, `documentRenamed==false` and an unchanged title for every format. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_export_obj` | ⛔ **refused by SOLIDWORKS** | `swx_export {format:"obj"}` | REFUSED by SOLIDWORKS for a part on this edition — `SaveAs3` returned swFileSaveError_e 256 and wrote nothing. `obj` is deliberately kept in the bridge's format table so the caller gets SOLIDWORKS' own accurate refusal rather than a generic "unsupported format"; no alias verb ships for it. |+| `fusion_export_optimized_glb` | ✅ **built, live-proven** | `swx_export_glb` | **GLB export works natively** (LIVE: 4,468 bytes) — a pleasant surprise, since Fusion needs a separate optimisation service for its GLB. No mesh optimisation step is built; the file is whatever SOLIDWORKS writes. **Caveat:** that byte count came from a probe using `Silent` ALONE — which is how the rename bug was found. The shipped path uses `Silent|Copy`, and **no export has ever run with those options**; whether Copy is even valid for PDF/PNG/JPG/TIF is unknown. `tools/live-smoke.py` asserts `saveErrorCode==0`, `documentRenamed==false` and an unchanged title for every format. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_export_sat` | ✅ **built, live-proven** | `swx_export_sat` | LIVE: 5,960 bytes. **Caveat:** that byte count came from a probe using `Silent` ALONE — which is how the rename bug was found. The shipped path uses `Silent|Copy`, and **no export has ever run with those options**; whether Copy is even valid for PDF/PNG/JPG/TIF is unknown. `tools/live-smoke.py` asserts `saveErrorCode==0`, `documentRenamed==false` and an unchanged title for every format. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_export_skp` | ❌ **lacking** | — | No SketchUp translator surfaced on this install. Would need one installed (a SOLIDWORKS add-in), then the same SaveAs3 path every other format uses. |+| `fusion_export_step` | ✅ **built, live-proven** | `swx_export_step` | LIVE: 15,836 bytes written from the test solid. **Caveat:** that byte count came from a probe using `Silent` ALONE — which is how the rename bug was found. The shipped path uses `Silent|Copy`, and **no export has ever run with those options**; whether Copy is even valid for PDF/PNG/JPG/TIF is unknown. `tools/live-smoke.py` asserts `saveErrorCode==0`, `documentRenamed==false` and an unchanged title for every format. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_export_stl` | ✅ **built, live-proven** | `swx_export_stl` | LIVE: 684 bytes. **Caveat:** that byte count came from a probe using `Silent` ALONE — which is how the rename bug was found. The shipped path uses `Silent|Copy`, and **no export has ever run with those options**; whether Copy is even valid for PDF/PNG/JPG/TIF is unknown. `tools/live-smoke.py` asserts `saveErrorCode==0`, `documentRenamed==false` and an unchanged title for every format. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_export_usdz` | ❌ **lacking** | — | No USD translator on this install. GLB (proven live, 4,468 bytes) is the AR/web-viewer route instead. |+| `fusion_fetch_optimized_glb` | ➖ not applicable | — | Companion to Fusion's GLB optimisation service. |+| `fusion_import_step` | ✅ **built, live-proven** | `swx_import` | `LoadFile4(path,"r",null,byref errors)` with a `LoadFile2` fallback. Arg name `filePath` mirrors Fusion. Not executed live. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |++### D. Introspection, windows & etiquette — 13 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_action_ledger` | 🧩 **built, no COM involved** | `swx_action_ledger` | Append-only `{at, action, detail}` in the bridge's scratch dir. Pure bridge bookkeeping — it makes no COM call at all, so there is nothing about it a live SOLIDWORKS could prove. Exercised by the mock suite; the file it writes is asserted on disk. |+| `fusion_alerts` | ❌ **lacking** | — | Fusion's add-in collects in-app alerts. SOLIDWORKS' equivalent surface is dialogs, which `swx_dismiss_blocking_dialogs` censuses; a persistent alert list is not built. |+| `fusion_cancel_run` | ❌ **lacking** | — | No cancel. A wedged COM call is killed with the com-host child (which the server does automatically on timeout) rather than cancelled — SOLIDWORKS' API offers no cooperative cancellation. |+| `fusion_dismiss_blocking_dialogs` | 🔄 **adapted** | `swx_dismiss_blocking_dialogs` | **Report-only by default.** Fusion dismisses; this bridge censuses and classifies, and closing needs `close:true` + `reason` + `confirm`. Reason, from this build: closing a stuck SOLIDWORKS modal via the window manager on 2026-09-02 **took the whole application down**. A dialog classified `neverAutoAnswer:true` (Save changes?, Document Recovery, licence) is never closed at all. |+| `fusion_live_feed` | ❌ **lacking** | — | A streaming screen feed. `swx_state {screenshot:true}` gives single background frames; a feed is v0.4. |+| `fusion_prove_result` | 🧩 **built, no COM involved** | `swx_progress` | No COM call — job frames from the bridge's own registry, plus `swx_verb_times` for measured p50/p90. Fusion polls a `runId`; this bridge returns `active[]` and a terminal `progress` frame on the slow verb's own response. |+| `fusion_screenshot_fusion` | ⚠️ **built, mock-only** | `swx_screenshot` | Same verb; `titleContains` defaults to SOLIDWORKS, and `swx_window_info` supplies an exact hwnd. |+| `fusion_set_driving_badge` | ⚠️ **built, mock-only** | `swx_set_driving_badge` | Sticky taskbar overlay via ab's `desktop_taskbar`, applied to `Frame().GetHWnd()`. The hwnd source is live-proven; the badge call is not. |+| `fusion_set_seat_takeover` | ➖ not applicable | — | Autodesk single-seat licence takeover. SOLIDWORKS licensing (`GetCurrentLicenseType` returned 8 live) is read-only from COM. |+| `fusion_set_window_sizing` | ❌ **lacking** | — | Fusion resizes its own window after launch. This bridge never launches, moves or resizes SOLIDWORKS' window. |+| `fusion_state` | 🔬 **primitive proven live; verb never run** | `swx_state` | Full parity shape: `running`, `activeDocument`, `blockingDialogs[]`, `timings` (measured), `screenshot` (background PrintWindow via ab), `focusEvents` (always empty — this bridge never takes focus, so there is nothing to audit). `screenshot:false` skips the ab callbacks. |+| `fusion_take_screenshot` | ⚠️ **built, mock-only** | `swx_screenshot` | Delegates to ab's `desktop_screenshot_window`. |+| `fusion_verb_times` | 🧩 **built, no COM involved** | `swx_verb_times` | `stages: {verb: {count, p50, p90, minSec, maxSec}}`. Pure bridge bookkeeping — no COM call. Same standing as the ledger. |++### E. Preferences & MCP — 10 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_get_preferences` | ✅ **built, live-proven** | `swx_get_preferences` | `GetUserPreferenceInteger(53,0)` was read live, but `swx_get_preferences` is NEW v0.3 code that has never executed. Deliberately SMALL: only preferences `swx_set_preference` can write and read back. Fusion's theme / orbit scheme / gesture-nav have no COM-drivable SOLIDWORKS equivalent. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |+| `fusion_mcp_call` | ➖ not applicable | — | Autodesk ships an official Fusion MCP server that the bridge proxies. **Dassault ships none for SOLIDWORKS.** Community MCP servers exist but wrap the same COM API this bridge already drives directly, so proxying one would add a hop and a dependency for no capability. |+| `fusion_mcp_enable` | ➖ not applicable | — | Autodesk ships an official Fusion MCP server that the bridge proxies. **Dassault ships none for SOLIDWORKS.** Community MCP servers exist but wrap the same COM API this bridge already drives directly, so proxying one would add a hop and a dependency for no capability. |+| `fusion_mcp_read` | ➖ not applicable | — | Read one Autodesk MCP resource. Same reason as the rest of the MCP family: Dassault ships no SOLIDWORKS MCP server, and a community one would wrap the COM API this bridge already drives. |+| `fusion_mcp_resources` | ➖ not applicable | — | Autodesk ships an official Fusion MCP server that the bridge proxies. **Dassault ships none for SOLIDWORKS.** Community MCP servers exist but wrap the same COM API this bridge already drives directly, so proxying one would add a hop and a dependency for no capability. |+| `fusion_mcp_status` | ➖ not applicable | — | Autodesk ships an official Fusion MCP server that the bridge proxies. **Dassault ships none for SOLIDWORKS.** Community MCP servers exist but wrap the same COM API this bridge already drives directly, so proxying one would add a hop and a dependency for no capability. |+| `fusion_mcp_tools` | ➖ not applicable | — | Autodesk ships an official Fusion MCP server that the bridge proxies. **Dassault ships none for SOLIDWORKS.** Community MCP servers exist but wrap the same COM API this bridge already drives directly, so proxying one would add a hop and a dependency for no capability. |+| `fusion_prefs_close` | 🚫 **declined by design** | — | As above. |+| `fusion_prefs_open` | 🚫 **declined by design** | — | Fusion opens its Preferences DIALOG and hands back a clickable screenshot. Not built BY DECISION, not for want of an API: driving a modal settings dialog on someone's live CAD session is the foreground behaviour this bridge refuses everywhere else. `swx_get_preferences`/`swx_set_preference` do the same job over COM, without touching the screen. |+| `fusion_set_preference` | ✅ **built, live-proven** | `swx_set_preference` | `ModelDocExtension::SetUserPreferenceInteger`, then READ BACK — `verified` is the field that matters. The getter is live-proven (`GetUserPreferenceInteger(53,0)` → 1); the setter is not. **Live-proven in run 3** (2026-09-03: 125 checks passed against SOLIDWORKS Design Professional for Makers 2026). |++### F. Cloud (APS → 3DEXPERIENCE) — 18 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_aps_browse` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_create_folder` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_download` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_file_info` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_get` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_open` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_recent` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_search` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_upload` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_versions` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_cleanup_cloud_files` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_list_cloud_files` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_list_cloud_projects` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_open_by_urn` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_open_cloud_file` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_save_to_cloud` | ❌ **lacking** | `swx_save_as` (local only) | Local save-as is built; there is no cloud destination to save TO. Same 3DSpace REST project as the rest of the cloud family. |+| `fusion_search_cloud_files` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_walk_cloud_tree` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |++### G. Libraries & 3D packages (Fusion Electronics) — 23 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_attach_3d_package` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_bind_library_3d` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_build_library_3d` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_capture_library_views` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_create_library` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_generate_package` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_install_library_bundle` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_library_manager` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_library_parts` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_make_3d_package` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_managed_library_create` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_managed_library_link` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_managed_library_pull` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_managed_library_push` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_managed_library_unlink` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_open_lbr` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_plan_library_import` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_preflight_lbr` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_3d_package` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_footprint` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_library` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_project` | 🔄 **adapted** | `swx_show_part / swx_show_assembly / swx_show_drawing` | Fusion's eight-surfaces contract, MCAD half only: open + activate + `ViewZoomtofit2` (live-proven) in the BACKGROUND, with `capture:true` for a background screenshot. Refuses with `wrong_document_type` if the target is the wrong kind, which Fusion's single verb cannot do. |+| `fusion_show_symbol` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |++### H. Electronics (schematic / PCB) — 11 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_board_info` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_board_stackup` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_detect_layers` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_electron_pan` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_electron_run` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_electron_select` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_electron_zoom` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_new_electronics_from_eagle` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_2d_board` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_3d_board` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_show_schematic` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |++### I. Manufacturing outputs — 4 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_export_bom` | ➖ not applicable | — | Electronics BOM. `swx_bom` is the mechanical one (Fusion's `fusion_assembly_bom` counterpart). |+| `fusion_export_cpl` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_export_gerbers` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |+| `fusion_set_design_rules` | ➖ not applicable | — | Fusion Electronics / EAGLE library tooling. SOLIDWORKS is a pure MCAD application with no schematic, PCB, or .lbr concept — there is nothing to bridge to. |++### J. Sign-in & licensing — 9 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_aps_forget_browser` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_get_browser` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_set_browser` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_set_client_id` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_signin` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_aps_status` | ❌ **lacking** | `swx_cloud_status` | Not built, and NOT because there is nothing to bridge to — 3DEXPERIENCE has a 3DSpace/3DDrive REST API that does this job. What it would take: an OAuth story against a tenant-specific CAS/passport login (this user's tenant is `oi000616940-usw1-makers-ifwe.3dexperience.3ds.com`), roughly the size of the Fusion bridge's APS work. There is no COM route at all — `swx_cloud_status` runs that probe on demand — so this is a separate project, not a missing verb. |+| `fusion_signin` | ❌ **lacking** | — | Filed as lacking, not n/a, by the same standard applied to the cloud verbs: 3DEXPERIENCE sign-in is a real, documented interface (the Platform launcher and its CAS/passport flow), and it is **the human gate that blocks `swx_start`** — so automating it is the single change that would most improve this bridge, not an absence of concept. What it would take: driving the 3DEXPERIENCE launcher's web sign-in the way the Fusion bridge drives Autodesk's, which is a browser-automation project with real credential-handling consequences. |+| `fusion_signin_2fa` | ❌ **lacking** | — | As above, plus the second factor. |+| `fusion_web_signin` | ❌ **lacking** | — | Autodesk web SSO via a pup browser. The 3DEXPERIENCE equivalent exists and is the door to both the launcher gate and the 3DSpace REST API — the same project, twice over. Not built. |++### K. Self-describe — 1 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_describe` | 🧩 **built, no COM involved** | `swx_describe` | Now also carries `scriptOps` (the modeling DSL's op list) and `exportFormats` (the live-verified format matrix).. Static catalog. The v0.3 additions (scriptOps, exportFormats) are asserted by the mock suite. |++### L. Doc-only catalog entries — 1 verbs++| Fusion verb | Verdict | SOLIDWORKS verb | Notes |+|---|---|---|---|+| `fusion_open_by_urn_note` | ➖ not applicable | — | Documentation pseudo-entry in the Fusion catalog, filtered out of fusion_describe. |++## The SOLIDWORKS verbs with no Fusion counterpart++| swx verb | Why it exists |+|---|---|+| `swx_new_document` | Drew's explicit ask, and Fusion has no twin verb (its documents arrive from the cloud or an import). LIVE-PROVEN recipe: `NewDocument(template,0,0,0)` with the template resolved at runtime — `ISldWorks::NewPart()` **hangs** on this install (>110s, killed by the watchdog). |+| `swx_find_files` | Disk search for `.sldprt`/`.sldasm`/`.slddrw`. Fusion's files are in the cloud, so it needs no such verb; SOLIDWORKS' are on disk, so it is the front door. |+| `swx_pack_and_go` | A SOLIDWORKS-native operation with no Fusion analogue. |+| `swx_interference` | Native assembly interference detection. |+| `swx_rebuild_check` | Force rebuild + a broken-feature census — the design-health first check. |+| `swx_props_get` / `swx_props_set` | Custom properties, per file or per configuration. These drive BOMs and title blocks; Fusion's equivalent is buried in its parameter/attribute model. |+| `swx_save_as` | The verb that gets a `swx_new_document` scratch part onto disk. `copy:true` writes a file without retitling the open document. |+| `swx_export_glb` | Native GLB, no optimisation service required. |+| `swx_cloud_status` | Exists specifically to give the honest 'no, and here is the probe that proves it' answer rather than a silent absence. |++## Recommended next steps++1. **Run `tools/live-smoke.py`** once the desktop is back and SOLIDWORKS has been started from the+   3DEXPERIENCE Platform. That is what converts 🔬 and ⚠️ into ✅ — or finds the next bug. It asserts+   the Silent|Copy fix, the `.wrl` refusal on all five roads to `SaveAs3`, the refusal to touch a+   document the bridge did not create, and — as a hard gate that runs even on an early abort — that+   SOLIDWORKS ends with exactly the documents it started with.+2. **Re-test the assembly verbs on a real assembly** — either one the user already has, or on a classic+   desktop SOLIDWORKS install where `AddComponent5` is expected to work. `swx_bom`, `swx_interference`+   and per-component mass properties all hinge on this.+3. **Test DXF/DWG/PDF export from a `.slddrw`.** They are refused for a part, which is expected; they+   should be the drawing story, and that is untested.+4. **Decide whether 3DEXPERIENCE cloud access is worth the OAuth project.** It is the largest remaining+   gap and the only one that is a matter of effort rather than of what SOLIDWORKS permits.+5. **Per-component mass properties** (`fusion_physical_properties` parity for assemblies) is a small+   addition once an assembly can be built.++## `swx_run_macro` — scaffolding, and labelled as such++Added 2026-09-03. `ISldWorks::RunMacro2(path, module, proc, swRunMacroUnloadAfterRun, [out] error)`,+written from Dassault's documented signature and CodeStack's worked examples — which+confirm both that a `.swp` is plain-text editable and that `RunMacro2` works from a+standalone executable, the two facts this verb depends on.++**It has not been run against a live SOLIDWORKS.** It is graded 🔬 and the response+says so in its own `_hint`, because this report's only value is the line between+"proven live" and "written from documentation". Two details in it are the ones most+easily got wrong, and both are guesses until a live run:++- the error is an **out parameter** (`swRunMacroError_e`), not the return value — the+  return is a bare bool, so a macro that fails to compile comes back `false` with the+  reason only in the out param;+- `swRunMacroUnloadAfterRun` is passed deliberately. Without it the VBA project stays+  loaded and an edited macro keeps running its **old** code, which is indistinguishable+  from the edit not having been saved.++The bundled `resources/macros/adom-hello.swp` is likewise a placeholder and says so in+its own comments. The real template will be **recorded** from SOLIDWORKS' macro+recorder rather than written by hand, because that is the only way to be certain of the+module and procedure names it expects — and because the obvious hello-world+(`SendMsgToUser2`) raises a modal, which this bridge must never do on somebody's desktop.++### The gate is the whole design++Every other write in this bridge is bounded by two questions — is the document ours, is+the destination clear. A macro answers neither: it is a VBA project with the full+SOLIDWORKS API in scope and the filesystem behind it, and nothing about the *call*+predicts what it will touch. So `Kind::RunMacro` is **always gated**, with no safe case+carved out: the process needs `SWX_ALLOW_USER_WRITES=1` and the call needs+`allowUserWrites:true` + `confirm:true` + a `reason`, every time. In the default posture+this verb refuses, always. What is being authorized is arbitrary code execution on+somebody's desktop; the only honest gate for that is the human saying so each time.

@@ -0,0 +1,348 @@+# Rust port brief — solidworks-bridge (swx)++Goal: replace the Python+PowerShell implementation in this repo with a single+Rust binary (`swx-bridge.exe`) of the SAME 23-verb surface and the same+response shapes. Quality bar: the kicad, pup, and native-browser bridges —+rich `_hint`s on every response, honest error codes, background etiquette,+progress blocks, self-cleaning scratch, a suite that cannot lie.++## Why Rust / what the SDK says++Adom Bridge (ab) treats compiled bridges as first-class: `spawn.kind: "exe"`,+ab spawns the entrypoint DIRECTLY appending `--port <port>` to argv (~10ms cold+start, no interpreter provisioning). Contract identical to node/python:++- Parse `--port N` from argv. Bind `ADOM_BIND_HOST` env (always 127.0.0.1;+  default to it when absent). NEVER 0.0.0.0 (firewall prompt).+- Bind the port FIRST, before anything slow. A failed bind = another instance+  owns it → print a line and exit 0 (single-instance guard). No SO_REUSEADDR.+- HTTP: GET `/status` and `/health` → 200 JSON with `{status:"ok", led,+  summary, tooltip, bridgeVersion, solidworks:{...}, mock}`. POST `/command`+  with `{"command":"swx_...","args":{...}}` → JSON result. Unknown path → 404.+- Every response ab relays VERBATIM to the calling AI. The `_hint` on every+  verb response IS the documentation the AI reads. Response contract keys:+  `success`, `errorCode` (stable, branchable — e.g. `host_app_not_installed`,+  `reason_required`), `windowEtiquette: "background"` on anything that touches+  windows, `progress` blocks on slow verbs (terminal frame percent:100 ++  elapsedSec) and a fast `swx_progress` verb returning `active[]` for polling.+- `swx_uninstall`: idempotent, non-interactive, fast; removes ONLY what the+  bridge created (`%LOCALAPPDATA%\Adom Bridge\bridges-cache\solidworks\`), never+  the host app or user docs. ab calls it with `{"cascade":true}` on app uninstall.+- Prune what you write: exports scratch dir capped (48h age, 300 files,+  oldest-first, rate-limited 1/10min).+- Caller identity: ab delivers `args.caller = {aiThread, containerName}` (and/or+  `X-Adom-Caller-*` headers). Log one compact line per verb:+  `[swx] <command> caller="<thread>" | args: {...}` (truncate args ~400 chars).+  Self-asserted — logging/UX only, NEVER authorization.+- Logging volume rules: one line per incoming verb; never per-item in loops;+  never a parallel log file; line-buffered stdout/stderr (ab captures them).+- bridge.json changes for the port: `spawn.kind:"exe"`,+  `entrypoint:"swx-bridge.exe"`, `killImageName:"swx-bridge.exe"`. Keep verbs,+  timeouts, detect, risk, uninstall, updateManifestUrl as-is.++## Architecture (required)++ONE binary, two modes:++1. **Server mode** (default): the HTTP bridge server. tiny_http + serde/serde_json+   (this is what the official hello-rust sample uses; see the size-optimized+   release profile in its Cargo.toml). Verb handlers port 1:1 from the Python+   `server.py` in git history / reference copy — same names, same arg names, same+   response keys, same hints (improve wording freely, never drop information).+2. **`--com-host` mode**: a child process the server spawns FROM ITS OWN EXE+   (`std::env::current_exe()`), speaking the same JSON-lines stdio protocol the+   PowerShell sidecar spoke: `{"id":N,"cmd":"...","args":{...}}` per line in,+   `{"id":N,"ok":true,"result":{...}}` / `{"id":N,"ok":false,"error":"...",+   "detail":"..."}` per line out, plus one `{"event":"ready","pid":N}` line at+   boot. Diagnostics to stderr only.++   WHY a child process and not an in-process COM thread: a wedged COM call+   (modal dialog, hung SOLIDWORKS) cannot be killed as a thread, but the child+   can be killed + respawned. The server owns: lazy spawn, one request in+   flight (mutex), per-request timeout, kill + respawn after crash/hang, stderr+   tail capture surfaced in `detail`. On Windows spawn the child with+   CREATE_NO_WINDOW (0x08000000) — no console may ever blip on screen.++3. **Backend trait** inside com-host mode:+   - `MockBackend` (all platforms; selected by `SWX_MOCK=1` or non-Windows):+     port of `sidecar/mock_host.py` — same canned data (3-row BOM with+     bracket/shaft/m4-screw, qty 2/1/8, mass 0.4173 kg, 1 interference, etc.)+     so the existing HTTP test expectations keep passing.+   - `ComBackend` (cfg(windows)): real COM via the `windows` crate,+     late-bound IDispatch (GetIDsOfNames + Invoke), STA-initialized main+     thread in com-host mode. Sidecar semantics to preserve from the PS+     version: attach via GetActiveObject("SldWorks.Application") first, only+     CoCreateInstance (launch) when `launch:true`; OpenDoc6 with+     swOpenDocOptions_Silent=1 and byref VT_I4 errors/warnings (fall back to+     legacy OpenDoc if it returns null); Save3(1, byref, byref); SaveAs3(path,+     0, 1) keyed off destination extension; CustomPropertyManager("").GetNames /+     Get4(name, false, byref BSTR, byref BSTR) / Add3(name, 30 /*text*/, value,+     2 /*replace*/); CreateMassProperty (Mass, Volume, SurfaceArea, Density,+     CenterOfMass safearray of f64); assembly GetComponents(topOnly) safearray+     of IDispatch → per-component GetSuppression()!=0 filter, GetPathName,+     ReferencedConfiguration, GetModelDoc2 → props; InterferenceDetectionManager+     (UseTransform=true, TreatCoincidenceAsInterference, GetInterferences /+     GetInterferenceCount, Done() in a finally); ForceRebuild3(false) + feature+     walk FirstFeature/GetNextFeature/GetErrorCode2; Pack and Go via+     Extension.GetPackAndGo → IncludeDrawings, SetSaveToName(true, dir),+     GetDocumentSaveToNames byref, Extension.SavePackAndGo. Doc types:+     .sldprt=1 .sldasm=2 .slddrw=3. Doc info shape: {title, path, type+     ("part"/"assembly"/"drawing"), config, dirty}.+     The COM layer CANNOT be exercised until SOLIDWORKS installs (trial serial+     pending) — it must COMPILE for x86_64-pc-windows-gnu, degrade gracefully+     (clear errors, never panic across the protocol boundary), and keep the+     `eval`→`swx_com_eval` escape hatch (in Rust: accept a limited expression —+     at minimum `<method>(args...)` chains on $sw — or document what it+     supports; reason-gated as today).++Verbs that DON'T go through COM (implement directly in the server, all+platforms): swx_status, swx_readiness, swx_describe, swx_progress,+swx_find_files (disk walk: .sldprt/.sldasm/.slddrw, skip ~$ lock files, dot/$+dirs, node_modules; newest first; limit + 150s guard; roots default to+~/Documents + ~/Desktop), swx_uninstall, swx_screenshot (POST to+ADOM_DIRECT_API_URL/command with X-Adom-Bridge-Token + forwarded+X-Adom-Caller-* headers + X-Adom-Caller-Delegate: solidworks — plain HTTP to+loopback, hand-roll over TcpStream or use a tiny client; never fail the verb+because the callback failed), swx_state (detection + docs via com-host when+running), and the BOM CSV assembly (sidecar returns rows; server sorts by name,+collects the union of property names as columns, writes CSV to the scratch dir).++Detection (server, cfg(windows)): App Paths registry key+HKLM/HKCU `...\App Paths\SLDWORKS.exe`, then path globs (Program Files+SOLIDWORKS Corp variants), plus HKLM\SOFTWARE\SolidWorks subkey enum for+registryVersions, plus tasklist check for SLDWORKS.exe running. Non-Windows:+installed:false. `swx_status` re-detects each call.++Host-app gate: when NOT mock and NOT installed, every COM-backed verb returns+`{success:false, errorCode:"host_app_not_installed", error:"SOLIDWORKS is not+installed", _hint:<trial-pending hint>}`. The trial hint: a 30-day desktop+trial was requested from Hawk Ridge Systems (reseller); serial arrives by+email; never tell the user to install by hand.++## Testing (adapted from the app-testing skill — build ALL of it)++The suite must not be able to lie. No test may assert by reading source files+as strings; every test drives the REAL compiled binary over HTTP/stdio.++1. **Harness**: build (debug) and spawn the real server binary on a free port+   with SWX_MOCK=1 and temp dirs for anything it writes; poll /status until+   healthy; always kill + clean up. Rust integration tests (tests/*.rs, use+   std or minimal deps) or keep/extend the existing Python tests/test_verbs.py+   (works: it drives HTTP exactly as ab does). Prefer BOTH: cargo test for+   Rust-side units (find_files filters, CSV assembly, prune logic, protocol+   framing) + the HTTP suite for end-to-end.+2. **Verb-coverage gate** (the interaction-coverage analog): read bridge.json+   `verbs[]` at test time and FAIL if any listed verb has no test entry, and+   FAIL if swx_describe returns a verb absent from bridge.json or vice versa.+   A new verb shipped without a test must turn the suite red.+3. **Error-gate analog**: every response must parse as JSON, carry a boolean+   `success` (or status ok for GET), never HTTP 500 on well-formed input; a+   malformed body → clean 400. Assert numbered error paths: unknown verb (hint+   lists valid commands), missing required args, wrong doc type for bom/+   interference, reason gate on swx_com_eval.+4. **Protocol e2e**: the real server spawning the REAL com-host child (mock+   backend) — the over-the-wire loop between our two processes: verb → child+   → response; child killed mid-run → next verb respawns it and succeeds+   (crash recovery is a required test); a child that answers garbage lines →+   server skips them without wedging.+5. **Effects, not existence**: swx_export writes a real file (assert bytes on+   disk); swx_bom csvPath exists and parses as CSV with the property columns;+   find_files honors query/types/limit and skips ~$ files (create real fixture+   files in a temp dir).+6. Exit non-zero on any failure. Suite runs green on this Linux container.++## Build requirements++- `cargo build --release --target x86_64-pc-windows-gnu` MUST succeed here+  (toolchain + mingw already installed). Also plain `cargo build` (linux) for+  the mock-mode test run. Windows-only code behind cfg(windows).+- Use the hello-rust release profile (opt-level z, lto, strip) for the shipped+  exe. Dependencies: tiny_http, serde, serde_json; windows + winreg behind+  [target.'cfg(windows)'.dependencies]. Justify any addition in Cargo.toml+  comments. No async runtime.+- Remove the Python implementation files (server.py, com_host.py, swx_detect.py,+  caller_identity.py, quiet_console.py, sidecar/*.ps1, sidecar/mock_host.py) —+  git history keeps them; port tests/test_verbs.py to drive the Rust binary.+  Update README.md (architecture diagram, dev instructions) and SKILL.md where+  they mention Python/PowerShell. Update bridge.json spawn block. Keep+  package.json/install.sh/uninstall.sh (skills pkg) as-is except doc touch-ups.+- Keep BRIDGE_VERSION and Cargo.toml version in lockstep: bump to 0.2.0.++## References on disk (read them)++- This repo pre-port (Python impl): `git show HEAD` — or the files before your+  removal commit. The response shapes and hints in server.py are the spec.+- Official Rust sample bridge: /tmp/claude-1001/-home-adom-project/ca530728-41cc-4f93-a92d-d32d4afe1153/scratchpad/hr/+  (src/main.rs, Cargo.toml, bridge.json — the exe contract in miniature).+- kicad-bridge latest release (the quality bar for hints/etiquette/logging):+  /tmp/claude-1001/-home-adom-project/ca530728-41cc-4f93-a92d-d32d4afe1153/scratchpad/kb-latest/ (server.py, caller_identity.py, bridge.json).+- pup-bridge page (README/SKILL/docs — the quality bar for docs + response+  design): /tmp/claude-1001/-home-adom-project/ca530728-41cc-4f93-a92d-d32d4afe1153/scratchpad/pup-bridge/+- Local skills: ~/.claude/skills/adom-bridge-sdk*/SKILL.md (the SDK, manifest,+  runtime contracts), ~/.claude/skills/pup/SKILL.md, ~/.claude/skills/native-browser-safety/SKILL.md.++## Non-goals for this port++- No publishing (release zip / wiki page) — a later step.+- No new verbs beyond the 23 (parity port + quality).+- No UI. No PowerShell anywhere.++## Build notes — 2026-09-01++What the port actually did differently from this brief, and why. Everything+here is a deliberate deviation, not a shortcut.++**Release profile: no `panic = "abort"`.** The hello-rust sample sets it for+size, but the com-host child catches panics (`catch_unwind`) and answers them+as ordinary `ok:false` responses — which needs unwinding. A late-bound COM call+meeting something it did not expect should cost one verb, not the user's whole+SOLIDWORKS session (open documents included). The exe is still 824 KB.++**Crash recovery is transparent, and narrowly so.** The brief asked that a+killed child be respawned by the next verb. Naively that costs one failed verb:+the server writes into a dead pipe, then reports it. So `ComHost::call` now+(a) reaps a child that has already exited BEFORE writing, and (b) retries once+if the write itself fails. The retry is deliberately limited to failures that+happen *before* the request reaches the child — nothing can have half-happened.+A child that dies MID-request is still reported, never silently re-run: quietly+repeating an export or a Pack and Go would be worse than the error. Stale-id and+non-JSON lines are skipped as specified, under an overall deadline.++**`swx_status.com.hostPid` (additive).** Which process holds the COM object is+the one fact you need to debug a wedge, and it is what makes crash recovery+observable — `tests/protocol.rs` kills that pid and asserts the next verb+succeeds against a *different* one. Nothing else in the response changed.++**`swx_com_eval` is a call-chain evaluator, not a script host.** There is no+PowerShell any more and Rust has no eval, so the escape hatch became a small+grammar: `$sw` / `$doc` rooted dotted chains with string, number and boolean+literals (`$doc.Extension.CustomPropertyManager("").GetNames()`). That is+exactly what prototyping a verb needs, and it is auditable, which for something+driving a live CAD application is the better trade. The parser lives in+`comhost/expr.rs` OUTSIDE `cfg(windows)` precisely so it is unit-tested on this+Linux host; only the evaluation is Windows-only. The verb's hints say what it+supports.++**lib + bin instead of one `main.rs`.** The integration tests need the crate's+own HTTP client to drive the binary, and the pure logic (CSV assembly, prune+selection, find_files filters, the eval grammar, path helpers) deserves unit+tests. Splitting `src/lib.rs` off gets both while the tests still spawn the REAL+`CARGO_BIN_EXE_swx-bridge`.++**Version lockstep is enforced by the compiler.** `BRIDGE_VERSION` is checked+against `CARGO_PKG_VERSION` in a `const` assertion — they cannot drift. The+suite additionally asserts `/status.bridgeVersion == bridge.json.version`, which+is what caught bridge.json still saying 0.1.0.++**`SWX_SCRATCH_DIR` override.** The Python fallback (`<repo>/.scratch` when+`LOCALAPPDATA` is unset) makes no sense for a shipped exe, and left the tests+writing into the developer's real cache. The root is now+`SWX_SCRATCH_DIR` → `%LOCALAPPDATA%\...` → OS temp, and `swx_uninstall` removes+that root — so "uninstall really deleted what the bridge created" became an+assertable fact instead of a claim.++**Two test-only knobs in the mock backend**, both documented in place and never+set in production: `SWX_MOCK_NOISE=1` makes the child emit a non-JSON line, an+event line and a stale-id response before every answer (this is how the+skip-what-you-cannot-parse path is proven over the real wire), and+`SWX_MOCK_SLOW_MS` gives the "cold start" real duration (this is how+`swx_progress` answering DURING a slow verb is proven).++**`_reportIssues` on every failure** and on the unknown-verb response, per+`adom-bridge-sdk-audit`. The Python version predated that contract.++**Small correctness wins carried over deliberately:** the mock's document titles+now use a real basename that splits on both separators (Python's+`os.path.basename` returned the whole `C:\...` string when the mock ran on+Linux); `detection.platform` reports `std::env::consts::OS` (`windows`/`linux`)+rather than Python's `win32`; the log line truncates on a char boundary, so a+non-ASCII folder name cannot panic the logger.++**Threading.** tiny_http is fed by a std `TcpListener` we bind ourselves, so the+single-instance guard is explicit and nothing enables address reuse. Four worker+threads serve requests — not for throughput (COM work serializes on the host+child regardless) but so `swx_progress` can answer while a 90-second+interference check is in flight. There is a test for exactly that.++**Not done, by design:** the COM backend has never executed — it compiles for+`x86_64-pc-windows-gnu` and is written to fail honestly (every error carries+what SOLIDWORKS said, via EXCEPINFO), but its live shakedown waits on the trial+serial. `swx_screenshot`'s ab callback is exercised only in its "ab unreachable"+shape, which is the only shape available off a real desktop.++## Build notes — 2026-09-01 (round 2: adversarial-review fixes)++The adversarial reviewer and a parity diff found real defects. What changed:++**CRITICAL — VARIANT double-free (variant.rs).** The reviewer was right and my+earlier comment was wrong: VARIANT has real drop glue in windows 0.62.2+(`needs_drop::<VARIANT>()` is true), so building the DISPPARAMS array with+`ptr::read` made a second owner that double-freed every BSTR / IDispatch+argument. Fixed: the arg array is now `Vec<ManuallyDrop<VARIANT>>` — the `Var`+arguments stay the sole owners and clear exactly once. Re-audited every Var+handoff (`Var::dispatch`, `as_dispatch`, `as_array`, `coerce`): each is now+balanced one-AddRef/one-Release. This was the one that had to be right before+the serial lands.++**HIGH.** find_files now collects all matches, sorts by mtime, THEN truncates,+so the limit can no longer drop the newest file (regression test added).+swx_uninstall removes ONLY `<cache>/exports`, best-effort per item, never the+cache root ab owns (unit + e2e tests). swx_status (the statusVerb) try_locks a+non-blocking snapshot so polling it never waits on a 580s Pack-and-Go; shutdown+kills the child by pid when the request lock is held, so the cascade can't+block. HTTP workers now catch_unwind at two layers (per-verb → JSON error with+_reportIssues; per-request → worker survives); test-only fault injection+(`SWX_TEST_PANIC`, debug builds only) proves it end to end. swx_bom relabelled+risk "write", and a path-traversal guard (`safe_out`) refuses a relative or+`..` destination for bom-csv, export and pack-and-go.++**MED COM invariants (compile-only until the serial lands).** Interference+`Done()` is now a Drop guard (survives panics), not a trailing statement. The+OpenDoc6 legacy fallback is gone (it was non-silent — a modal-dialog risk).+rebuild_check distinguishes a clean feature from an unreadable one+(`unreadableFeatures`, code:null). swx_stop treats the expected RPC disconnect+from ExitApp as success. as_array coerces a scalar to a one-element vec (the+PowerShell `@(...)` semantics), and handles VT_UNKNOWN. bridge.json's+hostAppOptionalVerbs gains uninstall + state (so the cascade and state work with+SOLIDWORKS absent — the current target), and the 3DEXPERIENCE glob is added.+The mock now runs the SAME parse_chain as the real backend, so the eval grammar+is genuinely exercised over the wire.++**Child watchdog (#14).** The child now runs a watchdog thread that polls the+parent server's liveness (`SWX_PARENT_PID`) and exits if the server is+hard-killed while a COM call is wedged — the one case the plain stdin-EOF path+(only checked between requests) cannot catch. Proven to work in a plain shell;+the wedged-case integration test is `#[ignore]`d because it is PID-namespace+sensitive (a sandboxed observer cannot always see or signal the child in its+namespace), with the always-on graceful-orphan test as cover.++**LOW.** EXCEPINFO BSTRs are freed after each failed Invoke and the bad-arg+index is included in the error. 8MB request-body cap → 413. 400/413 responses+carry _hint + _reportIssues. swx_screenshot no longer flips to failure on a+present-but-null `error`, and its gate/doc are reconciled (it needs a running+window, so it is gated). swx_export echoes the ACTUAL output extension+(`outputExtension`). The detect.rs env test no longer calls set_var (was a+data race). find_files accepts a bare-string `types` and a numeric-string+`limit` (Python parity); an empty/unmatched `types` means "all" again (the+previous code returned zero files, contradicting its own doc).++**Intentional, documented parity changes (NOT silent drift):**+- `solidworks.platform` reports `"windows"`/`"linux"` (`std::env::consts::OS`),+  not Python's `"win32"`. Cleaner; a caller branching on the old literal must+  update. Called out here so it is a decision, not an accident.+- BOM row `file` uses a backslash separator (`C:\mock\bracket.sldprt`); Python+  emitted a forward slash when the mock ran on Linux. Rust is correct.+- Re-opening an already-open doc moves it to the end of the mock's list (Python+  kept its position); this only affects close_doc's fallback target in mock+  mode. No test locks either old string.++**Rebutted / deferred:**+- Coverage gate "accepts a bare call with zero assertions" (#21): left as is.+  The harness RECORDS every call and the gate checks bridge.json ⇔ describe ⇔+  calls-made in all three directions; in practice every verb in the suite is+  asserted on. Requiring a per-verb assertion count would add machinery for no+  real coverage the three-way check doesn't already give. free_port TOCTOU is+  acknowledged and, as the reviewer agreed, fine to leave (the single-instance+  guard turns any collision into a clean failure, not a hang).+- swx_bom.topLevelOnly defaulting to false (#E): kept — false is the documented+  default and the flag is echoed back, so a caller always sees what ran.

@@ -0,0 +1,405 @@+# Fusion 360 bridge — complete `fusion_*` verb inventory++Source of truth: `describe.py` (`_T` table -> `fusion_describe`) in the fusion-bridge clone,+cross-checked against `bridge.json`, `VERBS.md` and `README_VERBS.md`.+Extracted mechanically from the `_T` tuples, so arg names, arg type strings and response key+names below are **verbatim** from the bridge. Long type/summary strings are truncated with `...`;+names are never truncated.++**132 catalog entries, 131 live verbs** (1 entry, `fusion_open_by_urn_note`, is a doc-only pseudo-entry that `_verbs()` filters out via the `name.endswith("_note")` rule).++Column notes:+- **category** = canonical semantic bucket (my grouping, for mirroring into `swx_*`).+- **Section headings** = the literal section comments inside `describe.py`'s `_T` table.+  Two of those sections have drifted: the "Catalog completion" and "Library SHOW verbs"+  sections were appended over time and now also carry plain CAD/manufacturing verbs+  (`fusion_export_iges`, `fusion_export_dxf`, ...). The `category` column is the reliable grouping.+- `timeout` = `timeoutSeconds`; `LR` = `longRunning` (keeps working after ab's timeout — poll `statusVerb`).++---++## Lifecycle  (22)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_preflight_lbr` | library | `libraryPath`: str (Windows .lbr path) | `success` bool<br>`preflight` {ok, checks[], errors[]} | PRE-ANALYZE a .lbr: will Fusion open it? Offline and instant - no Fusion needed, nothing launched. | 10 | yes | - |+| `fusion_install_library_bundle` | library | `zipPath`: str (staged bundle zip on THIS machine)<br>`lbrPath`: str (staged .lbr, STEP models beside it)<br>`libraryName`: optional str (default: file stem)<br>`capture`: optional bool (default true: bind + prove; false: place only) | `installed` bool<br>`libraryPath` str<br>`partsTotal` int<br>`partsToBind` int<br>`unbound` [{package, why}]<br>`partMetadata` {ok, summary, warnings[]}<br>`fusion` {installed, running, addinReady, status, message}<br>`runId` str<br>`statusVerb` fusion_prove_result | COMPOSITE, the Fusion twin of kicad_install_library_bundle (#68): ONE call takes a staged Cloud Library bundle (zip of <Lib>.lbr + <Part>.step models, or a bare lbrPath with STEPs beside... | 60 | yes | `fusion_prove_result` |+| `fusion_create_library` | library | `parts`: optional [{package, lbrPath, modelPath}]<br>`libraryPath`: optional str (shape A, or output path for B)<br>`kicadSymbolPath`: optional str<br>`kicadFootprintPath`: optional str<br>`stepPath`: optional str (required for proven)<br>`pinMap`: optional {pinName: padName}<br>`name`: optional str | `started` bool<br>`statusVerb` str | ONE-CALL library creation for web-control (one call = one consent). | 30 | yes | `fusion_prove_result` |+| `fusion_start` | lifecycle | `{}` (none) | `success` bool<br>`addinReady` bool<br>`status` str | Launch Fusion 360 (if needed) and wait for the AdomBridge add-in to be ready. | 150 | yes | - |+| `fusion_stop` | lifecycle | `skipCleanClose`: optional bool | `success` bool<br>`output` str | Gracefully STOP Fusion 360: close docs cleanly + WM_CLOSE, then wait. | 60 | - | - |+| `fusion_kill` | lifecycle | `skipCleanClose`: optional bool | `success` bool<br>`output` str | Force-KILL Fusion 360 (taskkill /F) - the desperate path for when fusion_stop cannot close it (stuck modal / wedged process). | 30 | - | - |+| `fusion_close_window` | lifecycle | `hwnd`: required int (the dialog window) | `success` bool | Close a DIALOG window by hwnd (WM_CLOSE, like clicking X) - for dialogs without Cancel/Escape handling (e.g. Recovered Documents). | 30 | - | - |+| `fusion_get_app_state` | lifecycle | `{}` (none) | `activeDocument` str<br>`activeWorkspace` str<br>`isElectronics` bool | Current app state: running, active document, workspace, isElectronics. | 20 | - | - |+| `fusion_readiness` | lifecycle | `{}` (none) | `installed` bool<br>`running` bool<br>`ready` bool<br>`hostApp` str<br>`bridgeVersion` str | FAST readiness check (does NOT launch Fusion): is the Fusion host app installed + running + the bridge ready to drive? ab DETECTS Fusion (never installs it) via bridge.json 'detect', and... | 15 | - | - |+| `fusion_new_electronics_from_eagle` | electronics | `schPath`: required str (Windows path to .sch)<br>`brdPath`: optional str (defaults to sibling .brd) | `success` bool<br>`imported` list | Import a legacy EAGLE .sch (+ paired .brd) into a NEW Fusion electronics design so the parts INSTANTIATE (schematic + populated board, lands in the PCB editor). | 200 | - | - |+| `fusion_notify_owner` | lifecycle | `title`: optional str<br>`body`: required str<br>`level`: optional str info\|warning\|error | `success` bool<br>`targets` list | LAST-RESORT human escalation: toast the user's MAIN computer (fans out cross-ab to every peer on the relay, so it reaches them even when this bridge runs on an unattended VM). | 20 | - | - |+| `fusion_signin` | auth | `profile`: optional str (chrome:<email>/edge:<email>)<br>`auto`: optional bool (do click+capture+reopen in one on-box call)<br>`waitSec`: optional int (server-side poll budget for the fresh URL, default 32) | `stage` str<br>`done` bool<br>`signinWhere` str<br>`signinProfile` str<br>`signinProfileReason` str<br>`signinWrongBrowser` str<br>`signinAuthUrl` str<br>`signinOpenedVia` str (extension\|extension_free)<br>`signinWall` str\|null (twofactor_email_code\|credentials\|protocol_handoff)<br>`notifyDelivered` bool<br>`signinWallHint` str\|null<br>`narrate` str | SELF-DRIVING as of 1.9.32: launches Fusion if needed, clicks Sign In, opens the OAuth in the right profile, TYPES THE EMAIL and advances to the exact remaining wall... | 120 | yes | `fusion_signin` |+| `fusion_mcp_status` | mcp/prefs | `{}` (none) | `enabled` bool<br>`serverInfo` obj<br>`toolCount` int<br>`tools` [{name,description}] | Is Autodesk's Fusion MCP server up, and what does it expose? Autodesk + Anthropic ship a LOCAL MCP server at http://127.0.0.1:27182/mcp exposing Fusion's own text-to-CAD surface (read... | 45 | - | `fusion_mcp_status` |+| `fusion_mcp_enable` | mcp/prefs | `{}` (none) | `enabled` bool<br>`alreadyOn` bool<br>`steps` list<br>`serverInfo` obj | Turn Autodesk's Fusion MCP server ON by driving Fusion's Preferences dialog for the user. | 180 | yes | `fusion_mcp_status` |+| `fusion_mcp_tools` | mcp/prefs | `{}` (none) | `count` int<br>`tools` list | Full tool list from Autodesk's Fusion MCP server INCLUDING input schemas, so you can construct a valid fusion_mcp_call. | 45 | - | `fusion_mcp_status` |+| `fusion_mcp_call` | mcp/prefs | `tool`: required str (from fusion_mcp_tools)<br>`arguments`: optional obj (per that tool's inputSchema)<br>`timeout`: optional int seconds, default 120 | `result` obj<br>`tool` str | Call any tool on Autodesk's Fusion MCP server (fusion_mcp_read, fusion_mcp_update, fusion_mcp_execute, fusion_mcp_electronics_read). | 150 | yes | `fusion_mcp_status` |+| `fusion_mcp_resources` | mcp/prefs | `uri`: optional str (omit to list) | `count` int<br>`resources` [str]<br>`result` obj | List Autodesk MCP resources, or read one by uri. | 60 | - | `fusion_mcp_status` |+| `fusion_prefs_open` | mcp/prefs | `section`: optional str (see knownSections in the response) | `hwnd` int<br>`shotId` str<br>`screenshot` str<br>`knownSections` [str]<br>`steps` list | Open Fusion's Preferences dialog and optionally jump to a section, then hand back a SCREENSHOT + shotId you can click in. | 120 | yes | `fusion_get_preferences` |+| `fusion_prefs_close` | mcp/prefs | `save`: optional bool, default true | `closed` bool<br>`saved` bool | Apply+OK (save:true, the default) or Cancel Fusion's Preferences dialog. | 60 | - | `fusion_get_preferences` |+| `fusion_set_auto_update` | lifecycle | `enabled`: optional bool (omit to read current value) | `autoUpdateFusion` bool<br>`narrate` str | Turn AUTOMATIC Fusion updating on/off for this user. | 30 | yes | `fusion_readiness` |+| `fusion_signin_2fa` | auth | `code`: required str (the 6 digits; non-digits are stripped)<br>`hwnd`: optional int (the 2FA window; auto-detected) | `submitted` bool<br>`steps` list<br>`narrate` str | Submit Autodesk's emailed 6-DIGIT verification code to finish a Fusion sign-in, typed IN THE BACKGROUND (UIA SetValue + Invoke - never steals the user's foreground or moves their cursor). | 90 | yes | `fusion_readiness` |+| `fusion_demo` | lifecycle | `query`: optional str (design to demo; else picked from APS search)<br>`stage`: optional str ('skip_aps' to proceed without cloud search) | `stage` str<br>`done` bool<br>`narrate` str<br>`screenshots` [{label,path}]<br>`steps` [str]<br>`apsSampleSearch` [{name,project}] | FIRST-TIME-USER DEMO in one verb - the thing to run when someone new wants to SEE what this bridge does (HD's installer calls this). | 240 | yes | `fusion_demo` |++---++## Cloud search & files (APS)  (19)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_aps_status` | auth | `{}` (none) | `configured` bool<br>`signedIn` bool<br>`neverCharge` bool | APS state: configured, signed in, token live, never-charge meter. | 20 | - | - |+| `fusion_aps_set_client_id` | auth | `clientId`: required str | `success` bool | Set the org's APS (PKCE) client id used for cloud search. | 20 | - | - |+| `fusion_aps_signin` | auth | `exe`: optional str (browser binary to launch+remember)<br>`profileDir`: optional str (e.g. 'Default','Profile 2')<br>`name`: optional str<br>`allowDefaultBrowser`: optional bool | `success` bool<br>`authUrl` str<br>`openedVia` str<br>`needsExtensionOpen` bool | Open the Autodesk sign-in in the REMEMBERED browser+profile (not the OS default); a background listener captures the token. | 30 | - | `fusion_aps_status` |+| `fusion_aps_set_browser` | auth | `name`: optional str<br>`exe`: str (browser binary) OR how:'extension'<br>`profileDir`: optional str<br>`how`: optional 'extension'\|'launch' | `success` bool<br>`browser` {name,exe,profileDir} | Remember the browser+profile that authed to Autodesk so every later sign-in reuses it (power users have many browsers/profiles; the OS default is usually the wrong one). | 10 | - | - |+| `fusion_aps_get_browser` | auth | `{}` (none) | `success` bool<br>`browser` {name,exe,profileDir}\|null | Show the remembered Autodesk sign-in browser (None until set). | 10 | - | - |+| `fusion_aps_forget_browser` | auth | `{}` (none) | `success` bool<br>`cleared` bool | Forget the remembered Autodesk sign-in browser (re-detect next time). | 10 | - | - |+| `fusion_aps_search` | cloud | `query`: required str<br>`limit`: optional int (default 50)<br>`hubId`: optional str<br>`projectId`: optional str | `count` int<br>`results` [{name,id,projectName,lastModified}] | Server-indexed search across the whole team hub (seconds, not a 30-min folder walk). | 60 | - | - |+| `fusion_aps_open` | cloud | `query`: required str<br>`wait`: optional bool | `opening` bool<br>`match` {name}<br>`statusVerb` str | Find a cloud design by name and open it in Fusion (any folder depth). | 60 | yes | `fusion_get_app_state` |+| `fusion_open_by_urn` | cloud | `urn`: required str | `success` bool<br>`output` str | Open a cloud ELECTRONICS DESIGN by URN. | 240 | yes | `fusion_get_app_state` |+| `fusion_aps_browse` | cloud | `hubId`: optional str<br>`projectId`: optional str<br>`folderId`: optional str | `items` [{name,type,id}] | Browse hubs/projects/folders without launching Fusion. | 60 | - | - |+| `fusion_aps_recent` | cloud | `limit`: optional int (default 25) | `count` int<br>`results` [...] | Most-recently-modified designs across the team hub, newest first. | 60 | - | - |+| `fusion_aps_file_info` | cloud | `query`: str  OR  projectId+urn | `versionCount` int<br>`tip` {...}<br>`versions` [...] | Version history + who/when/size for a file (tip + recent versions). | 40 | - | - |+| `fusion_aps_versions` | cloud | `query`: str  OR  projectId+urn | `versionCount` int<br>`versions` [...] | Full (uncapped) version history of a file. | 40 | - | - |+| `fusion_aps_download` | cloud | `query`: str OR projectId+urn<br>`saveDir`: optional str<br>`fileName`: optional str | `path` str<br>`bytes` int | Download a cloud file to the local machine (no Fusion needed). | 90 | - | - |+| `fusion_aps_upload` | cloud | `projectId`: required str<br>`folderId`: required str (NON-ROOT subfolder)<br>`localPath`: required str<br>`fileName`: optional str | `itemUrn` str<br>`bytes` int | Upload a local file as a NEW cloud file (free Data Management; needs data:write scope). | 90 | - | - |+| `fusion_aps_create_folder` | cloud | `projectId`: required str<br>`parentFolderId`: required str<br>`name`: required str | `folderId` str | Create a subfolder in a project (free; needs data:create scope). | 50 | - | - |+| `fusion_aps_get` | cloud | `path`: required str | `status` int<br>`body` obj | Raw authenticated GET against a free APS path (dev/verify helper). | 40 | - | - |+| `fusion_walk_cloud_tree` | cloud | `{}` (none) | `disabled` bool | ⛔ DISABLED (returns an error): the in-app add-in walk took 30+ min and CRASHED Fusion (WinError 10054). | 15 | - | - |+| `fusion_search_cloud_files` | cloud | `query`: required str | `disabled` bool | ⛔ DISABLED (returns an error): the in-app add-in search took 30+ min and CRASHED Fusion (WinError 10054). | 15 | - | - |++---++## Electronics  (26)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_show_schematic` | electronics | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...] | `success` bool<br>`activeWorkspace` str<br>`productType` str | Switch the OPEN electronics design to its SCHEMATIC view (the symmetric partner of fusion_show_2d_board / fusion_show_3d_board, via Fusion's SwitchSchDocCmd). | 70 | yes | - |+| `fusion_show_2d_board` | electronics | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...] | `activeWorkspace` str | Switch the OPEN electronics design to its 2D PCB Editor (board layout) view. | 70 | yes | - |+| `fusion_show_3d_board` | electronics | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...] | `activeWorkspace` str<br>`screenshots` [...] | Switch the OPEN electronics design to its 3D PCB view (populated board). | 70 | yes | - |+| `fusion_open_by_urn_note` | doc-only (filtered out of fusion_describe) | `{}` (none) | - | (see fusion_open_by_urn) | 30 | - | - |+| `fusion_board_info` | electronics | `{}` (none) | `rawXml` str | Raw board geometry XML (copper/arcs/lines) for the open board. | 60 | - | - |+| `fusion_alerts` | introspect/etiquette | `sinceSec`: optional float (default 300) | `alerts` [{at,text}] | Fusion's OWN alert toasts, read from its log. | 30 | - | - |+| `fusion_web_signin` | auth | `url`: required str (e.g. https://library.io/)<br>`sessionId`: optional str (default autodesk-web)<br>`provider`: optional str google\|password (default google)<br>`username`: optional str (for the Google account chooser) | `success` bool<br>`errorCode` str?<br>`url` str<br>`steps` [...] | Sign a pup browser window into an Autodesk WEB surface (library.io, the hub portal at <hub>.autodesk360.com, Autodesk Account) via Google SSO. | 240 | yes | `fusion_get_app_state` |+| `fusion_managed_library_create` | library | `name`: optional str (defaults to the library's own name)<br>`description`: optional str | `success` bool<br>`library` str<br>`alerts` [...] | Create a NEW managed library on library.io FROM the library in front (which must already be saved in a Fusion Hub). | 240 | yes | `fusion_get_app_state` |+| `fusion_managed_library_link` | library | `name`: optional str (exact library name from the picker; omit to list read-only)<br>`onUpdatePrompt`: optional str cancel\|merge\|replace (default cancel; replace OVERWRITES the local library) | `success` bool<br>`listedOnly` bool?<br>`managedLibraries` [{name,type,version,managedFolder,description}]<br>`linkedTo` str?<br>`updatePrompt` obj?<br>`alerts` [...] | Link the library IN FRONT to an existing managed library on library.io. | 180 | yes | `fusion_get_app_state` |+| `fusion_managed_library_unlink` | library | `{}` (none) | `success` bool<br>`library` str<br>`alerts` [...] | Unlink the library in front from its managed library on library.io. | 180 | yes | `fusion_get_app_state` |+| `fusion_managed_library_push` | library | `onConfirm`: optional str create\|cancel (default create) | `success` bool<br>`library` str<br>`confirmed` obj<br>`alerts` [...] | Push a NEW VERSION of the library in front up to its linked managed library on library.io. | 240 | yes | `fusion_get_app_state` |+| `fusion_managed_library_pull` | library | `onUpdatePrompt`: optional str merge\|replace\|cancel (default merge) | `success` bool<br>`library` str<br>`upToDate` bool<br>`updatePrompt` obj?<br>`alerts` [...] | Pull the newest version FROM library.io into the linked library in front. | 240 | yes | `fusion_get_app_state` |+| `fusion_library_manager` | library | `tab`: optional str hub\|public\|private (default private) | `success` bool<br>`tab` str<br>`hwnd` int<br>`libraries` [str] (usually empty - see pitfall)<br>`tableReadable` bool | Open Fusion's Library Manager and switch to one of its three tabs. | 240 | yes | `fusion_get_app_state` |+| `fusion_open_lbr` | library | `filePath`: required str (.lbr WINDOWS path C:/...; stage from container first)<br>`symbolName`: optional str<br>`verify`: optional bool | `success` bool<br>`postOpenScreenshot` {savedTo} | Import an EAGLE .lbr library into Fusion's Electronics LIBRARY editor (Content Manager / Electronics Library workspace), not a PCB design. | 50 | - | - |+| `fusion_attach_3d_package` | library | `filePath`: required str (.lbr WINDOWS path C:/...)<br>`modelPath`: required str (.step WINDOWS path C:/...)<br>`packageName`: optional str | `success` bool<br>`savePending` bool<br>`data` {steps}<br>`_hint` the Save-dialog click + verify steps | LOW-LEVEL primitive: attaches ONE model to ONE package. | 240 | yes | `fusion_get_app_state` |+| `fusion_install_fusion` | lifecycle | `{}` (none) | `success` bool<br>`installing` bool<br>`alreadyInstalled` bool?<br>`mode` globalinstall\|per-user<br>`statusVerb` str | Install Fusion 360 FOR the user - downloads Autodesk's official Client Downloader and streams the free trial silently, with NO shell_execute and NO ab approval gate (runs inside the... | 90 | yes | `fusion_get_app_state` |+| `fusion_generate_package` | library | `type`: required str (EPG family, e.g. chip\|soic\|qfn\|qfp\|bga\|sot23\|dfn2\|melf\|ecap\|crystal\|header_straight)<br>`params`: optional dict (generator dims in MM by default, e.g. chip: {D,E,A,L,L1}; soic: {A,A1,b,D,E,E1,e,L,DPins};...)<br>`unitsCm`: optional bool (params already EPG-native cm)<br>`etch`: optional str (marking text on the chip top: MPN / '103'; multi-line with newline, e.g. MPN+variant)<br>`etchStyle`: optional str raised\|engraved (default raised = thin WHITE positive extrude, silkscreen-style contrast;...)<br>`etchDepthMm`: optional float (marking height/depth, default 0.03)<br>`etchHeightMm`: optional float (text height; default auto-fit: top-5%-band face, 10% margin, width-aware)<br>`outputStep`: optional str (WINDOWS path; exports STEP incl. the marking) | `success` bool<br>`bodies` [{name,vol}]<br>`etched` str\|null<br>`stepPath` str\|null<br>`manifest` obj (settings+why+bboxes; also written as <step>.manifest.json sidecar for...<br>`manifestPath` str\|null<br>`epgDir` str | Generate an IPC-7351-compliant parametric 3D package via Fusion's BUILT-IN ElectronicsPackageGenerator (EPG) - ~50 package families... | 120 | yes | `fusion_get_app_state` |+| `fusion_make_3d_package` | library | `lbrPath`: required str (.lbr WINDOWS path; its FIRST package's footprint is loaded)<br>`modelPath`: required str (.step WINDOWS path)<br>`projectId`: optional str (default MAIN-project)<br>`folderId`: optional str (default upload folder)<br>`fileName`: optional str<br>`captureLabel`: optional str (capture before/after)<br>`orient`: optional bool (default true) | `success` bool<br>`wip_urn` str<br>`dims_mm` [x,y,z]<br>`f3d` str<br>`before` str\|null<br>`after` str\|null | Create a RENDERING component 3D package (FOOTPRINT + chip, aligned) for ONE part, fully programmatically with ZERO GUI dialogs. | 200 | yes | `fusion_get_app_state` |+| `fusion_build_library_3d` | library | `lbrPath`: required str (combined .lbr WINDOWS path to bind + open)<br>`parts`: required [{package, lbrPath (per-part footprint .lbr), modelPath (.step)}]<br>`outLbrPath`: optional str (default: overwrite lbrPath)<br>`capture`: optional bool (default true)<br>`projectId`: optional str<br>`folderId`: optional str<br>`openWhenDone`: optional bool (default true) | `success` bool<br>`boundLbr` str<br>`partsBound` int<br>`partsTotal` int<br>`parts` [{package,success,wip_urn,dims_mm,error}]<br>`screenshots` [{package,stage,path}]<br>`opened` bool | Build a RENDERING multi-part 3D library in ONE call - the whole programmatic pipeline. | 1800 | yes | `fusion_get_app_state` |+| `fusion_capture_library_views` | library | `packages`: required [<deviceset name>] (or 'package': single name)<br>`views`: optional subset of ['symbol','footprint','3d','component'] (default ALL FOUR, in that assembly order)<br>`settle`: optional float secs after each EDIT before capture (default 1.5; raise if a shot shows the PREVIOUS part) | `success` bool<br>`captured` [{package,view,path,ok}] | Capture the LIBRARY-EDITOR views EEs trust: the schematic SYMBOL (full pinout), the FOOTPRINT (pads + layer stack), and the COMPONENT/device view (Content Manager: symbol + the package... | 300 | yes | `fusion_get_app_state` |+| `fusion_cleanup_cloud_files` | cloud | `fileIds`: required [<lineage urn>]<br>`projectName`: optional str (default active project)<br>`folderPath`: optional str (default root) | `success` bool<br>`deletedCount` int<br>`failedCount` int<br>`failed` [{fileId,error}] | PRECISELY delete a list of cloud files by lineage urn - SAFE cleanup of AI-created clutter. | 1800 | yes | `fusion_get_app_state` |+| `fusion_run_modeling_script` | documents | `script`: required str (Python using adsk; globals: adsk, app, ui, design) | `result` obj<br>`documentName` str | Run an adsk.fusion modeling script in the live session (sketches/extrudes/params). | 180 | yes | - |+| `fusion_assembly_bom` | documents | `maxSeconds`: optional float (walk budget, default 20; the verb REFUSES fast with bom_walk_budget_exceeded + a...)<br>`treatAsUnit`: optional [str] name substrings counted as one unit (default ['with fasteners'])<br>`exclude`: optional [str] top-level name prefixes to skip<br>`includePhysicalProperties`: optional bool (adds volume_cm3/mass_kg per line)<br>`outputPath`: optional str (Windows CSV path) | `success` bool<br>`design` str<br>`partCount` int<br>`totalInstances` int<br>`parts` [{componentName, partNumber, description, material, quantity, bodies}] | Structured, kit-aware MECHANICAL bill of materials for the active Design assembly (the counterpart to the electronics-only fusion_export_bom). | 120 | - | - |+| `fusion_physical_properties` | documents | `names`: optional [str] component names to measure (default all)<br>`accuracy`: optional low\|medium\|high\|veryhigh (default low) | `success` bool<br>`count` int<br>`properties` {name: {volume_cm3, mass_kg, density, area_cm2, center_of_mass}} | Per-component physical properties (volume cm3, mass kg, density, area, center of mass) for the active design. | 120 | - | - |+| `fusion_set_preference` | mcp/prefs | `theme`: optional str<br>`invertScrollZoom`: optional bool<br>`orbitScheme`: optional str<br>`modelingOrientation`: optional str<br>`gestureNav`: optional bool<br>`cameraPivot`: optional bool<br>`lengthUnit`: optional str | `applied` obj<br>`current` obj | Set Fusion appearance/navigation preferences in the LIVE session - applies immediately, NO restart. | 30 | yes | - |+| `fusion_get_preferences` | mcp/prefs | `{}` (none) | `current` obj | Read current Fusion appearance/navigation preferences (theme, activeTheme, invertScrollZoom, orbitScheme, modelingOrientation, gestureNav, cameraPivot, lengthUnit) as friendly values -... | 20 | - | - |++---++## CAD & 3D export  (2)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_export_step` | export | `outputPath`: required str | `format` str<br>`fileSizeKB` int | Export the active design to STEP (needs the 3D view). | 300 | yes | - |+| `fusion_import_step` | export | `filePath`: required str (WINDOWS path C:/...; stage from container first) | `success` bool<br>`documentName` str | Import a STEP/.stp (or other native-importable) file into a NEW Fusion design via the native import API. | 300 | yes | - |++---++## Catalog completion (late-described verbs)  (15)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_open_cloud_file` | cloud | `fileName`: required str<br>`projectName`: optional str (defaults to active project)<br>`folderPath`: optional str | `success` bool<br>`documentName` str | Open a CLOUD file by name (the front door to every design flow). | 240 | yes | `fusion_get_app_state` |+| `fusion_open_design` | documents | `filePath`: required str (WINDOWS path) | `success` bool | Open a LOCAL design file (routes through the add-in import). | 240 | yes | - |+| `fusion_close_document` | documents | `name`: optional str (default: active document)<br>`save`: optional bool default false | `success` bool<br>`closed` str | Close ONE document WITHOUT the modal save dialog (save:false discards silently - the automation-safe close). | 60 | - | - |+| `fusion_close_all_documents` | documents | `save`: optional bool default false<br>`closeUntitled`: optional bool default false<br>`force`: optional bool default false | `success` bool<br>`closed` [str]<br>`wouldPrompt` [str]\|null | Close ALL open documents without save dialogs. | 60 | - | - |+| `fusion_reset_workspace` | documents | `force`: optional bool default false | `success` bool<br>`closedByAddin` list<br>`untitledScratchClosed` int<br>`remaining` list | Bring Fusion back to a clean slate between runs: closes named documents AND the Untitled scratch the library/bind flow leaves behind (page issue #59). | 90 | - | - |+| `fusion_document_info` | documents | `{}` (none) | `success` bool<br>`name` str<br>`productType` str<br>`isSaved` bool | Metadata for the ACTIVE document: name, product type, save state, version, parent project. | 30 | - | - |+| `fusion_execute_text_command` | documents | `command`: required str<br>`expectDocument`: optional str (refuses wrong_document if the active doc does not match) | `success` bool<br>`output` str | Run a raw Fusion TEXT COMMAND (app.executeTextCommand) - the escape hatch to Fusion internals (Electron.* electronics commands included). | 60 | - | - |+| `fusion_get_design_info` | documents | `{}` (none) | `success` bool<br>`components` int<br>`bodies` int | Design-level summary of the active design: components, bodies, sketches, units, root name. | 60 | - | - |+| `fusion_get_parameters` | documents | `{}` (none) | `success` bool<br>`parameters` list | All user + model parameters of the active design (name, expression, value, unit). | 60 | - | - |+| `fusion_list_cloud_projects` | cloud | `{}` (none) | `success` bool<br>`projects` list | List the cloud PROJECTS visible to the signed-in Fusion session (hub walk - slow on big teams; prefer fusion_aps_search for finding files). | 120 | yes | - |+| `fusion_list_cloud_files` | cloud | `projectName`: optional str (defaults to active project)<br>`folderPath`: optional str | `success` bool<br>`files` list | List files/folders in a cloud project (optionally a subfolder). | 120 | yes | - |+| `fusion_export_f3d` | export | `outputPath`: required str | `format` str | Export the active design as a Fusion archive (.f3d). | 300 | yes | - |+| `fusion_export_fbx` | export | `outputPath`: required str | `format` str | Export to FBX mesh. | 300 | yes | - |+| `fusion_export_sat` | export | `outputPath`: required str | `format` str | Export to SAT (ACIS solid). | 300 | yes | - |+| `fusion_export_skp` | export | `outputPath`: required str | `format` str | Export to SketchUp (.skp). | 300 | yes | - |++---++## Library SHOW verbs + bare-artifact wrapping  (23)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_show_symbol` | library | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...]<br>`name`: str (deviceset/symbol name; optional if symbolXml carries name=)<br>`libraryPath`: optional str (WINDOWS path .lbr)<br>`symbolXml`: optional str (bare <symbol ...>...</symbol>)<br>`foreground`: optional bool [DEFAULT IS BACKGROUND (no focus steal])<br>`foregroundReason`: required WITH foreground:true | `success` bool<br>`view` str<br>`screenshot` str path<br>`wrappedLibrary` str (when wrapped) | Open a schematic SYMBOL in Fusion's library editor - first-class, no hand-built EDIT strings. | 180 | yes | - |+| `fusion_show_footprint` | library | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...]<br>`name`: str<br>`libraryPath`: optional str<br>`packageXml`: optional str (bare <package ...>...</package>)<br>`foreground`: optional bool [DEFAULT IS BACKGROUND (no focus steal])<br>`foregroundReason`: required WITH foreground:true | `success` bool<br>`view` str<br>`screenshot` str path<br>`wrappedLibrary` str (when wrapped) | Open a FOOTPRINT (package) in Fusion's library editor. | 180 | yes | - |+| `fusion_show_3d_package` | library | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...]<br>`name`: str<br>`libraryPath`: optional str (.lbr)<br>`packageXml`: optional str (bare <package> fragment)<br>`stepPath`: optional str (WINDOWS path .step to attach)<br>`foreground`: optional bool [DEFAULT IS BACKGROUND (no focus steal])<br>`foregroundReason`: required WITH foreground:true | `success` bool<br>`view` str<br>`screenshot` str path<br>`wrappedLibrary` str | Open the 3D CHIP view (Package3DEnvironment) for a library package - and the RELIABLE way to get a 3D model into a library: pass stepPath and it is attached AFTER the library opens... | 300 | yes | - |+| `fusion_demo_progress` | lifecycle | `demoId`: required str (from fusion_demo mode:tour; omitted = the single running tour)<br>`imagesAs`: optional str paths\|base64\|both<br>`sinceShot`: optional int | `percent` int<br>`step` str<br>`stepLabel` str<br>`done` bool<br>`shots` list<br>`shotCount` int<br>`stepShot` dict\|absent | Poll a running fusion_demo tour: {percent, elapsedSec, estimatedSec, step, stepLabel, done, failed, shots, shotCount, stepShot}. | 15 | - | - |+| `fusion_make_test_project` | lifecycle | `libraryPath`: required str (WINDOWS path .lbr; stage from container first)<br>`deviceset`: optional str (defaults to the library's first deviceset)<br>`device`: optional str: the DEVICE (package variant) to place, e.g. "-HV" (default: the deviceset's first device) | `success` bool<br>`schPath` str<br>`brdPath` str<br>`circuit` str | Create a NEW electronics test project FROM SCRATCH around a library part - the Web Control demo's PROJECT button, and the answer to 'a customer only has a component page'. | 300 | yes | - |+| `fusion_screenshot_fusion` | introspect/etiquette | `hwnd`: optional int (a dialog; default the main window) | `success` bool<br>`savedTo` str<br>`sizeKB` int | Background PrintWindow capture of Fusion's MAIN window (largest same-title window; works occluded/bottom-of-z-order, never raises anything) or a specific dialog by hwnd. | 60 | - | - |+| `fusion_bind_library_3d` | library | `libraryPath`: required str (WINDOWS .lbr path)<br>`stepPath`: required str (WINDOWS .step path)<br>`deviceset`: optional str (defaults to the library's first) | `success` bool<br>`wip_urn` str<br>`bound` bool<br>`reopened` bool | LOW-LEVEL primitive: binds ONE STEP onto one deviceset. | 480 | yes | - |+| `fusion_show_library` | library | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...]<br>`libraryPath`: optional str (WINDOWS .lbr)<br>`name`: optional str (already-open library name) | `success` bool<br>`view` str<br>`screenshot` str | Eight-surfaces contract: the LIBRARY surface. | 240 | yes | - |+| `fusion_show_project` | library | `capture`: optional bool [set captureMaxWidth to shrink it - 320 keeps a /command body small,...]<br>`query`: optional str (cloud design name)<br>`urn`: optional str<br>`fileName`: alias of query | `success` bool<br>`view` str<br>`document` str<br>`screenshot` str | Eight-surfaces contract: bring the PROJECT/design to its top level. | 240 | yes | `fusion_get_app_state` |+| `fusion_set_window_sizing` | introspect/etiquette | `enabled`: optional bool (omit to read) | `success` bool<br>`sizeFusionWindow` bool | Read/toggle auto-sizing Fusion's WINDOW after launch (STICKY, default ON). | 15 | - | `fusion_state` |+| `fusion_set_driving_badge` | introspect/etiquette | `enabled`: optional bool (omit to read) | `success` bool<br>`showDrivingBadge` bool | Read/toggle the 'Adom is driving Fusion' TASKBAR OVERLAY BADGE (STICKY per user, default ON). | 15 | - | `fusion_state` |+| `fusion_set_seat_takeover` | introspect/etiquette | `enabled`: optional bool (omit to read) | `success` bool<br>`autoTakeOverSeat` bool | Read/toggle the mid-session Autodesk seat-takeover sweep (STICKY per user, default ON). | 15 | - | `fusion_readiness` |+| `fusion_state` | introspect/etiquette | `screenshot`: optional bool (default true)<br>`imageAs`: optional str path\|base64 (default path) | `success` bool<br>`running` bool<br>`activeDocument` str<br>`mainThreadBusy` dict\|null<br>`blockingDialogs` list<br>`focusEvents` list - the QUIETNESS AUDIT LOG (SDK canonical): every time this bridge took the...<br>`timings` dict - measured launch history on THIS machine (p50/p90 per phase, cold vs warm)<br>`screenshot` str path<br>`screenshotBase64` str (imageAs:base64 only) | The RENDER-ME verb (kicad_state parity, issues #28/#30): running + window + dialog + busy state PLUS a fresh background screenshot of whatever Fusion is showing - the one verb that makes... | 60 | - | - |+| `fusion_export_iges` | export | `outputPath`: required str | `format` str | Export to IGES. | 300 | yes | - |+| `fusion_export_stl` | export | `outputPath`: required str | `format` str | Export to STL mesh. | 300 | yes | - |+| `fusion_export_3mf` | export | `outputPath`: required str | `format` str | Export to 3MF mesh. | 300 | yes | - |+| `fusion_export_usdz` | export | `outputPath`: required str | `format` str | Export to USDZ (AR / Hydrogen 3D). | 300 | yes | - |+| `fusion_export_optimized_glb` | export | `outputPath`: required str (.glb)<br>`silkscreen`: bool default true<br>`pin`: str medium\|large default medium<br>`wait`: int seconds default 15 (keep under the ~60s relay timeout; re-call fetch until complete)<br>`async`: bool | `glbPath` str<br>`jobId` str<br>`pending` bool<br>`meshesAfter` int<br>`sizeBytes` int<br>`moleculeAnchored` bool<br>`silkscreenApplied` bool | Fusion board -> wiki-grade optimized GLB. | 200 | yes | - |+| `fusion_fetch_optimized_glb` | export | `jobId`: str (service job form)<br>`exportId`: str (async form from export_optimized_glb async:true)<br>`outputPath`: str (.glb)<br>`wait`: int seconds default 15 (keep under the ~60s relay timeout; re-call fetch until complete) | `glbPath` str<br>`status` str<br>`pending` bool<br>`sizeBytes` int | Finish a fusion_export_optimized_glb job: bounded-poll the optimizer by jobId and write the GLB to outputPath when complete. | 150 | - | - |+| `fusion_board_stackup` | electronics | `{}` (none) | `layerSetup` str<br>`copperLayers` list<br>`copperCount` int<br>`copperThickness_mm` list<br>`dielectricBonds` list (prepreg/core order)<br>`fr4` {x_mm,y_mm,dielectric_mm} | Read a board's PHYSICAL fabrication stackup (see the pcb-stackup skill): copper layer count + copper/dielectric thicknesses from the EAGLE design rules (layerSetup/mtCopper/mtIsolate)... | 200 | yes | - |+| `fusion_export_obj` | export | `outputPath`: required str | `format` str | Export to OBJ mesh. | 300 | yes | - |+| `fusion_export_dxf` | export | `outputPath`: required str | `format` str | Export 2D DXF. | 120 | yes | - |+| `fusion_export_dwg` | export | `outputPath`: required str | `format` str | Export 2D DWG. | 120 | yes | - |++---++## Manufacturing  (24)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_export_gerbers` | manufacturing | `outputDir`: optional str (default C:/tmp/adom-gerbers) | `fileCount` int<br>`files` [{name,size}]<br>`zipPath` str | Run the bundled JLCPCB CAM job (auto 2/4-layer) to produce the gerber + drill ZIP. | 180 | yes | - |+| `fusion_export_bom` | manufacturing | `outputPath`: optional str<br>`grouped`: optional bool (default true) | `componentCount` int<br>`grouped` bool | Export a Bill of Materials CSV (grouped by value+package) from the open board. | 60 | - | - |+| `fusion_export_cpl` | manufacturing | `outputPath`: optional str<br>`side`: optional str (all\|top\|bottom) | `topCount` int<br>`bottomCount` int | Export the Component Placement List (pick-and-place) CSV. | 60 | - | - |+| `fusion_set_design_rules` | manufacturing | `action`: optional str (apply\|export\|show)<br>`layers`: optional str (auto\|2\|4) | `activeWorkspace` str<br>`description` str | Load manufacturing-grade DRC into the open board (JLCPCB 2/4-layer profiles). | 90 | - | - |+| `fusion_detect_layers` | electronics | `{}` (none) | `layerCount` int<br>`copperLayers` [int] | Detect 2-layer vs 4-layer board (ULP + CAM comparison). | 90 | - | - |+| `fusion_dismiss_blocking_dialogs` | introspect/etiquette | `{}` (none) | `dialogs` [...] | Detect + classify (and optionally dismiss) blocking Fusion dialogs. | 30 | - | - |+| `fusion_electron_run` | electronics | `command`: required str | `success` bool<br>`output` str | Run an EAGLE/Electron command in the open board (the generic extension point, e.g. RUN <ulp>). | 90 | - | - |+| `fusion_electron_zoom` | electronics | `factor`: float (default 2.0)<br>`fit`: optional bool<br>`steps`: optional int (default 16)<br>`frameDelayMs`: optional int (default 35) | `success` bool<br>`output` str | Smoothly ZOOM the schematic/2D board for a recording (the whole motion is one call). | 60 | yes | - |+| `fusion_electron_pan` | electronics | `x1`: float<br>`y1`: float<br>`x2`: float<br>`y2`: float<br>`steps`: optional int (default 16)<br>`frameDelayMs`: optional int (default 35) | `success` bool<br>`output` str<br>`box` [...] | Smoothly PAN + zoom the view to frame a board-coordinate box (mm; get part positions from fusion_board_info). | 60 | yes | - |+| `fusion_electron_select` | electronics | `name`: str (refdes, e.g. R1)<br>`x`: optional float<br>`y`: optional float<br>`properties`: optional bool (default true) | `success` bool<br>`output` str<br>`deviceInfo` str | SELECT a part (by reference designator, or x/y board mm) and surface its properties - the way clicking a part reveals the properties panel. | 30 | yes | - |+| `fusion_prove_result` | introspect/etiquette | `runId`: optional str (omit for the latest run)<br>`inlineFrames`: optional bool<br>`shots`: optional int<br>`sinceShot`: optional int | `stage` str<br>`verdict` str<br>`evidence` []<br>`percent` float<br>`etaSec` float | POLL a background run started by fusion_create_library or the detached fusion_build_library_3d. | 20 | yes | - |+| `fusion_cancel_run` | introspect/etiquette | `runId`: optional str (omit for the latest run in flight) | `cancelRequested` bool<br>`runId` str<br>`stage` str at the time of the request<br>`statusVerb` fusion_prove_result | STOP a library import that is in flight (fusion_install_library_bundle / fusion_create_library) - the user's escape hatch from a long run, wired to a Cancel button in web control. | 10 | yes | `fusion_prove_result` |+| `fusion_addin_status` | lifecycle | `{}` (none) | `addinReady` bool<br>`port` int<br>`version` str<br>`busy` bool | Is the AdomBridge add-in loaded and answering inside Fusion? Reports addinReady, port and version, plus busy when a long command holds the main thread. | 15 | yes | - |+| `fusion_activate_document` | documents | `name`: required str (document name as reported by fusion_get_app_state) | `success` bool<br>`activeDocument` str | Make a named open document the ACTIVE one before driving it. | 60 | - | - |+| `fusion_action_ledger` | introspect/etiquette | `limit`: optional int (default 50) | `actions` [{at, action, detail}] | Read the append-only record of what the bridge did in the BACKGROUND on this machine - dialogs it answered, Untitled scratch docs it swept, Fusion auto-starts, add-in restarts. | 15 | yes | - |+| `fusion_save_to_cloud` | cloud | `name`: required str<br>`projectName`: optional str<br>`folderPath`: optional str<br>`description`: optional str | `success` bool<br>`urn` str | Save the ACTIVE document to Autodesk cloud storage with an explicit name and destination. | 180 | - | - |+| `fusion_take_screenshot` | introspect/etiquette | `outputPath`: optional str | `success` bool<br>`path` str | Screenshot the Fusion window in the BACKGROUND (no focus steal, reads through occlusion). | 60 | yes | - |+| `fusion_verb_times` | introspect/etiquette | `{}` (none) | `stages` {name: {count, p50, p90}} | This machine MEASURED timings per verb/stage - the same store that paces every progress bar and ETA. | 15 | yes | - |+| `fusion_library_parts` | library | `libraryPath`: required str (also accepts lbrPath/filePath/path) | `success` bool<br>`devicesets` [{name, description, variants:[{fullName, device, technology, package,...<br>`totals` {devicesets, variants, withMpn, withDistributor}<br>`metadataOk` bool<br>`warnings` [] | Every ORDERABLE variant in a .lbr with its part numbers - offline, no Fusion needed. | 15 | yes | - |+| `fusion_plan_library_import` | library | `parts`: optional [{package, lbrPath, modelPath}]<br>`stepPath`: optional single .step when not passing parts[]<br>`libraryPath`: optional .lbr for context | `success` bool<br>`fusion` {installed, running, addinReady, status, message}<br>`plan` [{stage, label, estimatedSec, confidence, needsUserConsent?}]<br>`estimatedSec` float<br>`estimatedSecIfAlreadyOpen` float<br>`summary` str | PRE-FLIGHT for a library import: does NO work and changes nothing. | 20 | yes | - |+| `fusion_live_feed` | introspect/etiquette | `action`: start\|stop\|status\|frames<br>`intervalSec`: optional float (default 1.0)<br>`maxSec`: optional float (default 600)<br>`since`: frames only: return ticks newer than this | `success` bool<br>`running` bool<br>`tick` int<br>`frames` [{tick, kind:main\|popup, path, title, at}] | A ~1 fps look INTO Fusion while the bridge drives it, kept as a BOX-SIDE ring buffer (~10 min). | 15 | yes | - |+| `fusion_restart_for_addin` | lifecycle | `save`: optional bool (default true) | `success` bool<br>`addinReady` bool<br>`tookSec` float<br>`steps` [{step, ok}] | ASYNC: returns immediately (started:true) and restarts Fusion in the background, SAVING the user's open documents first; poll fusion_readiness until ready with the new addinVersion (a... | 300 | - | - |+| `fusion_inspect_bodies` | documents | `worldSpace`: optional bool (resolve through occurrence transforms; default false = root component only)<br>`occurrence`: optional str (substring filter on occurrence name, worldSpace only) | `success` bool<br>`units` str (mm)<br>`bodyCount` int<br>`documentName` str<br>`bodies` [{name,owner,bbox:{x,y,z},sizeMm,volumeMm3,areaMm2,faceCount,cylindricalFaceCount,... | GEOMETRY READ-BACK: what actually got built, in MILLIMETRES. | 130 | - | `fusion_get_app_state` |+| `fusion_uninstall` | lifecycle | `dryRun`: optional bool (report the paths, delete nothing)<br>`cascade`: optional bool (set by ab)<br>`name`: optional str (set by ab) | `success` bool<br>`dryRun` bool<br>`fusionRunning` bool<br>`removed` [{path,kind}]<br>`failed` [{path,kind,error}]<br>`skipped` [{path,kind,why}] | CASCADE CLEANUP, called by ab's bridge_uninstall BEFORE this bridge's cache is deleted (ab 2.0.35+). | 60 | - | - |++---++## Self-describe  (1)++| verb | category | args (exact names + types + defaults) | key response fields | what it does | timeout | LR | statusVerb |+|---|---|---|---|---|---|---|---|+| `fusion_describe` | describe | `{}` (none) | `success` bool<br>`verbs` [{name,summary,input,output,timeoutSeconds,statusVerb,longRunning,example}] | Self-describe every verb the bridge exposes (this list) for ab's Verbs tab + runner. | 20 | - | - |++---++# Appendix++## (a) The exact `verbs[]` array in `bridge.json`++`bridge.json` (`manifest_version: 1`, `name: "fusion360"`, `version: 1.9.341`, `verbPrefixes: ["fusion_"]`)+lists **57** verbs — a hand-maintained *subset* of the 131 that `fusion_describe` returns. Routing is by+`verbPrefixes`, not by this list, so the extra 75 still route; the array is advertising, not a gate.++```+fusion_aps_browse            fusion_aps_create_folder     fusion_aps_download+fusion_aps_file_info         fusion_aps_get               fusion_aps_open+fusion_aps_recent            fusion_aps_search            fusion_aps_set_client_id+fusion_aps_signin            fusion_aps_status            fusion_aps_upload+fusion_aps_versions          fusion_attach_3d_package     fusion_board_info+fusion_build_library_3d      fusion_capture_library_views fusion_cleanup_cloud_files+fusion_close_window          fusion_describe              fusion_detect_layers+fusion_dismiss_blocking_dialogs                           fusion_electron_pan+fusion_electron_run          fusion_electron_select       fusion_electron_zoom+fusion_export_3mf            fusion_export_bom            fusion_export_cpl+fusion_export_dwg            fusion_export_dxf            fusion_export_gerbers+fusion_export_iges           fusion_export_obj            fusion_export_step+fusion_export_stl            fusion_export_usdz           fusion_generate_package+fusion_get_app_state         fusion_get_preferences       fusion_install_fusion+fusion_kill                  fusion_load_design_rules     fusion_make_3d_package+fusion_open_by_urn           fusion_open_lbr              fusion_readiness+fusion_run_modeling_script   fusion_search_cloud_files    fusion_set_design_rules+fusion_set_preference        fusion_show_2d_board         fusion_show_3d_board+fusion_show_schematic        fusion_start                 fusion_stop+fusion_walk_cloud_tree+```++**Drift found:** `fusion_load_design_rules` is the ONLY verb in `bridge.json`'s array that has **no**+`describe.py` entry (it is documented in `VERBS.md` but was never added to `_T`). The reverse drift is+75 verbs live-and-described but absent from `bridge.json`.++Other manifest fields worth mirroring into a `swx` bridge:+`statusVerb: "fusion_get_app_state"`, `uninstall: "fusion_uninstall"`,+`spawn: {kind: python, entrypoint: server.py, port: 0, healthEndpoint: "/status", stopMethod: kill, persistent: true}`,+`detect.installVerb: "fusion_install_fusion"`,+`detect.hostAppOptionalVerbs` (verbs allowed to run with the host app absent):+`readiness, describe, get_app_state, status, addin_status, aps_status, aps_search, aps_browse, aps_recent, install_fusion`,+and `timeouts` = `{default: 60, verbs: {...per-verb, keys WITHOUT the fusion_ prefix...}, prefixes: [{prefix: "open", seconds: 150}]}`.+Note the manifest `timeouts.verbs` numbers and `describe.py`'s `timeoutSeconds` are two separate stores and+do not always agree (e.g. `start`: 90 in the manifest, 150 in describe).++## (b) Response-envelope conventions the Fusion bridge uses++**1. `success` + `errorCode` + `error`.** Failures return `{"success": false, "errorCode": "<snake_case>", "error": "<human sentence>"}`.+Only `fusion_web_signin` declares `errorCode` in its describe schema, but the whole bridge emits it.+The full set of `errorCode` values found in `server.py` / `aps.py` / handlers:++```+3d_attach_failed            activation_refused          addin_not_answering+addin_restart_required      addin_restarting            adom_lbr_failed+adom_lbr_unavailable        artifact_not_in_library     bad_activity_mode+bad_bundle                  bad_code                    bad_menu_item+bad_name                    bom_walk_budget_exceeded    build_in_progress+code_field_not_found        command_running             confirm_missing+create_3d_package_failed    create_dialog_missing       file_not_found+foreground_reason_required  fusion_addin_busy           fusion_addin_not_responding+fusion_autostart_failed     fusion_host_hung            fusion_not_installed+fusion_not_running          google_sso_unavailable      human_credential_required+inspect_failed              installer_download_failed   installer_launch_failed+kicad_source_required       lbr_invalid                 lbr_preflight_failed+libio_menu_missing          library_manager_missing     library_not_active+library_open_failed         library_path_required       library_unreadable+main_thread_busy            no_2fa_window               no_3d_package_bound+no_3d_reference             no_cloud_project            no_fusion_window+no_input                    no_lbr                      no_path_argument+no_prove_run                no_run_in_flight            no_work_folder+not_a_library               not_found                   not_in_hub+not_linked_yet              not_listed                  picker_missing+pin_map_invalid             restart_failed              run_not_found+save_failed                 too_large                   unknown_package_type+unknown_run_id              unsaved_named_document      unsupported_extension+upload_in_flight_close_deferred                         use_open_board_instead+user_owns_restart           wrong_document              wrong_footprint_loaded++(from aps.py:)+aps_app_missing_product     aps_not_configured          aps_not_signed_in+refused_root_upload++(surfaced on a poll, not a direct return:)+cancelled_by_user           (with cancelledAt + how many parts were done)+```++The recurring shapes worth copying: `*_not_running` / `*_not_installed` / `*_busy` /+`*_not_responding` (host-app health), `*_restart_required` (host must be restarted to load the add-in —+returned as a payload the CALLER turns into the human ask, never a silent restart),+`foreground_reason_required` (etiquette gate, below), `unknown_run_id` / `run_not_found` / `no_run_in_flight`+(async run bookkeeping).++**2. `_hint` — the ONE principle.** Every meaningful response carries a `_hint` string telling the calling AI+its exact next action; the bridge assumes the AI reads CLI output, not the on-disk skill. `_hint` is+*appended to*, never replaced, by the etiquette wrapper (`dispatch_command` in `server.py` only appends its+note if `"focus was NOT touched"` is not already in the hint). Declared explicitly in describe for+`fusion_attach_3d_package` (`_hint`: "the Save-dialog click + verify steps") and referenced in the summaries of+`fusion_signin` and `fusion_demo`.++**3. No `_next` key.** Grep of `describe.py`, `server.py` and the docs finds **zero** `_next` usage — the+Fusion bridge folds "what to do next" into `_hint` plus the explicit `statusVerb` field. (If the SolidWorks+bridge wants a `_next`, it is a new convention, not a mirrored one.)++**4. `windowEtiquette` — a three-state ENUM, not a boolean.** `server.py` sets+`res.setdefault("windowEtiquette", "foreground" | "background")` on every verb in the `_WINDOW_RAISING` set.+Absent = "this verb does not report etiquette". The background branch also appends this exact `_hint`:++> "Window opened/changed in the BACKGROUND - the user's focus was NOT touched; do NOT foreground anything to+> compensate. Render results via fusion_state. If the USER asks to watch, re-call with+> {"foreground": true, "foregroundReason": "<why, shown to the user as a 3s caption>"}."++`_WINDOW_RAISING` (the annotated set, verb names WITHOUT the `fusion_` prefix):+`close_document, close_window, open_cloud_file, open_by_urn, aps_open, open_design, open_lbr, open_schematic,+open_board, import_electronics, import_step, new_electronics_from_eagle, show_schematic, show_2d_board,+show_3d_board, run_modeling_script, execute_text_command, electron_run, attach_3d_package, make_3d_package,+build_library_3d, capture_library_views, generate_package, export_optimized_glb, board_stackup, save_to_cloud,+start, show_symbol, show_footprint, show_3d_package, make_test_project, bind_library_3d, show_library,+show_project`.++**5. Progress / long-running frames.** There is no inline `progress` block in any describe output. Progress is+*polled*, via three distinct poll verbs:++| poll verb | started by | progress fields |+|---|---|---|+| `fusion_prove_result` | `fusion_install_library_bundle`, `fusion_create_library`, `fusion_build_library_3d` | `stage`, `verdict`, `evidence[]`, `percent` (float, MEASURED — never guessed), `etaSec` (float). Args `runId`, `inlineFrames`, `shots`, `sinceShot` |+| `fusion_demo_progress` | `fusion_demo {mode:"tour"}` | `percent` (int), `step`, `stepLabel`, `done`, `shots[]`, `shotCount`, `stepShot` (`dict\|absent`). Args `demoId`, `imagesAs` (`paths\|base64\|both`), `sinceShot` |+| `fusion_live_feed` | `{action:"start"}` | `running`, `tick`, `frames[{tick, kind:main\|popup, path, title, at}]`. Args `action` (`start\|stop\|status\|frames`), `intervalSec` (default 1.0), `maxSec` (default 600), `since` |++The **`sinceShot` windowing convention** (send only frames the caller has not already received) appears on both+`fusion_prove_result` and `fusion_demo_progress`; `fusion_live_feed` uses `since` for the same purpose.+`fusion_verb_times` returns `stages: {name: {count, p50, p90}}` — the *measured* history the percent/eta come+from. Rule stated in `dev-skills/fusion-verb-timing`: compute progress at READ time from measurements; never+present a guessed number as a measured one.++**6. Async handoff: `runId` + `statusVerb` + `longRunning`.** 71 of 131 verbs are `longRunning: true`+(they keep working after ab's relay timeout). A verb that cannot fit a relay window returns IMMEDIATELY with+`runId` (str) and a `statusVerb` *in the response body* naming what to poll+(`fusion_install_library_bundle`, `fusion_create_library`, `fusion_aps_open`, `fusion_install_fusion`,+`fusion_cancel_run`, `fusion_describe` carry the `statusVerb` response key). `fusion_cancel_run {runId?}` →+`{cancelRequested, runId, stage, statusVerb: "fusion_prove_result"}`; cancellation surfaces on the NEXT poll as+`errorCode: cancelled_by_user` + `cancelledAt`. Per-verb `statusVerb` in the describe table:+`fusion_get_app_state` (19 verbs), `fusion_mcp_status` (5), `fusion_prove_result` (3), `fusion_readiness` (3),+`fusion_get_preferences` (2), `fusion_state` (2), and one each of `fusion_signin`, `fusion_demo`,+`fusion_aps_status`; 95 verbs declare none.++**7. `capture: true` = ONE call, ONE consent.** On `fusion_install_library_bundle`, `fusion_show_schematic`,+`fusion_show_2d_board`, `fusion_show_3d_board`, `fusion_build_library_3d`, `fusion_show_symbol`,+`fusion_show_footprint`, `fusion_show_3d_package`, `fusion_show_library`, `fusion_show_project`. The bridge+settles the surface (waits for the add-in main thread + a paint beat) and returns proof **inline** as+`shot: {title, image, thumbnailDataUrl, maxWidth}` — base64 frame plus a ready-to-use `data:` URL for browser+callers. `captureMaxWidth` shrinks it (320 keeps a `/command` body small; default 640). The bridge encodes PNG+but the relay may transcode to WebP — **sniff, do not assume**. This exists so callers stop polling+`fusion_state` after a show, because each page-side poll costs one human consent (issue #30).++**8. Image return convention.** Verbs that produce images accept an `imageAs` / `imagesAs` arg+(`path` | `base64` | `both`, default `path`) and return `screenshot` (str path) plus `screenshotBase64` when+base64 was asked for.++**9. `fusion_describe` double-nesting.** The describe handler returns+`{success, bridge:"fusion360", verbCount, verbs:[...], data:{bridge, verbCount, verbs}}`. `verbs` at the TOP+level is what ab's Verbs tab reads off the raw `/command` response; ab's relay STRIPS non-standard top-level+fields on the CLI proxy path, so the same payload is repeated under `data` (which the relay forwards).+Any `swx_describe` must do the same double-nesting. Per-verb entry shape:+`{name, summary, input, output, timeoutSeconds, statusVerb, longRunning, example}`; entries whose name ends in+`_note` are filtered out of the emitted list (doc-only rows in the table).++**10. Quietness audit log.** `fusion_state` returns `focusEvents: [{at, verb, outcome: "foreground"|"refused", reason}]`+— every time the bridge took the user's foreground OR refused a bare `foreground:true`. `fusion_action_ledger+{limit=50}` returns `actions: [{at, action, detail}]`; `fusion_alerts {sinceSec=300}` returns `alerts: [{at, text}]`.++## (c) Verbs that are gated / require a `reason`++**Foreground etiquette gate (hard-enforced, returns `errorCode: foreground_reason_required`).**+Declared in `describe.py` on three verbs — `fusion_show_symbol`, `fusion_show_footprint`,+`fusion_show_3d_package` — with the identical arg pair:++- `foreground`: `optional bool` — **DEFAULT IS BACKGROUND** (no focus steal; response carries `windowEtiquette:"background"`). `true` REQUIRES `foregroundReason` and shows it to the user as a 3s ab caption before any focus change — only when the USER asked to watch.+- `foregroundReason`: **required WITH `foreground:true`** — a short user-facing sentence shown as the 3s caption (e.g. "You asked to watch the 3D board build").++`server.py` enforces it for the whole `_WINDOW_RAISING` set (list in §b4), not just those three: a bare+`foreground:true` with no `foregroundReason` is REFUSED with+`{"success": false, "errorCode": "foreground_reason_required", "error": "foreground:true needs foregroundReason (a short user-facing sentence)."}`+and the refusal is recorded in `fusion_state.focusEvents` as `outcome:"refused"`. When the gate passes, the+bridge strips `foreground`/`foregroundReason` before forwarding to the add-in.++**Soft `reason` (optional, defaulted — used as the caption text, never blocking).** `server.py` calls+`_notify_before_foreground(args.get("reason") or "<default sentence>")` for the foreground-click and+foreground-keypress paths, and passes `reason: args.get("reason") or "sign in to an Autodesk web surface"` on+the `fusion_web_signin` path.++**Other gates that are not `reason`-shaped but block the same way:**+- **`.lbr` preflight gate** — `fusion_open_lbr` and `fusion_create_library` run `fusion_preflight_lbr`'s checks automatically and refuse with `lbr_preflight_failed` / `library_unreadable` / `not_a_library` / `lbr_invalid`.+- **Add-in restart gate** — `addin_restart_required` / `user_owns_restart`: the add-in was installed or updated while Fusion was already open. The bridge returns the payload and the CALLER must turn it into a human ask (`fusion_restart_for_addin` exists but the restart is the user's to own).+- **Human-credential gate** — `human_credential_required`, `no_2fa_window`, `google_sso_unavailable` on the sign-in verbs (`fusion_signin`, `fusion_signin_2fa`, `fusion_web_signin`, `fusion_aps_signin`); `fusion_signin` reports the exact wall in `signinWall`: `twofactor_email_code | credentials | protocol_handoff` (plus `signinWallHint`).+- **Never-charge gate** — the manifest description states APS calls are capped to the free tier; `fusion_aps_*` refuse with `aps_not_signed_in` rather than falling back to a paid path.+- **Main-thread / busy gates** — `main_thread_busy`, `fusion_addin_busy`, `command_running`, `build_in_progress`, `upload_in_flight_close_deferred`.+- **Root-upload refusal** — `refused_root_upload` on `fusion_aps_upload` (no uploading to a hub root).

@@ -0,0 +1,921 @@+# Rebuilding the NSF machine crate in SOLIDWORKS, through the swx bridge++The SOLIDWORKS bridge's first real production job: take the NSF PCL machine-crate+build packet (wiki `adom/nsf-pcl`, `september-dc-event/machine-crate`, rev D) and+rebuild ONE crate as real SOLIDWORKS parts and assemblies — geometry, materials,+custom properties, fasteners — and export a BOM **from the SOLIDWORKS assembly**,+not from the wiki page.++Everything below happened on Drew's machine, live, against SOLIDWORKS Design+Professional for Makers 2026 (3DEXPERIENCE Connected, R2026x), driven entirely by+`swx_*` verbs from a container. The bridge stayed in its **default deny-by-default+posture** for the whole job: `SWX_ALLOW_USER_WRITES` was never set, so nothing the+user owns could be touched. Every document and every file in this build was+created by the bridge, in a new folder (`C:\Users\Public\adom-crate\`).++---++## 1. What had to be built into the bridge first++The job was gated on one thing the bridge could not do: **put components into an+assembly**. Without that there is no assembly, and without an assembly there is no+BOM. The parity report had written this off:++> `IAssemblyDoc::AddComponent5` returned `Nothing` for every combination tried+> live … The most likely explanation is that SOLIDWORKS **Connected** does not+> permit local-file component references.++That conclusion was wrong, and finding out why is the most valuable thing in this+log.++### Finding 1 — AddComponent5 works. Its RETURN VALUE is the lie.++`AddComponent5` really does return `Nothing` on this edition. It also really does+insert the component. The earlier probe measured success by the return value, so+it saw a failure that had not happened.++The fix is to stop trusting the return and **count the assembly's components+before and after the call**. `swx_add_component` does exactly that, and walks a+ladder of spellings (`AddComponent5` with each `swAddComponentConfigOptions_e`+value, then `AddComponent4`, `AddComponent3`, `AddComponent`) until the count+rises. On this install the rung that works is:++```+AddComponent5(path, 0, "", false, config, x, y, z)      # config option 0+```++Options 1, 2 and 3 all silently do nothing. The winning rung is cached, so a+400-fastener assembly pays the discovery cost once, not 400 times.++### Finding 2 — AddComponent5's X/Y/Z is NOT the component's origin.++Measured, not assumed. A part whose own centroid sits at (50, 6, -25) mm,+inserted at (0, 0, 0), leaves the assembly's centre of mass at the origin — i.e.+SOLIDWORKS centred the component on the point rather than putting its origin+there.++So `swx_add_component` writes each component's transform itself, after insertion,+via `IMathUtility::CreateTransform` + `IComponent2::Transform2`. `xMm/yMm/zMm`+then mean exactly one thing: *put the component's origin here*. Rotation+(`rotXDeg/rotYDeg/rotZDeg`) comes free with it — and rotation is not optional for+a crate, because the same ripped rail is used lying two different ways.++Because the insert call returns no handle, the components a batch inserted are+found by **matching the sequence of file paths** against the assembly's component+list — one contiguous run, forwards or backwards. That is O(n) COM calls for the+whole batch instead of a search per component, and it *proves* the mapping: if no+run matches, nothing is written and the response says so.++### Finding 3 — SOLIDWORKS' MathTransform 3x3 is COLUMN-major.++Filling `ArrayData[0..8]` row-major put a component rotated +90° about Z at −90°+instead. For the axis-aligned quarter turns a crate is made of, a transposed+rotation is a rotation the other way — silently wrong rather than obviously+broken. Caught by computing the expected assembly centre of mass in Python and+comparing: with the transpose fixed, three blocks at (0,0,0), (0,300,0)+Rz90 and+(600,0,0)+Ry90 give a measured CoM of **(206.333, 120.667, −33.333) mm** against a+predicted (206.333, 120.667, −33.333). Exact.++### Finding 4 (bug) — `run_script`'s documents were invisible to the com host.++`swx_close_doc` on a part the bridge had *just built* was refused:++> the com host refuses to close_doc: this document was not created by this bridge++`created_document()` looked for `{title, path}` under the result's `created` key,+but `run_script` nests: its `created` is the whole `new_document` result, whose+own `created` carries the title. The server's registry descended; the host's did+not. So the two ownership records disagreed, and the bridge would not clean up+after itself. Fixed (`src/comhost/host.rs`), with a unit test for both shapes.++### Finding 5 (bug, NOT fixed) — a bridge restart orphans the bridge's own documents.++The com host's record of what it created is persisted (`created_store`); the+**server's** scratch registry is in-memory only. Restart the server and it+disowns every document it made, while the host still owns them — the two vetoes+disagree in the direction that blocks cleanup, so the bridge can no longer close+its own scratch documents and they are stranded in the user's session.++Not fixed here (the honest fix is a second, independently-written persisted+registry on the server side — reading the host's file would collapse "two+independent vetoes" into one). Cost of this bug in this session: a handful of+orphaned scratch documents left open in Drew's SOLIDWORKS during bridge+development, before the crate build proper began.++### What shipped++`swx_add_component` — new verb, `components:[{filePath,xMm,yMm,zMm,rotXDeg,rotYDeg,rotZDeg,configuration}]`,+one batch per call, gated exactly like every other document-modifying verb+(the assembly must be one the bridge created; the component files are only read,+so they are not part of the gate). Plus `Var::r8_array` (the first SAFEARRAY this+bridge builds rather than reads), `script::parse_components`, `Component::transform`+and `script::locate_run` — all four unit-tested on Linux, plus an end-to-end+`swx_add_component` → `swx_bom` round trip in the e2e suite. Suites green: 79 unit,+28 e2e, 11 protocol.++---++## 2. The crate model++### Coordinate system++One frame for the whole crate, in the packet's own terms:++* **X** = the 96″ length, 0 at the near end plane.+* **Y** = the 48″ width, 0 at the near side plane.+* **Z** = height, **0 at the underside of the 2x4 base ring** (the caster mounting face).++The gravity stack, taken straight from D0 but with the plywood at its **as-purchased+15/32″** thickness rather than the packet's nominal ½″:++| | from | to |+|---|---|---|+| 2x4 base ring | 0 | 1.500 |+| deck ply `P1` | 1.500 | 1.96875 |+| walls (45″) | 1.96875 | 46.96875 |+| cap ply `P2` | 46.96875 | 47.4375 |+| cap ring | 47.4375 | **48.9375** |++48.9375″ against the packet's "49″ box" — the 1/16″ is the two sheets of 15/32″+plywood being 1/32″ thinner each than the ½″ the drawings round to. Every wall is+1.96875″ thick (rail 1.5 + ply 0.46875), which is the packet's "2″ thick" face.++### Parts++Lumber is **actual** size, never nominal: a 2x4 is 1.5 x 3.5, and the ripped rail+stock is 1.75 x 1.5 (mounted 1.5″ proud, exactly as C2 specifies). Every part was+built by `swx_run_script` (`new_part` → `sketch_rect` → `extrude` → `set_material`+→ six `set_prop`s), verified with `swx_inspect_bodies`, then `swx_save_as`'d into+`C:\Users\Public\adom-crate\parts\`.++| PartNo | Description | Size (in) | Size (mm) | Material | Qty/crate |+|---|---|---|---|---|---|+| `P1` | Base deck ply, 48 x 96 x 15/32 CDX (full sheet, no cuts) | 96 x 48 x 0-15/32 | 2438.400 x 1219.200 x 11.906 | Pine | 1 |+| `P2` | Cap ply, 48 x 96 x 15/32 CDX (full sheet, no cuts) | 96 x 48 x 0-15/32 | 2438.400 x 1219.200 x 11.906 | Pine | 1 |+| `P3` | Side wall ply, 96 x 45 x 15/32 CDX (one rip) | 96 x 45 x 0-15/32 | 2438.400 x 1143.000 x 11.906 | Pine | 2 |+| `P4` | End wall ply, 43-7/8 x 45 x 15/32 CDX | 45 x 43-7/8 x 0-15/32 | 1143.000 x 1114.425 x 11.906 | Pine | 2 |+| `P5` | Side-station backer, 12 x 12 x 15/32 CDX (from offcuts) | 12 x 12 x 0-15/32 | 304.800 x 304.800 x 11.906 | Pine | 4 |+| `R1` | Ripped rail 96in - side top/bottom rails + cap long rails | 96 x 1-3/4 x 1-1/2 | 2438.400 x 44.450 x 38.100 | Pine | 6 |+| `R2` | Ripped rail 41-1/2in - wall verticals | 41-1/2 x 1-3/4 x 1-1/2 | 1054.100 x 44.450 x 38.100 | Pine | 12 |+| `R3` | Ripped rail 45in - end edge rails, full height | 45 x 1-3/4 x 1-1/2 | 1143.000 x 44.450 x 38.100 | Pine | 4 |+| `R4` | Ripped rail 40-3/8in - end top/bottom rails | 40-3/8 x 1-3/4 x 1-1/2 | 1025.525 x 44.450 x 38.100 | Pine | 4 |+| `R5` | Ripped rail 44-1/2in - cap end rails + crossmembers | 44-1/2 x 1-3/4 x 1-1/2 | 1130.300 x 44.450 x 38.100 | Pine | 5 |+| `B1` | 2x4 96in - base long rails | 96 x 3-1/2 x 1-1/2 | 2438.400 x 88.900 x 38.100 | Pine | 2 |+| `B2` | 2x4 41in - base end rails | 41 x 3-1/2 x 1-1/2 | 1041.400 x 88.900 x 38.100 | Pine | 2 |+| `B3` | 2x4 41in - base crossmembers | 41 x 3-1/2 x 1-1/2 | 1041.400 x 88.900 x 38.100 | Pine | 3 |+| `B4` | 2x4 10in - corner caster doubler pads | 10 x 3-1/2 x 1-1/2 | 254.000 x 88.900 x 38.100 | Pine | 4 |+| `B5` | 2x4 43-7/8in - end pull handle | 43-7/8 x 3-1/2 x 1-1/2 | 1114.425 x 88.900 x 38.100 | Pine | 2 |+| `B6` | 2x4 43-7/8in - payload hold-down bar | 43-7/8 x 3-1/2 x 1-1/2 | 1114.425 x 88.900 x 38.100 | Pine | 2 |+| `B7` | 2x4 12in - side-station spacer block (rip to fit) | 12 x 3-1/2 x 1-1/2 | 304.800 x 88.900 x 38.100 | Pine | 8 |+| `FM1` | Foam bed strip, 2in PE plank 4 x 88in | 88 x 4 x 2 | 2235.200 x 101.600 x 50.800 | PE Low/Medium Density | 2 |+| `FM2` | Foam pad under hold-down bar, 1in PE plank | 43-7/8 x 3-1/2 x 1 | 1114.425 x 88.900 x 25.400 | PE Low/Medium Density | 2 |+| `FM3` | Foam side-station pad, 2in PE plank 12 x 12in | 12 x 12 x 2 | 304.800 x 304.800 x 50.800 | PE Low/Medium Density | 4 |+| `FM4` | Foam end thrust pad, 2in PE plank (cut to fit at pack) | 24 x 24 x 2 | 609.600 x 609.600 x 50.800 | PE Low/Medium Density | 2 |++**Materials.** This install's `SOLIDWORKS Materials.sldmat` has a `Woods` category+of exactly: Balsa, Beech, Cedar, Mahogany, Maple, Oak, Pine, Teak. There is no+"Plywood" and no "SPF"/"whitewood", so **`Pine`** is the honest closest match for+both the 15/32″ CDX and the KD whitewood 2x4s, and the real specification lives in+each part's `Material` and `Description` custom properties. Foam is+`PE Low/Medium Density`; fasteners are `Galvanized Steel`.++*Caveat, stated rather than hidden:* the SOLIDWORKS PE material is **solid**+polyethylene (~920 kg/m³). The crate's foam is 1.7 pcf plank (~27 kg/m³), so any+mass number that includes the foam parts overstates them by ~34x. The wood and+fastener masses are sound.++### Assembly structure++Five assemblies, not one flat pile, because the packet builds five things+(D1-D4 plus the crate) and a BOM that rolls up is worth more than one that does+not. `swx_bom`'s default flattens the whole tree, so a screw inside a side panel+that is instanced twice is counted twice.++| Assembly | Contents | Instances in the crate |+|---|---|---|+| `ASM-SIDE-PANEL` | 49 x F-8x125, 1 x P3, 2 x R1, 5 x R2 | 2 |+| `ASM-END-PANEL` | 1 x B5, 25 x F-8x125, 4 x F-L25x300, 4 x F-W10, 1 x P4, 1 x R2, 2 x R3, 2 x R4 | 2 |+| `ASM-CAP` | 49 x F-8x125, 1 x P2, 2 x R1, 5 x R5 | 1 |+| `ASM-BASE` | 2 x B1, 2 x B2, 3 x B3, 4 x B4, 6 x CASTER-6, 49 x F-8x200, 24 x F-L25x250, 1 x P1 | 1 |+| `ASM-CRATE` | 1 x ASM-BASE, 1 x ASM-CAP, 2 x ASM-END-PANEL, 2 x ASM-SIDE-PANEL, 2 x B6, 8 x B7, 108 x F-10x3, 2 x FM1, 2 x FM2, 4 x FM3, 2 x FM4, 4 x P5 | 1 |++Total component instances placed: **383** (245 in the sub-assemblies, 138 at the crate level).+++### Geometry verification++Every part was verified twice: once as it was built (`swx_inspect_bodies` between+the extrude and the save), and again as a FILE — each `.sldprt` reopened+read-only, its solid body's bounding box read back in millimetres, and its custom+properties read back, then closed. The second pass is the one that matters: it+proves what is on disk, not what a step list claimed.++The predicted numbers come from the packet's inch dimensions x 25.4, computed+independently in the generator (`crate.py`) rather than read off the model.+++### The assembly order, and where the interference check goes++The packet's A1 order is followed: base deck-down first, then the panels framed,+then the walls onto the deck, the ends dropped in between the side plies, the+bracing, and the cap last.++One deliberate choice about verification: **the interference check is run with+only the WOOD in the assembly, before any fastener goes in.** Screws are meant to+be embedded in timber, so an interference count taken after they are placed says+nothing — every screw is an "interference" by design. Wood-to-wood is the number+that means something, and it is the number the packet itself quotes+("0 interferences, 142 flush contacts").++The same check is also run independently in the generator, in Python, over+axis-aligned boxes before SOLIDWORKS is touched at all:++```+structural boxes: 74+X  -1.50000 ..  97.50000   (99.00000)   <- 99" over the handles+Y   0.00000 ..  48.00000   (48.00000)+Z   0.00000 ..  48.93750   (48.93750)   <- the "49 inch box"+box X (handles excluded): 0.00000 .. 96.00000  (96.00000)+interior clear: 92.06250 x 44.06250 x 45.00000+wood-to-wood interferences: 0+flush contacts: 170+```++against the packet's "footprint 96 x 48″ exact, 49″ box, interior 92 x 44 x 45″+clear, 99″ over the handles". Two independent computations of the same crate+agreeing is worth more than either one alone.++---++## 3. Bridge bugs and rough edges found doing real work++Beyond the two fixed above, this job surfaced these. They are worth as much as+the crate.++| # | What | Severity | Status |+|---|---|---|---|+| 1 | `AddComponent5` returns `Nothing` while succeeding — an entire capability was written off because the probe trusted the return value | high | worked around in `swx_add_component` (count, don't trust) |+| 2 | `AddComponent5`'s X/Y/Z is not the component's origin (it centres the component on the point) | high | worked around — the verb writes the transform itself |+| 3 | `MathTransform` `ArrayData`'s 3x3 is **column**-major; row-major fills rotate the wrong way, silently | high | fixed in `Component::transform`, unit-tested |+| 4 | `created_document()` did not descend `run_script`'s nested `created`, so the com host disowned every document the modelling DSL built and refused to close it | high | **fixed** |+| 5 | A bridge-server restart orphans the bridge's own documents: the com host's ownership record is persisted, the server's is memory-only, so they disagree in the direction that blocks cleanup | medium | **open** — needs a second, independently-written persisted registry on the server |+| 6 | The DSL's `save_as` is COPY mode, so the document stays untitled/unsaved and neither registry learns the path. The file is fine; the open document is not the file. `swx_save_as {copy:false}` is what a build script actually wants | low | documented; the crate build uses `swx_save_as` |+| 7 | `swx_add_component` reports the inserted component's `name` from the last entry of `GetComponents`, which is not reliably the newest — cosmetic, and it never feeds the transform mapping (that matches by path sequence) | low | open, cosmetic |+| 8 | Two `swx-batch` runs against the bridge at once interleave. The bridge serialises each CALL correctly, but a verb that resolves "the active document" then belongs to whichever batch touched it last | low | not a bridge bug so much as a documented hazard — **target every mutating verb explicitly** |+| 9 | `swx_com_eval` refused `$doc.GetMaterialPropertyName2("")` with *"Parameter not optional"* — the read allowlist is fine, the arity is not | low | open |++---++## 4. Fasteners++Drew's instruction, twice repeated and then a third time for the casters: **real+McMaster-Carr 3-D STEP models, not simplified cylinders**, with the head style+matched to the SPAX items actually bought at Lowe's, and the caster matched to the+YAEMIKY units bought on Amazon. The simplified-cylinder fallback was demoted to a+last resort, per item, with a logged reason.++Each STEP is imported with `swx_import`, given its material and custom properties+(including the McMaster part number, head style and drive style) with+`swx_run_script`, measured with `swx_inspect_bodies` + `swx_mass_properties`, and+saved as a `.sldprt` into `C:\Users\Public\adom-crate\fasteners\`.++**On orientation.** A vendor STEP arrives in the vendor's coordinate system, so+nothing about it is assumed. Each model's own bounding box gives the shank axis+(the long dimension), and the centre of mass says which END the head is on — a+head is heavier per unit length than a shank. Both are read back out of SOLIDWORKS+and fed to the placement maths, which then works in the packet's terms: *put this+screw's head bearing face here, driven that way.*++### Fastener sourcing — as purchased → McMaster++Every row is a real McMaster product page driven in `pup`, the CAD selector set to+**"3-D STEP no threads"**, and the file downloaded. No fabricated part numbers, no+simplified-cylinder fallbacks anywhere in this build. Compromises are named, not+buried.++| Tag | As purchased | McMaster P/N | Head / drive | Match |+|---|---|---|---|---|+| `F-10x3` | SPAX #10 x 3″ washer-head T-Star (Lowe's 3753135 / 3753046) | **90396A180** | Flanged rounded washer head, Torx | Head style **exact**. **Size compromise:** McMaster's only washer-head Torx wood-screw family (90396A) is No. 8 only, so this is #8 x 3-1/8″, not #10 x 3″. (An exact #10 x 3″ body with the *wrong* head, 90031A257, was also downloaded as an alternate.) |+| `F-8x125` | SPAX #8 x 1¼″ (Lowe's 3753042) | **3597N17** | Flat countersunk 82°, Torx | **Exact**, head and drive |+| `F-8x200` | SPAX #8 x 2″ (Lowe's 3753044) | **90031A205** | Flat countersunk 82°, Phillips | Head **exact** (0.332″ x 0.1″, 82°). **Drive compromise:** the Torx flat-head zinc family stops at 1¼″ |+| `F-L25x250` | SPAX ¼ x 2½″ washer-head (Lowe's 5641068) | **95526A175** | Flanged washer-face hex head, ext. hex | Head style **correct** — a PowerLag HexWasher head, 0.56″ flange, *not* a plain hex lag bolt. **Drive compromise:** external hex vs T-Star; McMaster has no round-washer-head Torx at ¼″ |+| `F-L25x300` | SPAX ¼ x 3″ PowerLag (Lowe's 3753018) | **95526A200** | Flanged washer-face hex head, ext. hex | Same family as above |+| `F-W10` | #10 ¾″ washers (Lowe's 61697) | **91090A126** | Oversized round flat washer | **Exact**: 0.203″ ID, 0.750″ OD, 0.047″ thick |+| `CASTER-6` | YAEMIKY 6″ PU, all swivel + brake, 3,000 lb/set of 4 (Amazon 112-2336638-0154627) | **2498T652** | Top-plate mount, 4-5/8 x 3¾″ | 6″ PU wheel 95A, **total-lock** brake, **overall height 7½″ exactly** (the packet's 56½ − 49), **820 lb each** vs 750 implied. ⚠ **Bolt pattern NOT verified against the YAEMIKY part** — Amazon returned HTTP 503 to `pup` and `nbrowser` was not used, so 3-5/8 x 3 / 3 x 2-5/8″ is McMaster's standard plate for this class. *Measure a real caster before drilling the deck.* |++Two flags worth repeating out loud, because they are the kind of thing that gets+lost between a model and a shop:++1. **`F-10x3` is a #8 shank, not #10.** The head — which is what Drew specified and+   what does the work in a washer-head structural screw — is exact. The shank is+   one gauge light. If pilot-hole geometry matters more than head bearing area,+   `F-10x3-ALT-exact-size.step` (90031A257) is the exact #10 x 3″ body with a+   countersunk head.+2. **The caster's bolt pattern is McMaster-standard, not measured.** Everything+   else about it — mount type, wheel, brake, height, capacity — matches or beats+   the as-purchased part.++**A unit bug worth recording**, because it is the kind the generator/read-back+split is *for*: `FAST_FRAME`'s head offsets are millimetres (they are measured out+of SOLIDWORKS) while the packet's dimensions are inches, and the first version of+the placement maths subtracted one from the other before converting. It put a+caster 2.4 metres below the crate. Caught immediately by printing one placement+and reading it, not by looking at a picture.+++---++## 5. How this was driven++Everything went through `tools/swx-batch.py` (staged call lists run in ONE round+trip to the desktop) plus a generator, `crate.py`, that owns every number. The+generator is the single source of truth: it holds the packet's inch dimensions,+converts to millimetres once, computes every component's position and rotation,+and runs its own interference and extents check before a single COM call is made.+SOLIDWORKS is then asked to build exactly what the generator computed, and the+model is read back and compared.++That split matters. A build script that computes positions inline and asserts+nothing is a script that can be confidently, quietly wrong — which is exactly the+failure mode the column-major transform bug had.++**A hazard worth recording:** two `swx-batch` runs were briefly in flight at once+during the part build. The bridge serialises each call correctly, but a verb that+resolves *"the active document"* belongs to whichever batch touched it last, so+the two runs could interleave onto each other's documents. Nothing was lost —+the part files are verified against the generator afterwards, one by one, which+is precisely the check that catches it — but the lesson is: **target every+mutating verb explicitly**, and never run two batches against one SOLIDWORKS.++---++## 6. Where everything is++On Drew's machine, under `C:\Users\Public\adom-crate\` — a folder the bridge+created, so nothing in this build ever needed the write opt-in:++```+parts\        P1 P2 P3 P4 P5  R1..R5  B1..B7  FM1..FM4      21 .sldprt+fasteners\    F-10x3 F-8x125 F-8x200 F-L25x250 F-L25x300+              F-W10 CASTER-6                                  7 .sldprt (+ the .step they came from)+_dl_archive\  the original McMaster downloads, untouched+ASM-SIDE-PANEL.sldasm  ASM-END-PANEL.sldasm+ASM-CAP.sldasm         ASM-BASE.sldasm       ASM-CRATE.sldasm+crate-bom.csv          ASM-CRATE.glb         ASM-CRATE.step+```++In this repo: `docs/crate-bom.csv` (the same CSV, pulled back) and this log.++**And a second, sharper version of the same hazard:** killing the local Python+that started a batch does **not** stop it. `tools/swx-batch.py` stages the call+list on the desktop and runs the whole list inside ONE remote PowerShell loop, so+the loop keeps POSTing to the bridge long after the process that launched it is+gone. Twice in this build a batch that looked dead was still driving SOLIDWORKS.+The only reliable signal is that no `adom-bridge … shell_execute` is in flight.++The recovery from that is worth stating too, because it is the shape of the whole+build: **the generator holds the truth, so damage is detectable.** Every part file+is reopened and its bounding box compared against the generator's numbers; a file+that does not match is deleted and rebuilt. Nothing is trusted because it was+written once.++---++## 7. What this proves about the bridge++The headline is not the crate. It is that **the whole `swx_*` assembly surface —+`swx_add_component`, `swx_bom`, `swx_interference`, per-component+`swx_mass_properties` — is live-proven on SOLIDWORKS Connected**, on the very+edition where the parity report had written it off as impossible. The report's+evidence was sound; its conclusion was not, and the difference was one+assumption: that a COM call which returns `Nothing` did nothing.++Three things generalise beyond SOLIDWORKS:++1. **Measure the effect, not the return value.** `AddComponent5` lies about+   whether it worked, and it lies about where it put the component. Both were+   caught by asking the model rather than the API.+2. **Keep the truth outside the CAD system.** Every dimension, position and+   rotation in this crate is computed in one generator that also runs its own+   interference and extents check. SOLIDWORKS is then asked to build it, and the+   result is read back and compared. That is what turned a silently-transposed+   rotation matrix and a mixed inch/millimetre subtraction into ten-minute bugs+   instead of a crate that looks right in a screenshot.+3. **Deny-by-default cost nothing.** This entire build — 21 parts, 7 imported+   fasteners, 5 assemblies, ~383 component instances, a BOM and three exports —+   ran with `SWX_ALLOW_USER_WRITES` unset. Every refusal the bridge issued was+   correct, and every one of them pointed at a targeting mistake on my side.++---++## 8. Handoff — exact state, and how to resume++Written so this can be picked up cold.++**Driver files** live in the session scratchpad+(`/tmp/claude-1001/-home-adom-project/ca530728-41cc-4f93-a92d-d32d4afe1153/scratchpad/`):++| File | What it is |+|---|---|+| `crate.py` | **the single source of truth.** Every packet dimension, the part table, all placements and rotations, the fastener frame maths. Inches in, millimetres out, converted once. |+| `check.py` | the pre-flight interference + extents check, pure Python, no CAD |+| `gen_asm.py` | turns `crate.py`'s placements into `swx_add_component` payloads, chunked 40 per call |+| `build_asm.py` | builds ONE assembly: new doc → wood → interference + mass → fasteners → save_as |+| `swx/pipeline.py` | the whole remaining job as sequential, checkpointed stages |+| `swx/import_fasteners.py` | STEP → part, with the axis/head measured off the model |+| `swx/fspec.json`, `swx/sourcing.json` | the fastener spec and the as-purchased → McMaster table |+| `swxb.py` | `tools/swx-batch.py` with the `Crate Rebuild` ai-thread |++**Resume:** `python3 swx/pipeline.py cleanup,verify,repair,assemblies,finish`.+Each stage writes `swx/stage_<name>.json` and is skipped if that file exists, so+a killed run picks up where it stopped. Delete a stage file to force it again.++**Two rules that this build learned the hard way, and that a resumer must keep:**++1. **Never run two batches against one SOLIDWORKS.** They interleave, and any verb+   that resolves "the active document" then belongs to whichever batch touched it+   last. Four part files went missing that way.+2. **Killing the local Python does not stop the batch.** `swx-batch` runs the whole+   call list inside one remote PowerShell loop on the desktop; it keeps driving+   SOLIDWORKS until the desktop-side timeout. Check that no+   `adom-bridge … shell_execute` for this thread is in flight before starting+   anything new.++---++## 9. State at handoff++### Geometry verification — measured, first pass++Read back out of each `.sldprt` FILE (opened, `swx_inspect_bodies`, closed), against+the generator's numbers. **14 of 21 correct**; the seven failures are the+signature of the concurrent-batch hazard in §5, not of the modelling:++```+  P1    expect  2438.400  1219.200    11.906  got  2438.400  1219.200    11.906  OK+  P2    expect  2438.400  1219.200    11.906  got  2438.400  1219.200    11.906  OK+  P3    expect  2438.400    11.906  1143.000  got  2438.400    11.906  1143.000  OK+  P4    expect    11.906  1114.425  1143.000  got    11.906  1114.425  1143.000  OK+  P5    expect   304.800    11.906   304.800  got   304.800    11.906   304.800  OK+  R1    expect  2438.400    38.100    44.450  got  2438.400    38.100    44.450  OK+  R2    expect    44.450    38.100  1054.100  got    44.450    38.100  1054.100  OK+  R3    expect    38.100    44.450  1143.000  got    38.100    44.450  1143.000  OK+  R4    expect    38.100  1025.525    44.450  got    38.100  1114.425    88.900  MISMATCH+  R5    expect    44.450  1130.300    38.100  got    88.900  1114.425    38.100  MISMATCH+  B1    expect  2438.400    88.900    38.100  got  2438.400    88.900    38.100  OK+  B2    expect    88.900  1041.400    38.100  got    88.900  1041.400    38.100  OK+  B3    expect    88.900  1041.400    38.100  got    88.900  1041.400    38.100  OK+  B4    expect   254.000    88.900    38.100  got            (file absent)       MISSING+  B5    expect    38.100  1114.425    88.900  got    38.100  1114.425    88.900  OK+  B6    expect    88.900  1114.425    38.100  got    88.900  1114.425    38.100  OK+  B7    expect   304.800    88.900    38.100  got  2438.400    88.900    38.100  MISMATCH+  FM1   expect  2235.200   101.600    50.800  got    88.900  1041.400    38.100  MISMATCH+  FM2   expect    88.900  1114.425    25.400  got    88.900  1041.400    38.100  MISMATCH+  FM3   expect   304.800    50.800   304.800  got   254.000    88.900    38.100  MISMATCH+  FM4   expect    50.800   609.600   609.600  got    50.800   609.600   609.600  OK+  verified OK: 14/21   BAD: R4,R5,B4,B7,FM1,FM2,FM3+```++`FM3` holding `B4`'s box (254 x 88.9 x 38.1) is the tell: two batches were in+flight, an untargeted `save_as` resolved to the other batch's active document,+and one part's geometry went to another part's filename. **Every one of these is+detectable and repairable precisely because the generator, not the CAD file,+holds the truth.**++### Fasteners — all seven imported and measured++| Tag | McMaster | measured (mm) | in inches | axis / head |+|---|---|---|---|---|+| `F-10x3` | 90396A180 | 81.662 x 10.922 | 3.215 x 0.430 | +X, head at −X |+| `F-8x125` | 3597N17 | 31.755 x 8.432 | 1.250 x 0.332 | +X, head at −X |+| `F-8x200` | 90031A205 | 50.800 x 8.432 | 2.000 x 0.332 | +X, head at −X |+| `F-L25x250` | 95526A175 | 70.622 x 14.224 | 2.780 x 0.560 | +X, head at −X |+| `F-L25x300` | 95526A200 | 83.322 x 14.224 | 3.280 x 0.560 | +X, head at −X |+| `F-W10` | 91090A126 | 19.05 x 19.05 x 1.194 | 0.750 OD x 0.047 | −Z (disc) |+| `CASTER-6` | 2498T652 | **190.5 tall**, 235.3 x 95.3 | **7.500** mount height | −Y, plate top at +3.75″ |++Every one matches its product page. The caster's 7.500″ mount height is an+independent confirmation of the packet's own arithmetic (56½″ on casters − 49″+box). It imports as **57 solid bodies** with a 235 mm X-span (swivel trail plus+brake pedal), so the "longest bounding-box axis is the shank" heuristic that+works for screws would have picked the wrong axis — its frame is set explicitly+from the measured plate face instead.++### What remains++1. **Repair 7 parts** — `R4, R5, B4, B7, FM1, FM2, FM3`. The recipe that works is+   **close the document by path FIRST, then delete, then rebuild, then+   `swx_save_as {targetDocument: <the title run_script just made>}`**. The first+   repair attempt deleted without closing; SOLIDWORKS still held the file, the+   delete silently failed, and `save_as` correctly refused an existing+   destination. `swx/repair2.py` has the corrected sequence.+2. **Close the ~30 open documents.** Every COM call gets slower as they pile up;+   this is the single biggest speed win available. `swx_close_doc {path}` per+   file, or `swx_reset_workspace` for the unsaved ones.+3. **Build the five assemblies** — `python3 swx/pipeline.py assemblies`. 383+   component instances, chunked 40 per `swx_add_component` call. The wood goes in+   first and `swx_interference` runs on wood only (fasteners are meant to be+   embedded, so an interference count taken after them means nothing).+4. **BOM + exports** — `python3 swx/pipeline.py finish`: `swx_bom {format:"csv"}`+   to `crate-bom.csv`, GLB, STEP, `swx_verb_times`, `swx_action_ledger` and a+   `swx_state` screenshot. Then pull the CSV back to `docs/crate-bom.csv`.++### Expected BOM, for cross-checking whatever comes out of SOLIDWORKS++Flattened (`topLevelOnly:false`), one crate:++```+P1 1  P2 1  P3 2  P4 2  P5 4+R1 6  R2 12  R3 4  R4 4  R5 5+B1 2  B2 2  B3 3  B4 4  B5 2  B6 2  B7 8+FM1 2  FM2 2  FM3 4  FM4 2+CASTER-6 6+F-10x3 108   F-8x125 197   F-8x200 49+F-L25x250 24   F-L25x300 8   F-W10 8+```++Every wood and foam quantity is the packet's own cut list (C1/C2). The fastener+counts fall out of the packet's spacing rules: `#10 x 3″` at 8″ o.c. on the four+corner columns (24), the floor ring (34) and the cap ring (34), plus 4 hold-down+bar ends and 12 side-station screws = **108**; `#8 x 1¼″` ply-to-frame at 8″ o.c.+on both side panels (49 each), both ends (25 each) and the cap (49) = **197**;+`#8 x 2″` deck-to-ring = **49**; four `¼ x 2½″` lags per caster plate = **24**;+four `¼ x 3″` PowerLags plus four washers per handle = **8 + 8**.++`swx/checkbom.py` compares the exported CSV against exactly these numbers.++### The running chain, at the moment of handoff++`swx/finish_all.sh` is running detached in the container (pid 1563686),+last stage marker: `== start 18:25:10`. It runs, in order:++```+pipeline.py cleanup      # close the ~30 documents that are slowing every COM call+repair2.py R4,R5,B4,B7,FM1,FM2,FM3   # close -> delete -> rebuild -> targeted save_as+pipeline.py verify       # re-read every part FILE against the generator+pipeline.py assemblies   # 5 assemblies, 383 component instances+pipeline.py finish       # BOM csv + GLB + STEP + verb timings + ledger + screenshot+adom-bridge pull_file    # crate-bom.csv -> docs/crate-bom.csv+```++Its log is `swx/final.log`. Every stage is checkpointed to+`swx/stage_<name>.json`, so if the chain is interrupted, re-running the same+commands resumes rather than restarts. **Before starting anything, check that no+`adom-bridge … shell_execute` for the `Crate Rebuild` thread is in flight**+(`/tmp/swx_busy.sh`) — a batch that looks dead is often still driving SOLIDWORKS+from the desktop side.++Performance, measured so far, for the bridge.json budgets: a STEP import plus+material, properties, measurement and save ran **2–3 minutes per fastener** warm+(the first was ~16 min under contention with a stale batch); a part build+(new_part → sketch → extrude → material → 6 properties → save_as → close) ran+**35–60 s**; `swx_add_component` measured **~1.2 s per component** on the+2-component and 3-component live probes, including the transform write. The+383-instance run is the number worth capturing — `swx_verb_times` is queried in+the finish stage precisely so the real p50/p90 lands in the record rather than an+estimate.++---++## 10. Finisher session — what the handoff did not know++The handoff's plan was sound and its diagnosis of the seven bad parts was exactly+right. What it could not know is that **three more bridge defects sat between the+parts and a finished crate**, and that two of them fail by returning a confident+wrong answer rather than an error.++### 10.1 The repair could not be done as written++`swx_close_doc` refused all 23 open crate documents — *"which this bridge did not+create"*. The bridge had been restarted mid-build, and its scratch registry is+memory-only (bug #5), so it had disowned its own documents. Six of the seven bad+parts were open, so Windows would not let their files be deleted either, and the+handoff's close → delete → rebuild recipe could not run at all. Both refusals were+CORRECT; the fix was to stop fighting them.++**`swx/repair_newpath.py`** rebuilds each bad part to a NEW path+(`parts\<TAG>-fix.sldprt`) — a write the bridge permits — and `gen_asm.py`+resolves parts through `swx/pathmap.json`. `PartNo` stays the tag, so a BOM still+aggregates under `R4`, not `R4-fix`. All seven rebuilt and read back correct:++```+R4 OK  R5 OK  B4 OK  B7 OK  FM1 OK  FM2 OK  FM3 OK      21/21 verified+```++### 10.2 Bug #10 — `swx_add_component` could not identify its own insertions++**The worst kind of bug: it reports success and silently builds the wrong model.**++The verb located the components it had just inserted by matching the request+against `GetComponents` as a CONTIGUOUS RUN of file paths. `same_path` matches ANY+instance of a file, and `GetComponents` returns neither insertion order nor+file-grouped order. So:++* a chunk containing a repeated part could never match → `locate_run` returned+  `None` → **no transforms written at all**, while the response still said+  `success:true, insertedCount:8`. Every component sat where `AddComponent5`+  dropped it (centred on the requested point), which looks like a built assembly+  and is a pile at the origin.+* inserting one at a time was no better: the new component's transform could be+  written onto an OLDER instance of the same file, overwriting a good placement.++Measured on the side panel (R1×2, R2×5, P3×1): R2 instances 1 and 2 landed+exactly; 3, 4 and 5 carried the "centred on the requested point" signature+(`Δy = −19.05 = −ly/2`, `Δz = +527.05 = +lz/2`). R1 and P3 — no repeats ahead of+them — were untouched.++Two tests disagreed, and **believing the clean one would have shipped a wrong+crate**: three R2s *alone* place perfectly, because when every instance is the+same file the transforms are still distributed one per instance and the resulting+SET of positions is correct. It only breaks in a mixed assembly.++**Fixed in 0.3.2** (`cmd_add_component` + `apply_transforms`): snapshot component+NAMES before inserting — a name is an identity, SOLIDWORKS never reissues one in a+document — and write only to components whose name is new, assigning each request+to a new component of the matching file greedily (exact, because same-file+instances are interchangeable). The old contiguous-run match stays as a fallback+for when names cannot be read.++Proof, against a centre of mass predicted independently in Python:++```+predicted  1219.200    35.522   571.500+measured   1219.200    35.522   571.500+delta         0.000     0.000     0.000   -> MATCH      (placed 8/8, interferences 0)+```++### 10.3 Bug #11 — `swx_docs` returned an empty list with `success:true`++`swx_docs` reported ZERO open documents while 51 were open. Twice, three minutes+apart, with `GetDocumentCount`, `swx_status.com.openDocs` and `swx_state.openDocs`+all still saying 51 and SOLIDWORKS never restarted (pid 88556, up since 11:14:55).++Mechanism: a busy SOLIDWORKS returns a null/empty VARIANT from `GetDocuments`+rather than an error, and **`variant.rs:228`'s `as_array()` turns a null variant+into an empty `Vec`**. Nothing downstream could tell that apart from "nothing is+open".++This one defect produced both of the errors that killed the assemblies, for a+document created seconds earlier:++```+swx_add_component: no open document is titled 'Assem24'          (resolve-by-title)+swx_add_component would modify 'Assem26 (unsaved)', which this+bridge did not create                                            (ownership gate)+```++It is almost certainly also the phantom `file not found: ...\B4.sldprt` for a file+the directory listing showed at 242,860 bytes.++**Fixed in 0.3.3**, three parts:++1. **Retry-on-reject at the COM layer.** SOLIDWORKS is an STA server with no+   message filter: mid-rebuild it REJECTS calls. `invoke` now wraps `invoke_once`+   and backs off 100ms × 2ⁿ (≤5s) on `RPC_E_CALL_REJECTED` /+   `RPC_E_SERVERCALL_RETRYLATER`. It wraps *every* call, so `OpenDoc6` gets it too.+2. **`documents()` never returns a contradicted empty** — it cross-checks+   `GetDocumentCount`, retries, and raises `docs_enumeration_failed` with the count+   instead of a plausible zero.+3. **`resolve`-by-title uses it**, so a failed enumeration can never be reported as+   "document not open".++Gate (`swx/smoke_docs.py`, 50 reads interleaved with `swx_status`):++```+reads=50  ok=39 (every one returned exactly 51; min=51 max=51)+errored=11 (honest "com host did not answer 'docs' within 30s")+independent count=[51,51,51,51,51]   under-reporting reads: 0   PASS+```++An honest failure is acceptable; a silent empty is not.++### 10.4 Bug #5, promoted to must-fix — ownership does not survive a respawn++Observed directly, and worse than "across a bridge restart": on a **freshly+started server**, ASM-BASE placed all 18 wood parts, the long `swx_interference`+call overran the com host's answer budget, the host was KILLED and respawned, and+every call after it refused with *"would modify 'Assem27 (unsaved)', which this+bridge did not create"* — an assembly the bridge had created ninety seconds+earlier. `hostPid` changed (100940). The build died holding a document it could no+longer save.++The server's ownership check fails CLOSED when the session cannot be read, which+turns "I cannot tell" into "not ours" — the same shape as the two bugs above.+**Ownership must persist across a com-host respawn, and an undeterminable session+must be an error, not a denial.**++Mitigation used here, not a fix: chunks of 12, and `swx_interference` moved to+*after* the assembly is saved, so its failure costs a report rather than the build.++### 10.5 The lesson these three share: an unchecked empty/default becomes a fact++Four instances in one session, three in the bridge and one in the driver:++| Where | The empty/default | The false conclusion |+|---|---|---|+| `variant.rs:228` `as_array()` | null VARIANT → empty `Vec` | "no documents are open" (51 were) |+| `owns_doc` | unreadable session → `false` | "this bridge did not create it" (it had) |+| `locate_run` → `placedCount:0` | no match → write nothing | `success:true` on an unplaced assembly |+| my `classify_docs.py` | `res.get("docs") or []` | "TOTAL 0" for a failed call |++In every case the code had enough information to say *"I do not know"* and instead+said something definite and wrong. The `documents()` guard, the+`docs_enumeration_failed` code, and printing `success`/`error` beside every count+are all the same correction.++### 10.6 State at the end of this session++**Bridge:** 0.3.3 built, cross-compiled, 118 tests green, deployed and verified by+installed byte count (1,411,584) and `swx_status.bridgeVersion`, in the DEFAULT+deny-by-default posture (`userWrites: disabled`). `SWX_ALLOW_USER_WRITES` was set+for one scoped cleanup attempt and removed again immediately; **no user document+was touched, and no `close_all` was ever run.**++**Assemblies — 3 of 5 built, saved and clean:**++| Assembly | Wood | Fasteners | Interferences | Bytes |+|---|---|---|---|---|+| `ASM-SIDE-PANEL` | 8/8 | 49/49 | 0 | 282,905 |+| `ASM-END-PANEL` | 7/7 | 33/33 | 0 | 229,075 |+| `ASM-CAP` | 8/8 | 49/49 | 0 | 249,161 |++`ASM-BASE` (91 instances) and `ASM-CRATE` (138) are NOT built, and the BOM, GLB+and STEP exports depend on `ASM-CRATE`.++**The blocker is not a bridge bug.** SOLIDWORKS can no longer create ANY document:++```+assembly template -> "SOLIDWORKS created no document from ...Assembly.asmdot"  (x3)+part     template -> "SOLIDWORKS created no document from ...Part.prtdot"+sldworks pid=88556  privMB=17465  handles=21770  threads=1420+free 5,966 MB of 32,173 MB      52 documents open+```++Both templates fail, so it is resource exhaustion, not a template fault — 52 open+documents, most of them orphaned by com-host respawns and un-closable because the+bridge disowns them (bug #5 again, now compounding). Closing them individually+needs the write opt-in, which is a decision for Drew, not for an agent: it is his+live SOLIDWORKS.++**`Part1` is open and DIRTY.** It is not in `C:\Users\Public\adom-crate\` and the+bridge has never claimed it (`swx_reset_workspace` skipped it every time while+closing `Part48`, `Part57–66`, `Assem14–17`). It may be Drew's. **It must not be+closed by anyone but him**, and no `close_all` can be used while it is open,+because `closeUnsaved:true` would discard it without a prompt.++### 10.7 Final state — SOLIDWORKS alive but COM-unreachable++The last probe (22:14) closes the picture:++```+RUNNING pid=88556                     <- SOLIDWORKS is still up+swx_open -> "SOLIDWORKS is not running, and this edition+             cannot be started programmatically"          <- the bridge can no longer ATTACH+```++So the process survives while COM attach fails: consistent with the exhaustion+above (17.4 GB private, 21,770 handles, 1,420 threads), and the end of what any+bridge fix can reach. **SOLIDWORKS was never stopped, killed or foregrounded by+this session** — no `swx_stop`, no `swx_kill`, no `process_kill` against+`sldworks.exe`. Only `swx-bridge.exe` was ever restarted.++The remedy is a SOLIDWORKS restart, which is **Drew's call, not an agent's** — his+session, and `Part1` (unsaved, dirty, never claimed by the bridge) is still in it.++**On disk in `C:\Users\Public\adom-crate\`, all verified present:**++```+parts\        28 .sldprt   (21 original + the 7 <TAG>-fix rebuilds)+fasteners\     7 .sldprt   (the McMaster STEP imports)+ASM-SIDE-PANEL.sldasm  282,905    ASM-END-PANEL.sldasm  229,075+ASM-CAP.sldasm         249,161+```++**To resume after a SOLIDWORKS restart** (the working set will be empty, which is+also the fix for the exhaustion):++```+python3 swx/pipeline.py assemblies     # skips the 3 built, does ASM-BASE + ASM-CRATE+python3 swx/pipeline.py finish         # BOM csv + GLB + STEP + timings + ledger + state+python3 swx/checkbom.py docs/crate-bom.csv+```++Everything those need is already in place: bridge 0.3.3 with both placement and+enumeration fixed, all 21 parts geometry-verified through `swx/pathmap.json`, the+fastener frames measured, and `build_asm.py` chunking at 12 with fail-fast and a+verified save before any checkpoint.++---++## 11. Finished — the crate, and the BOM out of SOLIDWORKS++Drew restarted SOLIDWORKS from the Start Menu, which cleared the exhaustion that+§10.6 ended on. The bridge (0.3.3, default posture) re-attached to an empty+session and the remaining two assemblies went in without a single failed chunk.++```+before:  privMB=523    handles=2810    openDocs=0+after:   privMB=13117  handles=7906    openDocs=33+```++The memory climb is inherent to the workload, not a leak introduced here: 480 leaf+component instances, six 57-body casters among them. It is also the reason the+first attempt died — see §10.6 — and the reason a long build wants a fresh+session.++### All five assemblies, built and saved++| Assembly | Wood | Fasteners | Instances | Bytes |+|---|---|---|---|---|+| `ASM-SIDE-PANEL` | 8/8 | 49/49 | 57 | 282,905 |+| `ASM-END-PANEL` | 7/7 | 33/33 | 40 | 229,075 |+| `ASM-CAP` | 8/8 | 49/49 | 57 | 249,161 |+| `ASM-BASE` | 18/18 | 73/73 | 91 | 4,546,131 |+| `ASM-CRATE` | 30/30 | 108/108 | 138 | 4,843,916 |++**383 component instances inserted, every one placed** — `placed == inserted` on+all 34 chunks, which is the check that would have caught the silent bug #10.+`ASM-CRATE` masses **229.02 kg (505 lb)**.++### The BOM, exported from the assembly++`swx_bom {path: ASM-CRATE.sldasm, format:"csv", out:…, topLevelOnly:false}` →+**32 rows**, in the repo as `docs/crate-bom.csv`. Columns are+`item,name,configuration,quantity,file` plus one column per custom property found+(`PartNo`, `Material`, `McMasterPN`, `HeadStyle`, `DriveStyle`, `AsPurchased`,+`Description`, `Size`, `QtyPerCrate`, `Source`, …).++```+BOM rows: 32   leaf part instances: 474   sub-assembly instances: 6   total: 480+```++`swx/checkbom.py` against the packet's own cut lists (§9) — **every part and every+fastener exact**:++```+P1 1  P2 1  P3 2  P4 2  P5 4     R1 6  R2 12  R3 4  R4 4  R5 5+B1 2  B2 2  B3 3  B4 4  B5 2  B6 2  B7 8     FM1 2  FM2 2  FM3 4  FM4 2+CASTER-6 6+F-10x3 108   F-8x125 197   F-8x200 49   F-L25x250 24   F-L25x300 8   F-W10 8+                                          28 of 28 part numbers match+```++The four rows `checkbom` flags as "mismatches" are `ASM-BASE`, `ASM-CAP`,+`ASM-END-PANEL` and `ASM-SIDE-PANEL` themselves — the nested sub-assemblies, which+a flattened BOM lists and the packet's parts-and-fasteners expectation does not.+They are correct, not errors.++**The repaired parts aggregate under their real numbers.** `R4`, `R5`, `B4`, `B7`,+`FM1`, `FM2` and `FM3` live on disk as `<TAG>-fix.sldprt`, and the BOM still reads+`R4 4`, `B7 8`, `FM3 4` — because `PartNo` is the identity, not the filename.++### Exports++```+ASM-CRATE.glb    183,436,448 bytes+ASM-CRATE.step     6,525,584 bytes+```++### Measured performance, at scale++`swx_verb_times` over the whole build (seconds):++| Verb | Calls | p50 | p90 | max |+|---|---|---|---|---|+| `swx_add_component` | 50 | 15.58 | 51.13 | **247.0** |+| `swx_run_script` | 50 | 13.84 | 26.21 | 39.03 |+| `swx_save_as` | 44 | 3.68 | 7.95 | 20.41 |+| `swx_new_document` | 46 | 3.99 | 7.86 | 11.07 |+| `swx_import` | 10 | 4.78 | 7.82 | 12.34 |++**`swx_add_component`'s 247.0s max against the com host's 252s answer budget is+the whole story of §10.4 in one number.** That call came within five seconds of+getting the host killed; the ones that did overrun cost an assembly each. Chunks+of 12 keep p90 at 51s, comfortably inside it. For the bridge.json budgets:+insertion costs roughly **1.2s per component** plus a per-call overhead that grows+with the assembly, so cost is driven by CHUNK COUNT as much as component count.++### Two caveats recorded rather than buried++1. **The interference numbers are not comparable across the five.** For the first+   three, `swx_interference` ran on the WOOD ONLY and returned **0** — the number+   that means something, since fasteners are meant to be embedded. For `ASM-BASE`+   and `ASM-CRATE` the check was moved to after the save (§10.4) so a slow call+   could not kill the build, which means it ran with the fasteners in: `ASM-BASE`+   reported **170**, which is fastener embedment, and `ASM-CRATE`'s timed out+   entirely. Neither is evidence of a wood clash; neither is evidence against one.+2. **No screenshots.** `swx_state`'s capture needs `ADOM_DIRECT_API_URL`, which+   Adom Bridge supplies when it spawns a bridge itself. This bridge was started by+   the dev loop's `launch_process`, so the variable is absent and every capture+   returns `{"success": false, "error": "ADOM_DIRECT_API_URL not in env"}`. A+   dev-loop bridge cannot take pictures — worth knowing before relying on one for+   visual verification.++### Hardware sourcing — the two compromises stand, flagged++Unchanged from §4 and still not silently accepted: **`F-10x3` (90396A180) is a #8+shank, not #10** — the washer head and Torx drive are exact, the shank is one+gauge light — and **the `CASTER-6` (2498T652) bolt pattern is McMaster-standard+and NOT verified** against the YAEMIKY part. *Measure a real caster before+drilling the deck.* `F-8x200` and `F-L25x250/300` carry drive compromises+(Phillips, external hex) for the same reason: no Torx in those families at size.

@@ -0,0 +1,574 @@+Machine crate build packet, NSF PCL Kickoff, Hart SH-216, September 2026+NSF PCL Kickoff · Machine crate+Fit+Side+End+Cap+Base+Joints+Bracing+Marks+Plywood+Lumber+Buy+Casters+Shock label+Assembly+September DC event · Drawing packet · rev D+Machine crate: exact 8 x 4 ft footprint, gravity-stacked+The shipping crate for the Hart SH-216 showcase workcell. The base and cap are full uncut 48 x 96 sheets that cap the stack, so the plan footprint is+exactly 96 x 48″+. Walls stand on the deck, the deck sits on the 2x4 ring, casters bolt under the ring, and the cap rests on the wall tops:+gravity carries the weight, screws only locate and resist racking+. Framing stays on the outside of every face, flush at the crate’s planes, and the whole interior is smooth ply. Every dimension comes from one generator script (+build-crate.py+), which also exports the+interactive 3D model+and machine-checks the fit.+FOOTPRINT+96 x 48″+exact+HEIGHT+49″+box,+~56½″+on casters+INTERIOR+92 x 44 x 45″+clear, all faces smooth+EMPTY+~400 lb+MATERIAL+5 sheets ply, 16 x 2x4, 6 casters+D0+How the box fits together+Sized to the payload: one gravity stack, one joint everywhere, handles on the ends+The base deck and cap are straight-off-the-rack uncut 48 x 96 sheets and carry their frames outside (2x4 ring below the deck, ripped-rail ring on top of the cap), flush with the ply edges. The walls inset so each frame ring sits+flush at the crate’s side planes+with the ply just inboard, which is what keeps the footprint at exactly 96 x 48. The PK ships+front face down+(electronics panel up), which stands its 36.2″ depth vertical, so the walls rip to+42″+(sides one rip each, ends crosscut plus two rips): payload on its 2″ foam bed tops out at 40.2″ with the hold-down stack filling the last 3.8″ to the ceiling. Each end carries a+full-width 2x4 pull handle bolted flat across the edge rails+, proud 1½″ beyond the box (99″ over the handles); hands wrap the bar inside the recessed ply pockets between the rails.+The load path is pure bearing: cap on wall tops, walls on the deck, deck on the ring, ring on the casters. The joint is the same everywhere, rail + ply + the neighbor’s rail with a #10 x 3″ screw: horizontal at the four corners, and+vertical+at the floor (down through the wall bottom rails and deck into the 2x4 ring) and at the lid (down through the cap ring into the wall top rails). Each handle mounts through bar + edge rail + ply with four 1/4 x 3″ SPAX PowerLag structural screws driven from outside (as purchased, replacing the original ⅜-16 carriage-bolt spec): crews will yank a quarter-ton crate by these.+All framing comes from+one lumber SKU+: sixteen 2x4s. Ten of them rip in half into 1¾ x 1½″ rails for the walls and cap, always mounted with the+1½″ side proud+, so every face of the crate is the same 2″ thick (½″ ply + 1½″ rail), matching the 2x4-flat base exactly.+Automated fit check (72 pieces):+0 interferences+142 flush contacts+footprint 96 x 48″ exact, 49″ box+interior 92 x 44 x 45″ clear+Open the interactive 3D model+Exploded view.+The cap lifts off the wall tops, sides and ends step off the deck, and the base ring with its casters drops down. Tan is ½″ plywood, amber is 2x2 framing, brown is the 2x4 base ring.+Assembled.+A clean 96 x 48 silhouette in plan; every vertical face is a flush frame ring with a recessed ply field, and the cap ring crowns the stack.+~53½″+overall+handles proud 1½″ per end+(99″ over the handles)+cap ring on top+walls rest on the deck+6″ casters x6+96″ box, exact+The gravity stack.+1½″ ring + ½″ deck + 45″ walls + ½″ cap + 1½″ cap ring = 49″ box, about 56½″ on 6″ casters. The box holds exactly 96 x 48″; only the pull handles stand proud, 1½″ per end.+PK fit check (from the real CAD):+measured from Drew’s STEP export of Kiosk - 0 - Probing Workcell, the probing kiosk is+33.9 x 36.2 x 88.1″+with the 32″ monitor mounted (83.8″ tall without it). Upright would force an over-8-ft crate that cannot roll through a standard doorway, so it ships+lying front face down, electronics panel up+, monitor still mounted: 88.1 vs 92 length, 33.9 vs 44 width, and height now budgets the electronics: DIN-rail devices on the panel (which faces UP) protrude up to 5″, so 36.2 + 5 DIN + 2″ foam = 43.2 vs the 45″ interior (1.8″ clear). That protrusion is what pushed the walls from 42 to 45″ in rev G. See the PK loaded view in the+3D model+. Brace the gantry carriage and Z axis before it ships horizontal.+Interior mounting:+all six inner faces are bare ply, 92 x 44 x 45″ clear. For strong anchor points, land screws where the exterior rails run (perimeter plus verticals at 24″ o.c., visible from outside). Between rails there is ½″ ply for light blocking, or through-bolt for heavy brackets.+D1+Side panel, build 2+Ply 96 x 45 x ½″ (one rip from a full sheet, label P3), frame ring flush at the crate side plane+96″ sheet length, no crosscut+45″+24″ o.c.+41½″+OUTSIDE FACE: one rip brings the 48″ sheet to 45″+Orthographic, outside face.+Rails flush with all four edges. The bottom rail bears on the deck; the top rail takes the lid screws; the corner rails back the corner joints. Save the 6″ rip offcut for blocking stock.+P3+R1+R1+R2+Isometric, outside face up.+Ply down on the bench, frame up. Every frame member is one straight cut; the verticals sit between the rails.+Qty+Ripped rail (1¾ x 1½″)+Length+2+Top and bottom rails+[R1]+96″+5+Verticals: 2 corner rails + 3 intermediate+[R2]+41½″+D2+End panel, build 2+Ply 43⅞ x 45 x ½″ (label P4), drops in between the side plies, 2x4 pull handle flat across the edge rails+43⅞″+45″+full 2x4 bar bolted flat across the edge+rails, proud 1½″; hands wrap it in the+recessed ply pockets between the rails+OUTSIDE FACE: handle center ~34½″ off the ground+Orthographic, outside face.+The edge rails run the full 45″ height and back every corner screw. The 2x4 handle bolts flat across the edge rails, proud 1½″, and a gloved hand wraps it inside the recessed pockets against the ply. Ripped 1/16″ shy per side so the panel drops in without persuasion.+P4+R3+R4+R2+B5+Isometric, outside face up.+The handle bar lies directly on the edge rails. Four 1/4 x 3″ SPAX PowerLags per handle run bar into rail and ply, washers under the heads, driven from outside (as purchased; original spec was ⅜-16 carriage bolts).+Qty+Ripped rail (1¾ x 1½″)+Length+2+Edge rails, full height+[R3]+45″+2+Top and bottom rails+[R4]+40⅜″+1+Center vertical+[R2]+41½″+1+Pull handle (full 2x4, flat across the edge rails)+43⅞″+D3+Cap, build 1+Full uncut 48 x 96 sheet (label P2) resting on the wall tops, rip ring on top+96″ full sheet, no cuts+48″+24″ o.c.+TOP FACE: screws drop through the ring into the wall top rails+Orthographic, from above.+Framed identically to a side panel. The sheet rests on the wall top edges all the way around; the ring rails land directly over the wall top rails, so the lid screws go straight down through 2″ of stack into 1½″ of meat.+P2+R1+R5+Isometric, outside face up.+The ring doubles as a curb: anything set on the crate top is fenced by 1½″ of rail.+Qty+Ripped rail (1¾ x 1½″)+Length+2+Long rails+[R1]+96″+5+End rails (2) + crossmembers (3) at 24″ o.c.+[R5]+44½″+D4+Base, build 1+Full uncut 48 x 96 deck (label P1) on a 2x4 ring, six 6″ swivel casters bolted through+96″ full sheet, no cuts+48″+9″+39″+dashed: caster plate x6+VIEW FROM BELOW: bolts up through ply + ring+Orthographic, from below.+Crossmembers at 24″ o.c. Corner casters land on rail + 10″ doubler pad; the mid pair lands where the center crossmembers meet the rails, so they need no pad.+P1+B1+B2+B3+B4+Isometric, upside down as you build it.+Deck ply down, ring and casters up. Bolt the casters, flip it onto its wheels, and everything else stacks on top: the machine’s weight runs deck to ring to casters by bearing alone.+Qty+2x4 piece+Length+2+Long rails+[B1]+96″+5+End rails (2) + crossmembers (3)+41″+4+Corner caster doubler pads, from offcuts+10″+D5+The one joint, everywhere+Outer rail + ply + the neighbor’s edge rail+side corner rail, at the side plane+side ply+end edge rail backs the joint+end ply+#10 x 3″ @ 8″ o.c.+crate end plane: all faces land flush+Corner in plan.+Screws pass through the side’s corner rail and ply into the end panel’s full-height edge rail: 2″ of stack into 1½″ of meat. The identical stack runs+vertically+at the floor (wall bottom rail, deck ply, base ring) and at the lid (cap ring, cap ply, wall top rail), so the whole crate uses one screw spec. The automated check proves nothing collides.+D6+Bracing the payload+Foam everywhere the crate touches the machine; 2x4s everywhere the foam needs backing+The rule is simple:+wood never touches the workcell+. The payload rides on a 2″ polyethylene foam bed, every brace presses through a foam face, and every brace anchors to the crate’s existing rail grid, either screwed from outside through an exterior rail + ply into the brace end (the same joint as the crate itself), or screwed down through the deck into the base ring and crossmembers. Never anchor into unbacked ply.+For the PK lying front-down: on the 2″ bed the frame tops out at 38.2″ above the deck and the DIN-rail devices on the up-facing electronics panel reach 43.2″, under the 45″ ceiling with 1.8″ to spare. The hold-downs sit at the+wall-vertical planes (x = 24 and 72″)+: a 2″ foam pad on clear panel, a 2x4 laid flat on top, and the bar ends screwed through the side ply into the wall verticals. The cap no longer captures the bars (rev G walls leave air above them), the screws into the verticals do the work — and+place each bar where the panel is clear of DIN devices+, shifting a few inches along the machine if needed. The+PK loaded view+shows the whole system, and the exploded view now floats the foam layers and the intact workcell out of the stack.+Will the foam carry it?+Fusion volumes total 62.6 L of solid material; at a realistic aluminum/steel mix that is roughly+210 kg / 460 lb+(169 kg if it were all 6061; read the exact mass off Fusion’s Properties dialog to confirm). On two 4″ x 88″ bed strips (704 in²) that is+~0.65 psi static+, square in the cushioning sweet spot for 2.2 lb/ft³ polyethylene plank (~0.3 to 1.2 psi) and far below its long-term creep threshold: expect under 10% thickness loss over years, and PE does not absorb water in Gulf humidity. Even at 350 kg the bed stays under 1.1 psi; if the confirmed mass exceeds that, widen the strips to 6″. On density: the priced Uline plank is+1.7 lb/ft³+, not 2.2. Density sets the cushioning band, and 1.7 pcf PE is happiest at roughly 0.2 to 0.9 psi static, which brackets our ~0.65 psi bed load better than 2.2 pcf (whose sweet spot starts around 0.5 and whose 25% compression point is ~9 psi vs ~6). Softer foam here means better vibration isolation, at the cost of slightly earlier creep; strip width is the tuning knob if the confirmed mass runs high. Isolation-wise the machine floats on foam in every axis: bed below, faced hold-downs above, ~2″ foam pads compressed directly between the frame ends and the end walls (the walls are the thrust structure; the interior leaves no room for blocks), and foam-faced 2x4 side blocks screwed to the deck; nothing rigid touches it, which is what protects a 50 µm end effector and a galvo through trailer shock. Two transport rules ride with the crates:+book air-ride trailers+(tell District Moving), and walk the crate slowly over rough asphalt.+Foam attachment for years of reuse:+hot Fort Worth trailers will cook a spray adhesive loose, so sprays are for positioning only. Bond every permanent foam face with+polyurethane construction adhesive+(Loctite PL Premium or similar: heat and humidity stable, bonds PE plank to wood), and give the bed strips mechanical capture too: screw ply-offcut curbs to the deck along each strip’s edges so the foam cannot walk even if a bond lets go.+Brace+Qty/crate+Build+Anchor+Foam bed strips+2 + pads+2″ PE plank under the frame contact lines+Friction + payload weight; spray-tack to the deck+Hold-down braces+2+2x4 flat x 43⅞″ + 1″ foam pad+#10 x 3″ from outside through the side top rail + ply into each end; cap bears on top+End thrust pads+2+~2″ foam, wall to frame, light compression fit+The end walls take the thrust directly; no blocks+Side stations+4+12 x 12″ ply backer (rip offcuts) + 2″ foam pad + two rip-to-fit 2x4 spacer blocks+Stations sit at the wall-vertical lines (x = 24, 72). Spacer blocks at the backer’s TOP and BOTTOM brace it against the side wall, so the thrust path is backer, block, ply, exterior rail: no cantilever. Bottom block also screws down into the deck. Foam glues full-face to the backer with PL Premium; optionally add four corner screws with 1″ fender washers, snug not compressing, as mechanical backup in trailer heat+Both kiosks measured, one crate design:+the LK comes in at+33.1 x 34.6 x 86.6″+(exact OCCT bbox from its STEP), a near-twin of the PK, and ships the same way: front face down on the foam bed, 36.6″ tall on the bed against the 42″ ceiling. Both crates are identical; only the pack-time foam cuts differ. The+3D model+has PK loaded and LK loaded views (LK massing is approximate within its exact envelope; its quantized CAD export defeats per-part decoding).+D7+Field disassembly markings+Anyone on the crew can see what comes apart, in what order, and what goes back where+3″ black dots on every wall-to-wall fastener.+Spray-painted through a 3″ circle template after first assembly: down the four corner columns (screws through the side faces into the end edge rails, 8″ o.c.) and around the cap ring (lid screws into the wall top rails). A screw with a dot is a field fastener; a screw without a dot stays put. The+3D model+renders every dot in place.+Corner match letters.+Freehand-paint+A, B, C, D+across each vertical corner seam so the letter reads half on the side panel, half on the end panel: panels can only go back where the letters heal. Add the crate ID (+PK+/+LK+) beside each letter so parts never swap between crates.+Floor screws live inside+(down through the wall bottom rails into the base ring): dot them from inside at first assembly. Full teardown order: cap, ends, sides, everything back by the letters.+One driver, spare bits.+All field screws are Torx structural: keep spare+T20+and+T30+impact bits taped inside the cap ring, plus a ⅞″ socket for the handle and caster bolts.+C1+Plywood cut list — both crates+Ten sheets of ½″ 4 x 8 (eleven bought; the spare also feeds the 12 x 12″ side-station backers). Write the label on every piece as it comes off the saw.+Label+Piece+Cut size+Per crate+Both crates+Cuts+P1+Base deck+48 x 96″+1+2+None, straight off the rack+P2+Cap+48 x 96″+1+2+None+P3+Side wall ply+96 x 45″+2+4+One rip per sheet; keep the 3″ offcut strips for blocking+P4+End wall ply+43⅞ x 45″+2+4+One sheet yields both: crosscut at 48″, rip each half to 43⅞″, then rip to 45″+P5+Side-station backer+12 x 12″+4+8+From the spare (11th) sheet; bed curbs and blocking from the rest of it+Why these numbers:+the base and cap are full sheets and set the exact 96 x 48″ footprint. The walls rip to+45″+tall (rev G): the PK lies at 36.2″ plus up to 5″ of DIN-rail devices standing off its up-facing electronics panel, plus the 2″ bed — 43.2″ of payload under a 45″ ceiling. The wall sleeve leaves a 44″ opening between the side plies, so the ends rip to 43⅞″ (a 1/16″ gap each side) and slide straight down onto the deck. Sheet count: per crate, deck + cap + two side sheets + one end sheet = 5; both crates = 10, plus the spare. Use ½″ CDX, ACX, or BC sanded, not underlayment (purchased: 15/32″ CDX, see C3).+C2+Lumber cut plan — both crates+One SKU: 2x4 x 8 ft, 36 used of the 50 bought. Per crate: ten rip in half into rail stock, eight stay full. Label every piece at the saw; identical labels are interchangeable.+The rip:+one table-saw pass down the middle of a 2x4 yields two rails at 1¾ x 1½″ nominal (the kerf really leaves about 1​+11+⁄+16+″). Mount every rail with the+1½″ side proud of the ply+so all four wall faces and the cap match the 2x4-flat base at 2″ total thickness. The lengths below assume a full 1¾″ rip; if yours comes out narrower, the between-rail pieces (44½″ and 40⅜″) grow by twice the difference, so cut those to fit after the perimeter rails are on.+Ripped rail pieces+Label+Piece+Length+Per crate+Both+R1+Side top+bottom rails, cap long rails+96″+6+12+R2+Wall verticals (side corners + intermediates, end centers)+41½″+12+24+R3+End edge rails, full height+45″+4+8+R4+End top/bottom rails+40⅜″+4+8+R5+Cap end rails + crossmembers+44½″+5+10+Stick plan per crate (10 sticks → 20 rails): 6 rails stay full 96″ (R1); 6 rails cut 2 x 41½″ (R2); 2 rails cut 2 x 45″ (R3); 2 rails cut 2 x 40⅜″ (R4); 3 rails cut 44½″ (R5; the third rail’s 51½″ offcut goes to spacer-block stock). Both crates: 20 sticks.+Full 2x4 pieces+Label+Piece+Length+Per crate+Both+B1+Base long rails+96″+2+4+B2+Base end rails+41″+2+4+B3+Base crossmembers+41″+3+6+B4+Caster pads+10″+4+8+B5+Pull handles+43⅞″+2+4+B6+Hold-down bars+43⅞″+2+4+B7+Side-station spacer blocks (rip to fit)+~12″+8+16+Stick plan per crate (8 sticks): 2 x B1 full; 3 sticks cut 2/2/1 x 41″ (B2 + B3); 1 stick cut 2 x 43⅞″ (B5); 2 sticks for bracing (B6 + B7); B4 pads come from the 41″-stick offcuts. Both crates: 16 sticks. Total: 36 of the 50 purchased — 14 spare for pack-time blocking.+Why 2x4 for the base and rips for the rest:+the base ring carries the machine, spans between casters, and takes the caster bolts, so it keeps the full 3½″ face. Everywhere else the plywood is the structure and the ripped rails stiffen the panels, give every joint its meat, and their recessed bays are the handholds. Upgrade the walls to full 2x4 only if the machine tops roughly 1,500 lb, the crate will be stacked, or it ships common-carrier freight.+C3+Purchasing list — as purchased+Everything for BOTH crates is bought (8/27–8/28), $1,483.74 all-in with tax and freight. Links go to the exact items; order numbers reference Drew’s accounts. Sources: Lowe’s Flower Mound in-store 8/27 ($861.04), Uline order 57096663, Amazon orders 112-2336638-0154627, 112-5723421-2594632, 112-7152192-0797848, 112-3272759-2120239.+Item+As purchased+Qty+Paid+Notes+Plywood+15/32″ CAT CDX 3-ply 4 x 8, Lowe’s item 12192+11+$284.46+One spare over the ten; four go in uncut per crate+2x4 x 8 ft+KD whitewood select stud, item 6005+50+$179.00+Eight spares over the 42; ten per crate rip into rail stock+Structural screws+SPAX #10 x 3″ washer-head T-Star, 3 lb (item 3753135)+x3 ++1 lb (item 3753046)+10 lb+$119.92+Every panel-to-panel field joint+Panel screws+SPAX #8 x 1¼″ 1 lb (item 3753042)+x3 ++#8 x 2″ 1 lb (item 3753044)+4 lb+$59.92+Ply to frame from the inside face+Structural lags+(replaces the carriage-bolt spec)+SPAX 1/4 x 2½″ washer-head (item 5641068)+++SPAX 1/4 x 3″ PowerLag (item 3753018)+++100x #10 3/4″ washers (item 61697)+2 boxes+$68.96+2½″ washer-heads take the casters, 3″ PowerLags take the handles; no nuts to fish inside+Construction adhesive+Loctite PL Premium 10 oz (item 100575)+3+$22.14+Permanent foam-to-wood bonds; survives Texas trailer heat+Wood glue+Gorilla Ultimate wood glue (item 1068391)+— sub for Titebond II+3+$41.04+Every rail-to-ply bond inside every panel; field joints stay dry+Spray adhesive+Gorilla Ultimate spray adhesive (item 5348950)+— sub for 3M 90+1+$19.98+Positioning tack only+Casters+YAEMIKY 6″ PU, sets of 4, all swivel + brake, 3,000 lb/set+12+$204.16+Amazon order 112-2336638-0154627 (8/27, delivered 8/28, price incl. straps); every caster locks+Lashing straps+Cartman 1″ x 12 ft, 600 lb — same Amazon order+12+incl.+Payload lashing inside the crates+Torx bits+Bosch Impact Tough ITT20205 T20 5-pk + ITT302B T30 10-pk+2 packs+$13.16+Amazon order 112-5723421-2594632, arrives Mon 8/31; spares taped inside the cap rings+PE foam plank+Uline S-12856, 48 x 96 x 2″, 1.7 pcf, carton of 2+1 carton+$261.48+Uline order 57096663 ($182 + tax + $59.55 Lykes Cartage freight), delivers Mon 8/31; one carton cuts all foam for both crates+Shock indicators+Thermlogix impact indicator 25G yellow, 20-pack+20+$55.00+Generic ShockWatch-2-style clone, field-armable; Amazon order 112-7152192-0797848, arrives Wed Sep 9+Tilt indicators+Thermlogix tilt indicator, 20-pack+20+$60.00+Same order as shock ($124.49 with tax); arrives Wed Sep 9+Marking paint+Rust-Oleum Painter’s Touch 2X Ultra Cover flat black 12 oz+3+$19.41+Amazon order 112-3272759-2120239, arrives Mon 8/31; dots and letters are freehanded (no stencils), plus one can already on hand+Total, all purchased+$1,483.74+Lowe’s $861.04 + Uline $261.48 + Amazon $361.22+C4+Casters and handling+Are PU casters right for 50 µm payloads?+Yes, with the isolation living in the foam, not the wheel. Solid PU transmits more high-frequency vibration than a pneumatic tire, but the payload never touches the crate structure: every path from wheel to machine crosses 2″ of PE foam, which is the actual suspension. Avoiding pneumatics is the right call (pressure drift, flats, load squirm). If you want extra insurance for asphalt, two upgrades stay plate-mount and tube-free:+spring-loaded shock-absorbing casters+(6″ PU on a sprung fork, ~$70 each) or flat-free microcellular foam wheels (softer tread, no inflation). The PL keeps standard PU; say the word and I swap the spec.+Six 6″ casters per crate bolted straight to the base ring (purchased: YAEMIKY sets, 3,000 lb per set of four),+all swivel and every one carries a brake+: sidestep and rotate anywhere, park anywhere. The tradeoff is that an all-swivel 8 ft crate wants to crab on long straight pushes, so plan on two people for corridor runs and lock the corners the moment it parks. 6″ wheels roll thresholds and door saddles that stop 4″ wheels, and their 500 lb+ ratings add margin. Fasten every plate through the deck into the 2x4 ring with 1/4 x 2½″ SPAX washer-head structural screws, four per plate (as purchased, replacing the ⅜″ carriage-bolt spec): they thread into the solid ring, never ply alone, which would work loose on the first curb.+Handling: each end carries a full-width 2x4 pull handle at ~34½″ grip height with finger pockets above and below, every vertical face is a flush frame ring with recessed ply bays, and the cap ring is a full-perimeter lip up top. Quote the carrier+96 x 48″ box (99″ over the handles), ~56½″ tall, rolls on its own casters+: no skids, no forklift pockets, liftgate truck and hand-rolling on the+Hart freight route+.+C5+Shock and tilt indicators+Crate empty is about 400 lb; with the workcell aboard the gross weight plausibly lands in the 600 to 1,200 lb range. On the standard SpotSee/ShockWatch selection chart, a large crate at 250 to 1,000 lb gross takes a+ShockWatch 2, 25G (red)+label. If gross weight exceeds about 1,000 lb, or the payload carries precision optics or spindles, step down to+15G+: heavier packages see lower G in the same drop, so the sticker must be more sensitive to still catch a mishandling event.+Recommendation: ShockWatch 2, 25G+, one label on each of two adjacent faces in the upper third (on the ply field, not a rail), plus the companion handle-with-care alert stickers.+Add a+TiltWatch XTR+on two faces: a crate on casters still earns tilt monitoring, and the 49″ box with the payload lying flat keeps the center of gravity low.+Arm the labels at the last moment before carrier handoff. They are single-use, and a slammed liftgate during your own load-in fires them too.+As purchased:+generic Thermlogix clones of both (25G shock 20-pack + tilt 20-pack, links in C3), arriving Sep 9. Same mechanisms, but no factory calibration certs, serials, or carrier brand recognition — they are our own telltales rather than freight-claim evidence. Apply two of each per crate as above; the 20-packs leave plenty of spares for re-arming across the two-year tour.+A1+Assembly order+Rip ten of the 2x4s in half: one table-saw pass each yields the twenty rail sticks. Cut the perimeter rails to length first and save the between-rail pieces for cut-to-fit.+Write the part label (C1/C2, first column) on every piece as it comes off the saw+— the same codes sit on the 2D drawings and in the 3D viewer’s Labels panel, so a pile of labeled parts reassembles days later without guesswork.+Build the base deck-down: glue + screw the 2x4 ring, crossmembers, and corner pads through the ply from the deck side, then bolt on all six casters and flip it onto its wheels.+Frame the five remaining panels: Gorilla Ultimate wood glue (as purchased) on every rail-to-ply face plus #8 x 1¼″ driven from the ply (inside) face at 8″ o.c., frames flush with the panel edges. Intermediate verticals and crossmembers butt the perimeter rails without screws: the ply skin is the structural web, and end-grain screws would split the rip stock for nothing. Swipe glue on the butt faces as they go in. This includes the cap and the door end: the glue-free rule is only for the joints BETWEEN panels. Lag on the end pull handles (1/4 x 3″ PowerLags).+Stand the sides on the deck, frame face flush with the deck edge. They rest on the floor of the crate by gravity; #10 x 3″ straight down through the bottom rail and deck into the base ring, 8″ o.c.+Drop the ends in between the side plies onto the deck. Screw the vertical corner stacks (through the side corner rails into the end edge rails) and down through the end bottom rails into the ring’s end rails.+Load the payload onto its 2″ foam bed before closing the second end. Box the frame ends with the foam-faced thrust blocks (screwed down into the base grid), set the foam-padded hold-down bars across the top at the wall-vertical planes (x = 24 / 72″, dodging the DIN devices) with their ends screwed through the side ply into the verticals, and add side blocking from the ply offcuts. Wood never touches the machine.+Set the cap on: it rests on the wall tops all the way around. Screw down through the cap ring into the wall top rails. No glue on the cap or one end: those are the doors.+Mark for the field: spray the 3″ black dots on every wall-to-wall fastener (corner columns and cap ring, plus the floor screws from inside), freehand the corner letters A to D across each corner seam with the crate ID (Rust-Oleum 2X flat black, no stencils), and tape spare T20/T30 bits inside the cap ring.+Paint the marks, then apply the shock and tilt indicator labels last.+Generated by+build-crate.py+in this folder: geometry, isometric views, the GLB models behind the+3D viewer+, and the interference check all come from the same piece definitions. Edit the script, rerun it, and the packet and model stay in lockstep.\ No newline at end of file

@@ -1,84 +1,26 @@ {-  "schema_version": 1,   "slug": "solidworks-bridge",-  "type": "app",-  "title": "SOLIDWORKS Bridge",-  "brief": "Drive SOLIDWORKS desktop CAD from any Adom container via swx_* verbs: create/open/import documents, model with a JSON DSL, drive dimensions, export 15+ formats, generate assembly BOMs, mass properties and interference - deny-by-default writes, live-validated. Check adom-bridge bridge_list; install runtime via bridge_install with this page's manifest; skills via adom-wiki pkg install adom/solidworks-bridge.",-  "version": "0.1.0",-  "hero": {-    "type": "billboard",-    "headline": "SOLIDWORKS, driven by your AI",-    "subhead": "Create, model, measure and export real SOLIDWORKS parts from any Adom container - with writes locked to its own documents"-  },-  "author": {-    "name": "Drew Owens",-    "email": "[email protected]"-  },-  "tags": [],-  "license": "proprietary",-  "visibility": {-    "public": true-  },-  "sample_prompts": [],-  "discovery_triggers": [-    "solidworks",-    "open my part in solidworks",-    "create a new solidworks part",-    "model a bracket in solidworks",-    "make a part in solidworks",-    "solidworks bom",-    "bill of materials from a solidworks assembly",-    "export step from solidworks",-    "export stl from solidworks",-    "export glb from solidworks",-    "solidworks mass properties",-    "how heavy is this part",-    "interference check on my assembly",-    "change a dimension in solidworks",-    "drive a solidworks dimension",-    "solidworks custom properties",-    "open a sldprt file",-    "open a sldasm assembly",-    "import a step file into solidworks",-    "pack and go a solidworks design",-    "find my solidworks files",-    "rebuild check my model",-    "screenshot solidworks",-    "launch solidworks",-    "close my solidworks document",-    "solidworks parameters",-    "set material in solidworks",-    "swx",-    "sldprt",-    "sldasm",-    "slddrw",-    "3dexperience solidworks",-    "solidworks for makers",-    "export a step file from solidworks",-    "export a solidworks part to step",-    "get a step out of solidworks",-    "solidworks to step",-    "solidworks export",-    "make a bom in solidworks",-    "solidworks assembly bom",-    "measure my solidworks part",-    "solidworks design analysis",-    "automate solidworks",-    "control solidworks",-    "solidworks from the cloud",-    "drive solidworks with ai",-    "solidworks bridge"-  ],-  "discovery_pitch": null,-  "metadata": {},-  "created_at": "2026-09-03T15:20:54.269Z",-  "updated_at": "2026-09-03T15:20:54.269Z",-  "install": {-    "binary_name": "",-    "install_dir": "",-    "install_hint": "",-    "version_cmd": ""-  },-  "skills": [],-  "org": "adom"+  "discovery_pitch": "Drive SOLIDWORKS from any Adom container: check `adom-bridge bridge_list` for the bridge, install its runtime via bridge_install with this page's manifest, get skills via `adom-wiki pkg install adom/solidworks-bridge`, then drive swx_* verbs. Writes are deny-by-default: it creates and edits its own documents, never the user's, unless explicitly opted in.",+  "sample_prompts": [+    {+      "label": "New part",+      "prompt": "Create a new SolidWorks part and extrude a 50x30x20mm block in 6061 aluminum"+    },+    {+      "label": "Export STEP",+      "prompt": "Export my active SolidWorks part as a STEP file"+    },+    {+      "label": "Assembly BOM",+      "prompt": "Generate a BOM CSV from my SolidWorks assembly"+    },+    {+      "label": "Mass properties",+      "prompt": "How heavy is this part? Get mass properties from SolidWorks"+    },+    {+      "label": "Change a dimension",+      "prompt": "Set the extrusion depth on my SolidWorks part to 25mm"+    }+  ] }\ No newline at end of file

@@ -0,0 +1,400 @@+//! SOLIDWORKS' WINDOWS, seen through ab's generic desktop verbs.+//!+//! This bridge deliberately owns no window code. Screenshots, window+//! enumeration, taskbar overlays and WM_CLOSE are ab-core capabilities that+//! every bridge would otherwise reimplement (badly, and differently), so the+//! `swx_*` window verbs are thin, honest delegations: we supply the SOLIDWORKS+//! knowledge (which HWND is the app, which dialog titles are blocking, what is+//! safe to touch) and ab supplies the mechanism.+//!+//! A callback that fails NEVER fails the verb: ab being unreachable means a+//! partial answer, not a broken bridge. Every helper here degrades to "unknown"+//! and says so.++use serde_json::{json, Value};+use std::time::Duration;++/// The Win32 dialog window class. Every SOLIDWORKS modal — Save changes?,+/// Document Recovery, the export option sheets — is one of these.+pub const DIALOG_CLASS: &str = "#32770";++/// Is this a top-level application FRAME rather than a dialog?+///+/// It matters because closing a frame is not "dismissing a dialog", it is+/// QUITTING THE APPLICATION — with Save-changes modals on the way out, and on a+/// Connected edition this bridge cannot start it again.+///+/// The hole this closes: `ownerConfirmed` is true precisely when a window is+/// most provably SOLIDWORKS', and the main frame is the most provable window+/// there is. So the "not a general window killer" guard passed on the one window+/// it should never have passed on — and `swx_status` / `swx_window_info` hand+/// `mainHwnd` to callers, so it was the obvious thing to try.+pub fn is_frame_window(w: &Value, main_hwnd: Option<i64>) -> bool {+    let hwnd = w.get("hwnd").and_then(|h| h.as_i64());+    if hwnd.is_some() && hwnd == main_hwnd {+        return true;+    }+    let class = w.get("className").and_then(|c| c.as_str()).unwrap_or("");+    // MFC frame windows (which is what SOLIDWORKS' own windows are) register as+    // `Afx:<hex>:...`. A dialog is `#32770`; ANYTHING ELSE — including a window+    // ab reports with no className at all — is treated as a frame.+    //+    // The `!class.is_empty() &&` that used to lead this expression inverted its+    // own fail-safe: a window whose class we could not read was declared "not a+    // frame" and therefore closable. Same rule as `kill_is_unsafe`: an+    // unanswerable question is not permission.+    class != DIALOG_CLASS+}++/// Dialog kinds this bridge itself causes. REPORTED, not licensed: closing even+/// one of these needs the process-level write opt-in, because on 2026-09-02+/// closing a stuck SOLIDWORKS modal through the window manager took the whole+/// application down. The flag exists so a caller can see which dialogs on screen+/// are the bridge's own mess.+///+/// Deliberately ONE entry: `export_options` is the sheet a `SaveAs3` raises.+/// Everything else, `settings` and `message` included, can equally be a dialog+/// the USER opened and is part-way through answering.+pub const BRIDGE_CAUSED_DIALOGS: &[&str] = &["export_options"];++/// Ask ab for the desktop's windows. Returns `Err` with a human message when+/// ab could not answer, so a caller can decide whether that is fatal (it never+/// is, here).+pub fn list_windows(timeout: Duration) -> Result<Vec<Value>, String> {+    let resp = crate::caller::ad_callback("desktop_list_windows", json!({}), timeout);+    windows_from(&resp).ok_or_else(|| {+        resp.get("error")+            .and_then(|e| e.as_str())+            .map(|s| s.to_string())+            .unwrap_or_else(|| "ab returned no window list".to_string())+    })+}++/// Dig the window array out of whichever envelope ab used. ab wraps some verb+/// payloads as a JSON STRING in `output` (`{"data":{"windows":[...]}}`) and+/// returns others inline, so both shapes are accepted rather than guessed at.+pub fn windows_from(resp: &Value) -> Option<Vec<Value>> {+    fn dig(v: &Value) -> Option<Vec<Value>> {+        v.get("windows")+            .or_else(|| v.get("data").and_then(|d| d.get("windows")))+            .and_then(|w| w.as_array())+            .cloned()+    }+    if let Some(w) = dig(resp) {+        return Some(w);+    }+    let inner: Value = serde_json::from_str(resp.get("output")?.as_str()?).ok()?;+    dig(&inner)+}++/// How a SOLIDWORKS dialog title is classified. The point of the classification+/// is the `blocking` / `neverAutoAnswer` split: a bridge may report anything,+/// but it must not answer a question about the USER'S unsaved work.+pub fn classify(title: &str) -> (&'static str, bool, bool) {+    let t = title.to_lowercase();+    // (kind, blocking, neverAutoAnswer)+    if t.contains("save") && (t.contains("change") || t.contains("?")) {+        return ("save_changes", true, true);+    }+    if t.contains("recover") {+        return ("document_recovery", true, true);+    }+    if t.contains("licen") || t.contains("activat") || t.contains("3dexperience") {+        return ("license", true, true);+    }+    if t.contains("update") || t.contains("upgrade") {+        return ("update", true, true);+    }+    if t == "export" || t.starts_with("export ") || t.contains("export options") {+        return ("export_options", true, false);+    }+    if t.contains("units") || t.contains("template") || t.contains("options") {+        return ("settings", true, false);+    }+    if t.contains("error") || t.contains("warning") || t.contains("rebuild") {+        return ("message", true, false);+    }+    ("unknown", true, true)+}++/// Is this window plausibly SOLIDWORKS'? `main_hwnd` (from COM's+/// `Frame().GetHWnd()`) identifies the application window exactly; a top-level+/// `#32770` cannot be attributed from the flat list ab returns, so it is+/// reported with `ownerConfirmed:false` rather than silently claimed.+pub fn is_solidworks_window(w: &Value, main_hwnd: Option<i64>, sw_pid: Option<i64>) -> Option<(bool, bool)> {+    let hwnd = w.get("hwnd").and_then(|h| h.as_i64())?;+    let title = w.get("title").and_then(|t| t.as_str()).unwrap_or("");+    let class = w.get("className").and_then(|c| c.as_str()).unwrap_or("");+    let pid = w.get("pid").and_then(|p| p.as_i64());++    // PROOF, in the only two forms available:+    //   1. the hwnd IS the application window COM told us about, or+    //   2. the window's owner pid IS SOLIDWORKS' pid.+    if Some(hwnd) == main_hwnd {+        return Some((true, true));+    }+    if let (Some(p), Some(sw)) = (pid, sw_pid) {+        if p == sw {+            return Some((true, true));+        }+        // A pid we CAN see, that is not SOLIDWORKS', is not ours at all.+        return None;+    }++    // Everything below is a CANDIDATE, never a confirmation.+    //+    // A title merely CONTAINING "SOLIDWORKS" used to count as proof, and it is+    // not: the SOLIDWORKS Installation Manager, a 3DEXPERIENCE launcher dialog+    // and an ordinary Explorer window showing a SOLIDWORKS folder all match,+    // and none of them belong to the process this bridge is driving. With COM+    // down there is no `main_hwnd` either, so the title would be the ONLY test —+    // exactly when being wrong is most likely.+    if title.to_uppercase().contains("SOLIDWORKS") {+        return Some((true, false));+    }+    if class == DIALOG_CLASS {+        return Some((true, false));+    }+    None+}++/// The dialog census: every window that could be a SOLIDWORKS modal, classified.+pub fn dialog_census(windows: &[Value], main_hwnd: Option<i64>, sw_pid: Option<i64>) -> Vec<Value> {+    let mut out = Vec::new();+    for w in windows {+        let class = w.get("className").and_then(|c| c.as_str()).unwrap_or("");+        let title = w.get("title").and_then(|t| t.as_str()).unwrap_or("");+        if class != DIALOG_CLASS {+            continue;+        }+        let Some((ours, confirmed)) = is_solidworks_window(w, main_hwnd, sw_pid) else { continue };+        if !ours {+            continue;+        }+        let (kind, blocking, never_auto) = classify(title);+        out.push(json!({+            "hwnd": w.get("hwnd").cloned().unwrap_or(Value::Null),+            "title": title,+            "className": class,+            "kind": kind,+            "bridgeCaused": BRIDGE_CAUSED_DIALOGS.contains(&kind),+            "blocking": blocking,+            "neverAutoAnswer": never_auto,+            "ownerConfirmed": confirmed,+            "rect": w.get("rect").cloned().unwrap_or(Value::Null),+        }));+    }+    out+}++/// Every window we believe belongs to SOLIDWORKS, for `swx_window_info`.+pub fn solidworks_windows(windows: &[Value], main_hwnd: Option<i64>, sw_pid: Option<i64>) -> Vec<Value> {+    windows+        .iter()+        .filter_map(|w| {+            let (ours, confirmed) = is_solidworks_window(w, main_hwnd, sw_pid)?;+            if !ours {+                return None;+            }+            let class = w.get("className").and_then(|c| c.as_str()).unwrap_or("");+            Some(json!({+                "hwnd": w.get("hwnd").cloned().unwrap_or(Value::Null),+                "title": w.get("title").cloned().unwrap_or(Value::Null),+                "className": class,+                "rect": w.get("rect").cloned().unwrap_or(Value::Null),+                "isMain": w.get("hwnd").and_then(|h| h.as_i64()) == main_hwnd,+                "isDialog": class == DIALOG_CLASS,+                "isFrame": is_frame_window(w, main_hwnd),+                // `closable` is what a caller ACTS on, so it has to fold in+                // every refusal `swx_close_window` applies — not just+                // attribution. Reporting a Save-changes dialog as closable was+                // the same discoverability shape as handing out `mainHwnd`.+                "closable": !is_frame_window(w, main_hwnd)+                    && confirmed+                    && !classify(w.get("title").and_then(|t| t.as_str()).unwrap_or("")).2,+                "pid": w.get("pid").cloned().unwrap_or(Value::Null),+                "ownerConfirmed": confirmed,+            }))+        })+        .collect()+}++/// Close one window through ab's UIA WindowPattern.+pub fn close_window(hwnd: i64, reason: &str, timeout: Duration) -> Value {+    crate::caller::ad_callback(+        "desktop_ui_window",+        json!({"action": "close", "hwnd": hwnd, "reason": reason}),+        timeout,+    )+}++/// Put (or clear) the "Adom is driving SOLIDWORKS" taskbar overlay badge.+pub fn set_badge(hwnd: i64, on: bool, tooltip: &str, timeout: Duration) -> Value {+    crate::caller::ad_callback(+        "desktop_taskbar",+        json!({+            "hwnd": hwnd,+            "overlay": {"badge": if on { "adom" } else { "none" }, "tooltip": tooltip},+        }),+        timeout,+    )+}++/// Background PrintWindow capture of one window — and, per ab's contract, of+/// every popup/dialog that window owns. That owned-popup list is the only+/// AUTHORITATIVE way to attribute a dialog to SOLIDWORKS, which is why+/// `swx_state`'s screenshot doubles as the trustworthy dialog census.+pub fn screenshot(hwnd: i64, timeout: Duration) -> Value {+    crate::caller::ad_callback("desktop_screenshot_window", json!({"hwnd": hwnd}), timeout)+}++#[cfg(test)]+mod tests {+    use super::*;++    fn win(hwnd: i64, title: &str, class: &str) -> Value {+        json!({"hwnd": hwnd, "title": title, "className": class, "rect": {"left": 0}})+    }++    #[test]+    fn unwraps_both_envelopes_ab_actually_uses() {+        // inline+        let inline = json!({"windows": [win(1, "a", "X")]});+        assert_eq!(windows_from(&inline).unwrap().len(), 1);+        // the real one observed live: a JSON STRING under `output`+        let nested = json!({"output": json!({"data": {"windows": [win(1, "a", "X"), win(2, "b", "Y")]}}).to_string()});+        assert_eq!(windows_from(&nested).unwrap().len(), 2);+        // and a shape with neither+        assert!(windows_from(&json!({"error": "nope"})).is_none());+    }++    #[test]+    fn the_dialogs_that_must_never_be_auto_answered_are_flagged() {+        for (title, kind) in [+            ("SOLIDWORKS", "unknown"),+            ("Save changes to Part1?", "save_changes"),+            ("SOLIDWORKS Document Recovery", "document_recovery"),+            ("3DEXPERIENCE", "license"),+        ] {+            let (k, blocking, never) = classify(title);+            assert_eq!(k, kind, "{title}");+            assert!(blocking, "{title}");+            assert!(never, "{title} must never be auto-answered");+        }+        // An export option sheet is classified as answerable IN PRINCIPLE (it is+        // the bridge's own dialog, not a question about the user's work) — but+        // classification is only half the decision: closing also requires the+        // window to be attributable to SOLIDWORKS. See+        // `an_unattributed_dialog_is_never_closable`.+        let (k, _, never) = classify("Export");+        assert_eq!(k, "export_options");+        assert!(!never);+    }++    #[test]+    fn the_application_frame_is_never_closable() {+        // THE round-7 hole. `ownerConfirmed` is true exactly when a window is+        // most provably SOLIDWORKS' — and the main frame is the most provable+        // window there is, so the "not a general window killer" guard passed on+        // the one window that must never be closed this way. Closing a frame is+        // quitting the application, which is swx_stop's job and is gated.+        let main = Some(4242);+        let frame = win(4242, "SOLIDWORKS Design Professional for Makers 2026", "Afx:0000");+        assert!(is_frame_window(&frame, main), "the main window is a frame");+        let ours = solidworks_windows(&[frame.clone()], main, None);+        assert_eq!(ours[0]["isMain"], true);+        assert_eq!(ours[0]["ownerConfirmed"], true, "it IS provably ours...");+        assert_eq!(ours[0]["closable"], false, "...and it is still never closable");++        // A SECOND SOLIDWORKS frame (a second document window) is a frame too,+        // even without being the one COM told us about.+        let other = win(5555, "SOLIDWORKS", "Afx:0001");+        assert!(is_frame_window(&other, main));+        // A dialog is not a frame — that is what this verb is for.+        let mut dialog = win(858186, "Export", DIALOG_CLASS);+        dialog["pid"] = json!(777);+        assert!(!is_frame_window(&dialog, main));+        assert_eq!(solidworks_windows(&[dialog], main, Some(777))[0]["closable"], true);+        // ...but a dialog about the USER'S OWN WORK is never closable, however+        // provably ours it is.+        let mut theirs = win(9001, "Save changes to gearbox?", DIALOG_CLASS);+        theirs["pid"] = json!(777);+        let row = solidworks_windows(&[theirs], main, Some(777));+        assert_eq!(row[0]["ownerConfirmed"], true);+        assert_eq!(row[0]["closable"], false, "never advertise the user's own question as closable");+    }++    #[test]+    fn only_dialogs_the_bridge_itself_raised_are_closable_without_the_opt_in() {+        // `export_options` is the sheet our own SaveAs3 raises. `settings` and+        // `message` can just as easily be something the USER opened and is+        // part-way through answering.+        assert!(BRIDGE_CAUSED_DIALOGS.contains(&"export_options"));+        for user_owned in ["settings", "message", "unknown", "save_changes"] {+            assert!(+                !BRIDGE_CAUSED_DIALOGS.contains(&user_owned),+                "{user_owned} may belong to the user"+            );+        }+    }++    #[test]+    fn an_unattributed_dialog_is_never_closable() {+        // THE regression test for the review finding. ab's flat window list+        // carries no owner pid, so a bare `#32770` could belong to Word's Save+        // dialog just as easily as to SOLIDWORKS. The census must mark it+        // ownerConfirmed:false, and the close path must refuse it on that basis+        // — the earlier version of this test asserted the opposite ("ours to+        // close"), encoding the hazard as intended behaviour.+        let windows = vec![win(858186, "Export", DIALOG_CLASS)];+        let census = dialog_census(&windows, Some(1836650), None);+        assert_eq!(census.len(), 1, "it IS reported");+        assert_eq!(census[0]["ownerConfirmed"], false, "...but never as proven SOLIDWORKS'");+        // A dialog whose title names SOLIDWORKS is attributable, and a #32770 is+        // exactly how SOLIDWORKS' own dialogs present.+        // A title containing "SOLIDWORKS" is NOT proof: the Installation+        // Manager and a 3DEXPERIENCE launcher dialog both match it and neither+        // is the process we are driving.+        let named = vec![win(9, "SOLIDWORKS Installation Manager", DIALOG_CLASS)];+        assert_eq!(dialog_census(&named, None, None)[0]["ownerConfirmed"], false);+        // An owner pid IS proof, in both directions.+        let mut owned = win(11, "Export", DIALOG_CLASS);+        owned["pid"] = json!(4242);+        assert_eq!(dialog_census(&[owned.clone()], None, Some(4242))[0]["ownerConfirmed"], true);+        assert!(dialog_census(&[owned], None, Some(777)).is_empty(), "another app's dialog is not ours at all");+    }++    #[test]+    fn attribution_is_reported_not_assumed() {+        let main = Some(1836650);+        let windows = vec![+            win(1836650, "SOLIDWORKS Design Professional for Makers 2026", "Afx:0000"),+            win(858186, "Export", DIALOG_CLASS),+            win(266266, "gallia - Google Chrome", "Chrome_WidgetWin_1"),+        ];+        let ours = solidworks_windows(&windows, main, None);+        assert_eq!(ours.len(), 2, "Chrome is not ours");+        assert_eq!(ours[0]["isMain"], true);+        assert_eq!(ours[0]["ownerConfirmed"], true);+        // a bare #32770 is a CANDIDATE, and says so+        assert_eq!(ours[1]["isDialog"], true);+        assert_eq!(ours[1]["ownerConfirmed"], false);++        let dialogs = dialog_census(&windows, main, None);+        assert_eq!(dialogs.len(), 1);+        assert_eq!(dialogs[0]["kind"], "export_options");+        assert_eq!(dialogs[0]["hwnd"], 858186);+    }++    #[test]+    fn without_a_com_hwnd_the_main_window_is_still_found_by_title() {+        let windows = vec![win(9, "SOLIDWORKS Design Professional", "Afx:1")];+        let ours = solidworks_windows(&windows, None, None);+        assert_eq!(ours.len(), 1, "it is still REPORTED as a candidate");+        assert_eq!(ours[0]["isMain"], false, "unproven without the COM hwnd");+        assert_eq!(+            ours[0]["ownerConfirmed"], false,+            "a title is not proof of ownership — and with COM down it would be the ONLY test"+        );+    }+}

@@ -0,0 +1,153 @@+//! BOM assembly: the com host returns raw component rows; the SERVER turns them+//! into the deliverable.+//!+//! That split is deliberate. The host process is doing single-threaded COM work+//! against a live application — the less time it spends sorting strings and+//! building CSV, the shorter the window in which SOLIDWORKS is blocked. So the+//! host walks the tree and the server does the paperwork: sort by name, work out+//! the union of custom-property names (they differ per component — that union is+//! the column set), and write RFC 4180 CSV.++use serde_json::Value;++/// Rows sorted by name, case-insensitively — the order a human reads a BOM in.+pub fn sort_rows(rows: &mut [Value]) {+    rows.sort_by_key(|r| r.get("name").and_then(|v| v.as_str()).unwrap_or("").to_lowercase());+}++/// The union of every row's custom-property names, sorted: the CSV columns.+pub fn prop_columns(rows: &[Value]) -> Vec<String> {+    let mut names: Vec<String> = rows+        .iter()+        .filter_map(|r| r.get("properties").and_then(|p| p.as_object()))+        .flat_map(|p| p.keys().cloned())+        .collect();+    names.sort();+    names.dedup();+    names+}++/// A property's display value: `resolved` (what SOLIDWORKS evaluates the+/// expression to) beats the raw `value`; missing is empty.+fn prop_cell(row: &Value, name: &str) -> String {+    let p = row.get("properties").and_then(|p| p.get(name));+    for key in ["resolved", "value"] {+        if let Some(v) = p.and_then(|p| p.get(key)) {+            let s = cell(v);+            if !s.is_empty() {+                return s;+            }+        }+    }+    String::new()+}++fn cell(v: &Value) -> String {+    match v {+        Value::Null => String::new(),+        Value::String(s) => s.clone(),+        other => other.to_string(),+    }+}++fn escape(field: &str) -> String {+    if field.contains([',', '"', '\n', '\r']) {+        format!("\"{}\"", field.replace('"', "\"\""))+    } else {+        field.to_string()+    }+}++fn write_row(out: &mut String, fields: &[String]) {+    out.push_str(&fields.iter().map(|f| escape(f)).collect::<Vec<_>>().join(","));+    out.push_str("\r\n");+}++/// The whole CSV: fixed columns first, then one column per custom property.+pub fn to_csv(rows: &[Value], prop_names: &[String]) -> String {+    let mut out = String::new();+    let mut header: Vec<String> =+        ["item", "name", "configuration", "quantity", "file"].iter().map(|s| s.to_string()).collect();+    header.extend(prop_names.iter().cloned());+    write_row(&mut out, &header);++    for (i, row) in rows.iter().enumerate() {+        let mut fields = vec![+            (i + 1).to_string(),+            cell(row.get("name").unwrap_or(&Value::Null)),+            cell(row.get("configuration").unwrap_or(&Value::Null)),+            cell(row.get("quantity").unwrap_or(&Value::Null)),+            cell(row.get("file").unwrap_or(&Value::Null)),+        ];+        fields.extend(prop_names.iter().map(|p| prop_cell(row, p)));+        write_row(&mut out, &fields);+    }+    out+}++#[cfg(test)]+mod tests {+    use super::*;+    use serde_json::json;++    fn rows() -> Vec<Value> {+        vec![+            json!({"name": "shaft", "configuration": "Long", "quantity": 1,+                   "file": "C:\\m\\shaft.sldprt",+                   "properties": {"PartNo": {"value": "SHF-220", "resolved": "SHF-220"}}}),+            json!({"name": "Bracket", "configuration": "Default", "quantity": 2,+                   "file": "C:\\m\\bracket.sldprt",+                   "properties": {"PartNo": {"value": "BRK-100", "resolved": "BRK-100"},+                                  "Material": {"value": "6061-T6", "resolved": "6061-T6"}}}),+        ]+    }++    #[test]+    fn sorts_case_insensitively_by_name() {+        let mut r = rows();+        sort_rows(&mut r);+        assert_eq!(r[0]["name"], "Bracket");+    }++    #[test]+    fn columns_are_the_sorted_union_of_property_names() {+        assert_eq!(prop_columns(&rows()), vec!["Material".to_string(), "PartNo".to_string()]);+    }++    #[test]+    fn csv_has_a_header_item_numbers_and_blank_cells_for_absent_props() {+        let mut r = rows();+        sort_rows(&mut r);+        let cols = prop_columns(&r);+        let csv = to_csv(&r, &cols);+        let lines: Vec<&str> = csv.lines().collect();+        assert_eq!(lines[0], "item,name,configuration,quantity,file,Material,PartNo");+        assert_eq!(lines[1], "1,Bracket,Default,2,C:\\m\\bracket.sldprt,6061-T6,BRK-100");+        // shaft has no Material -> empty cell, and keeps its item number+        assert_eq!(lines[2], "2,shaft,Long,1,C:\\m\\shaft.sldprt,,SHF-220");+        assert!(csv.ends_with("\r\n"), "RFC 4180 line endings");+    }++    #[test]+    fn fields_with_commas_and_quotes_are_escaped() {+        let r = vec![json!({+            "name": "odd, part", "configuration": "\"quoted\"", "quantity": 1, "file": "x",+            "properties": {"Note": {"resolved": "a,b"}}+        })];+        let csv = to_csv(&r, &["Note".to_string()]);+        assert!(csv.contains("\"odd, part\""), "{csv}");+        assert!(csv.contains("\"\"\"quoted\"\"\""), "{csv}");+        assert!(csv.contains("\"a,b\""), "{csv}");+    }++    #[test]+    fn resolved_wins_over_value_and_missing_is_blank() {+        let r = vec![json!({+            "name": "n", "quantity": 1, "file": "f", "configuration": "",+            "properties": {"A": {"value": "raw", "resolved": "evaluated"}, "B": {}}+        })];+        let csv = to_csv(&r, &["A".to_string(), "B".to_string()]);+        assert!(csv.contains("evaluated,"), "{csv}");+        assert!(csv.trim_end().ends_with("evaluated,"), "{csv}");+    }+}

@@ -0,0 +1,196 @@+//! Caller provenance — WHO asked.+//!+//! A user runs ~20 AI threads against one desktop. ab stamps the caller on every+//! relayed request TWO ways and we read both:+//!+//!   * `args.caller = {aiThread, containerName, source}` — what the CLI's+//!     `--ai-thread` flag actually produces, and what shows up in practice;+//!   * `X-Adom-Caller-Thread` / `-Container` / `-Reason` headers — the form ab+//!     uses on its own direct-API callbacks and what the SDK samples forward.+//!+//! args wins when both are present (it carries the explicit identity).+//!+//! TRUST RULE (ab's, and not optional): these values are SELF-ASSERTED, exactly+//! like `reason`. Use them for logging, UX and window labels — NEVER for+//! authorization. `if thread == "admin" { allow() }` is a hole, not a check.+//!+//! Identity is thread-local: each HTTP request is served on its own worker+//! thread, so no request can see another's caller.++use serde_json::Value;+use std::cell::RefCell;++/// What we call ourselves when we forward identity on a callback to ab.+pub const DELEGATE: &str = "solidworks";++pub const HEADERS: [&str; 3] =+    ["X-Adom-Caller-Thread", "X-Adom-Caller-Container", "X-Adom-Caller-Reason"];++#[derive(Default, Clone, Debug)]+pub struct Identity {+    pub thread: String,+    pub container: String,+    pub reason: String,+}++thread_local! {+    static CURRENT: RefCell<Option<Identity>> = const { RefCell::new(None) };+}++/// Capture the caller of the request this thread is about to serve.+pub fn set_from_request(header: impl Fn(&str) -> Option<String>, args: &Value) -> Identity {+    let mut ident = Identity {+        thread: header(HEADERS[0]).unwrap_or_default(),+        container: header(HEADERS[1]).unwrap_or_default(),+        reason: header(HEADERS[2]).unwrap_or_default(),+    };+    if let Some(caller) = args.get("caller").and_then(|c| c.as_object()) {+        if let Some(t) = caller.get("aiThread").and_then(|v| v.as_str()) {+            if !t.is_empty() {+                ident.thread = t.to_string();+            }+        }+        if let Some(c) = caller.get("containerName").and_then(|v| v.as_str()) {+            if !c.is_empty() {+                ident.container = c.to_string();+            }+        }+    }+    if ident.reason.is_empty() {+        if let Some(r) = args.get("reason").and_then(|v| v.as_str()) {+            ident.reason = r.to_string();+        }+    }+    CURRENT.with(|c| *c.borrow_mut() = Some(ident.clone()));+    ident+}++pub fn clear() {+    CURRENT.with(|c| *c.borrow_mut() = None);+}++pub fn current() -> Option<Identity> {+    CURRENT.with(|c| c.borrow().clone())+}++/// The ` caller="..."` fragment for the one-line-per-verb log, or "" when the+/// caller is anonymous (loopback callers — Hydrogen, another bridge, the local+/// CLI — send nothing, and that is fine).+pub fn log_suffix() -> String {+    match current() {+        Some(i) if !i.thread.is_empty() => format!(" caller=\"{}\"", i.thread),+        _ => String::new(),+    }+}++/// Headers to put on a callback we make WHILE serving an AI's verb: echo the+/// three we were handed, and add the Delegate naming us — so ab's Activity Log+/// can show BOTH facts, "chip-fetcher tab 3 (via solidworks)".+pub fn forward_headers() -> Vec<(String, String)> {+    let ident = match current() {+        Some(i) if !i.thread.is_empty() => i,+        _ => return Vec::new(),+    };+    vec![+        (HEADERS[0].to_string(), ident.thread),+        (HEADERS[1].to_string(), ident.container),+        (HEADERS[2].to_string(), ident.reason),+        ("X-Adom-Caller-Delegate".to_string(), DELEGATE.to_string()),+    ]+}++/// The `caller` args block for a callback the bridge makes on its OWN behalf+/// (a poll, a timer, cleanup): an explicit caller in args always beats the+/// forwarded headers, so no stale thread name can leak onto our own work.+pub fn self_caller() -> Value {+    serde_json::json!({"aiThread": "solidworks bridge (self)", "containerName": "local"})+}++/// Call an ab verb back over the loopback direct API, forwarding the caller.+///+/// ab injects `ADOM_DIRECT_API_URL` and `ADOM_BRIDGE_TOKEN` into our spawn env.+/// NEVER raises and never fails the verb it is helping: a delegated screenshot+/// that ab refuses is a partial answer, not a broken `swx_screenshot`.+/// Is ab's direct API reachable at all? False when this bridge was started by+/// hand instead of spawned by Adom Bridge, in which case every ab-delegated verb+/// fails for a reason unrelated to SOLIDWORKS — worth being able to say up front.+pub fn ab_available() -> bool {+    std::env::var("ADOM_DIRECT_API_URL").map(|v| !v.trim().is_empty()).unwrap_or(false)+}++pub fn ad_callback(command: &str, args: Value, timeout: std::time::Duration) -> Value {+    let base = std::env::var("ADOM_DIRECT_API_URL").unwrap_or_default();+    let base = base.trim_end_matches('/').to_string();+    if base.is_empty() {+        return serde_json::json!({+            "success": false,+            "error": "ADOM_DIRECT_API_URL not in env (inbound-only spawn?)",+        });+    }+    let mut args = args;+    let mut headers = forward_headers();+    if headers.is_empty() {+        // No caller to forward — this is our own initiative, so say so.+        if let Value::Object(map) = &mut args {+            map.entry("caller").or_insert_with(self_caller);+        }+    }+    if let Ok(token) = std::env::var("ADOM_BRIDGE_TOKEN") {+        if !token.is_empty() {+            // Attribution badge, not an auth gate.+            headers.push(("X-Adom-Bridge-Token".to_string(), token));+        }+    }+    let body = serde_json::json!({"command": command, "args": args}).to_string();+    match crate::httpc::post_json(&format!("{base}/command"), &headers, &body, timeout) {+        Ok(resp) => resp+            .json()+            .unwrap_or_else(|e| serde_json::json!({"success": false, "error": e})),+        Err(e) => serde_json::json!({"success": false, "error": format!("ab callback failed: {e}")}),+    }+}++#[cfg(test)]+mod tests {+    use super::*;+    use serde_json::json;++    fn no_headers(_: &str) -> Option<String> {+        None+    }++    #[test]+    fn args_caller_beats_headers() {+        let ident = set_from_request(+            |h| match h {+                "X-Adom-Caller-Thread" => Some("from-header".into()),+                _ => None,+            },+            &json!({"caller": {"aiThread": "from-args", "containerName": "box"}}),+        );+        assert_eq!(ident.thread, "from-args");+        assert_eq!(ident.container, "box");+        assert_eq!(log_suffix(), " caller=\"from-args\"");+        clear();+    }++    #[test]+    fn anonymous_callers_log_and_forward_nothing() {+        set_from_request(no_headers, &json!({}));+        assert_eq!(log_suffix(), "");+        assert!(forward_headers().is_empty());+        clear();+    }++    #[test]+    fn reason_falls_back_to_the_arg_and_the_delegate_is_added() {+        set_from_request(+            |h| (h == "X-Adom-Caller-Thread").then(|| "tab-3".to_string()),+            &json!({"reason": "prototyping a verb"}),+        );+        let fwd = forward_headers();+        assert!(fwd.contains(&("X-Adom-Caller-Delegate".into(), "solidworks".into())));+        assert!(fwd.contains(&("X-Adom-Caller-Reason".into(), "prototyping a verb".into())));+        clear();+    }+}

@@ -0,0 +1,3084 @@+//! ComBackend — the real SOLIDWORKS, over late-bound COM. Windows only.+//!+//! This is the direct port of the PowerShell sidecar it replaces, semantics+//! preserved call for call, because those semantics were learned the hard way:+//!+//!   * ATTACH FIRST (`GetActiveObject`), launch only when asked. Silently+//!     starting a 90-second application because someone ran a read verb is a+//!     hostile thing to do to a user's machine.+//!   * `OpenDoc6` with `swOpenDocOptions_Silent` (1) and byref error/warning+//!     out-params — an unattended bridge must never park SOLIDWORKS on a dialog+//!     nobody will answer. Fall back to legacy `OpenDoc` if the late-bound byref+//!     call comes back empty.+//!   * `Save3(1, ...)` / `SaveAs3(path, 0, 1)` — silent, copy-mode; SaveAs3+//!     keys the format off the destination extension.+//!   * Suppressed components (`GetSuppression() == 0`) are excluded from BOMs.+//!   * `InterferenceDetectionManager` is always closed with `Done()`, on every+//!     path — leaving it open leaves SOLIDWORKS in a modal-ish state.+//!+//! The COM layer cannot be exercised here (the trial serial is pending), so it+//! is written to degrade honestly: every failure carries what SOLIDWORKS+//! actually said, and a panic is caught by the host loop rather than crossing+//! the protocol boundary.++use super::host::{Backend, HostError, COMMANDS};+use super::expr::{parse_chain, Literal};+use super::variant::{Disp, Var};+use serde_json::{json, Map, Value};+use windows::core::{Interface, BSTR, GUID};+use windows::Win32::System::Com::{+    CLSIDFromProgID, CoCreateInstance, CoInitializeEx, IDispatch, CLSCTX_LOCAL_SERVER,+    COINIT_APARTMENTTHREADED,+};+use windows::Win32::System::Ole::GetActiveObject;+use windows::Win32::System::Variant::VARIANT;++const PROG_ID: &str = "SldWorks.Application";++/// swDocumentTypes_e+const DOC_PART: i32 = 1;+const DOC_ASSEMBLY: i32 = 2;+const DOC_DRAWING: i32 = 3;++fn doc_type_id(path: &str) -> Option<i32> {+    match super::mock::doc_type_of(path) {+        Some("part") => Some(DOC_PART),+        Some("assembly") => Some(DOC_ASSEMBLY),+        Some("drawing") => Some(DOC_DRAWING),+        _ => None,+    }+}++fn doc_type_name(id: i32) -> String {+    match id {+        DOC_PART => "part".into(),+        DOC_ASSEMBLY => "assembly".into(),+        DOC_DRAWING => "drawing".into(),+        other => format!("unknown({other})"),+    }+}++pub struct ComBackend {+    sw: Option<Disp>,+    was_launched: bool,+    /// The com host's OWN record of the documents it created — independent of+    /// the server's registry, and the reason this is not just a duplicated+    /// check. Rounds 3 and 5 both turned on the server-authorizes / host-acts+    /// split: a server-side decision is a claim, and the host acted on it. The+    /// host creates every document itself (`new_document`, `import`,+    /// `run_script`'s `new_part`), so it can answer "is this mine?" without+    /// being told — and it refuses a write the server "authorized" if its own+    /// answer differs.+    created: Vec<(String, Option<String>)>,+    /// The SOLIDWORKS session `created` belongs to. A record from another+    /// session is worthless: SOLIDWORKS restarts its Part numbering, so a+    /// remembered `Part1` would match the user's next one.+    created_session: Option<i64>,+    /// The component-insertion call that WORKED on this install, remembered+    /// after the first success.+    ///+    /// `IAssemblyDoc::AddComponent5` is documented as THE way to insert a+    /// component, and on this bridge's first live target (SOLIDWORKS Connected+    /// R2026x) it hands back `Nothing` — which an earlier probe read as "the+    /// edition cannot do it". It can: the return value is the lie, not the+    /// insertion. So `add_component` walks a ladder of spellings and decides+    /// success by COUNTING COMPONENTS rather than by trusting a return, and the+    /// rung that worked is cached here — a 150-component assembly must not pay+    /// the discovery cost 150 times.+    insert_method: Option<String>,+}++impl Default for ComBackend {+    fn default() -> Self {+        Self::new()+    }+}++impl ComBackend {+    /// Initializes COM for THIS thread as an STA. The com-host child runs its+    /// whole loop on one thread precisely so this holds for every call.+    pub fn new() -> Self {+        unsafe {+            // S_FALSE (already initialized) is fine; only a hard failure matters,+            // and it will resurface on the first call with a real message.+            let _ = CoInitializeEx(None, COINIT_APARTMENTTHREADED);+        }+        super::host::log("COM initialized (STA)");+        // A com-host child is killed and respawned by design — that is the whole+        // point of the child-process architecture. Its record of what it created+        // has to survive that, or the FIRST thing a respawn does is start+        // refusing writes to the bridge's own documents, silently, exactly after+        // the recovery path the architecture exists for.+        let (created_session, created) = crate::comhost::created_store::load_session();+        Self { sw: None, was_launched: false, created, created_session, insert_method: None }+    }++    fn clsid() -> Result<GUID, HostError> {+        let wide: Vec<u16> = PROG_ID.encode_utf16().chain(std::iter::once(0)).collect();+        unsafe {+            CLSIDFromProgID(windows::core::PCWSTR(wide.as_ptr())).map_err(|e| {+                HostError::detailed(+                    "SOLIDWORKS is not registered on this machine (no SldWorks.Application \+                     ProgID) — it is either not installed or the install is broken",+                    format!("{e}"),+                )+            })+        }+    }++    /// A live SldWorks.Application. Attaches to a running instance first;+    /// launches one only when `launch` is set.+    fn app(&mut self, launch: bool, visible: bool) -> Result<Disp, HostError> {+        if let Some(sw) = &self.sw {+            // Probe the cached object: a SOLIDWORKS that has since exited leaves+            // a stale proxy that fails on first touch.+            if sw.call("Visible", &[]).is_ok() {+                return Ok(sw.clone());+            }+            self.sw = None;+        }+        let clsid = Self::clsid()?;+        unsafe {+            let mut unk = None;+            if GetActiveObject(&clsid, None, &mut unk).is_ok() {+                if let Some(unk) = unk {+                    if let Ok(disp) = unk.cast::<IDispatch>() {+                        super::host::log("attached to running SOLIDWORKS");+                        let d = Disp(disp);+                        self.sw = Some(d.clone());+                        return Ok(d);+                    }+                }+            }+        }+        if !launch {+            return Err(HostError::msg(+                "SOLIDWORKS is not running (start it, then retry — swx_start reports whether \+                 this edition can be launched programmatically at all)",+            ));+        }+        super::host::log("launching SOLIDWORKS via COM (cold start can take 30-90s)...");+        let disp: IDispatch = unsafe {+            CoCreateInstance(&clsid, None, CLSCTX_LOCAL_SERVER).map_err(|e| {+                HostError::detailed(+                    "failed to launch SOLIDWORKS via COM. On SOLIDWORKS Connected / \+                     3DEXPERIENCE (including Design Professional for Makers) this ALWAYS \+                     fails: the process it spawns refuses with \"SOLIDWORKS Design must be \+                     launched from the 3DEXPERIENCE Platform\" and never becomes a drivable \+                     COM server. The human has to start it from the 3DEXPERIENCE Platform or \+                     the desktop shortcut it created.",+                    format!("{e}"),+                )+            })?+        };+        let sw = Disp(disp);+        sw.try_put("Visible", &Var::boolean(visible));+        // Suppress blocking modal dialogs where the API allows it: an unattended+        // bridge must never park SOLIDWORKS on a question nobody will answer.+        sw.try_put("UserControlBackground", &Var::boolean(true));+        self.was_launched = true;+        self.sw = Some(sw.clone());+        Ok(sw)+    }++    fn doc_info(doc: &Disp) -> Value {+        let type_id = doc.int("GetType", &[]).unwrap_or(0);+        let config = doc+            .obj("ConfigurationManager", &[])+            .ok()+            .flatten()+            .and_then(|cm| cm.obj("ActiveConfiguration", &[]).ok().flatten())+            .and_then(|c| c.string("Name", &[]));+        json!({+            "title": doc.string("GetTitle", &[]),+            "path": doc.string("GetPathName", &[]),+            "type": doc_type_name(type_id),+            "config": config,+            "dirty": doc.flag("GetSaveFlag", &[]),+        })+    }++    /// The target document: explicit `path`, else the active doc.+    fn resolve(&mut self, args: &Value) -> Result<Disp, HostError> {+        let sw = self.app(false, true)?;+        // Resolution order: `path`, then `docName`/`name` (a TITLE), then ActiveDoc.+        //+        // PATH FIRST, and this ordering is load-bearing. A title is not an+        // identity: `C:\users\thing.sldprt` and `C:\bridge\thing.sldprt` are+        // both titled `thing.sldprt`, and having two such documents open is+        // ordinary — so a save_as authorized against the bridge's copy once+        // renamed the user's.+        //+        // BUT A TITLE IS THE ONLY IDENTITY AN UNSAVED DOCUMENT HAS, and this is+        // where the live run broke. `GetOpenDocumentByName` wants a FULL PATH;+        // handed the title of a document that has never been saved it returns+        // nothing, so `swx_new_document` produced a `Part2` that `swx_docs`+        // listed and every other verb reported as "document not open" —+        // including with no target at all, because the server now always sends+        // the resolved identity. The whole create → model → export flow was dead+        // for new documents while 89 mock tests passed, since the mock resolved+        // titles from its own map.+        //+        // So a title is resolved by WALKING THE OPEN DOCUMENTS and comparing+        // `GetTitle()`. That works for saved and unsaved alike, and it lets the+        // ambiguity rule be enforced here too rather than trusting whichever+        // document SOLIDWORKS happens to hand back first.+        let path = args+            .get("path")+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty());+        if let Some(path) = path {+            return sw.obj("GetOpenDocumentByName", &[&Var::bstr(path)])?.ok_or_else(|| {+                HostError::coded(+                    "document_not_open",+                    format!("document not open: {path} (swx_docs lists the open titles and paths)"),+                )+            });+        }+        let title = args+            .get("docName")+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .or_else(|| args.get("name").and_then(|v| v.as_str()).filter(|s| !s.is_empty()));+        if let Some(title) = title {+            // A failed enumeration must NEVER be read as "that document is not+            // open" — `documents()` raises docs_enumeration_failed instead.+            let mut hits: Vec<Disp> = Vec::new();+            for doc in Self::documents(&sw)? {+                if doc.string("GetTitle", &[]).as_deref() == Some(title) {+                    hits.push(doc);+                }+            }+            return match hits.len() {+                1 => Ok(hits.remove(0)),+                0 => Err(HostError::coded(+                    "document_not_open",+                    format!("document not open: {title} (swx_docs lists the open titles and paths)"),+                )),+                n => Err(HostError::coded(+                    "ambiguous_target",+                    format!(+                        "{n} open documents are titled '{title}' — name the one you mean by path"+                    ),+                )),+            };+        }+        sw.obj("ActiveDoc", &[])?.ok_or_else(|| {+            HostError::coded(+                "no_target_document",+                "no active document (pass path or name, or swx_open one)",+            )+        })+    }++    /// Custom properties for one configuration scope ("" = file level).+    fn custom_props(doc: &Disp, configuration: &str) -> Value {+        let mut out = Map::new();+        let mgr = match doc+            .obj("Extension", &[])+            .ok()+            .flatten()+            .and_then(|ext| ext.obj("CustomPropertyManager", &[&Var::bstr(configuration)]).ok().flatten())+        {+            Some(m) => m,+            None => return Value::Object(out),+        };+        let names = match mgr.call("GetNames", &[]) {+            Ok(v) => v,+            Err(_) => return Value::Object(out),+        };+        for name_var in names.as_array() {+            let name = match name_var.as_string() {+                Some(n) if !n.is_empty() => n,+                _ => continue,+            };+            let mut value = BSTR::new();+            let mut resolved = BSTR::new();+            let call = mgr.call(+                "Get4",+                &[+                    &Var::bstr(&name),+                    &Var::boolean(false),+                    &Var::byref_bstr(&mut value as *mut BSTR),+                    &Var::byref_bstr(&mut resolved as *mut BSTR),+                ],+            );+            match call {+                Ok(_) => {+                    out.insert(+                        name,+                        json!({"value": value.to_string(), "resolved": resolved.to_string()}),+                    );+                }+                Err(e) => {+                    out.insert(name, json!({"value": null, "resolved": null, "error": e.message}));+                }+            }+        }+        Value::Object(out)+    }++    fn cmd_status(&mut self) -> Result<Value, HostError> {+        let mut running = false;+        let mut version = Value::Null;+        let mut open_docs = 0usize;+        if let Ok(clsid) = Self::clsid() {+            unsafe {+                let mut unk = None;+                if GetActiveObject(&clsid, None, &mut unk).is_ok() {+                    if let Some(disp) = unk.and_then(|u| u.cast::<IDispatch>().ok()) {+                        let sw = Disp(disp);+                        running = true;+                        version = sw+                            .string("RevisionNumber", &[])+                            .map(Value::from)+                            .unwrap_or(Value::Null);+                        open_docs = sw.call("GetDocuments", &[]).map(|d| d.as_array().len()).unwrap_or(0);+                        self.sw = Some(sw);+                    }+                }+            }+        }+        Ok(json!({+            "running": running,+            "version": version,+            "openDocs": open_docs,+            "attached": self.sw.is_some(),+        }))+    }++    fn cmd_open(&mut self, args: &Value) -> Result<Value, HostError> {+        let path = args+            .get("path")+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("path is required"))?;+        if !std::path::Path::new(path).exists() {+            return Err(HostError::msg(format!("file not found: {path}")));+        }+        let type_id = doc_type_id(path).ok_or_else(|| {+            HostError::msg(format!(+                "not a SOLIDWORKS document: {} (want .sldprt/.sldasm/.slddrw)",+                std::path::Path::new(path)+                    .extension()+                    .map(|e| format!(".{}", e.to_string_lossy().to_lowercase()))+                    .unwrap_or_default()+            ))+        })?;+        let configuration =+            args.get("configuration").and_then(|v| v.as_str()).unwrap_or("").to_string();+        // LAUNCH IS THE SERVER'S DECISION, NOT THIS FUNCTION'S. `swx_open` used+        // to pass launch:true unconditionally, which made it a second road to+        // CoCreateInstance that walked straight past the edition check — on a+        // Connected install that puts the "must be launched from the+        // 3DEXPERIENCE Platform" modal on the user's screen and leaves a dead+        // process behind. The server decides with `may_launch` and says so here.+        let launch = args.get("launch").and_then(|v| v.as_bool()).unwrap_or(false);+        let sw = self.app(launch, true)?;++        let mut errors = 0i32;+        let mut warnings = 0i32;+        // swOpenDocOptions_Silent = 1, swOpenDocOptions_ReadOnly = 2.+        //+        // Silent alone takes a WRITE LOCK on the user's file — nobody else can+        // open it for editing while the bridge holds it — and an older-version+        // document is converted in memory, which marks it dirty and makes+        // SOLIDWORKS offer to save on close. Since the default posture refuses+        // to write to a document the bridge did not create anyway, holding a+        // write lock on it buys nothing; `readOnly` is therefore the default+        // here, and a caller that means to edit says so.+        let read_only = args.get("readOnly").and_then(|v| v.as_bool()).unwrap_or(true);+        let open_options = if read_only { 1 | 2 } else { 1 };+        // NO fallback to the legacy OpenDoc: it has+        // no silent option and would let SOLIDWORKS raise the interactive open+        // dialog on an unattended machine — the exact thing this whole path+        // exists to prevent. Our byref marshalling is explicit here (unlike the+        // late-bound PowerShell it replaces), so the fallback bought nothing but+        // that risk. If OpenDoc6 fails, report it.+        let doc = sw+            .call(+                "OpenDoc6",+                &[+                    &Var::bstr(path),+                    &Var::i4(type_id),+                    &Var::i4(open_options),+                    &Var::bstr(&configuration),+                    &Var::byref_i4(&mut errors as *mut i32),+                    &Var::byref_i4(&mut warnings as *mut i32),+                ],+            )?+            .as_dispatch()+            .map(Disp)+            .ok_or_else(|| {+                HostError::msg(format!(+                    "SOLIDWORKS failed to open {path} (errors={errors} warnings={warnings})"+                ))+            })?;+        Ok(json!({+            "opened": Self::doc_info(&doc),+            "readOnly": read_only,+            "errors": errors,+            "warnings": warnings,+        }))+    }++    /// `SaveAs3` — the one call behind both export and save-as.+    ///+    /// TWO facts about it were learned the hard way on a live install, and both+    /// contradicted the port's original reading of the API docs:+    ///+    /// 1. It returns **swFileSaveError_e (a long), not a bool**: `0` means+    ///    SUCCESS. v0.2 read the return as a bool, so every successful export+    ///    reported failure while writing perfectly good bytes to disk.+    /// 2. The options flag matters. `swSaveAsOptions_Silent` (1) alone RENAMES+    ///    the open document to the export path — the user's `bracket.sldprt`+    ///    silently becomes `bracket.step` in memory. Exports therefore pass+    ///    `Silent|Copy` (1|2 = 3), which leaves the open document untouched;+    ///    only a deliberate `save_as` uses plain Silent.+    fn save_as3(doc: &Disp, out: &str, copy: bool) -> Result<i32, HostError> {+        // LAST LINE OF DEFENCE. The server checks this too, but every road to a+        // SaveAs3 — the export verbs, save_as, and the modelling DSL — passes+        // through here, and the DSL road skipped the server's check once+        // already. SaveAs3 reads the format off the extension, so this is the+        // one place that sees what SOLIDWORKS will actually be asked to do.+        if let Some(bad) = crate::verbs3::blocked_by_extension(out) {+            return Err(HostError::msg(format!(+                "refusing to write {out}: .{bad} (VRML) raises a modal option sheet that hangs \+                 SOLIDWORKS until the com-host watchdog kills it, and leaves the dialog on the \+                 user's screen"+            )));+        }+        if let Some(parent) = std::path::Path::new(out).parent() {+            if !parent.as_os_str().is_empty() {+                let _ = std::fs::create_dir_all(parent);+            }+        }+        // swSaveAsOptions_Silent = 1, swSaveAsOptions_Copy = 2+        let options = if copy { 1 | 2 } else { 1 };+        let r = doc.call("SaveAs3", &[&Var::bstr(out), &Var::i4(0), &Var::i4(options)])?;+        // Belt and braces: a build that ever DOES return a bool here still reads+        // correctly (true -> 0 = clean, false -> a generic save error).+        Ok(match r.as_i32() {+            Some(code) => code,+            None => {+                if r.as_bool() == Some(true) {+                    0+                } else {+                    1+                }+            }+        })+    }++    /// swFileSaveError_e, spelled out. Reported verbatim so a caller can act on+    /// the difference between "this format is not available" and "the file is+    /// locked".+    fn save_error_text(code: i32) -> String {+        if code == 0 {+            return "ok".into();+        }+        let bits: &[(i32, &str)] = &[+            (1, "generic save error"),+            (2, "read-only save error"),+            (4, "file name empty"),+            (8, "file name contains an @ sign"),+            (16, "file lock error"),+            (32, "file save format not available"),+            (128, "invalid file extension"),+            (256, "format not supported for this document type"),+            (512, "file save as bad selection"),+            (1024, "file save as bad file name"),+        ];+        let named: Vec<&str> =+            bits.iter().filter(|(b, _)| code & b != 0).map(|(_, t)| *t).collect();+        if named.is_empty() {+            format!("swFileSaveError_e {code}")+        } else {+            format!("{} (swFileSaveError_e {code})", named.join(", "))+        }+    }++    fn cmd_export(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let out = args+            .get("out")+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("out (destination path) is required"))?;+        let title_before = doc.string("GetTitle", &[]);+        let code = Self::save_as3(&doc, out, true)?;+        if code != 0 {+            return Err(HostError::msg(format!(+                "SOLIDWORKS refused to write {out}: {}. Formats verified on this install for a                  PART are STEP/STP, IGES, STL, X_T, X_B, SAT, 3MF, GLB, PLY, AMF, 3DXML, PNG,                  JPG, TIF and PDF; OBJ, DXF, DWG and U3D are refused for a part (DXF/DWG are                  drawing formats). VRML (.wrl) HANGS on a modal option sheet and is blocked by                  this bridge.",+                Self::save_error_text(code)+            )));+        }+        let bytes = std::fs::metadata(out).map(|m| m.len()).ok();+        // Copy mode should leave the document's identity alone; assert it, because+        // silently renaming the user's open document is the worst failure this+        // verb has.+        let title_after = doc.string("GetTitle", &[]);+        let renamed = title_before.is_some() && title_before != title_after;+        Ok(json!({+            "exported": out,+            "bytes": bytes,+            "fileSizeKB": bytes.map(|b| (b as f64 / 1024.0).round() as u64),+            "saveErrorCode": code,+            "documentRenamed": renamed,+            "doc": Self::doc_info(&doc),+        }))+    }++    fn cmd_bom(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        if doc.int("GetType", &[]).unwrap_or(0) != DOC_ASSEMBLY {+            return Err(HostError::msg("BOM needs an assembly (.sldasm) as the target document"));+        }+        let top_only = args.get("topLevelOnly").and_then(|v| v.as_bool()).unwrap_or(false);+        let comps = doc.call("GetComponents", &[&Var::boolean(top_only)])?;++        // Aggregate per (file, configuration): that pair IS the BOM line item.+        let mut keys: Vec<String> = Vec::new();+        let mut rows: Vec<Map<String, Value>> = Vec::new();+        let mut skipped = 0usize;+        for comp in comps.as_array() {+            let comp = match comp.as_dispatch().map(Disp) {+                Some(c) => c,+                None => continue,+            };+            // swComponentSuppressionState_e: 0 = fully suppressed+            if comp.int("GetSuppression", &[]) == Some(0) {+                skipped += 1;+                continue;+            }+            let file = comp.string("GetPathName", &[]).unwrap_or_default();+            let configuration = comp.string("ReferencedConfiguration", &[]).unwrap_or_default();+            let key = format!("{file}|{configuration}");+            if let Some(i) = keys.iter().position(|k| *k == key) {+                let q = rows[i].get("quantity").and_then(|v| v.as_i64()).unwrap_or(0) + 1;+                rows[i].insert("quantity".into(), Value::from(q));+                continue;+            }+            let props = comp+                .obj("GetModelDoc2", &[])+                .ok()+                .flatten()+                .map(|d| Self::custom_props(&d, ""))+                .unwrap_or_else(|| json!({}));+            let mut row = Map::new();+            row.insert("file".into(), Value::from(file.clone()));+            row.insert("name".into(), Value::from(super::mock::file_stem(&file).to_string()));+            row.insert("configuration".into(), Value::from(configuration));+            row.insert("quantity".into(), Value::from(1));+            row.insert("suppressedInstances".into(), Value::from(0));+            row.insert("properties".into(), props);+            keys.push(key);+            rows.push(row);+        }+        if skipped > 0 {+            // One line, after the loop — never one per component.+            super::host::log(&format!("bom: {skipped} suppressed component(s) excluded"));+        }+        let rows: Vec<Value> = rows.into_iter().map(Value::Object).collect();+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "topLevelOnly": top_only,+            "rowCount": rows.len(),+            "rows": rows,+        }))+    }++    fn cmd_interference(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        if doc.int("GetType", &[]).unwrap_or(0) != DOC_ASSEMBLY {+            return Err(HostError::msg("interference detection needs an assembly (.sldasm)"));+        }+        // LIVE FINDING (2026-09-02): `InterferenceDetectionManager` is a member of+        // IAssemblyDoc, NOT of IModelDocExtension. v0.2 looked for it on the+        // Extension and every interference check failed with "unavailable".+        let mgr = doc+            .obj("InterferenceDetectionManager", &[])?+            .ok_or_else(|| HostError::msg(+                "InterferenceDetectionManager unavailable (it is a member of the assembly \+                 document; make sure the target really is an .sldasm)",+            ))?;++        let coincidence =+            args.get("coincidenceCounts").and_then(|v| v.as_bool()).unwrap_or(false);++        // A drop guard, not a bare trailing statement: Done() must run on EVERY+        // exit — an early `?`, AND an unwinding panic. Leaving the interference+        // session open parks SOLIDWORKS in a modal-ish state, so this is exactly+        // the invariant that must survive the unexpected.+        struct DoneGuard(Disp);+        impl Drop for DoneGuard {+            fn drop(&mut self) {+                let _ = self.0.call("Done", &[]);+            }+        }+        let _guard = DoneGuard(mgr.clone());++        // The puts come AFTER the guard is armed. They were before it, so a+        // panic inside one would have leaked the interference session — which is+        // the exact state the guard exists to prevent.+        mgr.try_put("UseTransform", &Var::boolean(true));+        mgr.try_put("TreatCoincidenceAsInterference", &Var::boolean(coincidence));+        mgr.try_put("MakeInterferingPartsTransparent", &Var::boolean(false));++        let found = mgr.call("GetInterferences", &[])?;+        let count = mgr.int("GetInterferenceCount", &[]).unwrap_or(0);+        let mut out = Vec::new();+        for item in found.as_array() {+            let item = match item.as_dispatch().map(Disp) {+                Some(i) => i,+                None => continue,+            };+            let names: Vec<Value> = item+                .call("Components", &[])+                .map(|c| {+                    c.as_array()+                        .iter()+                        .filter_map(|v| v.as_dispatch().map(Disp))+                        .filter_map(|c| c.string("Name2", &[]))+                        .map(Value::from)+                        .collect()+                })+                .unwrap_or_default();+            out.push(json!({"components": names, "volumeM3": item.float("Volume", &[])}));+        }+        Ok(json!({"doc": Self::doc_info(&doc), "count": count, "interferences": out}))+    }++    fn cmd_rebuild_check(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        // Top-level rebuild, not just the active configuration.+        let rebuilt = doc.call("ForceRebuild3", &[&Var::boolean(false)])?.as_bool().unwrap_or(false);+        let mut bad = Vec::new();+        let mut unreadable = 0usize;+        let mut feature = doc.obj("FirstFeature", &[]).ok().flatten();+        // A feature tree is finite, but a broken GetNextFeature must not spin+        // this process forever.+        let mut guard = 0;+        while let Some(f) = feature {+            guard += 1;+            if guard > 20_000 {+                super::host::log("rebuild_check: feature walk hit the 20000 guard");+                break;+            }+            // LIVE FINDING (2026-09-02): `GetErrorCode2` is present on the+            // dispatch interface but rejects every arity we can express+            // late-bound (it wants a single BYREF BSTR out-param), so v0.2's+            // two-argument call failed for EVERY feature — which made a clean,+            // empty document report 16 "unreadable" errors. The plain+            // `GetErrorCode()` takes no arguments and answers correctly.+            match f.call("GetErrorCode", &[]) {+                Ok(code) => {+                    if code.as_i32().unwrap_or(0) != 0 {+                        bad.push(json!({+                            "feature": f.string("Name", &[]),+                            "type": f.string("GetTypeName2", &[]),+                            "code": code.as_i32(),+                            "status": Value::Null,+                        }));+                    }+                }+                Err(_) => {+                    unreadable += 1;+                    bad.push(json!({+                        "feature": f.string("Name", &[]),+                        "type": f.string("GetTypeName2", &[]),+                        "code": Value::Null,+                        "status": "error code could not be read",+                    }));+                }+            }+            feature = f.obj("GetNextFeature", &[]).ok().flatten();+        }+        // The app's own "what's wrong" census, as a cross-check on the walk.+        let whats_wrong = doc+            .obj("Extension", &[])+            .ok()+            .flatten()+            .and_then(|e| e.int("GetWhatsWrongCount", &[]));+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "rebuilt": rebuilt,+            "featureErrors": bad,+            "errorCount": bad.len(),+            "unreadableFeatures": unreadable,+            "whatsWrongCount": whats_wrong,+            "featuresWalked": guard,+        }))+    }++    fn cmd_pack_and_go(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let dest = args+            .get("out")+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("out (destination directory) is required"))?;+        // AFTER authorization, never before: creating the directory first left+        // one on the user's disk even when the write was refused.+        std::fs::create_dir_all(dest)+            .map_err(|e| HostError::msg(format!("cannot create {dest}: {e}")))?;+        let ext = doc.obj("Extension", &[])?.ok_or_else(|| HostError::msg("no ModelDocExtension"))?;+        let png = ext+            .obj("GetPackAndGo", &[])?+            .ok_or_else(|| HostError::msg("GetPackAndGo returned nothing"))?;+        png.try_put(+            "IncludeDrawings",+            &Var::boolean(args.get("includeDrawings").and_then(|v| v.as_bool()).unwrap_or(false)),+        );+        png.call("SetSaveToName", &[&Var::boolean(true), &Var::bstr(dest)])?;++        let mut files_v = VARIANT::default();+        let mut flags_v = VARIANT::default();+        let _ = png.call(+            "GetDocumentSaveToNames",+            &[+                &Var::byref_variant(&mut files_v as *mut VARIANT),+                &Var::byref_variant(&mut flags_v as *mut VARIANT),+            ],+        );+        let files: Vec<Value> =+            Var(files_v).as_array().iter().map(|v| v.to_json()).collect();+        let statuses: Vec<Value> =+            ext.call("SavePackAndGo", &[&Var::dispatch(&png.0)])?.as_array().iter().map(|v| v.to_json()).collect();+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "out": dest,+            "files": files,+            "statuses": statuses,+        }))+    }++    fn cmd_mass_properties(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let ext = doc.obj("Extension", &[])?.ok_or_else(|| HostError::msg("no ModelDocExtension"))?;+        let mp = ext.obj("CreateMassProperty", &[])?.ok_or_else(|| {+            HostError::msg("CreateMassProperty returned nothing (drawings have no mass properties)")+        })?;+        if let Some(system_units) = args.get("useSystemUnits").and_then(|v| v.as_bool()) {+            mp.try_put("UseSystemUnits", &Var::boolean(system_units));+        }+        let center: Vec<Value> =+            mp.call("CenterOfMass", &[]).map(|v| v.as_array().iter().map(|e| e.to_json()).collect())+                .unwrap_or_default();+        // Parts only; assemblies throw — best-effort, never fatal.+        let bbox: Value = doc+            .call("GetPartBox", &[&Var::boolean(true)])+            .map(|v| Value::Array(v.as_array().iter().map(|e| e.to_json()).collect()))+            .unwrap_or(Value::Null);+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "massKg": mp.float("Mass", &[]),+            "volumeM3": mp.float("Volume", &[]),+            "surfaceAreaM2": mp.float("SurfaceArea", &[]),+            "density": mp.float("Density", &[]),+            "centerOfMass": center,+            "boundingBox": bbox,+        }))+    }++    /// The escape hatch: a dotted call chain rooted at `$sw` or `$doc`.+    ///+    /// NOT an arbitrary script host — there is no PowerShell in this bridge any+    /// more, and there is no eval in Rust. What it supports is exactly what+    /// prototyping a new verb needs: `$sw.Member.Member(args...)` with string,+    /// number and boolean literals.+    fn cmd_eval(&mut self, args: &Value) -> Result<Value, HostError> {+        let expr = args.get("expr").and_then(|v| v.as_str()).unwrap_or("").trim().to_string();+        let (root_name, segments) = parse_chain(&expr)?;+        let mut current = match root_name.as_str() {+            "sw" => self.app(false, true)?,+            "doc" => self.resolve(&json!({}))?,+            other => {+                return Err(HostError::msg(format!(+                    "unknown root '${other}' — use $sw (the application) or $doc (the active document)"+                )))+            }+        };+        let mut last: Option<Var> = None;+        for (i, seg) in segments.iter().enumerate() {+            let owned: Vec<Var> = seg.args.iter().map(literal_var).collect();+            let refs: Vec<&Var> = owned.iter().collect();+            let value = current.call(&seg.name, &refs)?;+            if i + 1 < segments.len() {+                current = value.as_dispatch().map(Disp).ok_or_else(|| {+                    HostError::msg(format!(+                        "'{}' did not return an object, so '.{}' has nothing to run on",+                        seg.name,+                        segments[i + 1].name+                    ))+                })?;+            } else {+                last = Some(value);+            }+        }+        let value = last.unwrap_or_else(Var::empty);+        Ok(json!({+            "result": value.as_string().unwrap_or_default(),+            "value": value.to_json(),+            "expr": expr,+            "supports": "$sw / $doc rooted call chains with string, number and boolean literals",+        }))+    }+}++/// A parsed literal as a COM argument.+fn literal_var(l: &Literal) -> Var {+    match l {+        Literal::Str(s) => Var::bstr(s),+        Literal::Int(i) => Var::i4(*i),+        Literal::Num(f) => Var::r8(*f),+        Literal::Bool(b) => Var::boolean(*b),+        // VT_EMPTY is how "argument omitted" reaches a late-bound optional+        // [in] object parameter — SelectByID2's callout, LoadFile4's import data.+        Literal::Null => Var::empty(),+    }+}++impl ComBackend {+    /// Remember a document THIS HOST created, and persist it.+    fn remember_created(&mut self, doc: &Disp) {+        let title = doc.string("GetTitle", &[]).unwrap_or_default();+        let path = doc.string("GetPathName", &[]).filter(|s| !s.is_empty());+        self.remember_created_parts(title, path);+    }++    /// The same, from the `{title, path}` a result carries — the form the+    /// dispatch loop can apply to any command without knowing what it does.+    fn remember_created_parts(&mut self, title: String, path: Option<String>) {+        if title.is_empty() {+            return;+        }+        // A record from a previous SOLIDWORKS session is discarded the moment we+        // learn the current one, rather than being inherited.+        let session = self.current_session();+        if self.created_session != session {+            self.created.clear();+            self.created_session = session;+        }+        // Evict by IDENTITY, not by title. Keying this on the title meant an+        // imported document displaced the record of a SAVED one that happened to+        // share its name — which is exactly what `swx_import` of a STEP beside+        // the suite's own part produced — and the bridge then disowned the+        // document it had created.+        match &path {+            Some(p) => self.created.retain(|(t, cp)| {+                !cp.as_deref().map(|q| crate::verbs::same_path(q, p)).unwrap_or(false)+                    && !(cp.is_none() && *t == title)+            }),+            None => self.created.retain(|(t, cp)| !(cp.is_none() && *t == title)),+        }+        self.created.push((title, path));+        crate::comhost::created_store::save_session(self.created_session, &self.created);+    }++    /// SOLIDWORKS' own process id, or None when it cannot be asked.+    fn current_session(&self) -> Option<i64> {+        self.sw.as_ref().and_then(|sw| sw.int("GetProcessID", &[])).map(i64::from)+    }++    /// Does this host believe it created `doc`? Path where there is one, title+    /// otherwise — the same identity rule the server uses, reached independently.+    fn host_owns(&self, doc: &Disp) -> bool {+        // FAIL CLOSED across sessions: a stored record whose session does not+        // match the running SOLIDWORKS (a crash, a kill, the user quitting) is+        // not evidence of anything.+        let now = self.current_session();+        if now.is_none() || now != self.created_session {+            return false;+        }+        let title = doc.string("GetTitle", &[]).unwrap_or_default();+        let path = doc.string("GetPathName", &[]).filter(|s| !s.is_empty());+        match &path {+            Some(p) => self+                .created+                .iter()+                .any(|(_, cp)| cp.as_deref().map(|q| crate::verbs::same_path(q, p)).unwrap_or(false)),+            None => self.created.iter().any(|(t, cp)| cp.is_none() && *t == title),+        }+    }++    /// Which document a mutating command is aimed at, resolved the way the+    /// command itself will resolve it.+    fn authorize_target(&mut self, cmd: &str, args: &Value) -> Option<Disp> {+        // `run_script` names its document with `targetDocument`; everything else+        // uses the docName/path/name keys `resolve` already understands.+        if cmd == "run_script" {+            if let Some(t) = args.get("targetDocument").and_then(|v| v.as_str()).filter(|s| !s.is_empty()) {+                return self.resolve(&json!({"docName": t})).ok();+            }+            // A script that starts by creating its own document touches nothing+            // that exists yet.+            if let Ok(ops) = crate::script::parse(&args.get("script").cloned().unwrap_or(Value::Null)) {+                if matches!(ops.first(), Some(crate::script::Op::NewPart | crate::script::Op::NewAssembly)) {+                    return None;+                }+            }+        }+        self.resolve(args).ok()+    }++    /// THE HOST'S OWN VETO. Called before every mutating COM call.+    ///+    /// It re-decides the same two questions the server did — is the document+    /// ours, and does the destination already exist — from its OWN records and+    /// its OWN view of the filesystem, and it reads the process-level opt-in+    /// from the ENVIRONMENT it inherited rather than from anything the server+    /// sent. So the server cannot fabricate the escape: `allowUserWrites` in+    /// the request is necessary but never sufficient.+    /// Run a `.lnk` through the shell, detached.+    ///+    /// `raw_arg` rather than `arg`: `cmd.exe` does its own command-line parsing,+    /// and Rust's argument escaper is written for the CRT convention, so a path+    /// with a space in it (which every one of these has) arrives at `start`+    /// mis-split. DETACHED_PROCESS | CREATE_NO_WINDOW so no console flashes on+    /// the user's desktop — this bridge never puts a window on screen.+    #[cfg(windows)]+    fn spawn_shortcut(shortcut: &str) -> Result<(), HostError> {+        use std::os::windows::process::CommandExt;+        const DETACHED_PROCESS: u32 = 0x0000_0008;+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;+        if shortcut.contains('"') {+            return Err(HostError::coded(+                "host_app_launch_blocked",+                "the shortcut path contains a quote character and will not be run",+            ));+        }+        std::process::Command::new("cmd.exe")+            .raw_arg(format!("/c start \"\" \"{shortcut}\""))+            .creation_flags(DETACHED_PROCESS | CREATE_NO_WINDOW)+            .spawn()+            .map(|_| ())+            .map_err(|e| {+                HostError::coded(+                    "host_app_launch_blocked",+                    format!("could not invoke the shortcut: {e}"),+                )+            })+    }++    fn authorize(+        &self,+        args: &Value,+        what: &str,+        doc: Option<&Disp>,+        destination: Option<&str>,+    ) -> Result<(), HostError> {+        self.authorize_inner(args, what, doc, destination, false)+    }++    /// `always` forces the check even with no document and no destination — for+    /// the commands whose harm IS the state change (quitting, closing everything).+    fn authorize_inner(+        &self,+        args: &Value,+        what: &str,+        doc: Option<&Disp>,+        destination: Option<&str>,+        always: bool,+    ) -> Result<(), HostError> {+        let clobbers = destination+            .map(|d| !d.is_empty() && std::path::Path::new(d).exists())+            .unwrap_or(false);+        let foreign = doc.map(|d| !self.host_owns(d)).unwrap_or(false);+        if !clobbers && !foreign && !always {+            return Ok(());+        }+        // THE FULL OPT-IN CHAIN, re-checked here from the SAME function the+        // server uses — env, plus allowUserWrites AND confirm AND a reason.+        //+        // This used to test `allowUserWrites` alone, which had two consequences,+        // both live-proven on 2026-09-03. It made the host's veto a WEAKER test+        // than the server's, so "two independent vetoes" was not true in the+        // direction that mattered; and because a `Grant` only carried that one+        // boolean, a verb that authorized a CLOSE and then sent the host a+        // payload without it was refused by the host even though the human had+        // authorized it in full. An escape hatch nobody can open is not a safety+        // property, it is a bug — Drew authorized closing his own documents and+        // the bridge told him no.+        let env_on = crate::writes::user_writes_enabled();+        let missing = crate::writes::missing_opt_in(args);+        if env_on && missing.is_empty() {+            return Ok(());+        }+        Err(HostError::detailed(+            format!(+                "the com host refuses to {what}: {}{}",+                if foreign { "this document was not created by this bridge" } else { "" },+                if clobbers {+                    format!(+                        "{}the destination already exists ({})",+                        if foreign { ", and " } else { "" },+                        destination.unwrap_or("")+                    )+                } else {+                    String::new()+                }+            ),+            format!(+                "This is the com host's OWN check, not the server's — it keeps its own record of \+                 the documents it created and reads {} from the environment it was started with. \+                 A server-side decision alone is a claim; two independent vetoes is the \+                 guarantee — and the host applies the IDENTICAL test, so what the user \+                 authorizes in full the host allows in full. envOptIn={env_on} missing=[{}]",+                crate::writes::ENV_ALLOW,+                missing.join(", ")+            ),+        ))+    }+}++impl Backend for ComBackend {+    fn commands(&self) -> &'static [&'static str] {+        COMMANDS+    }++    fn register_created(&mut self, doc: &Value) {+        let title = doc.get("title").and_then(|t| t.as_str()).unwrap_or("").to_string();+        let path = doc+            .get("path")+            .and_then(|p| p.as_str())+            .filter(|s| !s.is_empty())+            .map(String::from);+        self.remember_created_parts(title, path);+    }++    fn authorize_command(&mut self, cmd: &str, args: &Value) -> Result<(), HostError> {+        // `eval` can reach ANY COM member, so the read allowlist is re-checked+        // HERE as well as on the server. It was server-only, which made the one+        // verb that can call anything the one with no host-side guard.+        if cmd == "eval" {+            let expr = args.get("expr").and_then(|v| v.as_str()).unwrap_or("");+            if let Some((member, why)) = super::expr::refused_member(expr) {+                return Err(HostError::detailed(+                    format!("the com host refuses to evaluate '{member}': {why}"),+                    "This is the host's own re-check of the read allowlist, not the server's. \+                     swx_com_eval evaluates reads only."+                        .to_string(),+                ));+            }+            return Ok(());+        }+        // Quitting, and closing everything, are harmful BY THEMSELVES — there is+        // no document to be foreign and no destination to clobber, so they are+        // gated unconditionally.+        if matches!(cmd, "stop" | "close_all_documents") {+            return self.authorize_inner(args, "quit or close the user's SOLIDWORKS session", None, None, true);+        }+        // An EXPORT (and a save_as in Copy mode) writes a NEW file and leaves+        // the document alone, so reading the user's part to produce one is not a+        // write to their data — only the destination has to be clear. Applying+        // the ownership rule here as well would refuse the single most useful+        // thing this bridge does.+        let copy_only = cmd == "export"+            || (cmd == "save_as" && args.get("copy").and_then(|v| v.as_bool()).unwrap_or(false));+        // `open` names a file that is not open yet, so there is no Disp to+        // resolve — ownership is decided on the PATH against the host's own+        // record, the same identity rule everywhere else uses.+        if cmd == "open" {+            let path = args.get("path").and_then(|v| v.as_str()).unwrap_or("");+            let ours = self+                .created+                .iter()+                .any(|(_, p)| p.as_deref().map(|q| crate::verbs::same_path(q, path)).unwrap_or(false));+            if !ours {+                return self.authorize_inner(args, "open this document FOR WRITING", None, None, true);+            }+            return Ok(());+        }+        let doc: Option<Disp> = if copy_only { None } else { self.authorize_target(cmd, args) };+        let destination = args+            .get("out")+            .or_else(|| args.get("outputPath"))+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty());+        self.authorize(args, cmd, doc.as_ref(), destination)+    }++    fn call(&mut self, cmd: &str, args: &Value) -> Result<Value, HostError> {+        match cmd {+            "ping" => Ok(json!({"pong": true, "pid": std::process::id()})),++            "status" => self.cmd_status(),++            "start" => {+                let visible = args.get("visible").and_then(|v| v.as_bool()).unwrap_or(true);+                // `launch` is decided by the SERVER, which knows the edition. See+                // `app()` and the swx_start handler: SOLIDWORKS Connected cannot+                // be launched programmatically at all.+                let launch = args.get("launch").and_then(|v| v.as_bool()).unwrap_or(false);+                let sw = self.app(launch, visible)?;+                Ok(json!({+                    "started": true,+                    "version": sw.string("RevisionNumber", &[]),+                    "wasLaunched": self.was_launched,+                    "mainHwnd": Self::main_hwnd(&sw),+                    "processId": sw.int("GetProcessID", &[]),+                }))+            }++            // THE SANCTIONED LAUNCH for SOLIDWORKS Connected.+            //+            // Invoke the shortcut the 3DEXPERIENCE Platform installed, which+            // runs CATSTART.exe -> SWXDesktopLauncher.exe with the tenant and+            // registry arguments baked into it. We do NOT assemble that command+            // line ourselves: the tenant is the user's, and a hand-built+            // launcher invocation would be a guess. `cmd /c start` is used+            // rather than CreateProcess because a `.lnk` is a shell artefact —+            // only the shell resolves it.+            //+            // Fire and forget, then a SHORT attach poll. A Connected cold start+            // runs one to three minutes and the com host must not be held for+            // that long: it is the only channel the server has, so blocking it+            // would freeze swx_progress and every other verb. The server polls+            // instead, and this call answers with what is true right now.+            "launch_shortcut" => {+                let shortcut = args.get("shortcut").and_then(|v| v.as_str()).unwrap_or("");+                if shortcut.is_empty() {+                    return Err(HostError::coded(+                        "host_app_launch_blocked",+                        "no shortcut was given to invoke",+                    ));+                }+                // Already up: invoking the shortcut again would raise a second+                // window (or the Platform's "already running" notice) on the+                // user's screen for no reason.+                if let Ok(sw) = self.app(false, true) {+                    return Ok(json!({+                        "invoked": false,+                        "attached": true,+                        "alreadyRunning": true,+                        "version": sw.string("RevisionNumber", &[]),+                    }));+                }+                Self::spawn_shortcut(shortcut)?;+                // One brief look, so a warm start reports attached immediately+                // instead of making the caller poll for something already true.+                let attached = self.app(false, true).is_ok();+                Ok(json!({+                    "invoked": true,+                    "attached": attached,+                    "shortcut": shortcut,+                    "version": if attached {+                        self.app(false, true).ok().and_then(|sw| sw.string("RevisionNumber", &[])).map(Value::from).unwrap_or(Value::Null)+                    } else {+                        Value::Null+                    },+                }))+            }++            "stop" => {+                let sw = match self.app(false, true) {+                    Ok(sw) => sw,+                    Err(_) => return Ok(json!({"stopped": false, "reason": "not running"})),+                };+                // ExitApp tears down the very COM server we are calling it on, so+                // the outgoing call often comes back as an RPC disconnect+                // (RPC_E_SERVER_DIED / "server is not available"). That IS the+                // success case — the app quit — so it must not be reported as a+                // failure. A genuinely different error still surfaces.+                let mut disconnect: Option<String> = None;+                if let Err(e) = sw.call("ExitApp", &[]) {+                    let d = e.detail.as_deref().unwrap_or("");+                    // ONLY the specific HRESULTs that mean "the object we were+                    // calling has gone away". The first version also matched any+                    // message containing "server" or "rpc", which would report+                    // stopped:true for a completely unrelated failure with+                    // SOLIDWORKS still on screen — a lie the caller then acts on.+                    let disconnected = [+                        "0x800706BA", // RPC_S_SERVER_UNAVAILABLE+                        "0x80010108", // RPC_E_DISCONNECTED+                        "0x800706BE", // RPC_S_CALL_FAILED+                        "0x800706BF", // RPC_S_CALL_FAILED_DNE+                        "0x80010012", // CO_E_OBJNOTCONNECTED+                        "0x80010105", // RPC_E_SERVERFAULT+                    ]+                    .iter()+                    .any(|code| d.contains(code));+                    if !disconnected {+                        return Err(e);+                    }+                    disconnect = Some(d.to_string());+                }+                self.sw = None;+                self.was_launched = false;+                // The session is over: SOLIDWORKS restarts its Part numbering, so+                // no remembered title can be trusted into the next one.+                self.created.clear();+                crate::comhost::created_store::clear();+                // VERIFY. ExitApp returning cleanly is not proof the application+                // quit; a re-attach that still succeeds means it did not.+                let still_up = Self::clsid()+                    .ok()+                    .map(|clsid| unsafe {+                        let mut unk = None;+                        GetActiveObject(&clsid, None, &mut unk).is_ok() && unk.is_some()+                    })+                    .unwrap_or(false);+                Ok(json!({+                    "stopped": !still_up,+                    "stillRunning": still_up,+                    "rpcDisconnect": disconnect,+                }))+            }++            "docs" => {+                let sw = self.app(false, true)?;+                let docs: Vec<Value> =+                    Self::documents(&sw)?.iter().map(Self::doc_info).collect();+                let active =+                    sw.obj("ActiveDoc", &[])?.map(|d| Self::doc_info(&d)).unwrap_or(Value::Null);+                Ok(json!({"docs": docs, "active": active}))+            }++            "open" => self.cmd_open(args),++            "close_doc" => {+                let sw = self.app(false, true)?;+                let doc = self.resolve(args)?;+                let title = doc.string("GetTitle", &[]).unwrap_or_default();+                if args.get("save").and_then(|v| v.as_bool()).unwrap_or(false) {+                    // close_doc{save:true} is a WRITE, and it is the same Save3+                    // the gated `save` command makes.+                    let (mut e, mut w) = (0i32, 0i32);+                    doc.call(+                        "Save3",+                        &[+                            &Var::i4(1),+                            &Var::byref_i4(&mut e as *mut i32),+                            &Var::byref_i4(&mut w as *mut i32),+                        ],+                    )?;+                }+                sw.call("CloseDoc", &[&Var::bstr(&title)])?;+                // A closed document is no longer ours: the server prunes its+                // registry the same way, and the two vetoes must not disagree+                // about who owns what.+                self.created.retain(|(t, _)| *t != title);+                crate::comhost::created_store::save_session(self.created_session, &self.created);+                Ok(json!({"closed": title}))+            }++            "save" => {+                let doc = self.resolve(args)?;+                let (mut errors, mut warnings) = (0i32, 0i32);+                // swSaveAsOptions_Silent = 1+                let saved = doc+                    .call(+                        "Save3",+                        &[+                            &Var::i4(1),+                            &Var::byref_i4(&mut errors as *mut i32),+                            &Var::byref_i4(&mut warnings as *mut i32),+                        ],+                    )?+                    .as_bool()+                    .unwrap_or(false);+                Ok(json!({+                    "saved": saved,+                    "errors": errors,+                    "warnings": warnings,+                    "doc": Self::doc_info(&doc),+                }))+            }++            "export" => self.cmd_export(args),++            "props_get" => {+                let doc = self.resolve(args)?;+                let configuration =+                    args.get("configuration").and_then(|v| v.as_str()).unwrap_or("");+                let configurations: Vec<Value> = doc+                    .call("GetConfigurationNames", &[])+                    .map(|v| v.as_array().iter().map(|e| e.to_json()).collect())+                    .unwrap_or_default();+                Ok(json!({+                    "doc": Self::doc_info(&doc),+                    "configuration": configuration,+                    "properties": Self::custom_props(&doc, configuration),+                    "configurations": configurations,+                }))+            }++            "props_set" => {+                let doc = self.resolve(args)?;+                let configuration =+                    args.get("configuration").and_then(|v| v.as_str()).unwrap_or("");+                let mgr = doc+                    .obj("Extension", &[])?+                    .and_then(|e| e.obj("CustomPropertyManager", &[&Var::bstr(configuration)]).ok().flatten())+                    .ok_or_else(|| HostError::msg("CustomPropertyManager unavailable"))?;+                let mut set = Map::new();+                let props = args.get("properties").and_then(|p| p.as_object()).cloned().unwrap_or_default();+                for (name, value) in props {+                    let text = match &value {+                        Value::String(s) => s.clone(),+                        other => other.to_string(),+                    };+                    // swCustomInfoText = 30; swCustomPropertyReplaceValue = 2+                    let r = mgr.call(+                        "Add3",+                        &[&Var::bstr(&name), &Var::i4(30), &Var::bstr(&text), &Var::i4(2)],+                    )?;+                    set.insert(name, r.as_i32().map(Value::from).unwrap_or(Value::Null));+                }+                Ok(json!({"doc": Self::doc_info(&doc), "set": Value::Object(set)}))+            }++            "mass_properties" => self.cmd_mass_properties(args),+            "bom" => self.cmd_bom(args),+            "interference" => self.cmd_interference(args),+            "rebuild_check" => self.cmd_rebuild_check(args),+            "pack_and_go" => self.cmd_pack_and_go(args),+            "eval" => self.cmd_eval(args),++            // v0.3+            "new_document" => self.cmd_new_document(args),+            "activate_document" => self.cmd_activate_document(args),+            "close_all_documents" => self.cmd_close_all_documents(args),+            "document_info" => self.cmd_document_info(args),+            "design_info" => self.cmd_design_info(args),+            "get_parameters" => self.cmd_get_parameters(args),+            "set_parameter" => self.cmd_set_parameter(args),+            "inspect_bodies" => self.cmd_inspect_bodies(args),+            "import" => self.cmd_import(args),+            "save_as" => self.cmd_save_as(args),+            "run_script" => self.cmd_run_script(args),+            "add_component" => self.cmd_add_component(args),+            "run_macro" => self.cmd_run_macro(args),+            "get_preferences" => self.cmd_get_preferences(args),+            "set_preference" => self.cmd_set_preference(args),+            "show" => self.cmd_show(args),+            "check_recovery" => self.cmd_check_recovery(),+            "app_state" => self.cmd_app_state(),+            "cloud_status" => self.cmd_cloud_status(),++            other => Err(HostError::msg(format!("unknown command: {other}"))),+        }+    }+}++// ── v0.3: the Fusion-parity surface ─────────────────────────────────────────+//+// Every call below was probed against a LIVE SOLIDWORKS Design Professional for+// Makers 2026 (3DEXPERIENCE R2026x, sldworks.exe 34.3.0) before it was written.+// Where a signature could NOT be proven live, the comment says so — that+// distinction is the whole point of the exercise, and it is reproduced verbatim+// in docs/FUSION-PARITY-REPORT.md.++impl ComBackend {+    /// The stock template for a document type. `GetDocumentTemplate` is the+    /// reliable route (proven live for all three types); the+    /// `GetUserPreferenceStringValue` defaults are the fallback.+    fn template_for(sw: &Disp, type_id: i32) -> Option<String> {+        let via_template = sw+            .call(+                "GetDocumentTemplate",+                &[&Var::i4(type_id), &Var::bstr(""), &Var::i4(0), &Var::r8(0.0), &Var::r8(0.0)],+            )+            .ok()+            .and_then(|v| v.as_string())+            .filter(|s| !s.is_empty());+        if via_template.is_some() {+            return via_template;+        }+        // swDefaultPartTemplate = 8, swDefaultAssemblyTemplate = 9,+        // swDefaultDrawingTemplate = 10 (all three verified live).+        let pref = match type_id {+            DOC_PART => 8,+            DOC_ASSEMBLY => 9,+            _ => 10,+        };+        sw.call("GetUserPreferenceStringValue", &[&Var::i4(pref)])+            .ok()+            .and_then(|v| v.as_string())+            .filter(|s| !s.is_empty())+    }++    fn type_id_from_name(name: &str) -> Result<i32, HostError> {+        match name.trim().to_lowercase().as_str() {+            "part" | "prt" | "sldprt" => Ok(DOC_PART),+            "assembly" | "asm" | "sldasm" => Ok(DOC_ASSEMBLY),+            "drawing" | "drw" | "slddrw" => Ok(DOC_DRAWING),+            other => Err(HostError::msg(format!(+                "unknown document type '{other}' — use part, assembly or drawing"+            ))),+        }+    }++    /// `swx_new_document`. LIVE-PROVEN recipe.+    ///+    /// `ISldWorks::NewPart()` HANGS on this install (>110s, killed by the+    /// watchdog), which is why this goes through `NewDocument(template,0,0,0)`+    /// with a template resolved at runtime instead of the convenience wrapper.+    fn cmd_new_document(&mut self, args: &Value) -> Result<Value, HostError> {+        let kind = args.get("type").and_then(|v| v.as_str()).unwrap_or("part");+        let type_id = Self::type_id_from_name(kind)?;+        let sw = self.app(false, true)?;+        let template = match args.get("template").and_then(|v| v.as_str()).filter(|s| !s.is_empty())+        {+            Some(t) => t.to_string(),+            None => Self::template_for(&sw, type_id).ok_or_else(|| {+                HostError::msg(format!(+                    "no {kind} template is configured in SOLIDWORKS (Tools > Options > File \+                     Locations > Document Templates) — pass `template` with an explicit \+                     .prtdot/.asmdot/.drwdot path"+                ))+            })?,+        };+        if !std::path::Path::new(&template).exists() {+            return Err(HostError::msg(format!("template not found on disk: {template}")));+        }+        let doc = sw+            .call(+                "NewDocument",+                &[&Var::bstr(&template), &Var::i4(0), &Var::r8(0.0), &Var::r8(0.0)],+            )?+            .as_dispatch()+            .map(Disp)+            .ok_or_else(|| {+                HostError::msg(format!(+                    "SOLIDWORKS created no document from {template} (is the template valid?)"+                ))+            })?;+        Ok(json!({"created": Self::doc_info(&doc), "template": template, "type": kind}))+    }++    /// `swx_activate_document`. Not provable live in this session (SOLIDWORKS+    /// Connected was down when this was written); the byref out-param is+    /// marshalled explicitly, and a failure is reported with what SOLIDWORKS+    /// said.+    fn cmd_activate_document(&mut self, args: &Value) -> Result<Value, HostError> {+        let name = args+            .get("name")+            .or_else(|| args.get("path"))+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("name (the document title, as swx_docs reports it) is required"))?;+        let sw = self.app(false, true)?;+        let mut errors = 0i32;+        // ActivateDoc3(Name, UseUserPreferences, Option, byref Errors).+        // swRebuildOnActivation_e: 0 = swDontRebuildActiveDoc.+        let doc = sw+            .call(+                "ActivateDoc3",+                &[+                    &Var::bstr(name),+                    &Var::boolean(false),+                    &Var::i4(0),+                    &Var::byref_i4(&mut errors as *mut i32),+                ],+            )?+            .as_dispatch()+            .map(Disp)+            .ok_or_else(|| {+                HostError::msg(format!(+                    "SOLIDWORKS could not activate '{name}' (errors={errors}) — swx_docs lists \+                     the titles that are actually open"+                ))+            })?;+        Ok(json!({"activeDocument": Self::doc_info(&doc), "errors": errors}))+    }++    /// Enumerate the open documents, and NEVER return an empty list the+    /// application itself contradicts.+    ///+    /// `GetDocuments` on a busy SOLIDWORKS hands back a null/empty VARIANT+    /// rather than an error, and `as_array()` turns that into an empty Vec. So+    /// `swx_docs` answered `success:true` with ZERO documents while 51 were+    /// open — twice, three minutes apart, with `GetDocumentCount` and+    /// `swx_state` both still saying 51. Everything downstream then drew a+    /// confident wrong conclusion from it: resolve-by-title said "no open+    /// document is titled 'Assem24'" and the ownership gate said "this bridge+    /// did not create it", for an assembly created seconds earlier.+    ///+    /// An empty list is only believed when the count agrees it is empty.+    fn documents(sw: &Disp) -> Result<Vec<Disp>, HostError> {+        let mut count = -1i32;+        for attempt in 0..4u64 {+            let docs: Vec<Disp> = sw+                .call("GetDocuments", &[])?+                .as_array()+                .iter()+                .filter_map(|v| v.as_dispatch().map(Disp))+                .collect();+            count = sw.int("GetDocumentCount", &[]).unwrap_or(-1);+            if !docs.is_empty() || count <= 0 {+                return Ok(docs);+            }+            std::thread::sleep(std::time::Duration::from_millis(150 * (attempt + 1)));+        }+        Err(HostError::coded(+            "docs_enumeration_failed",+            format!(+                "SOLIDWORKS reports {count} open document(s) but returned none — the enumeration \+                 failed, most likely because it was busy. NOTHING was concluded from this read; \+                 retry the call."+            ),+        ))+    }++    /// `swx_close_all_documents`. DESTRUCTIVE, so the server gates it; here we+    /// only report what was open before and what survived.+    fn cmd_close_all_documents(&mut self, args: &Value) -> Result<Value, HostError> {+        let sw = self.app(false, true)?;+        let before: Vec<Value> = sw+            .call("GetDocuments", &[])?+            .as_array()+            .iter()+            .filter_map(|v| v.as_dispatch().map(Disp))+            .map(|d| Self::doc_info(&d))+            .collect();+        let include_unsaved =+            args.get("closeUnsaved").and_then(|v| v.as_bool()).unwrap_or(false);+        let would_prompt: Vec<Value> = before+            .iter()+            .filter(|d| d.get("dirty").and_then(|x| x.as_bool()).unwrap_or(false))+            .cloned()+            .collect();+        let ok = sw+            .call("CloseAllDocuments", &[&Var::boolean(include_unsaved)])?+            .as_bool()+            .unwrap_or(false);+        let remaining: Vec<Value> = sw+            .call("GetDocuments", &[])?+            .as_array()+            .iter()+            .filter_map(|v| v.as_dispatch().map(Disp))+            .map(|d| Self::doc_info(&d))+            .collect();+        Ok(json!({+            "closedAll": ok,+            "closed": before,+            "remaining": remaining,+            "wouldPrompt": would_prompt,+            "closeUnsaved": include_unsaved,+        }))+    }++    /// `ISldWorks::RunMacro2(path, module, proc, options, [out] error) -> bool`+    ///+    /// SCAFFOLDING — written from the documented signature, NOT yet run against+    /// a live SOLIDWORKS. Everything else in this file carries a note saying+    /// whether it was proven live, and this one has not been, so it says so.+    ///+    /// Two details that are easy to get wrong and expensive to debug:+    ///   * the error is an OUT parameter (`swRunMacroError_e`), not the return+    ///     value — the return is a plain bool, and a macro that fails to compile+    ///     comes back `false` with the reason only in the out param;+    ///   * `swRunMacroUnloadAfterRun = 1` is passed deliberately. Without it the+    ///     VBA project stays loaded and an edited macro keeps running its OLD+    ///     code, which looks exactly like the edit not having been saved.+    fn cmd_run_macro(&mut self, args: &Value) -> Result<Value, HostError> {+        let sw = self.app(false, true)?;+        let path = args.get("path").and_then(|v| v.as_str()).unwrap_or("");+        let module = args.get("module").and_then(|v| v.as_str()).unwrap_or("main");+        let procedure = args.get("procedure").and_then(|v| v.as_str()).unwrap_or("main");+        // swRunMacroOption_e: swRunMacroUnloadAfterRun = 1+        let mut run_error: i32 = 0;+        let r = sw.call(+            "RunMacro2",+            &[+                &Var::bstr(path),+                &Var::bstr(module),+                &Var::bstr(procedure),+                &Var::i4(1),+                &Var::byref_i4(&mut run_error as *mut i32),+            ],+        )?;+        let ok = r.as_bool().unwrap_or(run_error == 0);+        Ok(json!({+            "ran": ok,+            "path": path,+            "module": module,+            "procedure": procedure,+            "runError": run_error,+            "runErrorText": Self::macro_error_text(run_error),+            "unloadedAfterRun": true,+            "provenLive": false,+        }))+    }++    /// `swRunMacroError_e`, spelled out — the difference between "no such file"+    /// and "your VBA does not compile" is the whole content of a failed run.+    fn macro_error_text(code: i32) -> &'static str {+        match code {+            0 => "ok",+            1 => "the macro or its module/procedure could not be found",+            2 => "the macro could not be opened (missing file, or not a macro)",+            4 => "the macro failed to compile",+            8 => "the macro raised a runtime error",+            _ => "unrecognised swRunMacroError_e — reported verbatim rather than guessed at",+        }+    }++    fn cmd_document_info(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let info = Self::doc_info(&doc);+        let configurations: Vec<Value> = doc+            .call("GetConfigurationNames", &[])+            .map(|v| v.as_array().iter().map(|e| e.to_json()).collect())+            .unwrap_or_default();+        let path = info.get("path").and_then(|p| p.as_str()).unwrap_or("").to_string();+        let props = Self::custom_props(&doc, "");+        Ok(json!({+            "name": info.get("title").cloned().unwrap_or(Value::Null),+            "productType": info.get("type").cloned().unwrap_or(Value::Null),+            "path": info.get("path").cloned().unwrap_or(Value::Null),+            // An unsaved scratch document has no path at all — that is the ONE+            // reliable "never been saved" signal SOLIDWORKS gives us.+            "isSaved": !path.is_empty(),+            "dirty": info.get("dirty").cloned().unwrap_or(Value::Null),+            "configuration": info.get("config").cloned().unwrap_or(Value::Null),+            "configurations": configurations,+            "customPropertyCount": props.as_object().map(|m| m.len()).unwrap_or(0),+            "needsRebuild": doc+                .obj("Extension", &[])+                .ok()+                .flatten()+                .and_then(|e| e.int("NeedsRebuild2", &[])),+            "doc": info,+        }))+    }++    /// `swx_design_info` — the design-level summary Fusion answers with.+    fn cmd_design_info(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let type_id = doc.int("GetType", &[]).unwrap_or(0);+        let mut features = 0usize;+        let mut sketches = 0usize;+        let mut errors = 0usize;+        let mut feature = doc.obj("FirstFeature", &[]).ok().flatten();+        let mut guard = 0;+        while let Some(f) = feature {+            guard += 1;+            if guard > 20_000 {+                break;+            }+            features += 1;+            if f.string("GetTypeName2", &[]).as_deref() == Some("ProfileFeature") {+                sketches += 1;+            }+            if f.call("GetErrorCode", &[]).ok().and_then(|c| c.as_i32()).unwrap_or(0) != 0 {+                errors += 1;+            }+            feature = f.obj("GetNextFeature", &[]).ok().flatten();+        }+        let bodies = if type_id == DOC_PART {+            doc.call("GetBodies2", &[&Var::i4(0), &Var::boolean(true)])+                .map(|v| v.as_array().len())+                .unwrap_or(0)+        } else {+            0+        };+        let components = if type_id == DOC_ASSEMBLY {+            doc.call("GetComponents", &[&Var::boolean(false)])+                .map(|v| v.as_array().len())+                .unwrap_or(0)+        } else {+            0+        };+        let configurations: Vec<Value> = doc+            .call("GetConfigurationNames", &[])+            .map(|v| v.as_array().iter().map(|e| e.to_json()).collect())+            .unwrap_or_default();+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "features": features,+            "sketches": sketches,+            "bodies": bodies,+            "components": components,+            "featureErrors": errors,+            "configurations": configurations,+            "material": Self::material_of(&doc, ""),+            "units": Self::units_of(&doc),+            "needsRebuild": doc+                .obj("Extension", &[])+                .ok()+                .flatten()+                .and_then(|e| e.int("NeedsRebuild2", &[])),+        }))+    }++    /// `GetMaterialPropertyName2(config, byref database) -> name`. The+    /// two-plain-string form v0.2 would have used is rejected by SOLIDWORKS —+    /// the second parameter is a BYREF out-param, which only the explicit+    /// marshalling here can supply.+    fn material_of(doc: &Disp, configuration: &str) -> Value {+        let mut database = BSTR::new();+        match doc.call(+            "GetMaterialPropertyName2",+            &[&Var::bstr(configuration), &Var::byref_bstr(&mut database as *mut BSTR)],+        ) {+            Ok(v) => {+                let name = v.as_string().unwrap_or_default();+                if name.is_empty() {+                    Value::Null+                } else {+                    json!({"name": name, "database": database.to_string()})+                }+            }+            Err(_) => Value::Null,+        }+    }++    /// Document units, read through `IModelDocExtension::GetUserPreferenceInteger`.+    ///+    /// HONEST CAVEAT: the raw enum id is reported alongside the decoded name,+    /// because the `swUserPreferenceIntegerValue_e` ids are not published in a+    /// form this bridge can verify against the installed build. The round trip+    /// (`swx_set_preference` then `swx_get_preferences`) IS proven; the LABEL is+    /// best-effort and says so.+    fn units_of(doc: &Disp) -> Value {+        let read = |id: i32| {+            doc.obj("Extension", &[])+                .ok()+                .flatten()+                .and_then(|e| e.int("GetUserPreferenceInteger", &[&Var::i4(id), &Var::i4(0)]))+        };+        json!({+            "linearRaw": read(53),+            "linear": read(53).map(Self::length_unit_name).unwrap_or(Value::Null),+            "systemRaw": read(48),+            "note": "raw swUserPreferenceIntegerValue_e values; the decoded names are \+                     best-effort. Every geometry number this bridge reports is in SI \+                     (metres/kg) or, where it says so, millimetres — never in document units.",+        })+    }++    fn length_unit_name(v: i32) -> Value {+        // swLengthUnit_e+        Value::from(match v {+            0 => "mm",+            1 => "cm",+            2 => "m",+            3 => "in",+            4 => "ft",+            5 => "ft-in",+            6 => "angstrom",+            7 => "nm",+            8 => "micron",+            9 => "mil",+            10 => "uin",+            _ => "unknown",+        })+    }++    /// `swx_get_parameters` — global variables (the equation manager) plus the+    /// named dimensions Fusion would call user parameters.+    fn cmd_get_parameters(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let mut out: Vec<Value> = Vec::new();+        if let Ok(Some(eq)) = doc.obj("GetEquationMgr", &[]) {+            let count = eq.int("GetCount", &[]).unwrap_or(0);+            for i in 0..count.max(0) {+                let text = eq.string("Equation", &[&Var::i4(i)]).unwrap_or_default();+                let value = eq.float("Value", &[&Var::i4(i)]);+                // `"name" = expression` is the equation-manager syntax.+                let (name, expression) = match text.split_once('=') {+                    Some((n, e)) => (n.trim().trim_matches('"').to_string(), e.trim().to_string()),+                    None => (format!("equation{i}"), text.clone()),+                };+                out.push(json!({+                    "name": name,+                    "expression": expression,+                    "value": value,+                    "unit": Value::Null,+                    "source": "equation",+                    "index": i,+                }));+            }+        }+        // Named dimensions: walk the feature tree and ask each feature for its+        // display dimensions. `IDimension::SystemValue` is metres, which is what+        // `Parameter("D1@Boss-Extrude1").SystemValue` returned live.+        // BOUNDED: each feature costs at least one COM round trip, so a+        // thousand-feature model would otherwise turn a "read the parameters"+        // verb into a minute of blocked CAD application. 500 features is well+        // past any hand-built part and the cut is reported, not hidden.+        const FEATURE_BUDGET: usize = 500;+        // Each probe is a COM round trip on a single-threaded apartment that+        // nothing else can use meanwhile, so the COST is what needs bounding,+        // not just the feature count. 400 probes is a fraction of a second on a+        // warm host and covers any hand-built part.+        const PROBE_BUDGET: usize = 400;+        let mut probes = 0usize;+        let mut feature = doc.obj("FirstFeature", &[]).ok().flatten();+        let mut guard = 0usize;+        let mut truncated = false;+        while let Some(f) = feature {+            guard += 1;+            if guard > FEATURE_BUDGET {+                truncated = true;+                break;+            }+            let fname = f.string("Name", &[]).unwrap_or_default();+            if !fname.is_empty() {+                for n in 1..=8 {+                    if probes >= PROBE_BUDGET {+                        truncated = true;+                        break;+                    }+                    probes += 1;+                    let key = format!("D{n}@{fname}");+                    let dim = doc.obj("Parameter", &[&Var::bstr(&key)]).ok().flatten();+                    let Some(dim) = dim else { break };+                    let value = dim.float("SystemValue", &[]);+                    out.push(json!({+                        "name": key,+                        "expression": Value::Null,+                        "value": value,+                        "valueMm": value.map(|v| (v * 1000.0 * 1000.0).round() / 1000.0),+                        "unit": "m",+                        "source": "dimension",+                    }));+                }+            }+            if truncated {+                break;+            }+            feature = f.obj("GetNextFeature", &[]).ok().flatten();+        }+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "parameters": out,+            "count": out.len(),+            "featuresWalked": guard,+            "dimensionProbes": probes,+            "truncated": truncated,+        }))+    }++    /// `swx_set_parameter` — drive one named dimension or global variable.+    fn cmd_set_parameter(&mut self, args: &Value) -> Result<Value, HostError> {+        let name = args+            .get("name")+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("name is required, e.g. \"D1@Boss-Extrude1\""))?;+        // `name` here is the DIMENSION, not the document. The document comes+        // from the server's authorized `docName`/`path`.+        let doc = self.resolve(&json!({+            "docName": args.get("docName").cloned(),+            "path": args.get("path").cloned(),+        }))?;+        // Millimetres if the caller says so (the unit an engineer speaks), metres+        // otherwise — SystemValue is metres and the ambiguity has to die here.+        let (value, unit) = match (args.get("valueMm").and_then(|v| v.as_f64()), args.get("value").and_then(|v| v.as_f64())) {+            (Some(mm), _) => (mm * 0.001, "mm"),+            (None, Some(m)) => (m, "m"),+            _ => return Err(HostError::msg("value (metres) or valueMm (millimetres) is required")),+        };+        if !value.is_finite() {+            return Err(HostError::msg("value must be a finite number"));+        }+        let dim = doc+            .obj("Parameter", &[&Var::bstr(name)])?+            .ok_or_else(|| {+                HostError::msg(format!(+                    "no dimension named '{name}' — swx_get_parameters lists what this document \+                     has (dimension names look like D1@Boss-Extrude1)"+                ))+            })?;+        let before = dim.float("SystemValue", &[]);+        dim.put("SystemValue", &Var::r8(value))?;+        let rebuilt = doc.call("EditRebuild3", &[]).ok().and_then(|v| v.as_bool());+        let after = dim.float("SystemValue", &[]);+        Ok(json!({+            "doc": Self::doc_info(&doc),+            "name": name,+            "requested": value,+            "unitGiven": unit,+            "before": before,+            "value": after,+            "valueMm": after.map(|v| (v * 1000.0 * 1000.0).round() / 1000.0),+            "rebuilt": rebuilt,+        }))+    }++    /// `swx_inspect_bodies` — geometry read-back in MILLIMETRES, the Fusion+    /// shape. `GetBodies2(0, true)` (solid bodies, visible only) is proven live.+    fn cmd_inspect_bodies(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        if doc.int("GetType", &[]).unwrap_or(0) != DOC_PART {+            return Err(HostError::msg(+                "inspect_bodies needs a part (.sldprt); for an assembly use swx_bom or \+                 swx_mass_properties",+            ));+        }+        let bodies = doc.call("GetBodies2", &[&Var::i4(0), &Var::boolean(true)])?;+        let filter = args.get("nameContains").and_then(|v| v.as_str()).unwrap_or("");+        let mut out = Vec::new();+        for b in bodies.as_array() {+            let Some(body) = b.as_dispatch().map(Disp) else { continue };+            let name = body.string("Name", &[]).unwrap_or_default();+            if !filter.is_empty() && !name.to_lowercase().contains(&filter.to_lowercase()) {+                continue;+            }+            // GetBodyBox -> [xMin,yMin,zMin,xMax,yMax,zMax] in metres.+            let bb: Vec<f64> =+                body.call("GetBodyBox", &[]).map(|v| v.as_array().iter().filter_map(|e| e.as_f64()).collect()).unwrap_or_default();+            let mm = |v: f64| (v * 1000.0 * 1000.0).round() / 1000.0;+            let (bbox, size) = if bb.len() >= 6 {+                (+                    json!({"minMm": [mm(bb[0]), mm(bb[1]), mm(bb[2])], "maxMm": [mm(bb[3]), mm(bb[4]), mm(bb[5])]}),+                    json!({"x": mm(bb[3] - bb[0]), "y": mm(bb[4] - bb[1]), "z": mm(bb[5] - bb[2])}),+                )+            } else {+                (Value::Null, Value::Null)+            };+            // IBody2::GetMassProperties(accuracy) -> [cx,cy,cz, volume, area, mass, ...]+            let mp: Vec<f64> = body+                .call("GetMassProperties", &[&Var::r8(0.0)])+                .map(|v| v.as_array().iter().filter_map(|e| e.as_f64()).collect())+                .unwrap_or_default();+            let get = |i: usize| mp.get(i).copied();+            out.push(json!({+                "name": name,+                "bbox": bbox,+                "sizeMm": size,+                "volumeMm3": get(3).map(|v| (v * 1.0e9 * 1000.0).round() / 1000.0),+                "areaMm2": get(4).map(|v| (v * 1.0e6 * 1000.0).round() / 1000.0),+                "massKg": get(5),+                "centerOfMassMm": (mp.len() >= 3).then(|| json!([mm(mp[0]), mm(mp[1]), mm(mp[2])])),+                "faceCount": body.int("GetFaceCount", &[]),+                "visible": body.flag("Visible", &[]),+                "isSolid": true,+            }));+        }+        Ok(json!({+            "documentName": doc.string("GetTitle", &[]),+            "doc": Self::doc_info(&doc),+            "units": "mm",+            "bodyCount": out.len(),+            "bodies": out,+        }))+    }++    /// `swx_import` — bring a neutral CAD file in as a new document.+    ///+    /// `LoadFile4(path, "r", importData, byref errors)` is the modern route; the+    /// `importData` argument is the optional object our `null` VARIANT covers.+    /// NOT proven live (SOLIDWORKS Connected was down when this was written), so+    /// it falls back to `LoadFile2(path, "")`, which at least reports honestly.+    fn cmd_import(&mut self, args: &Value) -> Result<Value, HostError> {+        let path = args+            .get("filePath")+            .or_else(|| args.get("path"))+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("filePath is required"))?;+        if !std::path::Path::new(path).exists() {+            return Err(HostError::msg(format!("file not found: {path}")));+        }+        let sw = self.app(false, true)?;+        let mut errors = 0i32;+        // Count first. LoadFile4 can IMPORT SUCCESSFULLY and still hand back+        // something that is not an IDispatch we can use — and the first version+        // of this fell through to LoadFile2 on exactly that, importing the file+        // a SECOND time and leaving two documents open, one of them untracked.+        // So the fallback is decided by whether a document actually appeared,+        // not by the shape of the return value.+        // FAIL CLOSED. If we cannot count the open documents we cannot tell+        // whether LoadFile4 already imported the file, and guessing wrong runs+        // the import a second time — two documents, one of them untracked.+        let before = match sw.call("GetDocuments", &[]) {+            Ok(d) => d.as_array().len(),+            Err(e) => {+                return Err(HostError::detailed(+                    "cannot import: SOLIDWORKS would not report its open documents, so there is \+                     no way to tell afterwards whether the import already happened"+                        .to_string(),+                    e.message,+                ))+            }+        };+        let load4 = sw.call(+            "LoadFile4",+            &[+                &Var::bstr(path),+                &Var::bstr("r"),+                &Var::empty(),+                &Var::byref_i4(&mut errors as *mut i32),+            ],+        );+        let load4_err = load4.as_ref().err().map(|e| e.message.clone());+        let imported = load4.ok().and_then(|v| v.as_dispatch()).map(Disp);+        let after = match sw.call("GetDocuments", &[]) {+            Ok(d) => d.as_array().len(),+            Err(e) => {+                return Err(HostError::detailed(+                    "the import may or may not have completed: SOLIDWORKS stopped reporting its \+                     open documents. Check swx_docs before retrying — retrying blind could import \+                     the file twice."+                        .to_string(),+                    e.message,+                ))+            }+        };+        if let Some(doc) = imported {+            return Ok(json!({+                "imported": Self::doc_info(&doc),+                "via": "LoadFile4",+                "errors": errors,+                "documentsOpened": after.saturating_sub(before),+            }));+        }+        if after > before {+            // It DID import; we just could not take the handle. Use the active+            // document rather than importing it again.+            let doc = sw+                .obj("ActiveDoc", &[])?+                .ok_or_else(|| HostError::msg("import added a document but none became active"))?;+            return Ok(json!({+                "imported": Self::doc_info(&doc),+                "via": "LoadFile4 (handle recovered from ActiveDoc)",+                "errors": errors,+                "documentsOpened": after - before,+            }));+        }+        let ok = sw.call("LoadFile2", &[&Var::bstr(path), &Var::bstr("")])?.as_bool().unwrap_or(false);+        if !ok {+            return Err(HostError::detailed(+                format!(+                    "SOLIDWORKS could not import {path} (LoadFile4 opened nothing, errors={errors}; \+                     LoadFile2 refused). Importable formats depend on the installed translators."+                ),+                load4_err.unwrap_or_else(|| "LoadFile4 returned no document".into()),+            ));+        }+        let doc = sw+            .obj("ActiveDoc", &[])?+            .ok_or_else(|| HostError::msg("import reported success but no document became active"))?;+        Ok(json!({+            "imported": Self::doc_info(&doc),+            "via": "LoadFile2",+            "errors": errors,+            "documentsOpened": 1,+        }))+    }++    /// `swx_save_as` — a DELIBERATE rename/move of the open document (plain+    /// Silent, no Copy), as opposed to `swx_export`'s copy.+    fn cmd_save_as(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let out = args+            .get("outputPath")+            .or_else(|| args.get("out"))+            .and_then(|v| v.as_str())+            .filter(|s| !s.is_empty())+            .ok_or_else(|| HostError::msg("outputPath is required"))?;+        let copy = args.get("copy").and_then(|v| v.as_bool()).unwrap_or(false);+        // A rename touches the DOCUMENT; a copy only writes a file.+        let was_ours = self.host_owns(&doc);+        let code = Self::save_as3(&doc, out, copy)?;+        if code != 0 {+            return Err(HostError::msg(format!(+                "SOLIDWORKS refused to save {out}: {}",+                Self::save_error_text(code)+            )));+        }+        // OWNERSHIP FOLLOWS THE DOCUMENT, not the string that used to name it.+        // A non-copy save_as retitles and re-paths the document in place; if the+        // host's record is not moved with it, the bridge disowns the scratch+        // document it just saved and can no longer close or clean it up.+        if !copy && was_ours {+            let old_title = doc.string("GetTitle", &[]).unwrap_or_default();+            self.created.retain(|(t, _)| *t != old_title);+            self.remember_created(&doc);+        }+        Ok(json!({+            "savedAs": out,+            "copy": copy,+            "bytes": std::fs::metadata(out).map(|m| m.len()).ok(),+            "doc": Self::doc_info(&doc),+        }))+    }++    /// `swx_show_*` — activate the document and fit it in the view, in the+    /// BACKGROUND. `ViewZoomtofit2` is proven live.+    fn cmd_show(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args)?;+        let title = doc.string("GetTitle", &[]).unwrap_or_default();+        let mut errors = 0i32;+        let activated = if args.get("activate").and_then(|v| v.as_bool()).unwrap_or(true) {+            let sw = self.app(false, true)?;+            sw.call(+                "ActivateDoc3",+                &[+                    &Var::bstr(&title),+                    &Var::boolean(false),+                    &Var::i4(0),+                    &Var::byref_i4(&mut errors as *mut i32),+                ],+            )+            .is_ok()+        } else {+            false+        };+        let zoomed = doc.call("ViewZoomtofit2", &[]).is_ok();+        Ok(json!({+            "document": title,+            "doc": Self::doc_info(&doc),+            "activated": activated,+            "zoomedToFit": zoomed,+            "activateErrors": errors,+        }))+    }++    /// `swx_get_app_state` — the Fusion-shaped snapshot, from COM only (the+    /// server adds the window/dialog half through ab).+    fn cmd_app_state(&mut self) -> Result<Value, HostError> {+        let sw = match self.app(false, true) {+            Ok(sw) => sw,+            Err(_) => {+                return Ok(json!({+                    "running": false,+                    "activeDocument": Value::Null,+                    "documents": [],+                    "busy": Value::Null,+                    "mainHwnd": Value::Null,+                }))+            }+        };+        let docs: Vec<Value> = sw+            .call("GetDocuments", &[])?+            .as_array()+            .iter()+            .filter_map(|v| v.as_dispatch().map(Disp))+            .map(|d| Self::doc_info(&d))+            .collect();+        let active = sw.obj("ActiveDoc", &[])?.map(|d| Self::doc_info(&d));+        let workspace = active+            .as_ref()+            .and_then(|a| a.get("type").and_then(|t| t.as_str()))+            .unwrap_or("none")+            .to_string();+        let unsaved = docs+            .iter()+            .filter(|d| d.get("dirty").and_then(|x| x.as_bool()).unwrap_or(false))+            .count();+        Ok(json!({+            "running": true,+            "version": sw.string("RevisionNumber", &[]),+            "activeDocument": active.clone().map(|a| a.get("title").cloned().unwrap_or(Value::Null)).unwrap_or(Value::Null),+            "activeDoc": active,+            "documents": docs,+            "documentCount": sw.int("GetDocumentCount", &[]),+            "unsavedDocuments": unsaved,+            "workspace": workspace,+            "busy": sw.flag("CommandInProgress", &[]),+            "visible": sw.flag("Visible", &[]),+            "processId": sw.int("GetProcessID", &[]),+            "mainHwnd": Self::main_hwnd(&sw),+        }))+    }++    /// The application window handle, straight from COM — the only way to+    /// attribute a desktop window to SOLIDWORKS with certainty. Proven live+    /// (`$sw.Frame().GetHWnd()` -> 1836650).+    fn main_hwnd(sw: &Disp) -> Value {+        sw.obj("Frame", &[])+            .ok()+            .flatten()+            .and_then(|f| f.int("GetHWnd", &[]))+            .map(Value::from)+            .unwrap_or(Value::Null)+    }++    /// `swx_check_recovery` — SOLIDWORKS exposes no "is the recovery pane up"+    /// API, so this reports the two facts it CAN prove and leaves the dialog+    /// half to the server's window census.+    fn cmd_check_recovery(&mut self) -> Result<Value, HostError> {+        let sw = self.app(false, true)?;+        let docs = sw.call("GetDocuments", &[])?.as_array().len();+        Ok(json!({+            "openDocuments": docs,+            "comApiHasRecoveryCheck": false,+            "note": "SOLIDWORKS exposes no COM member for the Document Recovery pane; the \+                     server pairs this with the window census, which is where a recovery \+                     dialog actually shows up.",+        }))+    }++    /// `swx_get_preferences` / `swx_set_preference`. Deliberately a SMALL,+    /// named table: a preference this bridge cannot round-trip is a preference+    /// it has no business claiming to support.+    fn cmd_get_preferences(&mut self, args: &Value) -> Result<Value, HostError> {+        let doc = self.resolve(args).ok();+        let sw = self.app(false, true)?;+        let mut current = Map::new();+        for (name, id) in PREFERENCES {+            let value = doc+                .as_ref()+                .and_then(|d| d.obj("Extension", &[]).ok().flatten())+                .and_then(|e| e.int("GetUserPreferenceInteger", &[&Var::i4(*id), &Var::i4(0)]));+            current.insert(+                (*name).to_string(),+                json!({"id": id, "value": value, "scope": "document"}),+            );+        }+        current.insert(+            "lengthUnit".into(),+            json!(doc+                .as_ref()+                .and_then(|d| d.obj("Extension", &[]).ok().flatten())+                .and_then(|e| e.int("GetUserPreferenceInteger", &[&Var::i4(53), &Var::i4(0)]))+                .map(Self::length_unit_name)+                .unwrap_or(Value::Null)),+        );+        Ok(json!({+            "current": Value::Object(current),+            "documentScoped": doc.is_some(),+            "app": {+                "visible": sw.flag("Visible", &[]),+                "licenseType": sw.int("GetCurrentLicenseType", &[]),+                "version": sw.string("RevisionNumber", &[]),+            },+        }))+    }++    fn cmd_set_preference(&mut self, args: &Value) -> Result<Value, HostError> {+        let name = args+            .get("name")+            .and_then(|v| v.as_str())+            .ok_or_else(|| HostError::msg("name is required"))?;+        let id = PREFERENCES+            .iter()+            .find(|(n, _)| *n == name)+            .map(|(_, id)| *id)+            .ok_or_else(|| {+                HostError::msg(format!(+                    "unknown preference '{name}' — this bridge only exposes preferences it can \+                     round-trip: {}",+                    PREFERENCES.iter().map(|(n, _)| *n).collect::<Vec<_>>().join(", ")+                ))+            })?;+        let value = args+            .get("value")+            .and_then(|v| v.as_i64())+            .ok_or_else(|| HostError::msg("value (an integer) is required"))?+            as i32;+        // `name` here is the PREFERENCE, not the document.+        let doc = self.resolve(&json!({+            "docName": args.get("docName").cloned(),+            "path": args.get("path").cloned(),+        }))?;+        let ext = doc.obj("Extension", &[])?.ok_or_else(|| HostError::msg("no ModelDocExtension"))?;+        let before = ext.int("GetUserPreferenceInteger", &[&Var::i4(id), &Var::i4(0)]);+        ext.call(+            "SetUserPreferenceInteger",+            &[&Var::i4(id), &Var::i4(0), &Var::i4(value)],+        )?;+        let after = ext.int("GetUserPreferenceInteger", &[&Var::i4(id), &Var::i4(0)]);+        // Verify by READING BACK — a preference setter that reports success+        // without checking is how a bridge starts lying.+        Ok(json!({+            "applied": {name: after},+            "name": name,+            "id": id,+            "requested": value,+            "before": before,+            "value": after,+            "verified": after == Some(value),+        }))+    }++    /// `swx_cloud_status` — what this install can tell us about 3DEXPERIENCE.+    ///+    /// LIVE FINDING: the SOLIDWORKS COM API exposes NO PLM/3DSpace member on+    /// this build (`IsPLMConnected`, `GetPLMConnection`, `GetSearchFolders` and+    /// `EnumDocuments2` are all absent or rejected). So there is no COM route to+    /// the cloud file store at all, and this verb says so precisely rather than+    /// pretending.+    fn cmd_cloud_status(&mut self) -> Result<Value, HostError> {+        let sw = self.app(false, true)?;+        let mut probed = Map::new();+        for member in ["IsPLMConnected", "GetPLMConnection", "GetSearchFolders", "EnumDocuments2"] {+            probed.insert(+                member.to_string(),+                Value::from(sw.call(member, &[]).is_ok()),+            );+        }+        Ok(json!({+            "connected": Value::Null,+            "comApiExposesCloud": false,+            "probedMembers": Value::Object(probed),+            "licenseType": sw.int("GetCurrentLicenseType", &[]),+            "version": sw.string("RevisionNumber", &[]),+        }))+    }++    /// `swx_run_script` — the modeling DSL, executed with the exact call+    /// sequence proven live on this install.+    /// `swx_add_component` — put component instances into an assembly.+    ///+    /// THE FINDING THIS VERB EXISTS FOR. `IAssemblyDoc::AddComponent5` is the+    /// documented way to insert a component, and on this bridge's first live+    /// target (SOLIDWORKS Connected R2026x, Design Professional for Makers) it+    /// returns `Nothing`. An earlier probe read that as "this edition cannot+    /// insert components at all" and the whole assembly surface — `swx_bom`,+    /// `swx_interference`, per-component mass properties — was written off as+    /// mock-only.+    ///+    /// The return value is the lie, not the insertion. So this command does not+    /// trust it: it COUNTS the assembly's components before and after the call+    /// and treats a rise as success. On top of that it walks a ladder of+    /// spellings (`AddComponent5` with each config option, then `AddComponent4`,+    /// `AddComponent3`, `AddComponent`) and, if every one fails, loads the+    /// component document read-only with `OpenDoc6` — a documented precondition+    /// — and walks the ladder again. Whatever rung works is remembered in+    /// `insert_method`, because an assembly of 150 fasteners must not pay the+    /// discovery cost 150 times.+    fn cmd_add_component(&mut self, args: &Value) -> Result<Value, HostError> {+        let asm = self.resolve(args)?;+        if asm.int("GetType", &[]).unwrap_or(0) != DOC_ASSEMBLY {+            return Err(HostError::coded(+                "not_an_assembly",+                "add_component needs an assembly (.sldasm) as the target document — \+                 swx_new_document {\"type\":\"assembly\"} makes one",+            ));+        }+        let reqs = Self::component_requests(args)?;+        let fix = args.get("fix").and_then(|v| v.as_bool()).unwrap_or(false);+        let sw = self.app(false, true)?;+        // AddComponent5 inserts into the ACTIVE assembly, so the target has to+        // be the one in front. This switches which DOCUMENT is current inside+        // SOLIDWORKS; it does not raise the application over anything.+        let title = asm.string("GetTitle", &[]).unwrap_or_default();+        let mut activate_errors = 0i32;+        let _ = sw.call(+            "ActivateDoc3",+            &[+                &Var::bstr(&title),+                &Var::boolean(false),+                &Var::i4(0),+                &Var::byref_i4(&mut activate_errors as *mut i32),+            ],+        );++        // WHICH components did this call insert? Matching the request against+        // GetComponents by FILE PATH cannot answer that once the assembly already+        // holds an instance of the same file: `same_path` matches ANY instance, so+        // the transform for a new component can be written onto an OLDER one -+        // overwriting a good placement and leaving the new component wherever+        // AddComponent5 dropped it. Measured on the crate's side panel: R2+        // instances 1-2 landed exactly, 3-5 carried the "centred on the requested+        // point" signature. Names are identities (SOLIDWORKS never reissues one in+        // a document), so snapshot them and diff.+        let before: std::collections::HashSet<String> = asm+            .call("GetComponents", &[&Var::boolean(true)])+            .map(|v| v.as_array())+            .unwrap_or_default()+            .iter()+            .filter_map(|c| c.as_dispatch().map(Disp))+            .filter_map(|c| c.string("Name2", &[]))+            .collect();++        let mut inserted: Vec<Value> = Vec::new();+        let mut failed: Vec<Value> = Vec::new();+        let mut fixed = 0usize;+        for r in &reqs {+            if !std::path::Path::new(&r.file).exists() {+                failed.push(json!({+                    "filePath": r.file,+                    "error": "file not found on the DESKTOP filesystem",+                }));+                continue;+            }+            let mut used: Option<&'static str> = None;+            let mut attempts: Vec<Value> = Vec::new();+            let mut preloaded: Option<Value> = None;+            'passes: for pass in 0..2 {+                if pass == 1 {+                    // Documented precondition, paid for only when the direct+                    // route failed: the component document must be in memory.+                    // READ-ONLY — inserting a component reads its geometry and+                    // never writes to the part file, and a write lock on it+                    // would buy nothing.+                    let (e, w) = Self::preload_component(&sw, &r.file, &r.config);+                    preloaded = Some(json!({"openErrors": e, "openWarnings": w}));+                }+                let before = Self::component_count(&asm);+                for method in Self::insert_ladder(self.insert_method.as_deref()) {+                    let called = Self::invoke_insert(&asm, method, r);+                    if Self::component_count(&asm) > before {+                        used = Some(method);+                        break 'passes;+                    }+                    attempts.push(json!({+                        "method": method,+                        "pass": pass,+                        "comError": called.err().map(|e| e.message),+                    }));+                }+            }+            match used {+                Some(method) => {+                    self.insert_method = Some(method.to_string());+                    let comp = Self::last_component(&asm);+                    if fix {+                        if let Some(c) = &comp {+                            if Self::fix_component(&asm, c) {+                                fixed += 1;+                            }+                        }+                    }+                    inserted.push(json!({+                        "filePath": r.file,+                        "name": comp.as_ref().and_then(|c| c.string("Name2", &[])),+                        "method": method,+                        "preloaded": preloaded.is_some(),+                        "positionMm": [+                            r.x / crate::script::MM,+                            r.y / crate::script::MM,+                            r.z / crate::script::MM,+                        ],+                        "rotationDeg": [+                            r.rx.to_degrees(),+                            r.ry.to_degrees(),+                            r.rz.to_degrees(),+                        ],+                    }));+                }+                None => failed.push(json!({+                    "filePath": r.file,+                    "error": "the assembly's component count did not rise after any known \+                              IAssemblyDoc insert call",+                    "preload": preloaded,+                    "attempts": attempts,+                })),+            }+        }+        // ORIENTATION, in ONE sweep. AddComponent5 places a component at a point+        // with no rotation, so anything that has to lie on its side needs its+        // transform written afterwards — and the insert call hands back no+        // handle to write it to. Matching components to requests by (file,+        // translation) costs one pass over the assembly instead of a search per+        // insert, which is the difference between O(n) and O(n²) COM calls on a+        // crate with four hundred fasteners in it.+        let orient = Self::apply_transforms(&sw, &asm, &reqs, &before);+        Ok(json!({+            "assembly": Self::doc_info(&asm),+            "requested": reqs.len(),+            "insertedCount": inserted.len(),+            "inserted": inserted,+            "failedCount": failed.len(),+            "failed": failed,+            "componentCount": Self::component_count(&asm),+            "method": self.insert_method,+            "fixedCount": fixed,+            "placedCount": orient.0,+            "rotationsRequested": reqs.iter().filter(|r| r.rotated()).count(),+            "placementNotes": orient.1,+            "activateErrors": activate_errors,+        }))+    }++    /// Every insert spelling this bridge knows, best first. `AddComponent5/<n>`+    /// is `AddComponent5` with `swAddComponentConfigOptions_e` = n.+    const INSERT_METHODS: &'static [&'static str] = &[+        "AddComponent5/1",+        "AddComponent5/3",+        "AddComponent5/2",+        "AddComponent5/0",+        "AddComponent4",+        "AddComponent3",+        "AddComponent",+    ];++    /// The ladder with the remembered winner promoted to the front, so a proven+    /// install pays one COM call per component and an unproven one still finds+    /// its way.+    fn insert_ladder(cached: Option<&str>) -> Vec<&'static str> {+        let mut v: Vec<&'static str> = Self::INSERT_METHODS.to_vec();+        if let Some(c) = cached {+            if let Some(i) = v.iter().position(|m| *m == c) {+                let m = v.remove(i);+                v.insert(0, m);+            }+        }+        v+    }++    fn invoke_insert(asm: &Disp, method: &str, r: &crate::script::Component) -> Result<(), HostError> {+        let (x, y, z) = (Var::r8(r.x), Var::r8(r.y), Var::r8(r.z));+        match method {+            "AddComponent4" => {+                asm.call(+                    "AddComponent4",+                    &[&Var::bstr(&r.file), &Var::bstr(&r.config), &x, &y, &z],+                )?;+            }+            "AddComponent3" => {+                asm.call("AddComponent3", &[&Var::bstr(&r.file), &x, &y, &z])?;+            }+            "AddComponent" => {+                asm.call("AddComponent", &[&Var::bstr(&r.file), &x, &y, &z])?;+            }+            other => {+                // AddComponent5(CompName, ConfigOption, NewConfigName,+                //               UseConfigForPartReferences, ConfigName, X, Y, Z)+                let opt: i32 = other.rsplit('/').next().and_then(|s| s.parse().ok()).unwrap_or(1);+                asm.call(+                    "AddComponent5",+                    &[+                        &Var::bstr(&r.file),+                        &Var::i4(opt),+                        &Var::bstr(""),+                        &Var::boolean(false),+                        &Var::bstr(&r.config),+                        &x,+                        &y,+                        &z,+                    ],+                )?;+            }+        }+        Ok(())+    }++    /// Load a component document silently and READ-ONLY. Returns OpenDoc6's+    /// byref (errors, warnings) so a failure to insert can say whether the file+    /// even loaded.+    fn preload_component(sw: &Disp, file: &str, config: &str) -> (i32, i32) {+        let mut errors = 0i32;+        let mut warnings = 0i32;+        let type_id = doc_type_id(file).unwrap_or(DOC_PART);+        // swOpenDocOptions_Silent (1) | swOpenDocOptions_ReadOnly (2)+        let _ = sw.call(+            "OpenDoc6",+            &[+                &Var::bstr(file),+                &Var::i4(type_id),+                &Var::i4(1 | 2),+                &Var::bstr(config),+                &Var::byref_i4(&mut errors as *mut i32),+                &Var::byref_i4(&mut warnings as *mut i32),+            ],+        );+        (errors, warnings)+    }++    /// THE SUCCESS TEST. Not the return value of the insert call — see+    /// `cmd_add_component`.+    fn component_count(asm: &Disp) -> usize {+        asm.call("GetComponents", &[&Var::boolean(true)]).map(|v| v.as_array().len()).unwrap_or(0)+    }++    /// The most recently added top-level component, best effort — used only for+    /// the reported name and the optional fix, never for the success test.+    fn last_component(asm: &Disp) -> Option<Disp> {+        let mut comps = asm.call("GetComponents", &[&Var::boolean(true)]).ok()?.as_array();+        comps.pop()?.as_dispatch().map(Disp)+    }++    /// Fix a component in place so nothing can drag it off its coordinates.+    /// Best effort: an assembly positioned by coordinates is still correct+    /// without it.+    fn fix_component(asm: &Disp, comp: &Disp) -> bool {+        let selected = comp+            .call("Select4", &[&Var::boolean(false), &Var::empty(), &Var::boolean(false)])+            .ok()+            .and_then(|v| v.as_bool())+            .unwrap_or(false);+        if !selected {+            return false;+        }+        let ok = asm.call("FixComponent", &[]).is_ok();+        let _ = asm.call("ClearSelection2", &[&Var::boolean(true)]);+        ok+    }++    /// Write the EXACT transform — position and rotation — onto every component+    /// this call inserted.+    ///+    /// Two live findings force this. `AddComponent5`'s X/Y/Z is not the+    /// component's transform origin on this install: a part whose own centroid+    /// sits at (50, 6, -25) mm inserted at (0, 0, 0) lands with the assembly's+    /// centre of mass at the origin, i.e. SOLIDWORKS centred it on the point+    /// rather than putting its origin there. And the insert call returns nothing+    /// to hold on to, so there is no handle to correct it through. Writing the+    /// transform afterwards makes the position mean exactly one thing —+    /// "the component's origin goes here" — and rotation comes free with it.+    ///+    /// The components this batch inserted are found by MATCHING THE SEQUENCE of+    /// file paths: they occupy one contiguous run of the assembly's component+    /// list, forwards or backwards, and the run that matches the request order+    /// is the batch. That is O(n) COM calls for the whole batch instead of a+    /// search per component, and it PROVES the mapping rather than assuming an+    /// ordering — if no run matches, nothing is written and the response says+    /// so.+    fn apply_transforms(+        sw: &Disp,+        asm: &Disp,+        reqs: &[crate::script::Component],+        before: &std::collections::HashSet<String>,+    ) -> (usize, Vec<Value>) {+        if reqs.is_empty() {+            return (0, Vec::new());+        }+        let mut notes: Vec<Value> = Vec::new();+        let math = match sw.obj("GetMathUtility", &[]) {+            Ok(Some(m)) => m,+            _ => {+                notes.push(json!({+                    "error": "IMathUtility is unavailable, so no component transform could be \+                              written — components are wherever AddComponent5 put them",+                }));+                return (0, notes);+            }+        };+        let comps: Vec<Disp> = asm+            .call("GetComponents", &[&Var::boolean(true)])+            .map(|v| v.as_array())+            .unwrap_or_default()+            .iter()+            .filter_map(|c| c.as_dispatch().map(Disp))+            .collect();+        let paths: Vec<String> =+            comps.iter().map(|c| c.string("GetPathName", &[]).unwrap_or_default()).collect();+        let names: Vec<String> =+            comps.iter().map(|c| c.string("Name2", &[]).unwrap_or_default()).collect();++        // The components whose NAME is new since the snapshot are exactly the ones+        // this call inserted — no ordering assumption at all. GetComponents does+        // not return them in insertion order, nor grouped by file, which is why+        // the contiguous-run match below could not find five R2 instances among+        // seven components.+        let new_idx: Vec<usize> = (0..comps.len())+            .filter(|&i| !names[i].is_empty() && !before.contains(&names[i]))+            .collect();+        let mut targets: Vec<usize> = Vec::new();+        if new_idx.len() == reqs.len() {+            // Instances of one file are interchangeable, so a greedy per-path+            // assignment over the new components is exact.+            let mut used = vec![false; new_idx.len()];+            for r in reqs {+                let mut hit: Option<usize> = None;+                for (k, &i) in new_idx.iter().enumerate() {+                    if !used[k] && crate::verbs::same_path(&r.file, &paths[i]) {+                        used[k] = true;+                        hit = Some(i);+                        break;+                    }+                }+                match hit {+                    Some(i) => targets.push(i),+                    None => {+                        targets.clear();+                        break;+                    }+                }+            }+        }+        if targets.len() != reqs.len() {+            // Fallback: the pre-0.3.2 contiguous-run match, for the case where+            // names could not be read at all.+            targets.clear();+            let Some((offset, forward)) = crate::script::locate_run(&paths, reqs) else {+                notes.push(json!({+                    "error": "the components just inserted could not be located in the assembly \+                              by name or by matching the sequence of file paths, so no transform \+                              was written — every component is where AddComponent5 put it, which \+                              is NOT necessarily the position that was asked for",+                    "assemblyComponents": paths.len(),+                    "newByName": new_idx.len(),+                    "requested": reqs.len(),+                }));+                return (0, notes);+            };+            for i in 0..reqs.len() {+                targets.push(if forward { offset + i } else { offset + reqs.len() - 1 - i });+            }+        }+        let mut placed = 0usize;+        for (i, r) in reqs.iter().enumerate() {+            let comp = &comps[targets[i]];+            let data = r.transform();+            match math.call("CreateTransform", &[&Var::r8_array(&data)]).map(|v| v.as_dispatch()) {+                Ok(Some(t)) => match comp.put("Transform2", &Var::dispatch(&t)) {+                    Ok(()) => placed += 1,+                    Err(e) => notes.push(json!({"filePath": r.file, "error": e.message})),+                },+                Ok(None) => notes+                    .push(json!({"filePath": r.file, "error": "CreateTransform returned nothing"})),+                Err(e) => notes.push(json!({"filePath": r.file, "error": e.message})),+            }+        }+        (placed, notes)+    }++    /// The SAME parser the server ran, re-run here. The host re-validating what+    /// the server already validated is the pattern every mutating command+    /// follows: a server-side decision is a claim.+    fn component_requests(args: &Value) -> Result<Vec<crate::script::Component>, HostError> {+        crate::script::parse_components(args).map_err(HostError::msg)+    }++    fn cmd_run_script(&mut self, args: &Value) -> Result<Value, HostError> {+        use crate::script::Op;+        let script = args.get("script").cloned().unwrap_or(Value::Null);+        let ops = crate::script::parse(&script).map_err(HostError::msg)?;+        let has_doc = self.resolve(&json!({})).is_ok();+        crate::script::validate(&ops, has_doc).map_err(HostError::msg)?;++        // PIN the target. Without this every step re-resolved "the active+        // document", so a dialog, a rebuild that stole focus, or the user simply+        // clicking another SOLIDWORKS window between steps could move a running+        // script onto a different model halfway through. The server sends the+        // title it validated ownership of; a `new_part` step replaces it with+        // the document it just made.+        let mut pinned: Option<String> =+            args.get("targetDocument").and_then(|v| v.as_str()).filter(|s| !s.is_empty()).map(String::from);+        if let Some(want) = &pinned {+            // Prove the pin resolves BEFORE running anything.+            self.resolve(&json!({"name": want})).map_err(|e| {+                HostError::detailed(+                    format!("cannot target document '{want}': {}", e.message),+                    "swx_docs lists the titles that are open. Nothing was run.".to_string(),+                )+            })?;+        }++        let mut results = Vec::new();+        let mut created: Option<Value> = None;+        for (i, op) in ops.iter().enumerate() {+            let step = i + 1;+            let detail = self.run_op(op, &pinned).map_err(|e| {+                HostError::detailed(+                    format!("step {step} ({}) failed: {}", op.name(), e.message),+                    e.detail.unwrap_or_else(|| {+                        format!(+                            "{} of {} steps ran. Anything already built is still in the open \+                             document; close it with swx_close_doc {{save:false}} if you want a \+                             clean slate.",+                            step - 1,+                            ops.len()+                        )+                    }),+                )+            })?;+            if matches!(op, Op::NewPart | Op::NewAssembly) {+                pinned = detail+                    .get("created")+                    .and_then(|c| c.get("title"))+                    .and_then(|t| t.as_str())+                    .map(String::from);+                created = Some(detail.clone());+            }+            results.push(json!({"step": step, "op": op.name(), "result": detail}));+        }+        let doc = self.resolve(&Self::doc_arg(&pinned)).ok();+        Ok(json!({+            "steps": results,+            "stepCount": results.len(),+            "created": created,+            "targetDocument": pinned,+            "documentName": doc.as_ref().and_then(|d| d.string("GetTitle", &[])),+            "doc": doc.as_ref().map(Self::doc_info).unwrap_or(Value::Null),+        }))+    }++    /// The resolve-args for the pinned document ("the active one" only when+    /// nothing is pinned, which is the case for a script that starts by+    /// creating its own document).+    fn doc_arg(pinned: &Option<String>) -> Value {+        match pinned {+            Some(name) => json!({"name": name}),+            None => json!({}),+        }+    }++    /// One DSL op, as the live-proven COM call sequence, against the PINNED+    /// document.+    fn run_op(&mut self, op: &crate::script::Op, pinned: &Option<String>) -> Result<Value, HostError> {+        use crate::script::Op;+        let target = Self::doc_arg(pinned);+        match op {+            Op::NewPart => self.cmd_new_document(&json!({"type": "part"})),+            Op::NewAssembly => self.cmd_new_document(&json!({"type": "assembly"})),++            Op::SketchRect { plane, x, y, width, height } => {+                let doc = self.resolve(&target)?;+                let sm = Self::open_sketch(&doc, plane)?;+                // From here the sketch is OPEN. Every exit — the error path+                // included — must close it, or the user's SOLIDWORKS is left+                // parked in sketch-edit mode with a half-drawn profile on screen.+                let made = sm.call(+                    "CreateCornerRectangle",+                    &[+                        &Var::r8(*x),+                        &Var::r8(*y),+                        &Var::r8(0.0),+                        &Var::r8(x + width),+                        &Var::r8(y + height),+                        &Var::r8(0.0),+                    ],+                );+                Self::close_sketch(&sm)?;+                let segs = made?.as_array().len();+                if segs == 0 {+                    return Err(HostError::msg(+                        "SOLIDWORKS drew no rectangle — check that widthMm and heightMm are \+                         non-zero",+                    ));+                }+                Ok(json!({+                    "plane": plane,+                    "segments": segs,+                    "widthMm": width * 1000.0,+                    "heightMm": height * 1000.0,+                }))+            }++            Op::SketchCircle { plane, x, y, radius } => {+                let doc = self.resolve(&target)?;+                let sm = Self::open_sketch(&doc, plane)?;+                // CreateCircleByRadius is the modern form; CreateCircle (centre+                // plus a rim point) is what every older macro uses. Try both+                // rather than betting the op on one spelling — and close the+                // sketch either way.+                let made = sm+                    .call(+                        "CreateCircleByRadius",+                        &[&Var::r8(*x), &Var::r8(*y), &Var::r8(0.0), &Var::r8(*radius)],+                    )+                    .or_else(|_| {+                        sm.call(+                            "CreateCircle",+                            &[+                                &Var::r8(*x),+                                &Var::r8(*y),+                                &Var::r8(0.0),+                                &Var::r8(x + radius),+                                &Var::r8(*y),+                                &Var::r8(0.0),+                            ],+                        )+                    });+                Self::close_sketch(&sm)?;+                let made = made?;+                Ok(json!({+                    "plane": plane,+                    "radiusMm": radius * 1000.0,+                    "created": !made.is_null(),+                }))+            }++            Op::Extrude { depth, reverse } => {+                let doc = self.resolve(&target)?;+                // FeatureExtrusion3's 23 arguments, in the order proven live:+                // Sd, Flip, Dir, T1, T2, D1, D2, Dchk1, Dchk2, Ddir1, Ddir2,+                // Dang1, Dang2, OffsetReverse1, OffsetReverse2, TranslateSurface1,+                // TranslateSurface2, Merge, UseFeatScope, UseAutoSelect, T0,+                // StartOffset, FlipStartOffset.+                let f = doc+                    .obj("FeatureManager", &[])?+                    .ok_or_else(|| HostError::msg("no FeatureManager"))?+                    .call(+                        "FeatureExtrusion3",+                        &[+                            &Var::boolean(true),+                            &Var::boolean(false),+                            &Var::boolean(*reverse),+                            &Var::i4(0),+                            &Var::i4(0),+                            &Var::r8(*depth),+                            &Var::r8(0.01),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::r8(0.0174533),+                            &Var::r8(0.0174533),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(true),+                            &Var::boolean(true),+                            &Var::boolean(true),+                            &Var::i4(0),+                            &Var::r8(0.0),+                            &Var::boolean(false),+                        ],+                    )?;+                let feature = f.as_dispatch().map(Disp);+                Self::clear_selection(&doc);+                if feature.is_none() {+                    return Err(HostError::msg(+                        "SOLIDWORKS built no extrusion — the sketch may be open, unclosed, or \+                         self-intersecting",+                    ));+                }+                Ok(json!({+                    "feature": feature.and_then(|d| d.string("Name", &[])),+                    "depthMm": depth * 1000.0,+                }))+            }++            Op::Cut { depth, through_all } => {+                let doc = self.resolve(&target)?;+                // NOT PROVEN LIVE. swEndConditions_e: 1 = Through All, 0 = Blind.+                let end = if *through_all { 1 } else { 0 };+                let f = doc+                    .obj("FeatureManager", &[])?+                    .ok_or_else(|| HostError::msg("no FeatureManager"))?+                    .call(+                        "FeatureCut4",+                        &[+                            &Var::boolean(true),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::i4(end),+                            &Var::i4(0),+                            &Var::r8(*depth),+                            &Var::r8(0.0),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::r8(0.0174533),+                            &Var::r8(0.0174533),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(true),+                            &Var::boolean(true),+                            &Var::boolean(true),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::boolean(false),+                            &Var::i4(0),+                            &Var::r8(0.0),+                            &Var::boolean(false),+                        ],+                    )?;+                Self::clear_selection(&doc);+                Ok(json!({+                    "feature": f.as_dispatch().map(Disp).and_then(|d| d.string("Name", &[])),+                    "throughAll": through_all,+                    "depthMm": depth * 1000.0,+                    "proven": false,+                }))+            }++            Op::SetMaterial { name, database } => {+                let doc = self.resolve(&target)?;+                doc.call(+                    "SetMaterialPropertyName2",+                    &[&Var::bstr(""), &Var::bstr(database), &Var::bstr(name)],+                )?;+                Ok(json!({"material": name, "database": database, "current": Self::material_of(&doc, "")}))+            }++            Op::SetProp { name, value } => {+                let doc = self.resolve(&target)?;+                let mgr = doc+                    .obj("Extension", &[])?+                    .and_then(|e| e.obj("CustomPropertyManager", &[&Var::bstr("")]).ok().flatten())+                    .ok_or_else(|| HostError::msg("CustomPropertyManager unavailable"))?;+                // swCustomInfoText = 30; swCustomPropertyReplaceValue = 2+                let r = mgr.call(+                    "Add3",+                    &[&Var::bstr(name), &Var::i4(30), &Var::bstr(value), &Var::i4(2)],+                )?;+                Ok(json!({"property": name, "value": value, "code": r.as_i32()}))+            }++            Op::SaveAs { path } => {+                let doc = self.resolve(&target)?;+                // COPY mode, unlike the standalone swx_save_as verb's default.+                // A script step should put a FILE on disk, not silently retitle+                // the document it is in the middle of building — that is the+                // v0.2 rename bug wearing a different hat, and a script has no+                // obvious place for the caller to have consented to it.+                // swx_save_as {copy:false} remains the deliberate rename.+                if std::path::Path::new(path).exists() {+                    return Err(HostError::msg(format!(+                        "refusing to overwrite an existing file: {path}. A modelling script that \+                         silently replaces a file on disk is indistinguishable from one that \+                         destroys the user's work — choose a new name, or use swx_save_as, which \+                         is the verb where overwriting is an explicit act."+                    )));+                }+                let code = Self::save_as3(&doc, path, true)?;+                if code != 0 {+                    return Err(HostError::msg(format!(+                        "SOLIDWORKS refused to save {path}: {}",+                        Self::save_error_text(code)+                    )));+                }+                Ok(json!({+                    "savedAs": path,+                    "copy": true,+                    "bytes": std::fs::metadata(path).map(|m| m.len()).ok(),+                }))+            }++            Op::Rebuild => {+                let doc = self.resolve(&target)?;+                Ok(json!({"rebuilt": doc.call("EditRebuild3", &[])?.as_bool()}))+            }++            Op::ZoomFit => {+                let doc = self.resolve(&target)?;+                let _ = doc.call("ViewZoomtofit2", &[]);+                Ok(json!({"zoomedToFit": true}))+            }+        }+    }++    /// Select a plane by name and open a sketch on it. The five-argument legacy+    /// `SelectByID` is used deliberately: it is proven live here and needs no+    /// null callout argument, so there is one less thing to marshal wrong.+    fn open_sketch(doc: &Disp, plane: &str) -> Result<Disp, HostError> {+        // Start from a known-empty selection: SelectByID replaces the selection,+        // but anything the USER had selected before the script ran would+        // otherwise survive into the feature that consumes it, and whatever the+        // feature leaves selected would linger afterwards on their screen.+        let _ = doc.call("ClearSelection2", &[&Var::boolean(true)]);+        let selected =+            doc.call("SelectByID", &[&Var::bstr(plane), &Var::bstr("PLANE"), &Var::r8(0.0), &Var::r8(0.0), &Var::r8(0.0)])?+                .as_bool()+                .unwrap_or(false);+        if !selected {+            return Err(HostError::msg(format!(+                "no plane named '{plane}' in this document (the stock templates give you \+                 'Front Plane', 'Top Plane' and 'Right Plane')"+            )));+        }+        let sm = doc.obj("SketchManager", &[])?.ok_or_else(|| HostError::msg("no SketchManager"))?;+        sm.call("InsertSketch", &[&Var::boolean(true)])?;+        // Returned so the caller closes the SAME SketchManager it opened, and+        // can do so on the error path too.+        Ok(sm)+    }++    /// Close the open sketch. `InsertSketch(true)` toggles, and SOLIDWORKS+    /// leaves the finished sketch SELECTED — which is exactly what+    /// `FeatureExtrusion3` consumes, so no re-selection is needed (proven live).+    fn close_sketch(sm: &Disp) -> Result<(), HostError> {+        sm.call("InsertSketch", &[&Var::boolean(true)])?;+        Ok(())+    }++    /// Leave no selection behind. Called after a feature consumes its sketch, so+    /// the user does not come back to a part with something highlighted that+    /// they did not click.+    fn clear_selection(doc: &Disp) {+        let _ = doc.call("ClearSelection2", &[&Var::boolean(true)]);+    }+}++/// Preferences this bridge is willing to name, as (name, swUserPreferenceIntegerValue_e id).+/// Small on purpose: `swx_set_preference` reads every value back after writing+/// it, so anything listed here is something the bridge can PROVE it changed.+pub const PREFERENCES: &[(&str, i32)] = &[("lengthUnitRaw", 53), ("unitSystemRaw", 48)];