LabWired

Compile C, C++, or Arduino firmware source into an ELF on LabWired's hosted PlatformIO toolchain — no local compiler needed. Returns a content-addressed firmware_ref you can pass straight to labwired_run, or structured compiler diagnostics (file/line/message) on failure. Cortex-M targets (STM32, RP2040, nRF52) compile and run in the digital twin. ESP32-C3 (esp32-c3-supermini) and ESP32-S3 (esp32-s3-zero) also RUN now: the compile additionally returns flash_image_refs (bootloader/partitions/app) — pass them to labwired_run for the faithful ROM-boot path. Classic ESP32 (dual-core) runs too, via the arduino-esp32 profile (the run service drives the symbol-bearing ELF and returns the e-paper panel paint; serial is stubbed on that path). For one-shot build+simulate, pass `source` with explicit `board`, `language`, and matching `entryPath` to labwired_run. Stateless: compiled artifacts are returned as content-addressed refs, not inline bytes.

labwired_compile

Describe any catalog entry by id — the MCU is just a component with more pins. A board/MCU id (e.g. "esp32-c3-supermini", "esp32c3", "nucleo-l476rg") returns its chip, whether the twin can run it, the hosted toolchains, per-bus default pins (I2C SDA/SCL, SPI SCK/MOSI/MISO/CS, UART TX/RX), the starter LED pin, and the full pin table with each pin's peripheral functions. A peripheral/passive type (e.g. "led", "bme280", "oled-ssd1306", "servo") returns { type, class, pins:[{name, roles}] }. Call labwired_list first to browse ids.

labwired_describe

Build and open a LabWired hardware lab as one inline widget, plus a shareable LabWired Studio URL. Omit `diagram` for a bare, validated LED-blink starter (optionally pick a `board` from labwired_list) — the generic first look when the user named no specific parts. Pass an explicit `diagram` (MCU + parts + wires, including any displays and sensors) to render that exact circuit; author the full diagram and call this once. Optional `source_code` is compiled server-side and, when the board has a hosted compiler, the resulting binary ships with the share so the lab replays that exact firmware. Each call mounts one widget, so build the complete diagram first and avoid re-calling with an unchanged diagram.

labwired_lab

Retrieve a deeper state slice from a prior labwired_run via its `snapshot_id` — the decoded peripheral register wall + display framebuffer artifacts, serial output, and hardware diagnosis. Shape the payload with `output` (summary|serial|peripherals|full) and narrow the peripheral wall with `peripheral`. Deterministic: the snapshot is the exact state labwired_run produced.

labwired_inspect

List the LabWired catalog. Pass `kind` to narrow: "board" (Playground starter boards), "mcu" (MCU components only), or "component" (every component — MCUs AND peripherals/passives, with { type, class, pin_count }). Omit `kind` to get everything (boards + components). Optional `filter` is a case-sensitive substring over the board id / component type.

labwired_list

Store firmware source files as content-addressed source artifacts and return a compact source_tree_ref. Use this before labwired_compile/labwired_run/labwired_verify when firmware is more than a tiny sketch; the later tools consume refs instead of carrying source text.

labwired_put_source

THE single execution tool: run firmware in the LabWired digital-twin simulator against a virtual hardware diagram. OBSERVATIONAL — it reports what happened but never mints a "verified" badge; use labwired_verify (with an oracle) for a gated proof. Two firmware sources: pass `source_tree_ref` (preferred) or small `source` with explicit `board`, `language`, and matching `entryPath` to compile-then-run on the hosted toolchain (no local compiler), OR pass a precompiled `firmware_ref` + `target`. Returns run status, serial output, cycle counts, the universal peripheral inspect wall (decoded registers + display framebuffer artifacts), a `snapshot_id` for labwired_inspect, and — on fault, hang, or step-limit — a hardware-level diagnosis explaining what went wrong (e.g. infinite loop, unmodeled peripheral poll, bad pointer). Any unmodeled/unmapped hardware access is surfaced as a first-class fault event (fail-loud). Use `output` to shape the payload: "full" (default; everything), "summary" (status + diagnosis, no serial/peripherals), "serial" (status + serial), or "peripherals" (the inspect wall; narrow with `peripheral`). Cortex-M targets (STM32, RP2040, nRF52): a bare ELF runs directly; see docs/firmware-scaffolds/README.md for the arm-none-eabi-gcc flags. ESP32-C3/S3: pass flash_image_refs (from labwired_compile) with a precompiled firmware_ref — the twin boots the REAL ROM (mask ROM → 2nd-stage bootloader → app, like silicon); the source path threads them for you. Tip: pass `acceptance` to stop the instant the firmware prints the expected text instead of running the whole step budget; `stimuli` drives a sensor mid-run.

labwired_run

Search the LabWired MCP tool catalog by keyword and return the relevant tool definitions. Use this to find board/component discovery, diagram validation, firmware compile/run/verify, inspection, and hardware-lab tools.

labwired_search

Validate a Playground diagram (ERC + pin checks) before running or sharing it, and/or check firmware↔wiring consistency (does the firmware drive the pins the diagram actually wired?). Returns diagnostics with error/warning counts; errors mean the diagram is not wired correctly.

labwired_validate

THE mandatory-oracle gate: run firmware AND prove it worked against an explicit behavioral oracle — the ONLY tool that mints `proven`. Same firmware sources as labwired_run (`source` with explicit `board`, `language`, and matching `entryPath` to compile-then-run, or precompiled `firmware_ref`+`target`), plus a REQUIRED `oracle` with at least one clause. The oracle asserts observable evidence: `serial` markers (lowered to a stop-on-match acceptance so a print-then-crash reports the fault, not a pass), a `display` paint (refresh generation + inked bytes, read from the peripheral framebuffer artifacts), and/or `registers`/`gpio` final state. Proven iff status is not an error AND every clause holds; the verdict is deterministic and server-side. An empty/missing oracle is rejected with ORACLE_REQUIRED — verify never passes on execution alone.

labwired_verify