Adom Library

@@ -1,102 +1,29 @@ # adom-lbr -**One part → every major EDA tool. A library generator, linter, and converter that takes KiCad sources and delivers to KiCad, Fusion 360, Altium and OrCAD — standalone Rust, no local EAGLE.**+**adom-lbr generator / EDA translator. One canonical part format → every major EDA tool — with native Altium output and no local EDA software.** -> **What it is:** adom-lbr is a **pure exporter/converter** — symbol(s) + footprint(s) + 3D symbol(s) in (as flags), ECAD library files out. **It never drives an app**; the orchestrating AI does that and uses adom-lbr's output. Full scope in the [skill](SKILL.md).+The **adom-lbr JSON** is Adom's own canonical part: one document carrying the symbol, footprint, 3D reference, and the pin↔pad map. adom-lbr is the translator around it — import a part from KiCad, then convert the adom-lbr JSON to **native Altium** (`.SchLib` / `.PcbLib` / `.IntLib`), an **EAGLE/Fusion** `.lbr`, or back to **KiCad**. The Altium libraries are written **natively** — the exact OLE2/CFBF binary — so no copy of Altium is needed at conversion time. Standalone Rust, no Node, no gallia. -adom-lbr turns a KiCad `.kicad_sym` (and optional `.kicad_mod`) into a true EAGLE `.lbr` with a complete deviceset — symbol + package + pin→pad connects. Because EAGLE libraries are the universal interchange format, that one `.lbr` imports cleanly into **Fusion 360 Electronics, Altium, and OrCAD**; and for KiCad it round-trips back to a native `.kicad_sym`. It can also synthesize a placeable symbol from a footprint's pads when there's no schematic symbol, and verify a library through `service-kicad`. Standalone Rust, no Node, no gallia.+("lbr" = **Adom Library**, the adom-lbr JSON — not EAGLE's `.lbr`, which is just one of the output formats.)  ## Formats & targets  | Direction | Format | Used by | |---|---|---|-| **Generate** | EAGLE `.lbr` (symbol + package + connects) | the source of truth adom-lbr builds |-| **Deliver → Fusion 360** | `.lbr` imported directly | Autodesk Fusion 360 Electronics |-| **Deliver → Altium** | `.lbr` import | Altium Designer |-| **Deliver → OrCAD** | `.lbr` import | Cadence OrCAD / Allegro |-| **Deliver → KiCad** | converted to native `.kicad_sym` | KiCad 6+ |-| **Import (reverse)** | EAGLE `.lbr` → `.kicad_sym` | bring EAGLE parts into KiCad |+| **Hub** | **adom-lbr JSON** (symbol + footprint + graphics + pin↔pad map) | the canonical format everything converts to/from |+| **Import → hub** | KiCad `.kicad_sym` + `.kicad_mod` → adom-lbr JSON | bring a KiCad part in |+| **Import → hub** | **Altium `.SchLib` / `.PcbLib` / `.IntLib` → adom-lbr JSON** | bring an Altium part in — pins, pads, and silk/courtyard/fab **layers** |+| **Export → Altium** | native `.SchLib` + `.PcbLib`, or one bundled `.IntLib` | Altium Designer — written natively, no Altium needed |+| **Export → Fusion/EAGLE** | EAGLE `.lbr` (symbol + package + connects) | Autodesk Fusion 360 Electronics, EAGLE, OrCAD |+| **Export → KiCad** | native `.kicad_sym` | KiCad 6+ *(planned)* |+| **Merge** | add a part's symbol into an existing `.SchLib` | install a part into a user's Altium library | -The **Send to** bar in the live app pushes the loaded library to whichever of those tools you're running (via the Adom Desktop bridge); the Altium/OrCAD bridges are an open contribution slot.+Altium footprint graphics keep their **layers** across the round trip — silk /+courtyard / fab decode into neutral roles and re-encode onto the right Altium+layers (outline → Mechanical 13 "Assembly Top", courtyard → Mechanical 15+"Courtyard Top"). Verified byte-exact (`Altium → JSON → Altium → JSON`). -## `export` — one part → all four tools in one command (new in 1.5)--```bash-adom-lbr export --sym part.kicad_sym --fp part.kicad_mod --model part.step --out part-library-```--One command, a **folder per EDA tool**, every folder built from the *same* source-so the symbol, the real footprint, and the chip outline match across all four:--```-part-library/-├── kicad/   part.kicad_sym  +  part.pretty/part.kicad_mod      ← native KiCad-├── fusion/  part.lbr        [+ part.fusion3d.json]             ← EAGLE + 3D handoff-├── orcad/   part.edn                                           ← EDIF 2.0.0 (via adom-orcad → native .olb)-├── altium/  part.SchLib + part.PcbLib (native, no Altium!)     ← + .lbr & bridge-manifest fallbacks-└── EXPORT.md                                                   ← per-tool import steps-```--It stays a **pure exporter**: KiCad and Fusion are written directly, OrCAD is-produced by shelling the `adom-orcad` EDIF converter (a CLI, not an app), and the-Altium *native* `.SchLib/.PcbLib` step is left to the **Altium bridge** with a-staged hand-off — adom-lbr never drives an app. Use `--targets kicad,fusion` to-emit a subset. `generate`/`bind-3d` remain for single-format work.--**BOM attributes:** pass `--mfr --mpn --mouser --digikey --lcsc` (chip-fetcher-looks these up) and they're written into the library's device technology as-`MF`/`MPN`/`MOUSER`/`DIGIKEY`/`LCSC`, which Fusion surfaces as Manufacturer / MPN-/ supplier fields in the BOM. Omit any and adom-lbr writes the library but prints-a `⛔ INCOMPLETE BOM` reprimand telling the caller to re-run with them.--**RefDes/Value text** (`>NAME`/`>VALUE`) is **carried through from the-`.kicad_mod`** (whatever adom-footprint placed and you tweaked), not invented-here; the linter's `name-value-overlap` check warns when that text lands on the-pads so you can fix it upstream.--**Native Altium, no Altium (new in 1.8):** the Altium target now writes real-binary **`.SchLib` + `.PcbLib`** directly in pure Rust — OLE2/CFB containers whose-streams and pin/pad records are byte-structurally conformant to what Altium itself-produces (reverse-engineered from manufacturer libraries). No Altium install, no-bridge needed to *create* them. ⚠️ Experimental: not yet round-tripped through a-real Altium loader, so the `.lbr` Import-Wizard path and the bridge manifest ship-alongside as fallbacks.--## Real footprints & 3D models (new in 1.1)--![ADS8588SIPM LQFP-64 — the package built from the real .kicad_mod: 16 pads per side, true 4-sided ring](docs/screenshot-footprint-4sided.png)--Pass **`--fp part.kicad_mod`** and the package is built from the **real footprint-geometry** — every pad at its true position, size, and rotation. An LQFP-64 comes-out as a proper 4-sided ring (16/16/16/16), a BGA as a grid, with the silkscreen-outline derived from the footprint body. (Earlier versions emitted a two-column-placeholder; that now survives only as the fallback when `--fp` is omitted.)--```bash-adom-lbr generate --sym part.kicad_sym --fp part.kicad_mod -o part.lbr-```--**3D bodies for Fusion** are a Fusion-side attach: a model only renders once Fusion-brings it into a session, so `--model part.step` keeps the `.lbr` 2D and emits a-`part.fusion3d.json` manifest pointing at the model + package. The **Fusion bridge**-does the attach (`Create3DPackage → import → orient → FINISH → Save`), which both-binds and renders. Optionally, if the model is already cloud-synced, `bind-3d`-pre-writes the binding into the `.lbr` (self-uploaded models use a `wip_urn`-`urn:adsk.wipprod:fs.file:vf…?version=1`, not `urn:adsk.eagle:package` — that's-managed-only):--```bash-adom-lbr generate --sym part.kicad_sym --fp part.kicad_mod --model part.step -o part.lbr-adom-lbr bind-3d --lbr part.lbr --wip-urn "urn:adsk.wipprod:fs.file:vf.<id>?version=1" --sidecar part.fusion3d.json-```--→ **Full walkthrough: [docs/fusion-export.md](docs/fusion-export.md)** — pad-mapping,-the verified 3D markup, the bridge attach vs. the `bind-3d` fast-path, and Altium/OrCAD notes.--📘 **Sub-skill: [skills/fusion-export](skills/fusion-export/SKILL.md)** — a focused-field guide to the four Fusion-export traps (placeholder footprint, the bridge-attach, `wip_urn` vs `eagle`, `dm.lineage`). It ships *inside* this package, so it-installs with adom-lbr and surfaces on its own when you're exporting to Fusion.+The **Send to** bar in the live app pushes the loaded library to whichever of those tools you're running (via the Adom Desktop bridge).  ## The 3-column library viewer — and an interactive embed @@ -136,13 +63,9 @@ This is the whole point. Fusion will silently show "No Components" or refuse to  ## What it does -- **`export`** — one part → a **complete bundle**, one folder per tool: native KiCad (`.kicad_sym` + `.pretty/.kicad_mod`), Fusion (`.lbr` + 3D sidecar), OrCAD (EDIF `.edn` via adom-orcad), Altium (`.lbr` + sources + bridge hand-off), with an `EXPORT.md` index. `--targets` for a subset.-- **`generate`** — `.kicad_sym` (+ real `.kicad_mod` via `--fp`) → native `.lbr`, lint-checked for Fusion compatibility. `--model` also emits a 3D handoff sidecar.-- **`bind-3d`** — pre-write a 3D binding (self-hosted `wip_urn`, or managed `urn`) into a `.lbr` so the body travels with the library; idempotent. The normal path is the Fusion bridge attach.+- **`generate`** — `.kicad_sym` (+ `.kicad_mod`) → native `.lbr`, lint-checked for Fusion compatibility. - **`lint` / `validate`** — catch the things Fusion rejects: missing connects, incomplete devicesets, bad pad maps. - **`import`** — EAGLE `.lbr` → KiCad `.kicad_sym`.-- **`generate --symbol-art <outline.svg>`** — draws adom-symbol's vector chip outline onto the schematic symbol as raw lines (layer 94), sized to the body like adom-symbol does (`--symbol-art-scale` to tune). One `.lbr` → the outline shows in Fusion / Altium / OrCAD.-- **`embed`** — a self-contained 3-column (symbol / footprint / 3D) viewer as one `.html`. - **Live app** — a viewer that lints the loaded `.lbr` and shows symbols / packages / devicesets / pins / pads at a glance.  ## Send to@@ -165,32 +88,8 @@ Used by **chip-fetcher** and the Send-to flow across **adom-symbol** and **adom- ## Run it  ```bash-adom-lbr export --sym part.kicad_sym --fp part.kicad_mod --model part.step --out part-library  # all 4 tools, one folder each adom-lbr generate --sym part.kicad_sym --fp part.kicad_mod --name PART --output part.lbr-adom-lbr generate --sym part.kicad_sym --fp part.kicad_mod --model part.step -o part.lbr  # + 3D sidecar-adom-lbr bind-3d --lbr part.lbr --wip-urn "urn:adsk.wipprod:fs.file:vf.<id>?version=1" --sidecar part.fusion3d.json-adom-lbr generate --sym part.kicad_sym --fp part.kicad_mod --symbol-art part-3d-outline.svg -o part.lbr  # draw the chip on the symbol-adom-lbr import part.lbr -o part.kicad_sym   # reverse: EAGLE → KiCad adom-lbr serve --port 8784          # live linter app (AI-drivable) adom-lbr embed --dir <chip-dir>     # Fusion-style 3-column viewer as one .html ``` MIT, contributions welcome.--## Contributing & forking — open source under the Adom org--**adom-lbr** is **open source** under the **adom** org on the [Adom Wiki](https://wiki.adom.inc/adom/adom-lbr). The full source lives in this page's repo — open the **Files** tab, or `adompkg install adom/adom-lbr` and edit the package. Third-party developers are welcome to modify it and contribute back.--**Modify it**-- Get the source from the Files tab (or `adompkg install adom/adom-lbr`), make your changes, and rebuild.--**Contribute back to Adom — two paths**-1. **Pull request (preferred).** The wiki runs a PR-per-page flow: propose your change on this page and the maintainer reviews + merges it — no fork needed.-2. **Fork + breadcrumb.** Prefer your own fork or add-on? Publish it as your own wiki page, then drop a **breadcrumb on _this_ page** pointing at your fork so it's discoverable:-   - Read existing trails: `GET https://wiki.adom.inc/api/v1/pages/adom-lbr/breadcrumbs`-   - Attach a breadcrumb from your fork's page targeting this anchor (a short label + your slug).--   The breadcrumb leaves a **linked path back here**, so **Adom's AI can auto-discover your fork** and surface it to users — the trail is followable both ways. Your fork stays yours; the original stays discoverable.--## License--**MIT** — © 2026 Adom Industries Inc. Open source; see [LICENSE](LICENSE). Modify, fork, and redistribute freely.

