Fusion - the Fusion 360 Bridge

@@ -0,0 +1,93 @@+# CLAUDE.md - adom-desktop-fusion-bridge (READ THIS, it is YOUR project)++This repo is **the Adom Desktop Fusion 360 bridge**. If you are an Adom AI touching anything+Fusion, **you own and maintain this code.** You write it, version it, publish it, and reinstall it.+Stop treating bridge problems as someone else's. (This file exists because an AI repeatedly forgot+all of this and filed its own bridge bugs as "adom-desktop" requests. Don't.)++## You vs adom-desktop (AD) core - the boundary++- **AD core owns:** the `adom-desktop` CLI, the relay / command passthrough, bridge lifecycle+  (`bridge_install` / streaming the bridge from the wiki into `…\bridges-cache\fusion360`), and the+  core `desktop_*` verbs. That's it. AD just **hosts and loads** this bridge.+- **YOU (this bridge) own:** every `fusion_*` verb and its response `_hint`s, the **APS** integration+  (auth/config/quota - see below), the **Fusion add-in** code AND **deploying it into Fusion**, the+  `SKILL.md` + bundled `skills/`, and the edit → publish → reinstall loop.+- So: a `fusion_*` verb behaves wrong, a hint is missing, APS misbehaves, the add-in is stale → it's+  **your code**, fix it here and republish. It is NOT an adom-desktop request.++## Map of what you manage++- `server.py` - bridge server / verb router (talks to AD's relay, proxies to the add-in). **On start+  it calls `install_addin()`** to deploy the add-in (see deploy below).+- `aps.py` - the **entire APS** implementation: PKCE OAuth, token store, server-indexed cloud search,+  never-charge cap. **All APS is yours** (the `fusion_aps_*` verbs + `fusion_search_cloud_files` /+  `fusion_walk_cloud_tree`). NOTE: port **8910 is AD's vestigial "native" APS** - NOT yours; this+  bridge uses **8917/8918/8920** and steers around it. The bare `aps_status` (8910) is that AD stub,+  not this bridge's `fusion_aps_status`.+- `addin/AdomBridge/` - the add-in that runs **inside Fusion**: `AdomBridge.py`, `http_server.py`,+  `commands/*.py` (cloud_documents, open_electronics_file, electronics, export, modeling,+  manufacturing, screenshot, document_info, parameters, …).+- `describe.py` - the `fusion_describe` self-describe catalog (AD's Verbs tab).+- `handlers/` - close / recovery / dialog-classify / UI / open_design.+- `skills/` - bundled skills you ship: `fusion-aps-search`, `fusion-aps-signin`, `fusion-bridge-dev`,+  `fusion-onboarding`. `resources/` - JLCPCB CAM jobs, Adom DRU rules, the layer-detect ULP.+- `bridge.json` + `BRIDGE_VERSION` - the manifest/version (keep in lockstep).++## How you DEPLOY when you change your code (VERIFIED by watching v1.5.1 ship, 2026-06-28)++Fusion loads the add-in from **`%APPDATA%\Roaming\Autodesk\Autodesk Fusion[ 360]\API\AddIns\AdomBridge\`**,+NOT from this repo or the cache. `install_addin.py` (`_sync_directory`) copies `addin/AdomBridge` ->+there. The exact, watched-it-happen release sequence (AFTER publishing to the wiki):++1. **`bridge_install {"manifestUrl": ".../adom-bridge-fusion-manifest.json"}`** - streams the new zip+   into the CACHE via `method: in_place_merge`. Updates the cache ONLY; it does NOT touch Fusion's+   AddIns dir. (Pass `"force": true` to re-merge when the version already bumped.)+   Do NOT manually `bridge_kill` - `bridge_install`'s own output says "AD reaps + respawns it from the+   new cache on the next call (no manual kill needed)," so the bridge SERVER (new server.py/describe.py)+   reloads automatically on the next verb. (Running `bridge_kill` here is pointless.)+2. **`fusion_stop`** (graceful; `fusion_kill` if it is wedged) - REQUIRED. Fusion holds the add-in files+   OPEN, so the sync canNOT overwrite them while Fusion runs. (This is why a bridge-server respawn alone+   does NOT update the add-in, and why `fusion_stop`+`fusion_start` by itself deploys nothing.)+3. Run the cache's **`install_addin.py`**: `shell_execute` -> `cd <cache>\fusion360 && python install_addin.py`.+   It prints `Updated: commands\cloud_documents.py ...` and removes stale `.bak`s - that is the add-in+   actually landing in Roaming.+4. **Verify by SHA256, never findstr.** `(Get-FileHash <Roaming>\commands\cloud_documents.py).Hash`+   must equal `sha256sum` of that same file unzipped from the published `v<ver>.zip`. findstr gives+   FALSE NEGATIVES on these files (UTF-8 box-drawing / dash chars break it) - it told me the reprimand+   was missing when the file was byte-identical to the release. Do not trust findstr; hash or+   `Get-Content -Raw` regex only.+5. **`fusion_start`** - Fusion now loads the new add-in. Confirm a `fusion_*` verb behaves new.++Memorize:+- `bridge_install` bumping `BRIDGE_VERSION` to the new version does NOT mean the running add-in changed.+  The version marker moves independently of the Roaming sync. Always hash-verify (step 5).+- The add-in sync only takes effect with **Fusion closed** (step 3). Skipping that is the #1 way a+  "successful" install leaves the OLD add-in running.+- **Never hand-edit the cache or the Roaming copy.** They get clobbered on the next stream/sync. Edit+  THIS source, publish, then run the sequence above.++## The publish/reinstall loop++See `skills/fusion-bridge-dev/SKILL.md` for the full ritual. Short form: edit here → bump+`BRIDGE_VERSION` + `bridge.json` together → `git commit` → **push GitHub backup** + **publish to the+wiki** (`wiki.adom.inc/adom/adom-desktop-fusion-bridge`, the canonical repo) → `bridge_install` on the+box → reap the old bridge instance + restart so the new code (and synced add-in) loads → anon-verify.+Wiki = canonical, GitHub = backup, keep in lockstep.++## Fusion electronics file hierarchy (the other thing you kept getting wrong)++A Fusion electronics design is a **parent/child chain of separate files**, each a distinct+`productType`. **ALWAYS open the PROJECT; never the schematic/.brd/3D directly.**++```+PROJECT        EcadDesignProductType    <- open THIS+  |- schematic   SchematicProductType+  |- board/.brd  BoardProductType+  |- 3D PCB      DesignProductType       (generated FROM the .brd - the LEAF; no editable board)+```++Opening a child gives an isolated/empty view (you can't pull a board out of the 3D). Same-named+copies in OTHER projects are usually 3D-model derivatives (`DesignProductType`), not the project.+The open verbs (`handle_open_cloud_file` / `handle_open_by_urn`) reprimand via `_hint` when you open+a non-`EcadDesignProductType` file - read it.

@@ -0,0 +1,109 @@+"""Adom Bridge — Fusion 360 Add-In.++Starts a localhost HTTP server on a background thread (port 8774).+Incoming commands are marshaled to the main Fusion thread via a CustomEvent,+so all Fusion API calls execute safely on the main thread.+"""++import adsk.core+import adsk.fusion+import traceback++# Module-level references kept alive for the add-in lifetime+_app = None+_ui = None+_custom_event = None+_event_handler = None+_http_thread = None++CUSTOM_EVENT_ID = "AdomBridgeCommandEvent"+++class CommandEventHandler(adsk.core.CustomEventHandler):+    """Handles custom events fired from the HTTP background thread.++    Each event's additionalInfo is a JSON string with {request_id, command, args}.+    The handler dispatches to the appropriate command function, then stores+    the result so the HTTP thread can return it.+    """++    def __init__(self):+        super().__init__()++    def notify(self, args: adsk.core.CustomEventArgs):+        try:+            import json+            from . import http_server+            from .commands import dispatch_command++            info = json.loads(args.additionalInfo)+            request_id = info["request_id"]+            command = info["command"]+            cmd_args = info.get("args", {})++            # Staleness check: if the HTTP waiter already timed out and+            # bailed, skip the work entirely. Saves main-thread time on+            # heavy exports whose caller already gave up.+            if not http_server.is_request_alive(request_id):+                adsk.core.Application.log(+                    f"AdomBridge: skipping stale request {request_id[:8]} ({command}) — HTTP waiter gone"+                )+                return++            try:+                result = dispatch_command(_app, command, cmd_args)+            except Exception as e:+                result = {"success": False, "error": f"Command error: {e}\n{traceback.format_exc()}"}++            http_server.set_result(request_id, result)++        except Exception:+            traceback.print_exc()+++def run(context):+    """Called by Fusion 360 when the add-in starts."""+    global _app, _ui, _custom_event, _event_handler, _http_thread++    try:+        _app = adsk.core.Application.get()+        _ui = _app.userInterface++        # Register the custom event for thread marshaling+        _custom_event = _app.registerCustomEvent(CUSTOM_EVENT_ID)+        _event_handler = CommandEventHandler()+        _custom_event.add(_event_handler)++        # Start the HTTP server on a background daemon thread+        from . import http_server+        _http_thread = http_server.start(CUSTOM_EVENT_ID, _app)++        # Log to the Text Commands palette (non-blocking)+        adsk.core.Application.log(f"Adom Bridge add-in started (port 8774)")++    except Exception:+        # Only use messageBox for errors — worth blocking to show the user+        if _ui:+            _ui.messageBox(f"Adom Bridge failed to start:\n{traceback.format_exc()}")+++def stop(context):+    """Called by Fusion 360 when the add-in stops."""+    global _app, _ui, _custom_event, _event_handler, _http_thread++    try:+        # Stop HTTP server+        from . import http_server+        http_server.stop()++        # Unregister custom event+        if _app and _custom_event:+            _app.unregisterCustomEvent(CUSTOM_EVENT_ID)++        _custom_event = None+        _event_handler = None+        _http_thread = None++    except Exception:+        if _ui:+            _ui.messageBox(f"Adom Bridge stop error:\n{traceback.format_exc()}")

