---
name: library-creator
description: Use when the user asks to "create a complete library component", "create symbol + footprint + 3D", "make a full KiCad library entry", "library review", "show all three views", "library creator", or wants to create and review all three artifacts (symbol, footprint, 3D model) for a component together.
---

# Library Creator

Orchestrate creating a complete library component — schematic symbol, PCB footprint, and 3D model — by calling the three existing creator skills (symbol-creator, footprint-creator, 3dcomponent-creator) in sequence, then display all three artifacts in **LibView** (the unified Library Review viewer) for cross-validation with interactive pin-pad-mesh highlighting.

## Workflow Overview

```
1. Research part  →  2. Create symbol  →  3. Create footprint  →  4. Generate 3D  →  5. Library Review  →  6. Iterate
```

## Step 1: Research the Part

Before creating anything, research the component thoroughly:

1. **Find the datasheet** — search Mouser, DigiKey, or JLCPCB using the MCP tools
2. **Extract key specs**: pin count, package type (QFN, TSSOP, BGA, etc.), body dimensions, pin pitch
3. **Build a complete pinout table**: pin number, pin name, electrical type, description
4. **Note the package name** for the footprint (e.g., "TSSOP-14", "QFN-24 4x4mm")

## Step 2: Create the Symbol

Read and follow the symbol-creator guide:

```
Read ~/.claude/skills/adom/guides/symbol-creator.md
```

Follow that guide's full workflow to produce:
- A `.kicad_sym` file
- SymView HTML (`PART_NAME-viewer.html`)
- Symbol SVG preview
- Pin metadata (names, numbers, electrical types)

**Save the SymView HTML path** — you'll need it for step 5.

## Step 3: Create the Footprint

Read and follow the footprint-creator guide:

```
Read ~/.claude/skills/adom/guides/footprint-creator.md
```

Follow that guide's full workflow to produce:
- A `.kicad_mod` file
- FpView HTML (`PART_NAME-fp-viewer.html`)
- A `-fp-metadata.json` file (pad descriptions, body size, symbol pin map)
- Footprint SVG preview

**Save the FpView HTML path and metadata** — you'll need them for steps 4 and 5.

## Step 4: Generate the 3D Model

Read and follow the 3d-component-creator guide:

```
Read ~/.claude/skills/adom/guides/3d-component-creator.md
```

Follow that guide's workflow to produce:
- A `.glb` file for preview
- A `.step` file for CAD delivery

**Save the GLB path** — you'll need it for step 5.

## Step 5: LibView — Library Review (unified 3-pane view)

After all three artifacts exist, display them together in **LibView** using the `gv_library_review` MCP tool. LibView shows all three views (SymView + FpView + 3dView) simultaneously with cross-highlighting — hovering a pin in the symbol highlights the corresponding pad in the footprint and the mesh in the 3D model, and vice versa.

### Build the maps

From the symbol and footprint metadata, construct these maps:

**`pin_pad_map`** — Maps symbol pin names to footprint pad numbers:
```json
{ "SDA": "4", "SCL": "5", "VCC": "1", "GND": "8" }
```
Build this from the footprint metadata's `symbolPinMap` (which maps pad number → pin name) by inverting it.

**`pad_mesh_map`** — Maps pad numbers to 3D mesh names. Can be left empty (`{}`) — the 3D viewer auto-generates synthetic `_lr_pad_N` mesh names from `footprint_pads` when no explicit map is provided. If you need to map to specific GLB mesh names (e.g., `part_0`, `part_1`), provide them:
```json
{ "1": "part_0", "2": "part_1", "3": "part_2" }
```

**`footprint_pads`** — Pad positions from the `.kicad_mod` for 3D pad overlay and cross-highlighting. Read from the baked `const pads = [...]` in the FpView HTML or parse from the `.kicad_mod` directly:
```json
[
  { "number": "1", "x": -0.75, "y": -0.5, "width": 0.6, "height": 0.3 },
  { "number": "2", "x": -0.75, "y": 0.0, "width": 0.6, "height": 0.3 }
]
```

### Call the MCP tool