@@ -1,281 +1,147 @@ --- name: adom-lbr description: >-  Turn a KiCad part (.kicad_sym + .kicad_mod) into one EAGLE .lbr that Fusion-  360, Altium, and OrCAD all import — with REAL footprint geometry (not a-  placeholder) — plus a round-trip back to KiCad .kicad_sym, a 3D-model handoff-  for Fusion's cloud library, and a 7-check Fusion linter. Trigger words: lbr,-  eagle library, fusion library, altium library, orcad library, kicad convert,-  generate lbr, import lbr, lint lbr, fusion 360 footprint, lbr footprint wrong,-  placeholder footprint, 3d model in lbr, bind 3d, fusion cloud urn, package3d,-  export library, export all tools, kicad fusion altium orcad, orcad edif, olb,-  schlib, pcblib, multi-tool library, library bundle.+  adom-lbr generator / EDA translator. The canonical adom-lbr JSON (symbol ++  footprint + pin↔pad map) is the hub; convert it to NATIVE Altium+  (.SchLib/.PcbLib/.IntLib — real OLE2 binary, no Altium needed), EAGLE/Fusion+  .lbr, or KiCad .kicad_sym. Import KiCad parts into the hub; merge a symbol into+  an existing .SchLib. Trigger words: adom-lbr, altium schlib pcblib intlib,+  convert to altium, kicad to altium, eda translator, lbr, eagle library, fusion+  library, adom-lbr json, kicad convert. ---  # adom-lbr -Generate a single EAGLE `.lbr` from a KiCad part for Fusion 360, Altium, or-OrCAD — or convert back to KiCad `.kicad_sym`. The `.lbr` is the EAGLE-family-interchange format the first three tools all read; KiCad gets a native symbol-via `import`.+adom-lbr generator / EDA translator. The **adom-lbr JSON** — Adom's own canonical part format (symbol + footprint + 3D + pin↔pad map) — is the hub; every EDA format is a converter around it. -## What adom-lbr is (and isn't)+- **Import** a KiCad `.kicad_sym` + `.kicad_mod` into the adom-lbr JSON.+- **Export** the adom-lbr JSON to **native Altium** `.SchLib` / `.PcbLib` / `.IntLib` (real OLE2/CFBF binary, no Altium at conversion time), an **EAGLE/Fusion** `.lbr`, or a **KiCad** `.kicad_sym`.+- **Merge** a part's symbol into an existing `.SchLib` (install into a user's Altium library). -adom-lbr is a **pure exporter/converter** — it generates ECAD library files and-**nothing else**. It never drives Fusion, KiCad, Altium, or any app.+("lbr" here = Adom Library / the adom-lbr JSON, not EAGLE's `.lbr` — that's just one output.) -- **In:** the part — symbol(s), footprint(s), 3D symbol(s) — as command-line-  flags (`--sym`, `--fp`, `--model`, `--symbol-art`).-- **Out:** library files for the target ECAD tool —-  - KiCad → native `.kicad_sym`-  - Fusion 360 / Altium / OrCAD → one EAGLE `.lbr` (all three read it)-  - …plus future export formats as they're added.+## Native Altium commands (both directions) -**The orchestrating AI does all the driving**, then uses adom-lbr's output.-adom-lbr's job ends when the file is written.+```bash+# INTO the hub+adom-lbr import-kicad  --sym part.kicad_sym --fp part.kicad_mod --mpn MPN   # KiCad  → MPN.adom-lbr.json+adom-lbr import-altium part.SchLib --pcblib part.PcbLib --mpn MPN           # Altium → MPN.adom-lbr.json+adom-lbr import-altium part.IntLib --mpn MPN                                # or one bundled .IntLib -### Where it runs (architecture)+# OUT of the hub → native Altium (real OLE2/CFBF, no Altium needed)+adom-lbr export-altium  part.adom-lbr.json --out-dir .                      # → MPN.SchLib + MPN.PcbLib+adom-lbr export-intlib  part.adom-lbr.json                                  # → MPN.IntLib (bundled)+adom-lbr add-to-schlib  existing.SchLib part.adom-lbr.json --out lib.SchLib # merge a symbol into a library+``` -- adom-lbr runs in **this cloud container** (installed with-  `adom-wiki pkg install adom/adom-lbr`). That's the only place it lives.-- The **Windows laptop** runs Fusion + adom-desktop. The **"Fusion bridge" is a-  plugin inside adom-desktop** (installed via `adom-desktop bridge_install`) that-  exposes `fusion_*` verbs. The AI drives Fusion from the container with-  `adom-desktop fusion_<action>`; the laptop never runs adom-lbr or adom-wiki.-- Flow: adom-lbr generates the file **here** → `adom-desktop send_files` ships it-  to the laptop → the AI imports/drives it in Fusion via the bridge verbs.+**What carries across (both ways):** symbol pins + body graphics; footprint pads;+**footprint silk / courtyard / fab graphics with their layers**; the pin↔pad map;+the footprint link. Value/Manufacturer/MPN/Package become Altium component+property fields (Value drawn on the symbol; the rest hidden), and are read back+out on import. -### Consequences for 3D + symbol art+### Footprint layer mapping (Altium) -- A 3D body **can't be baked into the file** (Fusion references it by an Autodesk-  cloud URN it mints itself). adom-lbr emits the 2D `.lbr` **plus** a-  `fusion3d.json` sidecar describing what to attach; the **AI/bridge** runs the-  Fusion-side attach (Create3DPackage → FINISH). adom-lbr doesn't attach anything.-- `--symbol-art` just **draws adom-symbol's vector outline into the exported file**.+Graphics carry a neutral layer role (`silk` / `courtyard` / `fab`), mapped on+export to the house convention (from the C0402 reference footprint): -### Fidelity rule+| Role | Altium layer | Named |+|---|---|---|+| fab + silk (outline) | Mechanical 13 | Assembly Top |+| courtyard | Mechanical 15 | Courtyard Top |+| pads | Top Layer | — | -Carry the inputs through faithfully on **every** export endpoint: the real-footprint geometry, and — when adom-symbol provides a 3D outline — that outline,-matched as closely as adom-symbol renders it. See [docs/ROADMAP.md](docs/ROADMAP.md).+Altium stores a track/arc layer in TWO places — the layer byte **and** a tail+class-pair `[41]/[43]` (Track) — and it *renders* from the tail pair, so the+encoder patches both. Decode reads the layers back into the neutral roles.+3D STEP models attach to the footprint via Altium's model factory (bridge), not+the native writer (the model checksum is a custom Altium algorithm). -## When to use+## EAGLE / Fusion path -- "Export this part to **every** tool" / "give me KiCad + Fusion + OrCAD + Altium"-  → `export` (one bundle, one folder per tool, with an `EXPORT.md` index)-- "Make a Fusion / Altium / OrCAD library from this KiCad part"-- "Convert this `.kicad_sym` to `.lbr`" / "import this `.lbr` to KiCad"-- "The generated footprint is a 2-column placeholder / doesn't match the chip"-  → regenerate **with `--fp`** so the real `.kicad_mod` geometry is used-- "Attach a 3D model to this Fusion library" → `--model` + `bind-3d`-- "Why does Fusion say No Components?" → `lint`+Fusion 360 Electronics shows "No Components" when an .lbr has an empty `<packages>` or `<connects/>`. adom-lbr's `generate` builds a COMPLETE deviceset: symbol + package + full pin-to-pad connects. KiCad users can round-trip any `.lbr` back to `.kicad_sym` with `adom-lbr import`.  ## Commands  ```-adom-lbr export   --sym <part.kicad_sym> [--fp <part.kicad_mod>] [--model <part.step>] [--symbol-art <svg>] [--out <dir>] [--targets kicad,fusion,orcad,altium] [--mfr <name>] [--mpn <pn>] [--mouser <pn>] [--digikey <pn>] [--lcsc <pn>]-adom-lbr generate --sym <part.kicad_sym> [--fp <part.kicad_mod>] [--model <part.step>] [-o out.lbr] [--name <override>] [--mfr <name>] [--mpn <pn>] [--mouser <pn>] [--digikey <pn>] [--lcsc <pn>]-adom-lbr bind-3d  (--lbr <part.lbr> | --record-only) (--wip-urn <…fs.file:vf…?version=N> | --urn <…eagle:package…>) [--lineage-urn <…dm.lineage…>] [--package <name>] [--sidecar <part.fusion3d.json>] [-o out.lbr]-adom-lbr import   <part.lbr> [-o out.kicad_sym]-adom-lbr lint     <part.lbr>          # JSON error codes-adom-lbr validate <part.lbr>          # human-readable-adom-lbr check    <part.kicad_sym>    # local Rust validation-adom-lbr serve [--port 8784] [--file <lbr>]-adom-lbr health | install | completions <bash|zsh|fish>+adom-lbr generate --sym <path.kicad_sym> [-o output.lbr] [--fp <path.kicad_mod>] [--name <override>]+adom-lbr import <path.lbr> [-o output.kicad_sym]+adom-lbr lint <path.lbr>+adom-lbr validate <path.lbr>+adom-lbr check <path.kicad_sym>+adom-lbr health+adom-lbr install+adom-lbr completions <bash|zsh|fish> ``` -## export — all four tools in one shot+## generate -`export` is the one-command front door: from a single KiCad part it writes a-**folder per EDA tool**, each populated from the *same* source so the symbol,-the real footprint, and the chip outline are identical across them:+Parses a KiCad .kicad_sym file and produces a valid EAGLE .lbr with:+- Symbol (body rectangle + pins with correct direction/rotation/length)+- Package (placeholder SMD pads for each pin number, courtyard outline)+- Deviceset with gate, device, and complete `<connect>` mappings -```-<name>-library/-├── kicad/   <name>.kicad_sym  +  <name>.pretty/<name>.kicad_mod   (native)-├── fusion/  <name>.lbr  [+ <name>.fusion3d.json]                  (EAGLE + 3D handoff)-├── orcad/   <name>.edn                                            (EDIF 2.0.0, via adom-orcad)-├── altium/  <name>.lbr + KiCad sources + ALTIUM-README.md         (direct import + bridge hand-off)-└── EXPORT.md                                                      (per-tool import steps)-```--- **KiCad** — native `.kicad_sym` (carried through 1:1 when you pass `--sym`,-  else synthesized) + the `.kicad_mod` in a `.pretty` footprint library.-- **Fusion 360** — the `.lbr`; with `--model`, also the `fusion3d.json` handoff-  (the bridge attaches the body — adom-lbr never drives Fusion).-- **OrCAD** — shells the **adom-orcad** converter to emit EDIF 2.0.0 (`.edn`),-  which Capture imports to a native `.olb`. If adom-orcad isn't installed it-  writes an `ORCAD-README.md` with the exact command instead of failing.-- **Altium** — **native binary `<part>.SchLib` + `<part>.PcbLib`, written in pure-  Rust with NO Altium** (the default). BOM part numbers (incl. `LCSC Part #`)-  land as native component parameters. ⚠️ EXPERIMENTAL: byte-structurally-  conformant to real Altium output (streams + pin/pad records match manufacturer-  libraries) but not yet round-tripped through a real Altium install. Fallbacks-  also emitted: the `.lbr` (Import Wizard) and **`<part>.altium.json`** (manifest-  for the **Altium bridge** — `adom/adom-desktop-altium-bridge` / `altium-part-importer`;-  `--altium-lib`/`--altium-mode` set its target).--`--targets` limits the set (e.g. `--targets kicad,fusion`). This is still a pure-exporter: it writes files and hands off; the orchestrating AI does any-app-driving. `generate`/`bind-3d` remain for single-format work.--## BOM / supply-chain attributes — the caller MUST pass them--Fusion (and Altium/OrCAD) read **device attributes** for the BOM. adom-lbr writes-them into the `.lbr`'s `<technology>`:--| Flag | EAGLE/Fusion attribute | Fusion field |-|---|---|---|-| `--mfr`     | `MF`      | Manufacturer |-| `--mpn`     | `MPN`     | Manufacturer Part Number |-| `--mouser`  | `MOUSER`  | supplier attribute |-| `--digikey` | `DIGIKEY` | supplier attribute |-| `--lcsc`    | `LCSC`    | supplier attribute |--**Contract: chip-fetcher looks all of these up, so the caller passes them in.**-`generate`/`export` resolve each value in priority order — explicit flag → a-matching `.kicad_sym` property (`Manufacturer`/`MPN`/`Mouser`/`Digi-Key`/`LCSC`,-common aliases accepted) → auto-fill (`MF` from a sibling-`<mpn>-symbol.extracted.json`, `MPN` from the part name). **When any are still-missing, adom-lbr writes the library anyway but prints a loud `⛔ INCOMPLETE BOM`-reprimand** listing exactly which flags to pass. So if you call adom-lbr without-the part numbers, expect to be told to re-run with them.--## >NAME / >VALUE placement — carried through, not owned--The footprint's RefDes (`>NAME`) and value (`>VALUE`) text are **carried through-from the `.kicad_mod`'s own `(fp_text reference …)` / `(fp_text value …)`** —-**position** (Y-negated for EAGLE), **height** (from `(font (size W H))`), and-**rotation** (`(at X Y A)` → EAGLE `rot="R<A>"`). So whatever **adom-footprint**-places (and the user tweaks in that app) is exactly what lands in the `.lbr`.-adom-lbr does **not** own this — it only auto-places (clear of the pads) as a-fallback when the `.kicad_mod` carries no such text.--It also **lints** the result: `name-value-overlap` warns when the text sits in the-keep-out. The keep-out is the pad span by default, but if a sibling-`<mpn>-footprint.extracted.json` carries a `textPlacement.courtyard`-(`{top,bottom,left,right}`, KiCad mm), adom-lbr uses that explicit courtyard-instead — so it validates against the generator's intended zone, not a re-guess.--Per-tool reality: KiCad (native) and Fusion/EAGLE (`.lbr`) carry the placement-fully. **Altium** native libraries are produced by the **Altium bridge** on the-laptop (`adom/adom-desktop-altium-bridge`, which drives a real Altium via-DelphiScript) or `altium-part-importer` (CREATE from `.IntLib`); via the EAGLE-`.lbr` Import Wizard path the designator may be re-placed at Altium's default, so-the bridge is the faithful route. (Reverse, Altium→KiCad, is `adom/adom-sfconvert`-+ the native `adom-altium-schlib`/`altium-pcblib` parsers.) **OrCAD** is the real-gap — adom-orcad's EDIF is schematic-symbol only, so footprint RefDes placement-isn't carried. One generic placement in the `.kicad_mod` is the right input for-all of them — never a per-tool switch.--## generate — the core--Parses the `.kicad_sym` (symbol) and, when given, the `.kicad_mod` (footprint),-and writes a complete EAGLE deviceset: symbol + package + `<connect>` mappings.--**Always pass `--fp` for anything you'll fabricate.** With `--fp`, the package is-built from the real footprint:--- one `<smd>` (or `<pad>` for thru-hole) per `.kicad_mod` pad, at its true-  position — a 4-sided LQFP stays 4-sided, BGA stays a grid, etc.-- KiCad is Y-down, EAGLE is Y-up → Y is negated; the KiCad pad angle maps-  straight to EAGLE `rot=R90/R180/R270` (Fusion's own convention — top/bottom-  QFP/SOIC pads come out `R90`).-- silkscreen outline derived from the footprint body (`F.SilkS`, else `F.Fab`,-  else pad extents).--**Without `--fp`** it falls back to a synthesized two-column placeholder package-(symbol-only parts). If a user reports a wrong/2-column footprint, the fix is-almost always: regenerate with `--fp`.--Auto-lints before writing; exits 2 if lint fails.--## Chip outline on the symbol — `--symbol-art`--If the adom-symbol input carries a **3D chip outline** (`<mpn>-3d-outline-*.svg`),-pass it with `--symbol-art` and adom-lbr draws it onto the schematic symbol as raw-`<wire>` lines (layer 94), centred and scaled to ~0.38× the body — matching-adom-symbol's own placement. Tune with `--symbol-art-scale`. The one `.lbr` carries-it into Fusion / Altium / OrCAD.--**Standing directive (owner):** whenever adom-symbol gives you a 3D outline, embed-it — as close to adom-symbol's rendering as you can — on **every** export, not just-Fusion. Today the `.lbr` covers Fusion/Altium/OrCAD; the KiCad `.kicad_sym`-conversion and future native exporters are TODO. See [docs/ROADMAP.md](docs/ROADMAP.md).--Heavy outlines bloat the library (a `-blueprint` ≈ 3000 wires / ~300 KB) — the tool-warns and suggests a lighter variant (`-bold`/`-thin`).--## The Fusion 3D attach--A 3D body only renders once Fusion brings the model into a session, so the `.lbr`-stays 2D and the **Fusion bridge does the attach** (verified by the bridge against-a round-tripped `.flbr`):--1. `generate --model part.step` emits the `.lbr` **plus** a `part.fusion3d.json`-   sidecar (schema `adom-lbr.fusion3d/2`): `model.path`, format, units, placement,-   a `binding` block, and `status: "pending-fusion-attach"`. No URN is pre-minted.-2. The bridge opens the `.lbr` (library active) → `Create3DPackage` → import-   `model.path` → orient (your `placement` overrides) → **FINISH** → Save. This-   both binds and renders; the in-Fusion library is the runtime source of truth.-3. **Record the URN** the bridge reports (`fusion_aps_file_info {query:"<pkg>"}`-   after Save → `fs.file:vf…?version=N`):-   `bind-3d --record-only --sidecar part.fusion3d.json --wip-urn <that>` writes-   `binding.wip_urn` + `status: bound` (and `--lineage-urn` for optional-   provenance) WITHOUT touching the `.lbr`.-4. **Optional fast-path** — bake the binding into the `.lbr`:-   `bind-3d --lbr part.lbr --wip-urn <…fs.file:vf…?version=N>`-   (`urn=""`, `wip_urn=…`, `locally_modified="yes"`). `--urn <…eagle:package…>`-   is managed/library.io only. NB a pre-written `wip_urn` shows a gray placeholder-   until the model is brought into a session, and `dm.lineage` is refused for the-   `.lbr` (provenance only) — so this is not a substitute for the bridge attach.--URN families: **self-hosted** model → `wip_urn` = versioned `fs.file:vf …?version=1`-(NOT the `dm.lineage` URN); **managed** part → `urn:adsk.eagle:package:NNN/V`.--See [docs/fusion-export.md](docs/fusion-export.md) for the full flow + exact markup.+Auto-lints the output before writing. Exits 2 if lint fails.  ## import -EAGLE `.lbr` → KiCad `.kicad_sym`. Maps pin direction-(pwr/in/out/io/pas/nc → power_in/input/output/bidirectional/passive/unconnected),-rotation, length, position; body rectangle from layer-94 wires; pin numbers from-`<connect>`; strips `@N` dedup suffixes.+Parses an EAGLE .lbr and converts to KiCad .kicad_sym format. Handles:+- Pin direction mapping (EAGLE pwr/in/out/io/pas/nc → KiCad power_in/input/output/bidirectional/passive/unconnected)+- Pin rotation, length, position+- Body rectangle from layer 94 wires+- Description, reference prefix+- Pin numbers from connect mappings+- Strips EAGLE @N dedup suffixes back to clean names++## lint -## lint / validate / check+Checks an existing .lbr for Fusion 360 compatibility. Outputs JSON with `passed`, `errors[]`, `warnings[]`. -- `lint` — 8 checks, JSON (`passed`, `errors[]`, `warnings[]`): `empty-packages`,-  `empty-connects`, `device-no-package`, `duplicate-pin-name`,-  `connect-pad-missing`, `malformed-xml`, `no-symbol-layer`, and-  `name-value-overlap` (>NAME/>VALUE text sitting on the pad copper).-- `validate` — same checks, human-readable; exit 0 valid / 2 errors.-- `check` — validates a `.kicad_sym` locally (structure, pins, properties,-  duplicate names). Run after `import`.+Checks:+- `empty-packages` — packages section empty (fatal: Fusion shows "No Components")+- `empty-connects` — device has no connect mappings (fatal)+- `device-no-package` — device element missing package attribute (fatal)+- `duplicate-pin-name` — EAGLE requires unique pin names; use @suffix for power/NC duplicates+- `connect-pad-missing` — connect references a pad that doesn't exist in the package+- `malformed-xml` — unbalanced angle brackets+- `no-symbol-layer` — nothing on layer 94 (symbol body invisible)++## validate++Same as lint but human-readable output. Exits 0 = valid, 2 = errors found.++## check++Validates a .kicad_sym file by local Rust validation — checks structure, pins, properties, duplicate names. Use after `import` to verify the output before sending to a desktop KiCad instance.  ## Duplicate pin handling -EAGLE requires unique pin names. KiCad repeats (e.g. 6× `IOVDD`) get `@N`-suffixes on generate (`IOVDD`, `IOVDD@2`, …); `import` strips them. Pad numbers-in `<connects>` are unaffected.+EAGLE requires unique pin names. When KiCad has multiple pins with the same name (e.g., 6 IOVDD pins), the generator appends `@N` suffixes: `IOVDD`, `IOVDD@2`, `IOVDD@3`, etc. The `import` command strips these back.  ## Workflows -### KiCad part → Fusion / Altium / OrCAD (real footprint + 3D)+### Fusion 360 user (has .kicad_sym, needs .lbr)+```+adom-lbr generate --sym RP2040.kicad_sym -o RP2040.lbr+# Send to Fusion via adom-desktop send_files + fusion_open_lbr+```++### KiCad user (has .lbr, needs .kicad_sym) ```-adom-lbr generate --sym part.kicad_sym --fp part.kicad_mod --model part.step -o part.lbr-# Fusion/Altium/OrCAD import part.lbr directly.-# Fusion 3D: bridge attaches the model (Create3DPackage → FINISH → Save). Optional pre-write:-#   adom-lbr bind-3d --lbr part.lbr --wip-urn <urn:adsk.wipprod:fs.file:vf.<id>?version=1> --sidecar part.fusion3d.json+adom-lbr import RP2040.lbr -o RP2040.kicad_sym+adom-lbr check RP2040.kicad_sym+# Send to KiCad via adom-desktop send_files + kicad_install_library ``` -### EAGLE .lbr → KiCad+### Pipeline (adom-symbol → both targets) ```-adom-lbr import part.lbr -o part.kicad_sym-adom-lbr check part.kicad_sym-# Send via adom-desktop: send_files + kicad_install_library+adom-symbol create <mpn> → .kicad_sym+adom-lbr generate --sym <mpn>.kicad_sym → .lbr (for Fusion)+# .kicad_sym already native for KiCad ``` -### Lint a suspicious .lbr+### Lint any .lbr before use ```-adom-lbr lint suspicious.lbr   # JSON error codes for programmatic handling+adom-lbr lint suspicious.lbr+# JSON output with error codes for programmatic handling ```