@@ -0,0 +1,139 @@+"""Command dispatch for the Adom Bridge Fusion 360 add-in."""++import adsk.core++from .app_state import handle_get_app_state+from .document_info import handle_document_info, handle_activate_document+from .export import (+    handle_export_step, handle_export_stl, handle_export_3mf,+    handle_export_f3d, handle_export_usdz, handle_export_fbx,+    handle_export_dxf, handle_export_dwg, handle_export_iges,+    handle_export_obj, handle_export_sat, handle_export_skp,+)+from .design_info import handle_get_design_info+from .electronics import (+    handle_electron_run,+    handle_execute_text_command,+    handle_export_source,+    handle_export_eagle_source,+    handle_open_electronics,+    handle_list_text_commands,+    handle_board_info,+)+from .electron_view import handle_electron_zoom, handle_electron_pan, handle_electron_select+from .open_lbr import handle_open_lbr, handle_export_lbr+from .import_file import handle_import_file+from .parameters import handle_get_parameters, handle_set_parameter+from .screenshot import handle_take_screenshot+from .close_document import handle_close_document, handle_close_all_documents+from .open_electronics_file import handle_open_schematic, handle_open_board, handle_show_3d_board, handle_show_2d_board, handle_show_schematic, handle_import_electronics+from .cloud_documents import (+    handle_save_to_cloud,+    handle_list_cloud_projects,+    handle_list_cloud_files,+    handle_delete_cloud_file,+    handle_create_cloud_folder,+    handle_open_cloud_file,+    handle_open_by_urn,+    handle_search_cloud_files,+    handle_export_cloud_file,+    handle_check_recovery,+    handle_walk_cloud_tree,+)+from .manufacturing import (+    handle_export_bom,+    handle_export_cpl,+    handle_export_gerbers,+    handle_set_design_rules,+    handle_export_board_image,+    handle_detect_layers,+)+from .silkscreen_capture import handle_take_silkscreen_screenshot+from .modeling import handle_run_modeling_script++COMMAND_HANDLERS = {+    # App state+    "get_app_state": handle_get_app_state,+    "document_info": handle_document_info,+    "activate_document": handle_activate_document,+    # 3D CAD commands+    "import_file": handle_import_file,+    "export_step": handle_export_step,+    "export_stl": handle_export_stl,+    "export_3mf": handle_export_3mf,+    "export_f3d": handle_export_f3d,+    "export_usdz": handle_export_usdz,+    "export_fbx": handle_export_fbx,+    "export_dxf": handle_export_dxf,+    "export_dwg": handle_export_dwg,+    "export_iges": handle_export_iges,+    "export_obj": handle_export_obj,+    "export_sat": handle_export_sat,+    "export_skp": handle_export_skp,+    "get_design_info": handle_get_design_info,+    "get_parameters": handle_get_parameters,+    "set_parameter": handle_set_parameter,+    "take_screenshot": handle_take_screenshot,+    # Electronics commands (EAGLE via Electron.run)+    "electron_run": handle_electron_run,+    "electron_zoom": handle_electron_zoom,+    "electron_pan": handle_electron_pan,+    "electron_select": handle_electron_select,+    "execute_text_command": handle_execute_text_command,+    "open_electronics": handle_open_electronics,+    "list_text_commands": handle_list_text_commands,+    "board_info": handle_board_info,+    "export_source": handle_export_source,+    "export_eagle_source": handle_export_eagle_source,+    # Library file commands (Document.Open / EXPORT SCRIPT)+    "open_lbr": handle_open_lbr,+    "export_lbr": handle_export_lbr,+    # Document management+    "close_document": handle_close_document,+    "close_all_documents": handle_close_all_documents,+    # Electronics file opening+    "open_schematic": handle_open_schematic,+    "open_board": handle_open_board,+    "show_3d_board": handle_show_3d_board,+    "show_2d_board": handle_show_2d_board,+    "show_schematic": handle_show_schematic,+    "import_electronics": handle_import_electronics,+    # Cloud document management+    "save_to_cloud": handle_save_to_cloud,+    "list_cloud_projects": handle_list_cloud_projects,+    "list_cloud_files": handle_list_cloud_files,+    "delete_cloud_file": handle_delete_cloud_file,+    "create_cloud_folder": handle_create_cloud_folder,+    "open_cloud_file": handle_open_cloud_file,+    "open_by_urn": handle_open_by_urn,+    "check_recovery": handle_check_recovery,+    "search_cloud_files": handle_search_cloud_files,+    "walk_cloud_tree": handle_walk_cloud_tree,+    "export_cloud_file": handle_export_cloud_file,+    # Manufacturing exports (Gerbers, BOM, CPL, DRC, images)+    "export_bom": handle_export_bom,+    "export_cpl": handle_export_cpl,+    "export_gerbers": handle_export_gerbers,+    "set_design_rules": handle_set_design_rules,+    "export_board_image": handle_export_board_image,+    "detect_layers": handle_detect_layers,+    # Silkscreen layer capture (isolated top/bottom PNG)+    "take_silkscreen_screenshot": handle_take_silkscreen_screenshot,+    # In-app parametric modeling (free; runs adsk.fusion in the live session)+    "run_modeling_script": handle_run_modeling_script,+}+++def dispatch_command(app: adsk.core.Application, command: str, args: dict) -> dict:+    """Dispatch a command to the appropriate handler.++    All handlers receive the Fusion Application object and an args dict.+    """+    handler = COMMAND_HANDLERS.get(command)+    if handler is None:+        return {+            "success": False,+            "error": f"Unknown add-in command: {command}",+            "_hint": f"Valid add-in commands: {', '.join(sorted(COMMAND_HANDLERS.keys()))}.",+        }+    return handler(app, args)

@@ -0,0 +1,127 @@+"""App state command — list open documents, active workspace, and Fusion state."""++import adsk.core+++def handle_get_app_state(app: adsk.core.Application, args: dict) -> dict:+    """Get the current state of Fusion 360: open documents, active workspace, etc.++    Returns information about every open document/tab, which one is active,+    the current workspace, and product type.+    """+    # Active workspace+    active_workspace = "unknown"+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+        if ws:+            active_workspace = ws.strip()+    except Exception:+        pass++    # Check if Electronics editor is active+    is_electronics = False+    try:+        app.executeTextCommand("Electron.run DISPLAY")+        is_electronics = True+    except Exception:+        pass++    # Active document+    active_doc_name = None+    try:+        doc = app.activeDocument+        if doc:+            active_doc_name = doc.name+    except Exception:+        pass++    # Active product type+    product_type = None+    try:+        product = app.activeProduct+        if product:+            product_type = product.productType+    except Exception:+        pass++    # All open documents+    documents = []+    try:+        for i in range(app.documents.count):+            doc = app.documents.item(i)+            doc_info = {+                "name": doc.name,+                "isActive": (doc.name == active_doc_name) if active_doc_name else False,+            }++            # documentType may not exist on all document types+            try:+                doc_info["type"] = _document_type_name(doc.documentType)+            except Exception:+                doc_info["type"] = "unknown"++            # isSaved may not be available on all document types+            try:+                doc_info["isSaved"] = doc.isSaved+            except Exception:+                pass++            # Try to get data file info (cloud save path)+            try:+                df = doc.dataFile+                if df:+                    doc_info["dataFile"] = {+                        "name": df.name,+                        "id": df.id,+                    }+                    try:+                        doc_info["dataFile"]["parentFolder"] = df.parentFolder.name+                    except Exception:+                        pass+            except Exception:+                pass++            documents.append(doc_info)+    except Exception as e:+        documents = [{"error": f"Failed to enumerate documents: {e}"}]++    # Build context-aware hint+    hints = []+    if is_electronics:+        hints.append("Electronics workspace active — fusion_electron_run, fusion_board_info, "+                      "fusion_export_source, fusion_export_eagle_source are available.")+    else:+        hints.append("Not in Electronics workspace. Use fusion_show_2d_board to enter board view, "+                      "or fusion_open_cloud_file to open an electronics project (.fprj).")+    hints.append("Check fusion_window_info for blocking dialogs before running commands.")+    hint = " ".join(hints)++    return {+        "success": True,+        "output": f"{len(documents)} document(s) open, active workspace: {active_workspace}",+        "data": {+            "activeWorkspace": active_workspace,+            "activeDocument": active_doc_name,+            "productType": product_type,+            "isElectronics": is_electronics,+            "documents": documents,+        },+        "_hint": hint,+    }+++def _document_type_name(doc_type) -> str:+    """Convert a DocumentType enum to a readable string."""+    type_map = {+        0: "FusionDesign",+        1: "FusionDesign",  # DesignDocumentType+        2: "Drawing",+        3: "Electronics",+        4: "PCB",+    }+    # The enum value might be an int or an enum object+    try:+        val = int(doc_type)+        return type_map.get(val, f"Unknown({val})")+    except (TypeError, ValueError):+        return str(doc_type)

@@ -0,0 +1,152 @@+"""Close document command — close a Fusion 360 document without the save dialog."""++import adsk.core+++def handle_close_document(app: adsk.core.Application, args: dict) -> dict:+    """Close a document in Fusion 360 without triggering the save dialog.++    Args (all optional):+        name: Name of the document to close. If omitted, closes the active document.+        save: If True, save before closing. Default False (discard changes, no dialog).++    This is essential for automation — a normal close triggers a modal save dialog+    that blocks the Fusion main thread and hangs the add-in until the user clicks.+    """+    target_name = args.get("name")+    save_changes = args.get("save", False)++    try:+        if target_name:+            # Find the document by name+            doc = None+            for i in range(app.documents.count):+                d = app.documents.item(i)+                if d.name == target_name:+                    doc = d+                    break+            if doc is None:+                # List available docs for a helpful error+                available = [app.documents.item(i).name for i in range(app.documents.count)]+                return {+                    "success": False,+                    "error": f"Document '{target_name}' not found. Open documents: {available}",+                    "_hint": "Call fusion_document_info to list open documents, or use fusion_close_document with no name to close the active document.",+                }+        else:+            # Close the active document+            doc = app.activeDocument+            if doc is None:+                return {+                    "success": False,+                    "error": "No active document to close.",+                    "_hint": "Call fusion_document_info to check open documents — nothing is currently active.",+                }++        doc_name = doc.name++        # Check if document has unsaved changes (for reporting)+        is_saved = True+        try:+            is_saved = doc.isSaved+        except Exception:+            pass++        # Close the document. Passing False skips the save dialog entirely.+        doc.close(save_changes)++        remaining = app.documents.count+        new_active = None+        try:+            if app.activeDocument:+                new_active = app.activeDocument.name+        except Exception:+            pass++        return {+            "success": True,+            "output": f"Closed '{doc_name}' (save={save_changes}, had_unsaved={'yes' if not is_saved else 'no'}). {remaining} document(s) remaining.",+            "data": {+                "closedDocument": doc_name,+                "savedBeforeClose": save_changes,+                "hadUnsavedChanges": not is_saved,+                "remainingDocuments": remaining,+                "activeDocument": new_active,+            },+            "_hint": f"{remaining} document(s) still open."+                     + (f" Active: '{new_active}'. " if new_active else " No active document. ")+                     + "Use fusion_get_app_state to check workspace, or fusion_open_cloud_file to open another document.",+        }++    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to close document: {e}",+            "_hint": "Retry with {\"save\": false} to discard changes, or call fusion_screenshot_fusion to check for a blocking Save dialog and dismiss it with fusion_send_key.",+        }+++def handle_close_all_documents(app: adsk.core.Application, args: dict) -> dict:+    """Close ALL open documents without save dialogs.++    Closes every open document/tab in Fusion without triggering any save+    dialogs. Essential before restarting Fusion to avoid the 'Recovered+    Documents' modal on next launch.++    Args (all optional):+        save: If True, save each document before closing. Default False.+    """+    save_changes = args.get("save", False)++    closed = []+    errors = []+    skipped = []++    # Snapshot the current document list ONCE. Do NOT loop on app.documents.count,+    # because Fusion may auto-create an Untitled blank doc whenever all docs close,+    # which turns `while count > 0` into an infinite loop and times out the bridge.+    try:+        snapshot = []+        for i in range(app.documents.count):+            d = app.documents.item(i)+            snapshot.append(d)+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to enumerate documents: {e}",+            "_hint": "Retry with {\"save\": false} to discard changes, or call fusion_screenshot_fusion to check for a blocking Save dialog and dismiss it with fusion_send_key.",+        }++    for doc in snapshot:+        try:+            doc_name = doc.name+        except Exception:+            doc_name = "<unknown>"+        try:+            # Skip Untitled blank docs — Fusion recreates them, closing is pointless+            has_data_file = False+            try:+                has_data_file = doc.dataFile is not None+            except Exception:+                has_data_file = False+            if not has_data_file and doc_name.lower().startswith("untitled"):+                skipped.append(doc_name)+                continue+            doc.close(save_changes)+            closed.append(doc_name)+        except Exception as e:+            errors.append(f"{doc_name}: {e}")+            # Keep going — don't abort the whole batch on one failure++    return {+        "success": len(errors) == 0,+        "output": f"Closed {len(closed)} document(s)"+                  + (f", skipped {len(skipped)} Untitled" if skipped else "")+                  + (f", {len(errors)} error(s)" if errors else ""),+        "data": {+            "closed": closed,+            "skipped": skipped if skipped else None,+            "errors": errors if errors else None,+            "remainingDocuments": app.documents.count,+        },+    }

@@ -0,0 +1,1880 @@+"""Cloud document management for Fusion 360.++Provides commands to save documents to Autodesk's cloud hub,+list cloud projects and files, and delete cloud files.++Uses the Fusion Data API (app.data) which requires the user+to be signed in to their Autodesk account.++Key concepts:+  - Hub: The team/organization account (e.g., "Adom")+  - Project: A folder-like container in the hub (e.g., "Personal", "Main")+  - DataFolder: Subfolder within a project+  - DataFile: A cloud-stored document with URN, version history, etc.+  - wip_urn: The version-specific URN used by Electronics libraries+             to reference 3D package models (e.g., urn:adsk.wipprod:fs.file:vf.xxx?version=1)+"""++import adsk.core+import adsk.fusion+import os+import threading+import time++# Walk/search progress state — updated by BFS loop on main thread,+# read by health endpoint on HTTP thread.+_walk_progress_lock = threading.Lock()+_walk_progress = None  # None when no walk/search is active+++def get_walk_progress():+    """Return a snapshot of the current walk/search progress, or None."""+    with _walk_progress_lock:+        if _walk_progress is None:+            return None+        return dict(_walk_progress)+++RESOLVE_PROJECT_TIMEOUT = 60  # seconds — overall wall-clock for hub/project enumeration+++def _resolve_project(app, project_name=None):+    """Find a cloud project by name. Defaults to active project.++    Robustness:+      - Every per-hub / per-project access wrapped in try/except so a single+        bad hub or project can't crash the resolve.+      - adsk.doEvents() yields between hubs so the UI stays responsive.+      - Overall wall-clock cap (RESOLVE_PROJECT_TIMEOUT). On expired/trial+        subscriptions the cloud Data API can take 30s+ per hub; cap the+        total so a hung lookup returns an actionable error instead of+        hanging Fusion's main thread indefinitely.+    """+    data = app.data+    if not data:+        return None, "Fusion Data API not available. Are you signed in?"++    if not project_name:+        try:+            proj = data.activeProject+        except Exception as e:+            return None, f"activeProject lookup failed: {e}"+        if proj:+            return proj, None+        return None, "No active project"++    needle = project_name.lower()+    started = time.time()++    # Search all hubs for the named project. Each hub.dataProjects access+    # is a network round-trip on the cloud Data API; wrap in try/except so+    # one bad hub doesn't take down the whole search.+    try:+        hubs = data.dataHubs+        hub_count = hubs.count+    except Exception as e:+        return None, f"Failed to enumerate hubs: {e}"++    for i in range(hub_count):+        if time.time() - started > RESOLVE_PROJECT_TIMEOUT:+            try:+                adsk.core.Application.log(+                    f"AdomBridge: _resolve_project hit timeout ({RESOLVE_PROJECT_TIMEOUT}s) "+                    f"at hub {i}/{hub_count} searching for '{project_name}'"+                )+            except Exception:+                pass+            return None, (+                f"Project lookup timed out after {RESOLVE_PROJECT_TIMEOUT}s "+                f"(searched {i}/{hub_count} hubs). Cloud API may be slow or "+                f"unavailable."+            )+        try:+            hub = hubs.item(i)+        except Exception:+            continue+        try:+            projects = hub.dataProjects+            proj_count = projects.count+        except Exception:+            continue+        for j in range(proj_count):+            try:+                proj = projects.item(j)+                if proj.name.lower() == needle:+                    return proj, None+            except Exception:+                continue+        # Yield between hubs so the UI stays responsive even when the+        # team has many hubs / projects.+        try:+            adsk.doEvents()+        except Exception:+            pass++    return None, f"Project '{project_name}' not found"+++def _resolve_folder(project, folder_path=None):+    """Navigate to a subfolder within a project. Returns root folder if no path given.++    Robustness: each `dataFolders.item(i).name` access is wrapped in+    try/except so a single corrupted subfolder doesn't crash navigation.+    """+    try:+        folder = project.rootFolder+    except Exception as e:+        return None, f"rootFolder lookup failed: {e}"+    if not folder_path:+        return folder, None++    parts = [p.strip() for p in folder_path.replace("\\", "/").split("/") if p.strip()]+    for part in parts:+        needle = part.lower()+        found = False+        try:+            subfolders = folder.dataFolders+            sub_count = subfolders.count+        except Exception as e:+            return None, f"dataFolders lookup failed for '{folder.name}': {e}"+        for i in range(sub_count):+            try:+                sf = subfolders.item(i)+                if sf.name.lower() == needle:+                    folder = sf+                    found = True+                    break+            except Exception:+                continue+        if not found:+            return None, f"Folder '{part}' not found in '{folder.name}'"++    return folder, None+++def handle_save_to_cloud(app: adsk.core.Application, args: dict) -> dict:+    """Save the active Fusion document to the cloud.++    Args:+        args: Dict with:+            - name: Name for the cloud document (required).+            - projectName: Target project name (optional, defaults to active project).+            - folderPath: Subfolder path within the project (optional, defaults to root).+            - description: Document description (optional).+    """+    name = args.get("name", "").strip()+    if not name:+        return {"success": False, "error": "No name specified. Provide a name for the cloud document."}++    doc = app.activeDocument+    if not doc:+        return {+            "success": False,+            "error": "No active document to save.",+            "_hint": "Call fusion_open_cloud_file or fusion_import_file first to have an active document, then retry.",+        }++    project_name = args.get("projectName", "")+    folder_path = args.get("folderPath", "")+    description = args.get("description", "")++    project, err = _resolve_project(app, project_name or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see available project names, then retry with a valid projectName.",+        }++    folder, err = _resolve_folder(project, folder_path or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_files with this projectName to see valid folderPath values, or call fusion_create_cloud_folder to create it.",+        }++    try:+        result = doc.saveAs(name, folder, description, "")+    except Exception as e:+        return {+            "success": False,+            "error": f"saveAs failed: {e}",+            "data": {"hint": "The document may already exist with this name, or you may lack permissions."},+        }++    if not result:+        return {"success": False, "error": "saveAs returned False. The save may have failed."}++    # Collect saved file info+    response_data = {+        "name": name,+        "project": project.name,+        "folder": folder.name,+        "documentName": doc.name,+        "isSaved": doc.isSaved,+    }++    df = doc.dataFile+    if df:+        response_data["fileId"] = df.id+        try:+            response_data["versionId"] = df.versionId+        except Exception:+            pass+        try:+            response_data["versionNumber"] = df.versionNumber+        except Exception:+            pass+        # The wip_urn format used by Electronics libraries for 3D packages+        if df.id and "wipprod" in df.id:+            response_data["wipUrn"] = df.id++    return {+        "success": True,+        "output": f"Saved '{name}' to project '{project.name}'",+        "data": response_data,+    }+++def handle_list_cloud_projects(app: adsk.core.Application, args: dict) -> dict:+    """List all cloud projects in the user's hub(s).++    Robustness (v1.0.2):+      - Per-hub / per-project try/except so a single bad item doesn't kill+        the whole listing.+      - adsk.doEvents() between hubs to keep the UI responsive.+      - Overall wall-clock cap of LIST_PROJECTS_TIMEOUT seconds.+      - Progress logged via Application.log so a slow listing is visible.++    Args:+        args: Dict (no required args).+    """+    data = app.data+    if not data:+        return {+            "success": False,+            "error": "Fusion Data API not available. Are you signed in?",+            "_hint": "Report to the user and ask them to sign into their Autodesk account in Fusion 360, then retry.",+        }++    LIST_PROJECTS_TIMEOUT = 90  # seconds — overall wall-clock cap+    started = time.time()+    list_timed_out = False++    hubs_data = []+    try:+        hubs = data.dataHubs+        hub_count = hubs.count+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to enumerate hubs: {e}",+            "_hint": "Cloud Data API may be unavailable. Verify sign-in status in Fusion (Help → About / sign-in icon).",+        }++    for i in range(hub_count):+        if time.time() - started > LIST_PROJECTS_TIMEOUT:+            list_timed_out = True+            try:+                adsk.core.Application.log(+                    f"AdomBridge: list_cloud_projects timed out at hub {i}/{hub_count}"+                )+            except Exception:+                pass+            break++        try:+            hub = hubs.item(i)+            hub_name = hub.name+            hub_id = hub.id+        except Exception:+            continue++        try:+            adsk.core.Application.log(+                f"AdomBridge: list_cloud_projects hub [{i+1}/{hub_count}] '{hub_name}'"+            )+        except Exception:+            pass++        projects_list = []+        try:+            projects = hub.dataProjects+            proj_count = projects.count+        except Exception:+            # Couldn't enumerate this hub's projects — still report the hub+            hubs_data.append({"name": hub_name, "id": hub_id, "projects": [], "_error": "dataProjects enumeration failed"})+            continue++        for j in range(proj_count):+            try:+                proj = projects.item(j)+                proj_info = {+                    "name": proj.name,+                    "id": proj.id,+                }+            except Exception:+                continue+            try:+                rf = proj.rootFolder+                if rf:+                    proj_info["rootFolderId"] = rf.id+            except Exception:+                pass+            projects_list.append(proj_info)++        hubs_data.append({+            "name": hub_name,+            "id": hub_id,+            "projects": projects_list,+        })++        # Yield between hubs+        try:+            adsk.doEvents()+        except Exception:+            pass++    # Also note the active project (safely)+    try:+        active_proj = data.activeProject+        active_name = active_proj.name if active_proj else "none"+    except Exception:+        active_name = "(lookup failed)"++    total = sum(len(h["projects"]) for h in hubs_data)+    elapsed = round(time.time() - started, 1)+    return {+        "success": True,+        "output": f"Found {total} projects across {len(hubs_data)} hub(s). Active: {active_name}"+                  f"{' (listing timed out, partial)' if list_timed_out else ''}",+        "data": {+            "activeProject": active_name,+            "hubs": hubs_data,+            "elapsedSeconds": elapsed,+            "listTimedOut": list_timed_out,+        },+        "_hint": "Use fusion_list_cloud_files with a projectName from this list to browse folders. "+                 "Use fusion_walk_cloud_tree for deep recursive search with filters.",+    }+++LIST_FILES_TIMEOUT = 60  # seconds — overall wall-clock cap+++def handle_list_cloud_files(app: adsk.core.Application, args: dict) -> dict:+    """List files in a cloud project/folder.++    Robustness (v1.0.2):+      - Per-file / per-subfolder try/except so a single corrupted item+        doesn't kill the whole listing.+      - adsk.doEvents() every 50 files to keep Fusion's UI responsive on+        folders containing thousands of files.+      - Overall wall-clock cap (LIST_FILES_TIMEOUT). Returns partial+        results with listTimedOut=true instead of hanging.++    Args:+        args: Dict with:+            - projectName: Project name (optional, defaults to active project).+            - folderPath: Subfolder path (optional, defaults to root folder).+    """+    project_name = args.get("projectName", "")+    folder_path = args.get("folderPath", "")++    project, err = _resolve_project(app, project_name or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see valid project names.",+        }++    folder, err = _resolve_folder(project, folder_path or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_files with this projectName to see valid folderPath values.",+        }++    started = time.time()+    list_timed_out = False+    files_skipped = 0+    files_list = []++    try:+        try:+            adsk.core.Application.log(+                f"AdomBridge: list_cloud_files '{folder_path or '(root)'}' in '{project.name}'"+            )+        except Exception:+            pass++        try:+            data_files = folder.dataFiles+            file_count = data_files.count+        except Exception as e:+            return {+                "success": False,+                "error": f"Failed to enumerate files: {e}",+                "_hint": "Call fusion_get_app_state to verify sign-in status; Autodesk cloud session may have expired. If so, the user must sign in via the Fusion UI.",+            }++        for i in range(file_count):+            # Yield every 50 files+            if i > 0 and i % 50 == 0:+                try:+                    adsk.doEvents()+                except Exception:+                    pass+            # Wall-clock cap+            if time.time() - started > LIST_FILES_TIMEOUT:+                list_timed_out = True+                try:+                    adsk.core.Application.log(+                        f"AdomBridge: list_cloud_files hit timeout at file {i}/{file_count}"+                    )+                except Exception:+                    pass+                break++            # Per-item try/except — a single corrupt/deleting file shouldn't+            # break the whole listing.+            try:+                df = data_files.item(i)+            except Exception:+                files_skipped += 1+                continue+            try:+                file_info = {"name": df.name}+            except Exception:+                files_skipped += 1+                continue+            try:+                file_info["id"] = df.id+            except Exception:+                pass+            try:+                file_info["versionNumber"] = df.versionNumber+            except Exception:+                pass+            try:+                file_info["versionId"] = df.versionId+            except Exception:+                pass+            try:+                file_info["fileExtension"] = df.fileExtension+            except Exception:+                pass+            try:+                file_info["dateModified"] = str(df.dateModified)+            except Exception:+                pass+            files_list.append(file_info)+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to list files: {e}",+            "_hint": "Call fusion_get_app_state to verify sign-in status; Autodesk cloud session may have expired. If so, the user must sign in via the Fusion UI.",+        }++    # Also list subfolders (per-item resilient)+    subfolders = []+    folders_skipped = 0+    try:+        folders = folder.dataFolders+        for i in range(folders.count):+            if time.time() - started > LIST_FILES_TIMEOUT:+                list_timed_out = True+                break+            try:+                sf = folders.item(i)+                subfolders.append({"name": sf.name, "id": sf.id})+            except Exception:+                folders_skipped += 1+                continue+    except Exception:+        pass++    return {+        "success": True,+        "output": f"Found {len(files_list)} files and {len(subfolders)} folders in '{folder.name}' (project: {project.name})"+                  f"{' [listing timed out, partial]' if list_timed_out else ''}",+        "data": {+            "project": project.name,+            "folder": folder.name,+            "files": files_list,+            "subfolders": subfolders,+            "elapsedSeconds": round(time.time() - started, 1),+            "filesSkipped": files_skipped,+            "foldersSkipped": folders_skipped,+            "listTimedOut": list_timed_out,+        },+    }+++def handle_delete_cloud_file(app: adsk.core.Application, args: dict) -> dict:+    """Delete a file from the cloud by name.++    Searches the specified project/folder for the file and deletes it.++    Args:+        args: Dict with:+            - fileName: Name of the file to delete (required).+            - projectName: Project name (optional, defaults to active project).+            - folderPath: Subfolder path (optional, defaults to root folder).+    """+    file_name = args.get("fileName", "").strip()+    if not file_name:+        return {"success": False, "error": "No fileName specified."}++    project_name = args.get("projectName", "")+    folder_path = args.get("folderPath", "")++    project, err = _resolve_project(app, project_name or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see valid project names.",+        }++    folder, err = _resolve_folder(project, folder_path or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_files with this projectName to see valid folderPath values.",+        }++    # Find the file (per-item resilient, with yield + timeout)+    target = None+    started = time.time()+    needle = file_name.lower()+    try:+        try:+            data_files = folder.dataFiles+            file_count = data_files.count+        except Exception as e:+            return {"success": False, "error": f"Failed to enumerate files in '{folder.name}': {e}"}+        for i in range(file_count):+            if i > 0 and i % 50 == 0:+                try:+                    adsk.doEvents()+                except Exception:+                    pass+            if time.time() - started > FIND_FILE_TIMEOUT:+                return {+                    "success": False,+                    "error": f"File lookup timed out after {FIND_FILE_TIMEOUT}s "+                             f"(scanned {i}/{file_count} files in '{folder.name}')",+                    "_hint": "Folder may be too large; provide a more specific folderPath, "+                             "or use fusion_walk_cloud_tree with maxFolders + nameContains.",+                }+            try:+                df = data_files.item(i)+                if df.name.lower() == needle:+                    target = df+                    break+            except Exception:+                continue+    except Exception as e:+        return {"success": False, "error": f"Failed to search files: {e}"}++    if not target:+        return {+            "success": False,+            "error": f"File '{file_name}' not found in '{folder.name}' (project: {project.name})",+            "_hint": "Call fusion_walk_cloud_tree to locate the file, or fusion_list_cloud_files to list what's in the folder.",+        }++    file_id = target.id+    try:+        target.deleteMe()+    except Exception as e:+        return {+            "success": False,+            "error": f"Delete failed: {e}",+            "data": {"hint": "You may lack permissions to delete this file."},+        }++    return {+        "success": True,+        "output": f"Deleted '{file_name}' from '{folder.name}' (project: {project.name})",+        "data": {+            "fileName": file_name,+            "fileId": file_id,+            "project": project.name,+            "folder": folder.name,+        },+    }+++def handle_create_cloud_folder(app: adsk.core.Application, args: dict) -> dict:+    """Create a new folder in a cloud project.++    Args:+        args: Dict with:+            - folderName: Name of the folder to create (required).+            - projectName: Target project (optional, defaults to active project).+            - parentPath: Parent folder path (optional, defaults to project root).+    """+    folder_name = args.get("folderName", "").strip()+    if not folder_name:+        return {"success": False, "error": "No folderName specified."}++    project_name = args.get("projectName", "")+    parent_path = args.get("parentPath", "")++    project, err = _resolve_project(app, project_name or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see available projects, or fusion_list_cloud_files with a known project name to browse folders.",+        }++    parent, err = _resolve_folder(project, parent_path or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see available projects, or fusion_list_cloud_files with a known project name to browse folders.",+        }++    # Check if folder already exists (per-item resilient, with yield + timeout)+    needle = folder_name.lower()+    started = time.time()+    try:+        existing = parent.dataFolders+        existing_count = existing.count+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to enumerate subfolders of '{parent.name}': {e}",+            "_hint": "Cloud Data API may be unavailable. Verify sign-in status in Fusion.",+        }+    for i in range(existing_count):+        if i > 0 and i % 50 == 0:+            try:+                adsk.doEvents()+            except Exception:+                pass+        if time.time() - started > 30:+            # Don't hang the main thread enumerating a huge subfolder list.+            # If we didn't find a match in 30s, fall through to create — Fusion+            # itself will detect a collision on add().+            break+        try:+            sf = existing.item(i)+            if sf.name.lower() == needle:+                return {+                    "success": True,+                    "output": f"Folder '{folder_name}' already exists in '{parent.name}'",+                    "data": {+                        "folderName": sf.name,+                        "folderId": sf.id,+                        "project": project.name,+                        "parentFolder": parent.name,+                        "alreadyExisted": True,+                    },+                }+        except Exception:+            continue++    try:+        new_folder = parent.dataFolders.add(folder_name)+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to create folder: {e}",+            "_hint": "Call fusion_get_app_state to verify sign-in status; Autodesk cloud session may have expired. If so, the user must sign in via the Fusion UI.",+        }++    return {+        "success": True,+        "output": f"Created folder '{folder_name}' in '{parent.name}' (project: {project.name})",+        "data": {+            "folderName": new_folder.name,+            "folderId": new_folder.id,+            "project": project.name,+            "parentFolder": parent.name,+        },+    }+++FIND_FILE_TIMEOUT = 60  # seconds — overall wall-clock cap for find+++def _find_cloud_file(app, args):+    """Find a cloud file by name in a project/folder. Returns (dataFile, project, folder, error).++    Robustness (v1.0.2): per-file try/except + doEvents every 50 files + wall-clock cap.+    """+    file_name = args.get("fileName", "").strip()+    if not file_name:+        return None, None, None, "No fileName specified."++    project_name = args.get("projectName", "")+    folder_path = args.get("folderPath", "")++    project, err = _resolve_project(app, project_name or None)+    if err:+        return None, None, None, err++    folder, err = _resolve_folder(project, folder_path or None)+    if err:+        return None, None, None, err++    file_ext = args.get("fileExtension", "").strip().lower().lstrip(".")+    needle = file_name.lower()+    started = time.time()++    target = None+    try:+        try:+            data_files = folder.dataFiles+            file_count = data_files.count+        except Exception as e:+            return None, None, None, f"Failed to enumerate files in '{folder.name}': {e}"++        for i in range(file_count):+            # Yield every 50 files so Fusion UI stays responsive+            if i > 0 and i % 50 == 0:+                try:+                    adsk.doEvents()+                except Exception:+                    pass+            # Wall-clock cap+            if time.time() - started > FIND_FILE_TIMEOUT:+                return None, None, None, (+                    f"File lookup timed out after {FIND_FILE_TIMEOUT}s "+                    f"(scanned {i}/{file_count} files in '{folder.name}'). "+                    f"Folder may be too large; try a more specific folderPath."+                )++            # Per-item try/except+            try:+                df = data_files.item(i)+                df_name = df.name+            except Exception:+                continue++            if df_name.lower() == needle:+                # If extension filter specified, match it+                if file_ext:+                    try:+                        if df.fileExtension.lower().lstrip(".") != file_ext:+                            continue+                    except Exception:+                        continue+                target = df+                break+    except Exception as e:+        return None, None, None, f"Failed to search files: {e}"++    if not target:+        ext_hint = f" with extension '.{file_ext}'" if file_ext else ""+        return None, None, None, f"File '{file_name}'{ext_hint} not found in '{folder.name}' (project: {project.name})"++    return target, project, folder, None+++def handle_check_recovery(app: adsk.core.Application, args: dict) -> dict:+    """Check if a cloud file has a recovery document from a previous crash.++    NOTE: The Fusion Python API does not reliably expose recovery document+    status. This command attempts to check, but may return false negatives.+    The most reliable detection is at the bridge level — if open_cloud_file+    times out, it's likely because a recovery dialog appeared.++    Args:+        fileName: Name of the file to check (required).+        projectName: Project to search in (optional, defaults to active project).+        folderPath: Subfolder path (optional, defaults to root).+    """+    target, project, folder, err = _find_cloud_file(app, args)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see available projects, or fusion_list_cloud_files with a known project name to browse folders.",+        }++    # Try to check for recovery doc — but these API methods may not exist+    has_recovery = False+    try:+        if hasattr(target, 'hasRecoveryDocument'):+            has_recovery = target.hasRecoveryDocument+    except Exception:+        pass++    return {+        "success": True,+        "output": (+            f"Recovery document found for '{target.name}' (API check)."+            if has_recovery+            else f"No recovery document detected for '{target.name}' via API. "+                 "Note: this check is not 100% reliable — Fusion may still show "+                 "a recovery dialog when opening. The bridge will detect this "+                 "via timeout if it happens."+        ),+        "data": {+            "fileName": target.name,+            "fileId": target.id,+            "project": project.name,+            "hasRecovery": has_recovery,+            "apiReliable": hasattr(target, 'hasRecoveryDocument'),+        },+    }+++def _ecad_open_reprimand(app):+    """Detect when an AI opened an electronics CHILD file instead of the PROJECT.++    Electronics files are a parent/child chain: PROJECT (EcadDesignProductType) ->+    schematic (SchematicProductType) -> board/.brd (BoardProductType) -> 3D (the leaf,+    generated from the .brd). Only the PROJECT should be opened directly; its schematic and+    board open from it. Returns a reprimand string for a child file, a confirmation for the+    project, or '' if it cannot tell.+    """+    try:+        pt = app.activeProduct.productType+    except Exception:+        return ''+    if pt == 'EcadDesignProductType':+        return ('OK: opened the electronics PROJECT file (EcadDesignProductType) - correct. '+                'Its schematic, board and 3D are children; switch to them from here.')+    nav = (' Electronics files are a parent/child chain: PROJECT (EcadDesignProductType) ->'+           ' schematic (SchematicProductType) -> board/.brd (BoardProductType) -> 3D (the leaf,'+           ' generated from the .brd). ALWAYS open the PROJECT file; its schematic and board open'+           ' from it. NEVER open a schematic, .brd, or 3D file directly to get the board.')+    label = {'SchematicProductType': 'the SCHEMATIC',+             'BoardProductType': 'the BOARD (.brd) / its 3D PCB',+             'DesignProductType': 'a 3D model file'}.get(pt)+    if label:+        return ('STOP - WRONG FILE: you opened ' + label + ' (' + pt + ') directly, not the project.'+                + nav)+    return ''+++def handle_open_cloud_file(app: adsk.core.Application, args: dict) -> dict:+    """Open a cloud file in Fusion 360 by name.++    PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.++    NOTE: If the file has a recovery document from a previous crash, Fusion+    will show a blocking modal dialog. The bridge layer (server.py) detects+    this via timeout and reports it to the AI. The AI should then screenshot+    and decide how to handle the dialog.++    Args:+        fileName: Name of the file to open (required).+        projectName: Project to search in (optional, defaults to active project).+        folderPath: Subfolder path (optional, defaults to root).+    """+    target, project, folder, err = _find_cloud_file(app, args)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see available projects, or fusion_list_cloud_files with a known project name to browse folders.",+        }++    # Open the file — if a recovery dialog appears, this call will block+    # and the bridge will detect the timeout.+    # Retry on InternalValidationError: Fusion's cloud hub frequently+    # throws this on the first try after a recent close, but the second+    # attempt (with a brief delay) usually succeeds.+    import time+    doc = None+    last_err = None+    attempts = []+    for attempt in range(3):+        try:+            doc = app.documents.open(target)+            if doc:+                break+        except Exception as e:+            last_err = str(e)+            attempts.append(f"attempt {attempt+1}: {last_err}")+            if "InternalValidationError" in last_err and attempt < 2:+                time.sleep(2 + attempt * 2)  # 2s, 4s+                continue+            break++    if not doc:+        return {+            "success": False,+            "error": f"Failed to open '{target.name}' after {len(attempts)} attempts: {last_err}",+            "_hint": "Call fusion_screenshot to check for a recovery dialog or other modal, then fusion_send_key with {\"key\":\"escape\"} or click to dismiss it, then retry.",+            "data": {"fileId": target.id, "attempts": attempts},+        }++    # Explicitly activate the freshly-opened doc. Fusion's cloud hub can+    # auto-reopen recent tabs in the background, stealing focus from the+    # doc we just opened. Force it back.+    activate_note = None+    try:+        doc.activate()+        activate_note = "activated"+    except Exception as e:+        activate_note = f"activate-failed: {e}"++    # Enumerate ALL currently open docs so the caller can see any ghost tabs+    # that Fusion auto-reopened alongside the target.+    open_docs = []+    try:+        for i in range(app.documents.count):+            d = app.documents.item(i)+            df_name = None+            try:+                df_name = d.dataFile.name if d.dataFile else None+            except Exception:+                df_name = None+            open_docs.append({+                "name": d.name,+                "dataFileName": df_name,+                "isActive": (d == app.activeDocument),+            })+    except Exception:+        pass++    # Check whether the now-active doc actually matches the target+    active_matches = False+    try:+        active_df_name = app.activeDocument.dataFile.name if app.activeDocument and app.activeDocument.dataFile else None+        active_matches = (active_df_name == target.name)+    except Exception:+        pass++    response_data = {+        "fileName": target.name,+        "fileId": target.id,+        "project": project.name,+        "documentName": doc.name,+        "activateResult": activate_note,+        "activeMatchesTarget": active_matches,+        "openDocuments": open_docs,+        "ghostTabCount": max(0, len(open_docs) - 1),+    }++    try:+        response_data["versionNumber"] = target.versionNumber+    except Exception:+        pass+    try:+        response_data["fileExtension"] = target.fileExtension+    except Exception:+        pass+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+        response_data["activeWorkspace"] = ws+    except Exception:+        pass++    _rep = _ecad_open_reprimand(app)+    return {+        "success": True,+        "output": ((_rep + " || ") if _rep.startswith("STOP") else "") + f"Opened '{target.name}' from project '{project.name}'",+        "_hint": _rep,+        "message": f"Opened '{target.name}'. IMPORTANT: Fusion may show a blocking dialog "+                   f"('What to design?', 'PCB out of date', etc.) that is NOT visible to the API. "+                   f"You MUST screenshot the Fusion window now to verify no dialog is blocking.",+        "data": response_data,+        "postOpenCheck": {+            "required": True,+            "steps": [+                "Run desktop_list_windows to find the Fusion HWND",+                "Run desktop_screenshot_window with that HWND",+                "If a dialog is visible, dismiss it with fusion_send_key {\"key\": \"escape\"} or fusion_click_fusion on the Cancel/X button",+                "Screenshot again to confirm the dialog is gone",+            ],+            "commonDialogs": [+                {"name": "What to design?", "dismiss": "fusion_send_key {\"key\": \"escape\"} or click Cancel"},+                {"name": "PCB out of date", "dismiss": "Click Update or X to dismiss"},+                {"name": "Recovered Documents", "dismiss": "fusion_dismiss_recovery"},+                {"name": "Save changes?", "dismiss": "fusion_send_key {\"key\": \"escape\"} to cancel"},+            ],+        },+    }+++def handle_search_cloud_files(app: adsk.core.Application, args: dict) -> dict:+    """Search for files in a cloud project by name.++    [WARNING - DO NOT USE FOR SEARCH] This goes through Fusion's rate-limited+    add-in Data API. It is SLOW (a real project can take 30+ MINUTES) and CAN+    CRASH the live Fusion session: the add-in connection gets forcibly closed+    (WinError 10054) and Fusion goes down. Use fusion_aps_search instead (APS+    Data Management server-side index - returns in SECONDS). Read the+    'fusion-aps-search' skill before touching this verb. Only fall back here as+    a last resort when APS is unconfigured AND you accept the crash risk.++    Case-insensitive substring match on file names. Searches the root folder+    by default (fast, safe). Set recursive=true to search subfolders — but+    this makes one cloud API call per folder, so use maxDepth and maxFolders+    to stay safe.++    SAFETY (v1.0.1 — May 2026): The previous implementation had thin+    defenses and could freeze Fusion's main thread for long enough that+    Windows marked the window "Not Responding" — users perceived this as+    a crash. The fixes:++      - Per-folder wall-clock timeout (FOLDER_TIMEOUT = 30s). If a single+        folder's cloud calls take >30s we skip the rest of that folder+        and move on, instead of blocking the main thread indefinitely.+      - Overall search wall-clock cap (SEARCH_TIMEOUT = 120s). The whole+        search aborts cleanly with partial results if exceeded.+      - Per-file try/except wrapping `df.name` and `df.fileExtension`+        access. A single corrupt file no longer kills the folder.+      - adsk.doEvents() yields every 50 files (not just per-folder), so+        a folder with thousands of files doesn't starve the UI.+      - adsk.core.Application.log() per-folder progress so post-mortem+        forensics show exactly where the search was at any point.+      - Iterative BFS queue (no recursion). Prevents Python stack growth+        on deep trees.++    Args:+        args: Dict with:+            - query: Search string (required). Matches file names.+            - projectName: Limit search to this project (optional, defaults to active).+            - folderPath: Start search in this subfolder (optional, defaults to root).+            - recursive: Search subfolders (default: false — root only).+            - maxDepth: Max recursion depth (default: 2, no upper cap).+            - maxFolders: Max folders to visit (default: 10, no upper cap).+                          Default is intentionally low — search_cloud_files is+                          tuned for quick targeted lookups. For exhaustive walks+                          across hundreds of folders, prefer fusion_walk_cloud_tree+                          which has a 600s envelope vs search's 120s.+            - maxResults: Max results to return (default: 20, no upper cap).+            - folderTimeout: Per-folder cloud-API timeout in seconds (default: 30).+            - searchTimeout: Overall wall-clock timeout in seconds (default: 120).+                             If you raise this above 180, also pass `timeout:<N>`+                             at the bridge level so the HTTP waiter envelope+                             doesn't give up first.++    Returns data:+        files, totalFound, foldersSearched, foldersSkipped, project, truncated,+        folderLimitReached, searchTimedOut, elapsedSeconds, hint.+    """+    query = args.get("query", "").strip().lower()+    if not query:+        return {"success": False, "error": "No query specified."}++    project_name = args.get("projectName", "")+    folder_path = args.get("folderPath", "")+    recursive = bool(args.get("recursive", False))+    try:+        # No hard upper caps in v1.0.2+ — the per-folder timeout, doEvents+        # yield, per-file try/except, overall search timeout, and stale-lock+        # watchdog all make hard caps unnecessary. You can ask for an+        # exhaustive search of the entire cloud (e.g. maxFolders=10000); the+        # overall timeout governs when partial results are returned.+        max_depth = max(0, int(args.get("maxDepth", 2)))+        max_folders = max(1, int(args.get("maxFolders", 10)))+        max_results = max(1, int(args.get("maxResults", 20)))+    except (TypeError, ValueError):+        return {+            "success": False,+            "error": "maxDepth / maxFolders / maxResults must be integers.",+        }++    # Bounds on cloud-API time. The per-folder timeout protects against a+    # single slow folder. The overall search timeout is the escape hatch.+    # Both are tunable per-call via folderTimeout / searchTimeout args.+    try:+        FOLDER_TIMEOUT = max(5, int(args.get("folderTimeout", 30)))+        SEARCH_TIMEOUT = max(10, int(args.get("searchTimeout", 120)))+    except (TypeError, ValueError):+        FOLDER_TIMEOUT = 30+        SEARCH_TIMEOUT = 120++    # NOTE: the HTTP-server per-command timeout (180s by default for+    # search_cloud_files in http_server.PER_COMMAND_TIMEOUT) is the OUTER+    # envelope. If you set searchTimeout > 180, also pass `timeout`:<N>+    # at the bridge level so the HTTP waiter doesn't give up first. For+    # truly exhaustive walks of huge trees (10+ minutes), prefer+    # fusion_walk_cloud_tree (600s envelope, default maxFolders=500).++    data = app.data+    if not data:+        return {"success": False, "error": "Fusion Data API not available."}++    # Resolve starting point+    if project_name:+        project, err = _resolve_project(app, project_name)+        if err:+            return {+                "success": False,+                "error": err,+                "_hint": "Call fusion_list_cloud_projects to see valid project names.",+            }+    else:+        try:+            project = data.activeProject+        except Exception as e:+            return {"success": False, "error": f"activeProject lookup failed: {e}"}+        if not project:+            return {"success": False, "error": "No active project. Specify projectName."}++    start_folder, err = _resolve_folder(project, folder_path or None)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_files with this projectName to see valid folderPath values.",+        }++    results = []+    folders_visited = 0+    folders_skipped = 0+    files_skipped = 0+    search_timed_out = False++    # Set progress state for external observers+    global _walk_progress+    search_start = time.time()+    with _walk_progress_lock:+        _walk_progress = {+            "command": "search_cloud_files",+            "startedAt": search_start,+            "project": project.name,+            "query": query,+            "foldersVisited": 0,+            "currentFolder": folder_path or "(root)",+            "filesFound": 0,+            "elapsedSeconds": 0,+        }++    # Iterative BFS queue: list of (folder, path, depth). No recursion =+    # bounded Python stack depth + easy to short-circuit on timeout.+    start_path = folder_path or ""+    queue = [(start_folder, start_path, 0)]++    try:+        while queue:+            # Overall search timeout — return partial results cleanly.+            if time.time() - search_start > SEARCH_TIMEOUT:+                search_timed_out = True+                try:+                    adsk.core.Application.log(+                        f"AdomBridge: search hit overall timeout ({SEARCH_TIMEOUT}s) "+                        f"after {folders_visited} folder(s), {len(results)} result(s)"+                    )+                except Exception:+                    pass+                break++            # Folder / result caps+            if folders_visited >= max_folders or len(results) >= max_results:+                break++            folder, path, depth = queue.pop(0)+            folders_visited += 1+            folder_start = time.time()++            try:+                adsk.core.Application.log(+                    f"AdomBridge: search [{folders_visited}/{folders_visited + len(queue)}] '{path or '(root)'}' (depth={depth})"+                )+            except Exception:+                pass++            # ── Search files in this folder ──+            try:+                data_files = folder.dataFiles+                # If even getting the dataFiles handle took >FOLDER_TIMEOUT,+                # skip iteration entirely.+                if time.time() - folder_start > FOLDER_TIMEOUT:+                    folders_skipped += 1+                    try:+                        adsk.core.Application.log(+                            f"AdomBridge: search skipping slow folder '{path}' (>{FOLDER_TIMEOUT}s on dataFiles)"+                        )+                    except Exception:+                        pass+                else:+                    file_count = data_files.count+                    for i in range(file_count):+                        # Yield every 50 files to keep Fusion responsive.+                        # Without this, a folder with 1000 files would+                        # block the main thread for the whole iteration.+                        if i > 0 and i % 50 == 0:+                            try:+                                adsk.doEvents()+                            except Exception:+                                pass+                        # Per-file timeout check (cheap).+                        if time.time() - folder_start > FOLDER_TIMEOUT:+                            folders_skipped += 1+                            try:+                                adsk.core.Application.log(+                                    f"AdomBridge: search folder '{path}' hit per-folder timeout at file {i}"+                                )+                            except Exception:+                                pass+                            break+                        if len(results) >= max_results:+                            break++                        # Per-file try/except — a single corrupt or+                        # in-flight-deletion file shouldn't kill the+                        # whole folder. Just skip it and keep going.+                        # We COUNT every skip so the caller knows "0 results"+                        # could be a false negative if files_skipped > 0.+                        try:+                            df = data_files.item(i)+                        except Exception:+                            files_skipped += 1+                            continue+                        try:+                            df_name = df.name+                        except Exception:+                            files_skipped += 1+                            continue+                        if query in df_name.lower():+                            info = {+                                "name": df_name,+                                "project": project.name,+                                "folderPath": path or "/",+                            }+                            try:+                                info["id"] = df.id+                            except Exception:+                                pass+                            try:+                                info["versionNumber"] = df.versionNumber+                            except Exception:+                                pass+                            try:+                                info["fileExtension"] = df.fileExtension+                            except Exception:+                                pass+                            results.append(info)+            except Exception as e:+                folders_skipped += 1+                try:+                    adsk.core.Application.log(+                        f"AdomBridge: search dataFiles error in '{path}': {e}"+                    )+                except Exception:+                    pass++            # Update progress for external observers (health endpoint, bridge)+            with _walk_progress_lock:+                if _walk_progress is not None:+                    _walk_progress["foldersVisited"] = folders_visited+                    _walk_progress["currentFolder"] = path+                    _walk_progress["filesFound"] = len(results)+                    _walk_progress["elapsedSeconds"] = round(time.time() - search_start, 1)+                    _walk_progress["queueSize"] = len(queue)++            # Yield to Fusion's event loop between folders.+            try:+                adsk.doEvents()+            except Exception:+                pass++            # ── Enqueue subfolders ──+            if recursive and depth < max_depth and (time.time() - folder_start <= FOLDER_TIMEOUT):+                try:+                    subfolders = folder.dataFolders+                    sub_count = subfolders.count+                    for i in range(sub_count):+                        if len(results) >= max_results:+                            break+                        try:+                            sf = subfolders.item(i)+                            sub_path = f"{path}/{sf.name}" if path else sf.name+                            queue.append((sf, sub_path, depth + 1))+                        except Exception:+                            continue+                except Exception as e:+                    folders_skipped += 1+                    try:+                        adsk.core.Application.log(+                            f"AdomBridge: search dataFolders error in '{path}': {e}"+                        )+                    except Exception:+                        pass+    finally:+        with _walk_progress_lock:+            _walk_progress = None++    hit_folder_limit = folders_visited >= max_folders+    hit_result_limit = len(results) >= max_results+    elapsed_total = time.time() - search_start++    # ── searchComplete: TRUE only if we exhausted the search space ──+    # Any cap hit OR any skip means we might have missed matches.+    # The AI should treat "0 results + searchComplete=false" as+    # "result unknown", never as "confirmed not present".+    search_complete = (+        not hit_folder_limit+        and not hit_result_limit+        and not search_timed_out+        and folders_skipped == 0+        and files_skipped == 0+    )++    # Cost analysis — useful for both reporting back and informing+    # whether to ask the user for narrower scope next time.+    folders_per_sec = (folders_visited / elapsed_total) if elapsed_total > 0 else 0.0+    cost_analysis = {+        "elapsedSeconds": round(elapsed_total, 1),+        "foldersPerSecond": round(folders_per_sec, 2),+        # Rough estimate based on observed throughput. If the user wanted+        # an exhaustive sweep of the entire project, this is how long it+        # might take given THIS search's average folder latency. (Can't+        # know the project's actual folder count without walking it.)+        "estimatedSecondsPer100Folders": round(100 / folders_per_sec) if folders_per_sec > 0 else None,+    }++    # ── Build a hint that's EXPLICIT about what kind of "0" we got ──+    hint_parts = []++    if search_complete:+        if len(results) == 0:+            hint_parts.append(+                f"COMPLETE SEARCH: searched {folders_visited} folder(s) in "+                f"{round(elapsed_total)}s and found NO files matching '{query}'. "+                f"This is a confirmed negative — the file does not exist in "+                f"'{folder_path or project.name}'."+            )+        else:+            hint_parts.append(+                f"COMPLETE SEARCH: all {len(results)} matches returned."+            )+    else:+        # Search was incomplete — be explicit about WHY and what it implies+        reasons = []+        if hit_folder_limit:+            reasons.append(f"hit maxFolders={max_folders}")+        if hit_result_limit:+            reasons.append(f"hit maxResults={max_results}")+        if search_timed_out:+            reasons.append(f"hit searchTimeout={SEARCH_TIMEOUT}s")+        if folders_skipped > 0:+            reasons.append(f"{folders_skipped} folder(s) errored/timed out")+        if files_skipped > 0:+            reasons.append(f"{files_skipped} file(s) errored on .name access")++        hint_parts.append(+            f"INCOMPLETE SEARCH ({'; '.join(reasons)}). "+            f"Found {len(results)} match(es) in {folders_visited} folder(s) "+            f"over {round(elapsed_total)}s — but this is a LOWER BOUND, not exhaustive."+        )++        if len(results) == 0:+            hint_parts.append(+                "CRITICAL: 0 results does NOT mean the file is absent. The search "+                "stopped before exhausting the scope. Do NOT report 'file not found' "+                "to the user — re-run with broader caps OR narrower folderPath first."+            )++    # ── Proactive scope-narrowing nudge for broad searches ──+    # If this was a wide search and took non-trivial time, the AI should+    # (a) tell the user why this is slow (Autodesk API design, NOT adom-desktop)+    # (b) suggest the simple fix (folderPath narrowing)+    # (c) mention the long-term community fix (paid APS, fork + PR)+    if recursive and not folder_path and elapsed_total > 30:+        cost_str = (+            f" (at the observed {folders_per_sec:.1f} folders/sec, "+            f"a 10-folder subtree would take ~{round(10 / folders_per_sec)}s "+            f"vs this {round(elapsed_total)}s scan)"+            if folders_per_sec > 0 else ""+        )+        hint_parts.append(+            f"BROAD-SCOPE NOTE: searched '{project.name}' from root in "+            f"{round(elapsed_total)}s. WHY SLOW: Autodesk's free Fusion 360 "+            f"Python API has no indexed file-search endpoint, so we must walk "+            f"the cloud Data API one folder at a time — each folder is a "+            f"separate HTTP round-trip to Autodesk. THIS IS AN AUTODESK API "+            f"LIMITATION, NOT AN ADOM-DESKTOP LIMITATION — when you tell the "+            f"user it's slow, attribute it to Autodesk / Fusion 360, not to "+            f"adom-desktop's bridge. Autodesk's PAID Autodesk Platform Services "+            f"(APS, formerly Forge) Data Management API DOES expose indexed "+            f"search that would make this ~instant; if your team has APS "+            f"credentials, you (or anyone in the community) can fork the "+            f"adom-desktop fusion bridge to add an aps_search verb and PR it "+            f"back to https://wiki-ufypy5dpx93o.adom.cloud/apps/adom-desktop "+            f"— the whole Adom community would benefit. FOR THIS SEARCH "+            f"RIGHT NOW: just ask the user 'do you know which subfolder "+            f"<query> is typically stored in?'{cost_str} Naming a folder "+            f"like 'Molecules' cuts search 10-50x with zero new API."+        )+    elif not recursive and len(results) == 0:+        hint_parts.append(+            "Search was limited to root folder (recursive=false). If the file "+            "could be in a subfolder, set recursive=true and ideally folderPath "+            "to the most likely parent (ask the user if unsure)."+        )++    # If we hit the result cap, more matches may exist+    if hit_result_limit:+        hint_parts.append(+            f"RESULT CAP HIT: you got the first {max_results} matches but more "+            f"may exist. Raise maxResults to see all."+        )++    full_hint = " | ".join(hint_parts) if hint_parts else None++    return {+        "success": True,+        "output": f"Found {len(results)} file(s) matching '{query}' "+                  f"(searched {folders_visited} folder(s) in '{project.name}'"+                  f"{', search timed out' if search_timed_out else ''}"+                  f"{', INCOMPLETE' if not search_complete else ''})",+        "data": {+            "query": query,+            "files": results,+            "totalFound": len(results),+            "foldersSearched": folders_visited,+            "foldersSkipped": folders_skipped,+            "filesSkipped": files_skipped,+            "project": project.name,+            "scopeFolderPath": folder_path or "(project root)",+            "recursive": recursive,+            # ── The big flag the AI must check before reporting "no match" ──+            "searchComplete": search_complete,+            "truncated": hit_result_limit,+            "folderLimitReached": hit_folder_limit,+            "searchTimedOut": search_timed_out,+            "elapsedSeconds": round(elapsed_total, 1),+            "costAnalysis": cost_analysis,+            "hint": full_hint,+        },+        "_hint": full_hint,  # also at top level for AI scaffolding that checks _hint+    }+++def handle_export_cloud_file(app: adsk.core.Application, args: dict) -> dict:+    """Export the active Fusion document to a local file for transfer.++    Exports the currently open document as STEP, STL, F3D, or other format+    to a local file path. The file can then be pulled back to Docker via pull_file.++    Args:+        args: Dict with:+            - outputPath: Local file path to export to (required).+            - format: Export format (optional, default "step").+                     Supported: "step", "stl", "f3d", "iges", "sat", "smt".+    """+    output_path = args.get("outputPath", "").strip()+    if not output_path:+        return {"success": False, "error": "No outputPath specified."}++    output_path = output_path.replace("\\", "/")+    fmt = args.get("format", "step").lower().strip()++    doc = app.activeDocument+    if not doc:+        return {+            "success": False,+            "error": "No active document to export.",+            "_hint": "Call fusion_open_cloud_file to open a file, then retry.",+        }++    # Get the design product+    design = None+    try:+        design = adsk.fusion.Design.cast(app.activeProduct)+    except Exception:+        pass++    if not design:+        return {+            "success": False,+            "error": "Active document is not a Fusion Design. Cannot export.",+            "_hint": "Call fusion_activate_workspace with target='design' or open a Fusion Design document first, then retry.",+            "data": {"hint": "Open a design document first, or switch to the Design workspace."},+        }++    # Ensure output directory exists+    out_dir = os.path.dirname(output_path)+    if out_dir and not os.path.exists(out_dir):+        os.makedirs(out_dir, exist_ok=True)++    root = design.rootComponent+    export_mgr = design.exportManager++    try:+        if fmt in ("step", "stp"):+            options = export_mgr.createSTEPExportOptions(output_path, root)+            export_mgr.execute(options)+        elif fmt == "stl":+            options = export_mgr.createSTLExportOptions(root, output_path)+            export_mgr.execute(options)+        elif fmt in ("iges", "igs"):+            options = export_mgr.createIGESExportOptions(output_path, root)+            export_mgr.execute(options)+        elif fmt == "sat":+            options = export_mgr.createSATExportOptions(output_path, root)+            export_mgr.execute(options)+        elif fmt == "smt":+            options = export_mgr.createSMTExportOptions(output_path, root)+            export_mgr.execute(options)+        elif fmt == "f3d":+            options = export_mgr.createFusionArchiveExportOptions(output_path)+            export_mgr.execute(options)+        else:+            return {+                "success": False,+                "error": f"Unsupported format: {fmt}",+                "data": {"supportedFormats": ["step", "stl", "f3d", "iges", "sat", "smt"]},+            }+    except Exception as e:+        return {"success": False, "error": f"Export failed: {e}"}++    if not os.path.exists(output_path):+        return {"success": False, "error": f"Export file was not created at {output_path}"}++    size = os.path.getsize(output_path)++    return {+        "success": True,+        "output": f"Exported '{doc.name}' as {fmt.upper()} to {output_path} ({size} bytes)",+        "data": {+            "outputPath": output_path,+            "format": fmt,+            "fileSize": size,+            "documentName": doc.name,+        },+    }+++def handle_walk_cloud_tree(app: adsk.core.Application, args: dict) -> dict:+    """Walk a cloud folder tree iteratively and return a flat list of all files and folders.++    [WARNING - DO NOT USE FOR SEARCH] Goes through Fusion's rate-limited add-in+    Data API: SLOW (30+ MINUTES on a real project) and CAN CRASH the live Fusion+    session (add-in connection forcibly closed, WinError 10054 - Fusion goes+    down). Use fusion_aps_search instead (APS server-side index, seconds). See+    the 'fusion-aps-search' skill. Last-resort only, when APS is unconfigured+    and you accept the crash risk.++    Purpose: replace the broken recursive search_cloud_files. No sleeps, no tiny+    hardcoded caps. Single add-in call does the whole BFS inside the main thread+    — one request to the bridge, one response back.++    Args:+        args: Dict with:+            - projectName: Project name (optional, defaults to active project).+            - folderPath: Starting folder path (optional, defaults to root).+            - maxDepth: Max recursion depth (optional, default 10).+            - maxFolders: Hard cap on number of folders visited (optional, default 500).+            - extensions: List of file extensions to include, e.g. ["f3d", "fprj"]+                          (optional, default: include all files).+            - nameContains: Substring filter for file/folder names, case-insensitive+                          (optional, default: no filter).+            - includeFiles: If False, return only the folder tree (default True).++    Returns data:+        - project: project name+        - rootFolder: starting folder name+        - folders: [{path, name, id, depth}]+        - files:   [{path, folder, name, id, fileExtension, versionNumber}]+        - stats: {foldersVisited, foldersSkipped, filesFound, maxDepthReached, truncated}+    """+    project_name = args.get("projectName", "") or None+    folder_path = args.get("folderPath", "") or None+    max_depth = int(args.get("maxDepth", 10))+    max_folders = int(args.get("maxFolders", 500))+    extensions = args.get("extensions") or []+    if isinstance(extensions, str):+        extensions = [extensions]+    extensions = {e.lower().lstrip(".") for e in extensions}+    name_contains = (args.get("nameContains") or "").lower()+    include_files = args.get("includeFiles", True)++    project, err = _resolve_project(app, project_name)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_projects to see valid project names.",+        }++    root, err = _resolve_folder(project, folder_path)+    if err:+        return {+            "success": False,+            "error": err,+            "_hint": "Call fusion_list_cloud_files with this projectName to see valid folderPath values.",+        }++    folders_out = []+    files_out = []+    folders_visited = 0+    folders_skipped = 0+    files_found = 0+    max_depth_reached = 0+    truncated = False++    # Iterative BFS queue: list of (folder, path, depth)+    start_path = root.name if folder_path else ""+    queue = [(root, start_path, 0)]++    # Set progress state so external callers (health endpoint, bridge busy+    # gate) know a walk is running and can report progress.+    global _walk_progress+    walk_start = time.time()+    with _walk_progress_lock:+        _walk_progress = {+            "command": "walk_cloud_tree",+            "startedAt": walk_start,+            "project": project.name,+            "rootFolder": root.name,+            "foldersVisited": 0,+            "queueSize": len(queue),+            "currentFolder": start_path or "(root)",+            "filesFound": 0,+            "elapsedSeconds": 0,+        }++    try:+        while queue:+            if folders_visited >= max_folders:+                truncated = True+                break++            folder, path, depth = queue.pop(0)+            folders_visited += 1+            if depth > max_depth_reached:+                max_depth_reached = depth++            # Per-folder wall-clock timeout — if a single folder's cloud API+            # calls take >30s, skip remaining work and move on. We can't+            # interrupt folder.dataFiles mid-call, but we can skip subfolder+            # enumeration and file iteration if the first call was too slow.+            FOLDER_TIMEOUT = 30  # seconds+            folder_start = time.time()++            adsk.core.Application.log(+                f"AdomBridge: walk [{folders_visited}/{folders_visited + len(queue)}] '{path}'"+            )++            folders_out.append({+                "path": path,+                "name": folder.name,+                "id": folder.id,+                "depth": depth,+            })++            # List files in this folder+            if include_files:+                try:+                    data_files = folder.dataFiles+                    if time.time() - folder_start > FOLDER_TIMEOUT:+                        adsk.core.Application.log(+                            f"AdomBridge: walk skipping slow folder '{path}' (>{FOLDER_TIMEOUT}s on dataFiles)"+                        )+                        folders_skipped += 1+                    else:+                        for i in range(data_files.count):+                            # Yield every 50 files to keep Fusion responsive+                            if i > 0 and i % 50 == 0:+                                try:+                                    adsk.doEvents()+                                except Exception:+                                    pass+                            if time.time() - folder_start > FOLDER_TIMEOUT:+                                adsk.core.Application.log(+                                    f"AdomBridge: walk folder '{path}' hit timeout during file iteration at file {i}"+                                )+                                folders_skipped += 1+                                break+                            try:+                                df = data_files.item(i)+                                name = df.name+                                ext = ""+                                try:+                                    ext = (df.fileExtension or "").lower()+                                except Exception:+                                    pass+                                if extensions and ext not in extensions:+                                    continue+                                if name_contains and name_contains not in name.lower():+                                    continue+                                entry = {+                                    "path": (path + "/" + name) if path else name,+                                    "folder": path,+                                    "name": name,+                                    "id": df.id,+                                    "fileExtension": ext,+                                }+                                try:+                                    entry["versionNumber"] = df.versionNumber+                                except Exception:+                                    pass+                                files_out.append(entry)+                                files_found += 1+                            except Exception:+                                continue+                except Exception:+                    folders_skipped += 1++            # Enqueue subfolders (unless at depth limit or folder timed out)+            if depth < max_depth and (time.time() - folder_start <= FOLDER_TIMEOUT):+                try:+                    subfolders = folder.dataFolders+                    for i in range(subfolders.count):+                        try:+                            sf = subfolders.item(i)+                            sub_path = (path + "/" + sf.name) if path else sf.name+                            queue.append((sf, sub_path, depth + 1))+                        except Exception:+                            continue+                except Exception:+                    folders_skipped += 1+            elif depth < max_depth:+                adsk.core.Application.log(+                    f"AdomBridge: walk skipping subfolders of '{path}' (folder timed out)"+                )++            # Update progress for external observers (health endpoint, bridge)+            with _walk_progress_lock:+                if _walk_progress is not None:+                    _walk_progress["foldersVisited"] = folders_visited+                    _walk_progress["queueSize"] = len(queue)+                    _walk_progress["currentFolder"] = path+                    _walk_progress["filesFound"] = files_found+                    _walk_progress["elapsedSeconds"] = round(time.time() - walk_start, 1)++            # Yield to Fusion's event loop to prevent "Not Responding" state.+            try:+                adsk.doEvents()+            except Exception:+                pass++    finally:+        with _walk_progress_lock:+            _walk_progress = None++    summary = (+        f"Walked {folders_visited} folders under '{root.name}' in project '{project.name}' "+        f"(max depth {max_depth_reached}). Found {files_found} files."+    )+    if truncated:+        summary += f" TRUNCATED at maxFolders={max_folders} — increase limit or narrow folderPath."++    return {+        "success": True,+        "output": summary,+        "data": {+            "project": project.name,+            "rootFolder": root.name,+            "folders": folders_out,+            "files": files_out,+            "stats": {+                "foldersVisited": folders_visited,+                "foldersSkipped": folders_skipped,+                "filesFound": files_found,+                "maxDepthReached": max_depth_reached,+                "truncated": truncated,+            },+        },+    }+++def handle_open_by_urn(app: adsk.core.Application, args: dict) -> dict:+    """Open a cloud file directly by its APS/Fusion URN.++    PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.++    Works for ANY file regardless of folder nesting (unlike open_cloud_file,+    which searches by name only in a project's root folder). APS hands the+    bridge the exact file URN; we resolve it to a Fusion DataFile via+    Data.findFileById and open it.+    """+    urn = (args.get("urn") or args.get("fileUrn") or "").strip()+    if not urn:+        return {"success": False, "error": "No urn specified."}++    # File-based breadcrumb (Application.log only reaches the in-app Text Commands+    # palette, which is unreadable headless). Opening a heavy assembly or an+    # electronics/PCB design can hard-crash the host mid-open with no other trace;+    # this leaves the last step on disk so the crash point is provable afterward.+    import os as _os, tempfile as _tf+    _crumb_path = _os.path.join(_tf.gettempdir(), "adom_open_by_urn.log")+    def _crumb(msg):+        try:+            with open(_crumb_path, "a", encoding="utf-8") as _fh:+                _fh.write(msg + "\n")+                _fh.flush()+        except Exception:+            pass+        try:+            adsk.core.Application.log("[open_by_urn] " + msg)+        except Exception:+            pass++    data = app.data+    # APS returns a version urn like urn:adsk.wipprod:fs.file:vf.<base>?version=N.+    # findFileById wants the file/lineage id — try several derivations.+    raw = urn.split("?")[0]+    candidates = [urn, raw]+    if "fs.file:vf." in raw:+        base = raw.split("fs.file:vf.")[-1]+        candidates.append("urn:adsk.wipprod:dm.lineage:" + base)+        candidates.append(base)++    _crumb("resolving urn: " + urn[:80])++    df = None+    tried = []+    for cid in candidates:+        try:+            f = data.findFileById(cid)+            if f:+                df = f+                tried.append(cid[:55] + " -> FOUND")+                break+            tried.append(cid[:55] + " -> none")+        except Exception as e:+            tried.append(cid[:55] + " -> " + str(e)[:40])+    if not df:+        _crumb("FAILED to resolve urn to a DataFile. tried=" + " | ".join(tried))+        return {"success": False,+                "error": "Could not resolve the file URN to a Fusion DataFile.",+                "_hint": "URN resolution failed — an open-path issue, NOT the Fusion license. A "+                         "read-only/expired/trial Fusion still opens+views files (only save/export "+                         "are blocked). Check the urn form / file access.",+                "data": {"tried": tried, "urn": urn}}++    _crumb("resolved '%s' (id=%s) — about to call documents.open "+           "(PCB/electronics designs spin up the Electronics editor here; a heavy "+           "assembly downloads all referenced parts here — the wedge/crash point)"+           % (df.name, df.id))++    doc = None+    last_err = None+    for attempt in range(3):+        try:+            doc = app.documents.open(df)+            if doc:+                _crumb("documents.open returned a doc for '%s'" % df.name)+                break+        except Exception as e:+            last_err = str(e)+            if "InternalValidationError" in last_err and attempt < 2:+                time.sleep(2 + attempt * 2)+                continue+            break+    if not doc:+        return {"success": False, "error": "Open failed for '%s': %s" % (df.name, last_err),+                "_hint": "documents.open failed — an open-path issue, NOT the Fusion license. A "+                         "read-only/expired/trial Fusion still opens+views files (only save/export "+                         "are blocked). Likely a slow/large assembly, a blocking Electronics picker, "+                         "or a transient cloud error — retry / check fusion_window_info for a modal.",+                "data": {"fileName": df.name, "fileId": df.id}}+    try:+        doc.activate()+    except Exception:+        pass+    _rep = _ecad_open_reprimand(app)+    return {"success": True, "output": ((_rep + " || ") if _rep.startswith("STOP") else "") + ("Opened '%s'." % df.name),+            "_hint": _rep,+            "data": {"fileName": df.name, "fileId": df.id, "resolved": tried}}

@@ -0,0 +1,98 @@+"""Design info command — component tree, bodies, document info."""++import adsk.core+import adsk.fusion+++def handle_get_design_info(app: adsk.core.Application, args: dict) -> dict:+    """Get information about the active design.++    Returns component tree, bodies, user parameters, and document info.+    """+    product = app.activeProduct+    if not product or product.productType != "DesignProductType":+        return {+            "success": False,+            "error": "No active design open in Fusion 360",+            "_hint": "Call fusion_open_cloud_file to open a Design document, or fusion_show_3d_board if an electronics board is open, then retry.",+        }++    design = adsk.fusion.Design.cast(product)+    doc = app.activeDocument++    root = design.rootComponent+    components = _walk_component(root)++    # User parameters+    params = []+    for i in range(design.userParameters.count):+        param = design.userParameters.item(i)+        params.append({+            "name": param.name,+            "expression": param.expression,+            "value": param.value,+            "unit": param.unit,+        })++    return {+        "success": True,+        "data": {+            "document": {+                "name": doc.name if doc else "Untitled",+                "isSaved": doc.isSaved if doc else False,+            },+            "designType": "Parametric" if design.designType == adsk.fusion.DesignTypes.ParametricDesignType else "Direct",+            "components": components,+            "userParameters": params,+        },+    }+++def _walk_component(comp: adsk.fusion.Component) -> dict:+    """Recursively walk a component and its children."""+    bodies = []+    for i in range(comp.bRepBodies.count):+        body = comp.bRepBodies.item(i)+        bodies.append({+            "name": body.name,+            "isVisible": body.isVisible,+            "isSolid": body.isSolid,+            "volume_cm3": body.volume if body.isSolid else None,+        })++    # Also check mesh bodies (STL/3MF imports create these)+    mesh_bodies = []+    try:+        for i in range(comp.meshBodies.count):+            mb = comp.meshBodies.item(i)+            mesh_bodies.append({+                "name": mb.name,+                "isVisible": mb.isVisible,+            })+    except Exception:+        pass  # meshBodies may not exist in older API versions++    children = []+    for i in range(comp.occurrences.count):+        occ = comp.occurrences.item(i)+        children.append({+            "name": occ.name,+            "isVisible": occ.isVisible,+            "component": _walk_component(occ.component),+        })++    result = {+        "name": comp.name,+        "bodies": bodies,+        "children": children,+    }+    if mesh_bodies:+        result["meshBodies"] = mesh_bodies++    # Debug info: feature count tells us if there's actual content+    try:+        result["features"] = comp.features.count+    except Exception:+        pass++    return result

@@ -0,0 +1,305 @@+"""Document info and activation commands.++document_info — lightweight metadata about ALL open documents plus active doc details.+activate_document — switch to a specific open document tab by name or type.+"""++import adsk.core+++def _document_type_str(doc_type) -> str:+    """Convert a DocumentType enum to a human-readable string."""+    if doc_type is None:+        return "unknown"+    type_map = {+        0: "FusionDesign",+        1: "FusionDesign",+        2: "Drawing",+        3: "Electronics",+        4: "PCB",+    }+    try:+        val = int(doc_type)+        return type_map.get(val, f"Unknown({val})")+    except (TypeError, ValueError):+        return str(doc_type)+++def handle_document_info(app: adsk.core.Application, args: dict) -> dict:+    """Get metadata about all open documents and the active document.++    Returns every open document/tab with name, type, and active status,+    plus detailed cloud info for the active document. Uses only in-memory+    data — no cloud API calls.++    This is the command to use when Claude needs to know what tabs are open+    and which one is focused, without expensive cloud searches.+    """+    # Active workspace+    active_workspace = "unknown"+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+        if ws:+            active_workspace = ws.strip()+    except Exception:+        pass++    # Active document name (for isActive flag)+    active_doc_name = None+    active_doc = None+    try:+        active_doc = app.activeDocument+        if active_doc:+            active_doc_name = active_doc.name+    except Exception:+        pass++    # Enumerate ALL open documents+    open_documents = []+    try:+        for i in range(app.documents.count):+            doc = app.documents.item(i)+            doc_info = {+                "name": doc.name,+                "isActive": (doc.name == active_doc_name) if active_doc_name else False,+            }+            try:+                doc_info["documentType"] = _document_type_str(getattr(doc, 'documentType', None))+                doc_info["documentTypeRaw"] = str(getattr(doc, 'documentType', None))+            except Exception:+                doc_info["documentType"] = "unknown"++            try:+                doc_info["isSaved"] = doc.isSaved+            except Exception:+                pass++            # Cloud file info (lightweight — just the cached ID)+            try:+                df = doc.dataFile+                if df:+                    doc_info["cloudFileId"] = df.id+                    doc_info["isCloudDocument"] = True+                    try:+                        doc_info["cloudProjectName"] = df.parentProject.name+                    except Exception:+                        pass+                else:+                    doc_info["isCloudDocument"] = False+            except Exception:+                doc_info["isCloudDocument"] = False++            open_documents.append(doc_info)+    except Exception as e:+        open_documents = [{"error": f"Failed to enumerate documents: {e}"}]++    # Detailed info for the active document+    active_detail = {}+    if active_doc:+        try:+            active_detail["documentName"] = active_doc.name+        except Exception:+            pass++        try:+            df = active_doc.dataFile+            if df:+                active_detail["isCloudDocument"] = True+                try:+                    active_detail["cloudFileId"] = df.id+                except Exception:+                    pass+                try:+                    active_detail["documentVersion"] = df.versionNumber+                except Exception:+                    pass+                try:+                    active_detail["cloudProjectName"] = df.parentProject.name+                except Exception:+                    pass+                try:+                    # Build folder path+                    folder = df.parentFolder+                    parts = []+                    depth = 0+                    while folder and depth < 10:+                        parts.append(folder.name)+                        try:+                            folder = folder.parentFolder+                        except Exception:+                            break+                        depth += 1+                    if parts:+                        parts.reverse()+                        active_detail["cloudFolderPath"] = "/".join(parts)+                except Exception:+                    pass+            else:+                active_detail["isCloudDocument"] = False+        except Exception:+            active_detail["isCloudDocument"] = False++        try:+            active_detail["isSaved"] = active_doc.isSaved+        except Exception:+            pass++    # Product type+    try:+        product = app.activeProduct+        if product:+            active_detail["productType"] = product.productType+    except Exception:+        pass++    data = {+        "activeWorkspace": active_workspace,+        "activeDocument": active_doc_name,+        "openDocuments": open_documents,+        "openDocumentCount": len(open_documents),+        **active_detail,+    }++    return {+        "success": True,+        "output": f"{len(open_documents)} document(s) open, "+                  f"active: {active_doc_name or '(none)'}, "+                  f"workspace: {active_workspace}",+        "data": data,+        "_hint": "Use fusion_get_app_state to check workspace type. "+                 "For exports: fusion_export_gerbers, fusion_export_bom, fusion_export_cpl, "+                 "fusion_export_source (.fsch/.fbrd), fusion_export_eagle_source (.sch/.brd). "+                 "Use fusion_activate_document to switch tabs.",+    }+++def handle_activate_document(app: adsk.core.Application, args: dict) -> dict:+    """Switch to a specific open document tab by name or type.++    Searches all open documents and activates the matching one. This is+    essential for automation — Claude can switch between schematic, board,+    and library tabs without asking the user to click.++    Args:+        name: Document name to activate (case-insensitive substring match).+        documentType: Document type to activate — "Electronics", "PCB",+                      "FusionDesign", "Drawing". If both name and type are+                      given, both must match.++    If multiple documents match, activates the first match and lists all+    matches in the response so Claude can refine.+    """+    target_name = args.get("name", "").strip().lower()+    target_type = args.get("documentType", "").strip().lower()+    target_data_file = args.get("dataFileName", "").strip()  # EXACT match on dataFile.name++    if not target_name and not target_type and not target_data_file:+        return {+            "success": False,+            "error": "Specify 'name' (substring) or 'dataFileName' (exact cloud-file name) "+                     "or 'documentType' (Electronics, PCB, FusionDesign, Drawing).",+            "_hint": "Call fusion_document_info to list open documents by index, or fusion_open_cloud_file to open a new document, then retry.",+        }++    # Find matching documents+    matches = []+    try:+        for i in range(app.documents.count):+            doc = app.documents.item(i)+            name_match = True+            type_match = True+            datafile_match = True++            if target_data_file:+                df_name = None+                try:+                    df_name = doc.dataFile.name if doc.dataFile else None+                except Exception:+                    df_name = None+                datafile_match = (df_name == target_data_file)++            if target_name:+                name_match = target_name in doc.name.lower()++            if target_type:+                doc_type_str = _document_type_str(getattr(doc, 'documentType', None)).lower()+                doc_type_raw = str(getattr(doc, 'documentType', None)).lower()+                type_match = (target_type in doc_type_str or+                              target_type in doc_type_raw)++            if name_match and type_match and datafile_match:+                matches.append(doc)+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to enumerate documents: {e}",+            "_hint": "Call fusion_get_app_state to check if Fusion is in a usable state; a modal dialog may be blocking.",+        }++    if not matches:+        # List what IS open for debugging+        available = []+        try:+            for i in range(app.documents.count):+                doc = app.documents.item(i)+                available.append({+                    "name": doc.name,+                    "type": _document_type_str(getattr(doc, 'documentType', None)),+                })+        except Exception:+            pass++        return {+            "success": False,+            "error": f"No open document matching name='{target_name or '*'}' "+                     f"type='{target_type or '*'}'",+            "_hint": "Call fusion_document_info to list open documents by index, or fusion_open_cloud_file to open a new document, then retry.",+            "data": {+                "openDocuments": available,+                "hint": "Use fusion_document_info to see all open documents.",+            },+        }++    # Activate the first match+    target_doc = matches[0]+    try:+        activated = target_doc.activate()+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to activate '{target_doc.name}': {e}",+            "_hint": "Call fusion_get_app_state to check if Fusion is in a usable state; a modal dialog may be blocking.",+            "data": {"hint": "The document may be in a state that prevents activation."},+        }++    # Query workspace after activation+    new_workspace = "unknown"+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+        if ws:+            new_workspace = ws.strip()+    except Exception:+        pass++    response = {+        "success": True,+        "output": f"Activated '{target_doc.name}' — workspace: {new_workspace}",+        "data": {+            "activatedDocument": target_doc.name,+            "documentType": _document_type_str(getattr(target_doc, 'documentType', None)),+            "activeWorkspace": new_workspace,+        },+    }++    # If multiple matches, list them all so Claude can refine+    if len(matches) > 1:+        response["data"]["allMatches"] = [+            {"name": m.name, "type": _document_type_str(getattr(m, 'documentType', None))}+            for m in matches+        ]+        response["data"]["hint"] = (+            f"{len(matches)} documents matched — activated the first one. "+            "Use a more specific name to target a different one."+        )++    return response

@@ -0,0 +1,139 @@+"""Video-friendly view control for the Fusion Electronics (EAGLE) editor.++One bridge call = a whole smooth motion, because the loop runs HERE inside the add-in+(tight timing + a repaint per frame), not as N round-trips from the bridge server.++  fusion_electron_zoom   - smooth zoom in/out (or fit)+  fusion_electron_pan    - smooth pan/zoom to a board-coordinate box+  fusion_electron_select - select a part by name (or x/y) and surface its properties++All EAGLE motion is `app.executeTextCommand("Electron.run WINDOW ...")`; each frame is+forced to render with `Electron.ImmediateRepaint /full` (the 2D analogue of vp.refresh()).+"""++import time+import adsk.core++# Last view box we set, in board mm (x1, y1, x2, y2). Lets pan interpolate from where+# the view actually is. None until the first pan establishes it.+_view_box = None+++def _run(app, eagle_cmd):+    return app.executeTextCommand(f"Electron.run {eagle_cmd}")+++def _repaint(app):+    try:+        app.executeTextCommand("Electron.ImmediateRepaint /full")+    except Exception:+        pass+++def handle_electron_zoom(app: adsk.core.Application, args: dict) -> dict:+    """Smoothly zoom the schematic / 2D board view.++    Args:+        fit:          bool - zoom to fit the whole sheet/board (ignores factor).+        factor:       float - total zoom multiple (>1 = in, <1 = out). Default 2.0.+        steps:        int   - frames over which to ramp (smoothness). Default 16.+        frameDelayMs: int   - ms between frames. Default 35.+    """+    if args.get("fit"):+        _run(app, "WINDOW FIT")+        _repaint(app)+        return {"success": True, "output": "Zoomed to fit."}++    factor = float(args.get("factor", 2.0))+    steps = max(1, int(args.get("steps", 16)))+    delay = float(args.get("frameDelayMs", 35)) / 1000.0+    per = factor ** (1.0 / steps)  # geometric per-frame step -> perceptually even+    for _ in range(steps):+        _run(app, f"WINDOW {per:.5f}")+        _repaint(app)+        adsk.doEvents()+        time.sleep(delay)+    return {+        "success": True,+        "output": f"Zoomed {'in' if factor > 1 else 'out'} {factor}x over {steps} frames.",+    }+++def handle_electron_pan(app: adsk.core.Application, args: dict) -> dict:+    """Smoothly pan + zoom the view to frame a board-coordinate box.++    Coords are board millimetres (get part positions from fusion_board_info). The view+    animates from wherever it last was (tracked) to the target box.++    Args:+        x1, y1, x2, y2: required floats - the target rectangle (board mm).+        steps:          int   - frames. Default 16.+        frameDelayMs:   int   - ms between frames. Default 35.+    """+    global _view_box+    try:+        tx1, ty1 = float(args["x1"]), float(args["y1"])+        tx2, ty2 = float(args["x2"]), float(args["y2"])+    except (KeyError, TypeError, ValueError):+        return {"success": False, "error": "Need x1,y1,x2,y2 (board mm). Get part positions from fusion_board_info."}++    steps = max(1, int(args.get("steps", 16)))+    delay = float(args.get("frameDelayMs", 35)) / 1000.0++    if _view_box is None:+        _run(app, f"WINDOW ({tx1:.3f} {ty1:.3f}) ({tx2:.3f} {ty2:.3f})")+        _repaint(app)+        _view_box = (tx1, ty1, tx2, ty2)+        return {"success": True, "output": "Framed region (no animation - first view set; later pans animate).",+                "data": {"box": _view_box}}++    sx1, sy1, sx2, sy2 = _view_box+    for i in range(1, steps + 1):+        t = i / steps+        x1 = sx1 + (tx1 - sx1) * t+        y1 = sy1 + (ty1 - sy1) * t+        x2 = sx2 + (tx2 - sx2) * t+        y2 = sy2 + (ty2 - sy2) * t+        _run(app, f"WINDOW ({x1:.3f} {y1:.3f}) ({x2:.3f} {y2:.3f})")+        _repaint(app)+        adsk.doEvents()+        time.sleep(delay)+    _view_box = (tx1, ty1, tx2, ty2)+    return {"success": True,+            "output": f"Panned to ({tx1:.1f},{ty1:.1f})-({tx2:.1f},{ty2:.1f}) over {steps} frames.",+            "data": {"box": _view_box}}+++def handle_electron_select(app: adsk.core.Application, args: dict) -> dict:+    """Select a part (by reference designator, or by x/y board coords) and read its+    properties - the way clicking a part in the editor reveals the properties panel.++    Args:+        name (or component): str - reference designator (e.g. "R1"). Cleanest.+        x, y:                floats - board-mm point to click/select (alternative).+        properties:          bool - also return the selected device's info. Default true.+    """+    name = args.get("name") or args.get("component")+    try:+        if name:+            sel = app.executeTextCommand(f"Electron.SelectbyName {name}")+        elif "x" in args and "y" in args:+            app.executeTextCommand(f"Electron.LeftButtonDown {args['x']} {args['y']}")+            sel = app.executeTextCommand(f"Electron.Select {args['x']} {args['y']}")+        else:+            return {"success": False, "error": "Provide {name} (reference designator) or {x,y} (board mm)."}+    except Exception as e:+        return {"success": False, "error": f"Select failed: {e}"}++    _repaint(app)+    info = ""+    if args.get("properties", True):+        try:+            info = app.executeTextCommand("Electron.sch_get_deviceinfo")+        except Exception:+            pass+    return {+        "success": True,+        "output": f"Selected {name or (str(args.get('x')) + ',' + str(args.get('y')))}.",+        "data": {"selection": str(sel)[:300], "deviceInfo": str(info)[:600]},+    }

@@ -0,0 +1,1058 @@+"""Electronics commands — run EAGLE commands via Electron.run text command.++Fusion 360's Electronics workspace (inherited from EAGLE) has no Python API,+but we can use `app.executeTextCommand('Electron.run <cmd>')` to send EAGLE+editor commands into the electronics workspace.++IMPORTANT: The user must be in an Electronics editor (schematic, board, or library)+for Electron.run commands to work. The "Electronics Design" overview/container+workspace does NOT count — the user must have a schematic or board open and active.++Workspace hierarchy:+  "Design"              — Normal 3D CAD (Electron.run fails)+  "Electronics Design"  — Container/overview (Electron.run fails)+  "Schematic Editor"    — Schematic editing (Electron.run works)+  "Board Layout"        — PCB layout editing (Electron.run works)+  "Electronics Library" — Library editing (Electron.run works)++Commands that BLOCK (open dialogs — avoid from automation):+  WRITE               — Opens Save As dialog+  ADD                 — Opens component picker dialog+  SHOW <name>         — Opens interactive highlight mode+  GRID (no params)    — Opens grid settings dialog+  EDIT <new>.sym      — Opens "Create new?" confirmation dialog++Safe automation patterns:+  SCRIPT '<path>.scr' — Runs batch commands from file (non-interactive)+  EXPORT SCRIPT       — Exports library/schematic to .scr file (for verification)+  DISPLAY             — Shows/hides layers (non-interactive)+  WINDOW FIT          — Zoom to fit+  EDIT <existing>.sym — Opens existing symbol (no dialog)+  SET CONFIRM YES     — In .scr: suppresses create-new confirmations+"""++import adsk.core+import glob+import os+import re+import tempfile+++def _get_fusion_log_path() -> str | None:+    """Find the latest Fusion 360 log file."""+    log_dir = os.path.join(+        os.environ.get("LOCALAPPDATA", ""),+        "Autodesk", "Autodesk Fusion 360",+    )+    # Find user-specific log dir (e.g. X3G293QFLPJERKGZ/logs/)+    for entry in os.listdir(log_dir):+        candidate = os.path.join(log_dir, entry, "logs")+        if os.path.isdir(candidate):+            logs = sorted(glob.glob(os.path.join(candidate, "AppLogFile*.log")),+                          key=os.path.getmtime, reverse=True)+            if logs:+                return logs[0]+    return None+++def _get_log_line_count(log_path: str) -> int:+    """Get current line count of a log file (fast — seeks to end)."""+    try:+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:+            return sum(1 for _ in f)+    except Exception:+        return 0+++def _check_log_for_alerts(log_path: str, after_line: int) -> list[str]:+    """Check Fusion log for 'New Alert message' entries after a given line number.++    Returns list of alert message texts (the error toast content).+    """+    alerts = []+    try:+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:+            for i, line in enumerate(f, 1):+                if i <= after_line:+                    continue+                if "New Alert message" in line:+                    # Extract: "Tooltip: <msg>, Short Message: <msg>"+                    m = re.search(r"Short Message:\s*(.+?)(?:,\s*Long Message:|$)", line)+                    if m:+                        alerts.append(m.group(1).strip())+                    else:+                        # Fallback: grab everything after "Tooltip: "+                        m2 = re.search(r"Tooltip:\s*(.+?)(?:,|$)", line)+                        if m2:+                            alerts.append(m2.group(1).strip())+    except Exception:+        pass+    return alerts+++def _extract_export_path(eagle_cmd: str) -> str | None:+    """Extract the output file path from an EAGLE EXPORT command.++    EAGLE EXPORT commands use single-quoted paths:+      EXPORT NETLIST 'C:/tmp/netlist.txt'+      EXPORT IMAGE 'C:/tmp/board.png' 300+      EXPORT PARTLIST 'C:/tmp/parts.txt'++    Returns the unquoted path, or None if not found.+    """+    # Match single-quoted path+    m = re.search(r"'([^']+)'", eagle_cmd)+    if m:+        return m.group(1)+    # Fallback: look for unquoted path-like tokens (with / or \ and an extension)+    parts = eagle_cmd.strip().split()+    for part in parts[2:]:  # Skip "EXPORT" and subcommand+        cleaned = part.strip("'\"")+        if ("/" in cleaned or "\\" in cleaned) and "." in cleaned:+            return cleaned+    return None+++def _get_workspace_info(app: adsk.core.Application) -> dict:+    """Get current workspace info and whether Electronics Electron editor is active."""+    try:+        active_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+    except Exception:+        active_ws = "unknown"++    is_electron = False+    try:+        app.executeTextCommand("Electron.run DISPLAY")+        is_electron = True+    except Exception:+        pass++    # Get document info+    doc_info = None+    try:+        doc = app.activeDocument+        if doc:+            doc_info = {"name": doc.name, "type": str(doc.documentType)}+    except Exception:+        pass++    # Get product type+    product_type = None+    try:+        product = app.activeProduct+        if product:+            product_type = product.productType+    except Exception:+        pass++    info = {+        "activeWorkspace": active_ws.strip() if active_ws else "unknown",+        "isElectronics": is_electron,+    }+    if doc_info:+        info["document"] = doc_info+    if product_type:+        info["productType"] = product_type+    return info+++def _get_recent_operations(app: adsk.core.Application, count: int = 5) -> list:+    """Get recent Fusion operations log via Diagnostics.RecentOperations."""+    try:+        result = app.executeTextCommand(f"Diagnostics.RecentOperations {count}")+        if result:+            lines = [l.strip() for l in result.strip().split("\r\n") if l.strip()]+            # Filter to just command begin/end, skip DLL loads+            return [l for l in lines if l.startswith("Command ")]+        return []+    except Exception:+        return []+++def _query_post_command_state(app: adsk.core.Application, eagle_cmd: str, ops_before: list) -> dict:+    """Query Fusion state after an Electron.run command to return meaningful feedback.++    Uses Diagnostics.RecentOperations to diff what actually happened, plus+    workspace/document state for context.+    """+    import time+    time.sleep(0.3)  # Brief pause for command to take effect++    state = {}++    # Always include workspace info+    try:+        active_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+        state["activeWorkspace"] = active_ws.strip() if active_ws else "unknown"+    except Exception:+        state["activeWorkspace"] = "unknown"++    # Active document+    try:+        doc = app.activeDocument+        if doc:+            state["activeDocument"] = doc.name+    except Exception:+        pass++    # Diff operations log — what commands fired as a result?+    ops_after = _get_recent_operations(app, 10)+    if ops_before and ops_after:+        # Find new operations that weren't in the before snapshot+        new_ops = []+        for op in ops_after:+            if op not in ops_before:+                new_ops.append(op)+        if new_ops:+            state["fusionOperations"] = new_ops[:5]  # Cap at 5 to keep response size sane++    # Parse command to provide targeted feedback+    cmd_parts = eagle_cmd.strip().split(None, 1)+    cmd_verb = cmd_parts[0].upper() if cmd_parts else ""+    cmd_upper = eagle_cmd.strip().upper()++    # Command-specific hints and extra queries+    if cmd_verb == "DISPLAY":+        state["commandType"] = "layer_visibility"+        state["hint"] = "DISPLAY command executed. Use fusion_take_screenshot to verify layer changes visually."++    elif cmd_verb == "WINDOW":+        state["commandType"] = "view_control"+        state["hint"] = "Zoomed to fit all content in view." if "FIT" in cmd_upper else "View position/zoom changed."++    elif cmd_verb == "EDIT":+        target = cmd_parts[1] if len(cmd_parts) > 1 else ""+        state["commandType"] = "edit"+        ext_map = {".sym": "symbol", ".pac": "package", ".dev": "device"}+        for ext, editor in ext_map.items():+            if target.endswith(ext):+                state["hint"] = f"Opened {editor} editor for: {target}"+                state["editorType"] = editor+                break+        else:+            state["hint"] = f"Opened editor for: {target}"++    elif cmd_verb == "RATSNEST":+        state["commandType"] = "ratsnest"+        state["hint"] = "Ratsnest (airwires) recalculated."++    elif cmd_verb == "BOARD":+        state["commandType"] = "view_switch"+        state["hint"] = "Requested switch to board layout. Verify with a screenshot."++    elif cmd_verb == "SET":+        state["commandType"] = "setting"+        state["hint"] = f"Setting changed: {eagle_cmd.strip()}"++    elif cmd_verb == "SCRIPT":+        state["commandType"] = "script"+        state["hint"] = f"Script executed: {cmd_parts[1] if len(cmd_parts) > 1 else '(unknown)'}"++    elif cmd_verb == "USE":+        state["commandType"] = "library_load"+        state["hint"] = f"Library load requested: {cmd_parts[1] if len(cmd_parts) > 1 else '(unknown)'}"++    elif cmd_verb in ("NAME", "VALUE", "SMASH", "MOVE", "ROTATE", "DELETE", "COPY", "GROUP",+                       "ROUTE", "RIPUP", "WIRE", "CIRCLE", "RECT", "POLYGON", "TEXT", "ARC",+                       "PAD", "SMD", "VIA", "HOLE", "PIN", "LABEL", "NET", "BUS", "JUNCTION"):+        state["commandType"] = "design_edit"+        state["hint"] = f"Design edit command executed: {cmd_verb}"++    elif cmd_verb == "EXPORT":+        state["commandType"] = "export"+        # Try to verify the export actually produced a file+        # Parse output path from command: EXPORT <TYPE> <path> [options]+        export_parts = eagle_cmd.strip().split()+        export_path = None+        if len(export_parts) >= 3:+            # The path is typically the 3rd token (after EXPORT <TYPE>)+            candidate = export_parts[2]+            # Handle quoted paths+            if candidate.startswith(("'", '"')):+                quote = candidate[0]+                rest = eagle_cmd.strip().split(quote)+                if len(rest) >= 3:+                    export_path = rest[1]+            else:+                export_path = candidate++        if export_path:+            import os+            if os.path.exists(export_path):+                fsize = os.path.getsize(export_path)+                state["hint"] = f"Export succeeded: {export_path} ({fsize} bytes)"+                state["exportedFile"] = export_path+                state["exportedFileSize"] = fsize+            else:+                state["hint"] = (+                    f"Export command ran but output file NOT found at: {export_path}. "+                    "The EAGLE command may have failed silently — check Fusion's error toast or operations log."+                )+                state["exportFailed"] = True+                state["expectedPath"] = export_path+        else:+            state["hint"] = f"Export command executed: {eagle_cmd.strip()}"++    else:+        state["commandType"] = "generic"+        state["hint"] = f"Command executed: {eagle_cmd.strip()}. Use fusion_take_screenshot to verify the result visually."++    # If no Fusion operations fired, the command likely failed silently.+    # EAGLE's Electron.run never returns errors — failures only show as+    # toast dialogs on the user's screen that are invisible to the API.+    # We check Fusion's error log for alert toasts (see handle_electron_run),+    # but log writes are async so errors may appear after our check window.+    if "fusionOperations" not in state or not state["fusionOperations"]:+        state["possibleFailure"] = True+        state["hint"] = (+            f"WARNING: No Fusion operations detected after '{cmd_verb}'. "+            f"The command likely failed silently. Check the 'alertErrors' field "+            f"in this response — if populated, it contains the actual Fusion error "+            f"message captured from the log. If 'alertErrors' is empty, the error "+            f"may not have been logged yet; take a screenshot with "+            f"fusion_take_screenshot to see the error toast in Fusion's UI. "+            f"Original hint: {state.get('hint', '')}"+        )++    return state+++def handle_electron_run(app: adsk.core.Application, args: dict) -> dict:+    """Execute an EAGLE command in the Electronics workspace via Electron.run.++    Requires an active Electronics editor (schematic, board, or library).+    Returns workspace state + Fusion operations log diff after execution.++    Args:+        args: Dict with:+            - command: The EAGLE command to execute (required).+              Examples: "EDIT resistor.sym", "USE mylib.lbr", "WINDOW FIT"+    """+    eagle_cmd = args.get("command", "")+    if not eagle_cmd:+        return {"success": False, "error": "No command specified. Provide an EAGLE command string."}++    # Check we're in Electronics before executing+    ws_info = _get_workspace_info(app)+    if not ws_info["isElectronics"]:+        return {+            "success": False,+            "error": f"Not in Electronics editor (current: {ws_info['activeWorkspace']}). "+                     "Open a schematic or board in Fusion 360's Electronics workspace first.",+            "_hint": "Call fusion_open_schematic {\"filePath\":\"...\"}, fusion_open_board {\"filePath\":\"...\"}, or fusion_open_lbr {\"filePath\":\"...\"} to enter the Electronics editor, then retry.",+            "data": {+                **ws_info,+                "hint": "Use fusion_open_schematic, fusion_open_board, or fusion_open_lbr to open an electronics file first.",+            },+        }++    # Parse the first word as the command verb for validation and routing.+    cmd_verb = eagle_cmd.strip().split()[0].upper() if eagle_cmd.strip() else ""++    # Block commands that don't work in Fusion's Electronics workspace or that+    # pop up error dialogs on the user's screen with no useful result.+    BLOCKED_COMMANDS = {+        "SCHEMATIC": "Use fusion_show_2d_board or fusion_electron_run '{\"command\": \"BOARD\"}' to switch between schematic/board views. "+                     "The SCHEMATIC command doesn't exist in Fusion's EAGLE integration.",+        "ADD": "Opens an interactive component picker dialog that blocks automation. "+               "Place components through the Fusion UI instead.",+        "SHOW": "Opens interactive highlight mode that blocks automation. "+                "Use fusion_board_info to query component/net data instead.",+        "CHANGE": "Opens interactive change mode that blocks automation.",+        "MOVE": "Opens interactive move mode — requires clicking to place. "+                "Not suitable for CLI automation. Use the Fusion API to move components programmatically.",+    }++    # WRITE always opens a blocking "Version Description" dialog on cloud docs,+    # even when a path argument is provided. Tested 2026-04-10 — WRITE <path>+    # still triggers the dialog. Block unconditionally.+    if cmd_verb == "WRITE":+        return {+            "success": False,+            "error": "Command 'WRITE' is blocked — it opens a blocking 'Version Description' save dialog "+                     "on cloud documents, even when a path argument is provided (tested 2026-04-10). "+                     "Use fusion_export_source for .fsch/.fbrd export, or fusion_export_eagle_source for .sch/.brd.",+            "_hint": "For Fusion-format source: fusion_export_source {\"outputPath\":\"C:/out/file.fbrd\"}. "+                     "For EAGLE-format source: fusion_export_eagle_source {\"outputPath\":\"C:/out/file.brd\"}.",+            "data": {+                "command": eagle_cmd,+                "blockedVerb": "WRITE",+                "activeWorkspace": ws_info["activeWorkspace"],+            },+        }++    if cmd_verb in BLOCKED_COMMANDS:+        return {+            "success": False,+            "error": f"Command '{cmd_verb}' is blocked for automation: {BLOCKED_COMMANDS[cmd_verb]}",+            "_hint": f"'{cmd_verb}' opens an interactive dialog. Use fusion_board_info / fusion_save_to_cloud / the Fusion API alternatives instead of this EAGLE command.",+            "data": {+                "command": eagle_cmd,+                "blockedVerb": cmd_verb,+                "hint": BLOCKED_COMMANDS[cmd_verb],+                "activeWorkspace": ws_info["activeWorkspace"],+            },+        }++    # Auto-suppress overwrite/confirmation dialogs for EXPORT commands.+    # Without this, EAGLE shows a Qt "Overwrite?" dialog that blocks the+    # add-in thread and is invisible to the CLI/AI — freezing everything.+    export_target_path = None+    if cmd_verb == "EXPORT":+        try:+            app.executeTextCommand("Electron.run SET CONFIRM YES")+        except Exception:+            pass  # Best effort — don't block if SET fails++        # Extract the output file path from the EXPORT command.+        # EAGLE EXPORT syntax: EXPORT <type> '<path>' [options]+        # Paths are typically single-quoted: EXPORT NETLIST '/path/to/file.txt'+        export_target_path = _extract_export_path(eagle_cmd)+        if export_target_path and os.path.exists(export_target_path):+            try:+                os.remove(export_target_path)+            except PermissionError:+                return {+                    "success": False,+                    "error": f"Cannot overwrite '{export_target_path}' — file is locked by another process.",+                    "_hint": "Choose a different outputPath (e.g., append a timestamp) and retry the EXPORT command.",+                    "data": {+                        "command": eagle_cmd,+                        "filePath": export_target_path,+                        "hint": "The target file exists and is locked. Close any program using it, "+                                "or choose a different output path.",+                        "nextSteps": [+                            f"Delete or rename '{export_target_path}' manually",+                            "Or use a different output path in the EXPORT command",+                        ],+                    },+                }+            except Exception as e:+                return {+                    "success": False,+                    "error": f"Cannot remove existing file '{export_target_path}': {e}",+                    "data": {+                        "command": eagle_cmd,+                        "filePath": export_target_path,+                        "hint": "Pre-delete failed. Use a different output path to avoid the overwrite dialog.",+                    },+                }++    # Snapshot operations log and Fusion error log BEFORE execution+    ops_before = _get_recent_operations(app, 10)+    log_path = _get_fusion_log_path()+    log_line_before = _get_log_line_count(log_path) if log_path else 0++    try:+        raw_result = app.executeTextCommand(f"Electron.run {eagle_cmd}")+    except Exception as e:+        return {+            "success": False,+            "error": f"Electron.run failed: {e}",+            "_hint": "Check the active workspace with fusion_execute_text_command {\"command\": \"DebugCommands.ActiveWorkspace\"} — EAGLE commands need the right editor (schematic vs board vs library). Call fusion_open_schematic / fusion_open_board / fusion_open_lbr to switch.",+            "data": {+                "command": eagle_cmd,+                "hint": "The command may be invalid or require a specific editor context (schematic vs board vs library).",+            },+        }++    # Query state after execution — includes ops log diff+    post_state = _query_post_command_state(app, eagle_cmd, ops_before)++    # Check Fusion's error log for alert messages that appeared after the command.+    # These are the toast errors shown in the lower-right of Fusion's UI that+    # Electron.run silently swallows — the only way to detect them is via the log.+    # Fusion writes to the log asynchronously, so we poll with increasing delays.+    alert_errors = []+    if log_path:+        import time+        for _attempt in range(4):+            time.sleep(0.3 if _attempt == 0 else 0.5)+            alert_errors = _check_log_for_alerts(log_path, log_line_before)+            if alert_errors:+                break++    # Detect export failures (command ran but output file not created)+    succeeded = True+    if post_state.get("exportFailed"):+        succeeded = False++    # If Fusion logged alert errors, the command failed+    if alert_errors:+        succeeded = False+        post_state["alertErrors"] = alert_errors+        post_state["hint"] = (+            f"EAGLE error: {alert_errors[0]}. "+            f"Original hint: {post_state.get('hint', '')}"+        )++    # For EXPORT commands, verify the output file exists and report size+    export_data = {}+    if cmd_verb == "EXPORT" and export_target_path:+        import time+        time.sleep(0.5)  # Give EAGLE a moment to flush to disk+        if os.path.exists(export_target_path):+            fsize = os.path.getsize(export_target_path)+            export_data = {+                "exportedFile": export_target_path,+                "fileSizeBytes": fsize,+                "fileSizeKB": fsize // 1024,+            }+            succeeded = True  # Override exportFailed if file actually exists+        else:+            succeeded = False+            export_data = {+                "exportedFile": export_target_path,+                "exportFailed": True,+                "hint": f"EXPORT command ran but file was not created at '{export_target_path}'. "+                        "This EXPORT subcommand may not be supported in the current editor context.",+            }++    result = {+        "success": succeeded,+        "error": alert_errors[0] if alert_errors else "",+        "output": post_state.get("hint", f"Executed: {eagle_cmd}"),+        "data": {+            "command": eagle_cmd,+            "rawResult": raw_result if raw_result else "",+            "alertErrors": alert_errors,+            **post_state,+            **export_data,+        },+    }++    # If we suspect failure but didn't catch a log error, hint the AI+    # that errors from Electron.run are async — the real error may appear+    # in the next command's alertErrors or in a screenshot.+    if post_state.get("possibleFailure") and not alert_errors:+        result["data"]["asyncErrorHint"] = (+            "Electron.run is fire-and-forget — errors only appear as toast "+            "dialogs in Fusion's UI. The error log was checked but nothing "+            "appeared yet. Run fusion_take_screenshot to see the current "+            "Fusion state and check for error toasts."+        )++    return result+++def handle_open_electronics(app: adsk.core.Application, args: dict) -> dict:+    """Check Electronics workspace status and optionally open a file.++    PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.++    Args:+        args: Dict with:+            - type: "status" to just check (default). Other values reserved+                   for future use (workspace switching handled by bridge server).+            - filePath: Optional path to a .sch, .brd, or .lbr file to open+                       (only works if already in Electronics editor).+    """+    file_path = args.get("filePath", "")+    ws_info = _get_workspace_info(app)++    # If already in electronics, handle file opening or return status+    if ws_info["isElectronics"]:+        if file_path:+            try:+                result = app.executeTextCommand(f"Electron.run EDIT '{file_path}'")+                return {+                    "success": True,+                    "output": f"Opened {file_path} in Electronics workspace.",+                    "data": {"result": result if result else "", **ws_info},+                }+            except Exception as e:+                return {+                    "success": False,+                    "error": f"Failed to open {file_path}: {e}",+                    "_hint": "Verify the file exists on the Windows host, then try fusion_open_schematic or fusion_open_board with the correct filePath.",+                }+        return {+            "success": True,+            "output": "Electronics editor is active. Electron.run commands will work.",+            "data": ws_info,+        }++    # Not in Electronics — report status+    return {+        "success": True,+        "output": f"Not in Electronics editor (current workspace: {ws_info['activeWorkspace']}).",+        "data": ws_info,+    }+++def handle_export_source(app: adsk.core.Application, args: dict) -> dict:+    """Export the active electronics document as .fsch, .fbrd, or .flbr source file.++    Uses Fusion's Document.CopyToDesktop text command, which exports the+    currently active document in its native format based on the file extension.++    PREREQUISITES — the caller MUST set up the correct view before calling:++    To export .fbrd (board):+      1. Open the .fprj:  fusion_open_cloud_file {"projectName":"Main", "fileName":"MyDesign", "fileExtension":"fprj", ...}+      2. Enter board view: fusion_show_2d_board+      3. Export:           fusion_export_source {"outputPath": "C:/out/MyDesign.fbrd"}++    To export .fsch (schematic):+      4. Switch to schematic: fusion_electron_run {"command": "EDIT .s1"}+      5. Export:              fusion_export_source {"outputPath": "C:/out/MyDesign.fsch"}++    To export .flbr (library):+      1. Open the .lbr:   fusion_open_lbr {"filePath": "C:/path/to/lib.lbr"}+      2. Export:           fusion_export_source {"outputPath": "C:/out/MyLib.flbr"}++    IMPORTANT GOTCHAS:+    - You MUST open the .fprj file first, NOT .fbrd/.fsch directly+    - You MUST call show_2d_board before exporting .fbrd (the 3D board view won't work)+    - To switch between board and schematic: use EDIT .s1 (schematic) or EDIT .brd (board)+    - The active workspace MUST be "Board Layout" for .fbrd or "Schematic Editor" for .fsch+    - If the wrong workspace is active, the file will not be created+    - After opening cloud file, wait for the document to fully load before exporting+    - Always screenshot after open to check for blocking dialogs before exporting++    Args:+        args: Dict with:+            - outputPath: Required. Full path including extension (.fsch, .fbrd, or .flbr).+              The extension determines the export format.+    """+    import os++    output_path = args.get("outputPath", "").strip()+    if not output_path:+        return {+            "success": False,+            "error": "Missing required arg: outputPath",+            "_hint": "Provide outputPath with extension .fsch, .fbrd, or .flbr. "+                     "For plain EAGLE format (.sch/.brd), use fusion_export_eagle_source instead.",+        }++    # Validate extension+    ext = os.path.splitext(output_path)[1].lower()+    valid_exts = {".fsch", ".fbrd", ".flbr"}+    if ext not in valid_exts:+        return {+            "success": False,+            "error": f"Invalid extension '{ext}'. Must be one of: {', '.join(sorted(valid_exts))}",+            "_hint": "Use .fsch for schematic source, .fbrd for board source, .flbr for library source. "+                     "For plain EAGLE format (.sch/.brd), use fusion_export_eagle_source instead.",+        }++    # Ensure output directory exists+    out_dir = os.path.dirname(output_path)+    if out_dir:+        os.makedirs(out_dir, exist_ok=True)++    # Normalize path for Fusion (use forward slashes)+    fusion_path = output_path.replace("\\", "/")++    try:+        result = app.executeTextCommand(f"Document.CopyToDesktop {fusion_path}")+    except Exception as e:+        return {+            "success": False,+            "error": f"Document.CopyToDesktop failed: {e}",+            "_hint": "Ensure the correct workspace is active: Board Layout for .fbrd, Schematic Editor for .fsch, Electronics Library for .flbr. Call fusion_show_2d_board or fusion_electron_run {\"command\":\"EDIT .s1\"} to switch.",+        }++    # Verify file was created+    # Fusion may use the exact path or normalize it+    check_path = output_path.replace("/", "\\")+    if not os.path.exists(check_path) and not os.path.exists(output_path):+        return {+            "success": False,+            "error": f"Command ran but file not found at {output_path}. "+                     "Make sure the correct editor is active (Board Layout for .fbrd, "+                     "Schematic Editor for .fsch).",+            "_hint": "Call fusion_show_2d_board (for .fbrd) or fusion_electron_run {\"command\":\"EDIT .s1\"} (for .fsch) to activate the right workspace, then retry.",+            "data": {"commandResult": result.strip() if result else ""},+        }++    actual_path = check_path if os.path.exists(check_path) else output_path+    size_bytes = os.path.getsize(actual_path)++    # Get active document context+    doc_name = ""+    workspace = ""+    try:+        doc = app.activeDocument+        if doc:+            doc_name = doc.name+        workspace = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    return {+        "success": True,+        "output": f"Exported {ext} source ({size_bytes:,} bytes) to {output_path}",+        "data": {+            "savedTo": output_path.replace("\\", "/"),+            "sizeBytes": size_bytes,+            "format": ext.lstrip("."),+            "activeDocument": doc_name,+            "activeWorkspace": workspace,+        },+    }+++def handle_export_eagle_source(app: adsk.core.Application, args: dict) -> dict:+    """Export the active electronics document as plain EAGLE .sch or .brd XML.++    Fusion's .fsch/.fbrd files are ZIP containers with a real EAGLE .sch/.brd+    XML file inside at `electron.BlobParts/ExtFile.*.{sch,brd}`. This command:+      1. Exports the .fsch/.fbrd via Document.CopyToDesktop (same as fusion_export_source)+      2. Extracts the inner EAGLE XML from the ZIP+      3. Writes it to outputPath as a plain EAGLE file+      4. Cleans up the intermediate .fsch/.fbrd++    The resulting file is valid EAGLE XML (`<?xml ...><eagle version="9.7.0">...`)+    that can be opened by standalone EAGLE, KiCad (via import), or parsed by any+    XML tool.++    PREREQUISITES — same as fusion_export_source:+      Board (.brd):  must be in "Board Layout" / "PCB Editor" workspace+      Schematic (.sch): must be in "Schematic Editor" workspace++    Args:+        args: Dict with:+            - outputPath: Required. Full path ending in .sch or .brd.+    """+    import tempfile+    import zipfile++    output_path = args.get("outputPath", "").strip()+    if not output_path:+        return {"success": False, "error": "Missing required arg: outputPath"}++    ext = os.path.splitext(output_path)[1].lower()+    valid_exts = {".sch": ".fsch", ".brd": ".fbrd"}+    if ext not in valid_exts:+        return {+            "success": False,+            "error": f"Invalid extension '{ext}'. Must be .sch or .brd.",+            "_hint": "For Fusion-format source (.fsch/.fbrd/.flbr), use fusion_export_source instead.",+        }++    fusion_ext = valid_exts[ext]  # .sch -> .fsch, .brd -> .fbrd++    # Export to a temp .fsch/.fbrd first+    tmp_dir = tempfile.mkdtemp(prefix="adom-eagle-")+    tmp_fusion_path = os.path.join(tmp_dir, f"temp{fusion_ext}")+    fusion_path = tmp_fusion_path.replace("\\", "/")++    try:+        result = app.executeTextCommand(f"Document.CopyToDesktop {fusion_path}")+    except Exception as e:+        return {+            "success": False,+            "error": f"Document.CopyToDesktop failed: {e}",+            "_hint": "Ensure the correct workspace is active: PCB Editor / Board Layout for .brd, "+                     "Schematic Editor for .sch. Use fusion_show_2d_board or "+                     "fusion_electron_run {\"command\":\"EDIT .s1\"} to switch.",+        }++    # Check if the file was created+    check_path = tmp_fusion_path.replace("/", "\\")+    actual_tmp = None+    for p in [check_path, tmp_fusion_path]:+        if os.path.exists(p):+            actual_tmp = p+            break++    if not actual_tmp:+        return {+            "success": False,+            "error": f"Document.CopyToDesktop ran but intermediate {fusion_ext} file not found.",+            "_hint": "Ensure the correct workspace is active: PCB Editor / Board Layout for .brd, "+                     "Schematic Editor for .sch.",+        }++    # Extract the EAGLE XML from the ZIP container+    eagle_data = None+    inner_name = None+    try:+        with zipfile.ZipFile(actual_tmp, "r") as zf:+            for name in zf.namelist():+                if name.endswith(ext):  # Find the .sch or .brd inside+                    eagle_data = zf.read(name)+                    inner_name = name+                    break+    except Exception as e:+        # Clean up temp+        try:+            os.remove(actual_tmp)+            os.rmdir(tmp_dir)+        except Exception:+            pass+        return {+            "success": False,+            "error": f"Failed to read {fusion_ext} ZIP container: {e}",+        }++    # Clean up temp file+    try:+        os.remove(actual_tmp)+        os.rmdir(tmp_dir)+    except Exception:+        pass++    if not eagle_data:+        return {+            "success": False,+            "error": f"No {ext} file found inside {fusion_ext} ZIP container.",+            "_hint": "The Fusion container format may have changed. Use fusion_export_source "+                     "to get the raw .fsch/.fbrd and inspect with a ZIP tool.",+        }++    # Verify it looks like EAGLE XML+    header = eagle_data[:100].decode("utf-8", errors="replace")+    if "<eagle" not in header and "<?xml" not in header:+        return {+            "success": False,+            "error": f"Extracted file does not appear to be EAGLE XML. "+                     f"First 100 bytes: {header!r}",+        }++    # Write to output path+    out_dir = os.path.dirname(output_path)+    if out_dir:+        os.makedirs(out_dir, exist_ok=True)++    with open(output_path, "wb") as f:+        f.write(eagle_data)++    size_bytes = len(eagle_data)++    # Get context+    doc_name = ""+    workspace = ""+    try:+        doc = app.activeDocument+        if doc:+            doc_name = doc.name+        workspace = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    return {+        "success": True,+        "output": f"Exported EAGLE {ext} ({size_bytes:,} bytes) to {output_path}",+        "data": {+            "savedTo": output_path.replace("\\", "/"),+            "sizeBytes": size_bytes,+            "format": ext.lstrip("."),+            "innerZipEntry": inner_name,+            "activeDocument": doc_name,+            "activeWorkspace": workspace,+        },+        "_hint": "This is a plain EAGLE XML file — parseable by standalone EAGLE, "+                 "KiCad import, or any XML tool. For Fusion-format source, use "+                 "fusion_export_source instead.",+    }+++def handle_execute_text_command(app: adsk.core.Application, args: dict) -> dict:+    """Execute any Fusion 360 text command directly.++    This is a lower-level command that runs `app.executeTextCommand()` without+    any wrapper. Useful for workspace info, debugging, or non-Electron commands.++    Unlike Electron.run, many text commands DO return meaningful results+    (e.g., DebugCommands.ActiveWorkspace returns the workspace name).++    Args:+        args: Dict with:+            - command: The full text command to execute (required).+    """+    text_cmd = args.get("command", "")+    if not text_cmd:+        return {"success": False, "error": "No command specified."}++    try:+        result = app.executeTextCommand(text_cmd)++        data = {"command": text_cmd, "result": result.strip() if result else ""}++        # Add workspace context for common debug queries+        if not text_cmd.startswith("DebugCommands.ActiveWorkspace"):+            try:+                ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+                data["activeWorkspace"] = ws.strip() if ws else "unknown"+            except Exception:+                pass++        try:+            doc = app.activeDocument+            if doc:+                data["activeDocument"] = doc.name+        except Exception:+            pass++        return {+            "success": True,+            "output": result.strip() if result else f"Executed: {text_cmd} (no output)",+            "data": data,+        }+    except Exception as e:+        return {+            "success": False,+            "error": f"Text command failed: {e}",+            "_hint": "Call fusion_list_text_commands to discover valid commands, or verify the active workspace supports this command.",+        }+++def handle_list_text_commands(app: adsk.core.Application, args: dict) -> dict:+    """List available Fusion 360 text commands matching a filter.++    Args:+        args: Dict with:+            - filter: Optional filter string (default: "Electron").+    """+    filter_str = args.get("filter", "Electron")++    try:+        result = app.executeTextCommand("TextCommands.List")+        if result:+            lines = result.split("\n")+            matching = [l for l in lines if filter_str.lower() in l.lower()]+            return {+                "success": True,+                "output": f"Found {len(matching)} commands matching '{filter_str}'",+                "data": {+                    "commands": matching[:50],+                    "total": len(matching),+                },+            }+        return {+            "success": True,+            "output": "TextCommands.List returned no output",+            "data": {"commands": []},+        }+    except Exception as e:+        return {+            "success": False,+            "error": f"TextCommands.List failed: {e}",+            "_hint": "Ensure an Electronics workspace is active — call fusion_open_schematic, fusion_open_board, or fusion_open_lbr first, then retry.",+        }+++def handle_board_info(app: adsk.core.Application, args: dict) -> dict:+    """Get structured board data from the current PCB layout.++    Returns XML with copper traces, pads, component placements (name, x, y,+    rotation), net names, layer setup, board thickness, DRC violations, and+    library packages used. Only works when a .brd board is open in PCB Editor.++    This is much richer than a screenshot — the AI can read exact coordinates,+    net connectivity, and component positions.+    """+    # Electron.boardInfo requires an output file path+    board_info_path = os.path.join(tempfile.gettempdir(), "adom_board_info.xml")++    try:+        app.executeTextCommand(f"Electron.boardInfo {board_info_path}")+    except Exception as e:+        err_msg = str(e)+        if "not PCB2d document" in err_msg.lower() or "not pcb" in err_msg.lower():+            ws = "unknown"+            try:+                ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+            except Exception:+                pass+            return {+                "success": False,+                "error": f"No board open (current workspace: {ws}). Open a .brd file first with fusion_open_board.",+                "_hint": "Call fusion_open_board {\"filePath\":\"...\"} or fusion_show_2d_board to enter Board Layout, then retry.",+                "data": {"activeWorkspace": ws},+            }+        return {+            "success": False,+            "error": f"boardInfo failed: {e}",+            "_hint": "Ensure a .brd file is open in Board Layout — call fusion_show_2d_board first, then retry.",+        }++    # Read the output file (Fusion writes UTF-16 LE BOM)+    result = None+    for enc in ("utf-16", "utf-8-sig", "utf-8"):+        try:+            with open(board_info_path, "r", encoding=enc) as f:+                result = f.read()+            break+        except (UnicodeDecodeError, UnicodeError):+            continue+    if result is None:+        try:+            with open(board_info_path, "rb") as f:+                raw = f.read()+            return {"success": False, "error": f"Failed to decode boardInfo (first bytes: {raw[:20].hex()})"}+        except Exception as e:+            return {"success": False, "error": f"Failed to read boardInfo output: {e}"}++    if not result:+        return {"success": False, "error": "boardInfo returned no data. Is a .brd board open?"}++    # Parse the XML to extract a summary for the AI+    import xml.etree.ElementTree as ET+    summary = {}+    try:+        root = ET.fromstring(result)+        board = root.find("g")+        if board is not None:+            summary["name"] = board.get("name", "")+            summary["unit"] = board.get("unit", "mm")+            summary["boardThickness"] = board.get("boardThickness", "")+            summary["layerSetup"] = board.get("layersetup", "")++        # Extract component placements from <libraries>+        components = []+        for lib_group in root.iter("g"):+            lib = lib_group.get("library")+            pkg = lib_group.get("package")+            if lib and pkg:+                for comp in lib_group.findall("g"):+                    name = comp.get("name")+                    if name:+                        components.append({+                            "name": name,+                            "library": lib,+                            "package": pkg,+                            "x": comp.get("x"),+                            "y": comp.get("y"),+                            "rotation": comp.get("rot", "R0"),+                            "locked": comp.get("LOCKED", "false") == "true",+                        })+        summary["components"] = components+        summary["componentCount"] = len(components)++        # Extract net names from copper traces+        nets = set()+        for copper in root.iter("copper"):+            net_name = copper.get("name", "")+            if net_name:+                nets.add(net_name)+        summary["nets"] = sorted(nets)+        summary["netCount"] = len(nets)++        # Extract DRC issues+        drc = root.find(".//drc")+        if drc is not None:+            overlaps = []+            for overlap in drc.findall(".//overlap"):+                for signal in overlap.findall("signal"):+                    overlaps.append(signal.get("name", ""))+            if overlaps:+                summary["drcOverlaps"] = overlaps++    except ET.ParseError:+        # If XML parsing fails, just return the raw result+        pass++    return {+        "success": True,+        "output": f"Board info: {summary.get('name', 'unknown')}, "+                  f"{summary.get('componentCount', 0)} components, "+                  f"{summary.get('netCount', 0)} nets",+        "data": {+            "summary": summary,+            "rawXml": result,  # Full XML for detailed analysis if needed+        },+    }

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

@@ -0,0 +1,107 @@+"""Import file command — open STEP, IGES, SAT, STL, etc. into the active design."""++import adsk.core+import adsk.fusion+from pathlib import Path++SUPPORTED_EXTENSIONS = {+    ".step", ".stp",+    ".iges", ".igs",+    ".sat",+    ".sab",+    ".smb",+    ".smt",+    ".f3d", ".f3z",+    ".stl",+    ".3mf",+    ".obj",+}+++def handle_import_file(app: adsk.core.Application, args: dict) -> dict:+    """Import a file into Fusion 360 using the native import API.++    Args:+        args: Dict with:+            - filePath: Full path to the file to import (required).+    """+    file_path = args.get("filePath", "")+    if not file_path:+        return {"success": False, "error": "No filePath specified"}++    path = Path(file_path)+    if not path.exists():+        return {+            "success": False,+            "error": f"File not found: {file_path}",+            "_hint": "The path may exist on Docker but not on the Windows host. Use push_file to copy from Docker first, or verify the host-side path.",+        }++    ext = path.suffix.lower()+    if ext not in SUPPORTED_EXTENSIONS:+        return {+            "success": False,+            "error": f"Unsupported file type: {ext}. Supported: {', '.join(sorted(SUPPORTED_EXTENSIONS))}",+            "_hint": "Use fusion_import_electronics for .fsch/.fbrd/.flbr electronics files, or verify the extension is one of the 3D formats Fusion supports.",+        }++    import_mgr = app.importManager++    try:+        # Select the right import options based on file type+        if ext in (".step", ".stp"):+            options = import_mgr.createSTEPImportOptions(str(path))+        elif ext in (".iges", ".igs"):+            options = import_mgr.createIGESImportOptions(str(path))+        elif ext in (".sat", ".sab"):+            options = import_mgr.createSATImportOptions(str(path))+        elif ext in (".smb", ".smt"):+            options = import_mgr.createSMTImportOptions(str(path))+        elif ext in (".f3d", ".f3z"):+            options = import_mgr.createFusionArchiveImportOptions(str(path))+        elif ext == ".stl":+            options = import_mgr.createSTLImportOptions(str(path))+        elif ext == ".3mf":+            options = import_mgr.createC3MFImportOptions(str(path))+        elif ext == ".obj":+            options = import_mgr.createOBJImportOptions(str(path))+        else:+            return {+                "success": False,+                "error": f"No import handler for {ext}",+                "_hint": "Use fusion_import_electronics for .fsch/.fbrd/.flbr electronics files, or verify the extension is one of the 3D formats Fusion supports.",+            }++        # Always import to a new document — importToTarget fails on Part Designs+        # because "Part Design documents can only contain one component".+        # importToNewDocument opens the file in its own document tab, which is+        # the expected behavior (like File > Open).+        doc = import_mgr.importToNewDocument(options)+        if not doc:+            return {+                "success": False,+                "error": f"Import returned null for {path.name}",+                "_hint": "Call fusion_screenshot_fusion to check for a blocking dialog (e.g. unit prompt), then fusion_send_key with 'enter' to accept defaults, then retry.",+            }++        # Activate the newly imported document so subsequent commands work on it+        doc.activate()++        # Verify it's now the active document+        active_doc = app.activeDocument+        doc_name = active_doc.name if active_doc else "Unknown"++        return {+            "success": True,+            "output": f"Imported {path.name} into Fusion 360.",+            "data": {+                "document": doc_name,+            },+        }++    except Exception as e:+        return {+            "success": False,+            "error": f"Import failed: {e}",+            "_hint": "Call fusion_screenshot to check for a modal dialog, dismiss with fusion_send_key escape, then retry.",+        }

@@ -0,0 +1,1185 @@+"""Manufacturing export commands — Gerbers, BOM, CPL for PCB fabrication and assembly.++These commands extract manufacturing data from the open PCB board in Fusion 360's+Electronics workspace and write industry-standard output files:+  - Gerbers (RS-274X) + Excellon drill files via EAGLE CAM processor+  - BOM (Bill of Materials) CSV for component purchasing+  - CPL (Component Placement List) CSV for pick-and-place assembly+  - Design rules (DRU) injection for Adom's InstapcbPCB manufacturing capabilities++All three export commands require a .brd board to be open in PCB Editor.++IMPORTANT — EAGLE "Overwrite?" dialog:+  EAGLE's EXPORT commands open a blocking confirmation dialog if the output+  file already exists. This freezes Fusion's UI thread and crashes the add-in.+  Always use _safe_eagle_export() which deletes the file first and runs+  SET CONFIRM YES before any EAGLE export command.+"""++import adsk.core+import os+import csv+import html+import io+import json+import tempfile+import time+import xml.etree.ElementTree as ET+import zipfile+++def _safe_eagle_export(app, eagle_cmd: str, output_file: str) -> dict:+    """Run an EAGLE export command safely, avoiding the 'Overwrite?' dialog.++    EAGLE's EXPORT commands open a blocking confirmation dialog if the output+    file already exists. This helper:+      1. Deletes the target file if it exists+      2. Runs SET CONFIRM YES to suppress any remaining dialogs+      3. Executes the export command++    Returns a dict with 'deletedExisting' flag so the caller can include it+    in response data for AI debugging context.+    """+    result = {"deletedExisting": False}+    if os.path.exists(output_file):+        os.remove(output_file)+        result["deletedExisting"] = True+    app.executeTextCommand("Electron.run SET CONFIRM YES")+    app.executeTextCommand(f"Electron.run {eagle_cmd}")+    return result+++def _get_board_xml(app: adsk.core.Application) -> str:+    """Get board info XML from the current PCB layout via Electron.boardInfo."""+    board_info_path = os.path.join(tempfile.gettempdir(), "adom_mfg_board_info.xml")++    try:+        app.executeTextCommand(f"Electron.boardInfo {board_info_path}")+    except Exception as e:+        err_msg = str(e)+        if "not pcb" in err_msg.lower():+            ws = "unknown"+            try:+                ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+            except Exception:+                pass+            raise RuntimeError(+                f"No board open (current workspace: {ws}). "+                "Open a .brd file first with fusion_open_board."+            )+        raise RuntimeError(f"boardInfo failed: {e}")++    # Read the output file (Fusion writes UTF-16 LE BOM)+    for enc in ("utf-16", "utf-8-sig", "utf-8"):+        try:+            with open(board_info_path, "r", encoding=enc) as f:+                return f.read()+        except (UnicodeDecodeError, UnicodeError):+            continue++    raise RuntimeError("Failed to decode boardInfo XML output.")+++def _parse_components(xml_str: str) -> list:+    """Parse component data from boardInfo XML.++    Returns list of dicts with: name, value, package, library, x, y, rotation, side.+    EAGLE rotation format: R0/R90/R180/R270 = top, MR0/MR90/MR180/MR270 = bottom.+    """+    root = ET.fromstring(xml_str)+    components = []++    for lib_group in root.iter("g"):+        lib = lib_group.get("library")+        pkg = lib_group.get("package")+        if not (lib and pkg):+            continue++        for comp in lib_group.findall("g"):+            name = comp.get("name")+            if not name:+                continue++            rot_str = comp.get("rot", "R0")+            # M prefix = mirrored = bottom side+            side = "Bottom" if rot_str.startswith("M") else "Top"+            # Extract numeric rotation+            rot_num = rot_str.replace("M", "").replace("R", "").replace("S", "")+            try:+                rotation = float(rot_num)+            except ValueError:+                rotation = 0.0++            components.append({+                "name": name,+                "value": comp.get("value", ""),+                "package": pkg,+                "library": lib,+                "x": comp.get("x", "0"),+                "y": comp.get("y", "0"),+                "rotation": rotation,+                "side": side,+            })++    return components+++def _parse_attributes(xml_str: str) -> dict:+    """Parse component attributes from boardInfo XML.++    Returns dict of {component_name: {attr_name: attr_value}}.+    Looks for MPN, MANUFACTURER, MOUSER_PN, DIGIKEY_PN, LCSC_PN etc.+    """+    root = ET.fromstring(xml_str)+    attrs = {}++    # Attributes are stored as <attribute> elements within component groups+    for elem in root.iter("attribute"):+        name = elem.get("name", "")+        value = elem.get("value", "")+        # The parent chain should lead us to the component+        # For now, collect all attributes+        if name and value:+            # Try to find parent component name+            parent = elem+            comp_name = None+            for _ in range(5):  # Walk up max 5 levels+                parent = None  # ET doesn't have parent refs, use different approach+                break+            if name not in attrs:+                attrs[name] = value++    return attrs+++# ─── BOM Export ───────────────────────────────────────────────────────────++def handle_export_bom(app: adsk.core.Application, args: dict) -> dict:+    """Export Bill of Materials (BOM) from the open PCB board.++    Generates a CSV with component values, quantities, and designators —+    suitable for ordering from Mouser, Digi-Key, or LCSC.++    Two approaches combined:+      1. EAGLE's EXPORT PARTLIST for raw parts data+      2. boardInfo XML parsing for coordinates and grouping++    Args:+        outputPath: File path for the output CSV (default: C:/tmp/adom-bom.csv)+        grouped: If true (default), group identical parts by value+package.+                 If false, list every individual component.+    """+    output_path = args.get("outputPath", "C:/tmp/adom-bom.csv")+    grouped = args.get("grouped", True)++    # Ensure output directory exists+    os.makedirs(os.path.dirname(output_path), exist_ok=True)++    # Also try EXPORT PARTLIST for additional attribute data+    partlist_path = os.path.join(tempfile.gettempdir(), "adom_partlist.txt")+    partlist_data = {}+    try:+        _safe_eagle_export(app, f"EXPORT PARTLIST '{partlist_path}'", partlist_path)+        time.sleep(0.5)+        if os.path.exists(partlist_path):+            for enc in ("utf-16", "utf-8-sig", "utf-8", "latin-1"):+                try:+                    with open(partlist_path, "r", encoding=enc) as f:+                        lines = f.readlines()+                    # Parse tab-separated partlist+                    if len(lines) > 1:+                        headers = lines[0].strip().split("\t")+                        for line in lines[1:]:+                            fields = line.strip().split("\t")+                            if len(fields) >= 2:+                                part_name = fields[0].strip()+                                part_info = {}+                                for i, h in enumerate(headers):+                                    if i < len(fields):+                                        part_info[h.strip()] = fields[i].strip()+                                partlist_data[part_name] = part_info+                    break+                except (UnicodeDecodeError, UnicodeError):+                    continue+    except Exception:+        pass  # EXPORT PARTLIST might fail if not in board view; we still have boardInfo++    # Get components from boardInfo XML+    try:+        xml_str = _get_board_xml(app)+    except RuntimeError as e:+        return {+            "success": False,+            "error": str(e),+            "_hint": "Call fusion_show_2d_board or fusion_open_board {\"filePath\":\"...\"} to enter Board Layout, then retry.",+        }++    components = _parse_components(xml_str)+    if not components:+        return {+            "success": False,+            "error": "No components found in board. Is a populated .brd file open?",+            "data": {+                "hint": "The board XML was parsed but contained no component data. "+                        "This usually means the board has no placed components yet.",+                "recoverySteps": [+                    "Verify the board has components placed (not just an empty board outline)",+                    "Switch to schematic and back: fusion_electron_run with 'BOARD' command",+                    "Try fusion_board_info to get raw board data for debugging",+                ],+            },+        }++    # Merge partlist attributes into component data+    for comp in components:+        pl = partlist_data.get(comp["name"], {})+        if pl.get("Value"):+            comp["value"] = pl["Value"]++    if grouped:+        # Group by value + package (same part = same BOM line)+        groups = {}+        for comp in components:+            key = (comp["value"], comp["package"], comp["library"])+            if key not in groups:+                groups[key] = {+                    "value": comp["value"],+                    "package": comp["package"],+                    "library": comp["library"],+                    "designators": [],+                    "quantity": 0,+                }+            groups[key]["designators"].append(comp["name"])+            groups[key]["quantity"] += 1++        # Sort by designator (natural sort: C1, C2, ..., R1, R2, ...)+        rows = sorted(groups.values(), key=lambda g: g["designators"][0])++        # Write grouped BOM CSV+        with open(output_path, "w", newline="", encoding="utf-8") as f:+            writer = csv.writer(f)+            writer.writerow(["Comment", "Designator", "Footprint", "Quantity", "Library"])+            for row in rows:+                writer.writerow([+                    row["value"],+                    " ".join(sorted(row["designators"])),+                    row["package"],+                    row["quantity"],+                    row["library"],+                ])+    else:+        # Ungrouped — one row per component+        with open(output_path, "w", newline="", encoding="utf-8") as f:+            writer = csv.writer(f)+            writer.writerow(["Designator", "Comment", "Footprint", "Library", "Side"])+            for comp in sorted(components, key=lambda c: c["name"]):+                writer.writerow([+                    comp["name"],+                    comp["value"],+                    comp["package"],+                    comp["library"],+                    comp["side"],+                ])++    unique_count = len(rows) if grouped else len(components)+    return {+        "success": True,+        "output": f"BOM exported: {len(components)} components"+                  + (f" in {unique_count} unique parts" if grouped else "")+                  + f" → {output_path}",+        "message": (+            f"Bill of Materials CSV with {unique_count} unique part"+            f"{'s' if unique_count != 1 else ''} and {len(components)} total placements. "+            "Format: Comment, Designator, Footprint, Quantity, Library — "+            "compatible with JLCPCB, PCBWay, Mouser, and Digi-Key."+        ),+        "data": {+            "outputPath": output_path,+            "componentCount": len(components),+            "uniquePartCount": unique_count,+            "grouped": grouped,+            "nextSteps": [+                "Run fusion_export_cpl to generate the pick-and-place CSV",+                "Run fusion_export_gerbers to generate the Gerber fabrication ZIP",+                "Once you have BOM + CPL + Gerbers, upload all three to your PCB fab service",+            ],+            "hint": (+                "If BOM looks incomplete, check that component values are set in the schematic. "+                "Use fusion_board_info for raw structured component data."+            ),+        },+    }+++# ─── CPL / Pick-and-Place Export ──────────────────────────────────────────++def handle_export_cpl(app: adsk.core.Application, args: dict) -> dict:+    """Export Component Placement List (CPL) for pick-and-place assembly.++    Generates a CSV with component centroid positions, rotation, and side —+    the standard format expected by PCBA manufacturers (JLCPCB, PCBWay, etc.).++    Coordinates are in millimeters relative to the board origin.++    Args:+        outputPath: File path for the output CSV (default: C:/tmp/adom-cpl.csv)+        side: Filter by side — "all" (default), "top", or "bottom"+    """+    output_path = args.get("outputPath", "C:/tmp/adom-cpl.csv")+    side_filter = args.get("side", "all").lower()++    os.makedirs(os.path.dirname(output_path), exist_ok=True)++    try:+        xml_str = _get_board_xml(app)+    except RuntimeError as e:+        return {+            "success": False,+            "error": str(e),+            "_hint": "Call fusion_show_2d_board or fusion_open_board {\"filePath\":\"...\"} to enter Board Layout, then retry.",+        }++    components = _parse_components(xml_str)+    if not components:+        return {+            "success": False,+            "error": "No components found in board. Is a populated .brd file open?",+            "data": {+                "hint": "Board has no component placements. CPL requires components to be placed on the board.",+                "recoverySteps": [+                    "Verify the board has components placed (check with fusion_board_info)",+                    "If schematic has components but board doesn't, the board may need updating",+                ],+            },+        }++    # Filter by side if requested+    if side_filter in ("top", "bottom"):+        target = side_filter.capitalize()+        components = [c for c in components if c["side"] == target]++    if not components:+        return {+            "success": False,+            "error": f"No {side_filter}-side components found.",+        }++    # Write CPL CSV (standard JLCPCB/generic format)+    with open(output_path, "w", newline="", encoding="utf-8") as f:+        writer = csv.writer(f)+        writer.writerow(["Designator", "Mid X", "Mid Y", "Layer", "Rotation"])+        for comp in sorted(components, key=lambda c: c["name"]):+            writer.writerow([+                comp["name"],+                comp["x"],+                comp["y"],+                comp["side"],+                comp["rotation"],+            ])++    top_count = sum(1 for c in components if c["side"] == "Top")+    bottom_count = sum(1 for c in components if c["side"] == "Bottom")++    return {+        "success": True,+        "output": f"CPL exported: {len(components)} placements "+                  f"({top_count} top, {bottom_count} bottom) → {output_path}",+        "message": (+            f"Pick-and-place CSV with {len(components)} component placements "+            f"({top_count} top-side, {bottom_count} bottom-side). "+            "Format: Designator, Mid X, Mid Y, Layer, Rotation — "+            "coordinates in mm, compatible with JLCPCB/PCBWay/Adom PCBA."+        ),+        "data": {+            "outputPath": output_path,+            "totalPlacements": len(components),+            "topCount": top_count,+            "bottomCount": bottom_count,+            "sideFilter": side_filter,+            "nextSteps": [+                "Run fusion_export_bom if you haven't already — you need BOM + CPL together",+                "Run fusion_export_gerbers to generate the Gerber fabrication ZIP",+                "Upload BOM + CPL + Gerbers together to your PCBA service for assembly quoting",+            ],+            "hint": (+                "If placement coordinates look wrong, verify the board origin in EAGLE. "+                "Use side='top' or side='bottom' to export only one side for single-sided assembly."+            ),+        },+    }+++# ─── Resource Path Helper ────────────────────────────────────────────────++def _get_resources_dir() -> str:+    """Get the path to the add-in's bundled resources directory.++    Resources (CAM jobs, DRU files, ULP scripts) are bundled at:+      AdomBridge/resources/  (synced to %APPDATA%/.../AdomBridge/resources/)+    """+    # manufacturing.py is at: AdomBridge/commands/manufacturing.py+    # resources are at:       AdomBridge/resources/+    addin_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+    return os.path.join(addin_root, "resources")+++# ─── Layer Detection ─────────────────────────────────────────────────────++def _detect_layer_count(app: adsk.core.Application) -> dict:+    """Detect if the open board is 2-layer or 4-layer.++    Uses two methods in priority order:+      1. ULP script — runs detect_layers.ulp to inspect copper layers and traces+      2. CAM comparison — exports with both 2-layer and 4-layer CAM jobs,+         compares ZIP sizes to detect inner copper content++    Returns dict with: layerCount, is4Layer, method, copperLayers, details+    """+    resources = _get_resources_dir()+    result = {"layerCount": 2, "is4Layer": False, "method": "default",+              "copperLayers": [1, 16], "details": ""}++    # Method A: ULP script detection+    ulp_path = os.path.join(resources, "ulp", "detect_layers.ulp").replace("\\", "/")+    if os.path.exists(ulp_path):+        try:+            temp_fd, temp_json = tempfile.mkstemp(suffix=".json")+            os.close(temp_fd)+            temp_json = os.path.abspath(temp_json).replace("\\", "/")++            app.executeTextCommand(f"Electron.run RUN '{ulp_path}' '{temp_json}'")++            if os.path.exists(temp_json):+                with open(temp_json, "r") as f:+                    data = json.loads(f.read())+                os.remove(temp_json)++                copper_count = data.get("copperLayerCount", 0)+                layers_list = data.get("layers", [])+                copper_layers = [+                    l["number"] for l in layers_list+                    if l.get("isCopper") and (l["number"] in (1, 16) or l.get("hasTraces"))+                ]+                internal = [l for l in copper_layers if l not in (1, 16)]++                if internal or copper_count > 2:+                    result.update({+                        "layerCount": max(copper_count, 4),+                        "is4Layer": True,+                        "method": "ulp",+                        "copperLayers": copper_layers,+                        "details": f"ULP found {len(internal)} internal routing layer(s): {internal}",+                    })+                else:+                    result.update({+                        "method": "ulp",+                        "copperLayers": copper_layers,+                        "details": f"ULP found {copper_count} copper layers, no internal routing",+                    })+                return result+        except Exception as e:+            result["details"] = f"ULP detection failed: {e}; "++    # Method B: CAM comparison (export both, compare sizes)+    cam_2 = os.path.join(resources, "cam", "jlcpcb-2layers.cam").replace("\\", "/")+    cam_4 = os.path.join(resources, "cam", "jlcpcb-4layers.cam").replace("\\", "/")++    if os.path.exists(cam_2) and os.path.exists(cam_4):+        try:+            tmp_dir = tempfile.gettempdir().replace("\\", "/")+            zip_2 = f"{tmp_dir}/adom_test_2layer.zip"+            zip_4 = f"{tmp_dir}/adom_test_4layer.zip"++            # Export with 2-layer CAM+            app.executeTextCommand(+                f"Electron.run set confirm yes;manufacturing export '{zip_2}' '{cam_2}'"+            )+            size_2 = os.path.getsize(zip_2) if os.path.exists(zip_2) else 0++            # Export with 4-layer CAM+            app.executeTextCommand(+                f"Electron.run set confirm yes;manufacturing export '{zip_4}' '{cam_4}'"+            )+            size_4 = os.path.getsize(zip_4) if os.path.exists(zip_4) else 0++            # Clean up+            for f in (zip_2, zip_4):+                try:+                    os.remove(f)+                except Exception:+                    pass++            if size_2 > 0 and size_4 > 0:+                ratio = size_4 / size_2+                # Adaptive threshold based on file size+                if size_2 > 100_000:+                    threshold = 1.02+                elif size_2 > 50_000:+                    threshold = 1.03+                else:+                    threshold = 1.05++                if ratio > threshold:+                    result.update({+                        "layerCount": 4, "is4Layer": True, "method": "cam_comparison",+                        "details": f"4-layer ZIP is {ratio:.2f}x larger (threshold {threshold})",+                    })+                else:+                    result.update({+                        "method": "cam_comparison",+                        "details": f"4-layer ZIP ratio {ratio:.2f} (< {threshold}), treating as 2-layer",+                    })+                return result+        except Exception as e:+            result["details"] += f"CAM comparison failed: {e}"++    return result+++def handle_detect_layers(app: adsk.core.Application, args: dict) -> dict:+    """Detect the layer count of the open PCB board.++    Uses ULP script and/or CAM comparison to determine if the board is+    2-layer or 4-layer. Useful before gerber export or design rules application.+    """+    # Verify we're in board layout+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        ws = "unknown"++    if "Board" not in ws and "PCB" not in ws:+        return {+            "success": False,+            "error": f"Not in Board Layout (current: {ws}). Open a .brd file first.",+            "_hint": "Call fusion_show_2d_board or fusion_open_board {\"filePath\":\"...\"} to enter PCB Editor, then retry.",+            "data": {"activeWorkspace": ws},+        }++    detection = _detect_layer_count(app)++    layer_type = f"{detection['layerCount']}-layer"+    return {+        "success": True,+        "output": f"Board detected as {layer_type} ({detection['method']} method). "+                  f"Copper layers: {detection['copperLayers']}",+        "message": (+            f"This is a {layer_type} board. Detection used {detection['method']} method. "+            f"Copper layers found: {detection['copperLayers']}. "+            f"All subsequent manufacturing commands (gerbers, design rules) will auto-select "+            f"the {layer_type} configuration."+        ),+        "data": {+            **detection,+            "activeWorkspace": ws,+            "nextSteps": [+                f"Run fusion_set_design_rules to apply Adom's {layer_type} manufacturing rules",+                f"Run fusion_export_gerbers — auto-selects the {layer_type} CAM job",+                "Run fusion_electron_run with command 'DRC' after applying design rules to check compliance",+            ],+        },+    }+++# ─── Gerber Export ────────────────────────────────────────────────────────++def handle_export_gerbers(app: adsk.core.Application, args: dict) -> dict:+    """Export Gerber manufacturing files from the open PCB board.++    Uses Fusion's CAM processor with bundled JLCPCB-compatible CAM job files+    to produce a ZIP containing industry-standard gerber files:+      - Top/Bottom Copper (.GTL/.GBL)+      - Top/Bottom Silkscreen (.GTO/.GBO)+      - Top/Bottom Solder Mask (.GTS/.GBS)+      - Top/Bottom Paste (.GTP/.GBP)+      - Board Outline (.GKO)+      - Drill file (.XLN)+      - (4-layer boards also get inner copper .G1/.G2)++    Auto-detects 2-layer vs 4-layer boards and selects the right CAM job.++    Args:+        outputDir: Directory for the output ZIP (default: C:/tmp/adom-gerbers/)+        boardName: Prefix for the ZIP filename (default: from active document)+        layers: Force layer count — "2" or "4" (default: auto-detect)+    """+    output_dir = args.get("outputDir", "C:/tmp/adom-gerbers")+    board_name = args.get("boardName", "")+    force_layers = args.get("layers", "auto")++    os.makedirs(output_dir, exist_ok=True)++    # Verify board layout+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        ws = "unknown"++    if "Board" not in ws and "PCB" not in ws:+        return {+            "success": False,+            "error": f"Not in Board Layout (current: {ws}). "+                     "Open a .brd file in PCB Editor first.",+            "_hint": "Call fusion_show_2d_board to switch to PCB Editor, then retry.",+            "data": {+                "activeWorkspace": ws,+                "hint": "Use fusion_show_2d_board to switch to PCB Editor.",+            },+        }++    # Get board name+    if not board_name:+        try:+            doc = app.activeDocument+            if doc:+                board_name = doc.name.replace(".brd", "").replace(".fsch", "").replace(" ", "_")+            else:+                board_name = "board"+        except Exception:+            board_name = "board"++    # Detect layer count+    if force_layers in ("2", "4"):+        layer_count = int(force_layers)+        detection_method = "manual"+    else:+        detection = _detect_layer_count(app)+        layer_count = detection["layerCount"]+        detection_method = detection["method"]++    # Select CAM job file+    resources = _get_resources_dir()+    cam_file = os.path.join(+        resources, "cam", f"jlcpcb-{layer_count}layers.cam"+    ).replace("\\", "/")++    if not os.path.exists(cam_file):+        return {+            "success": False,+            "error": f"CAM job file not found: {cam_file}",+            "data": {+                "hint": "Ensure the resources/cam/ directory contains jlcpcb-2layers.cam "+                        "and jlcpcb-4layers.cam. Run install_addin.py to sync.",+            },+        }++    # Build output ZIP path+    zip_path = os.path.join(output_dir, f"{board_name}_gerbers.zip").replace("\\", "/")++    # Delete existing ZIP to avoid overwrite dialog+    if os.path.exists(zip_path):+        try:+            os.remove(zip_path)+        except Exception:+            pass++    # Execute the CAM export — this is the working command from AdomHelperJoe+    try:+        export_cmd = f"Electron.run set confirm yes;manufacturing export '{zip_path}' '{cam_file}'"+        app.executeTextCommand(export_cmd)+    except Exception as e:+        return {+            "success": False,+            "error": f"Manufacturing export failed: {e}",+            "_hint": "Call fusion_show_2d_board to ensure 2D PCB Editor is active (not 3D view), then retry.",+            "data": {+                "command": f"manufacturing export '{zip_path}' '{cam_file}'",+                "hint": "Ensure you are in the PCB Editor (not schematic or 3D view).",+            },+        }++    # Verify output+    if not os.path.exists(zip_path):+        return {+            "success": False,+            "error": "CAM export command ran but ZIP was not created.",+            "_hint": "Call fusion_show_2d_board to ensure 2D PCB Editor is active, then retry.",+            "data": {+                "zipPath": zip_path,+                "camFile": cam_file,+                "layerCount": layer_count,+                "hint": "Try switching to 2D board view with fusion_show_2d_board, "+                        "then retry.",+            },+        }++    zip_size = os.path.getsize(zip_path)++    # List ZIP contents for the AI+    gerber_files = []+    try:+        with zipfile.ZipFile(zip_path, "r") as zf:+            for info in zf.infolist():+                if not info.is_dir():+                    gerber_files.append({+                        "name": info.filename,+                        "size": info.file_size,+                    })+    except Exception:+        pass++    file_names = [f["name"] for f in gerber_files]+    return {+        "success": True,+        "output": (+            f"Gerbers exported: {len(gerber_files)} files in ZIP "+            f"({zip_size // 1024} KB) → {zip_path}"+        ),+        "message": (+            f"Gerber ZIP created for {layer_count}-layer board '{board_name}' with "+            f"{len(gerber_files)} files ({zip_size // 1024} KB). "+            f"Contains: {', '.join(file_names[:5])}{'...' if len(file_names) > 5 else ''}. "+            "This ZIP is ready for upload to any PCB fabrication service."+        ),+        "data": {+            "zipPath": zip_path,+            "zipSizeKB": zip_size // 1024,+            "layerCount": layer_count,+            "detectionMethod": detection_method,+            "boardName": board_name,+            "files": gerber_files,+            "fileCount": len(gerber_files),+            "nextSteps": [+                "Run fusion_export_bom to generate the Bill of Materials CSV",+                "Run fusion_export_cpl to generate the Component Placement List CSV",+                "Once you have Gerbers + BOM + CPL, upload all three to your PCBA service",+                "Use pull_file to transfer the ZIP back to Docker for ordering",+            ],+            "hint": (+                f"Auto-detected {layer_count}-layer board via {detection_method}. "+                "If wrong, force layer count with layers='2' or layers='4'."+            ),+        },+    }+++# ─── Design Rules (DRU) ──────────────────────────────────────────────────++def _parse_edru_description(edru_path: str) -> str:+    """Parse an .edru file and extract its human-readable description."""+    try:+        tree = ET.parse(edru_path)+        root = tree.getroot()+        desc_elem = root.find(".//description[@language='en']")+        if desc_elem is not None and desc_elem.text:+            return html.unescape(desc_elem.text).strip()+    except Exception:+        pass+    return ""+++def handle_set_design_rules(app: adsk.core.Application, args: dict) -> dict:+    """Set PCB design rules in the open board to match Adom's manufacturing capabilities.++    Loads a bundled .edru design rules file via EAGLE's `drc load` command.+    The .edru files are industry-tested rules from JLCPCB, adapted for Adom's+    InstapcbPCB manufacturing process.++    Auto-detects 2-layer vs 4-layer boards and loads the appropriate rule set.++    Args:+        action: "apply" (default) to load Adom rules, "export" to save current rules,+                "show" to display capabilities without changing anything+        layers: "auto" (default), "2", or "4" — which rule set to load+        outputPath: For "export" — path to save current .dru file+    """+    action = args.get("action", "apply")+    force_layers = args.get("layers", "auto")+    resources = _get_resources_dir()++    if action == "show":+        # Show capabilities from the 2-layer .edru description+        edru_2 = os.path.join(resources, "dru", "Adom-InstaPCB-2-Layer.edru")+        edru_4 = os.path.join(resources, "dru", "Adom-InstaPCB-4-Layer.edru")+        desc_2 = _parse_edru_description(edru_2) if os.path.exists(edru_2) else ""+        desc_4 = _parse_edru_description(edru_4) if os.path.exists(edru_4) else ""++        return {+            "success": True,+            "output": "Adom InstaPCB design rules (from bundled .edru files)",+            "data": {+                "2layer_rules": desc_2 or "2-layer .edru file not found",+                "4layer_rules": desc_4 or "4-layer .edru file not found",+                "nextSteps": [+                    "Use fusion_set_design_rules with action='apply' to load rules into the board",+                    "Layer count is auto-detected, or force with layers='2' or layers='4'",+                ],+            },+        }++    # Verify we're in board layout+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        ws = "unknown"++    if "Board" not in ws and "PCB" not in ws:+        return {+            "success": False,+            "error": f"Not in Board Layout (current: {ws}). Open a .brd file first.",+            "_hint": "Call fusion_show_2d_board or fusion_open_board {\"filePath\":\"...\"} to enter PCB Editor, then retry.",+            "data": {"activeWorkspace": ws},+        }++    if action == "export":+        output_path = args.get("outputPath", "C:/tmp/current-design-rules.dru")+        os.makedirs(os.path.dirname(output_path), exist_ok=True)+        try:+            app.executeTextCommand(f"Electron.run DRC SAVE '{output_path}'")+            time.sleep(0.5)+            if os.path.exists(output_path):+                return {+                    "success": True,+                    "output": f"Current design rules exported to {output_path}",+                    "data": {"outputPath": output_path},+                }+            return {+                "success": False,+                "error": "DRC SAVE did not produce output.",+            }+        except Exception as e:+            return {"success": False, "error": f"DRC SAVE failed: {e}"}++    # action == "apply": Load bundled .edru design rules+    if force_layers in ("2", "4"):+        layer_count = int(force_layers)+        detection_method = "manual"+    else:+        detection = _detect_layer_count(app)+        layer_count = detection["layerCount"]+        detection_method = detection["method"]++    # Resolve the .edru file+    edru_filename = f"Adom-InstaPCB-{layer_count}-Layer.edru"+    edru_path = os.path.join(resources, "dru", edru_filename)++    if not os.path.exists(edru_path):+        return {+            "success": False,+            "error": f"Design rules file not found: {edru_path}",+            "data": {+                "hint": "Ensure resources/dru/ contains the .edru files. "+                        "Run install_addin.py to sync.",+            },+        }++    edru_path_fwd = edru_path.replace("\\", "/")++    # Load via EAGLE's drc load command (lowercase — this is the correct syntax)+    try:+        app.executeTextCommand(f"Electron.run drc load '{edru_path_fwd}'")+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to load design rules: {e}",+            "data": {"edruPath": edru_path_fwd},+        }++    # Parse description for the success message+    description = _parse_edru_description(edru_path)++    return {+        "success": True,+        "output": (+            f"Adom {layer_count}-layer design rules loaded from {edru_filename}. "+            f"Detection method: {detection_method}."+        ),+        "message": (+            f"Adom InstaPCB {layer_count}-Layer design rules are now active. "+            f"Min trace: 0.08mm (3mil), min spacing: 0.08mm (3mil), min drill: 0.2mm (8mil). "+            f"Rule violations will now show as DRC markers in the board editor."+        ),+        "data": {+            "edruFile": edru_filename,+            "edruPath": edru_path_fwd,+            "layerCount": layer_count,+            "detectionMethod": detection_method,+            "description": description,+            "activeWorkspace": ws,+            "nextSteps": [+                "Run fusion_electron_run with command 'DRC' to check for rule violations",+                "Run fusion_export_gerbers to export Gerber files with the correct CAM job",+                "Run fusion_export_bom and fusion_export_cpl to complete the manufacturing package",+            ],+            "hint": (+                "DRC violations appear as markers in the board. Use fusion_board_info to get "+                "structured DRC data, or fusion_export_board_image with preset 'fabrication' "+                "to visually inspect the result."+            ),+        },+    }+++# ─── Board Image Export (PNG / PDF / layer views) ────────────────────────++# Layer presets for common manufacturing views+LAYER_PRESETS = {+    "all": {+        "description": "All layers visible",+        "command": "DISPLAY ALL",+    },+    "top_copper": {+        "description": "Top copper + pads + vias",+        "layers": [1, 17, 18],+    },+    "bottom_copper": {+        "description": "Bottom copper + pads + vias",+        "layers": [16, 17, 18],+    },+    "top_silkscreen": {+        "description": "Top silkscreen + names",+        "layers": [21, 25],+    },+    "bottom_silkscreen": {+        "description": "Bottom silkscreen + names",+        "layers": [22, 26],+    },+    "top_soldermask": {+        "description": "Top solder mask openings",+        "layers": [29],+    },+    "bottom_soldermask": {+        "description": "Bottom solder mask openings",+        "layers": [30],+    },+    "top_paste": {+        "description": "Top paste/stencil openings",+        "layers": [31],+    },+    "bottom_paste": {+        "description": "Bottom paste/stencil openings",+        "layers": [32],+    },+    "board_outline": {+        "description": "Board outline (dimension layer)",+        "layers": [20],+    },+    "drill": {+        "description": "Drill holes + vias",+        "layers": [44, 45, 17, 18],+    },+    "assembly_top": {+        "description": "Top assembly view — copper + silk + outline + names",+        "layers": [1, 17, 18, 20, 21, 25, 51],+    },+    "assembly_bottom": {+        "description": "Bottom assembly view — copper + silk + outline + names",+        "layers": [16, 17, 18, 20, 22, 26, 52],+    },+    "fabrication": {+        "description": "Full fabrication view — all copper + mask + silk + outline",+        "layers": [1, 16, 17, 18, 19, 20, 21, 22, 25, 26, 29, 30, 51],+    },+}+++def handle_export_board_image(app: adsk.core.Application, args: dict) -> dict:+    """Export a PNG image of the open PCB board with configurable layer visibility.++    Uses EAGLE's EXPORT IMAGE command to render the board at a specified DPI.+    Layer presets make it easy to export common manufacturing views (silkscreen,+    copper, outline, etc.) without manually toggling layers.++    After export, restores the previous layer visibility.++    Args:+        outputPath: File path for the output image (default: C:/tmp/adom-board.png)+        dpi: Resolution in dots per inch (default: 300, max: 600)+        preset: Layer preset name — one of:+            "all", "top_copper", "bottom_copper", "top_silkscreen",+            "bottom_silkscreen", "top_soldermask", "bottom_soldermask",+            "top_paste", "bottom_paste", "board_outline", "drill",+            "assembly_top", "assembly_bottom", "fabrication"+        layers: Custom layer numbers (list of ints) — overrides preset if provided+        monochrome: If true, export in black & white (default: false)+        mirror: If true, mirror the image horizontally (default: false)+        listPresets: If true, return available presets instead of exporting+    """+    # List presets mode+    if args.get("listPresets", False):+        preset_list = {k: v["description"] for k, v in LAYER_PRESETS.items()}+        return {+            "success": True,+            "output": f"{len(preset_list)} layer presets available",+            "data": {"presets": preset_list},+        }++    output_path = args.get("outputPath", "C:/tmp/adom-board.png")+    dpi = min(int(args.get("dpi", 300)), 600)+    preset = args.get("preset", "all")+    custom_layers = args.get("layers", None)+    monochrome = args.get("monochrome", False)+    mirror_img = args.get("mirror", False)++    os.makedirs(os.path.dirname(output_path), exist_ok=True)++    # Verify we're in an electronics editor+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        ws = "unknown"++    # Works in Board Layout and Schematic Editor+    is_electronics = False+    try:+        app.executeTextCommand("Electron.run DISPLAY")+        is_electronics = True+    except Exception:+        pass++    if not is_electronics:+        return {+            "success": False,+            "error": f"Not in Electronics editor (current: {ws}). "+                     "Open a .brd or .sch file first.",+            "_hint": "Call fusion_open_board {\"filePath\":\"...\"} or fusion_show_2d_board to enter the PCB editor, then retry.",+            "data": {+                "activeWorkspace": ws,+                "hint": "Use fusion_open_board or fusion_show_2d_board to enter the PCB editor.",+                "recoverySteps": [+                    "Open a .brd file with fusion_open_board",+                    "Or switch to 2D board view with fusion_show_2d_board",+                    "Then retry this command",+                ],+            },+        }++    # Save current layer state (we'll restore it after export)+    # There's no direct way to query current DISPLAY state, so we'll+    # just restore ALL after export.++    # Silkscreen registration: when exporting a silkscreen layer, fit the view to+    # the BOARD OUTLINE (layer 20) rather than the silk content. The silk content's+    # bbox is smaller than (and offset within) the board, so a content-fit PNG can't+    # be UV-mapped to the board's XY bbox by a downstream overlay (e.g. OCCT+    # apply_silkscreen). We show the outline ONLY to key WINDOW FIT to the board+    # bbox, then hide it before EXPORT so it's not baked into the silk PNG.+    # (Pixel-exact bbox crop + bottom-side mirror are done container-side, where an+    # image lib is available — Fusion's add-in Python has none.)+    silk_export_display = None  # set for silk presets: the silk-only DISPLAY used for EXPORT++    # Set layer visibility+    if custom_layers:+        layer_nums = " ".join(str(l) for l in custom_layers)+        display_cmd = f"DISPLAY NONE; DISPLAY {layer_nums}"+    elif preset in LAYER_PRESETS:+        p = LAYER_PRESETS[preset]+        if "command" in p:+            display_cmd = p["command"]+        else:+            layer_nums = " ".join(str(l) for l in p["layers"])+            if preset in ("top_silkscreen", "bottom_silkscreen"):+                # Fit with the outline visible; export with silk only.+                display_cmd = f"DISPLAY NONE; DISPLAY {layer_nums} 20"+                silk_export_display = f"DISPLAY NONE; DISPLAY {layer_nums}"+            else:+                display_cmd = f"DISPLAY NONE; DISPLAY {layer_nums}"+    else:+        return {+            "success": False,+            "error": f"Unknown preset '{preset}'. Use listPresets to see available options.",+            "_hint": "Call fusion_export_board_image with {\"listPresets\": true} to see valid preset names.",+            "data": {"availablePresets": list(LAYER_PRESETS.keys())},+        }++    try:+        # Set layers — split semicolon-separated commands into individual calls+        for cmd in display_cmd.split(";"):+            cmd = cmd.strip()+            if cmd:+                app.executeTextCommand(f"Electron.run {cmd}")+                time.sleep(0.2)+        time.sleep(0.3)++        # Zoom to fit. For silk presets the board outline (layer 20) is visible+        # here, so WINDOW FIT keys the view to the board's XY bbox.+        app.executeTextCommand("Electron.run WINDOW FIT")+        time.sleep(0.3)++        # Silk: hide the outline now (keep the same window extent) so the EXPORT+        # captures only silkscreen, board-bbox-keyed.+        if silk_export_display:+            for cmd in silk_export_display.split(";"):+                cmd = cmd.strip()+                if cmd:+                    app.executeTextCommand(f"Electron.run {cmd}")+                    time.sleep(0.15)+            time.sleep(0.2)++        # Delete existing file to avoid overwrite dialog+        output_path_escaped = output_path.replace("\\", "/")+        if os.path.exists(output_path_escaped):+            os.remove(output_path_escaped)++        # Export image+        export_cmd = f"EXPORT IMAGE '{output_path_escaped}' {dpi}"+        if monochrome:+            export_cmd = f"EXPORT IMAGE '{output_path_escaped}' MONOCHROME {dpi}"++        app.executeTextCommand(f"Electron.run SET CONFIRM YES")+        app.executeTextCommand(f"Electron.run {export_cmd}")+        time.sleep(1.0)++    except Exception as e:+        # Restore layers before returning error+        try:+            app.executeTextCommand("Electron.run DISPLAY ALL")+        except Exception:+            pass+        return {+            "success": False,+            "error": f"Export failed: {e}",+            "data": {+                "activeWorkspace": ws,+                "preset": preset,+                "hint": "EXPORT IMAGE may fail if no board/schematic content is visible. "+                        "Try WINDOW FIT first, or use a different layer preset.",+            },+        }++    # Restore all layers visible+    try:+        app.executeTextCommand("Electron.run DISPLAY ALL")+    except Exception:+        pass++    # Verify output file exists+    if not os.path.exists(output_path):+        return {+            "success": False,+            "error": f"EXPORT IMAGE did not create file at {output_path}. "+                     "The command may not be supported in this context.",+            "_hint": "Call fusion_show_2d_board first to ensure 2D PCB Editor is active, then retry.",+        }++    file_size = os.path.getsize(output_path)+    preset_desc = LAYER_PRESETS.get(preset, {}).get("description", preset) if not custom_layers else f"custom layers: {custom_layers}"++    return {+        "success": True,+        "output": f"Board image exported ({preset_desc}) at {dpi} DPI → {output_path}",+        "message": (+            f"PNG image of {preset_desc} at {dpi} DPI ({file_size // 1024} KB). "+            "Use pull_file to transfer to Docker for inspection or documentation."+        ),+        "data": {+            "outputPath": output_path,+            "dpi": dpi,+            "preset": preset if not custom_layers else "custom",+            "presetDescription": preset_desc,+            "fileSize": file_size,+            "fileSizeKB": file_size // 1024,+            "monochrome": monochrome,+            "activeWorkspace": ws,+            "nextSteps": [+                "Use pull_file to transfer the image to Docker for review",+                "Export more views: 'assembly_top', 'assembly_bottom', 'top_copper', 'board_outline'",+                "For manufacturing: also export gerbers, BOM, and CPL",+            ],+            "hint": (+                "Common presets: 'assembly_top' (component placement review), "+                "'top_copper' (routing check), 'fabrication' (full fab view), "+                "'board_outline' (dimensions check)."+            ),+        },+    }

@@ -0,0 +1,543 @@+"""Open electronics files in Fusion 360's Electronics workspace.++Each file type gets its own command for clarity:+  fusion_open_schematic  — .sch files → Schematic Editor+  fusion_open_board      — .brd files → Board Layout editor+  fusion_show_3d_board   — switches Board Layout → 3D PCB view++All use Document.newDesignFromLocal which reliably opens these file types+and switches to the correct Electronics sub-workspace automatically.++fusion_open_lbr (in open_lbr.py) handles .lbr library files.++Fusion 360 Electronics projects are cloud-based (not .epr files like standalone EAGLE).+The project is the Fusion document itself. Open a schematic or board to work with a design.+"""++import adsk.core+import os+import time+++def _open_electronics(app: adsk.core.Application, file_path: str, file_type: str, expected_ext: str) -> dict:+    """Common logic for opening an electronics file in Fusion."""+    if not file_path:+        return {+            "success": False,+            "error": f"No filePath specified. Provide a {expected_ext} file path.",+            "data": {+                "hint": f"Usage: fusion_open_{file_type.replace(' ', '_')} {{\"filePath\": \"C:/path/to/file{expected_ext}\"}}"+            },+        }++    file_path = file_path.replace("\\", "/")++    if not os.path.exists(file_path):+        return {+            "success": False,+            "error": f"File not found: {file_path}",+            "_hint": "The path may exist on Docker but not on the Windows host. Verify with desktop_list_directory on the host, or use push_file to copy from Docker first.",+            "data": {"filePath": file_path, "hint": "Check that the file path exists on the Windows desktop machine, not on Docker."},+        }++    ext = os.path.splitext(file_path)[1].lower()+    if ext != expected_ext:+        return {+            "success": False,+            "error": f"Expected a {expected_ext} file, got {ext}. Use the correct command for this file type.",+            "data": {+                "hint": {+                    ".sch": "Use fusion_open_schematic for .sch files",+                    ".brd": "Use fusion_open_board for .brd files",+                    ".lbr": "Use fusion_open_lbr for .lbr files",+                    ".step": "Use fusion_import_step for .step files",+                    ".stp": "Use fusion_import_step for .stp files",+                }.get(ext, f"This command only handles {expected_ext} files"),+            },+        }++    try:+        r = app.executeTextCommand(f"Document.newDesignFromLocal {file_path}")+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to open {file_type}: {e}",+            "_hint": "Call fusion_screenshot to check for a modal dialog blocking Fusion, then fusion_send_key escape to dismiss it, then retry.",+            "data": {+                "filePath": file_path,+                "hint": "Fusion 360 may not support this file. Ensure Fusion is fully loaded and responsive.",+            },+        }++    time.sleep(1.0)++    # Get workspace info to confirm we landed in the right editor+    ws_info = {}+    try:+        active_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+        ws_info["activeWorkspace"] = active_ws.strip() if active_ws else "unknown"+    except Exception:+        pass+    try:+        doc = app.activeDocument+        if doc:+            ws_info["activeDocument"] = doc.name+    except Exception:+        pass++    # Build helpful next-steps based on file type+    next_steps = {+        "schematic": [+            "Use fusion_electron_run to send EAGLE commands (e.g. WINDOW FIT, DISPLAY ALL)",+            "Use fusion_take_screenshot to capture the schematic view",+            "Use fusion_close_document to close without saving when done",+        ],+        "board layout": [+            "Use fusion_show_3d_board to switch to 3D PCB visualization",+            "Use fusion_electron_run to send EAGLE commands (e.g. WINDOW FIT, RATSNEST)",+            "Use fusion_take_screenshot to capture the board view",+            "Use fusion_close_document to close without saving when done",+        ],+    }++    return {+        "success": True,+        "output": f"Opened {file_type}: {os.path.basename(file_path)}",+        "message": f"Opened {file_type}: {os.path.basename(file_path)}. "+                   f"IMPORTANT: Fusion may show a blocking dialog that is NOT visible to the API. "+                   f"You MUST screenshot the Fusion window now to verify no dialog is blocking.",+        "data": {+            "filePath": file_path,+            "fileType": file_type,+            "nextSteps": next_steps.get(file_type, []),+            **ws_info,+        },+        "postOpenCheck": {+            "required": True,+            "steps": [+                "Run desktop_list_windows to find the Fusion HWND",+                "Run desktop_screenshot_window with that HWND",+                "If a dialog is visible, dismiss it with fusion_send_key {\"key\": \"escape\"} or fusion_click_fusion on the Cancel/X button",+                "Screenshot again to confirm the dialog is gone",+            ],+        },+    }+++def handle_open_schematic(app: adsk.core.Application, args: dict) -> dict:+    """Open a schematic (.sch) file in Fusion 360's Schematic Editor.++    PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.++    The schematic opens in the Electronics workspace where you can use+    EAGLE commands via fusion_electron_run (e.g. WINDOW FIT, DISPLAY ALL).++    Args:+        args: Dict with:+            - filePath: Path to the .sch file on the Windows desktop (required).+    """+    return _open_electronics(app, args.get("filePath", ""), "schematic", ".sch")+++def handle_open_board(app: adsk.core.Application, args: dict) -> dict:+    """Open a board layout (.brd) file in Fusion 360's Board Layout editor.++    PCB/ELECTRONICS NAV RULE: a board is NOT a standalone file - the schematic, 2D board and 3D board are VIEWS inside ONE electronics DESIGN. Open the DESIGN document first (fusion_open_cloud_file or fusion_open_by_urn), THEN switch to its schematic and its 2D board (fusion_show_2d_board) and 3D board (fusion_show_3d_board). A Select-Electronics-Design-File picker IS that design list of its schematic + board. An EMPTY 2D board usually means you opened a derivative or the wrong file, or it is out of sync - reopen the parent electronics DESIGN and switch to its board view; do NOT open a .brd or .sch as a standalone file.++    Opens the 2D board layout where you can see traces, pads, and components.+    Use fusion_show_3d_board to switch to the 3D PCB visualization.+    Use fusion_electron_run {"command": "BOARD"} to return to 2D.++    Args:+        args: Dict with:+            - filePath: Path to the .brd file on the Windows desktop (required).+    """+    return _open_electronics(app, args.get("filePath", ""), "board layout", ".brd")+++def handle_show_3d_board(app: adsk.core.Application, args: dict) -> dict:+    """Switch to the 3D PCB board view in Fusion 360.++    Must have a board (.brd) open in the Board Layout editor first.+    The board MUST have an outline on layer 20 (Dimension) — without it,+    Fusion cannot generate the 3D model.++    Uses the Fusion command Switch3dPcbDocCmd to switch workspaces.++    To return to 2D board layout, use:+        fusion_execute_text_command {"command": "Commands.Start Electron::Insert2DPCB"}+    """+    # Check current workspace+    ws = "unknown"+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    # Already in 3D PCB?+    if ws == "3D PCB":+        return {+            "success": True,+            "output": "Already in 3D PCB view.",+            "data": {+                "activeWorkspace": ws,+                "nextSteps": [+                    "Use fusion_take_screenshot to capture the 3D board view",+                    "Use fusion_show_2d_board to return to 2D layout",+                    "Use fusion_close_document to close without saving when done",+                ],+            },+        }++    # Must be in PCB Editor (board layout) to switch to 3D+    is_pcb_editor = False+    try:+        app.executeTextCommand("Electron.run DISPLAY")+        is_pcb_editor = True+    except Exception:+        pass++    if not is_pcb_editor:+        return {+            "success": False,+            "error": f"Not in Electronics editor (current workspace: {ws}). "+                     "Open a .brd board file first with fusion_open_board.",+            "_hint": "Call fusion_open_board {\"filePath\":\"...\"} to load a board, then retry fusion_show_3d_board.",+            "data": {+                "activeWorkspace": ws,+                "hint": "You need to open a .brd file first: fusion_open_board {\"filePath\": \"C:/path/to/board.brd\"}",+            },+        }++    # Switch to 3D PCB using Fusion's workspace switch command+    try:+        result = app.executeTextCommand("Commands.Start Switch3dPcbDocCmd")+    except Exception as e:+        err_msg = str(e)+        if "outline" in err_msg.lower() or "missing" in err_msg.lower():+            return {+                "success": False,+                "error": f"3D PCB failed: {e}. The board may be missing an outline on layer 20 (Dimension).",+                "_hint": "Call fusion_electron_run with a WIRE command on layer 20 to add a board outline, then retry fusion_show_3d_board.",+                "data": {+                    "hint": "Add a board outline on layer 20 (Dimension) using WIRE command, then try again.",+                },+            }+        return {+            "success": False,+            "error": f"Switch to 3D PCB failed: {e}",+            "data": {"activeWorkspace": ws},+        }++    time.sleep(2.0)++    # Zoom to fit in 3D view+    try:+        app.executeTextCommand("Commands.Start FitCommand")+    except Exception:+        pass  # FitCommand may report missing 3D models as an "error" but still works++    # Verify we're now in 3D PCB+    new_ws = "unknown"+    try:+        new_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    if new_ws != "3D PCB":+        return {+            "success": False,+            "error": f"Switch to 3D PCB may have failed (workspace: {new_ws}). "+                     "Ensure the board has an outline on layer 20.",+            "_hint": "Call fusion_screenshot to check state, then verify the board has a layer-20 outline before retrying.",+            "data": {"activeWorkspace": new_ws},+        }++    return {+        "success": True,+        "output": "Switched to 3D PCB board view. Board outline, copper, solder mask, and component placeholders are shown in 3D.",+        "message": "Switched to 3D PCB view. IMPORTANT: Fusion may show a 'What to design?' or "+                   "'PCB out of date' dialog. You MUST screenshot the Fusion window to verify.",+        "data": {+            "activeWorkspace": new_ws,+            "nextSteps": [+                "FIRST: Screenshot Fusion window to check for blocking dialogs — dismiss with fusion_send_key escape",+                "Use fusion_take_screenshot to capture the 3D board view",+                "Use fusion_show_2d_board to return to 2D layout",+                "Use fusion_close_document to close without saving when done",+            ],+        },+        "postOpenCheck": {+            "required": True,+            "steps": [+                "Run desktop_list_windows to find the Fusion HWND",+                "Run desktop_screenshot_window with that HWND",+                "If a dialog is visible, dismiss it with fusion_send_key {\"key\": \"escape\"}",+                "Screenshot again to confirm the dialog is gone",+            ],+        },+    }+++def handle_import_electronics(app: adsk.core.Application, args: dict) -> dict:+    """Import a Fusion-native electronics file (.fsch/.fbrd/.flbr) as a new local project.++    These are Fusion 360's own electronics formats (not legacy EAGLE .sch/.brd).+    Uses Document.newDesignFromLocal to create a new document from the local file.++    After importing, use fusion_save_to_cloud to persist to the Fusion cloud.++    Args:+        args: Dict with:+            - filePath: Path to the .fsch, .fbrd, or .flbr file on Windows (required).+    """+    file_path = args.get("filePath", "")+    if not file_path:+        return {+            "success": False,+            "error": "No filePath specified. Provide a .fsch, .fbrd, or .flbr file path.",+            "data": {+                "hint": "Usage: fusion_import_electronics {\"filePath\": \"C:/path/to/file.fsch\"}",+                "supportedExtensions": [".fsch", ".fbrd", ".flbr"],+            },+        }++    file_path = file_path.replace("\\", "/")++    if not os.path.exists(file_path):+        return {+            "success": False,+            "error": f"File not found: {file_path}",+            "_hint": "The path may exist on Docker but not on the Windows host. Use push_file to copy it from Docker first, or verify the host-side path.",+            "data": {"filePath": file_path, "hint": "Check that the file path exists on the Windows desktop machine."},+        }++    ext = os.path.splitext(file_path)[1].lower()+    valid_extensions = {".fsch", ".fbrd", ".flbr"}+    if ext not in valid_extensions:+        ext_hints = {+            ".sch": "Use fusion_open_schematic for legacy EAGLE .sch files",+            ".brd": "Use fusion_open_board for legacy EAGLE .brd files",+            ".lbr": "Use fusion_open_lbr for legacy EAGLE .lbr files",+            ".step": "Use fusion_import_step for .step files",+            ".stp": "Use fusion_import_step for .stp files",+        }+        return {+            "success": False,+            "error": f"Unsupported extension '{ext}'. This command handles Fusion-native electronics formats: .fsch, .fbrd, .flbr",+            "_hint": ext_hints.get(ext, f"Supported: {', '.join(sorted(valid_extensions))}"),+            "data": {+                "hint": ext_hints.get(ext, f"Supported: {', '.join(sorted(valid_extensions))}"),+                "supportedExtensions": sorted(valid_extensions),+            },+        }++    file_type_map = {+        ".fsch": "Fusion schematic",+        ".fbrd": "Fusion board",+        ".flbr": "Fusion library",+    }+    file_type = file_type_map[ext]++    try:+        r = app.executeTextCommand(f"Document.newDesignFromLocal {file_path}")+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to import {file_type}: {e}",+            "data": {+                "filePath": file_path,+                "hint": "Fusion 360 may not support this file version. Ensure Fusion is fully loaded and responsive.",+            },+        }++    time.sleep(1.5)++    # Get workspace info to confirm we landed in the right editor+    ws_info = {}+    try:+        active_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace")+        ws_info["activeWorkspace"] = active_ws.strip() if active_ws else "unknown"+    except Exception:+        pass+    try:+        doc = app.activeDocument+        if doc:+            ws_info["activeDocument"] = doc.name+    except Exception:+        pass++    next_steps = []+    if ext == ".fsch":+        next_steps = [+            "Use fusion_electron_run to send EAGLE commands (e.g. WINDOW FIT)",+            "Use fusion_save_to_cloud to persist this document to the Fusion cloud",+            "Use fusion_close_document to close without saving when done",+        ]+    elif ext == ".fbrd":+        next_steps = [+            "Use fusion_show_3d_board to switch to 3D PCB visualization",+            "Use fusion_electron_run to send EAGLE commands (e.g. WINDOW FIT, RATSNEST)",+            "Use fusion_save_to_cloud to persist this document to the Fusion cloud",+            "Use fusion_close_document to close without saving when done",+        ]+    elif ext == ".flbr":+        next_steps = [+            "Use fusion_export_lbr to verify library contents (.scr text format)",+            "Use fusion_save_to_cloud to persist this library to the Fusion cloud",+            "Use fusion_close_document to close without saving when done",+        ]++    return {+        "success": True,+        "output": f"Imported {file_type}: {os.path.basename(file_path)}",+        "message": f"Imported {file_type}: {os.path.basename(file_path)}. "+                   f"This is a NEW local document — use fusion_save_to_cloud to persist it. "+                   f"IMPORTANT: Fusion may show a blocking dialog. Screenshot to verify.",+        "data": {+            "filePath": file_path,+            "fileType": file_type,+            "extension": ext,+            "nextSteps": next_steps,+            **ws_info,+        },+        "postOpenCheck": {+            "required": True,+            "steps": [+                "Run desktop_list_windows to find the Fusion HWND",+                "Run desktop_screenshot_window with that HWND",+                "If a dialog is visible, dismiss it with fusion_send_key {\"key\": \"escape\"}",+                "Screenshot again to confirm the dialog is gone",+            ],+        },+    }+++def handle_show_2d_board(app: adsk.core.Application, args: dict) -> dict:+    """Switch back to the 2D board layout from 3D PCB view.++    Uses the Fusion command Electron::Insert2DPCB to return to PCB Editor.+    """+    ws = "unknown"+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    if ws == "PCB Editor":+        return {+            "success": True,+            "output": "Already in 2D board layout.",+            "data": {"activeWorkspace": ws},+        }++    try:+        app.executeTextCommand("Commands.Start SwitchPcbDocCmd")+    except Exception as e:+        return {+            "success": False,+            "error": f"Switch to 2D board failed: {e}",+            "_hint": "Call fusion_open_board {\"filePath\":\"...\"} to ensure a board is loaded, then retry.",+            "data": {"activeWorkspace": ws},+        }++    time.sleep(1.0)++    new_ws = "unknown"+    try:+        new_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    return {+        "success": True,+        "output": "Switched to 2D board layout. EAGLE commands via fusion_electron_run will work.",+        "data": {+            "activeWorkspace": new_ws,+            "nextSteps": [+                "Use fusion_electron_run to send EAGLE commands",+                "Use fusion_show_3d_board to switch back to 3D view",+            ],+        },+    }+++def handle_show_schematic(app: adsk.core.Application, args: dict) -> dict:+    """Switch the OPEN electronics design to its SCHEMATIC view.++    The schematic / 2D board / 3D board are VIEWS of ONE electronics design - open the+    PROJECT first (fusion_open_cloud_file / fusion_open_by_urn), then switch views with+    fusion_show_schematic / fusion_show_2d_board / fusion_show_3d_board. Uses Fusion's+    SwitchSchDocCmd (the symmetric partner of SwitchPcbDocCmd / Switch3dPcbDocCmd).+    Drive the schematic for demos with fusion_electron_zoom / _pan / _select.+    """+    ws = "unknown"+    try:+        ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass++    # Already viewing the schematic?+    cur_pt = ""+    try:+        cur_pt = app.activeProduct.productType+    except Exception:+        pass+    if cur_pt == "SchematicProductType":+        return {+            "success": True,+            "output": "Already in the schematic view.",+            "data": {"activeWorkspace": ws, "productType": cur_pt},+        }++    try:+        app.executeTextCommand("Commands.Start SwitchSchDocCmd")+    except Exception as e:+        return {+            "success": False,+            "error": f"Switch to schematic failed: {e}",+            "_hint": "Open the electronics DESIGN first (fusion_open_cloud_file / fusion_open_by_urn), "+                     "then retry. The schematic is a VIEW of the design, not a standalone file.",+            "data": {"activeWorkspace": ws},+        }++    time.sleep(1.2)+    try:+        app.executeTextCommand("Electron.run WINDOW FIT")+    except Exception:+        pass++    new_ws = "unknown"+    new_pt = ""+    try:+        new_ws = app.executeTextCommand("DebugCommands.ActiveWorkspace").strip()+    except Exception:+        pass+    try:+        new_pt = app.activeProduct.productType+    except Exception:+        pass++    return {+        "success": True,+        "output": "Switched to the schematic view. Drive it with fusion_electron_zoom / _pan / _select "+                  "or fusion_electron_run WINDOW commands.",+        "message": "Switched to the schematic. Fusion may show a blocking dialog that is NOT visible to "+                   "the API - screenshot the Fusion window to verify.",+        "data": {+            "activeWorkspace": new_ws,+            "productType": new_pt,+            "nextSteps": [+                "fusion_electron_zoom / fusion_electron_pan to move the view for a recording",+                "fusion_show_2d_board / fusion_show_3d_board to switch to the board / 3D",+                "fusion_take_screenshot to capture the schematic",+            ],+        },+        "postOpenCheck": {+            "required": True,+            "steps": [+                "Run desktop_screenshot_window on the Fusion HWND",+                "If a dialog is visible, dismiss it with fusion_send_key {\"key\": \"escape\"}",+            ],+        },+    }