LibView uses the existing **SymView** and **FpView** HTML files (pre-generated by the symbol-creator and footprint-creator services). All pin descriptions, pad descriptions, and metadata are already baked into those viewer files — you do NOT pass them again here.

```
gv_library_review({
  sym_view_path: "/path/to/PART_NAME-viewer.html",
  fp_view_path: "/path/to/PART_NAME-fp-viewer.html",
  glb_path: "/path/to/PART_NAME.glb",
  pin_pad_map: { "SDA": "4", "SCL": "5", ... },
  pad_mesh_map: { "1": "part_0", "2": "part_1", ... },
  footprint_pads: [{ number: "1", x: -0.75, y: -0.5, w: 0.6, h: 0.3 }, ...],
  title: "PART_NAME Library Review"
})
```

The `sym_view_path` points to the SymView HTML from the symbol folder (e.g. `symbols/NE555/NE555-viewer.html`). The `fp_view_path` points to the FpView HTML from the footprint folder (e.g. `footprints/NE555/NE555-fp-viewer.html`).

### What to check in LibView

Tell the user to hover over pins/pads to verify:

- **Every pin** in the symbol has a corresponding pad in the footprint (no unmapped pins)
- **Every pad** in the footprint has a corresponding mesh in the 3D model
- **Pin names** in the symbol match the signal names on footprint pads
- **3D model pads** are in the same positions as the footprint pads
- **Electrical types** are correct (power, I/O, passive, etc.)

**3D pane interaction**: When hovering over pad discs in the 3D pane, the cursor changes to a hand pointer and the pad turns teal. A floating callout shows "Pad N — PinName". Cross-highlighting updates the symbol and footprint panes simultaneously.

**3D toolbar toggles**: When a real GLB model is loaded, the 3D toolbar provides toggle buttons for:
- **FR4 board** — show/hide the green PCB substrate
- **Board pads** — show/hide KiCad's native pads from the GLB
- **Footprint pads** — show/hide the custom copper-colored overlay pads used for cross-highlighting (visible by default, can be toggled off for a clean model view)
- **Axes** — show/hide XYZ origin axes

### GLB serving

The viewer server serves GLB files from `/tmp/gv-3d/` via the `/glb/` route. Copy the GLB there before referencing it:
```bash
cp /path/to/PART.glb /tmp/gv-3d/PART.glb
```
Then use `glb_path` pointing to the original file — the MCP tool copies it to the serve dir automatically.

### Debug commands

Use the server API to send debug commands to the 3D pane:
```bash
# Show XYZ origin axes (red=X, green=Y, blue=Z)
curl -X POST http://127.0.0.1:8771/api/action -H 'Content-Type: application/json' \
  -d '{"action":"show_origin","visible":true}'

# Set camera to a named view (front, back, left, right, top, bottom, isometric)
curl -X POST http://127.0.0.1:8771/api/action -H 'Content-Type: application/json' \
  -d '{"action":"set_view","view":"front"}'

# Toggle footprint pad overlays in 3D
curl -X POST http://127.0.0.1:8771/api/action -H 'Content-Type: application/json' \
  -d '{"action":"toggle_fp_pads"}'
```

## Step 6: Iterate

If the user spots issues in LibView:

1. Identify which artifact has the problem (symbol, footprint, or 3D)
2. Go back to the relevant creator skill to fix it
3. Re-generate the GLB if the footprint changed
4. Call `gv_library_review` again with the updated paths

## Troubleshooting

### "No pad mapping" shown in tooltip
The `pin_pad_map` is missing an entry for that pin. Check that all symbol pins have corresponding entries.

### Footprint pads don't align with 3D pads
The `footprint_pads` array positions may be wrong. Re-read the `.kicad_mod` file and extract the pad `(at x y)` and `(size w h)` values.

### 3D mesh names don't match
After generating the GLB, the mesh names depend on the order KiCad processes them. If highlighting doesn't work, you may need to inspect the GLB mesh names by loading it in 3dView first and checking what mesh names are reported on hover.

### Footprint SVG hit zones are offset
The coordinate mapping uses the courtyard center as an anchor. If the footprint has no courtyard layer (`F.CrtYd`), the offset calculation falls back to the SVG center, which may be less accurate.