@@ -1,56 +1,66 @@ {   "slug": "adom-lbr",-  "version": "1.8.3",+  "version": "2.0.0",   "type": "app",-  "description": "One KiCad part → every major EDA tool. `adom-lbr export` writes a folder per tool: native KiCad, Fusion 360 (.lbr + 3D handoff), OrCAD (EDIF via adom-orcad), and native Altium (.SchLib/.PcbLib) — real-footprint accurate. Bidirectional KiCad converter + 8-check linter + a live library viewer. Includes a focused fusion-export sub-skill.",+  "description": "adom-lbr generator / EDA translator. One canonical adom-lbr JSON part \u2014 symbol + footprint + 3D + pin\u2194pad map \u2014 converts to native Altium (.SchLib/.PcbLib/.IntLib), EAGLE/Fusion (.lbr), and KiCad. Altium is written natively, no Altium needed at conversion time.",   "dependencies": {},-  "discovery_triggers": [-    "lbr bom attributes",-    "mpn manufacturer part number lbr",-    "mouser digikey lcsc lbr",-    "name value overlap footprint",-    "refdes value placement fusion",-    "export library all tools",-    "kicad fusion altium orcad",-    "multi-tool library export",-    "orcad edif",-    "kicad to eagle",-    "generate lbr",-    "eagle library",-    "fusion library",-    "fusion 360 library",-    "altium library",-    "orcad library",-    "kicad to fusion",-    "lbr from kicad",-    "import lbr to kicad",-    "lint lbr",-    "fusion no components",-    "make eagle library",-    "fusion library export",-    "lbr 3d model",-    "package3d",-    "wip_urn",-    "fusion cloud urn",-    "bind 3d",-    "lbr footprint wrong",-    "lbr placeholder footprint"-  ],-  "scripts": {-    "install": "./install.sh",-    "uninstall": "./uninstall.sh"-  },-  "needs_sudo": false,-  "hero": {-    "type": "image",-    "path": "screenshots/hero-v2.png"-  },   "tags": [     "eda",+    "altium",+    "schlib",+    "pcblib",+    "intlib",     "kicad",     "eagle",     "lbr",     "fusion360",-    "viewer"+    "converter"+  ],+  "hero": {+    "type": "billboard",+    "headline": "One part, every EDA tool.",+    "subhead": "The adom-lbr JSON is the hub \u2014 convert it to native Altium, EAGLE/Fusion, or KiCad. Altium output is written natively, no Altium at conversion time.",+    "screenshot": "screenshots/shot.png",+    "accent": "#00b8b1"+  },+  "scripts": {+    "install": "./install.sh",+    "uninstall": "./uninstall.sh"+  },+  "needs_sudo": false,+  "files": [+    "bin/**",+    "SKILL.md",+    "README.md",+    "install.sh",+    "uninstall.sh",+    "screenshots/**"+  ],+  "discovery_triggers": [+    "convert kicad to altium",+    "kicad to schlib pcblib",+    "altium to kicad",+    "make an intlib",+    "generate eagle lbr",+    "eda file converter",+    "adom-lbr json",+    "convert footprint between eda tools",+    "import altium symbol footprint",+    "footprint silk courtyard layers"+  ],+  "discovery_pitch": "One CLI to convert electronic-component symbols + footprints between Altium (written natively, no Altium needed), KiCad, and EAGLE/Fusion \u2014 through one canonical adom-lbr JSON, with silk/courtyard/fab layers preserved.",+  "sample_prompts": [+    {+      "prompt": "Convert this KiCad symbol and footprint to an Altium SchLib and PcbLib",+      "label": "KiCad \u2192 Altium"+    },+    {+      "prompt": "Import this Altium footprint into the adom-lbr JSON",+      "label": "Altium \u2192 JSON"+    },+    {+      "prompt": "Bundle this part into a single Altium IntLib",+      "label": "Make IntLib"+    }   ]-}+}\ No newline at end of file