@@ -0,0 +1,183 @@+"""Open an EAGLE .lbr library file in Fusion 360's Electronics workspace.++Uses the Document.newDesignFromLocal text command to open the file, which+switches Fusion to the Electronics Library editor automatically.+This avoids the fragile workspace-switching dance.++Note: Document.Open fails with error 3 for .lbr files, but+Document.newDesignFromLocal works reliably.++Flow:+  1. Write .lbr XML file to disk (caller provides path or XML content)+  2. Document.newDesignFromLocal <path> opens it in Electronics Library editor+  3. Optionally navigate to a specific symbol with Electron.run EDIT <name>.sym+  4. Optionally export via EXPORT SCRIPT for round-trip verification+"""++import adsk.core+import os+import tempfile+import time+++def handle_open_lbr(app: adsk.core.Application, args: dict) -> dict:+    """Open an EAGLE .lbr file in the Electronics Library editor.++    Args:+        args: Dict with:+            - filePath: Path to the .lbr file on disk (required).+            - symbolName: Optional symbol name to navigate to after opening.+            - verify: If True, exports the library back via EXPORT SCRIPT.+    """+    file_path = args.get("filePath", "")+    symbol_name = args.get("symbolName", "")+    verify = args.get("verify", False)++    if not file_path:+        return {"success": False, "error": "No filePath specified"}++    # Normalize path for Fusion (forward slashes)+    file_path = file_path.replace("\\", "/")++    if not os.path.exists(file_path):+        return {+            "success": False,+            "error": f"File not found: {file_path}",+            "_hint": "The path may exist on Docker but not on the Windows host. Use push_file to copy from Docker, or verify the host-side path.",+        }++    if not file_path.lower().endswith(".lbr"):+        return {+            "success": False,+            "error": f"Not a .lbr file: {file_path}",+            "_hint": "Use fusion_open_schematic for .sch files, fusion_open_board for .brd files, or fusion_import_electronics for .fsch/.fbrd/.flbr files.",+        }++    results = []++    # Step 1: Open the .lbr file via Document.newDesignFromLocal+    # (Document.Open fails with error 3 for .lbr files)+    try:+        r = app.executeTextCommand(f"Document.newDesignFromLocal {file_path}")+        results.append(f"Document.newDesignFromLocal: {r if r else 'ok'}")+    except Exception as e:+        return {+            "success": False,+            "error": f"Document.newDesignFromLocal failed: {e}",+            "_hint": "Call fusion_screenshot to check for a modal dialog blocking Fusion, dismiss with fusion_send_key escape, then retry.",+            "data": {"filePath": file_path},+        }++    # Step 2: If a symbol name was given, navigate to it+    if symbol_name:+        # Give Fusion a moment to finish opening the library+        time.sleep(1)++        sym_ref = symbol_name if symbol_name.endswith(".sym") else f"{symbol_name}.sym"+        try:+            app.executeTextCommand(f"Electron.run EDIT {sym_ref}")+            results.append(f"EDIT {sym_ref}: ok")+        except Exception as e:+            results.append(f"EDIT {sym_ref} failed: {e}")++        # Zoom to fit+        try:+            app.executeTextCommand("Electron.run WINDOW FIT")+            results.append("WINDOW FIT: ok")+        except Exception:+            pass++    # Step 3: Verification via EXPORT SCRIPT+    verification = None+    if verify:+        verification = _export_and_verify(app, symbol_name)+        results.append(f"Verification: exported={verification.get('exported', False)}")++    response = {+        "success": True,+        "output": f"Opened library: {os.path.basename(file_path)}",+        "data": {"results": results, "filePath": file_path},+    }+    if symbol_name:+        response["data"]["symbolName"] = symbol_name+    if verification:+        response["data"]["verification"] = verification+    return response+++def handle_export_lbr(app: adsk.core.Application, args: dict) -> dict:+    """Export the current Electronics library via EXPORT SCRIPT.++    This exports the library contents to an EAGLE .scr script file,+    which is a text representation of the entire library. Useful for+    verifying that a library was loaded correctly (round-trip test).++    Args:+        args: Dict with:+            - outputPath: Path to write the .scr export (optional,+                         defaults to a temp file).+    """+    output_path = args.get("outputPath", "")+    if not output_path:+        import uuid+        output_path = os.path.join(tempfile.gettempdir(), f"_adom_export_{uuid.uuid4().hex[:8]}.scr")++    output_path = output_path.replace("\\", "/")++    try:+        app.executeTextCommand(f"Electron.run EXPORT SCRIPT '{output_path}'")+    except Exception as e:+        return {+            "success": False,+            "error": f"EXPORT SCRIPT failed: {e}. "+                     "Ensure you are in an Electronics editor (library, schematic, or board).",+            "_hint": "Call fusion_open_lbr {\"filePath\":\"...\"} to enter the Electronics Library editor, then retry.",+        }++    if not os.path.exists(output_path):+        return {+            "success": False,+            "error": f"Export file was not created at {output_path}",+        }++    size = os.path.getsize(output_path)+    # Read a preview of the exported content+    with open(output_path, "r", errors="replace") as f:+        preview = f.read(2000)++    return {+        "success": True,+        "output": f"Exported library to {output_path} ({size} bytes)",+        "data": {+            "outputPath": output_path,+            "fileSize": size,+            "preview": preview,+        },+    }+++def _export_and_verify(app: adsk.core.Application, symbol_name: str = "") -> dict:+    """Export library and check if the symbol exists in the output."""+    import uuid+    verify_path = os.path.join(tempfile.gettempdir(), f"_adom_verify_{uuid.uuid4().hex[:8]}.scr")+    try:+        app.executeTextCommand(f"Electron.run EXPORT SCRIPT '{verify_path}'")+        if os.path.exists(verify_path):+            with open(verify_path, "r", errors="replace") as f:+                content = f.read()+            result = {+                "exported": True,+                "fileSize": os.path.getsize(verify_path),+                "preview": content[:1000],+            }+            if symbol_name:+                # EAGLE uppercases symbol names in EXPORT SCRIPT output+                has_symbol = (+                    f"Edit '{symbol_name.upper()}.sym'" in content+                    or f"Edit '{symbol_name}.sym'" in content+                )+                result["hasSymbol"] = has_symbol+            return result+        return {"exported": False, "error": "Export file not created"}+    except Exception as e:+        return {"exported": False, "error": str(e)}

