wirestudio 0.45.0__tar.gz → 0.47.0__tar.gz

{wirestudio-0.45.0 → wirestudio-0.47.0}/LICENSES.md

@@ -33,15 +33,16 @@ them when the user (or a CI gate) builds. None is vendored.
 | the LoRaWAN target (`templates/platformio.ini.j2`) | [RadioLib](https://github.com/jgromes/RadioLib) | MIT |
 | the LoRaWAN target | [LoRaWAN_ESP32](https://github.com/ropg/LoRaWAN_ESP32) | MIT |
 | `lorawan:` blocks on `axp192`, `dht`, `ssd1306`, `uart_gps` | [XPowersLib](https://github.com/lewisxhe/XPowersLib) (MIT), [Adafruit DHT sensor library](https://github.com/adafruit/DHT-sensor-library) (MIT), [Adafruit SSD1306](https://github.com/adafruit/Adafruit_SSD1306) (BSD-3-Clause), [TinyGPSPlus](https://github.com/mikalhart/TinyGPSPlus) (LGPL-2.1-or-later) | as listed |
-| `wled:` usermod blocks on `bme280`, `bmp280`, `sht3xd`, `ds18b20`, `dht` | [BME280](https://github.com/finitespace/BME280) (GPL-3.0), [SHT85](https://github.com/RobTillaart/SHT85) (MIT), [OneWire](https://github.com/PaulStoffregen/OneWire) (MIT-style notice in the source), [DHT_nonblocking](https://github.com/alwynallan/DHT_nonblocking) (GPL-3.0) | as listed |
+| `wled:` usermod blocks on `bme280`, `bmp280`, `sht3xd`, `ds18b20`, `dht`, `vl53l0x`, `i2s_microphone`, `ld2410`, `ssd1306`, `st7789`, `mpu6050`, `bme680` | [BME280](https://github.com/finitespace/BME280) (GPL-3.0), [SHT85](https://github.com/RobTillaart/SHT85) (MIT), [OneWire](https://github.com/PaulStoffregen/OneWire) (MIT-style notice in the source), [DHT_nonblocking](https://github.com/alwynallan/DHT_nonblocking) (GPL-3.0), [VL53L0X](https://github.com/pololu/vl53l0x-arduino) (MIT), [arduinoFFT](https://github.com/kosme/arduinoFFT) (GPL-3.0), [ld2410](https://github.com/ncmreynolds/ld2410) (LGPL-2.1), [U8g2](https://github.com/olikraus/u8g2) (BSD-2-Clause), [TFT_eSPI](https://github.com/Bodmer/TFT_eSPI) (FreeBSD and MIT, per its licence file), [MPU6050](https://github.com/ElectronicCats/mpu6050) (MIT), [Bolder Flight Systems Eigen](https://github.com/bolderflight/eigen) (MIT, wrapping Eigen under MPL-2.0), [BSEC Software Library](https://github.com/boschsensortec/BSEC-Arduino-library) (Bosch's own licence: binary only, for use with Bosch sensors) | as listed |
 | `circuitpython:` blocks, copied into `CIRCUITPY/lib` | the `adafruit_*` and `neopixel` libraries of the [Adafruit CircuitPython Bundle](https://github.com/adafruit/Adafruit_CircuitPython_Bundle) | MIT |
 | `micropython:` blocks, installed by `mip` | [micropython-lib](https://github.com/micropython/micropython-lib) `ssd1306`, `logging`, `lora-sx127x` and `lora-sync` (MIT); [BME280](https://github.com/robert-hh/BME280), [BME680-Micropython](https://github.com/robert-hh/BME680-Micropython), [micropython_ahtx0](https://github.com/targetblank/micropython_ahtx0), [micropython-bmp280](https://github.com/dafvid/micropython-bmp280), [pyb_ina219](https://github.com/chrisb2/pyb_ina219), [micropython-mcp23008](https://github.com/mcauser/micropython-mcp23008), [micropython-mcp23017](https://github.com/mcauser/micropython-mcp23017), [micropython-mpu9x50](https://github.com/micropython-IMU/micropython-mpu9x50), [micropython-adafruit-pca9685](https://github.com/adafruit/micropython-adafruit-pca9685), [MicroPython_SCD4X](https://github.com/peter-l5/MicroPython_SCD4X), [micropython-sht31](https://github.com/kfricke/micropython-sht31), [MicroPython_SHT4X](https://github.com/jposada202020/MicroPython_SHT4X), [micropython-adafruit-tsl2561](https://github.com/adafruit/micropython-adafruit-tsl2561), [veml7700](https://github.com/palouf34/veml7700), [micropython-max7219](https://github.com/mcauser/micropython-max7219), [micropython-ili9341](https://github.com/rdagger/micropython-ili9341), [st7789py_mpy](https://github.com/russhughes/st7789py_mpy), [ads1x15](https://github.com/robert-hh/ads1x15), [hx711](https://github.com/robert-hh/hx711), [micropython_ir](https://github.com/peterhinch/micropython_ir), [upy-rtttl](https://github.com/dhylands/upy-rtttl) (MIT, some by the notice in the source); [vl53l0x](https://github.com/kevinmcaleer/vl53l0x) (BSD-3-Clause) | as listed |
 | the ESPHome generator, for the external-component LoRaWAN path | [lorawan-for-esphome](https://github.com/moellere/lorawan-for-esphome), pinned by commit | MIT |
 | the `cc1101` component's notes | the `radiolib_cc1101` ESPHome fork, which the user adds as an `external_components` entry; the generator does not emit it | per that fork |
 
 A firmware the user builds from these is the user's: its licence
-follows from the libraries it links, and a WLED build with the BME280 or
-DHT usermod links GPL-3.0 code.
+follows from the libraries it links, and a WLED build with the BME280,
+DHT or audioreactive usermod links GPL-3.0 code; one with the BME680
+links Bosch's binary BSEC library under its own terms.
 
 ## Compiled into the web bundle
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wirestudio
-Version: 0.45.0
+Version: 0.47.0
 Summary: Agent-driven IoT device design tool that produces ESPHome YAML.
 Author: wirestudio contributors
 License: MIT
@@ -125,7 +125,7 @@ Detailed docs live in [`docs/`](docs/):
 
 ## Status
 
-`v0.40.0` — on PyPI (`pip install wirestudio`). The studio has wide
+`v0.46.0` — on PyPI (`pip install wirestudio`). The studio has wide
 surface area (YAML, schematic, PCB + fab outputs, enclosure,
 subcircuits with electrical rules, inventory matching, component
 authoring, agent, MCP server, two ESPHome build paths, remote
@@ -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** | 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. Both gates are 25 of 28 (`gate.min_pass`, `gate.claude_code_min_pass`), one below the lower of two runs on one commit |
+| **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.47.0}/README.md

@@ -91,7 +91,7 @@ Detailed docs live in [`docs/`](docs/):
 
 ## Status
 
-`v0.40.0` — on PyPI (`pip install wirestudio`). The studio has wide
+`v0.46.0` — on PyPI (`pip install wirestudio`). The studio has wide
 surface area (YAML, schematic, PCB + fab outputs, enclosure,
 subcircuits with electrical rules, inventory matching, component
 authoring, agent, MCP server, two ESPHome build paths, remote
@@ -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** | 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. Both gates are 25 of 28 (`gate.min_pass`, `gate.claude_code_min_pass`), one below the lower of two runs on one commit |
+| **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.47.0}/pyproject.toml

@@ -72,6 +72,7 @@ include = ["wirestudio*"]
 # tries to read components/ + boards/.
 "wirestudio.library" = ["components/*.yaml", "boards/*.yaml", "modules/*.yaml"]
 "wirestudio.agent" = ["*.yaml"]
+"wirestudio.generate" = ["esphome_integrations.txt"]
 "wirestudio.schema" = ["*.json"]
 "wirestudio.examples" = ["*.json"]
 "wirestudio.targets.lorawan" = ["templates/*.j2"]

{wirestudio-0.45.0 → wirestudio-0.47.0}/tests/test_agent.py

@@ -75,6 +75,33 @@ def test_set_board_drops_a_flash_size_measured_on_the_old_board(lib, garage_moti
     assert "flash_size_mb" not in garage_motion_design["board"]
 
 
+def test_set_board_takes_a_revision_and_drops_it_with_the_board(lib, garage_motion_design):
+    out, is_error = execute_tool(
+        "set_board", {"library_id": "heltec-wifi-lora32-v4", "revision": "4.3"}, garage_motion_design, lib,
+    )
+    assert is_error is False
+    assert json.loads(out)["board"]["revision"] == "4.3"
+    assert garage_motion_design["board"]["revision"] == "4.3"
+    execute_tool("set_board", {"library_id": "wemos-d1-mini"}, garage_motion_design, lib)
+    assert "revision" not in garage_motion_design["board"]
+
+
+def test_set_board_unlisted_revision_returns_error(lib, garage_motion_design):
+    out, is_error = execute_tool(
+        "set_board", {"library_id": "heltec-wifi-lora32-v4", "revision": "4.9"}, garage_motion_design, lib,
+    )
+    assert is_error is True
+    assert "4.2, 4.3" in json.loads(out)["error"]
+    assert garage_motion_design["board"]["library_id"] != "heltec-wifi-lora32-v4"
+
+
+def test_list_boards_shows_revisions(lib, garage_motion_design):
+    out, _ = execute_tool("list_boards", {}, garage_motion_design, lib)
+    by_id = {b["library_id"]: b for b in json.loads(out)["boards"]}
+    assert by_id["heltec-wifi-lora32-v4"]["revisions"] == ["4.2", "4.3"]
+    assert by_id["esp32-devkitc-v4"]["revisions"] == []
+
+
 def test_set_board_unknown_returns_error(lib, garage_motion_design):
     out, is_error = execute_tool(
         "set_board", {"library_id": "no-such-board"}, garage_motion_design, lib,
@@ -506,3 +533,19 @@ def test_search_components_puts_an_alias_above_a_use_case(lib):
     body = json.loads(execute_tool("search_components", {"query": alias}, {}, lib)[0])
     assert body["matches"][0]["score"] >= 90
     assert alias_owner.id in {m["library_id"] for m in body["matches"] if m["score"] >= 90}
+
+
+def test_add_component_hint_esphome_refuses_is_suffixed_with_a_note(lib, garage_motion_design):
+    out, _ = execute_tool(
+        "add_component", {"library_id": "bh1750", "instance_id_hint": "bh1750"}, garage_motion_design, lib,
+    )
+    body = json.loads(out)
+    assert body["instance_id"] == "bh1750_1"
+    assert body["note"].startswith("instance_id_hint 'bh1750' names an ESPHome integration")
+    out, _ = execute_tool(
+        "add_component", {"library_id": "bh1750", "instance_id_hint": "bh1750_1"}, garage_motion_design, lib,
+    )
+    body = json.loads(out)
+    assert body["instance_id"] == "bh1750_2" and "is already in use" in body["note"]
+    out, _ = execute_tool("add_component", {"library_id": "bh1750", "instance_id_hint": "lux"}, garage_motion_design, lib)
+    assert "note" not in json.loads(out)

{wirestudio-0.45.0 → wirestudio-0.47.0}/tests/test_agent_eval.py

@@ -345,3 +345,21 @@ def test_a_replayed_call_must_fit_the_tool_schema(library):
         ev.apply_calls(design, [("add_bus", {"id": "w", "type": "1wire", "pin": "D5", "bogus": 1})], library)
     with pytest.raises(RuntimeError, match="not an agent tool"):
         ev.apply_calls(design, [("create_design", {})], library)
+
+
+def test_first_i2c_part_survives_the_library_id_as_hint(library, tmp_path):
+    """The hint a model reaches for first, the library id, names the
+    integration the part loads; the studio suffixes it instead of handing
+    ESPHome an id it refuses (#410)."""
+    task = BY_ID["first-i2c-part"]
+
+    def hinting(t, design):
+        final = copy.deepcopy(design)
+        log = ev.apply_calls(final, [("add_component", {"library_id": "bh1750", "instance_id_hint": "bh1750"}),
+                                     ("solve_pins", {})], library)
+        return final, log, {}, ""
+
+    [r] = ev.run_tasks([task], library, hinting, esphome=esphome_available(), workdir=tmp_path,
+                       log=lambda s: None)
+    assert r.passed, r.reasons
+    assert r.tools == ["add_component", "solve_pins"]

{wirestudio-0.45.0 → wirestudio-0.47.0}/tests/test_api.py

@@ -309,10 +309,11 @@ def test_list_examples(client):
     assert r.status_code == 200
     examples = r.json()
     ids = {e["id"] for e in examples}
-    assert {"garage-motion-v1", "awning-control", "ttgo-lora32"} <= ids
+    assert {"garage-motion", "awning-control", "ttgo-lora32"} <= ids
     for e in examples:
         assert e["board_library_id"]
         assert e["mcu"] in {"esp8266", "esp32"}
+        assert client.get(f"/examples/{e['id']}").status_code == 200
 
 
 def test_get_example_returns_design_json(client):

wirestudio-0.47.0/tests/test_board_check.py

@@ -0,0 +1,214 @@
+"""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_revision_pins_are_checked(lib):
+    v4 = (BUNDLED / "boards" / "heltec-wifi-lora32-v4.yaml").read_text()
+    assert check_board_yaml(v4, lib).errors == []
+    broken = v4.replace('"4.3": {radio: {txen: GPIO5}}', '"4.3": {radio: {txen: GPIO99}}')
+    assert "revisions.4.3.radio.txen: GPIO99 is not in gpio_capabilities" in _errors(broken, lib)
+    bad_key = v4.replace('"4.3": {radio: {txen: GPIO5}}', '"4.3": {radio: {pa_pin: GPIO5}}')
+    assert "unknown keys ['pa_pin']" in _errors(bad_key, lib)
+
+
+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.47.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.47.0}/tests/test_designs_seed.py

@@ -207,3 +207,15 @@ def test_connector_adds_with_unassigned_positions(library):
     add_component_with_connections(design, library, library_id="connector_1x04", label="Plug", instance_id_hint="plug")
     targets = [c["target"] for c in design["connections"] if c["component_id"] == "plug"]
     assert len(targets) == 4 and all(t == {"kind": "net", "component_id": "", "net": ""} for t in targets)
+
+
+def test_a_hint_esphome_refuses_is_suffixed(library):
+    """`bh1750` as the id of a bh1750 collides with the integration the
+    render loads, so ESPHome refuses it; `fan` on an output is fine."""
+    design = _empty_design()
+    instance_id, _ = add_component_with_connections(design, library, library_id="bh1750", instance_id_hint="bh1750")
+    assert instance_id == "bh1750_1"
+    assert [c["id"] for c in design["components"]] == ["bh1750_1"]
+    assert {c["component_id"] for c in design["connections"]} == {"bh1750_1"}
+    instance_id, _ = add_component_with_connections(design, library, library_id="gpio_output", instance_id_hint="fan")
+    assert instance_id == "fan"