@@ -1,16 +1,20 @@ {   "slug": "adom-lbr",-  "version": "1.8.3",+  "version": "2.0.0",   "type": "app",-  "description": "One KiCad part → every major EDA tool. `adom-lbr export` writes a folder per tool: native KiCad, Fusion 360 (.lbr + 3D handoff), OrCAD (EDIF via adom-orcad), and native Altium (.SchLib/.PcbLib) — real-footprint accurate. Bidirectional KiCad converter + 8-check linter + a live library viewer. Includes a focused fusion-export sub-skill.",+  "description": "adom-lbr generator / EDA translator. One canonical adom-lbr JSON part — symbol + footprint + 3D + pin↔pad map — converts to native Altium (.SchLib/.PcbLib/.IntLib), EAGLE/Fusion (.lbr), and KiCad. Altium is written natively, no Altium needed at conversion time.",   "dependencies": {},   "tags": [     "eda",+    "altium",+    "schlib",+    "pcblib",+    "intlib",     "kicad",     "eagle",     "lbr",     "fusion360",-    "viewer"+    "converter"   ],   "hero": {     "type": "image",@@ -31,35 +35,38 @@   "source_visibility": "public",   "license": "MIT",   "discovery_triggers": [-    "lbr bom attributes",-    "mpn manufacturer part number lbr",-    "mouser digikey lcsc lbr",-    "name value overlap footprint",-    "refdes value placement fusion",-    "export library all tools",-    "kicad fusion altium orcad",-    "multi-tool library export",-    "orcad edif",-    "kicad to eagle",-    "generate lbr",-    "eagle library",-    "fusion library",-    "fusion 360 library",-    "altium library",-    "orcad library",-    "kicad to fusion",-    "lbr from kicad",-    "import lbr to kicad",-    "lint lbr",-    "fusion no components",-    "make eagle library",-    "fusion library export",-    "lbr 3d model",-    "package3d",-    "wip_urn",-    "fusion cloud urn",-    "bind 3d",-    "lbr footprint wrong",-    "lbr placeholder footprint"+    "convert kicad to altium",+    "kicad to schlib pcblib",+    "altium to kicad",+    "make an intlib",+    "generate eagle lbr",+    "eda file converter",+    "adom-lbr json",+    "convert footprint between eda tools",+    "import altium symbol footprint",+    "footprint silk courtyard layers"+  ],+  "files": [+    "bin/**",+    "SKILL.md",+    "README.md",+    "install.sh",+    "uninstall.sh",+    "screenshots/**"+  ],+  "discovery_pitch": "One CLI to convert electronic-component symbols + footprints between Altium (written natively, no Altium needed), KiCad, and EAGLE/Fusion — through one canonical adom-lbr JSON, with silk/courtyard/fab layers preserved.",+  "sample_prompts": [+    {+      "prompt": "Convert this KiCad symbol and footprint to an Altium SchLib and PcbLib",+      "label": "KiCad → Altium"+    },+    {+      "prompt": "Import this Altium footprint into the adom-lbr JSON",+      "label": "Altium → JSON"+    },+    {+      "prompt": "Bundle this part into a single Altium IntLib",+      "label": "Make IntLib"+    }   ] }\ No newline at end of file