@@ -0,0 +1,134 @@+"""Parameter commands — get and set design parameters."""++import adsk.core+import adsk.fusion+++def handle_get_parameters(app: adsk.core.Application, args: dict) -> dict:+    """Get all parameters (user + model) from the active design.++    Args:+        args: Optional dict with:+            - type: "user", "model", or "all" (default: "all").+    """+    product = app.activeProduct+    if not product or product.productType != "DesignProductType":+        return {+            "success": False,+            "error": "No active design open in Fusion 360",+            "_hint": "Call fusion_open_cloud_file to open a Design document, then retry.",+        }++    design = adsk.fusion.Design.cast(product)+    param_type = args.get("type", "all").lower()++    result = []++    if param_type in ("user", "all"):+        for i in range(design.userParameters.count):+            p = design.userParameters.item(i)+            result.append({+                "name": p.name,+                "type": "user",+                "expression": p.expression,+                "value": p.value,+                "unit": p.unit,+                "comment": p.comment,+            })++    if param_type in ("model", "all"):+        for i in range(design.allParameters.count):+            p = design.allParameters.item(i)+            # Skip user params if we already included them+            if param_type == "all" and _is_user_param(design, p.name):+                continue+            result.append({+                "name": p.name,+                "type": "model",+                "expression": p.expression,+                "value": p.value,+                "unit": p.unit,+            })++    return {+        "success": True,+        "data": result,+        "output": f"Found {len(result)} parameter(s).",+    }+++def handle_set_parameter(app: adsk.core.Application, args: dict) -> dict:+    """Set a parameter's expression by name.++    Args:+        args: Dict with:+            - name: Parameter name (required).+            - expression: New expression string (required), e.g. "10 mm".+    """+    name = args.get("name", "")+    expression = args.get("expression", "")+    if not name:+        return {"success": False, "error": "No parameter name specified"}+    if not expression:+        return {"success": False, "error": "No expression specified"}++    product = app.activeProduct+    if not product or product.productType != "DesignProductType":+        return {+            "success": False,+            "error": "No active design open in Fusion 360",+            "_hint": "Call fusion_open_cloud_file to open a Design document, then retry.",+        }++    design = adsk.fusion.Design.cast(product)++    # Try user parameters first, then all parameters+    param = None+    for i in range(design.userParameters.count):+        p = design.userParameters.item(i)+        if p.name == name:+            param = p+            break++    if not param:+        for i in range(design.allParameters.count):+            p = design.allParameters.item(i)+            if p.name == name:+                param = p+                break++    if not param:+        return {+            "success": False,+            "error": f"Parameter not found: {name}",+            "_hint": "Call fusion_get_parameters to list all valid parameter names, then retry with a correct name.",+        }++    old_expr = param.expression+    try:+        param.expression = expression+    except Exception as e:+        return {+            "success": False,+            "error": f"Failed to set parameter: {e}",+            "_hint": "Verify the expression format (e.g., \"10 mm\", \"5 deg\") and that units match the parameter's unit type.",+        }++    return {+        "success": True,+        "output": f"Parameter '{name}' changed: {old_expr} -> {expression}",+        "data": {+            "name": param.name,+            "expression": param.expression,+            "value": param.value,+            "unit": param.unit,+        },+    }+++def _is_user_param(design: adsk.fusion.Design, name: str) -> bool:+    """Check if a parameter name exists in the user parameters."""+    for i in range(design.userParameters.count):+        if design.userParameters.item(i).name == name:+            return True+    return False

