Fusion - the Fusion 360 Bridge

@@ -1,200 +1,220 @@ # Adom Desktop - Fusion 360 Bridge -Drive **Autodesk Fusion 360** from the cloud through [Adom Desktop](https://wiki.adom.inc/adom/adom-desktop). A small local HTTP server that Adom Desktop spawns and proxies `fusion_*` verbs to — it launches Fusion, talks to the bundled **AdomBridge** add-in, and exposes Fusion Electronics + design automation: open an EAGLE board, lay out copper, render the populated 3D PCB, export Gerbers / BOM / STEP, walk the cloud tree, and **search your Fusion cloud files fast via APS**.+Drive **Autodesk Fusion 360** from the cloud through [Adom Desktop](https://wiki.adom.inc/adom/adom-desktop):+component libraries with real 3D, parametric IPC package generation with laser-etched markings,+electronics board workflows, manufacturing exports (Gerbers/BOM/CPL), per-manufacturer design rules,+and fast APS cloud-file search - all by asking your AI. Every verb returns a rich `_hint`, so a+calling AI never has to guess. -Real boards driven through it: TI DRV8323SR + DRV8411A motor drivers and an ST VL53L8 time-of-flight sensor.--![TI DRV8323SR gate-driver board, rendered in 3D](fz-3d.png)--![DRV8411A copper layout in the Fusion Electronics editor](fz-2d.png)--![ST VL53L8 ToF sensor breakout, populated board](fz-sensor.png)--## Demo - a whole 12-part 3D library from ONE call (zero GUI dialogs)--<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library2-3d-montage.mp4"></video>--[Watch the montage](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library2-3d-montage.mp4) - a **12-part** library (10 Adom basic parts + an **ESP32-S3FN8** and an **ATSAMD51J20A** microcontroller) with **real, rendering 3D on every package** (footprint + chip, aligned), built by a single `fusion_build_library_3d` call. For each part you see the BEFORE (the footprint loaded in the 3D viewer) and the AFTER (the real chip placed flat on it, pads landing on pads). No Save dialogs, no clicking.--![The 12-part library, every package rendering its real chip on its footprint](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib2-12part-library.png)--| Footprint loads (before) | Real chip placed (after) |-|---|---|-| ![ESP32-S3FN8 footprint in the 3D viewer](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib2-esp32-footprint.png) | ![ESP32-S3FN8 chip on its footprint](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib2-esp32-chip.png) |--`fusion_build_library_3d` runs the entire pipeline - per-part footprint+chip `.f3d` packages, all-bindings injected in one pass, the finished library opened once - and returns every part's `wip_urn`-plus a before/after screenshot. See [`fusion-multipart-libraries`](skills/fusion-multipart-libraries/SKILL.md).--### The library itself, not just the 3D+```+"generate an IPC SOIC-8 with LM358 etched on top and export the STEP"   - just ask Claude+``` -The 3D proves the chip renders, but EEs want the **symbol, footprint, and device** views.-`fusion_capture_library_views {packages:[...]}` grabs them straight from Fusion's Library editor:+## Component library manager - the Adom basic parts library -| Schematic symbol (full pinout) | Footprint (pads + layer stack) | Component view (footprint↔package Mapped ✓) |-|---|---|---|-| ![ESP32-S3FN8 schematic symbol](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib2-symbol.png) | ![ESP32-S3FN8 footprint editor](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib2-footprint-editor.png) | ![ESP32-S3FN8 component view](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib2-component.png) |+The bridge builds and opens full EAGLE-format component libraries in Fusion's library editor. Below:+the **entire Adom basic parts library** (138 parts - 0402/0603/0805 R/C/L, LEDs, and more) open in+the Content Manager: the component list, the R-0402 deviceset's schematic symbol, footprint + 3D+chip previews, and the footprint↔package **Mapped ✓** check EEs look for. -Every pin named on the symbol, the real pad array + Copper/Silkscreen/Mask layers on the footprint,-and the Content Manager showing the package **Mapped** with matching pin/pad counts. The demo video-above opens with these views before the 3D.+![Adom basic parts library in the Fusion library manager](screenshots/library-manager-138.png) -## Showcase: the ENTIRE Adom basic parts library (138 parts)+- `fusion_open_lbr` - open any `.lbr` in the library editor+- `fusion_build_library_3d` - build a whole RENDERING multi-part 3D library in one call+- `fusion_capture_library_views` - capture the symbol / footprint / component view per part+- Get the library: [adom-basic-parts-fusion-lbr](https://wiki.adom.inc/adom/adom-basic-parts-fusion-lbr)  <video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/AdomBasicParts-138-library.mp4"></video> -The bridge built the **complete [Adom basic parts library](https://wiki.adom.inc/basic-parts-library)-as a Fusion 360 library**: all **138 parts** (79 resistors, 40 MLCC capacitors, 11 LEDs, 6 inductors,-2 ferrite beads), every value placeable with its real footprint and a **rendering 3D model**.--The trick to doing it fast: those 138 values share only **10 footprints** (one `R-0402` used by all 41-of the 0402 resistor values, one `C-0603` by all 14 of those caps, etc.) - exactly how a real EAGLE-library is built. So the whole thing is **10 `fusion_build_library_3d` 3D packages + 138 devicesets**-that share them, not 138 separate 3D builds.+![138-part overview](screenshots/lib3-138-overview.png) -![The 138-part library in Fusion's Content Manager](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/lib3-138-overview.png)+## Generate IPC packages from parameters (ElectronicsPackageGenerator) -**Drop it into a design:** download-[AdomBasicParts_full.lbr](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/AdomBasicParts_full.lbr)-and `fusion_open_lbr` it (or import it in Fusion's Electronics Library workspace). Every deviceset-carries `VALUE` / `MPN` / `MF` / `MOUSER` attributes straight from the catalog.+Fusion ships a built-in **ElectronicsPackageGenerator** add-in (~50 package families with IPC-7351B+calculators). This bridge drives it **headlessly** via `fusion_generate_package`: parametric 3D+package + laser-etched marking + STEP export, in ONE call, a few seconds per part. -(The earlier 10-part montage built with the per-part `fusion_make_3d_package` verb is still-[here](https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library-3d-montage.mp4).)+![0603 chip with 103 etched](screenshots/epg-0603-103.png) -## Install (via Adom Desktop)--```-adom-desktop bridge_install '{"manifestUrl":"https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/adom-bridge-fusion-manifest.json"}'+```bash+adom-desktop fusion_generate_package '{+  "type": "soic",+  "params": {"DPins": 8, "D": 4.9, "E": 6.0, "E1": 3.9, "e": 1.27, "A": 1.6, "A1": 0.1, "b": 0.41, "L": 0.84},+  "etch": "LM358\nADOM-A",+  "outputStep": "C:/tmp/ADOM-LM358-SOIC8.step"+}' ``` -AD downloads the manifest + zip, sha256-verifies, and caches it; the cached version supersedes the copy bundled in the AD installer. Manage with `bridge_list` / `bridge_kill` / `bridge_log_read`.+![SOIC-8 with white LM358 marking](screenshots/epg-soic8-lm358-white.png) -## What it does+**Why this matters:** the output is OUR generated geometry from open IPC-7351B math - **no vendor+CAD licenses, no redistribution restrictions** - the royalty-free path to a complete component+library. Families: chip (0402/0603/0805...), soic, soj, sot23/143/223, son, qfn, qfp, plcc, bga,+dfn2/3/4, dip (+sockets), dpak, melf, molded, ecap, radial + axial passives, crystals (+HC49),+oscillators, headers (straight/right-angle, socket/SMD), standoffs, chip arrays, LEDs. -- **Launch + drive Fusion** — `fusion_start`, dialog/recovery handling, window screenshots, key/click.-- **Electronics + exports** — open schematic/board, STEP / IGES / STL / 3MF / USDZ / OBJ / DXF / DWG / Gerbers, BOM / CPL, `.lbr` import/export, silkscreen capture, InstaPCB design rules.-- **Cloud files** — `fusion_walk_cloud_tree`, `fusion_search_cloud_files`, and **fast indexed search** via `fusion_aps_search` (Autodesk Platform Services Data Management index — seconds, not the multi-minute folder walk).-- **Self-reporting health** — serves `/status` (the manifest `healthEndpoint`) with a `{led, summary, tooltip}` GUI chip; every spawn logs to `~/.adom/bridge-logs/fusion360.log`.+**Markings that read like real silkscreen:**+- **Raised WHITE text by default** (a thin positive extrude painted white - the contrast humans can+  actually read; `etchStyle:"engraved"` for a sunken laser cut when a datasheet calls for it).+- The top surface is found from the **whole-chip bounding box**: only upward faces in the **top 5%+  height band** count (terminals tie the body on height), then **largest area** wins.+- Text runs along the **longest axis** of the face (auto-rotated 90° when needed), with a **10%+  margin ENFORCED by measuring** the placed text and shrink-to-fitting - never a font-metric guess.+- **Multi-line**: `"LM358\nADOM-A"` = MPN + variant, per-line auto-fit.+- A **sidecar manifest** (`<step>.manifest.json`) records every setting picked + WHY + the+  calculated bboxes, so a marking refresh (adding a variant line later) reproduces placement exactly. -`fusion_aps_*` (status / set_client_id / signin / search / get) run the bridge's own PKCE OAuth against APS — see the `fusion-aps-search` and `fusion-aps-signin` skills for the setup.+![Two-line MPN + variant marking with enforced margins](screenshots/epg-2line-margins.png) -## Electronics workflow: open the PROJECT, not the pieces+The exported STEP is **colored** (AP214): the white marking arrives white in KiCad's 3D viewer. -A Fusion electronics design is a **parent/child chain of separate files**, each a distinct `productType`. **Open the PROJECT, never the schematic / .brd / 3D directly:**+## Electronics boards: project → schematic → 2D board → 3D board -```-PROJECT        EcadDesignProductType    <- open THIS (fusion_open_cloud_file / fusion_open_by_urn)-  |- schematic   SchematicProductType-  |- board/.brd  BoardProductType-  |- 3D PCB      DesignProductType       (generated FROM the .brd, the leaf - no editable board)-```+A Fusion electronics design is a parent/child chain: the **PROJECT** file (open THIS) links the+schematic, the 2D board layout, and the generated 3D PCB. The bridge opens the project and switches+views on command - each `show_*` verb returns a screenshot array so the AI SEES what it switched to. -Open the project, then switch views with `fusion_show_2d_board` / `fusion_show_3d_board` (and the schematic). Opening a CHILD directly gives an isolated/empty view, so `fusion_open_cloud_file` and `fusion_open_by_urn` **reprimand you in the response `_hint`** when the opened file is not `EcadDesignProductType`. Same-named copies in OTHER projects are usually 3D-model derivatives, not the project.--**Lifecycle:** `fusion_start` (launch) · `fusion_stop` (graceful close, no force) · `fusion_kill` (force-kill `taskkill /F`, the desperate path). `fusion_close` is a deprecated alias of the old graceful-then-force behavior.--**Driving the editor (for demos / screen recordings):** smooth, scripted motion from single calls, each looping inside the add-in (one call = one move, a repaint per frame):-- `fusion_electron_zoom {factor|fit, steps?}` - smooth zoom in/out of the schematic / 2D board.-- `fusion_electron_pan {x1,y1,x2,y2, steps?}` - glide+frame a board-coordinate region (mm); get part positions from `fusion_board_info` / `fusion_export_cpl`.-- `fusion_electron_select {name|x,y}` - select a part and surface its properties (pair with `pan` for a "select chip -> zoom to it" tour).-- For the 3D PCB, orbit the camera via `fusion_run_modeling_script` (`app.activeViewport.camera` stepped around the target, `vp.refresh()` between frames).--Capture with WGC (`desktop_record_window_start`) - it grabs the live editor canvas without stealing focus.--**Full verb reference:** every verb with its input/output schema and examples is in **[`VERBS.md`](VERBS.md)** (generated from the bridge's own `fusion_describe`).--**Building component libraries** (symbol + footprint + 3D into a placeable `.lbr`, with the chip-fetcher / adom-symbol / adom-footprint / adom-lbr pipeline and the 3D-via-cloud-URN flow): see **[`MAKING_LIBRARIES.md`](MAKING_LIBRARIES.md)** (the guide) and its companion **[`LIBRARY_FINDINGS.md`](LIBRARY_FINDINGS.md)** (the hard-won findings log: the `.fusion` variant, the exact `package3d` `wip_urn` markup, the owned-popup error-capture technique, and every pitfall).--**Building / publishing / forking this bridge** (version bump, build the zip, publish as a wiki *release*, install into Adom Desktop, and the community fork -> test -> PR flow, with all the pitfalls): see **[`PUBLISHING.md`](PUBLISHING.md)**.--### Packages vs Releases on the wiki (and why this bridge ships as a Release)--The Adom Wiki gives every page two distribution channels, and they are NOT the same thing:--| | **Package** (`pkg` / `adompkg`) | **Release** (`release`) |-|---|---|---|-| Model | npm-style **dependency** registry | GitHub-Releases-style **downloadable assets** |-| Holds | versioned tarballs + `package.json` + a dependency map + dist-tags | per-version, per-platform **binary assets** (zips, installers, compiled binaries) |-| Consumed by | `adompkg install <slug>` - resolves + installs deps transitively, like `npm i`, so OTHER code can import it | a direct **download by URL** (`/download/<org>/<slug>/<ver>/<file>`) - nothing resolves it as a dependency |-| Use it when | your page IS a code library other packages depend on | you ship an artifact someone downloads + runs |+| View | Verb |+|---|---|+| Project (parent: schematic + 2D + 3D previews) | `fusion_open_cloud_file` / `fusion_aps_open` (the project file) |+| Schematic | `fusion_show_schematic` |+| 2D board layout | `fusion_show_2d_board` |+| 3D board | `fusion_show_3d_board` (orbitable via `fusion_run_modeling_script`) | -**This bridge ships its build as a Release.** Adom Desktop's `bridge_install` is handed a manifest whose-`url` points straight at the release asset and **streams the zip by URL** into its bridge cache - it-never `adompkg install`s the bridge as a code dependency. So the `.zip` goes through-`adom-wiki release upload` (binaries do not belong in the git repo; see [`PUBLISHING.md`](PUBLISHING.md)),-and only the small **manifest JSON** lives in the page's git repo, pointing at that release.+Real Adom boards driven through it - the DRV8411A copper layout in the 2D editor, and the TI+DRV8323SR + ST VL53L8 boards rendered as populated 3D PCBs: -## ⚡ Fast cloud search (APS) — find any team design in seconds+![DRV8411A copper layout in the Fusion Electronics editor](fz-2d.png) -Searching your Fusion 360 cloud files the normal way (the in-app data API) takes **30+ minutes** on a real team hub — it has to walk folders one at a time. This bridge instead queries **Autodesk Platform Services (APS)**, Autodesk's **server-side index**, so the same search returns in **seconds**. Live-proven: searching "Molecule" across a 16-project hub returned 37 real files in ~12 seconds.+![TI DRV8323SR gate-driver board, rendered in 3D](fz-3d.png) -It also works with **Fusion closed** — it's pure HTTPS against the cloud.+![ST VL53L8 ToF sensor breakout, populated board](fz-sensor.png) -### What you can do (verbs)+⚠ Always open the PROJECT - opening a child (.brd / 3D) directly gives an isolated view. The open+verbs reprimand via `_hint` if you open a non-project file. -| Verb | Does |-|---|---|-| `fusion_aps_search {query}` | Fast name search across every project in the team hub. Newest-first, shows which project each file is in. Scope with `{projectId}` for an even faster single-project search. |-| `fusion_aps_browse {}` / `{projectId}` / `{folderId}` | Browse hubs → projects → folders → files, no Fusion needed (a cloud file explorer). |-| `fusion_aps_open {query}` | Search by name and **open the best match in Fusion** — works for any file, however deeply nested (opens by the file's exact cloud URN). Returns immediately; the open finishes in the background (poll `fusion_get_app_state`), or pass `{wait:true}`. |-| `fusion_aps_recent {limit?}` | Most-recently-modified designs across the team hub, newest-first (great for "what changed today?"). |-| `fusion_aps_file_info {query}` | Version history for a design — how many versions, who last touched it, when, and size. |-| `fusion_aps_status {}` | Is it configured? signed in? token live? Plus the never-charge usage meter. |-| `fusion_aps_signin {}` | One-time per user — opens the Autodesk consent, captures the token. |-| `fusion_aps_set_client_id {clientId}` | Set the org's APS Client ID. |+## Manufacturing exports: Gerbers, BOM, CPL -### 🔑 Authentication — set up ONCE per company, each teammate just signs in once+One verb each, straight from the open board: -This is the important part, and it's designed to be painless:+```bash+adom-desktop fusion_export_gerbers '{"outputPath": "C:/tmp/gerbers"}'   # JLCPCB-ready CAM job+adom-desktop fusion_export_bom     '{"outputPath": "C:/tmp/bom.csv"}'   # grouped by value+package+adom-desktop fusion_export_cpl     '{"outputPath": "C:/tmp/cpl.csv"}'   # pick-and-place centroids+``` -- **An admin sets up APS once for the whole company** — register a free APS app (the AI drives the entire setup; see the `fusion-aps-signin` skill), which produces a **Client ID**. That Client ID is a **public PKCE identifier (no secret)**, so it's safe to share across the company / bake into that org's bridge config.-- **Every teammate then just runs `fusion_aps_signin` once** — they sign in with **their own** Autodesk account (one consent click), and immediately get fast search of the team's shared files. **No plan, no credit card, no app registration, no setup for them.**-- **Per-organization, not platform-wide.** Each company that uses Adom runs this setup once for *itself* (so each org's usage rides its *own* free plan and sees its *own* data). Adom employees share Adom's Client ID; other orgs (e.g. NTX, Teaazers) each create their own. Don't ship one global Client ID for everyone.+Plus mechanical exports: STEP / IGES / STL / 3MF / USDZ / OBJ / DXF / DWG. Long exports return+promptly with `statusVerb: fusion_get_app_state` - the AI polls instead of blocking. -### 💸 You are NEVER charged+## Design rules per manufacturer (JLCPCB 2-layer, 4-layer, ...) -The APS Free tier requires a card **only to verify identity** — there is no charge. The bridge enforces this three ways: the PKCE app type **structurally cannot call paid APIs**; the bridge calls **only free Data Management endpoints**; and a **monthly hard cap fails closed** before any quota. `fusion_aps_status` reports the live usage meter.+The bridge ships manufacturer rule files + CAM jobs in `resources/` and loads them into the open+board, so DRC matches what the fab actually checks: -### Getting started+```bash+adom-desktop fusion_load_design_rules '{"ruleFile": "JLCPCB-2layer.dru"}'+adom-desktop fusion_set_design_rules  '{"rules": {"minClearance": 0.127}}'   # ad-hoc tweaks+``` -1. `fusion_aps_status` — it tells you exactly what's next (configure / sign in / ready).-2. First time for a company: the AI drives the one-time APS app setup (`fusion-aps-signin` skill) → Client ID.-3. Each user: `fusion_aps_signin` once → `fusion_aps_search "<part name>"`.+Included: JLCPCB 2-layer + 4-layer DRU rules, the matching Gerber CAM jobs (used by+`fusion_export_gerbers`), and Adom's house rules.++## How the bridge talks to Fusion (architecture)++![Architecture: cloud AI to AD relay to bridge to add-in to Fusion](screenshots/architecture.svg)++The bridge picks the right channel per task:++1. **Python bridge server** (`server.py`) - spawned by Adom Desktop, receives every `fusion_*` verb.+2. **AdomBridge add-in** - installed BY the bridge into every Fusion add-in location+   (`%APPDATA%\Autodesk\FusionAddins` on 2025+ Fusion, plus the legacy `API\AddIns` dirs - Fusion+   moved this across versions and silently ignores the others). It serves HTTP :8774 inside Fusion+   and marshals work onto Fusion's single main thread via CustomEvent.+3. **In-Fusion channels**: the `adsk` Python API for data/geometry, `executeTextCommand` for EAGLE+   editor commands (EDIT / ADD / WINDOW FIT), `Electron.run` for electronics-UI JS+   (zoom/pan/select), and `run_modeling_script` for free-form CAD (this is how EPG packages and+   laser markings are generated).+4. **Win32 / UIA side channel** - when the API can't reach it: background hwnd screenshots, WM_CLOSE+   dialog dismissal (no focus steal), SendInput keys/clicks, and AD core verbs+   (`desktop_find_control` / `desktop_ui_click`).+5. **APS cloud** (`aps.py`) - fast server-indexed search + file ops at scale (below).++## Dialog awareness: parent/child screenshots (the automation breakthrough)++Fusion's classic failure mode is a **modal dialog** (save prompt, recovery, licensing) silently+blocking the add-in's main thread while the caller sees only a fake "not responding". The+breakthrough: Adom Desktop's window capture returns a window's **owned child popups** - dialogs that+don't even enumerate in a normal window list - so every mutating verb returns a **classified dialog+array + screenshots** and the AI can never fly blind past one.++![A licensing decision dialog caught during first launch](screenshots/dialog-active-sessions.png)++- Benign launch errors (an incomplete webdeploy folder) are **auto-dismissed in the background**+  (WM_CLOSE - never a focus-stealing Escape).+- DECISION dialogs - like the seat conflict above, whose options suspend Fusion on the user's OTHER+  machine - are **never auto-picked**: the bridge returns `needsUserDecision:true` and the AI+  notifies + asks the user.+- `fusion_check_dialogs` polls the dialog array on demand; `fusion_dismiss_blocking_dialogs` clears+  the known-safe ones.++## ⚡ Fast cloud search + file management (APS)++`fusion_aps_search` finds any design in the team's Fusion cloud in ~2 seconds (server-indexed - not+a slow tree walk), plus browse / recent / file-info / versions / upload / download / folder creation.++**Authentication:** APS uses Autodesk's official OAuth (PKCE). Setup is **once per company** - an+admin registers the APS app (`fusion_aps_set_client_id`), then **each user signs in once** in a+browser (`fusion_aps_signin`); tokens refresh silently afterward. It is **per-org by design**: each+company uses its own APS app, credentials, and quota. **You are never charged** - the bridge caps+all calls to Autodesk's free tier.++**Cloud hygiene:** the bridge NEVER writes to a shared project root - uploads default to an+**Adom AI Workspace** folder with per-task subfolders, and `fusion_cleanup_cloud_files` deletes+precisely by lineage URN (never by name).++## Installing Fusion for the user (or finding theirs)++The AI does the whole setup - the user never gets handed a download link:++- **Detection first:** AD detects an existing Fusion via this bridge's `detect` paths - per-user+  (`%LOCALAPPDATA%`) AND system-wide (`%ProgramFiles%`, from `--globalinstall`) webdeploy installs.+  `fusion_readiness` / AD's `bridge_readiness` answer installed/running/ready without launching+  anything.+- **AI-driven install:** if Fusion is absent, the AI OFFERS to install it and does it on a yes - the+  fusion-onboarding skill silent-installs the **free trial / personal-use tier** (plenty for viewing+  and real work), drives the Autodesk sign-in (the user types only their own credentials/2FA), and+  deploys the add-in. A **view-only trial** install is a first-class option for users who just need+  to open and inspect designs.+- **Never a manual step:** the bridge restarts Fusion itself (`fusion_stop`/`fusion_start`),+  installs the add-in to every add-in directory Fusion has ever used, and fires an AD toast the+  moment a step genuinely needs the user (sign-in, 2FA, license acceptance). -Full reasoning + setup procedure live in the bundled skills: **`fusion-aps-search`** (why/architecture/auth model) and **`fusion-aps-signin`** (the AI-driven setup, step by step).+## Install (via Adom Desktop) -## Building component libraries (symbol + footprint + rendering 3D)+```bash+adom-desktop bridge_install '{"manifestUrl": "https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/adom-bridge-fusion-manifest.json"}'+adom-wiki pkg install adom/adom-desktop-fusion-bridge   # the skills pack for your AI+``` -Build ONE `.lbr` holding many parts, each with a real, RENDERING 3D model - **fully programmatically,-no GUI dialogs.** The verb `fusion_make_3d_package` turns a STEP into a renderable 3D-package-`wip_urn` (import -> orient flat -> save f3d -> upload), which you hand-write into the library's-`<packages3d>`. Proven on a 10-part Adom basic-parts library (R/C/L/LED/nRF54L15), every package-rendering its real chip flat on its footprint.+Auto-updates via `updateManifestUrl` (AD polls on launch + every 4h). 54 verbs -+`fusion_describe '{}'` returns the full machine-readable catalog. More demos: -- **Many parts in one library:** the [`fusion-multipart-libraries`](skills/fusion-multipart-libraries/SKILL.md)-  skill (the per-package 3D recipe + the dead ends to avoid) and the full tool-chain tutorial-  [CREATING_BASIC_PARTS_LIBRARIES.md](CREATING_BASIC_PARTS_LIBRARIES.md).-- **One part end to end:** the [`fusion-libraries`](skills/fusion-libraries/SKILL.md) skill +-  [MAKING_LIBRARIES.md](MAKING_LIBRARIES.md).-- **Operating Fusion safely** (read the dialog array, never fly blind) + **cloud-save discipline:**-  [`fusion-driving`](skills/fusion-driving/SKILL.md) + [`fusion-cloud-save`](skills/fusion-cloud-save/SKILL.md).+<video controls width="100%" src="https://wiki.adom.inc/api/v1/pages/adom-desktop-fusion-bridge/files/library2-3d-montage.mp4"></video>  ## Source code -**This wiki page IS the git repository.** Every file you see in the [**Files tab**](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge) is the live source, browsable in place: `server.py`, `aps.py`, `describe.py`, the whole Fusion add-in under `addin/AdomBridge/`, the `handlers/`, the bundled `skills/`, all of it. No GitHub account needed. Two ways to get it:--- **Browse it here:** open the [Files tab](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge) and read any file right on the page.-- **Clone the whole tree:** `adom-wiki repo clone adom/adom-desktop-fusion-bridge`--A **GitHub backup mirror** is kept in lockstep at [adom-inc/adom-desktop-fusion-bridge](https://github.com/adom-inc/adom-desktop-fusion-bridge) (private), but this wiki page is canonical.--> The original home in `adom-inc/adom-desktop` -> `plugins/fusion360/` is a frozen first-run fallback only: stale, not canonical.+The full source lives on this page (Files tab): `server.py`, `aps.py`, the AdomBridge add-in,+`describe.py`, handlers, skills, and manufacturer resources. GitHub mirror:+`adom-inc/adom-desktop-fusion-bridge` (the wiki is canonical). MIT licensed.  ## Platforms -Windows (full) and macOS (Fusion runs there; add-in paths handled). **Linux is unsupported** — Autodesk doesn't ship Fusion 360 for Linux, so there's no host app for the add-in to attach to.+Windows (primary, tested end to end). macOS install paths handled in `fusion_detect.py`. Linux: not+supported (Autodesk ships no Fusion host app for Linux).  ## Contributing -Clone the bundle, make changes, and email a patch (`git format-patch origin/main..HEAD --stdout`) to **`[email protected]`**, or open a PR once the GitHub mirror is public. Useful targets: newer Fusion versions, more export formats, faster cloud search.+Open a discussion on this page - bug reports with a repro (like+[#55](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/discussions/55) and+[#63](https://wiki.adom.inc/adom/adom-desktop-fusion-bridge/discussions/63), both root-caused and+fixed) directly shape releases.