wirestudio 0.45.0__tar.gz → 0.46.0__tar.gz

{wirestudio-0.45.0/wirestudio.egg-info → wirestudio-0.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wirestudio
-Version: 0.45.0
+Version: 0.46.0
 Summary: Agent-driven IoT device design tool that produces ESPHome YAML.
 Author: wirestudio contributors
 License: MIT
@@ -147,8 +147,8 @@ Tiers, in priority order:
 | **Verified** | CSP pin solver + compat checker | assign legal pins, surface boot-strap / ADC2-WiFi / voltage / locked-pin issues | unit tests + property checks in `tests/test_pin_solver.py` + `tests/test_compatibility.py` |
 | **Verified** | Fleet handoff | push YAML to `fleet-for-esphome` ha-addon, optional compile + log relay | round-trip tests in `tests/test_fleet.py` |
 | **Verified** | KiCad schematic | write a KiCad 8 `.kicad_sch` the studio draws itself (board, peripherals, subcircuits drawn as circuits from their library layouts; symbols embedded), plus a SKiDL script for the same design | every bundled example builds a KiCad netlist against the pinned upstream symbol libraries, every PR ([gate](.github/workflows/kicad-schematic.yml)) — no unresolved symbols or pins; kicad-cli reads the netlist back from every written sheet's geometry and it must match the design's, then `kicad-cli sch erc` runs on all of them against a baseline of the violation types the writer cannot avoid ([gate](.github/workflows/kicad-render.yml)). Parts KiCad ships no symbol for (sensor/module breakouts) render as labeled generic headers |
-| **Verified** | KiCad PCB layout | emit a placed, unrouted `.kicad_pcb` — footprints, nets, ratsnest, edge cuts | every bundled example emits a structurally sound board, every PR ([gate](.github/workflows/pcb-layout.yml)); a DRC tier opens each board in real KiCad ([gate](.github/workflows/pcb-drc.yml)) |
-| **Verified** | Fab outputs | JLCPCB upload bundle — BOM, CPL, Gerber + drill (`/design/fab/*`) | CPL positions match the `.kicad_pcb` placement; the DRC tier smoke-tests the Gerber export. Boards are unrouted until the Freerouting step, so Gerbers carry pads but no traces (`is_routed` flags it) |
+| **Verified** | KiCad PCB layout | emit a placed, unrouted `.kicad_pcb` — footprints, nets, ratsnest, edge cuts, and a GND pour on the bottom layer that the route step fills | every bundled example emits a structurally sound board, every PR ([gate](.github/workflows/pcb-layout.yml)); a DRC tier opens each board in real KiCad ([gate](.github/workflows/pcb-drc.yml)) |
+| **Verified** | Fab outputs | JLCPCB upload bundle — BOM, CPL, Gerber + drill (`/design/fab/*`) | CPL positions match the `.kicad_pcb` placement; the DRC tier smoke-tests the Gerber export. `?route=true` routes the board first; without it Gerbers carry pads but no tracks or pour (`is_routed` flags it). The routed gate checks a routed board's B.Cu Gerber carries the GND pour ([gate](.github/workflows/pcb-route.yml)) |
 | **Verified** | Subcircuits + building blocks | a component built from discrete parts (five bundled blocks, two H-bridges) expands into the schematic, PCB, BOM, CPL and inventory check; part values are parametric; each block's `verify.checks` rule runs at `validate` with the real params and rails | goldens for every subcircuit example pin YAML + BOM; `component_check` fails a block whose defaults break its own rule (`tests/test_electrical.py`); the schematic and PCB gates cover the expanded parts like any other |
 | **Verified** | Inventory check | cross-check a design's BOM against the drawer (library modules + discrete parts), propose same-package substitutes ranked by pinout, package, rating headroom and stock, accept one or all of them as `part_overrides` that every fab output honours, pick list by location, buy list priced on JLCPCB | matching, substitution and coverage tests in `tests/test_inventory.py` against the real drawer CSV; JLCPCB pricing is mocked and degrades to an unpriced list when the parts API is down |
 | **Verified** | Parametric enclosure | OpenSCAD `.scad` from board mount-hole metadata, built on [YAPP_Box](https://github.com/mrWheel/YAPP_Box): base and lid with standoffs, port cutouts, a ridge and snap joins | every enclosure-capable board renders through real OpenSCAD to a non-empty, manifold (closed, printable) solid, every PR ([gate](.github/workflows/enclosure-render.yml)) |
@@ -160,12 +160,13 @@ Tiers, in priority order:
 | **Works (lighter checks)** | Meshtastic flashing + config | proxy the official release factory image (`/meshtastic/firmware`) for the radio boards, flash it via the unified WebSerial dialog, then push region, modem preset, owner and primary channel as protobufs over the same port | endpoint tests with mocked upstream; board-to-variant map checked against `meshtastic/firmware` variants; config push tested against a fake device; no live-flash gate |
 | **Works (lighter checks)** | MicroPython flashing + main.py | proxy the official release image for the board's chip (`/micropython/firmware`; every library board maps to a generic port image, ESP8266 included), flash via the unified dialog, generate `main.py` from the design over the `machine` API (`/micropython/code`) and push it through the raw REPL over the same serial port | endpoint tests with a captured download page; every board's starter and every example's main.py parse as Python; the raw-REPL push is tested against a fake board; the micropython.org page format could not be fetched from the build session, so the first live flash validates it; no live-flash gate |
 | **Verified** | Component authoring | write a component YAML in the studio or through `component_create`; the same gate as `component_check` (schema, subcircuit nets, template render, KiCad symbols / pins / footprint) before it lands in the user library | a user-authored component goes through the gate and its synthetic design through upstream `esphome config`, every PR ([gate](.github/workflows/esphome-config.yml)); the gate rejects every file in a corpus of bad components for the named reason (`tests/test_component_corpus.py`); KiCad resolution runs only where the toolchain is present |
+| **Verified** | Board authoring | write a board YAML in the studio or through `board_create`; the same gate as `board_check` (schema, every bus / onboard / radio pin against `gpio_capabilities`, KiCad symbol pins and footprint, enclosure geometry, ESPHome's board table, an ESPHome render with the onboard peripherals) before it lands in the user library | every bundled board passes the gate (`tests/test_board_check.py`); a user-authored board with its onboard peripherals goes through upstream `esphome config`, every PR ([gate](.github/workflows/esphome-config.yml)); the pinout is not checked against the datasheet |
 | **Verified** | ESPHome dashboard compile | push the rendered YAML to a running ESPHome Device Builder (`/esphome/push`), start a compile there, stream the log and serve the firmware, with the same job shapes as the fleet path | nightly, against a live Device Builder (ESPHome 2026.10.0) open and password-protected: push, compile over the WebSocket API, fetch the image, with the client's wire assumptions asserted ([dashboard](.github/workflows/esphome-compile.yml)); client + route tests against a fake of the same in `tests/test_esphome_dashboard.py` |
 | **Works (lighter checks)** | CircuitPython flashing | proxy the official release image (`/circuitpython/firmware`) for ESP32/S3/C3/C6 boards, flash via the unified dialog, serve a generated starter `code.py` (`/circuitpython/code`) | endpoint tests with mocked upstream; every board-id mapping verified against downloads.circuitpython.org; generated starters parse as valid Python; no live-flash gate |
 | **Verified** | MCP server | 53 tools over the Model Context Protocol: 31 design / library / inventory / fab, plus 22 that reach hardware — workbench flash and boot verification, LoRaWAN compile / provision / activation, fleet and dashboard push + build status, and job polling for the long ones | the `mcp` package's own client connects to the mounted server over Streamable HTTP with the bearer token, lists the tools, drives a design from `create_design` to `render` and reads a resource, every PR (`tests/test_mcp_client.py`); tool / auth / resource tests in `tests/test_mcp_*.py`; the hardware tools drive the real clients against wire-level fakes, and were exercised against a live bench, ChirpStack and fleet during bring-up |
 | **Experimental** | Thingiverse search relay | rank community models for a board | smoke-tested; depends on a third-party search API that ranks unevenly |
 | **Verified** | Agent (Claude tool-using) | natural-language design driving | scored nightly against the 28-task list in `wirestudio/agent/eval_tasks.yaml`: the design it hands back passes `esphome config`, carries the asked-for change, and the turn stayed within its tool-call budget ([gate](.github/workflows/agent-eval.yml)); every task's reference solution passes the same scorer on every PR (`tests/test_agent_eval.py`). The nightly run drives the studio through Claude Code over MCP with the `CLAUDE_CODE_OAUTH_TOKEN` secret (a subscription); the embedded agent is scored too when `ANTHROPIC_API_KEY` is set. Each driver's first scored run sets its gate |
-| **Verified** | PCB autorouting | Freerouting roundtrip — board → Specctra DSN → routed → SES import; SSE route endpoint, `route_pcb` MCP/agent tool, web-UI Route button, `?route=true` fab exports, `-pcb` image variant | representative examples route with zero unconnected items and pass routed DRC ([gate](.github/workflows/pcb-route.yml)) |
+| **Verified** | PCB autorouting | Freerouting roundtrip — board → Specctra DSN → routed → SES import, GND pour filled; via cost and keepout rectangles as parameters; KiCad's DRC of the routed board reported back; SSE route endpoint, `route_pcb` MCP/agent tool, web-UI Route button, `?route=true` fab exports, `-pcb` image variant | representative examples route with zero unconnected items, a filled pour and a clean routed DRC; a high via cost must remove vias and a keepout must clear the track under it ([gate](.github/workflows/pcb-route.yml)) |
 
 The **Verified** tier is the bar the project is asking to be judged
 on. Everything else is offered with the caveat that's spelled out in

{wirestudio-0.45.0 → wirestudio-0.46.0}/README.md

@@ -113,8 +113,8 @@ Tiers, in priority order:
 | **Verified** | CSP pin solver + compat checker | assign legal pins, surface boot-strap / ADC2-WiFi / voltage / locked-pin issues | unit tests + property checks in `tests/test_pin_solver.py` + `tests/test_compatibility.py` |
 | **Verified** | Fleet handoff | push YAML to `fleet-for-esphome` ha-addon, optional compile + log relay | round-trip tests in `tests/test_fleet.py` |
 | **Verified** | KiCad schematic | write a KiCad 8 `.kicad_sch` the studio draws itself (board, peripherals, subcircuits drawn as circuits from their library layouts; symbols embedded), plus a SKiDL script for the same design | every bundled example builds a KiCad netlist against the pinned upstream symbol libraries, every PR ([gate](.github/workflows/kicad-schematic.yml)) — no unresolved symbols or pins; kicad-cli reads the netlist back from every written sheet's geometry and it must match the design's, then `kicad-cli sch erc` runs on all of them against a baseline of the violation types the writer cannot avoid ([gate](.github/workflows/kicad-render.yml)). Parts KiCad ships no symbol for (sensor/module breakouts) render as labeled generic headers |
-| **Verified** | KiCad PCB layout | emit a placed, unrouted `.kicad_pcb` — footprints, nets, ratsnest, edge cuts | every bundled example emits a structurally sound board, every PR ([gate](.github/workflows/pcb-layout.yml)); a DRC tier opens each board in real KiCad ([gate](.github/workflows/pcb-drc.yml)) |
-| **Verified** | Fab outputs | JLCPCB upload bundle — BOM, CPL, Gerber + drill (`/design/fab/*`) | CPL positions match the `.kicad_pcb` placement; the DRC tier smoke-tests the Gerber export. Boards are unrouted until the Freerouting step, so Gerbers carry pads but no traces (`is_routed` flags it) |
+| **Verified** | KiCad PCB layout | emit a placed, unrouted `.kicad_pcb` — footprints, nets, ratsnest, edge cuts, and a GND pour on the bottom layer that the route step fills | every bundled example emits a structurally sound board, every PR ([gate](.github/workflows/pcb-layout.yml)); a DRC tier opens each board in real KiCad ([gate](.github/workflows/pcb-drc.yml)) |
+| **Verified** | Fab outputs | JLCPCB upload bundle — BOM, CPL, Gerber + drill (`/design/fab/*`) | CPL positions match the `.kicad_pcb` placement; the DRC tier smoke-tests the Gerber export. `?route=true` routes the board first; without it Gerbers carry pads but no tracks or pour (`is_routed` flags it). The routed gate checks a routed board's B.Cu Gerber carries the GND pour ([gate](.github/workflows/pcb-route.yml)) |
 | **Verified** | Subcircuits + building blocks | a component built from discrete parts (five bundled blocks, two H-bridges) expands into the schematic, PCB, BOM, CPL and inventory check; part values are parametric; each block's `verify.checks` rule runs at `validate` with the real params and rails | goldens for every subcircuit example pin YAML + BOM; `component_check` fails a block whose defaults break its own rule (`tests/test_electrical.py`); the schematic and PCB gates cover the expanded parts like any other |
 | **Verified** | Inventory check | cross-check a design's BOM against the drawer (library modules + discrete parts), propose same-package substitutes ranked by pinout, package, rating headroom and stock, accept one or all of them as `part_overrides` that every fab output honours, pick list by location, buy list priced on JLCPCB | matching, substitution and coverage tests in `tests/test_inventory.py` against the real drawer CSV; JLCPCB pricing is mocked and degrades to an unpriced list when the parts API is down |
 | **Verified** | Parametric enclosure | OpenSCAD `.scad` from board mount-hole metadata, built on [YAPP_Box](https://github.com/mrWheel/YAPP_Box): base and lid with standoffs, port cutouts, a ridge and snap joins | every enclosure-capable board renders through real OpenSCAD to a non-empty, manifold (closed, printable) solid, every PR ([gate](.github/workflows/enclosure-render.yml)) |
@@ -126,12 +126,13 @@ Tiers, in priority order:
 | **Works (lighter checks)** | Meshtastic flashing + config | proxy the official release factory image (`/meshtastic/firmware`) for the radio boards, flash it via the unified WebSerial dialog, then push region, modem preset, owner and primary channel as protobufs over the same port | endpoint tests with mocked upstream; board-to-variant map checked against `meshtastic/firmware` variants; config push tested against a fake device; no live-flash gate |
 | **Works (lighter checks)** | MicroPython flashing + main.py | proxy the official release image for the board's chip (`/micropython/firmware`; every library board maps to a generic port image, ESP8266 included), flash via the unified dialog, generate `main.py` from the design over the `machine` API (`/micropython/code`) and push it through the raw REPL over the same serial port | endpoint tests with a captured download page; every board's starter and every example's main.py parse as Python; the raw-REPL push is tested against a fake board; the micropython.org page format could not be fetched from the build session, so the first live flash validates it; no live-flash gate |
 | **Verified** | Component authoring | write a component YAML in the studio or through `component_create`; the same gate as `component_check` (schema, subcircuit nets, template render, KiCad symbols / pins / footprint) before it lands in the user library | a user-authored component goes through the gate and its synthetic design through upstream `esphome config`, every PR ([gate](.github/workflows/esphome-config.yml)); the gate rejects every file in a corpus of bad components for the named reason (`tests/test_component_corpus.py`); KiCad resolution runs only where the toolchain is present |
+| **Verified** | Board authoring | write a board YAML in the studio or through `board_create`; the same gate as `board_check` (schema, every bus / onboard / radio pin against `gpio_capabilities`, KiCad symbol pins and footprint, enclosure geometry, ESPHome's board table, an ESPHome render with the onboard peripherals) before it lands in the user library | every bundled board passes the gate (`tests/test_board_check.py`); a user-authored board with its onboard peripherals goes through upstream `esphome config`, every PR ([gate](.github/workflows/esphome-config.yml)); the pinout is not checked against the datasheet |
 | **Verified** | ESPHome dashboard compile | push the rendered YAML to a running ESPHome Device Builder (`/esphome/push`), start a compile there, stream the log and serve the firmware, with the same job shapes as the fleet path | nightly, against a live Device Builder (ESPHome 2026.10.0) open and password-protected: push, compile over the WebSocket API, fetch the image, with the client's wire assumptions asserted ([dashboard](.github/workflows/esphome-compile.yml)); client + route tests against a fake of the same in `tests/test_esphome_dashboard.py` |
 | **Works (lighter checks)** | CircuitPython flashing | proxy the official release image (`/circuitpython/firmware`) for ESP32/S3/C3/C6 boards, flash via the unified dialog, serve a generated starter `code.py` (`/circuitpython/code`) | endpoint tests with mocked upstream; every board-id mapping verified against downloads.circuitpython.org; generated starters parse as valid Python; no live-flash gate |
 | **Verified** | MCP server | 53 tools over the Model Context Protocol: 31 design / library / inventory / fab, plus 22 that reach hardware — workbench flash and boot verification, LoRaWAN compile / provision / activation, fleet and dashboard push + build status, and job polling for the long ones | the `mcp` package's own client connects to the mounted server over Streamable HTTP with the bearer token, lists the tools, drives a design from `create_design` to `render` and reads a resource, every PR (`tests/test_mcp_client.py`); tool / auth / resource tests in `tests/test_mcp_*.py`; the hardware tools drive the real clients against wire-level fakes, and were exercised against a live bench, ChirpStack and fleet during bring-up |
 | **Experimental** | Thingiverse search relay | rank community models for a board | smoke-tested; depends on a third-party search API that ranks unevenly |
 | **Verified** | Agent (Claude tool-using) | natural-language design driving | scored nightly against the 28-task list in `wirestudio/agent/eval_tasks.yaml`: the design it hands back passes `esphome config`, carries the asked-for change, and the turn stayed within its tool-call budget ([gate](.github/workflows/agent-eval.yml)); every task's reference solution passes the same scorer on every PR (`tests/test_agent_eval.py`). The nightly run drives the studio through Claude Code over MCP with the `CLAUDE_CODE_OAUTH_TOKEN` secret (a subscription); the embedded agent is scored too when `ANTHROPIC_API_KEY` is set. Each driver's first scored run sets its gate |
-| **Verified** | PCB autorouting | Freerouting roundtrip — board → Specctra DSN → routed → SES import; SSE route endpoint, `route_pcb` MCP/agent tool, web-UI Route button, `?route=true` fab exports, `-pcb` image variant | representative examples route with zero unconnected items and pass routed DRC ([gate](.github/workflows/pcb-route.yml)) |
+| **Verified** | PCB autorouting | Freerouting roundtrip — board → Specctra DSN → routed → SES import, GND pour filled; via cost and keepout rectangles as parameters; KiCad's DRC of the routed board reported back; SSE route endpoint, `route_pcb` MCP/agent tool, web-UI Route button, `?route=true` fab exports, `-pcb` image variant | representative examples route with zero unconnected items, a filled pour and a clean routed DRC; a high via cost must remove vias and a keepout must clear the track under it ([gate](.github/workflows/pcb-route.yml)) |
 
 The **Verified** tier is the bar the project is asking to be judged
 on. Everything else is offered with the caveat that's spelled out in

wirestudio-0.46.0/tests/test_board_check.py

@@ -0,0 +1,205 @@
+"""Checking and creating library boards at runtime."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from wirestudio.api.app import create_app
+from wirestudio.library import Library
+from wirestudio.library.board_check import check_board_yaml, create_board
+
+BUNDLED = Path(__file__).resolve().parent.parent / "wirestudio" / "library"
+DRAFT = (Path(__file__).resolve().parent / "fixtures" / "boards" / "lolin-s2-mini.yaml").read_text()
+DEVKIT = (BUNDLED / "boards" / "esp32-devkitc-v4.yaml").read_text()
+C3 = (BUNDLED / "boards" / "esp32-c3-devkitm-1.yaml").read_text()
+
+
+@pytest.fixture
+def lib(tmp_path):
+    return Library(BUNDLED, tmp_path / "user")
+
+
+@pytest.fixture
+def client(tmp_path):
+    return TestClient(create_app(library=Library(BUNDLED, tmp_path / "user")))
+
+
+def _errors(text: str, lib: Library) -> str:
+    return " | ".join(check_board_yaml(text, lib).errors)
+
+
+def test_every_bundled_board_passes(lib):
+    for path in sorted((BUNDLED / "boards").glob("*.yaml")):
+        report = check_board_yaml(path.read_text(), lib)
+        assert report.ok, (path.stem, report.errors)
+        assert report.exists == "bundled"
+
+
+def test_draft_passes_and_renders_its_onboard_parts(lib):
+    report = check_board_yaml(DRAFT, lib)
+    assert report.ok, report.errors
+    assert report.library_id == "lolin-s2-mini" and report.exists == ""
+    assert any("gpio_output, gpio_input" in v for v in report.verified)
+    assert any("34.3 x 25.4" in v for v in report.verified)
+    assert any("no kicad: block" in w for w in report.warnings)
+    assert any("datasheet" in n for n in report.not_checked)
+
+
+def test_unparseable_and_invalid_files_are_reported(lib):
+    assert "not valid YAML" in _errors("id: [", lib)
+    assert "top level must be a mapping" in _errors("- a", lib)
+    assert "platformio_board" in _errors(DRAFT.replace("platformio_board: lolin_s2_mini\n", ""), lib)
+    assert "names the file" in _errors(DRAFT.replace("id: lolin-s2-mini", "id: Lolin S2"), lib)
+
+
+def test_platform_fields_must_agree(lib):
+    assert "not an ESP32 variant" in _errors(DRAFT.replace("chip_variant: esp32s2", "chip_variant: esp32s9"), lib)
+    assert "needs mcu esp32" in _errors(DRAFT.replace("mcu: esp32\n", "mcu: esp8266\n"), lib)
+    assert "not an ESPHome platform" in _errors(DRAFT.replace("chip_variant: esp32s2", "chip_variant: stm32"), lib)
+    assert "framework" in _errors(DRAFT.replace("framework: arduino", "framework: zephyr"), lib)
+
+
+def test_every_named_pin_must_be_a_gpio(lib):
+    errors = _errors(DRAFT.replace("sda: GPIO33", "sda: GPIO34").replace("pin: GPIO15", "pin: GPIO14"), lib)
+    assert "default_buses.i2c.sda: GPIO34 is not in gpio_capabilities" in errors
+    assert "onboard_peripherals.led.pin: GPIO14 is not in gpio_capabilities" in errors
+    assert "no scl pin" in _errors(DRAFT.replace(", scl: GPIO35", ""), lib)
+    assert "unknown bus type" in _errors(DRAFT.replace("  spi: {", "  qspi: {"), lib)
+    assert "no GND rail" in _errors(DRAFT.replace('  - {name: "GND", voltage: 0.0}\n', ""), lib)
+
+
+def test_an_input_only_pin_cannot_drive_a_bus_line(lib):
+    text = DRAFT.replace("GPIO33: [gpio, pwm, i2c_sda]", "GPIO33: [gpio, input_only]")
+    assert "GPIO33 is input_only and cannot drive sda" in _errors(text, lib)
+
+
+def test_radio_pins_are_cross_checked(lib):
+    heltec = (BUNDLED / "boards" / "heltec-wifi-lora32-v2.yaml").read_text()
+    assert check_board_yaml(heltec, lib).ok
+    broken = heltec.replace("pins: {cs: GPIO18", "pins: {cs: GPIO99")
+    assert broken != heltec
+    assert "radio.pins.cs: GPIO99" in _errors(broken, lib)
+
+
+def test_enclosure_geometry_stays_on_the_pcb(lib):
+    off = DRAFT.replace("offset_mm: 8.95", "offset_mm: 20.0")
+    assert "runs off the 25.4 mm short_a edge" in _errors(off, lib)
+    edge = DRAFT.replace("edge: short_a", "edge: top")
+    assert "edge 'top'" in _errors(edge, lib)
+
+
+def test_pin_map_is_checked_against_the_symbol(lib, tmp_path, monkeypatch):
+    symdir = tmp_path / "symbols"
+    symdir.mkdir()
+    pins = " ".join(
+        f'(pin passive line (at 0 0 0) (length 2.54) (name "Pin_{n}") (number "{n}"))' for n in range(1, 31))
+    (symdir / "Connector_Generic.kicad_sym").write_text(
+        '(kicad_symbol_lib (version 20231120) (generator kicad_symbol_editor)'
+        f' (symbol "Conn_02x15_Odd_Even" {pins}))')
+    monkeypatch.setenv("KICAD8_SYMBOL_DIR", str(symdir))
+    report = check_board_yaml(C3, lib)
+    assert report.ok, report.errors
+    assert any("has every pin_map pin" in v for v in report.verified)
+
+    assert "has no pin '31'" in _errors(C3.replace('GPIO1: "19"', 'GPIO1: "31"'), lib)
+    assert "GPIO1 and GPIO0 share pin 17, which would short them" in _errors(C3.replace('GPIO1: "19"', 'GPIO1: "17"'), lib)
+    assert "no symbol 'Conn_02x20'" in _errors(C3.replace("Conn_02x15_Odd_Even", "Conn_02x20"), lib)
+    assert "symbol library 'RF_Module' not found" in _errors(DEVKIT, lib)
+
+
+def test_create_saves_into_the_user_library_only(lib, tmp_path):
+    report = create_board(DRAFT, lib)
+    assert report.ok and report.saved.endswith("user/boards/lolin-s2-mini.yaml")
+    assert Path(report.saved).read_text() == DRAFT
+    assert lib.board_source("lolin-s2-mini") == "user"
+    assert lib.board("lolin-s2-mini").chip_variant == "esp32s2"
+    assert "lolin-s2-mini" in [b.id for b in lib.list_boards()]
+
+    again = create_board(DRAFT, lib)
+    assert not again.ok and any("already exists" in e for e in again.errors)
+    assert create_board(DRAFT, lib, overwrite=True).ok
+
+    bundled = create_board(DEVKIT, lib)
+    assert not bundled.ok and any("bundled board" in e for e in bundled.errors)
+    assert not (tmp_path / "user" / "boards" / "esp32-devkitc-v4.yaml").exists()
+
+    with pytest.raises(PermissionError):
+        lib.delete_board("esp32-devkitc-v4")
+    lib.delete_board("lolin-s2-mini")
+    assert lib.board_source("lolin-s2-mini") == ""
+    with pytest.raises(FileNotFoundError):
+        lib.board("lolin-s2-mini")
+
+    assert not create_board(DRAFT, Library(BUNDLED)).ok  # no user dir configured
+
+
+def test_a_bundled_board_wins_over_a_user_file(lib, tmp_path):
+    (tmp_path / "user" / "boards").mkdir(parents=True)
+    (tmp_path / "user" / "boards" / "esp32-devkitc-v4.yaml").write_text(DRAFT.replace("lolin-s2-mini", "esp32-devkitc-v4"))
+    assert lib.board_source("esp32-devkitc-v4") == "bundled"
+    assert lib.board("esp32-devkitc-v4").chip_variant == "esp32"
+    assert [b.id for b in lib.list_boards()].count("esp32-devkitc-v4") == 1
+
+
+def test_user_board_flows_into_a_design(lib):
+    from wirestudio.generate.yaml_gen import render_yaml
+    from wirestudio.model import Design
+
+    assert create_board(DRAFT, lib).ok
+    design = Design.model_validate({
+        "schema_version": "0.1", "id": "t", "name": "t",
+        "board": {"library_id": "lolin-s2-mini", "mcu": "esp32"},
+        "power": {"supply": "usb-5v", "rail_voltage_v": 5.0, "budget_ma": 500},
+        "components": [{"id": "led", "library_id": "gpio_output", "label": "LED"}],
+        "buses": [], "requirements": [], "warnings": [],
+        "connections": [
+            {"component_id": "led", "pin_role": "OUT", "target": {"kind": "gpio", "pin": "GPIO15"}},
+        ],
+    })
+    rendered = render_yaml(design, lib)
+    assert "board: lolin_s2_mini" in rendered and "variant: ESP32S2" in rendered
+    assert "pin: GPIO15" in rendered
+
+
+def test_api_round_trip(client):
+    check = client.post("/library/boards/check", json={"yaml": DRAFT})
+    assert check.status_code == 200 and check.json()["ok"]
+
+    created = client.post("/library/boards", json={"yaml": DRAFT})
+    assert created.status_code == 201 and created.json()["saved"]
+    listed = {b["id"]: b for b in client.get("/library/boards").json()}
+    assert listed["lolin-s2-mini"]["source"] == "user"
+    assert listed["esp32-devkitc-v4"]["source"] == "bundled"
+    assert client.get("/library/boards/lolin-s2-mini").json()["chip_variant"] == "esp32s2"
+    assert client.get("/library/boards/lolin-s2-mini/yaml").text == DRAFT
+
+    assert client.post("/library/boards", json={"yaml": DRAFT}).status_code == 409
+    assert client.post("/library/boards", json={"yaml": DEVKIT}).status_code == 409
+    bad = client.post("/library/boards", json={"yaml": DRAFT.replace("pin: GPIO15", "pin: GPIO14")})
+    assert bad.status_code == 422 and not bad.json()["ok"]
+
+    assert client.delete("/library/boards/esp32-devkitc-v4").status_code == 409
+    assert client.delete("/library/boards/lolin-s2-mini").status_code == 200
+    assert client.delete("/library/boards/lolin-s2-mini").status_code == 404
+    assert "lolin-s2-mini" not in {b["id"] for b in client.get("/library/boards").json()}
+
+
+def test_agent_tools(lib):
+    from wirestudio.agent.tools import _run_board_check, _run_board_create, _run_board_delete, _run_list_boards
+
+    assert _run_board_check({}, lib, yaml=DRAFT)["ok"]
+    assert _run_board_create({}, lib, yaml=DRAFT)["saved"]
+    sources = {b["library_id"]: b["source"] for b in _run_list_boards({}, lib)["boards"]}
+    assert sources["lolin-s2-mini"] == "user"
+    assert _run_board_delete({}, lib, library_id="lolin-s2-mini")["ok"]
+    assert not _run_board_delete({}, lib, library_id="esp32-devkitc-v4")["ok"]
+
+
+def test_platformio_board_is_looked_up_in_esphome(lib):
+    pytest.importorskip("esphome")
+    assert any("lolin_s2_mini is an ESPHome esp32 board" in v for v in check_board_yaml(DRAFT, lib).verified)
+    unknown = check_board_yaml(DRAFT.replace("lolin_s2_mini", "no_such_board"), lib)
+    assert unknown.ok and any("not in ESPHome's esp32 board list" in w for w in unknown.warnings)
+    assert "is an esp32c3 board in ESPHome, not esp32s2" in _errors(DRAFT.replace("lolin_s2_mini", "esp32-c3-devkitm-1"), lib)

{wirestudio-0.45.0 → wirestudio-0.46.0}/tests/test_community.py

@@ -43,9 +43,10 @@ def studio(monkeypatch, user_library):
             raise RuntimeError(f"404 {url}")
         return files[url]
 
-    def publish(*entries, designs=None, components=None):
+    def publish(*entries, designs=None, components=None, library=None):
         files[f"{RAW}/index/index.json"] = json.dumps(
-            {"version": 1, "generated": "2026-10-23T00:00:00+00:00", "designs": list(entries)}).encode()
+            {"version": 1, "generated": "2026-10-23T00:00:00+00:00", "designs": list(entries),
+             **(library or {})}).encode()
         for slug, doc in (designs or {}).items():
             files[f"{RAW}/main/designs/{slug}/design.json"] = json.dumps(doc).encode()
         for url, text in (components or {}).items():
@@ -246,3 +247,141 @@ def test_share_packs_the_user_components_the_design_uses(studio, user_library):
     assert z.read(f"{slug}/components/led_driver_npn.yaml").decode() == LED_DRIVER
     assert not [n for n in z.namelist() if "/components/" in n and "led_driver_npn" not in n], \
         "bundled components are not packed"
+
+
+S2_MINI = (Path(__file__).resolve().parent / "fixtures" / "boards" / "lolin-s2-mini.yaml").read_text()
+LIB_LED_URL = f"{RAW}/main/library/components/led_driver_npn/component.yaml"
+LIB_S2_URL = f"{RAW}/main/library/boards/lolin-s2-mini/board.yaml"
+
+
+def _publish_library(publish, **over):
+    publish(library={
+        "components": [{"id": "led_driver_npn", "name": "NPN LED driver", "author": "octocat",
+                        "license": "MIT", "url": LIB_LED_URL, **over}],
+        "boards": [{"id": "lolin-s2-mini", "name": "LOLIN S2 Mini", "author": "octocat",
+                    "license": "MIT", "url": LIB_S2_URL}],
+    }, components={LIB_LED_URL: LED_DRIVER, LIB_S2_URL: S2_MINI})
+
+
+def test_library_lists_entries_and_what_is_here(studio, user_library):
+    app, publish, _ = studio
+    _publish_library(publish)
+    user_library.save_component("led_driver_npn", LED_DRIVER)
+    body = app.get("/community/library").json()
+    assert [(e["id"], e["installed"]) for e in body["components"]] == [("led_driver_npn", "user")]
+    assert [(e["id"], e["installed"]) for e in body["boards"]] == [("lolin-s2-mini", "")]
+
+
+def test_an_index_without_library_entries_lists_none(studio):
+    app, publish, _ = studio
+    publish(_entry("porch-motion"))
+    body = app.get("/community/library").json()
+    assert body["components"] == [] and body["boards"] == []
+
+
+def test_install_runs_the_gate_and_is_idempotent(studio, user_library):
+    app, publish, _ = studio
+    _publish_library(publish)
+    r = app.post("/community/library/boards/lolin-s2-mini/install")
+    assert r.status_code == 200 and r.json()["installed"] is True
+    assert user_library.board_source("lolin-s2-mini") == "user"
+    assert app.post("/community/library/boards/lolin-s2-mini/install").json()["installed"] is False
+    r = app.post("/community/library/components/led_driver_npn/install")
+    assert r.status_code == 200 and user_library.component_source("led_driver_npn") == "user"
+
+
+def test_install_refuses_conflicts_and_foreign_urls(studio, user_library):
+    app, publish, _ = studio
+    _publish_library(publish)
+    user_library.save_component("led_driver_npn", LED_DRIVER.replace("NPN low-side LED driver", "mine", 1))
+    r = app.post("/community/library/components/led_driver_npn/install")
+    assert r.status_code == 409 and "different component" in r.json()["detail"]
+    assert "mine" in user_library.component_yaml("led_driver_npn")
+    assert app.post("/community/library/components/nope/install").status_code == 404
+    assert app.post("/community/library/modules/x/install").status_code == 404
+
+
+def test_install_only_follows_urls_inside_the_catalogue(studio, user_library):
+    app, publish, fetched = studio
+    _publish_library(publish, url="https://evil.example/led.yaml")
+    r = app.post("/community/library/components/led_driver_npn/install")
+    assert r.status_code == 502 and "points outside" in r.json()["detail"]
+    assert "https://evil.example/led.yaml" not in fetched
+
+
+def test_install_refuses_an_entry_whose_file_names_another_id(studio, user_library):
+    app, publish, _ = studio
+    publish(library={"boards": [{"id": "lolin-s2", "url": LIB_S2_URL}]}, components={LIB_S2_URL: S2_MINI})
+    r = app.post("/community/library/boards/lolin-s2/install")
+    assert r.status_code == 502 and "declares id 'lolin-s2-mini'" in r.json()["detail"]
+    assert user_library.board_source("lolin-s2-mini") == ""
+
+
+def test_install_of_a_broken_entry_is_reported_not_saved(studio, user_library):
+    app, publish, _ = studio
+    broken = S2_MINI.replace("pin: GPIO15", "pin: GPIO14")
+    publish(library={"boards": [{"id": "lolin-s2-mini", "url": LIB_S2_URL}]}, components={LIB_S2_URL: broken})
+    r = app.post("/community/library/boards/lolin-s2-mini/install")
+    assert r.status_code == 502 and "GPIO14 is not in gpio_capabilities" in r.json()["detail"]
+    assert user_library.board_source("lolin-s2-mini") == ""
+
+
+def _share_library(app, **over):
+    body = {"kind": "boards", "id": "lolin-s2-mini", "author": "@octocat", "tags": ["esp32s2"],
+            "source": "https://www.wemos.cc/en/latest/s2/s2_mini.html", **over}
+    return app.post("/community/library/share", json=body)
+
+
+def test_share_library_packs_the_entry_folder(studio, user_library):
+    app, _, _ = studio
+    user_library.save_board("lolin-s2-mini", S2_MINI)
+    r = _share_library(app, notes="Pinout from the WEMOS docs.")
+    assert r.status_code == 200, r.text
+    z = zipfile.ZipFile(io.BytesIO(r.content))
+    assert sorted(z.namelist()) == ["lolin-s2-mini/README.md", "lolin-s2-mini/board.yaml", "lolin-s2-mini/meta.yaml"]
+    assert z.read("lolin-s2-mini/board.yaml").decode() == S2_MINI
+    assert yaml.safe_load(z.read("lolin-s2-mini/meta.yaml")) == {
+        "author": "octocat", "tags": ["esp32s2"], "source": "https://www.wemos.cc/en/latest/s2/s2_mini.html"}
+
+    user_library.save_component("led_driver_npn", LED_DRIVER)
+    r = _share_library(app, kind="components", id="led_driver_npn", source="")
+    assert sorted(zipfile.ZipFile(io.BytesIO(r.content)).namelist()) == [
+        "led_driver_npn/component.yaml", "led_driver_npn/meta.yaml"]
+
+
+def test_share_library_refuses_what_is_not_yours_or_not_clean(studio, user_library):
+    app, _, _ = studio
+    assert _share_library(app, id="esp32-devkitc-v4").status_code == 422
+    user_library.save_board("lolin-s2-mini", S2_MINI)
+    assert "GitHub handle" in _share_library(app, author="not a handle").json()["detail"]
+    assert "https://" in _share_library(app, source="ftp://x").json()["detail"]
+    assert _share_library(app, kind="widgets").status_code == 404
+    user_library.save_board("lolin-s2-mini", S2_MINI.replace("pin: GPIO15", "pin: GPIO14"))
+    assert "no longer passes its gate" in _share_library(app).json()["detail"]
+
+
+def _s2_design() -> dict:
+    return {**EXAMPLE, "id": "s2-blink",
+            "board": {"library_id": "lolin-s2-mini", "mcu": "esp32"},
+            "components": [{"id": "led", "library_id": "gpio_output", "label": "LED", "params": {}}],
+            "buses": [],
+            "connections": [{"component_id": "led", "pin_role": "OUT", "target": {"kind": "gpio", "pin": "GPIO15"}}]}
+
+
+def test_design_share_and_import_carry_a_user_board(studio, user_library):
+    app, publish, _ = studio
+    user_library.save_board("lolin-s2-mini", S2_MINI)
+    r = _share(app, design=_s2_design())
+    assert r.status_code == 200, r.text
+    z = zipfile.ZipFile(io.BytesIO(r.content))
+    assert z.read("s2-blink/boards/lolin-s2-mini.yaml").decode() == S2_MINI
+
+    user_library.delete_board("lolin-s2-mini")
+    url = f"{RAW}/main/designs/s2-blink/boards/lolin-s2-mini.yaml"
+    publish(_entry("s2-blink", user_boards=[{"id": "lolin-s2-mini", "url": url}]),
+            designs={"s2-blink": _s2_design()}, components={url: S2_MINI})
+    r = app.post("/community/designs/s2-blink/import")
+    assert r.status_code == 200, r.text
+    assert r.json()["installed_boards"] == ["lolin-s2-mini"]
+    assert user_library.board_source("lolin-s2-mini") == "user"
+

{wirestudio-0.45.0 → wirestudio-0.46.0}/tests/test_firmware_gen.py

@@ -7,6 +7,7 @@ import pytest
 from wirestudio.library import default_library
 from wirestudio.migrate import migrate
 from wirestudio.model import Design
+from wirestudio.targets.lorawan.codec import decode_js, fields_for
 from wirestudio.targets.lorawan.firmware_gen import generate_firmware, write_firmware
 
 
@@ -230,14 +231,11 @@ def test_ci_component_designs_carry_every_lorawan_block(lib):
     assert built | board_built == {c.id for c in lib.list_components() if c.lorawan is not None}
     for design in designs:
         main = generate_firmware(design, lib)["src/main.cpp"]
-        for comp in design.components:
-            for field in lib.component(comp.library_id).lorawan.fields:
-                assert field.cpp_expr in main
+        for field in fields_for(design, lib):
+            assert field["cpp_expr"] in main
 
 
 def test_i2c_sensor_blocks_bring_up_wire_and_report_scaled_fields(lib):
-    from wirestudio.targets.lorawan.codec import fields_for
-
     design = _design_with("bme280", "sht4x")
     names = [f["name"] for f in fields_for(design, lib)]
     assert {"bme280_temp_c", "bme280_humidity", "bme280_pressure", "sht4x_temp_c"} <= set(names)
@@ -245,3 +243,73 @@ def test_i2c_sensor_blocks_bring_up_wire_and_report_scaled_fields(lib):
     assert "Wire.begin(" in main
     assert "bme280Ok = bme280.begin(0x76, &Wire);" in main
     assert "(int16_t)(bme280TempC * 100.0)" in main
+
+
+def _wired(components, buses, connections) -> Design:
+    return Design.model_validate({
+        "schema_version": "1.0", "id": "dev1", "name": "Dev 1", "target": "lorawan", "lorawan": {},
+        "board": {"library_id": "ttgo-lora32-v2", "mcu": "esp32"},
+        "power": {"supply": "usb", "rail_voltage_v": 3.3},
+        "components": [{"id": i, "library_id": c, "label": i, "params": p} for i, c, p in components],
+        "buses": buses,
+        "connections": [{"component_id": c, "pin_role": r, "target": t} for c, r, t in connections],
+    })
+
+
+def _uart(bus_id, rx, tx, baud=9600):
+    return {"id": bus_id, "type": "uart", "rx": rx, "tx": tx, "baud_rate": baud}
+
+
+def _on(bus_id):
+    return {"kind": "bus", "bus_id": bus_id}
+
+
+def test_each_uart_bus_gets_its_own_hardware_uart(lib):
+    parts = [("co2", "mhz19", {}), ("pm", "pmsx003", {})]
+    buses = [_uart("u1", "GPIO16", "GPIO17"), _uart("u2", "GPIO32", "GPIO33")]
+    conns = [("co2", "TX", _on("u1")), ("co2", "RX", _on("u1")), ("pm", "TX", _on("u2")), ("pm", "RX", _on("u2"))]
+    main = generate_firmware(_wired(parts, buses, conns), lib)["src/main.cpp"]
+    assert "HardwareSerial co2Serial(1);" in main and "HardwareSerial pmSerial(2);" in main
+    assert "co2Serial.begin(9600, SERIAL_8N1, 16, 17);" in main
+    third = _wired(parts + [("radar", "ld2410", {})], buses + [_uart("u3", "GPIO4", "GPIO25", 256000)],
+                   conns + [("radar", "TX", _on("u3")), ("radar", "RX", _on("u3"))])
+    with pytest.raises(ValueError, match="hardware UART"):
+        generate_firmware(third, lib)
+
+
+def test_a_uart_bus_keeps_its_parity(lib):
+    design = _wired([("plug", "cse7766", {})], [{**_uart("u1", "GPIO16", "GPIO17", 4800), "parity": "EVEN"}],
+                    [("plug", "TX", _on("u1"))])
+    assert "plugSerial.begin(4800, SERIAL_8E1, 16, 17);" in generate_firmware(design, lib)["src/main.cpp"]
+
+
+def test_spi_parts_share_the_radio_bus(lib):
+    spi = lib.board("ttgo-lora32-v2").default_buses["spi"]
+    conns = [("tc", "CLK", _on("s")), ("tc", "MISO", _on("s")), ("tc", "CS", {"kind": "gpio", "pin": "GPIO25"})]
+    main = generate_firmware(_wired([("tc", "max31855", {})], [{"id": "s", "type": "spi", **spi}], conns),
+                             lib)["src/main.cpp"]
+    assert "#include <SPI.h>" in main and "SPI.begin(5, 19, 27);" in main
+    elsewhere = {"id": "s", "type": "spi", "clk": "GPIO14", "miso": "GPIO12", "mosi": "GPIO13"}
+    with pytest.raises(ValueError, match="radio's bus"):
+        generate_firmware(_wired([("tc", "max31855", {})], [elsewhere], conns), lib)
+
+
+def test_parts_on_a_hub_read_through_it_and_name_their_fields(lib):
+    spi = lib.board("ttgo-lora32-v2").default_buses["spi"]
+    parts = [("adc", "mcp3008", {}), ("ch0", "mcp3008_channel", {"number": 0}),
+             ("ch5", "mcp3008_channel", {"number": 5, "reference_voltage": "5.0V"}),
+             ("bus", "modbus", {}), ("mains", "pzemac", {"address": 2})]
+    conns = [("adc", r, _on("s")) for r in ("CLK", "MOSI", "MISO")] + [
+        ("adc", "CS", {"kind": "gpio", "pin": "GPIO2"}),
+        ("ch0", "HUB", {"kind": "component", "component_id": "adc"}),
+        ("ch5", "HUB", {"kind": "component", "component_id": "adc"}),
+        ("bus", "UART", _on("u1")), ("bus", "FLOW", {"kind": "gpio", "pin": "GPIO4"}),
+        ("mains", "HUB", {"kind": "component", "component_id": "bus"})]
+    design = _wired(parts, [{"id": "s", "type": "spi", **spi}, _uart("u1", "GPIO16", "GPIO17")], conns)
+    main = generate_firmware(design, lib)["src/main.cpp"]
+    assert "ch5Mv = (uint16_t)(adcRead(5) * 5.0 * 1000.0 / 1023.0 + 0.5);" in main
+    assert "busRead(2, 0x04, 0, 10, _d)" in main
+    assert "digitalWrite(4, HIGH);  // RS485 driver on" in main
+    names = [f["name"] for f in fields_for(design, lib)]
+    assert {"ch0_voltage", "ch5_voltage", "mains_voltage", "mains_energy"} <= set(names)
+    assert "ch5_voltage" in decode_js(fields_for(design, lib))

{wirestudio-0.45.0 → wirestudio-0.46.0}/tests/test_kicad.py

@@ -318,3 +318,9 @@ def test_subcircuit_refs_do_not_disturb_other_prefixes(lib):
     assert refs[part_key("bridge", "q_hi_a")] == "Q1"
     assert refs[part_key("bridge", "r_gate_a")] == "R1"
     assert refs["feedback"] == "U1"
+
+
+def test_expander_pads_join_the_expander_pin_net(lib):
+    script = generate_skidl(_design("keypad"), lib)
+    assert 'Net("kpd_hub_GP0")' in script
+    assert 'c_kpd_hub["P0"] += Net.fetch("kpd_hub_GP0")' in script

{wirestudio-0.45.0 → wirestudio-0.46.0}/tests/test_kicad_erc.py

@@ -21,9 +21,9 @@ REPORT = {
         "violations": [
             {"type": "pin_not_driven", "severity": "error", "description": "Input Power pin not driven by any Output Power pins",
              "items": [{"description": "Symbol U1 Pin 3 [VCC, Power input]"}], "excluded": False},
-            {"type": "lib_symbol_issues", "severity": "warning", "description": "Pin not connected",
+            {"type": "global_label_dangling", "severity": "warning", "description": "Pin not connected",
              "items": [{"description": "Symbol J2 Pin 4"}], "excluded": False},
-            {"type": "lib_symbol_issues", "severity": "warning", "description": "Pin not connected",
+            {"type": "global_label_dangling", "severity": "warning", "description": "Pin not connected",
              "items": [{"description": "Symbol J2 Pin 5"}], "excluded": True},
             {"type": "endpoint_off_grid", "severity": "error", "description": "Pins of type Output and Output are connected",
              "items": [{"description": "Symbol U1 Pin 7"}, {"description": "Symbol U2 Pin 2"}], "excluded": False},
@@ -51,7 +51,7 @@ def _writer_ok(monkeypatch):
 def test_summarize_flattens_counts_and_drops_exclusions():
     out = summarize(REPORT)
     assert out["kicad_version"] == "8.0.9"
-    assert out["counts"] == {"lib_symbol_issues": 1, "endpoint_off_grid": 1, "pin_not_driven": 1}
+    assert out["counts"] == {"global_label_dangling": 1, "endpoint_off_grid": 1, "pin_not_driven": 1}
     assert out["errors"] == 2 and out["warnings"] == 1
     assert out["violations"][0]["items"] == ["Symbol U1 Pin 3 [VCC, Power input]"]
     assert summarize({}) == {"kicad_version": None, "violations": [], "counts": {}, "errors": 0, "warnings": 0}
@@ -103,11 +103,11 @@ def _load_script():
 def test_gate_judges_against_the_baseline():
     mod = _load_script()
     allowed = mod.load_baseline()
-    assert {"pin_not_driven", "lib_symbol_issues"} <= set(allowed)
+    assert {"pin_not_driven", "global_label_dangling"} <= set(allowed)
     results = {"garage-motion": summarize(REPORT)}
     failures, stale = mod.judge(results, allowed, check_stale=True)
     assert failures == ["garage-motion: [error] endpoint_off_grid: Pins of type Output and Output are connected (Symbol U1 Pin 7)"]
-    assert stale == sorted(set(allowed) - {"pin_not_driven", "lib_symbol_issues"})
+    assert stale == sorted(set(allowed) - {"pin_not_driven", "global_label_dangling"})
     only_power = {"x": summarize({"sheets": [{"path": "/", "violations": [REPORT["sheets"][0]["violations"][0]]}]})}
     failures, stale = mod.judge(only_power, allowed, check_stale=True)
     assert failures == [] and stale == sorted(set(allowed) - {"pin_not_driven"})
@@ -119,3 +119,27 @@ def test_gate_checks_every_example_by_default():
     paths = mod.example_paths([])
     assert len(paths) == len(list(mod.EXAMPLES_DIR.glob("*.json"))) > 50
     assert mod.example_paths(["garage-motion"]) == [mod.EXAMPLES_DIR / "garage-motion.json"]
+
+
+def test_run_erc_checks_the_sheet_inside_a_project(monkeypatch, garage_motion_design, library, tmp_path):
+    """kicad-cli reports every embedded symbol's library as not configured
+    unless the sheet sits in a project whose sym-lib-table names it."""
+    from wirestudio.kicad import erc as E
+
+    (tmp_path / "Sensor.kicad_sym").write_text("(kicad_symbol_lib)")
+    monkeypatch.setattr(E, "default_symbol_dirs", lambda: [tmp_path])
+    monkeypatch.setattr(R.shutil, "which", lambda exe: "/usr/bin/" + exe)
+    _writer_ok(monkeypatch)
+    monkeypatch.setattr(R, "generate_kicad_sch", lambda d, lib: '(kicad_sch (symbol (lib_id "Sensor:BME280")) (symbol (lib_id "power:GND")))')
+    seen = {}
+
+    def run(cmd, **kw):
+        sch = Path(cmd[-1])
+        seen["table"] = (sch.parent / "sym-lib-table").read_text()
+        seen["pro"] = sch.with_suffix(".kicad_pro").is_file()
+        return _fake_run(cmd, **kw)
+    monkeypatch.setattr(subprocess, "run", run)
+    run_erc(garage_motion_design, library)
+    assert seen["pro"]
+    assert f'(name "Sensor")(type "KiCad")(uri "{tmp_path / "Sensor.kicad_sym"}")' in seen["table"]
+    assert '"power"' not in seen["table"]  # no such library here, so no row