@@ -0,0 +1,136 @@+"""Screenshot command — capture the Fusion 360 viewport."""++import adsk.core+import os+import time+from pathlib import Path+++def _build_view_orientations():+    """Build orientation map at runtime to avoid crashing if enum values differ."""+    orientations = {"home": None}+    try:+        vo = adsk.core.ViewOrientations+        mapping = {+            "front": "FrontViewOrientation",+            "back": "BackViewOrientation",+            "top": "TopViewOrientation",+            "bottom": "BottomViewOrientation",+            "left": "LeftViewOrientation",+            "right": "RightViewOrientation",+            "iso_top_front_right": "IsoTopFrontRightViewOrientation",+            "iso_top_front_left": "IsoTopFrontLeftViewOrientation",+            "iso_top_back_right": "IsoTopBackRightViewOrientation",+            "iso_top_back_left": "IsoTopBackLeftViewOrientation",+            "iso_bottom_front_right": "IsoBottomFrontRightViewOrientation",+            "iso_bottom_front_left": "IsoBottomFrontLeftViewOrientation",+            "iso_bottom_back_right": "IsoBottomBackRightViewOrientation",+            "iso_bottom_back_left": "IsoBottomBackLeftViewOrientation",+        }+        for name, attr in mapping.items():+            if hasattr(vo, attr):+                orientations[name] = getattr(vo, attr)+    except Exception:+        pass+    return orientations+++def handle_take_screenshot(app: adsk.core.Application, args: dict) -> dict:+    """Capture the active viewport to a PNG file.++    Uses Fusion's viewport render API (same as Capture Image from the menu)+    for high-quality renders at any resolution, without opening a dialog.++    Args:+        args: Dict with:+            - outputPath: Full path for the output .png file (required).+            - width: Image width in pixels (default: 1920).+            - height: Image height in pixels (default: 1080).+            - orientation: Camera orientation preset (optional).+              One of: "home", "front", "back", "top", "bottom", "left", "right",+              "iso_top_front_right", "iso_top_front_left", etc.+            - fitToView: If true, zoom to fit all geometry (default: true).+            - listOrientations: If true, return available orientations.+    """+    VIEW_ORIENTATIONS = _build_view_orientations()++    # List orientations mode+    if args.get("listOrientations", False):+        return {+            "success": True,+            "output": f"{len(VIEW_ORIENTATIONS)} view orientations available",+            "data": {"orientations": list(VIEW_ORIENTATIONS.keys())},+        }++    output_path = args.get("outputPath", "")+    if not output_path:+        return {"success": False, "error": "No outputPath specified"}++    width = int(args.get("width", 1920))+    height = int(args.get("height", 1080))+    orientation = args.get("orientation", "").lower().strip()+    fit_to_view = args.get("fitToView", True)++    viewport = app.activeViewport+    if not viewport:+        return {+            "success": False,+            "error": "No active viewport",+            "_hint": "Call fusion_open_cloud_file or fusion_open_board to open a document first — there is nothing to screenshot.",+        }++    Path(output_path).parent.mkdir(parents=True, exist_ok=True)++    # Set camera orientation if specified+    orientation_applied = None+    if orientation:+        if orientation not in VIEW_ORIENTATIONS:+            return {+                "success": False,+                "error": f"Unknown orientation '{orientation}'. "+                         f"Available: {', '.join(VIEW_ORIENTATIONS.keys())}",+            }++        camera = viewport.camera+        view_enum = VIEW_ORIENTATIONS[orientation]++        if view_enum is not None:+            camera.viewOrientation = view_enum+        camera.isFitView = True if fit_to_view else False+        viewport.camera = camera++        # Let Fusion render the new view+        adsk.doEvents()+        time.sleep(0.3)+        adsk.doEvents()++        orientation_applied = orientation+    elif fit_to_view:+        camera = viewport.camera+        camera.isFitView = True+        viewport.camera = camera+        adsk.doEvents()++    result = viewport.saveAsImageFile(output_path, width, height)++    if result:+        size = os.path.getsize(output_path) if os.path.exists(output_path) else 0+        response = {+            "success": True,+            "output": f"Screenshot saved to {output_path} ({width}x{height})",+            "data": {+                "outputPath": output_path,+                "width": width,+                "height": height,+                "fileSizeKB": size // 1024,+            },+        }+        if orientation_applied:+            response["data"]["orientation"] = orientation_applied+        return response++    return {+        "success": False,+        "error": "Screenshot capture failed",+        "_hint": "Try desktop_screenshot_window with the Fusion HWND as a fallback (captures the full window including UI chrome).",+    }

@@ -0,0 +1,308 @@+"""Silkscreen capture — render isolated top/bottom silkscreen layer PNGs.++Hides all 3D bodies except the target silkscreen layer, aims the camera+at the PCB bounding box, captures a 2048x2048 transparent-background PNG,+then restores the original visibility and camera state.++This is a low-level primitive. Orchestration (which documents to open,+which workspace to activate, where to save) belongs in the skill layer.+"""++import adsk.core+import adsk.fusion+import os+import time+from pathlib import Path+++def _pump_events(iterations=5):+    """Flush Fusion's event queue so visibility/camera changes render."""+    try:+        for _ in range(iterations):+            adsk.doEvents()+    except Exception:+        pass+++def _compute_pcb_bbox(design):+    """Union bounding boxes of all bodies to frame the board."""+    combined = None++    def merge(bbox):+        nonlocal combined+        if not bbox:+            return+        if combined is None:+            combined = adsk.core.BoundingBox3D.create(+                bbox.minPoint.copy(), bbox.maxPoint.copy()+            )+        else:+            combined.expand(bbox.minPoint)+            combined.expand(bbox.maxPoint)++    for ci in range(design.allComponents.count):+        comp = design.allComponents.item(ci)+        for bi in range(comp.bRepBodies.count):+            try:+                merge(comp.bRepBodies.item(bi).boundingBox)+            except Exception:+                pass+        for mi in range(comp.meshBodies.count):+            try:+                merge(comp.meshBodies.item(mi).boundingBox)+            except Exception:+                pass+    return combined+++def _bbox_center_and_extent(bbox):+    if bbox is None:+        return adsk.core.Point3D.create(0, 0, 0), 20.0, 20.0+    mn, mx = bbox.minPoint, bbox.maxPoint+    cx = (mn.x + mx.x) / 2+    cy = (mn.y + mx.y) / 2+    cz = (mn.z + mx.z) / 2+    xy_ext = max(abs(mx.x - mn.x), abs(mx.y - mn.y), 1.0)+    z_ext = max(abs(mx.z - mn.z), 1.0)+    return adsk.core.Point3D.create(cx, cy, cz), xy_ext, z_ext+++def _is_silk_match(name, target):+    """True if body/mesh/canvas name matches the target silkscreen layer."""+    n = name.lower()+    return "silk" in n and target in n+++def _store_visibility(design):+    """Snapshot visibility of all bodies, meshes, and canvases."""+    state = {"root_b": {}, "root_m": {}, "comps": {}}+    root = design.rootComponent+    for i in range(root.bRepBodies.count):+        state["root_b"][i] = root.bRepBodies.item(i).isVisible+    for i in range(root.meshBodies.count):+        state["root_m"][i] = root.meshBodies.item(i).isVisible+    for ci in range(design.allComponents.count):+        comp = design.allComponents.item(ci)+        ck = ci+        state["comps"][ck] = {"b": {}, "m": {}, "cv": {}}+        for bi in range(comp.bRepBodies.count):+            state["comps"][ck]["b"][bi] = comp.bRepBodies.item(bi).isVisible+        for mi in range(comp.meshBodies.count):+            state["comps"][ck]["m"][mi] = comp.meshBodies.item(mi).isVisible+        for cvi in range(comp.canvases.count):+            try:+                c = comp.canvases.item(cvi)+                state["comps"][ck]["cv"][cvi] = getattr(c, "isLightBulbOn", True)+            except Exception:+                pass+    return state+++def _restore_visibility(design, state):+    """Restore a previous visibility snapshot."""+    if not state:+        return+    root = design.rootComponent+    for i, vis in state.get("root_b", {}).items():+        try:+            root.bRepBodies.item(i).isVisible = vis+        except Exception:+            pass+    for i, vis in state.get("root_m", {}).items():+        try:+            root.meshBodies.item(i).isVisible = vis+        except Exception:+            pass+    for ci in range(design.allComponents.count):+        cs = state.get("comps", {}).get(ci, {})+        comp = design.allComponents.item(ci)+        for bi, vis in cs.get("b", {}).items():+            try:+                comp.bRepBodies.item(bi).isVisible = vis+            except Exception:+                pass+        for mi, vis in cs.get("m", {}).items():+            try:+                comp.meshBodies.item(mi).isVisible = vis+            except Exception:+                pass+        for cvi, vis in cs.get("cv", {}).items():+            try:+                c = comp.canvases.item(cvi)+                if hasattr(c, "isLightBulbOn"):+                    c.isLightBulbOn = vis+            except Exception:+                pass+++def _hide_all_except_silk(design, target):+    """Hide everything except the target silkscreen layer ('top'/'bottom').++    Silkscreen in Fusion 3D PCB is stored as Canvases (not bodies).+    Canvases are overlaid on the Board body, so the Board body must stay+    visible as a backdrop — otherwise the canvas renders over nothing and+    the viewport capture comes out blank.+    """+    root = design.rootComponent++    for i in range(root.bRepBodies.count):+        b = root.bRepBodies.item(i)+        b.isVisible = False+    for i in range(root.meshBodies.count):+        m = root.meshBodies.item(i)+        m.isVisible = False++    for ci in range(design.allComponents.count):+        comp = design.allComponents.item(ci)+        comp_name = comp.name.lower()++        for bi in range(comp.bRepBodies.count):+            b = comp.bRepBodies.item(bi)+            # Keep the Board body visible — canvases need it as a backdrop+            if comp_name == "board" and b.name.lower() == "board":+                b.isVisible = True+            else:+                b.isVisible = False++        for mi in range(comp.meshBodies.count):+            m = comp.meshBodies.item(mi)+            m.isVisible = False++        for cvi in range(comp.canvases.count):+            c = comp.canvases.item(cvi)+            try:+                if hasattr(c, "isLightBulbOn"):+                    c.isLightBulbOn = _is_silk_match(c.name, target)+            except Exception:+                pass+++def _capture_png(viewport, output_path, width=2048, height=2048):+    """Save viewport as PNG, preferring transparent background."""+    try:+        opts = adsk.core.SaveImageFileOptions.create(output_path)+        opts.width = width+        opts.height = height+        opts.isBackgroundTransparent = True+        opts.isAntiAliased = True+        if viewport.saveAsImageFileWithOptions(opts):+            return True+    except Exception:+        pass+    try:+        return viewport.saveAsImageFile(output_path, width, height)+    except Exception:+        return False+++# ── Public handler ──────────────────────────────────────────────────────++def handle_take_silkscreen_screenshot(app: adsk.core.Application, args: dict) -> dict:+    """Capture an isolated silkscreen layer as a transparent-background PNG.++    Requires the active document to be a 3D Design (not PCB Editor).+    Call fusion_show_3d_board first if you're in the 2D board view.++    Args:+        outputPath (str): Full path for the output .png file (required).+        layer (str): "top" or "bottom" (required).+        width (int): Image width in pixels (default: 2048).+        height (int): Image height in pixels (default: 2048).++    Returns success + outputPath + fileSizeKB.+    """+    output_path = args.get("outputPath", "")+    if not output_path:+        return {+            "success": False,+            "error": "outputPath is required",+            "_hint": 'Provide {"outputPath": "C:/tmp/silk_top.png", "layer": "top"}',+        }++    layer = args.get("layer", "").lower().strip()+    if layer not in ("top", "bottom"):+        return {+            "success": False,+            "error": f"layer must be 'top' or 'bottom', got '{layer}'",+            "_hint": '{"outputPath": "...", "layer": "top"}',+        }++    width = int(args.get("width", 2048))+    height = int(args.get("height", 2048))++    # Need an active Design product (3D view)+    product = app.activeProduct+    if not product or product.productType != "DesignProductType":+        return {+            "success": False,+            "error": "No active Design document. Silkscreen capture requires the 3D PCB view.",+            "_hint": "Call fusion_show_3d_board to switch to the 3D view, then retry.",+        }+    design = adsk.fusion.Design.cast(product)++    viewport = app.activeViewport+    if not viewport:+        return {"success": False, "error": "No active viewport"}++    Path(output_path).parent.mkdir(parents=True, exist_ok=True)++    # Save state+    camera = viewport.camera+    orig_eye = camera.eye.copy()+    orig_target = camera.target.copy()+    orig_up = camera.upVector.copy()+    bbox = _compute_pcb_bbox(design)+    vis_state = _store_visibility(design)++    try:+        center, xy_ext, z_ext = _bbox_center_and_extent(bbox)++        # Hide everything except the target silkscreen layer+        _hide_all_except_silk(design, layer)++        # Aim camera straight down (top) or straight up (bottom)+        if layer == "top":+            eye_z = center.z + z_ext + xy_ext * 2.0+        else:+            eye_z = center.z - z_ext - xy_ext * 2.0++        camera.eye = adsk.core.Point3D.create(center.x, center.y, eye_z)+        camera.target = adsk.core.Point3D.create(center.x, center.y, center.z)+        camera.upVector = adsk.core.Vector3D.create(0, 1, 0)+        camera.viewExtents = xy_ext * 1.2+        camera.isSmoothTransition = False+        viewport.camera = camera+        viewport.refresh()++        # Let GPU finish rendering the new visibility state+        _pump_events()+        time.sleep(1.0)++        ok = _capture_png(viewport, output_path, width, height)+        if not ok:+            return {+                "success": False,+                "error": "Viewport capture failed",+                "_hint": "Try desktop_screenshot_window as a fallback.",+            }++        size = os.path.getsize(output_path) if os.path.exists(output_path) else 0+        return {+            "success": True,+            "output": f"Silkscreen {layer} captured to {output_path}",+            "data": {+                "outputPath": output_path.replace("\\", "/"),+                "layer": layer,+                "width": width,+                "height": height,+                "fileSizeKB": round(size / 1024, 1),+            },+        }+    finally:+        # Always restore+        camera.eye = orig_eye+        camera.target = orig_target+        camera.upVector = orig_up+        viewport.camera = camera+        viewport.refresh()+        _restore_visibility(design, vis_state)