Merge branch 'neutral-ble-client' into radon-eye-single-node

The neutral engine reports both the user disconnect trigger and the
connect action's abort hook from one callback list, so an on_disconnect
automation that calls ble_client.connect cancelled the attempt it had
just started and never ran the rest of its chain. The legacy engine
avoided this by keying the two on different events (CLOSE_EVT for the
trigger, DISCONNECT_EVT for the abort); the hook now skips the abort
while a fresh attempt is in flight.

connected() no longer reports a link with an accepted teardown in
flight, so a connect action started in that window stops taking the
already-connected fast path, and a second disconnect() in that window
is ignored rather than settling the link twice.

The write/notify completion contract claimed every completion arrives
from the event loop, which the rp2 backend contradicts for the two
local-only operations; it now names them and requires consumers to arm
their pending state before issuing an op.

.agents/skills/display-test/SKILL.md

@@ -1,156 +0,0 @@
----
-name: display-test
-description: Test an ESPHome display driver on a real panel with a camera. Use when a task asks to verify a display (LCD, e-paper, OLED, RLCD) on hardware, check orientation/rotation, partial updates, colours, contrast, or that text and shapes render correctly. Covers finding the USB port, flashing a test pattern, capturing the panel with any camera, and reading the photo.
-allowed-tools: Read, Write, Edit, Bash, Glob, Grep
----
-
-# Display testing with a camera
-
-Point a camera at the panel to get visual evidence that a driver renders correctly. Any camera
-and capture tool works; this skill covers the common ones. `$SKILL` below is this directory
-(`.agents/skills/display-test`).
-
-## Ask before using a camera
-
-A camera can show people and rooms, not only the panel. Before the first capture, ask the user
-for permission and for which camera to use. List the cameras the host has (the commands below
-show how), name the one you intend to use, and wait for the user to confirm it. Do not pick a
-camera yourself, and do not fall back to another camera if the chosen one fails; ask again.
-
-The permission covers this session and the camera the user named. Ask again for a different
-camera or in a new session. If the user declines, stop and report that the display was not
-checked visually.
-
-## Capturing a frame
-
-Grab a still image, skipping the first few frames so auto-exposure and white balance settle.
-Read the JPEG with the Read tool; the image is shown visually.
-
-### macOS
-
-The bundled Swift tool uses AVFoundation and avoids the frame-grabbing problems some USB
-cameras have with other tools:
-
-```bash
-mkdir -p /tmp/camsnap /tmp/display-test
-swiftc -O "$SKILL/scripts/camsnap.swift" -o /tmp/camsnap/camsnap
-/tmp/camsnap/camsnap <camera-name-substring> /tmp/display-test/after.jpg 30
-```
-
-The camera argument is a case-insensitive substring of the name AVFoundation reports. If it does
-not match, the tool lists the cameras it found, so a run with a name that matches nothing lists
-the cameras without capturing. Use a substring that matches only the camera the user approved.
-It creates the output directory if needed and reports encoding or write errors on stderr. Other
-options include `ffmpeg` with `avfoundation` input, `imagesnap`, or Photo Booth's still capture.
-
-### Linux
-
-Use `ffmpeg` with the v4l2 input, `fswebcam`, or `v4l2-ctl`. With `ffmpeg`, `-ss 2` after the
-input discards the first two seconds of frames while exposure settles:
-
-```bash
-mkdir -p /tmp/display-test
-ffmpeg -f v4l2 -i /dev/video0 -ss 2 -frames:v 1 -y /tmp/display-test/after.jpg
-# or
-fswebcam -d /dev/video0 --skip 10 /tmp/display-test/after.jpg
-```
-
-List devices with `v4l2-ctl --list-devices`.
-
-### Windows
-
-Use `ffmpeg` with the DirectShow input (`-ss 2` skips the first frames, as on Linux), or any
-camera application that can save a still image:
-
-```powershell
-mkdir C:\temp -Force | Out-Null
-ffmpeg -f dshow -list_devices true -i dummy   # find the device name
-ffmpeg -f dshow -i video="<device name>" -ss 2 -frames:v 1 -y C:\temp\after.jpg
-```
-
-### Camera caveats
-
-- The board may sit at an angle. Do not trust absolute pixel positions or aspect ratios from the
-  photo; judge orientation, ordering and approximate spacing, using the corner markers as
-  references.
-- Reflections or a glossy cover can brighten one side. Capture again if a region is unclear.
-- A moving pattern is caught at an arbitrary phase. Take several captures, or use a static marker
-  per position.
-
-## Board and port
-
-Find the port; names change on every replug:
-
-```bash
-python3 "$SKILL/../hardware-test/scripts/ports.py"
-```
-
-Native-USB ESP32-S3/C3/C6/H2 boards show up as `USB JTAG/serial debug unit` and need
-`logger: hardware_uart: USB_SERIAL_JTAG`.
-
-## Test pattern
-
-Write a scratch config outside the checkout. Use one `name:` per board and include:
-
-- a white background, a black border and a filled square at the centre, drawn in the first
-  update (full-window check and scale);
-- a 60x20 bar near each corner, one bar per later update with `auto_clear_enabled: false`, so
-  each bar is written by its own partial window. The bars are wider than tall, which shows a
-  90 or 270 degree rotation; the corners exercise the window alignment;
-- a 20x20 square under the left end of the top-left bar, drawn in the same update, which marks
-  the top-left corner and shows a 180 degree rotation or a mirrored image.
-
-Use `Color::BLACK` and `Color::WHITE` in lambdas. Do not use the old `COLOR_OFF`/`COLOR_ON`
-constants; black must mean black.
-
-A ready template is in `$SKILL/templates/display-pattern.yaml`. Substitute the display platform,
-pins and (for a driver with fonts) a font. The marker pattern needs no font.
-
-## Build, flash, capture
-
-Run from the worktree under test so `python -m esphome` imports the checkout, not an installed
-copy:
-
-```bash
-cd <worktree>
-python3 -c "import esphome; print(esphome.__file__)"   # must print the worktree path
-PYTHONUNBUFFERED=1 python3 -m esphome compile /tmp/display-test/display-pattern.yaml
-PYTHONUNBUFFERED=1 python3 -m esphome upload /tmp/display-test/display-pattern.yaml \
-  --device /dev/cu.usbmodemXXXX
-sleep 6   # boot plus a few update intervals
-<capture command> /tmp/display-test/after.jpg
-```
-
-The device path differs by OS and host; use the path printed by `ports.py`. If the USB console
-wedges during flashing (esptool `No serial data received`), replug the board and retry. A board
-powered only by a battery may need the USB cable for flashing; the panel keeps its image when
-power is removed, which is useful for checking that an image is bistable.
-
-## What to check
-
-1. **Orientation**: the extra square sits under the bar in the expected top-left corner. If it is
-   in another corner, the image is rotated or mirrored. Test `rotation:` values with the same
-   pattern. The logical width and height swap at 90 and
-   270 degrees, so the 60x20 corner bars should then appear taller than wide on the physical
-   panel.
-2. **Coverage**: the border touches all four edges, with no dead rows or columns at the edges.
-3. **Partial updates**: with `auto_clear_enabled: false`, draw one marker per update. Each should
-   appear exactly at its requested position with no smearing, offset or mirrored placement.
-   Include all four corners.
-4. **Text and contrast**: sharp glyphs, correct polarity (black text on white, not inverted), no
-   ghosting from the previous frame.
-5. **Speed**: if the driver logs transfer sizes, check that a full refresh and a partial window
-   take the expected times.
-
-Record the build commit, board, config, and the captured image path when reporting results.
-
-## When a partial update looks wrong
-
-Take a marker-only capture before assuming the mapping is wrong: the camera's perspective makes
-absolute positions deceptive. If markers land in mirrored positions, the controller's address
-order (`MADCTL` MX/MY/MV) or the RAM block mapping is inverted for the window; verify the
-full-frame path separately, then fix the window computation.
-
-## Add findings
-
-Add new capture tools, panel quirks, or recovery steps here so the next session starts ahead.

.agents/skills/display-test/scripts/camsnap.swift

@@ -1,71 +0,0 @@
-// camsnap <camera name substring> <output.jpg> [frames to skip]
-// macOS only: grabs one frame from an AVFoundation camera after letting exposure settle.
-// See SKILL.md for capture tools on other systems.
-import AVFoundation
-import AppKit
-import CoreImage
-
-let args = CommandLine.arguments
-guard args.count >= 3 else {
-  FileHandle.standardError.write("usage: camsnap <camera name> <out.jpg> [skip]\n".data(using: .utf8)!)
-  exit(2)
-}
-let wanted = args[1].lowercased()
-let outPath = args[2]
-let skip = args.count > 3 ? Int(args[3]) ?? 30 : 30
-
-let discovery = AVCaptureDevice.DiscoverySession(
-  deviceTypes: [.external, .builtInWideAngleCamera], mediaType: .video, position: .unspecified)
-guard let device = discovery.devices.first(where: { $0.localizedName.lowercased().contains(wanted) }) else {
-  let names = discovery.devices.map { $0.localizedName }.joined(separator: ", ")
-  FileHandle.standardError.write("no camera matching '\(wanted)'; found: \(names)\n".data(using: .utf8)!)
-  exit(1)
-}
-
-final class Grabber: NSObject, AVCaptureVideoDataOutputSampleBufferDelegate {
-  var seen = 0
-  let skip: Int
-  let out: String
-  init(skip: Int, out: String) { self.skip = skip; self.out = out }
-  func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer,
-                     from connection: AVCaptureConnection) {
-    seen += 1
-    guard seen > skip, let pixels = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
-    let image = CIImage(cvPixelBuffer: pixels)
-    let rep = NSBitmapImageRep(ciImage: image)
-    guard let jpeg = rep.representation(using: .jpeg, properties: [.compressionFactor: 0.9]) else {
-      FileHandle.standardError.write("failed to encode \(out) as JPEG\n".data(using: .utf8)!)
-      exit(1)
-    }
-    let url = URL(fileURLWithPath: out)
-    try? FileManager.default.createDirectory(
-      at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
-    do {
-      try jpeg.write(to: url)
-    } catch {
-      FileHandle.standardError.write("failed to write \(out): \(error)\n".data(using: .utf8)!)
-      exit(1)
-    }
-    print("saved \(out) after \(seen) frames")
-    exit(0)
-  }
-}
-
-let session = AVCaptureSession()
-session.sessionPreset = .high
-guard let input = try? AVCaptureDeviceInput(device: device), session.canAddInput(input) else {
-  FileHandle.standardError.write("cannot open \(device.localizedName)\n".data(using: .utf8)!)
-  exit(1)
-}
-session.addInput(input)
-let output = AVCaptureVideoDataOutput()
-output.videoSettings = [kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA]
-let grabber = Grabber(skip: skip, out: outPath)
-output.setSampleBufferDelegate(grabber, queue: DispatchQueue(label: "camsnap"))
-session.addOutput(output)
-session.startRunning()
-DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
-  FileHandle.standardError.write("timed out waiting for frames\n".data(using: .utf8)!)
-  exit(1)
-}
-RunLoop.main.run()

.agents/skills/display-test/templates/display-pattern.yaml

@@ -1,43 +0,0 @@
-# Display test pattern: corner markers, centre reference and partial-update markers.
-# Replace the display platform and pins with the driver under test.
-esphome:
-  name: display-pattern
-
-esp32:
-  board: esp32-s3-devkitc-1
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-  level: DEBUG
-
-spi:
-  clk_pin: GPIO11
-  mosi_pin: GPIO12
-
-display:
-  - platform: st7305
-    id: test_display
-    cs_pin: GPIO40
-    dc_pin: GPIO5
-    reset_pin: GPIO41
-    update_interval: 1s
-    auto_clear_enabled: false
-    lambda: |-
-      static int frame = 0;
-      if (frame == 0) {
-        it.fill(Color::WHITE);
-        it.rectangle(0, 0, it.get_width(), it.get_height(), Color::BLACK);
-        it.filled_rectangle(it.get_width() / 2 - 10, it.get_height() / 2 - 10, 20, 20, Color::BLACK);
-      } else if (frame == 1) {
-        it.filled_rectangle(20, 20, 60, 20, Color::BLACK);
-        it.filled_rectangle(20, 50, 20, 20, Color::BLACK);
-      } else if (frame == 2) {
-        it.filled_rectangle(20, it.get_height() - 40, 60, 20, Color::BLACK);
-      } else if (frame == 3) {
-        it.filled_rectangle(it.get_width() - 80, 20, 60, 20, Color::BLACK);
-      } else if (frame == 4) {
-        it.filled_rectangle(it.get_width() - 80, it.get_height() - 40, 60, 20, Color::BLACK);
-      }
-      frame++;

.agents/skills/hardware-test/SKILL.md

@@ -115,7 +115,7 @@ Per-topic scripts, each described in the matching `reference/recipes/<component>
 (host driver, Zephyr driver probe), `rtsp_server/` (protocol client, raw rate reader, measurement set,
 API image grab), `cse7766/` (API observer with ping), `zephyr_coredump/` (reader flow, decode with the
 Zephyr tools), `libretiny_prefs/` (rtc preference harness header), `libretiny_crash/` (BK72xx crash probe header and
-capture decoder), `api_outgoing/` (wake cycle and Wi-Fi drop timing readers), `ld2450/` (zone number driver, loopback harness driver with number and binary sensor states and TX frame summarizer), `api/` (raw plaintext native API client for user defined actions), `dfrobot_sen0395/` (API driver and case runner), `homeassistant_light/` (direct bulb driver, held-report case driver), `usb_audio/` (URL player), `speaker_media_player/` (API player driver, pipeline task case runner), `web_server/` (SSE client, request mix, SSE and HTTPD case runners), `mqtt/` (broker config with TLS, client-certificate and WebSocket listeners, test CA with server and client certificates, transport case runner, flash-and-drive runner, CLI TLS check without a board), `udp/` (datagram recorder, `udp.write` payload checker and case driver), `entity_icons/` (icon and device class readback over the API, MQTT discovery, web_server and dump_config, with a comparer).
+capture decoder), `api_outgoing/` (wake cycle and Wi-Fi drop timing readers), `ld2450/` (zone number driver), `dfrobot_sen0395/` (API driver and case runner), `homeassistant_light/` (direct bulb driver, held-report case driver), `usb_audio/` (URL player).
 
 ## Templates in `$SKILL/templates`
 
@@ -131,15 +131,11 @@ capture decoder), `api_outgoing/` (wake cycle and Wi-Fi drop timing readers), `l
   `homeassistant-light-dut.yaml`, `deep-sleep-outgoing-dut.yaml`, `outgoing-wifi-drop-dut.yaml`,
   `globals-storage-dut.yaml`, `usb-audio-waveshare-s3-eth-dut.yaml`, `usb-audio-sendspin-s3-eth-dut.yaml`,
   `cast-pro-1-sendspin-control.yaml`, `aux-2-preprod-stock-dut.yaml`, `aux-2-preprod-usb-audio-dut.yaml`,
-  `dfrobot-sen0395-dut.yaml`, `aux-2-preprod-speaker-player-dut.yaml`, `web-server-sse-dut.yaml`,
-  `mqtt-transport-dut.yaml`, `mqtt-tls-dut.yaml`, `udp-write-dut.yaml`, `entity-icon-dut.yaml`.
+  `dfrobot-sen0395-dut.yaml`.
 
 ## When something looks wrong
 
 - A capture stopped early or a line is missing: check the timestamps before trusting it.
-- A script that pipes into `tee` never ends although its work is done: a background command written as
-  `(cd dir && server & echo $!)` backgrounds the whole `cd && server` list, so a shell stays behind holding the
-  pipe open and `$!` is that shell, not the server. Write `(cd dir && exec server > out 2>&1 < /dev/null) &`.
 - The client never joins the AP: another board may still run an AP with the same SSID, or the device
   booted with saved credentials because the name was reused. One AP device at a time on the bench.
 - Builds come out byte-identical between branches: the wrong tree was imported (rule 3). The reverse
@@ -149,10 +145,6 @@ capture decoder), `api_outgoing/` (wake cycle and Wi-Fi drop timing readers), `l
   preference and repeat it in a periodic alive line, as `scripts/libretiny_prefs/ltprefs.hpp` does.
 - Multicast from the host never arrives on some access points: test it device to device. Broadcast
   is lossy under Wi-Fi power save, unicast is not. Throttle UDP floods to a fixed packet rate.
-- The merge base comes from a freshly fetched `origin/dev`; a stale local `dev` puts dependency bumps into the
-  PR diff and builds the control from the wrong commit.
-- A `.local` name can stop resolving in the middle of a run; keep the address from the boot log and drive by it.
-- `wc -l` pads its count on macOS, so `tail -n +$n0` needs `$((n0+0))` or an arithmetic expansion.
 - `api:` reboots a board after 15 min without a client: `reboot_timeout: 0s` on `api:` and `mqtt:` for
   soak tests.
 

.agents/skills/hardware-test/reference/boards.md

@@ -7,9 +7,6 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
 
 - Opening the port usually resets the board through DTR, but not always; `serial_capture.py --reset`
   pulses RTS to capture from boot. 74880 baud shows the ROM boot messages (`rst cause`, `boot mode`).
-- UART0 can be looped back onto itself (`USC0(0) |= (1 << UCLBE)` in an `on_boot` lambda) so a UART
-  component is testable without its device: frames written with `uart.write` arrive on RX. Log over the
-  API with `logger: baud_rate: 0`, since the serial port carries the component's bytes.
 - `esphome logs` on some CH340s emits thousands of duplicated garbage lines right after the RTS reset;
   a plain pyserial capture at 115200 is reliable.
 - A failed esptool write can wedge the adapter (`termios` error 22, or an open that hangs) until replug.

.agents/skills/hardware-test/reference/recipes/README.md

@@ -4,24 +4,23 @@ Each flow names the pull requests it was used on, so their result tables show wh
 
 One file per component, named after it:
 
-- [`api.md`](api.md): noise handshake and OTA encryption on the ESP8266, outgoing connection wake timing on deep sleep and after a Wi-Fi drop, user defined action listing and execution with a raw plaintext client
+- [`api.md`](api.md): noise handshake and OTA encryption on the ESP8266, outgoing connection wake timing on deep sleep and after a Wi-Fi drop
 - [`captive_portal.md`](captive_portal.md): fallback AP and /wifisave hammer
 - [`cse7766.md`](cse7766.md): Sonoff S31 parser check over the API
 - [`espnow.md`](espnow.md): ESP8266 broadcast receive
 - [`hdmi_cec.md`](hdmi_cec.md): two-board wire
-- [`ld2450.md`](ld2450.md): polygon zones, zone number round trip through the radar's readback, ESP8266 loopback harness without a radar
-- [`ld2412.md`](ld2412.md): output pin level through the basic configuration command, held back writes
+- [`ld2450.md`](ld2450.md): polygon zones, zone number round trip through the radar's readback
 - [`libretiny.md`](libretiny.md): rtc preference emulation, BK72xx crash report on the next boot
-- [`mqtt.md`](mqtt.md): broker bench, QoS, reconnect, crash log over MQTT, WebSocket transports with a local and a public broker, TLS trust sources (own CA, client certificate, certificate bundle, no verification) with the CLI check
+- [`mqtt.md`](mqtt.md): broker bench, QoS, reconnect, crash log over MQTT
 - [`nrf52.md`](nrf52.md): dongle board support
 - [`online_image.md`](online_image.md): stalled and malformed downloads
 - [`openthread.md`](openthread.md): border router on the S3 host plus H2 RCP
 - [`ota.md`](ota.md): overlap and lock, timeouts, deflate
 - [`rtsp_server.md`](rtsp_server.md): camera streaming on the Waveshare ESP32-S3-ETH
 - [`scheduler.md`](scheduler.md): loop wake A/B
-- [`udp.md`](udp.md): datagrams, multicast, sockets, `udp.write` payload shapes
+- [`udp.md`](udp.md): datagrams, multicast, sockets
 - [`usb_cdc_acm.md`](usb_cdc_acm.md): nRF52840 dongle host driver
-- [`wifi.md`](wifi.md): reboot_timeout with a fallback AP, DHCP lease cache, Easy Connect (DPP), WISP bridge with an ethernet upstream
+- [`wifi.md`](wifi.md): reboot_timeout with a fallback AP, DHCP lease cache, Easy Connect (DPP)
 - [`zephyr.md`](zephyr.md): preferences on the nRF52840 dongle
 - [`zephyr_coredump.md`](zephyr_coredump.md): crash and decode on nRF52 boards
 - [`zwave_proxy.md`](zwave_proxy.md): frame checksums on a live proxy
@@ -29,5 +28,3 @@ One file per component, named after it:
 - [`homeassistant.md`](homeassistant.md): light platform mirrored from a local Home Assistant, held reports versus later calls
 - [`usb_audio.md`](usb_audio.md): USB audio speaker and microphone, the usb_host FIFO split, and Music Assistant playback through sendspin
 - [`dfrobot_sen0395.md`](dfrobot_sen0395.md): SEN0395 mmWave command flow, module quirks and overlong lines through its error reply
-- [`speaker.md`](speaker.md): media player pipeline tasks on the Connect AUX-2 with the `speaker` platform player
-- [`web_server.md`](web_server.md): state SSE stress and the HTTPD task stack on web_server_idf, entity icon and device class readback

.agents/skills/hardware-test/reference/recipes/api.md

@@ -28,15 +28,3 @@ connected first, and the loop-time maxima. For the loop cost of polling, repeat
 so after a drop every dial is closed and HA's incoming reconnect wins 11 to 33 s later; the measurable effect is the
 first dial landing in the loop the network flag flips.
 Results: https://github.com/esphome/esphome/pull/21085#issuecomment-6254742791
-
-## User defined action listing and execution without a client library (#18882)
-
-`scripts/api/rawactions.py HOST list` speaks the plaintext native API over a raw socket and decodes every
-`ListEntitiesServicesResponse` by field number (argument fields 1 name, 2 type, 3 description, 4 example, 5 optional,
-6 default_value), so new wire fields show up without waiting for the client library. `rawactions.py HOST exec ACTION
-k=v ...` sends `ExecuteServiceRequest` with `sint32` ints (field 5, not the legacy int32 field 2), fixed32 floats,
-length delimited strings and `int[]` as repeated sint32 (field 7); `ALLOW_MISSING=1` leaves arguments out on purpose
-(the device then drops the call). `templates/api-actions-dut.yaml` (D1 mini, three actions, optional variables with
-defaults) and `templates/api-actions-strings-dut.yaml` (required strings) log what arrived. String arguments are
-`StringRef`s that are not null terminated: copy them with `snprintf("%.*s", size, c_str())` into a buffer before
-logging, and do not pass `%.*s` to `logger.log`, whose validator counts it as one pattern.

.agents/skills/hardware-test/reference/recipes/ld2412.md

@@ -1,13 +0,0 @@
-# ld2412
-
-## Output pin level and the basic configuration command (#21353)
-
-`templates/ld2412-select-only-dut.yaml` (ESP32-S3, the module on GPIO43 and GPIO44 at 115200, only the output pin
-level select, the module's OUT pin on GPIO38 as a binary sensor plus the presence sensor) with `uart: debug:
-direction: BOTH`. Drive the select with `scripts/ld2450/lddrive.py HOST KEY LOGFILE sel:NAME=OPTION` and read the TX
-dump for command `02` carrying the level byte, then the OUT pin binary sensor against presence: with level high the
-pin follows presence, with level low it is inverted. A module that never answers the boot query (no `<<<` lines)
-only shows the held back path: `Command 02 held back until the module reports its settings`, a query `12`, and after
-2 s `Command 02 not sent, the module did not report its settings` with the select republished to the last known
-level. With the full set of numbers configured a select change also needs every number to have a state, so wait
-for the boot query answer before judging.

.agents/skills/hardware-test/reference/recipes/ld2450.md

@@ -13,30 +13,3 @@ selects over the API and prints every LD2450 state update. After each set the hu
 the radar and republishes all twelve coordinates from the answer, so set each coordinate of each zone to a distinct
 value and check the readbacks; no target is needed. Readbacks can arrive late over Wi-Fi, so match them by content.
 Results: https://github.com/esphome/esphome/pull/21146#issuecomment-6278026922
-
-## ESP8266 loopback harness, no radar needed (#21349)
-
-`templates/ld2450-loopback.yaml` (package; substitutions `name` and `baud`) runs the hub on UART0 (GPIO1 and GPIO3)
-with `logger: baud_rate: 0` and sets the UART0 loopback bit in `on_boot` (`USC0(0) |= (1 << UCLBE)`), so everything
-the hub or a `uart.write` action sends comes back on RX. Template buttons inject periodic frames (all four direction
-strings, targets 2 and 3), query zone acks (zone type 0, 1 and 2 for the select readback) and call the name based
-setters with a valid and a bogus name. `uart: debug: direction: TX` delimited on the command footer dumps every
-command the hub sends. Drive it with `scripts/ld2450/lddrive.py HOST KEY LOGFILE press:NAME sel:NAME=OPTION wait:S`
-(logs over the API at VERBOSE, 2 s between steps because the API log stream drops lines while `send_command_`
-blocks), then `txsum.py LOGFILE` lists the TX frames per step; diff the summaries of the two builds. The hub reads its
-own commands back and logs `Invalid status` for each, which is harmless. The boot readback of the baud rate select
-comes from the UART setting, so a second build at `baud: "9600"` checks the flash table lookup.
-Results: https://github.com/esphome/esphome/pull/21349#issuecomment-6332320026
-
-## Frame splitter collisions (#21357)
-
-The loopback template also carries the zone 1 numbers and seven collision buttons: a periodic frame with the
-command footer inside target 1, zone acks with `55 CC` and with `04 03 02 01` inside the coordinates, a periodic
-frame cut after 12 bytes followed by a zone ack, a frame missing its last byte followed by a complete one, a bogus
-255 byte length then a frame, and garbage then a frame. Judge by the state updates plus the `Handling Periodic` and
-`Handling Ack` lines. Through a real radar the set zone ack is sometimes corrupted by the radar itself (its tail
-replaced by the periodic frame it was sending, for example `04 03 03 03 00 ... 55 CC`), so count readbacks over at
-least 24 selects per build and read the raw bytes with `uart: debug: direction: RX` (`!extend` the package's uart
-id) before blaming the parser; the API log stream drops lines under that dump volume, so some misses stay
-unclassified.
-Results: https://github.com/esphome/esphome/pull/21357#issuecomment-6333244886

.agents/skills/hardware-test/reference/recipes/mqtt.md

@@ -10,44 +10,3 @@ after bulk subscribe and unsubscribe; read the heap seconds later over several r
 leak. Spawned subscriptions need about 2.5 s to reach the broker before the next publish.
 `esphome logs --device MQTT` only uses the MQTT transport when the config has no `api:`. Driver pattern: a
 paho script publishes and polls the serial capture file.
-
-## WebSocket transports on ESP-IDF (#16056)
-
-One build per transport from `templates/mqtt-transport-dut.yaml`, with `scripts/mqtt/mosquitto-ws.conf` as the
-local broker (mosquitto 2.x from brew has `websockets` support; `log_type all` prints `New connection from <ip>:<port>
-on port <listener>`, which proves which listener each client used) and `scripts/mqtt/make_test_ca.sh BROKER_IP` for
-the TLS listener's certificate, both run in the scratch directory so keys, logs and outputs stay out of the checkout. `scripts/mqtt/cases.sh NAME KEY BROKER_HOST SUB_PORT CAPTURE [DEV_HOST] [restart]` subscribes
-to `NAME/#`, sends a switch command and an `on_message` topic, presses the 3000 byte publish button over the API,
-restarts the local broker when the last argument is `restart` (the PID in `mosquitto.pid`, written when the broker
-was started with `mosquitto -c mosquitto-ws.conf & echo $! > mosquitto.pid` in the working directory next to the
-certificates), checks every listener in the broker config answers again, and prints the broker's message counts with the device log. `mosquitto_sub` cannot speak
-WebSocket, so it subscribes on the plain listener of the same broker. Cases: `tcp` on 1883, `ws` on 9001, `wss` on
-9002 with `certificate_authority` (the certificate names an address, so `skip_cert_cn_check: true`), `wss` to
-test.mosquitto.org on 8081 with no CA for the certificate bundle, and two negatives that must never connect: a
-different CA (`mbedtls_ssl_handshake returned -0x2700`) and the self-signed server through the bundle
-(`esp-x509-crt-bundle: Failed to verify certificate`, `-0x3000`). `CONFIG_MQTT_TRANSPORT_WEBSOCKET` is on by
-default in the generated sdkconfig. The TLS session costs about 29 kB of internal heap while connected; the public
-broker carries other devices' `esphome/discover` traffic, which is noise. Results:
-https://github.com/esphome/esphome/pull/16056#issuecomment-6301034019
-
-## TLS trust sources on ESP-IDF (#14318)
-
-One build per trust source from `templates/mqtt-tls-dut.yaml`: broker only (port must resolve to 1883),
-`certificate_authority` with no port (must resolve to 8883), `verify_ssl: false` with no CA, the CA plus
-`client_certificate` and `client_certificate_key` on the 8884 listener that requires one, `transport: wss` with the CA,
-`tls: true` to test.mosquitto.org on 8886 for the certificate bundle, and `tls: true` to the local self-signed broker as
-the negative. `scripts/mqtt/mosquitto-ws.conf` now has the 8883 and 8884 listeners and `scripts/mqtt/make_test_ca.sh`
-also writes `client.crt`/`client.key`. Before flashing, check each build's `src/esphome/core/defines.h` for
-`USE_MQTT_TLS`, `USE_MQTT_CERT_BUNDLE` and `USE_MQTT_TLS_INSECURE` and its `sdkconfig.<name>` for
-`CONFIG_MBEDTLS_CERTIFICATE_BUNDLE` and `CONFIG_ESP_TLS_INSECURE`: only the bundle builds may carry the bundle and only
-the unverified build the insecure flags. `scripts/mqtt/flash_and_drive.sh TREE YAML PORT KEY BROKER_HOST
-local|public|neg` runs one build end to end (flash, bounded capture, `cases.sh` with a restart for the local broker,
-counts and the broker's per-listener connection lines) and prints the config dump's `TLS:` line (`CA certificate`,
-`certificate bundle` or `no verification`). The CLI side (`esphome/mqtt.py`) is covered without a board by
-`scripts/mqtt/cli_tls_check.sh TREE [neg] YAML...`, which runs `esphome clean-mqtt` under a timeout: status 124
-after `Connected to MQTT broker!` is a pass, and with `neg` each config must instead fail with
-`CERTIFICATE_VERIFY_FAILED` and never connect. Python's default SSL
-context rejects a CA that lacks a `keyUsage` extension (`CA cert does not include key usage extension`) while mbedTLS
-on the device accepts it, which is why the test CA carries `basicConstraints` and `keyUsage`. A broker kill shows as one
-`Last esp-tls error: 0x8008` on every build, TLS or not. Results:
-https://github.com/esphome/esphome/pull/14318#issuecomment-6311863827

.agents/skills/hardware-test/reference/recipes/speaker.md

@@ -1,19 +0,0 @@
-# speaker
-
-## Media player pipeline tasks (#21203)
-
-The `speaker` media player platform (`speaker/media_player/`) creates `ann_read`, `ann_decode`, `med_read` and
-`med_decode` FreeRTOS tasks on every play and deletes them after a stop. The AUX-2 and sendspin packages use the
-`speaker_source` player instead, which has its own pipeline and never runs that code, so a test of
-`speaker/media_player/*` has to swap the player: `templates/aux-2-preprod-speaker-player-dut.yaml` removes the
-package's `external_media_player` with `id: !remove` and adds a `speaker` platform player on the package's resampler
-speakers, plus a "Task names" button whose lambda calls `xTaskGetHandle()` on the four names and logs internal free
-heap. Serve FLAC files from the host (`ffmpeg -f lavfi -i "sine=frequency=440:duration=90" -ac 2 -ar 48000 -c:a flac
-media90.flac`, a 3 s mono one for announcements, `python3 -m http.server 8765 --directory www`); `audio_http`
-refuses WAV and MP3. `scripts/speaker_media_player/cases.sh HOST KEY MEDIA_URL ANN_URL CAPTURE LABEL` runs three
-cycles through `drive.py` (`play:URL | ann:URL | stop | press:NAME | wait:S` on one API connection) with the probe
-pressed idle, during media, during the announcement, after it and after the stop. Pass: idle none, media `med_*`
-only, announcement all four, after stop none, every cycle. API commands land a second or two late over Wi-Fi, so read
-the probe against the `State changed to` lines rather than the driver's timestamps. Internal free heap after a stop
-moved by 2.5 kB between two boots of the same build, so a heap delta needs more than one boot per build. Results:
-https://github.com/esphome/esphome/pull/21203#issuecomment-6299581943

.agents/skills/hardware-test/reference/recipes/udp.md

@@ -9,18 +9,3 @@ listener. Broadcast to boards is lossy under power save, unicast is not. Flood a
 reconnect on the Pico keeps IGMP membership. Set a long loop interval from `wifi.on_connect`
 (`App.set_loop_interval(20000)`), not `on_boot`, or Wi-Fi connect crawls. The `logger.log` action
 rejects `%.*s`; use a lambda.
-
-## udp.write payload shapes (#21263, ApplyBytes)
-
-`templates/udp-write-dut.yaml` puts every payload shape behind a template button (constant 4 bytes twice, 3, 9, 0,
-128, 129 and 600 bytes, a 300 byte lambda, a simple value, a string) plus an `on_receive` that replies with the
-received bytes reversed. `scripts/udp/write_cases.sh DEVICE_IP KEY` records the device's datagrams with
-`udp_listen.py` on the test host, presses the buttons two seconds apart, sends one unicast datagram for the echo and
-compares everything byte for byte with `check.py`; a missing datagram shifts every later one, so read the first
-mismatch. Before flashing, check the generated `main.cpp`: on ESP8266 a constant payload is copied out of its
-`PROGMEM` table into `uint8_t esphome__bytes[N]` up to the stack limit and into `std::make_unique<uint8_t[]>` beyond,
-identical payloads share one table, a lambda is sent from its vector. An empty constant payload is generated as
-`send_packet(nullptr, 0)`, and the raw lwIP UDP `sendto` used on ESP8266 rejected a null buffer with `EINVAL`
-(`sendto() error 22` in the log, no datagram) until it accepted `nullptr` with a zero length; the old
-`TemplatableBytes::visit` had passed a zero length stack buffer instead. Compare sizes against the stacked PR's own
-head when the PR is stacked, not against dev. Results: https://github.com/esphome/esphome/pull/21263

.agents/skills/hardware-test/reference/recipes/web_server.md

@@ -1,60 +0,0 @@
-# web_server
-
-## State SSE on web_server_idf (#21109) and the HTTPD task stack (#21038)
-
-`templates/web-server-sse-dut.yaml` (ESP32 classic, ESP-IDF, `web_server` version 3) publishes eight sensors every
-200 ms (small state events on the 1024 byte stack buffer) and three text sensors whose JSON carries the string twice
-(`value` and `state`): 600 chars for about 1.3 kB (the 2048 byte tail), 1800 chars for about 3.7 kB (tail grown to
-4096) and 2800 chars for about 5.7 kB, over the 5120 byte JSON room, which must log `State event does not fit`
-and never put a truncated frame on the wire. An `interval` lambda logs `uxTaskGetStackHighWaterMark()` of the loop
-task (`nullptr`) and of the HTTPD task (`xTaskGetHandle("httpd")`) every 5 s; the ESPHome loop task is `loopTask`
-on ESP32. Keep `power_save_mode: none`, and drive the device by address: mDNS names dropped out mid-run once.
-
-`scripts/web_server/sse.py HOST SECONDS [--clients N] [--stall] [--churn CYCLES]` opens raw TCP connections to
-`/events`, decodes the chunked body and parses every `state` event as JSON; `--stall` adds a connection with a 2 kB
-receive buffer that never reads (the device must log `Closing stuck EventSource connection` after the 20 s stall
-timeout), `--churn` opens and resets a connection CYCLES times. `sse_cases.sh HOST KEY LABEL CAPTURE` runs the
-set: 1 client 60 s, 4 clients 60 s, a reader plus a stalled client 45 s, a reader plus 10 abrupt closes, then two
-clients with the "Burst" button (50 sensor and 50 text publishes in one loop pass). Pass: 0 invalid JSON on every
-client, the oversize sensor dropped with its warning on every publish, the stalled session closed after about
-20 s, no reset. The loop task watermark is a minimum since boot, so compare the value after the first client, after
-four clients and after the burst between the builds (the SSE split in #21109 left 1280 B more on the ESP32 classic).
-
-For the HTTPD task, `web_server: auth: type: digest` (the default `auth` is Basic) and
-`scripts/web_server/httpd_cases.sh HOST USER PASS LABEL CAPTURE`: `httpmix.sh` sends a `curl --anyauth` request
-mix per round (page, `/sensor/<Name>`, `/text_sensor/<Name>`, `/switch/<Name>`, a `POST` with `Content-Length: 0`
-to `/switch/<Name>/toggle`, an unknown path, which the IDF server closes without a response, an unauthenticated
-request answered 401, and a 2 s `/events` stream), 20 rounds alone and 12 rounds next to two `ssecurl.sh` SSE
-clients. Entity URLs use the entity name, URL encoded, not an object id. The HTTPD watermark follows the deepest
-request of the boot; compare after the mix and after the SSE round, with two boots when the numbers are close.
-Results: https://github.com/esphome/esphome/pull/21109#issuecomment-6300582328 and
-https://github.com/esphome/esphome/pull/21038#issuecomment-6301310182
-
-## Entity icon and device class readback (#21111)
-
-Covers every path that reads an entity's icon or device class: the native API listing, MQTT discovery, the web_server
-`/events` listing and REST endpoints, and `dump_config`. `templates/entity-icon-dut.yaml` (ESP8266 board with wifi,
-encrypted api, ota, web_server and mqtt against a local broker) carries a sensor with a 63 character icon, one with no
-icon or device class, an internal sensor, and binary_sensor, switch, button, text_sensor, number, select, event, cover
-and text entities with icons and device classes. The per-run file supplies `name` and `broker_ip` through
-substitutions. Flash the PR and base builds under different names, then from the scratch directory:
-
-```sh
-scripts/entity_icons/readback.sh DEVICE_IP KEY NAME BROKER_HOST cap-NAME.txt   # once per build
-scripts/entity_icons/compare.sh ic-base ic-pr                                   # api, web, mqttn, dump all identical
-```
-
-`readback.sh` takes about 25 s once the device is on the network: 12 s of `mosquitto_sub` on `homeassistant/#` and
-`NAME/#`, the API listing (`api_list.py`, one JSON line per entity with icon, device class, unit, options and event
-types) and `web_dump.py` (6 s on `/events`, keeping only the listing rows that carry `domain`, then a GET of each
-listed id with `?detail=all` and one retry, because the ESP8266 async server occasionally leaves a request unanswered
-within 5 s). The web ids are `domain/Name`, not object ids, and `/event/<name>` has no GET handler (404 on every
-build). `mqtt_norm.py` drops the `dev` block (compile time) and the `NAME/debug` topic (heap probe), so a clean run
-differs in nothing. `dump_config` prints icons and device classes only for some domains; button, event and
-binary_sensor icons never appear there.
-
-Found with this flow on 2026-10-21: since #19577 every ESP8266 `web_server` build that lists a cover, climate, lock,
-valve, update, alarm_control_panel or water_heater entity reboots with `Exception (3) LoadStoreErr` in
-`json::linked(const char *)` (the ROM `strlen` on a flash address), fixed by #21316. The cover in the template keeps
-that path covered; before #21316 is merged, apply its one line change to both trees or the web_server comparison
-cannot run.

.agents/skills/hardware-test/reference/recipes/wifi.md

@@ -23,17 +23,3 @@ Only an Android phone configures: Settings, network details, Add device, Share W
 QR scanner makes the phone an enrollee). Render the URI with the `qrcode` module and open the PNG.
 `esp32: framework: log_level: DEBUG` plus `sdkconfig_options: CONFIG_WPA_DEBUG_PRINT: y` prints the
 supplicant state machine.
-
-## WISP bridge with an ethernet upstream (#7147)
-
-`templates/wisp-ethernet-dut.yaml` (ESP32-S3 with a W5500, `wifi: ap:` with `ap_mode: WISP` and no station) and
-`templates/wisp-client.yaml` (D1 mini joining the bridge, `http_request` to a web server on the wired LAN and to
-`http://example.com/` every 15 s, `time: sntp`). Secrets: `wisp_psk` and `lan_http` (serve a text file on the host
-with `python -m http.server 8787 --bind 0.0.0.0` from a scratch directory). Judge by the client's `GET status 200`
-lines, the web server log showing the device's ethernet address as the source (NAT), the client's DHCP info (DNS1 is
-the LAN resolver) and `SNTP synced`. The device logs `Starting AP` and `DHCP DNS server: <resolver>` on its USB
-console; flashing over the air reboots it for repeat boots. Before the AP address and DHCP server moved ahead of the
-AP start (the fix in that PR), the first AP start failed on every boot with `esp_netif_dhcps_option failed: 20484`
-(DHCP server already started by the AP start event) and `Failed to enable NAT`, and the bridge only came up on the
-retry 90 s later; a client that cannot find the SSID for the first minute on an older build is that. With the fix
-the bridge is up 6 s after boot. Any change to the ESP-IDF AP start should also rerun the captive portal hammer.

.agents/skills/hardware-test/scripts/api/rawactions.py

@@ -1,211 +0,0 @@
-"""Plaintext native API client that lists user actions with their raw argument fields and executes one.
-
-usage: rawactions.py HOST list
-       rawactions.py HOST exec ACTION key=value [...]   (every argument must be given; types from the listing)
-Fields of ListEntitiesServicesArgument: 1 name, 2 type, 3 description, 4 example, 5 optional, 6 default_value.
-"""
-
-import os
-import socket
-import struct
-import sys
-
-HOST = sys.argv[1]
-CMD = sys.argv[2]
-ARGS = sys.argv[3:]
-TYPE_NAMES = {
-    0: "bool",
-    1: "int",
-    2: "float",
-    3: "string",
-    4: "bool[]",
-    5: "int[]",
-    6: "float[]",
-    7: "string[]",
-}
-
-
-def varint(v: int) -> bytes:
-    out = bytearray()
-    while True:
-        b = v & 0x7F
-        v >>= 7
-        if v:
-            out.append(b | 0x80)
-        else:
-            out.append(b)
-            return bytes(out)
-
-
-def svarint(v: int) -> bytes:
-    return varint((v << 1) ^ (v >> 63))
-
-
-def decode_varint(buf: bytes, pos: int) -> tuple[int, int]:
-    value = shift = 0
-    while True:
-        b = buf[pos]
-        pos += 1
-        value |= (b & 0x7F) << shift
-        if not b & 0x80:
-            return value, pos
-        shift += 7
-
-
-def fields(payload: bytes) -> list[tuple[int, int, object]]:
-    out = []
-    pos = 0
-    while pos < len(payload):
-        key, pos = decode_varint(payload, pos)
-        fnum, wt = key >> 3, key & 7
-        if wt == 0:
-            v, pos = decode_varint(payload, pos)
-        elif wt == 2:
-            ln, pos = decode_varint(payload, pos)
-            v = payload[pos : pos + ln]
-            pos += ln
-        elif wt == 5:
-            v = payload[pos : pos + 4]  # fixed32, caller unpacks
-            pos += 4
-        else:
-            raise ValueError(f"wire type {wt}")
-        out.append((fnum, wt, v))
-    return out
-
-
-def frame(mtype: int, payload: bytes) -> bytes:
-    return b"\x00" + varint(len(payload)) + varint(mtype) + payload
-
-
-def field_bytes(fnum: int, data: bytes) -> bytes:
-    return varint((fnum << 3) | 2) + varint(len(data)) + data
-
-
-def field_varint(fnum: int, v: int) -> bytes:
-    return varint((fnum << 3) | 0) + varint(v)
-
-
-def recv_frames(
-    sock: socket.socket, until: set[int], limit: float = 5.0
-) -> list[tuple[int, bytes]]:
-    sock.settimeout(limit)
-    buf = bytearray()
-    frames = []
-    while True:
-        try:
-            chunk = sock.recv(4096)
-        except TimeoutError:
-            return frames
-        if not chunk:
-            return frames
-        buf += chunk
-        while True:
-            if len(buf) < 3:
-                break
-            if buf[0] != 0:
-                raise ValueError("not plaintext")
-            try:
-                ln, p = decode_varint(buf, 1)
-                mt, p = decode_varint(buf, p)
-            except IndexError:
-                break
-            if len(buf) < p + ln:
-                break
-            frames.append((mt, bytes(buf[p : p + ln])))
-            del buf[: p + ln]
-            if mt in until:
-                return frames
-
-
-def main() -> None:
-    sock = socket.create_connection((HOST, 6053), timeout=5)
-    sock.sendall(
-        frame(
-            1, field_bytes(1, b"rawactions") + field_varint(2, 1) + field_varint(3, 10)
-        )
-    )  # HelloRequest
-    recv_frames(sock, {2})
-    sock.sendall(frame(3, b""))  # ConnectRequest, no password
-    recv_frames(sock, {4})
-    sock.sendall(frame(11, b""))  # ListEntitiesRequest
-    frames = recv_frames(sock, {19})
-    services = {}
-    for mt, payload in frames:
-        if mt != 41:
-            continue
-        name = key = None
-        args = []
-        for fnum, _, v in fields(payload):
-            if fnum == 1:
-                name = v.decode()
-            elif fnum == 2:
-                key = struct.unpack("<I", v)[0]
-            elif fnum == 3:
-                a = {
-                    "name": None,
-                    "type": 0,
-                    "description": None,
-                    "example": None,
-                    "optional": None,
-                    "default": None,
-                }
-                for af, _, av in fields(v):
-                    if af == 1:
-                        a["name"] = av.decode()
-                    elif af == 2:
-                        a["type"] = av
-                    elif af == 3:
-                        a["description"] = av.decode()
-                    elif af == 4:
-                        a["example"] = av.decode()
-                    elif af == 5:
-                        a["optional"] = bool(av)
-                    elif af == 6:
-                        a["default"] = av.decode()
-                    else:
-                        a[f"field{af}"] = av
-                args.append(a)
-        services[name] = (key, args)
-    if CMD == "list":
-        for name, (key, args) in services.items():
-            print(f"action {name} key={key}")
-            for a in args:
-                extra = {
-                    k: v
-                    for k, v in a.items()
-                    if k not in ("name", "type") and v is not None
-                }
-                print(f"  {a['name']}: {TYPE_NAMES.get(a['type'], a['type'])} {extra}")
-        return
-    name = ARGS[0]
-    key, args = services[name]
-    payload = varint((1 << 3) | 5) + struct.pack("<I", key)
-    given = dict(kv.split("=", 1) for kv in ARGS[1:])
-    for a in args:
-        if a["name"] not in given:
-            if os.environ.get("ALLOW_MISSING"):
-                continue  # leave the argument out of the request on purpose
-            sys.exit(f"missing {a['name']}")
-        raw = given[a["name"]]
-        t = a["type"]
-        if t == 0:
-            av = field_varint(1, 1 if raw.lower() == "true" else 0)
-        elif t == 1:
-            av = varint((5 << 3) | 0) + svarint(int(raw))  # sint32 int_
-        elif t == 2:
-            av = varint((3 << 3) | 5) + struct.pack("<f", float(raw))
-        elif t == 3:
-            av = field_bytes(4, raw.encode())
-        elif t == 5:
-            av = b"".join(
-                varint((7 << 3) | 0) + svarint(int(x)) for x in raw.split(",") if x
-            )  # repeated sint32 int_array
-        else:
-            sys.exit(f"type {t} not supported here")
-        payload += field_bytes(2, av)
-    sock.sendall(frame(42, payload))  # ExecuteServiceRequest
-    print(f"sent {name} with {given}")
-    sock.close()
-
-
-main()

.agents/skills/hardware-test/scripts/api_button.py

@@ -1,6 +1,6 @@
 """Press a template button on the test device over the API, or list its buttons.
 
-usage: api_button.py HOST KEY list | press "Button name" [...]  (KEY of - means a plaintext API)
+usage: api_button.py HOST KEY list | press "Button name" [...]
 """
 
 import asyncio
@@ -13,7 +13,7 @@ CMD, ARGS = sys.argv[3], sys.argv[4:]
 
 
 async def main() -> None:
-    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
+    c = APIClient(HOST, 6053, None, noise_psk=KEY)
     await c.connect(login=True)
     ents, _ = await c.list_entities_services()
     buttons = {e.name: e for e in ents if isinstance(e, ButtonInfo)}

.agents/skills/hardware-test/scripts/entity_icons/api_list.py

@@ -1,56 +0,0 @@
-"""List every entity over the native API with its icon, device class and unit: one sorted JSON line each.
-
-usage: api_list.py HOST KEY OUT
-"""
-
-import asyncio
-import json
-import pathlib
-import sys
-
-from aioesphomeapi import APIClient
-
-HOST, KEY, OUT = sys.argv[1], sys.argv[2], sys.argv[3]
-
-
-async def main() -> None:
-    c = APIClient(HOST, 6053, None, noise_psk=KEY)
-    await c.connect(login=True)
-    ents, _ = await c.list_entities_services()
-    rows = []
-    for e in ents:
-        row = {
-            "type": type(e).__name__,
-            "name": e.name,
-            "object_id": e.object_id,
-            "icon": e.icon,
-        }
-        for k in (
-            "device_class",
-            "unit_of_measurement",
-            "event_types",
-            "options",
-            "mode",
-        ):
-            if hasattr(e, k):
-                v = getattr(e, k)
-                row[k] = (
-                    list(v)
-                    if isinstance(v, (list, tuple))
-                    else (v.name if hasattr(v, "name") else v)
-                )
-        row["entity_category"] = (
-            e.entity_category.name
-            if hasattr(e.entity_category, "name")
-            else e.entity_category
-        )
-        row["disabled_by_default"] = e.disabled_by_default
-        rows.append(row)
-    rows.sort(key=lambda r: (r["type"], r["name"]))
-    with pathlib.Path(OUT).open("w", encoding="utf-8") as f:
-        f.writelines(json.dumps(r, sort_keys=True) + "\n" for r in rows)
-    print(f"{len(rows)} entities listed")
-    await c.disconnect()
-
-
-asyncio.run(main())

.agents/skills/hardware-test/scripts/entity_icons/compare.sh

@@ -1,13 +0,0 @@
-#!/bin/sh
-# compare.sh NAME_A NAME_B : diff the readback.sh outputs of two device names (api, web, mqttn and, when present, dump)
-# after replacing each name with DEV. Exit 1 when any pair differs; the diffs stay in cmp-KIND.diff.
-A=$1; B=$2; rc=0
-[ -n "$A" ] && [ -n "$B" ] || { echo "usage: compare.sh NAME_A NAME_B"; exit 2; }
-for k in api web mqttn dump; do
-  ext=jsonl; [ $k = dump ] && ext=txt
-  [ -f "$PWD/$k-$A.$ext" ] && [ -f "$PWD/$k-$B.$ext" ] || { echo "$k: missing"; [ $k = dump ] || rc=1; continue; }
-  sed "s/$A/DEV/g; s/$(echo "$A" | tr - _)/DEV/g" "$PWD/$k-$A.$ext" > "$PWD/cmp-$k-a.txt"
-  sed "s/$B/DEV/g; s/$(echo "$B" | tr - _)/DEV/g" "$PWD/$k-$B.$ext" > "$PWD/cmp-$k-b.txt"
-  if diff -u "$PWD/cmp-$k-a.txt" "$PWD/cmp-$k-b.txt" > "$PWD/cmp-$k.diff"; then echo "$k: identical ($(wc -l < "$PWD/cmp-$k-b.txt" | tr -d ' ') lines)"; else echo "$k: DIFFERS"; head -20 "$PWD/cmp-$k.diff"; rc=1; fi
-done
-exit $rc

.agents/skills/hardware-test/scripts/entity_icons/mqtt_norm.py

@@ -1,37 +0,0 @@
-"""Normalise mosquitto_sub output (topic TAB payload) for one device: drop other devices, replace the name, drop dev block.
-
-usage: mqtt_norm.py IN NAME OUT
-"""
-
-import json
-import pathlib
-import sys
-
-IN, NAME, OUT = sys.argv[1], sys.argv[2], sys.argv[3]
-rows = {}
-with pathlib.Path(IN).open(encoding="utf-8") as f:
-    for line in f:
-        topic, _, payload = line.rstrip("\n").partition("\t")
-        if (
-            f"/{NAME}/" not in topic and not topic.startswith(f"{NAME}/")
-        ) or topic == f"{NAME}/debug":
-            continue
-        topic = topic.replace(NAME, "DEV")
-        try:
-            obj = json.loads(payload)
-        except ValueError:
-            rows[topic] = payload.replace(NAME, "DEV")
-            continue
-        if isinstance(obj, dict):
-            obj.pop("dev", None)
-            obj = {
-                k: (v.replace(NAME, "DEV") if isinstance(v, str) else v)
-                for k, v in obj.items()
-            }
-        rows[topic] = obj
-with pathlib.Path(OUT).open("w", encoding="utf-8") as f:
-    f.writelines(
-        json.dumps({"topic": t, "payload": rows[t]}, sort_keys=True) + "\n"
-        for t in sorted(rows)
-    )
-print(f"{len(rows)} topics for {NAME}")

.agents/skills/hardware-test/scripts/entity_icons/readback.sh

@@ -1,18 +0,0 @@
-#!/bin/sh
-# readback.sh DEVICE_IP KEY NAME BROKER_HOST [CAPTURE] : record how a device built from templates/entity-icon-dut.yaml
-# reports its entity icons and device classes: the native API listing (api-NAME.jsonl), the retained MQTT discovery
-# payloads and states (mqtt-NAME.txt, normalised to mqttn-NAME.jsonl with the device name replaced and the debug topic
-# dropped), the web_server /events listing plus every REST endpoint with ?detail=all (web-NAME.jsonl) and, when a
-# serial CAPTURE is given, the dump_config Icon and Device Class lines (dump-NAME.txt, timestamps and line numbers
-# removed). KEY as for api_button.py. Outputs go to the working directory; compare two names with compare.sh.
-HERE=$(cd "$(dirname "$0")" && pwd); PY=${PYTHON:-python3}; DEV=$1; KEY=$2; N=$3; B=$4; CAP=$5; rc=0; TAB=$(printf '\t')
-[ -n "$DEV" ] && [ -n "$KEY" ] && [ -n "$N" ] && [ -n "$B" ] || { echo "usage: readback.sh DEVICE_IP KEY NAME BROKER_HOST [CAPTURE]"; exit 2; }
-timeout 12 mosquitto_sub -h "$B" -v -t 'homeassistant/#' -t "$N/#" -F "%t$TAB%p" > "$PWD/mqtt-$N.txt" 2> "$PWD/mqtt-$N.err"
-$PY "$HERE/mqtt_norm.py" "$PWD/mqtt-$N.txt" "$N" "$PWD/mqttn-$N.jsonl" || rc=1
-$PY "$HERE/api_list.py" "$DEV" "$KEY" "$PWD/api-$N.jsonl" || { echo "API listing failed"; rc=1; }
-$PY "$HERE/web_dump.py" "$DEV" "$PWD/web-$N.jsonl" || { echo "web_server dump failed"; rc=1; }
-if [ -n "$CAP" ]; then
-  LC_ALL=C grep -a '\]:   Icon: \|\]:   Device Class: ' "$CAP" | LC_ALL=C sed 's/\x1b\[[0-9;]*m//g; s/^\[[^]]*\]//; s/:[0-9]*\]:/]:/' | sort > "$PWD/dump-$N.txt"
-  echo "dump_config icon lines $(grep -c 'Icon:' "$PWD/dump-$N.txt"), device class lines $(grep -c 'Device Class:' "$PWD/dump-$N.txt")"
-fi
-exit $rc

.agents/skills/hardware-test/scripts/entity_icons/web_dump.py

@@ -1,99 +0,0 @@
-"""Dump the web_server view of every entity: the /events listing (detail all) and each REST endpoint with ?detail=all.
-
-usage: web_dump.py HOST OUT
-"""
-
-import json
-import pathlib
-import socket
-import sys
-import time
-import urllib.parse
-import urllib.request
-
-HOST, OUT = sys.argv[1], sys.argv[2]
-
-
-def sse_listing(seconds: float) -> list[dict]:
-    s = socket.create_connection((HOST, 80), timeout=5)
-    s.sendall(
-        b"GET /events HTTP/1.1\r\nHost: %s\r\nAccept: text/event-stream\r\n\r\n"
-        % HOST.encode()
-    )
-    buf = b""
-    deadline = time.monotonic() + seconds
-    s.settimeout(1.0)
-    while time.monotonic() < deadline:
-        try:
-            data = s.recv(65536)
-        except TimeoutError:
-            continue
-        if not data:
-            break
-        buf += data
-    s.close()
-    head, _, body = buf.partition(b"\r\n\r\n")
-    if b"chunked" in head.lower():
-        out = b""
-        while True:
-            i = body.find(b"\r\n")
-            if i < 0:
-                break
-            size = int(body[:i].split(b";")[0], 16)
-            out += body[i + 2 : i + 2 + size]
-            body = body[i + 2 + size + 2 :]
-            if size == 0:
-                break
-        body = out
-    rows = []
-    for block in body.decode(errors="replace").split("\n\n"):
-        ev, data = None, None
-        for line in block.split("\n"):
-            line = line.rstrip("\r")
-            if line.startswith("event:"):
-                ev = line[6:].strip()
-            elif line.startswith("data:"):
-                data = line[5:].strip()
-        if ev in ("state", "state_detail_all") and data:
-            try:
-                obj = json.loads(data)
-            except ValueError:
-                rows.append({"event": ev, "invalid": data})
-                continue
-            # bare state updates that land inside the window carry no domain; only the listing rows are kept
-            if "domain" in obj:
-                rows.append({"event": ev, **obj})
-    return rows
-
-
-def get_json(url: str) -> dict:
-    """One retry: the ESP8266 async server occasionally leaves a request unanswered."""
-    for attempt in (1, 2):
-        try:
-            with urllib.request.urlopen(url, timeout=5) as resp:
-                return json.loads(resp.read())
-        except TimeoutError:
-            if attempt == 2:
-                raise
-            print(f"retrying {url}", flush=True)
-    return {}
-
-
-rows = sse_listing(6)
-ids = sorted({r["id"] for r in rows if "id" in r})
-rest = []
-for ident in ids:
-    domain, _, obj = ident.partition("/")
-    url = f"http://{HOST}/{domain}/{urllib.parse.quote(obj)}?detail=all"
-    try:
-        rest.append({"url": url.replace(HOST, "HOST"), **get_json(url)})
-    except Exception as e:  # noqa: BLE001
-        rest.append({"url": url.replace(HOST, "HOST"), "error": str(e)})
-    time.sleep(0.3)
-with pathlib.Path(OUT).open("w", encoding="utf-8") as f:
-    f.writelines(
-        json.dumps(r, sort_keys=True) + "\n"
-        for r in sorted(rows, key=lambda r: (r.get("id", ""), r["event"]))
-    )
-    f.writelines(json.dumps(r, sort_keys=True) + "\n" for r in rest)
-print(f"{len(rows)} sse rows, {len(ids)} ids, {len(rest)} rest rows")

.agents/skills/hardware-test/scripts/ld2450/lddrive.py

@@ -1,123 +0,0 @@
-"""Drive an LD24xx harness over the API: press buttons, set selects and numbers, print state updates, save the log.
-
-usage: lddrive.py HOST KEY LOGFILE OP [OP ...]   (KEY of - means a plaintext API)
-  OP: list | press:NAME | sel:NAME=OPTION | set:NAME=VALUE | wait:SECONDS
-Steps are 2 s apart: the API log stream drops lines while the hub blocks in send_command_.
-"""
-
-import asyncio
-from pathlib import Path
-import sys
-import time
-
-from aioesphomeapi import (
-    APIClient,
-    BinarySensorState,
-    ButtonInfo,
-    LogLevel,
-    NumberInfo,
-    NumberState,
-    SelectInfo,
-    SelectState,
-    SensorInfo,
-    SensorState,
-    TextSensorInfo,
-    TextSensorState,
-)
-
-HOST, KEY, LOGFILE = sys.argv[1], sys.argv[2], sys.argv[3]
-OPS = sys.argv[4:]
-T0 = time.time()
-STEP_GAP_S = 2.0
-
-
-def stamp() -> str:
-    return f"{time.time() - T0:7.3f}"
-
-
-async def run(c: APIClient, log) -> None:
-    info = await c.device_info()
-    print(
-        f"device {info.name} esphome {info.esphome_version} compiled {info.compilation_time}"
-    )
-    ents, _ = await c.list_entities_services()
-    by_key = {e.key: e for e in ents}
-    buttons = {e.name: e for e in ents if isinstance(e, ButtonInfo)}
-    selects = {e.name: e for e in ents if isinstance(e, SelectInfo)}
-    numbers = {e.name: e for e in ents if isinstance(e, NumberInfo)}
-
-    def on_state(s) -> None:
-        e = by_key.get(s.key)
-        if e is None:
-            return
-        missing = " (missing)" if getattr(s, "missing_state", False) else ""
-        if isinstance(s, TextSensorState):
-            print(f"{stamp()} TXT {e.name} = {s.state!r}{missing}", flush=True)
-        elif isinstance(s, BinarySensorState):
-            print(f"{stamp()} BIN {e.name} = {s.state}{missing}", flush=True)
-        elif isinstance(s, NumberState):
-            print(f"{stamp()} NUM {e.name} = {s.state:.0f}{missing}", flush=True)
-        elif isinstance(s, SelectState):
-            print(f"{stamp()} SEL {e.name} = {s.state!r}{missing}", flush=True)
-        elif (
-            isinstance(s, SensorState)
-            and isinstance(e, SensorInfo)
-            and "Count" in e.name
-        ):
-            print(f"{stamp()} CNT {e.name} = {s.state:.0f}", flush=True)
-
-    def on_log(msg) -> None:
-        log.write(f"{stamp()} {msg.message.decode(errors='replace')}\n")
-
-    c.subscribe_states(on_state)
-    c.subscribe_logs(on_log, log_level=LogLevel.LOG_LEVEL_VERBOSE)
-    await asyncio.sleep(1.5)
-    for op in OPS:
-        if op == "list":
-            for n in sorted(buttons):
-                print("button:", n)
-            for n in sorted(selects):
-                print("select:", n, selects[n].options)
-            for e in ents:
-                if isinstance(e, TextSensorInfo):
-                    print("text_sensor:", e.name)
-            continue
-        kind, _, rest = op.partition(":")
-        if kind == "wait":
-            await asyncio.sleep(float(rest))
-            continue
-        if kind == "press":
-            if rest not in buttons:
-                sys.exit(f"no button named {rest!r}; have {sorted(buttons)}")
-            print(f"{stamp()} >>> press {rest}", flush=True)
-            log.write(f"{stamp()} >>> press {rest}\n")
-            c.button_command(buttons[rest].key)
-        elif kind == "set":
-            name, _, value = rest.partition("=")
-            if name not in numbers:
-                sys.exit(f"no number named {name!r}; have {sorted(numbers)}")
-            print(f"{stamp()} >>> set {name} = {value}", flush=True)
-            log.write(f"{stamp()} >>> set {name} = {value}\n")
-            c.number_command(numbers[name].key, float(value))
-        elif kind == "sel":
-            name, _, value = rest.partition("=")
-            if name not in selects:
-                sys.exit(f"no select named {name!r}; have {sorted(selects)}")
-            print(f"{stamp()} >>> select {name} = {value}", flush=True)
-            log.write(f"{stamp()} >>> select {name} = {value}\n")
-            c.select_command(selects[name].key, value)
-        else:
-            sys.exit(f"unknown op {op!r}")
-        await asyncio.sleep(STEP_GAP_S)
-    await asyncio.sleep(1)
-
-
-async def main() -> None:
-    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
-    await c.connect(login=True)
-    with Path(LOGFILE).open("w", encoding="utf-8") as log:
-        await run(c, log)
-    await c.disconnect()
-
-
-asyncio.run(main())

.agents/skills/hardware-test/scripts/ld2450/txsum.py

@@ -1,33 +0,0 @@
-"""Summarize an lddrive.py log: for each step, the LD2450 TX frames, commands and publishes.
-
-usage: txsum.py LOGFILE   (diff the output of two builds)
-"""
-
-from pathlib import Path
-import re
-import sys
-
-ANSI = re.compile(r"\x1b\[[0-9;]*m")
-out: list[str] = []
-with Path(sys.argv[1]).open(encoding="utf-8", errors="replace") as log:
-    for raw in log:
-        line = ANSI.sub("", raw.rstrip("\n"))
-        m = re.match(r"\s*[\d.]+ (.*)", line)
-        if not m:
-            continue
-        text = m.group(1)
-        if text.startswith(">>>"):
-            out.append(f"\n# {text[4:]}")
-        elif "[uart_debug" in text:
-            out.append(f"  TX {text.split('>>> ')[1]}")
-        elif "[ld2450" in text and (
-            "Sending COMMAND" in text
-            or "zone type" in text.lower()
-            or "Query zone" in text
-        ):
-            out.append(f"  LOG {text.split(']: ', 1)[1]}")
-        elif "[select:" in text and ">>" in text:
-            out.append(f"  SEL {text.split(']: ', 1)[1]}")
-        elif "[text_sensor:098]" in text:
-            out.append(f"  TXT {text.split(']: ', 1)[1]}")
-print("\n".join(out))

.agents/skills/hardware-test/scripts/mqtt/cases.sh

@@ -1,44 +0,0 @@
-#!/bin/sh
-# cases.sh NAME KEY BROKER_HOST SUB_PORT CAPTURE [DEV_HOST] [restart] : subscribe to NAME/# on the broker, send a
-# switch command and an on_message topic, press the 3000 byte publish button over the API (KEY, - for plaintext),
-# optionally restart the local broker (its PID from mosquitto.pid in the working directory, written when it was started
-# with `mosquitto -c mosquitto-ws.conf & echo $! > mosquitto.pid`), and show the device log. Outputs (sub-NAME.txt, mosquitto.out) go to the working directory, which should be the scratch directory.
-N=$1; KEY=$2; B=$3; SP=$4; LOG=$5; DEV=${6:-$1.local}; RESTART=$7; HERE=$(cd "$(dirname "$0")" && pwd); PY=${PYTHON:-python3}; WORK=$PWD
-BTN=$HERE/../api_button.py
-[ -n "$KEY" ] && [ -r "$LOG" ] || { echo "usage: cases.sh NAME KEY BROKER_HOST SUB_PORT CAPTURE [DEV_HOST] [restart] (CAPTURE must be a readable file)"; exit 2; }
-show() { tail -n +$(($1+1)) "$LOG" | sed 's/\x1b\[[0-9;]*m//g' | grep -a 'mqtt\|\[probe:\|cmd payload\|Relay\|\[W\]\|\[E\]\|Guru\|abort\|Backtrace\|ESPHome version' | grep -a -v 'took a long time\|Publish.*Counter\|sensor/counter' | cut -c1-170; }
-pub() { mosquitto_pub -h "$B" -p "$SP" -t "$1" -m "$2" || { echo "mosquitto_pub to $1 failed"; exit 1; }; }
-n0=$(($(wc -l < "$LOG")+0))
-timeout 75 mosquitto_sub -h "$B" -p "$SP" -v -t "$N/#" > "$WORK/sub-$N.txt" 2> "$WORK/sub-$N.err" &
-sub_pid=$!
-sleep 20
-echo "=== $N: command to the switch and the 3000 byte publish ($(date +%T))"
-pub "$N/switch/relay/command" ON; sleep 2
-pub "$N/cmd" "hello-over-$N"; sleep 2
-$PY "$BTN" "$DEV" "$KEY" press "Publish big" || { echo "button press failed"; exit 1; }; sleep 3
-pub "$N/switch/relay/command" OFF; sleep 2
-if [ "$RESTART" = restart ]; then
-  [ -f "$WORK/mosquitto-ws.conf" ] || { echo "no mosquitto-ws.conf in $WORK, cannot restart the broker"; exit 1; }
-  echo "=== $N: broker restart ($(date +%T))"; n1=$(($(wc -l < "$LOG")+0))
-  # Only this run's broker is signalled: its PID comes from mosquitto.pid, written when it was started
-  pid=$(cat "$WORK/mosquitto.pid" 2>/dev/null); [ -n "$pid" ] || { echo "no mosquitto.pid in $WORK, cannot restart the broker"; exit 1; }
-  kill "$pid" || { echo "broker PID $pid is not running, nothing to restart"; exit 1; }; sleep 8
-  nc -z -w 3 "$B" 1883 && { echo "the old broker still answers on 1883 after the kill"; exit 1; }
-  # exec so the PID is the broker's own and no shell stays behind holding the caller's output pipe open
-  (cd "$WORK" && exec mosquitto -c mosquitto-ws.conf > mosquitto.out 2>&1 < /dev/null) &
-  echo $! > "$WORK/mosquitto.pid"; sleep 25
-  for port in $(awk '/^listener/ {print $2}' "$WORK/mosquitto-ws.conf"); do nc -z -w 3 "$B" "$port" || { echo "broker port $port not listening after the restart"; exit 1; }; done
-  tail -n +$((n1+1)) "$LOG" | grep -a -q "MQTT_EVENT_CONNECTED\|\[mqtt:[0-9]*\]: Connected" || { echo "the device did not reconnect after the broker restart"; exit 1; }
-else
-  echo "=== $N: no broker restart (pass 'restart' as the 7th argument for a local broker)"
-fi
-wait $sub_pid; sub_rc=$?
-[ "$sub_rc" = 124 ] || { echo "subscriber ended with status $sub_rc: $(cat "$WORK/sub-$N.err")"; exit 1; }
-echo "--- broker saw ($(grep -c . "$WORK/sub-$N.txt") messages): $(cut -c1-60 "$WORK/sub-$N.txt" | awk '{print $1}' | sort | uniq -c | tr '\n' ';')"
-big=$(grep "^$N/big " "$WORK/sub-$N.txt" | awk '{print length($2)}' | tr '\n' ' ')
-echo "--- big payload bytes seen: $big"
-echo "--- device log:"; show "$n0"
-case " $big " in *" 3000 "*) ;; *) echo "the 3000 byte payload did not reach the broker"; exit 1;; esac
-for want in "Relay ON" "cmd payload: hello-over-$N" "Relay OFF"; do
-  tail -n +$((n0+1)) "$LOG" | grep -a -q "$want" || { echo "the device never logged '$want': the broker to device path failed"; exit 1; }
-done

.agents/skills/hardware-test/scripts/mqtt/cli_tls_check.sh

@@ -1,24 +0,0 @@
-#!/bin/sh
-# cli_tls_check.sh TREE [neg] YAML... : run `esphome clean-mqtt` from the checkout TREE for each config, which goes
-# through the same TLS setup in esphome/mqtt.py as `esphome logs` over MQTT, without needing a board. clean-mqtt never
-# exits on its own, so it runs under a 25 s timeout: status 124 after "Connected to MQTT broker!" means the CLI
-# connected. With neg every config must instead fail with CERTIFICATE_VERIFY_FAILED and never connect, so a negative
-# that fails for another reason (bad YAML, broker down) is reported as a failure too. A relative YAML path is taken
-# from the working directory, where the cleanmqtt-NAME.log outputs also go. Exit 1 when any config missed its result.
-TREE=$1; shift; PY=${PYTHON:-python3}; NEG=0
-[ "$1" = neg ] && { NEG=1; shift; }
-[ -d "$TREE/esphome" ] && [ -n "$1" ] || { echo "usage: cli_tls_check.sh TREE [neg] YAML..."; exit 2; }
-bad=0
-for y in "$@"; do
-  case $y in /*) ;; *) y=$PWD/$y;; esac
-  n=$(basename "$y" .yaml); log=$PWD/cleanmqtt-$n.log
-  (cd "$TREE" && PYTHONUNBUFFERED=1 timeout 25 $PY -m esphome clean-mqtt "$y" > "$log" 2>&1); rc=$?
-  if [ "$NEG" = 0 ] && [ "$rc" = 124 ] && grep -q "Connected to MQTT broker" "$log"; then
-    echo "$n: connected"
-  elif [ "$NEG" = 1 ] && grep -q "CERTIFICATE_VERIFY_FAILED" "$log" && ! grep -q "Connected to MQTT broker" "$log"; then
-    echo "$n: rejected (CERTIFICATE_VERIFY_FAILED)"
-  else
-    echo "$n: FAILED (status $rc): $(grep -a -m1 -i 'cannot connect\|error' "$log" | cut -c1-160)"; bad=$((bad+1))
-  fi
-done
-[ "$bad" = 0 ]

.agents/skills/hardware-test/scripts/mqtt/flash_and_drive.sh

@@ -1,53 +0,0 @@
-#!/bin/sh
-# flash_and_drive.sh TREE YAML PORT KEY BROKER_HOST MODE [SUB_PORT] : flash YAML from the checkout TREE over the serial
-# PORT, capture the serial log (cap-NAME.txt in the working directory), wait for the first MQTT connect or TLS error,
-# then drive the device with cases.sh (KEY as for cases.sh, - for a plaintext API). MODE local runs cases.sh with a
-# broker restart (the working directory must hold mosquitto-ws.conf and mosquitto.pid), public runs it without a
-# restart, neg only watches for 100 s (a build that must never connect). SUB_PORT is the plain listener cases.sh
-# subscribes on (default 1883). Ends with connect, disconnect, handshake error and crash counts, the config dump's
-# TLS line, the probe heap lines and the broker listener each connection used. Exit 1 when the capture did not start,
-# the device reached no MQTT event within 90 s (local and public), it crashed, or the mode's own check failed.
-TREE=$1; YAML=$2; PORT=$3; KEY=$4; B=$5; MODE=$6; SP=${7:-1883}
-case $YAML in /*) ;; *) YAML=$PWD/$YAML;; esac
-HERE=$(cd "$(dirname "$0")" && pwd); PY=${PYTHON:-python3}; N=$(basename "$YAML" .yaml); CAP=$PWD/cap-$N.txt; ULOG=$PWD/upload-$N.log
-[ -d "$TREE/esphome" ] && [ -e "$PORT" ] && [ -n "$KEY" ] && [ -n "$B" ] || { echo "usage: flash_and_drive.sh TREE YAML PORT KEY BROKER_HOST local|public|neg [SUB_PORT]"; exit 2; }
-case $MODE in local|public|neg) ;; *) echo "MODE must be local, public or neg"; exit 2;; esac
-pkill -f "[s]erial_capture.py $PORT "; sleep 1
-echo "=== $N: flash ($(date +%T))"
-(cd "$TREE" && PYTHONUNBUFFERED=1 timeout 300 $PY -m esphome upload "$YAML" --device "$PORT" > "$ULOG" 2>&1) || { echo "upload failed"; tail -5 "$ULOG"; exit 1; }
-SECS=200; [ "$MODE" = neg ] && SECS=100
-# a stale capture from an earlier run must not satisfy the wait below
-rm -f "$CAP"
-$PY "$HERE/../serial_capture.py" "$PORT" $SECS "$CAP" > "$PWD/cap-$N.stderr" 2>&1 &
-cap_pid=$!
-i=0; until grep -a -q "MQTT_EVENT_CONNECTED\|\[mqtt:[0-9]*\]: Connected\|mbedtls_ssl_handshake returned\|Failed to verify" "$CAP" 2>/dev/null || [ $i -ge 45 ]; do sleep 2; i=$((i+1)); done
-kill -0 $cap_pid 2>/dev/null && [ -f "$CAP" ] || { echo "serial capture is not running on $PORT"; tail -3 "$PWD/cap-$N.stderr"; exit 1; }
-DEV=$(grep -a -o 'IP Address: [0-9.]*' "$CAP" | head -1 | awk '{print $3}')
-if [ $i -ge 45 ] || [ -z "$DEV" ]; then
-  echo "=== $N: no MQTT event or no IP within 90 s ($(date +%T))"
-  [ "$MODE" = neg ] || { pkill -f "[s]erial_capture.py $PORT "; exit 1; }
-else
-  echo "=== $N: first MQTT event after $((i*2)) s, device $DEV ($(date +%T))"
-fi
-grep -a 'ESPHome version\|\]:   Transport\|\]:   TLS:' "$CAP" | sed 's/\x1b\[[0-9;]*m//g' | cut -c1-120
-rc=0
-case $MODE in
-  local)  PYTHON=$PY sh "$HERE/cases.sh" "$N" "$KEY" "$B" "$SP" "$CAP" "$DEV" restart; rc=$?;;
-  public) PYTHON=$PY sh "$HERE/cases.sh" "$N" "$KEY" "$B" "$SP" "$CAP" "$DEV"; rc=$?;;
-  neg)    sleep 70;;
-esac
-wait $cap_pid
-strip() { sed 's/\x1b\[[0-9;]*m//g'; }
-# count the backend's own events so the result does not depend on on_connect/on_disconnect log lines in the config
-connects=$(grep -a -c 'MQTT_EVENT_CONNECTED' "$CAP"); errors=$(grep -a -c 'mbedtls_ssl_handshake returned\|Failed to verify certificate' "$CAP")
-crashes=$(grep -a -c 'Guru\|abort()\|Backtrace' "$CAP")
-echo "=== $N: connects $connects, disconnects $(grep -a -c 'MQTT_EVENT_DISCONNECTED' "$CAP"), handshake errors $errors, crashes $crashes"
-grep -a 'mbedtls_ssl_handshake returned\|Failed to verify\|esp-tls' "$CAP" | strip | sed 's/^\[[^]]*\]//' | sort | uniq -c | sort -rn | head -4 | cut -c1-150
-grep -a '\[probe:' "$CAP" | strip | sed 's/.*\[probe:[0-9]*\]: //' | sed -n '1p;$p'
-[ -f "$PWD/mosquitto.log" ] && [ -n "$DEV" ] && echo "broker listeners used by $DEV: $(grep "New connection from $DEV" "$PWD/mosquitto.log" | sed 's/.*on port //' | sort | uniq -c | tr '\n' ';')"
-[ "$crashes" = 0 ] || { echo "device crashed $crashes time(s)"; exit 1; }
-if [ "$MODE" = neg ]; then
-  [ "$connects" = 0 ] && [ "$errors" -gt 0 ] || { echo "negative case: expected no connect and a handshake error"; exit 1; }
-else
-  [ "$rc" = 0 ] || { echo "cases.sh failed with status $rc"; exit 1; }
-fi

.agents/skills/hardware-test/scripts/mqtt/make_test_ca.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-# make_test_ca.sh BROKER_IP : a throwaway CA, a server certificate for the broker address and a client certificate
-# (30 days), written into the working directory; run it in the scratch directory where a copy of mosquitto-ws.conf
-# lives. The device config takes ca.crt as certificate_authority (skip_cert_cn_check: true, the name check does not
-# match an address) and client.crt/client.key as client_certificate/client_certificate_key for the listener that
-# requires one; other-ca.crt is a second CA for the negative case. The CA carries basicConstraints and keyUsage
-# because Python's default SSL context (esphome logs, esphome clean-mqtt) rejects a CA without them.
-set -e
-IP=$1
-[ -n "$IP" ] || { echo "usage: make_test_ca.sh BROKER_IP"; exit 2; }
-openssl req -x509 -newkey rsa:2048 -nodes -keyout ca.key -out ca.crt -days 30 -subj "/CN=hwtest-ca" \
-  -addext "basicConstraints=critical,CA:TRUE" -addext "keyUsage=critical,keyCertSign,cRLSign"
-openssl req -newkey rsa:2048 -nodes -keyout server.key -out server.csr -subj "/CN=hwtest-broker"
-printf "subjectAltName=IP:%s\nextendedKeyUsage=serverAuth\n" "$IP" > san.ext
-openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 30 -extfile san.ext
-openssl req -newkey rsa:2048 -nodes -keyout client.key -out client.csr -subj "/CN=hwtest-client"
-printf "extendedKeyUsage=clientAuth\n" > client.ext
-openssl x509 -req -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out client.crt -days 30 -extfile client.ext
-openssl req -x509 -newkey rsa:2048 -nodes -keyout other-ca.key -out other-ca.crt -days 30 -subj "/CN=other-ca" \
-  -addext "basicConstraints=critical,CA:TRUE" -addext "keyUsage=critical,keyCertSign,cRLSign"
-openssl verify -CAfile ca.crt server.crt client.crt

.agents/skills/hardware-test/scripts/mqtt/mosquitto-ws.conf

@@ -1,26 +0,0 @@
-# Copy next to the certificates in the scratch directory and start it there with
-# `mosquitto -c mosquitto-ws.conf & echo $! > mosquitto.pid` (cases.sh restarts that PID): plain MQTT, MQTT over TLS,
-# MQTT over TLS that requires a client certificate, MQTT over WebSocket, and MQTT over WebSocket with TLS
-# (server.crt, server.key, ca.crt from make_test_ca.sh in the same directory). log_type all gives the listener port
-# per connection.
-listener 1883
-protocol mqtt
-listener 8883
-protocol mqtt
-certfile server.crt
-keyfile server.key
-listener 8884
-protocol mqtt
-certfile server.crt
-keyfile server.key
-cafile ca.crt
-require_certificate true
-listener 9001
-protocol websockets
-listener 9002
-protocol websockets
-certfile server.crt
-keyfile server.key
-allow_anonymous true
-log_type all
-log_dest file mosquitto.log

.agents/skills/hardware-test/scripts/speaker_media_player/cases.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-# cases.sh HOST KEY MEDIA_URL ANN_URL CAPTURE LABEL : three play, announce, stop cycles on a speaker media player with the
-# "Task names" probe button pressed idle, during media, during the announcement, after it and after the stop.
-# KEY of - is plaintext. Serve FLAC files with `python3 -m http.server 8765 --directory www` (audio_http refuses WAV and MP3).
-H=$1; K=$2; MEDIA=$3; ANN=$4; LOG=$5; LABEL=$6; PY=${PYTHON:-python3}; HERE=$(dirname "$0")
-[ -r "$LOG" ] || { echo "usage: cases.sh HOST KEY MEDIA_URL ANN_URL CAPTURE LABEL (CAPTURE must be a readable file)"; exit 2; }
-show() { tail -n +$(($1+1)) "$LOG" | sed 's/\x1b\[[0-9;]*m//g' | grep -a '\[tasks:\|speaker_media_player\|speaker_mixer\|\[W\]\|\[E\]\|Guru\|abort\|Backtrace' | grep -a -v 'took a long time' | cut -c1-180; }
-for cycle in 1 2 3; do
-  n0=$(wc -l < "$LOG"); echo "=== $LABEL cycle $cycle ($(date +%T))"
-  $PY "$HERE/drive.py" "$H" "$K" "press:Task names" wait:1 "play:$MEDIA" wait:5 "press:Task names" wait:1 "ann:$ANN" wait:1.5 "press:Task names" wait:5 "press:Task names" wait:1 stop wait:3 "press:Task names" || { rc=$?; echo "driver failed ($rc), aborting"; exit $rc; }
-  sleep 1; echo "--- device log:"; show "$n0"
-done

.agents/skills/hardware-test/scripts/speaker_media_player/drive.py

@@ -1,50 +0,0 @@
-"""Drive the speaker platform media player (the first media player found) over one API connection.
-
-usage: drive.py HOST KEY op [op ...]
-ops: play:URL | ann:URL | stop | press:BUTTON | wait:S
-"""
-
-import asyncio
-import sys
-
-from aioesphomeapi import APIClient, ButtonInfo, MediaPlayerCommand, MediaPlayerInfo
-
-HOST, KEY, OPS = sys.argv[1], sys.argv[2], sys.argv[3:]
-
-
-async def main() -> None:
-    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
-    await c.connect(login=True)
-    try:
-        await run_ops(c)
-    finally:
-        await c.disconnect()
-
-
-async def run_ops(c: APIClient) -> None:
-    ents, _ = await c.list_entities_services()
-    player = next((e for e in ents if isinstance(e, MediaPlayerInfo)), None)
-    if player is None:
-        sys.exit("no media player on this device")
-    buttons = {e.name: e for e in ents if isinstance(e, ButtonInfo)}
-    for op in OPS:
-        kind, _, rest = op.partition(":")
-        print(f"{asyncio.get_running_loop().time():.1f} {op}", flush=True)
-        if kind == "play":
-            c.media_player_command(player.key, media_url=rest)
-        elif kind == "ann":
-            c.media_player_command(player.key, media_url=rest, announcement=True)
-        elif kind == "stop":
-            c.media_player_command(player.key, command=MediaPlayerCommand.STOP)
-        elif kind == "press":
-            if rest not in buttons:
-                sys.exit(f"no button {rest!r}; have {sorted(buttons)}")
-            c.button_command(buttons[rest].key)
-        elif kind == "wait":
-            await asyncio.sleep(float(rest))
-        else:
-            sys.exit(f"unknown op {op!r}")
-    await asyncio.sleep(0.5)
-
-
-asyncio.run(main())

.agents/skills/hardware-test/scripts/udp/check.py

@@ -1,40 +0,0 @@
-"""Compare the listener log (JSON lines from udp_listen.py) against the udp-write-dut.yaml payload sequence.
-
-usage: check.py LISTEN_JSONL ECHO_HEX  (ECHO_HEX is the datagram sent to the device for the echo case)
-"""
-
-import json
-import pathlib
-import sys
-
-with pathlib.Path(sys.argv[1]).open(encoding="utf-8") as f:
-    log = [json.loads(line) for line in f if line.strip()]
-echo_in = bytes.fromhex(sys.argv[2])
-small = bytes([0xAA, 0x55, 0x01, 0x02])
-expected = [
-    ("small 1/2", small),
-    ("small 2/2", small),
-    ("simple", bytes([1, 2, 3])),
-    ("text", b"hello udp"),
-    ("empty", b""),
-    ("stack128", bytes((0x10 + i) & 0xFF for i in range(128))),
-    ("heap129", bytes((0x20 + i) & 0xFF for i in range(129))),
-    ("heap600", bytes((0x30 + i) & 0xFF for i in range(600))),
-    ("lambda300", bytes((i * 7) & 0xFF for i in range(300))),
-    ("echo", echo_in[::-1]),
-]
-got = [bytes.fromhex(e["hex"]) for e in log]
-ok = 0
-for i, (name, want) in enumerate(expected):
-    have = got[i] if i < len(got) else None
-    res = (
-        "OK"
-        if have == want
-        else f"MISMATCH got {None if have is None else have[:16].hex() + '... len ' + str(len(have))}"
-    )
-    ok += res == "OK"
-    print(f"{name:10s} {len(want):4d} B  {res}")
-print(
-    f"{ok}/{len(expected)} payloads byte-exact, {len(got)} datagrams received, sources {sorted({e['src'] for e in log})}"
-)
-sys.exit(0 if ok == len(expected) and len(got) == len(expected) else 1)

.agents/skills/hardware-test/scripts/udp/udp_listen.py

@@ -1,32 +0,0 @@
-"""Log every datagram on PORT for SECONDS as one JSON line: time, source, length, hex payload."""
-
-import json
-import pathlib
-import socket
-import sys
-import time
-
-port, secs, out = int(sys.argv[1]), float(sys.argv[2]), sys.argv[3]
-s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-s.bind(("", port))
-s.settimeout(1.0)
-end = time.monotonic() + secs
-with pathlib.Path(out).open("w", encoding="utf-8") as f:
-    while time.monotonic() < end:
-        try:
-            data, (ip, sport) = s.recvfrom(65535)
-        except TimeoutError:
-            continue
-        f.write(
-            json.dumps(
-                {
-                    "t": time.strftime("%H:%M:%S"),
-                    "src": ip,
-                    "len": len(data),
-                    "hex": data.hex(),
-                }
-            )
-            + "\n"
-        )
-        f.flush()

.agents/skills/hardware-test/scripts/udp/write_cases.sh

@@ -1,22 +0,0 @@
-#!/bin/sh
-# write_cases.sh DEVICE_IP KEY [PORT] : drive a device built from templates/udp-write-dut.yaml. Records every datagram
-# the device sends to PORT (the udp component's port, default 18511) with udp_listen.py in the working directory,
-# presses the eight payload buttons over the API two seconds apart (KEY as for api_button.py, - for a plaintext API),
-# sends one 16 byte unicast datagram to the device for the echo case, then compares the recorded datagrams with
-# check.py. The recorder runs until the driver stops it. Exit 1 when the recorder did not start or a payload is
-# missing or differs; listen.jsonl stays in the working directory.
-HERE=$(cd "$(dirname "$0")" && pwd); PY=${PYTHON:-python3}; DEV=$1; KEY=$2; PORT=${3:-18511}
-[ -n "$DEV" ] && [ -n "$KEY" ] || { echo "usage: write_cases.sh DEVICE_IP KEY [PORT]"; exit 2; }
-ECHO=0102030405060708090a0b0c0d0e0f10
-rm -f "$PWD/listen.jsonl"
-$PY "$HERE/udp_listen.py" "$PORT" 600 "$PWD/listen.jsonl" &
-lst=$!
-sleep 2
-kill -0 $lst 2>/dev/null || { echo "udp_listen.py is not running on port $PORT"; exit 1; }
-for b in Small Simple Text Empty Stack128 Heap129 Heap600 Lambda300; do
-  $PY "$HERE/../api_button.py" "$DEV" "$KEY" press "$b" > /dev/null || echo "press $b failed"; sleep 2
-done
-$PY -c "import socket; socket.socket(socket.AF_INET, socket.SOCK_DGRAM).sendto(bytes.fromhex('$ECHO'), ('$DEV', $PORT))"
-sleep 5
-kill $lst 2>/dev/null; wait $lst 2>/dev/null
-$PY "$HERE/check.py" "$PWD/listen.jsonl" "$ECHO"

.agents/skills/hardware-test/scripts/web_server/httpd_cases.sh

@@ -1,17 +0,0 @@
-#!/bin/sh
-# httpd_cases.sh HOST USER PASS LABEL CAPTURE : HTTPD task stack load for the web_server_idf task size; probe lines from
-# CAPTURE, SSE client output into the working directory. A failed step ends the run with its status.
-H=$1; U=$2; P=$3; LABEL=$4; LOG=$5; HERE=$(dirname "$0")
-[ -r "$LOG" ] || { echo "usage: httpd_cases.sh HOST USER PASS LABEL CAPTURE (CAPTURE must be a readable file)"; exit 2; }
-probes() { tail -n +$(($1+1)) "$LOG" | sed 's/\x1b\[[0-9;]*m//g' | grep -a -o "\[[0-9:]*\]\[I\]\[probe:[0-9]*\]: .*httpd min free stack [0-9]*\|\[[0-9:]*\]\[[WE]\]\[[a-z_.]*:[0-9]*\].*\|Guru.*" | grep -a -v "took a long time\|does not fit\|\]\[httpd\]: /" | sed 's/\[I\]\[probe:[0-9]*\]: loopTask min free stack \([0-9]*\), httpd min free stack \([0-9]*\)/ loop \1 httpd \2/' | uniq -f1 | cut -c1-140; }
-step() { n0=$(wc -l < "$LOG"); echo "=== $LABEL: $1 ($(date +%T))"; shift; "$@" || { rc=$?; echo "step failed ($rc)"; exit $rc; }; echo "--- device log:"; probes "$n0"; }
-step "idle 15 s" sleep 15
-step "request mix, 20 rounds" sh "$HERE/httpmix.sh" "$H" "$U" "$P" 20
-# Two SSE clients next to the request mix; arguments stay quoted, nothing is reparsed as shell code
-concurrent() {
-  sh "$HERE/ssecurl.sh" "$H" "$U" "$P" 40 "$PWD/sse1-$LABEL.txt" & p1=$!
-  sh "$HERE/ssecurl.sh" "$H" "$U" "$P" 40 "$PWD/sse2-$LABEL.txt" & p2=$!
-  sh "$HERE/httpmix.sh" "$H" "$U" "$P" 12 && wait $p1 && wait $p2
-}
-step "2 SSE clients 40 s with the request mix alongside" concurrent
-step "idle 15 s after" sleep 15

.agents/skills/hardware-test/scripts/web_server/httpmix.sh

@@ -1,26 +0,0 @@
-#!/bin/sh
-# httpmix.sh HOST USER PASS ROUNDS : authenticated request mix (curl --anyauth follows the server's Basic or Digest
-# challenge): page, two json endpoints, a switch POST, a 404, an unauthenticated 401 and a 2 s SSE stream per round
-H=$1; U=$2; P=$3; N=$4; ok=0; bad=0
-# chk EXPECTED LABEL curl-args... : only LABEL is printed on a miss, never the argument list with the credentials
-chk() { exp=$1; label=$2; shift 2; c=$(curl -s -m 6 -o /dev/null -w "%{http_code}" "$@"); if [ "$c" = "$exp" ]; then ok=$((ok+1)); else bad=$((bad+1)); echo "expected $exp got $c: $label"; fi; }
-sse_tmp=$(mktemp)
-for i in $(seq 1 $N); do
-  page=$(curl -s -m 6 -o /dev/null -w "%{http_code}" -u "$U:$P" --anyauth "http://$H/")
-  if [ "$page" = 200 ]; then ok=$((ok+1)); else bad=$((bad+1)); echo "expected 200 got $page: /"; fi
-  chk 200 "GET /sensor/Fast%201" -u "$U:$P" --anyauth "http://$H/sensor/Fast%201"
-  chk 200 "GET /text_sensor/Big" -u "$U:$P" --anyauth "http://$H/text_sensor/Big"
-  chk 200 "GET /switch/Toggle" -u "$U:$P" --anyauth "http://$H/switch/Toggle"
-  chk 200 "POST /switch/Toggle/toggle" -u "$U:$P" --anyauth -X POST -H "Content-Length: 0" "http://$H/switch/Toggle/toggle"
-  # The IDF server closes an unknown path without a response: curl ends with 52 (empty reply) or 56 (reset), never a
-  # timeout (28) or a refused connection (7); only trust the close when the page just answered
-  c=$(curl -s -m 6 -o /dev/null -w "%{http_code}" -u "$U:$P" --anyauth "http://$H/nonexistent"); rc=$?
-  if [ "$c" = 000 ] && [ "$page" = 200 ] && { [ "$rc" = 52 ] || [ "$rc" = 56 ]; }; then ok=$((ok+1)); else bad=$((bad+1)); echo "unknown path: got $c, curl status $rc, with the page at $page"; fi
-  chk 401 "GET / without credentials" "http://$H/"
-  timeout 2 curl -s -N -u "$U:$P" --anyauth -o "$sse_tmp" "http://$H/events" 2>/dev/null; rc=$?
-  if [ "$rc" = 124 ] && grep -q "^event: state" "$sse_tmp"; then ok=$((ok+1)); else bad=$((bad+1)); echo "SSE stream: curl status $rc, $(grep -c '^event: state' "$sse_tmp") state events"; fi
-  sleep 1
-done
-rm -f "$sse_tmp"
-echo "httpmix: $ok ok, $bad unexpected"
-[ "$bad" = 0 ]

.agents/skills/hardware-test/scripts/web_server/sse.py

@@ -1,187 +0,0 @@
-"""SSE client(s) for a web_server /events stream: counts state events and checks each is valid JSON.
-
-usage: sse.py HOST SECONDS [--clients N] [--stall] [--churn CYCLES]
---stall opens one extra connection that never reads (the device's socket buffer fills); --churn opens
-and abruptly closes a connection CYCLES times, 2 s apart, next to the reading clients.
-"""
-
-import argparse
-from collections import Counter
-import contextlib
-import json
-import socket
-import sys
-import threading
-import time
-
-ap = argparse.ArgumentParser()
-ap.add_argument("host")
-ap.add_argument("seconds", type=float)
-ap.add_argument("--clients", type=int, default=1)
-ap.add_argument("--stall", action="store_true")
-ap.add_argument("--churn", type=int, default=0)
-args = ap.parse_args()
-
-REQ = b"GET /events HTTP/1.1\r\nHost: %s\r\nAccept: text/event-stream\r\nConnection: keep-alive\r\n\r\n"
-
-
-def read_chunked(sock, deadline, on_line):
-    """Decode HTTP chunked transfer encoding and feed complete event-stream lines to on_line."""
-    buf = b""
-    body = b""
-    headers_done = False
-    sock.settimeout(1.0)
-    while time.monotonic() < deadline:
-        try:
-            data = sock.recv(65536)
-        except TimeoutError:
-            continue
-        if not data:
-            return "closed"
-        buf += data
-        if not headers_done:
-            i = buf.find(b"\r\n\r\n")
-            if i < 0:
-                continue
-            headers_done = True
-            buf = buf[i + 4 :]
-        while True:
-            i = buf.find(b"\r\n")
-            if i < 0:
-                break
-            size = int(buf[:i].split(b";")[0], 16)
-            if len(buf) < i + 2 + size + 2:
-                break
-            body += buf[i + 2 : i + 2 + size]
-            buf = buf[i + 2 + size + 2 :]
-            if size == 0:
-                return "closed"
-        while b"\n" in body:
-            line, body = body.split(b"\n", 1)
-            on_line(line.rstrip(b"\r"))
-    return "deadline"
-
-
-class Client(threading.Thread):
-    def __init__(self, idx, seconds):
-        super().__init__(daemon=True)
-        self.idx = idx
-        self.seconds = seconds
-        self.events = Counter()
-        self.ids = Counter()
-        self.invalid = 0
-        self.max_data = 0
-        self.bytes = 0
-        self.end = "?"
-        self.cur_event = None
-
-    def on_line(self, line):
-        self.bytes += len(line) + 1
-        if line.startswith(b"event:"):
-            self.cur_event = line[6:].strip().decode()
-        elif line.startswith(b"data:"):
-            ev = self.cur_event or "message"
-            self.events[ev] += 1
-            data = line[5:].strip()
-            self.max_data = max(self.max_data, len(data))
-            if ev in ("state", "state_detail_all"):
-                try:
-                    obj = json.loads(data)
-                    self.ids[obj.get("id", "?")] += 1
-                except ValueError:
-                    self.invalid += 1
-        elif line == b"":
-            self.cur_event = None
-
-    def run(self):
-        try:
-            s = socket.create_connection((args.host, 80), timeout=5)
-            s.sendall(REQ % args.host.encode())
-            self.end = read_chunked(s, time.monotonic() + self.seconds, self.on_line)
-            s.close()
-        except (OSError, ValueError) as e:
-            self.end = f"error: {e}"
-
-
-clients = [Client(i, args.seconds) for i in range(args.clients)]
-for c in clients:
-    c.start()
-    time.sleep(0.3)
-
-stall_sock = None
-if args.stall:
-    # The window scale is negotiated in the SYN, so the small buffer must be set before connect()
-    stall_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    stall_sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2048)
-    stall_sock.settimeout(5)
-    stall_sock.connect((args.host, 80))
-    stall_sock.sendall(REQ % args.host.encode())
-    print("stalled client opened (never reads)", flush=True)
-
-churn_done = 0
-for _ in range(args.churn):
-    try:
-        cs = socket.create_connection((args.host, 80), timeout=5)
-        cs.sendall(REQ % args.host.encode())
-        cs.settimeout(1.0)
-        with contextlib.suppress(TimeoutError):
-            cs.recv(4096)
-        cs.setsockopt(
-            socket.SOL_SOCKET, socket.SO_LINGER, b"\x01\x00\x00\x00\x00\x00\x00\x00"
-        )  # RST on close
-        cs.close()
-        churn_done += 1
-    except OSError as e:
-        print("churn error", e, flush=True)
-    time.sleep(2)
-if args.churn:
-    print(f"churn: {churn_done}/{args.churn} abrupt closes", flush=True)
-
-for c in clients:
-    c.join()
-stall_closed = None
-if stall_sock is not None:
-    # Drain what the small buffer holds: a close shows as b"" or a reset after it. A session the device left
-    # open keeps feeding events, so the drain has its own deadline and data past it means "still open".
-    stall_sock.settimeout(2.0)
-    drain_deadline = time.monotonic() + 5.0
-    try:
-        while stall_sock.recv(65536):
-            if time.monotonic() > drain_deadline:
-                break
-        else:
-            stall_closed = True
-    except TimeoutError:
-        pass
-    except OSError:
-        stall_closed = True
-    if stall_closed is None:
-        stall_closed = False
-    print(
-        "stalled client: closed by device"
-        if stall_closed
-        else "stalled client: still open",
-        flush=True,
-    )
-    stall_sock.close()
-
-for c in clients:
-    states = c.events["state"]
-    print(
-        f"client {c.idx}: {c.end}, {states} state events, {c.invalid} invalid JSON, max data {c.max_data} B, "
-        f"{c.bytes} B, other events { {k: v for k, v in c.events.items() if k != 'state'} }",
-        flush=True,
-    )
-    print("  per id:", dict(sorted(c.ids.items())), flush=True)
-
-failed = [
-    c for c in clients if c.end != "deadline" or c.invalid or not c.events["state"]
-]
-if failed:
-    sys.exit(
-        f"{len(failed)} client(s) did not run clean to the deadline with valid state events"
-    )
-if stall_closed is False:
-    sys.exit("stalled session was not closed by the device")
-if churn_done < args.churn:
-    sys.exit(f"only {churn_done} of {args.churn} churn connections were made")

.agents/skills/hardware-test/scripts/web_server/sse_cases.sh

@@ -1,19 +0,0 @@
-#!/bin/sh
-# sse_cases.sh HOST KEY LABEL CAPTURE : the SSE cases against templates/web-server-sse-dut.yaml with a console capture
-# running into CAPTURE; KEY is the API key (- for plaintext). The burst client output goes to the working directory.
-H=$1; K=$2; LABEL=$3; LOG=$4; PY=${PYTHON:-python3}; HERE=$(dirname "$0"); BTN=$HERE/../api_button.py
-[ -r "$LOG" ] || { echo "usage: sse_cases.sh HOST KEY LABEL CAPTURE (CAPTURE must be a readable file)"; exit 2; }
-show() { tail -n +$(($1+1)) "$LOG" | sed 's/\x1b\[[0-9;]*m//g' | grep -a '\[probe:\|\[W\]\|\[E\]\|web_server\|Guru\|abort\|Backtrace\|ESPHome version' | grep -a -v 'took a long time' | cut -c1-200; }
-step() { n0=$(wc -l < "$LOG"); echo "=== $LABEL: $1 ($(date +%T))"; shift; "$@" || { rc=$?; echo "client failed ($rc), aborting"; exit $rc; }; echo "--- device log:"; show "$n0"; }
-step "idle 15 s, no client" sleep 15
-step "1 client 60 s" $PY "$HERE/sse.py" "$H" 60 --clients 1
-step "4 clients 60 s" $PY "$HERE/sse.py" "$H" 60 --clients 4
-step "1 reader plus a stalled client 45 s" $PY "$HERE/sse.py" "$H" 45 --clients 1 --stall
-step "1 reader plus 10 abrupt closes 30 s" $PY "$HERE/sse.py" "$H" 30 --clients 1 --churn 10
-n0=$(wc -l < "$LOG"); echo "=== $LABEL: 2 clients 25 s with the Burst button at 5 s ($(date +%T))"
-$PY "$HERE/sse.py" "$H" 25 --clients 2 > "$PWD/burst-$LABEL.txt" 2>&1 &
-pid=$!
-sleep 5; $PY "$BTN" "$H" "$K" press "Burst" || { echo "button press failed"; exit 1; }
-wait $pid || { cat "$PWD/burst-$LABEL.txt"; echo "SSE clients failed during the burst"; exit 1; }
-cat "$PWD/burst-$LABEL.txt"; echo "--- device log:"; show "$n0"
-step "idle 15 s after" sleep 15

.agents/skills/hardware-test/scripts/web_server/ssecurl.sh

@@ -1,25 +0,0 @@
-#!/bin/sh
-# ssecurl.sh HOST USER PASS SECONDS OUT : one authenticated SSE client through curl; counts state events and checks JSON
-H=$1; U=$2; P=$3; T=$4; OUT=$5
-timeout "$T" curl -sS -f -N -u "$U:$P" --anyauth "http://$H/events" > "$OUT"; rc=$?
-[ "$rc" = 124 ] || { echo "sse: curl ended with status $rc before the $T s deadline"; exit 1; }
-python3 - "$OUT" <<'PY'
-import json, sys
-states = invalid = 0; biggest = 0; ev = None
-data = open(sys.argv[1], "rb").read()
-lines = data.split(b"\n")
-if not data.endswith(b"\n"):
-    lines = lines[:-1]  # the deadline can cut the last line in half; only complete lines are checked
-for line in lines:
-    line = line.rstrip(b"\r")
-    if line.startswith(b"event:"):
-        ev = line[6:].strip()
-    elif line.startswith(b"data:") and ev == b"state":
-        states += 1; d = line[5:].strip(); biggest = max(biggest, len(d))
-        try: json.loads(d)
-        except ValueError: invalid += 1
-    elif line == b"":
-        ev = None
-print(f"sse: {states} state events, {invalid} invalid JSON, largest {biggest} B")
-sys.exit(1 if invalid or not states else 0)
-PY

.agents/skills/hardware-test/templates/api-actions-dut.yaml

@@ -1,65 +0,0 @@
-esphome:
-  name: ${name}
-
-esp8266:
-  board: d1_mini
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-logger:
-  level: DEBUG
-
-api:
-  reboot_timeout: 0s
-  actions:
-    - action: play_buzzer
-      description: Play a song or build one from parts
-      variables:
-        song_str:
-          type: string
-          description: Full RTTTL string
-          example: "scale:d=4,o=5,b=100:c,d,e"
-          required: false
-        notes:
-          type: string
-          required: false
-        octave:
-          type: int
-          default: 5
-        bpm:
-          type: int
-          default: 100
-        tempo:
-          type: float
-          default: 1.5
-        loud:
-          type: bool
-          default: true
-        label:
-          type: string
-          default: ""
-      then:
-        - lambda: |-
-            char s[40], n[40], l[40];
-            snprintf(s, sizeof(s), "%.*s", (int) song_str.size(), song_str.c_str());
-            snprintf(n, sizeof(n), "%.*s", (int) notes.size(), notes.c_str());
-            snprintf(l, sizeof(l), "%.*s", (int) label.size(), label.c_str());
-            ESP_LOGD("main", "play_buzzer song=%s(%d) notes=%s(%d) octave=%d bpm=%d tempo=%.1f loud=%d label=%s(%d)", s,
-                     (int) song_str.size(), n, (int) notes.size(), octave, bpm, tempo, loud, l, (int) label.size());
-    - action: plain_action
-      variables:
-        value: int
-      then:
-        - logger.log:
-            format: "plain_action value=%d"
-            args: ["value"]
-    - action: list_action
-      variables:
-        values: int[]
-      then:
-        - logger.log:
-            format: "list_action n=%d"
-            args: ["values.size()"]

.agents/skills/hardware-test/templates/api-actions-strings-dut.yaml

@@ -1,28 +0,0 @@
-esphome:
-  name: ${name}
-
-esp8266:
-  board: d1_mini
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-logger:
-  level: DEBUG
-
-api:
-  reboot_timeout: 0s
-  actions:
-    - action: str_action
-      variables:
-        song_str: string
-        notes: string
-        octave: int
-      then:
-        - lambda: |-
-            char s[40], n[40];
-            snprintf(s, sizeof(s), "%.*s", (int) song_str.size(), song_str.c_str());
-            snprintf(n, sizeof(n), "%.*s", (int) notes.size(), notes.c_str());
-            ESP_LOGD("main", "str_action song=%s(%d) notes=%s(%d) octave=%d", s, (int) song_str.size(), n, (int) notes.size(), octave);

.agents/skills/hardware-test/templates/aux-2-preprod-speaker-player-dut.yaml

@@ -1,66 +0,0 @@
-# Needs packages/aux-2-pre-prod.yaml from NabuCasa/aux-2 at commit 283f2e64 next to this file (see
-# reference/recipes/usb_audio.md). The AUX-2 package with the package's speaker_source player swapped for the speaker
-# platform player, which is the one built on speaker/media_player/audio_pipeline.cpp, plus the task name probe.
-
-packages:
-  core: !include aux-2-pre-prod.yaml
-
-esphome:
-  name: aux-2-dut
-  name_add_mac_suffix: false
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  encryption:
-    key: !secret api_key
-
-logger:
-  level: DEBUG
-
-sendspin:
-  unpaired_access: true
-
-media_player:
-  - id: !remove external_media_player
-  - platform: speaker
-    id: speaker_media_player
-    name: Media Player
-    volume_increment: 0.05
-    volume_min: 0.4
-    volume_max: 0.85
-    announcement_pipeline:
-      speaker: announcement_resampling_speaker
-      format: FLAC
-      num_channels: 1
-      sample_rate: 48000
-    media_pipeline:
-      speaker: media_resampling_speaker
-      format: FLAC
-      num_channels: 2
-      sample_rate: 48000
-    on_announcement:
-      - mixer_speaker.apply_ducking:
-          id: media_mixing_input
-          decibel_reduction: 20
-          duration: 0.0s
-
-button:
-  - platform: template
-    name: Task names
-    on_press:
-      - lambda: |-
-          static const char *const NAMES[] = {"ann_read", "ann_decode", "med_read", "med_decode"};
-          for (const char *n : NAMES) {
-            TaskHandle_t h = xTaskGetHandle(n);
-            if (h == nullptr) {
-              ESP_LOGI("tasks", "%s: missing", n);
-            } else {
-              ESP_LOGI("tasks", "%s: found as '%s', stack high water %u", n, pcTaskGetName(h),
-                       (unsigned) uxTaskGetStackHighWaterMark(h));
-            }
-          }
-          ESP_LOGI("tasks", "internal free %u, largest block %u", (unsigned) heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
-                   (unsigned) heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));

.agents/skills/hardware-test/templates/entity-icon-dut.yaml

@@ -1,148 +0,0 @@
-# Entity icon and device class readback (esphome#21111): the per-run file supplies name and broker_ip through substitutions and includes this file as a package. Every readback path is covered: API listing, MQTT discovery, web_server JSON and dump_config. See reference/recipes/web_server.md.
-esp8266:
-  board: d1_mini
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-web_server:
-  port: 80
-
-mqtt:
-  broker: ${broker_ip}
-  reboot_timeout: 0s
-
-interval:
-  - interval: 10s
-    then:
-      - lambda: |-
-          ESP_LOGI("probe", "free heap %u, max block %u", (unsigned) ESP.getFreeHeap(), (unsigned) ESP.getMaxFreeBlockSize());
-
-esphome:
-  name: ${name}
-
-sensor:
-  - platform: template
-    name: Temp
-    id: temp
-    device_class: temperature
-    unit_of_measurement: "°C"
-    icon: mdi:thermometer
-    accuracy_decimals: 1
-    lambda: return 21.5;
-    update_interval: 30s
-  - platform: template
-    name: Long Icon
-    id: long_icon
-    icon: mdi:this-icon-name-is-exactly-sixty-three-characters-long-abcde
-    device_class: humidity
-    unit_of_measurement: "%"
-    lambda: return 40.0;
-    update_interval: 30s
-  - platform: template
-    name: Plain
-    id: plain
-    lambda: return 1.0;
-    update_interval: 30s
-  - platform: template
-    name: Hidden
-    id: hidden
-    internal: true
-    icon: mdi:eye-off
-    device_class: power
-    lambda: return 2.0;
-    update_interval: 30s
-
-binary_sensor:
-  - platform: template
-    name: Motion
-    id: motion
-    device_class: motion
-    icon: mdi:motion-sensor
-    lambda: return false;
-
-switch:
-  - platform: template
-    name: Relay
-    id: relay
-    device_class: outlet
-    icon: mdi:power-plug
-    optimistic: true
-
-button:
-  - platform: template
-    name: Reboot
-    id: reboot_btn
-    device_class: restart
-    icon: mdi:restart
-    on_press:
-      - logger.log: "Reboot pressed"
-
-text_sensor:
-  - platform: template
-    name: Version
-    id: version
-    device_class: timestamp
-    icon: mdi:tag
-    lambda: return {"2026-10-21T00:00:00+00:00"};
-    update_interval: 30s
-
-number:
-  - platform: template
-    name: Level
-    id: level
-    device_class: battery
-    icon: mdi:knob
-    unit_of_measurement: "%"
-    min_value: 0
-    max_value: 100
-    step: 1
-    optimistic: true
-    initial_value: 50
-
-select:
-  - platform: template
-    name: Mode
-    id: mode
-    icon: mdi:format-list-bulleted
-    options: [a, b, c]
-    optimistic: true
-    initial_option: a
-
-event:
-  - platform: template
-    name: Doorbell
-    id: doorbell
-    device_class: doorbell
-    icon: mdi:doorbell
-    event_types: [ring, knock]
-
-cover:
-  - platform: template
-    name: Garage
-    id: garage
-    device_class: garage
-    icon: mdi:garage
-    optimistic: true
-
-text:
-  - platform: template
-    name: Secret Note
-    id: note
-    mode: password
-    icon: mdi:form-textbox-password
-    optimistic: true
-    initial_value: "x"

.agents/skills/hardware-test/templates/ld2412-select-only-dut.yaml

@@ -1,57 +0,0 @@
-substitutions:
-  name: ld2412sel
-
-esphome:
-  name: ${name}
-
-esp32:
-  variant: esp32s3
-  board: esp32-s3-devkitc-1
-  flash_size: 8MB
-  framework:
-    type: esp-idf
-
-logger:
-  level: VERBOSE
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-uart:
-  - id: uart_ld2412
-    tx_pin: GPIO43
-    rx_pin: GPIO44
-    baud_rate: 115200
-    debug:
-      direction: BOTH
-      dummy_receiver: false
-      after:
-        timeout: 10ms
-        bytes: 120
-
-ld2412:
-  id: ld2412_radar
-  uart_id: uart_ld2412
-
-select:
-  - platform: ld2412
-    ld2412_id: ld2412_radar
-    out_pin_level:
-      name: "LD2412 Hardware output pin level"
-
-binary_sensor:
-  - platform: gpio
-    name: "LD2412 Out Pin"
-    pin: GPIO38
-  - platform: ld2412
-    ld2412_id: ld2412_radar
-    has_target:
-      name: "LD2412 Presence"

.agents/skills/hardware-test/templates/ld2450-loopback.yaml

@@ -1,258 +0,0 @@
-esphome:
-  name: ${name}
-  on_boot:
-    priority: -100
-    then:
-      - lambda: |-
-          // UART0 TX looped back into its own RX so injected frames reach the hub
-          USC0(0) |= (1 << UCLBE);
-          ESP_LOGI("harness", "UART0 loopback on");
-
-esp8266:
-  board: d1_mini
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-logger:
-  baud_rate: 0
-  level: VERBOSE
-
-uart:
-  id: radar_uart
-  tx_pin: GPIO1
-  rx_pin: GPIO3
-  baud_rate: ${baud}
-  debug:
-    direction: TX
-    dummy_receiver: false
-    after:
-      delimiter: [0x04, 0x03, 0x02, 0x01]
-
-ld2450:
-  id: radar
-  uart_id: radar_uart
-
-select:
-  - platform: ld2450
-    baud_rate:
-      name: Baud Rate
-    zone_type:
-      name: Zone Type
-
-text_sensor:
-  - platform: ld2450
-    version:
-      name: Radar Version
-    target_1:
-      direction:
-        name: T1 Direction
-    target_2:
-      direction:
-        name: T2 Direction
-    target_3:
-      direction:
-        name: T3 Direction
-
-sensor:
-  - platform: ld2450
-    target_count:
-      name: Target Count
-
-button:
-  # periodic frames: header, 3 x (x, y, speed, resolution), footer
-  - platform: template
-    name: Frame Approach
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x14, 0x00, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  - platform: template
-    name: Frame Away
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x14, 0x80, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  - platform: template
-    name: Frame Stationary
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x00, 0x00, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  - platform: template
-    name: Frame None
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  - platform: template
-    name: Frame T2 T3
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0xF4, 0x81, 0x20, 0x83, 0x1E, 0x00, 0x64, 0x00,
-                 0x2C, 0x01, 0xB0, 0x84, 0x0A, 0x80, 0x64, 0x00,
-                 0x55, 0xCC]
-  # query zone acks: header, length, command C1, status 01, 00 00, zone type, 00, 24 coordinate bytes, footer
-  - platform: template
-    name: Zone Ack Disabled
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x1E, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x04, 0x03, 0x02, 0x01]
-  - platform: template
-    name: Zone Ack Detection
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x1E, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x01, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x04, 0x03, 0x02, 0x01]
-  - platform: template
-    name: Zone Ack Filter
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x1E, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x02, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x04, 0x03, 0x02, 0x01]
-  # name based setters, the path lambdas use
-  - platform: template
-    name: Set Zone Filter By Name
-    on_press:
-      - lambda: id(radar).set_zone_type("Filter");
-  - platform: template
-    name: Set Zone Bogus By Name
-    on_press:
-      - lambda: id(radar).set_zone_type("Bogus");
-  - platform: template
-    name: Set Baud 57600 By Name
-    on_press:
-      - lambda: id(radar).set_baud_rate("57600");
-  - platform: template
-    name: Set Baud Bogus By Name
-    on_press:
-      - lambda: id(radar).set_baud_rate("Bogus");
-  # target 1 at x 772, y 258: bytes 04 03 02 01 are the command footer
-  - platform: template
-    name: Frame CmdFooter In Payload
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  # zone ack, type Detection, zone 1 x1 = 0xCC55: bytes 55 CC are the periodic footer
-  - platform: template
-    name: Zone Ack DataFooter In Payload
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x1E, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x01, 0x00,
-                 0x55, 0xCC, 0xC8, 0x00, 0xDC, 0x05, 0xB8, 0x0B, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x04, 0x03, 0x02, 0x01]
-  # zone ack, type Filter, zone 1 x1 = 0x0304 and y1 = 0x0102: bytes 04 03 02 01 are the command footer
-  - platform: template
-    name: Zone Ack CmdFooter In Payload
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xFD, 0xFC, 0xFB, 0xFA, 0x1E, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x02, 0x00,
-                 0x04, 0x03, 0x02, 0x01, 0xDC, 0x05, 0xB8, 0x0B, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x04, 0x03, 0x02, 0x01]
-  # a periodic frame cut after 12 bytes, then a complete zone ack (type Disabled, zeros)
-  - platform: template
-    name: Cut Frame Then Zone Ack
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00, 0x00, 0x00, 0xE8, 0x83, 0x14, 0x00, 0x64, 0x00,
-                 0xFD, 0xFC, 0xFB, 0xFA, 0x1E, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x04, 0x03, 0x02, 0x01]
-  # a periodic frame missing its last byte, then a complete one (target 1 moving away)
-  - platform: template
-    name: Cut Frame Then Frame
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x14, 0x00, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55,
-                 0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x14, 0x80, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  # a command header claiming a 255 byte payload, then a complete periodic frame (target 1 stationary)
-  - platform: template
-    name: Bogus Length Then Frame
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0xFD, 0xFC, 0xFB, 0xFA, 0xFF, 0x00,
-                 0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x00, 0x00, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-  # five garbage bytes, then a complete periodic frame (target 1 approaching)
-  - platform: template
-    name: Garbage Then Frame
-    on_press:
-      - uart.write:
-          id: radar_uart
-          data: [0x01, 0x02, 0x03, 0x42, 0x99,
-                 0xAA, 0xFF, 0x03, 0x00,
-                 0x00, 0x00, 0xE8, 0x83, 0x14, 0x00, 0x64, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 0x55, 0xCC]
-
-number:
-  - platform: ld2450
-    presence_timeout:
-      name: Presence Timeout
-    zone_1:
-      x1:
-        name: Z1 X1
-      y1:
-        name: Z1 Y1
-      x2:
-        name: Z1 X2
-      y2:
-        name: Z1 Y2

.agents/skills/hardware-test/templates/mqtt-tls-dut.yaml

@@ -1,99 +0,0 @@
-# MQTT TLS trust-source test (#14318, needs that PR's tree for tls and verify_ssl): one build per trust source, with
-# the name and the mqtt block edited per file (see reference/recipes/mqtt.md). Secrets: broker_ip (the local broker
-# from make_test_ca.sh), mqtt_ca, mqtt_client_cert and mqtt_client_key as block scalars from the same run.
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: VERBOSE
-  logs:
-    wifi: DEBUG
-    api: DEBUG
-    api.connection: DEBUG
-    scheduler: DEBUG
-    component: DEBUG
-    sensor: DEBUG
-    esp32: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-interval:
-  - interval: 10s
-    then:
-      - lambda: |-
-          ESP_LOGI("probe", "mqtt connected %d, internal free %u, largest block %u", id(mq).is_connected(),
-                   (unsigned) heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
-                   (unsigned) heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));
-
-sensor:
-  - platform: template
-    name: Counter
-    update_interval: 2s
-    accuracy_decimals: 0
-    lambda: |-
-      static uint32_t n = 0;
-      return n++;
-
-switch:
-  - platform: template
-    name: Relay
-    id: relay
-    optimistic: true
-    on_turn_on:
-      - logger.log: "Relay ON"
-    on_turn_off:
-      - logger.log: "Relay OFF"
-
-button:
-  - platform: template
-    name: Publish big
-    on_press:
-      - mqtt.publish:
-          topic: ${name}/big
-          payload: !lambda |-
-            return std::string(3000, 'q');
-
-substitutions:
-  name: mqtt-dut
-
-esphome:
-  name: ${name}
-
-mqtt:
-  id: mq
-  broker: !secret broker_ip        # test.mosquitto.org for the bundle run
-  # No port: it must resolve to 1883 without TLS options and to 8883 with them. Spell it out only for the
-  # client-certificate listener (8884), wss (9002) and the public bundle broker (8886).
-  # The next two lines are the own-CA build. Remove both for the broker-only build (skip_cert_cn_check alone turns
-  # TLS on), replace both with verify_ssl: false for the unverified build (the flag is rejected next to it), or with
-  # tls: true for the bundle builds (public broker, and the local one as the negative).
-  skip_cert_cn_check: true         # with the local CA: the certificate names an address
-  certificate_authority: !secret mqtt_ca
-  # client_certificate: !secret mqtt_client_cert       # with the CA, port 8884
-  # client_certificate_key: !secret mqtt_client_key
-  # transport: wss                                     # with the CA, port 9002
-  reboot_timeout: 0s
-  discovery: false
-  on_message:
-    - topic: ${name}/cmd
-      then:
-        - logger.log:
-            format: "cmd payload: %s"
-            args: ["x.c_str()"]
-  on_connect:
-    - logger.log: "MQTT on_connect"
-  on_disconnect:
-    - logger.log: "MQTT on_disconnect"

.agents/skills/hardware-test/templates/mqtt-transport-dut.yaml

@@ -1,88 +0,0 @@
-# MQTT transport test (#16056, needs that PR's tree for the transport option): one build per transport, name and mqtt block per file (see reference/recipes/mqtt.md).
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: VERBOSE
-  logs:
-    wifi: DEBUG
-    api: DEBUG
-    api.connection: DEBUG
-    scheduler: DEBUG
-    component: DEBUG
-    sensor: DEBUG
-    esp32: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-interval:
-  - interval: 10s
-    then:
-      - lambda: |-
-          ESP_LOGI("probe", "mqtt connected %d, internal free %u, largest block %u", id(mq).is_connected(),
-                   (unsigned) heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
-                   (unsigned) heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));
-
-sensor:
-  - platform: template
-    name: Counter
-    update_interval: 2s
-    accuracy_decimals: 0
-    lambda: |-
-      static uint32_t n = 0;
-      return n++;
-
-switch:
-  - platform: template
-    name: Relay
-    id: relay
-    optimistic: true
-    on_turn_on:
-      - logger.log: "Relay ON"
-    on_turn_off:
-      - logger.log: "Relay OFF"
-
-button:
-  - platform: template
-    name: Publish big
-    on_press:
-      - mqtt.publish:
-          topic: ${name}/big
-          payload: !lambda |-
-            return std::string(3000, 'q');
-
-substitutions:
-  name: mqtt-dut
-
-esphome:
-  name: ${name}
-
-mqtt:
-  id: mq
-  broker: !secret broker_ip        # test.mosquitto.org for the public bundle run
-  port: 9002                       # 1883 tcp, 9001 ws, 9002 wss, 8081 public wss
-  transport: wss                   # drop for tcp
-  ws_path: /mqtt                   # ws and wss only
-  certificate_authority: !secret mqtt_ca   # drop for the bundle runs
-  skip_cert_cn_check: true         # with the local CA only: the certificate names an address
-  reboot_timeout: 0s
-  discovery: false
-  on_message:
-    - topic: ${name}/cmd
-      then:
-        - logger.log:
-            format: "cmd payload: %s"
-            args: ["x.c_str()"]

.agents/skills/hardware-test/templates/udp-write-dut.yaml

@@ -1,93 +0,0 @@
-# udp.write payload shapes (#21263): every shape the action takes behind a template button, plus an on_receive that
-# replies with the received bytes reversed through a lambda. Per run file: substitutions name and listener_ip (the test
-# host that runs scripts/udp/udp_listen.py), then packages: common: !include this file. Drive it with
-# scripts/udp/write_cases.sh DEVICE_IP KEY, which presses the buttons, sends the echo datagram and checks every payload.
-esp8266:
-  board: d1_mini
-
-logger:
-  level: VERBOSE
-  logs:
-    wifi: DEBUG
-    api: DEBUG
-    api.connection: DEBUG
-    scheduler: DEBUG
-    component: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-interval:
-  - interval: 10s
-    then:
-      - lambda: |-
-          ESP_LOGI("probe", "free heap %u, max block %u", (unsigned) ESP.getFreeHeap(), (unsigned) ESP.getMaxFreeBlockSize());
-
-esphome:
-  name: ${name}
-
-udp:
-  id: u
-  addresses:
-    - ${listener_ip}
-  on_receive:
-    - lambda: ESP_LOGI("echo", "received %u bytes", (unsigned) data.size());
-    - udp.write: !lambda |-
-        std::vector<uint8_t> v(data.rbegin(), data.rend());
-        return v;
-
-button:
-  - platform: template
-    name: Small
-    on_press:
-      - logger.log: "case small"
-      - udp.write: [0xAA, 0x55, 0x01, 0x02]
-      - udp.write: [0xAA, 0x55, 0x01, 0x02]
-  - platform: template
-    name: Simple
-    on_press:
-      - logger.log: "case simple"
-      - udp.write: [1, 2, 3]
-  - platform: template
-    name: Text
-    on_press:
-      - logger.log: "case text"
-      - udp.write: "hello udp"
-  - platform: template
-    name: Empty
-    on_press:
-      - logger.log: "case empty"
-      - udp.write: []
-  - platform: template
-    name: Stack128
-    on_press:
-      - logger.log: "case stack128"
-      - udp.write: [0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F]
-  - platform: template
-    name: Heap129
-    on_press:
-      - logger.log: "case heap129"
-      - udp.write: [0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0]
-  - platform: template
-    name: Heap600
-    on_press:
-      - logger.log: "case heap600"
-      - udp.write: [0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87]
-  - platform: template
-    name: Lambda300
-    on_press:
-      - logger.log: "case lambda300"
-      - udp.write: !lambda |-
-          std::vector<uint8_t> v(300);
-          for (size_t i = 0; i < v.size(); i++) v[i] = (uint8_t) (i * 7);
-          return v;

.agents/skills/hardware-test/templates/web-server-sse-dut.yaml

@@ -1,136 +0,0 @@
-# web_server_idf state SSE and HTTPD task stress (#21109, #21038). Add `auth:` with `type: digest` for the HTTPD
-# stack case; the entity endpoints are named after the entities (/sensor/Fast%201, /switch/Toggle/toggle).
-esphome:
-  name: web-server-dut
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-  power_save_mode: none
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-web_server:
-  port: 80
-  version: 3
-
-# Stack and heap probe from the main loop task (loopTask) and the HTTPD task.
-interval:
-  - interval: 5s
-    then:
-      - lambda: |-
-          TaskHandle_t httpd = xTaskGetHandle("httpd");
-          if (httpd == nullptr) {
-            ESP_LOGW("probe", "httpd task not found, loopTask min free stack %u",
-                     (unsigned) uxTaskGetStackHighWaterMark(nullptr));
-            return;
-          }
-          ESP_LOGI("probe", "loopTask min free stack %u, httpd min free stack %u, internal free %u, largest block %u",
-                   (unsigned) uxTaskGetStackHighWaterMark(nullptr), (unsigned) uxTaskGetStackHighWaterMark(httpd),
-                   (unsigned) heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
-                   (unsigned) heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));
-
-# Small state events: eight sensors at 200 ms, well under the 1024 byte stack buffer.
-sensor:
-  - platform: template
-    name: Fast 1
-    id: fast1
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 2
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 3
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 4
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 5
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 6
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 7
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-  - platform: template
-    name: Fast 8
-    update_interval: 200ms
-    accuracy_decimals: 3
-    lambda: return random_float() * 100.0f;
-
-# Large state events: the text sensor JSON carries the string twice (value and state).
-# mid ~1.3 kB goes to the 2048 byte tail, big ~3.7 kB grows the tail to 4096, huge ~5.7 kB exceeds the
-# 5120 byte JSON room and must be dropped with "State event does not fit".
-text_sensor:
-  - platform: template
-    name: Mid
-    id: mid
-    update_interval: 1s
-    lambda: |-
-      static uint32_t n = 0;
-      std::string s = std::to_string(n++) + ":";
-      s.append(600 - s.size(), 'm');
-      return s;
-  - platform: template
-    name: Big
-    id: big
-    update_interval: 2s
-    lambda: |-
-      static uint32_t n = 0;
-      std::string s = std::to_string(n++) + ":";
-      s.append(1800 - s.size(), 'b');
-      return s;
-  - platform: template
-    name: Huge
-    id: huge
-    update_interval: 7s
-    lambda: |-
-      static uint32_t n = 0;
-      std::string s = std::to_string(n++) + ":";
-      s.append(2800 - s.size(), 'h');
-      return s;
-
-switch:
-  - platform: template
-    name: Toggle
-    optimistic: true
-
-button:
-  - platform: template
-    name: Burst
-    on_press:
-      - lambda: |-
-          for (int i = 0; i < 50; i++) {
-            id(fast1).publish_state(i);
-            id(mid).publish_state(std::string(600, 'x'));
-          }

.agents/skills/hardware-test/templates/wisp-client.yaml

@@ -1,57 +0,0 @@
-substitutions:
-  name: wispcli
-  ap_ssid: wisp-bridge
-
-esphome:
-  name: ${name}
-
-esp8266:
-  board: d1_mini
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: ${ap_ssid}
-  password: !secret wisp_psk
-  power_save_mode: none
-  reboot_timeout: 0s
-
-http_request:
-  esp8266_disable_ssl_support: true
-  timeout: 8s
-
-time:
-  - platform: sntp
-    id: sntp_time
-    on_time_sync:
-      - logger.log:
-          format: "SNTP synced"
-          level: INFO
-
-interval:
-  - interval: 15s
-    then:
-      - http_request.get:
-          url: !secret lan_http
-          capture_response: true
-          on_response:
-            - logger.log:
-                format: "LAN GET status %d body %s"
-                args: ["response->status_code", "body.c_str()"]
-                level: INFO
-          on_error:
-            - logger.log:
-                format: "LAN GET failed"
-                level: WARN
-      - http_request.get:
-          url: http://example.com/
-          on_response:
-            - logger.log:
-                format: "WAN GET status %d"
-                args: ["response->status_code"]
-                level: INFO
-          on_error:
-            - logger.log:
-                format: "WAN GET failed"
-                level: WARN

.agents/skills/hardware-test/templates/wisp-ethernet-dut.yaml

@@ -1,40 +0,0 @@
-substitutions:
-  name: wispeth
-  ap_ssid: wisp-bridge
-
-esphome:
-  name: ${name}
-
-esp32:
-  board: esp32-s3-devkitc-1
-  variant: esp32s3
-  flash_size: 16MB
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-  level: VERBOSE
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-ethernet:
-  type: W5500
-  clk_pin: GPIO13
-  mosi_pin: GPIO11
-  miso_pin: GPIO12
-  cs_pin: GPIO14
-  interrupt_pin: GPIO10
-  reset_pin: GPIO9
-
-wifi:
-  ap:
-    ssid: ${ap_ssid}
-    password: !secret wisp_psk
-    ap_mode: WISP

.clang-tidy

@@ -12,7 +12,6 @@ Checks: >-
   -bugprone-multi-level-implicit-pointer-conversion,
   -bugprone-narrowing-conversions,
   -bugprone-tagged-union-member-count,
-  -bugprone-signed-bitwise,
   -bugprone-signed-char-misuse,
   -bugprone-switch-missing-default-case,
   -cert-dcl50-cpp,
@@ -40,7 +39,6 @@ Checks: >-
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-avoid-do-while,
   -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-explicit-constructor,
   -cppcoreguidelines-init-variables,
   -cppcoreguidelines-macro-to-enum,
   -cppcoreguidelines-macro-usage,
@@ -86,7 +84,6 @@ Checks: >-
   -llvm-use-ranges,
   -llvmlibc-*,
   -misc-const-correctness,
-  -misc-explicit-constructor,
   -misc-include-cleaner,
   -misc-multiple-inheritance,
   -misc-no-recursion,
@@ -116,7 +113,6 @@ Checks: >-
   -objc-*,
   -performance-enum-size,
   -portability-avoid-pragma-once,
-  -portability-no-assembler,
   -portability-template-virtual-member-function,
   -readability-ambiguous-smartptr-reset-call,
   -readability-avoid-nested-conditional-operator,
@@ -133,13 +129,9 @@ Checks: >-
   -readability-named-parameter,
   -readability-redundant-casting,
   -readability-redundant-inline-specifier,
-  -readability-redundant-lambda-parameter-list,
   -readability-redundant-member-init,
-  -readability-redundant-nested-if,
   -readability-redundant-parentheses,
   -readability-redundant-typename,
-  -readability-trailing-comma,
-  -readability-trivial-switch,
   -readability-uppercase-literal-suffix,
   -readability-use-anyofallof,
   -readability-use-std-min-max,

.coveragerc

@@ -2,6 +2,4 @@
 omit =
     esphome/components/*
     esphome/analyze_memory/*
-    esphome/espidf/get_idf_tool_paths.py
-    esphome/espidf/get_idf_version.py
     tests/integration/*

.github/scripts/auto-label-pr/constants.js

@@ -21,7 +21,6 @@ module.exports = {
     'github-actions',
     'by-code-owner',
     'has-tests',
-    'api.proto',
     'needs-tests',
     'needs-docs',
     'needs-developer-docs',

.github/scripts/auto-label-pr/detectors.js

@@ -272,18 +272,6 @@ async function detectTests(changedFiles) {
   return labels;
 }
 
-// Strategy: API protocol change detection
-// aioesphomeapi carries copies of both files, so every change here needs a sync there
-const API_PROTO_FILES = ['esphome/components/api/api.proto', 'esphome/components/api/api_options.proto'];
-
-async function detectApiProto(changedFiles) {
-  const labels = new Set();
-  if (changedFiles.some(file => API_PROTO_FILES.includes(file))) {
-    labels.add('api.proto');
-  }
-  return labels;
-}
-
 // Strategy: PR Template Checkbox detection
 async function detectPRTemplateCheckboxes(context) {
   const labels = new Set();
@@ -472,7 +460,6 @@ module.exports = {
   detectGitHubActionsChanges,
   detectCodeOwner,
   detectTests,
-  detectApiProto,
   detectPRTemplateCheckboxes,
   detectDeprecatedComponents,
   detectMaintainerAccess,

.github/scripts/auto-label-pr/index.js

@@ -10,7 +10,6 @@ const {
   detectGitHubActionsChanges,
   detectCodeOwner,
   detectTests,
-  detectApiProto,
   detectPRTemplateCheckboxes,
   detectDeprecatedComponents,
   detectMaintainerAccess,
@@ -115,7 +114,6 @@ module.exports = async ({ github, context }) => {
     actionsLabels,
     codeOwnerLabels,
     testLabels,
-    apiProtoLabels,
     checkboxLabels,
     deprecatedResult,
     maintainerAccess
@@ -130,7 +128,6 @@ module.exports = async ({ github, context }) => {
     detectGitHubActionsChanges(changedFiles),
     detectCodeOwner(github, context, changedFiles),
     detectTests(changedFiles),
-    detectApiProto(changedFiles),
     detectPRTemplateCheckboxes(context),
     detectDeprecatedComponents(github, context, changedFiles),
     detectMaintainerAccess(context)
@@ -159,7 +156,6 @@ module.exports = async ({ github, context }) => {
     ...actionsLabels,
     ...codeOwnerLabels,
     ...testLabels,
-    ...apiProtoLabels,
     ...checkboxLabels,
     ...deprecatedLabels
   ]);

.github/scripts/auto-label-pr/tests/detectors.test.js

@@ -1,7 +1,6 @@
 const { describe, it } = require('node:test');
 const assert = require('node:assert/strict');
 const {
-  detectApiProto,
   detectMergeBranch,
   detectNewPlatforms,
   detectNewComponents,
@@ -376,27 +375,6 @@ describe('detectRequirements', () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// detectApiProto
-// ---------------------------------------------------------------------------
-
-describe('detectApiProto', () => {
-  it('labels a PR that changes api.proto', async () => {
-    const labels = await detectApiProto(['esphome/components/api/api.proto', 'esphome/components/api/api_pb2.cpp']);
-    assert.deepEqual(Array.from(labels), ['api.proto']);
-  });
-
-  it('labels a PR that changes only api_options.proto', async () => {
-    const labels = await detectApiProto(['esphome/components/api/api_options.proto']);
-    assert.deepEqual(Array.from(labels), ['api.proto']);
-  });
-
-  it('ignores the generated protocol files and other components', async () => {
-    const labels = await detectApiProto(['esphome/components/api/api_pb2.cpp', 'esphome/components/uart/api.proto']);
-    assert.equal(labels.size, 0);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // MANAGED_LABELS
 // ---------------------------------------------------------------------------
@@ -409,10 +387,6 @@ describe('MANAGED_LABELS', () => {
   it('includes needs-developer-docs so the workflow syncs it', () => {
     assert.ok(MANAGED_LABELS.includes('needs-developer-docs'));
   });
-
-  it('includes api.proto so the workflow removes it when the file drops out of the diff', () => {
-    assert.ok(MANAGED_LABELS.includes('api.proto'));
-  });
 });
 
 // ---------------------------------------------------------------------------

.github/workflows/ci.yml

@@ -286,7 +286,7 @@ jobs:
           fi
           echo "version=$version" >> "$GITHUB_OUTPUT"
       - name: Run prek
-        uses: j178/prek-action@af4d4fcb6922b8e6f65c0426947125fcc38794ce # v3.0.2
+        uses: j178/prek-action@1382ad72dea72f9d53832f2bcb65b3e87a947204 # v3.0.1
         with:
           prek-version: ${{ steps.prek.outputs.version }}
           # This job only runs on pull requests, so nothing ever populates
@@ -1007,19 +1007,19 @@ jobs:
           - id: clang-tidy
             name: Run script/clang-tidy for ESP32 S3
             # yamllint disable-line rule:line-length
-            options: --environment esp32s3-idf-tidy --grep SOC_TEMP_SENSOR_SUPPORTED --grep SOC_RISCV_COPROC_SUPPORTED --grep USE_ESP32_VARIANT_ESP32S3 --grep USE_LOGGER_USB_CDC --grep SOC_I2S_SUPPORTS_TDM --grep USE_OPENTHREAD
+            options: --environment esp32s3-idf-tidy --grep SOC_TEMP_SENSOR_SUPPORTED --grep USE_ESP32_VARIANT_ESP32S3 --grep USE_LOGGER_USB_CDC --grep SOC_I2S_SUPPORTS_TDM --grep USE_OPENTHREAD
             tidy_environment: esp32s3-idf-tidy
           - id: clang-tidy
             name: Run script/clang-tidy for ESP32 P4
             # P4 has no native Wi-Fi/BLE; those run over the hosted co-processor,
             # so their code paths differ -- lint them under the P4 build too.
             # yamllint disable-line rule:line-length
-            options: --environment esp32p4-idf-tidy --grep USE_ESP32_VARIANT_ESP32P4 --grep SOC_LP_CORE_SUPPORTED --grep CONFIG_IDF_TARGET_ESP32P4 --grep USE_ESP32_HOSTED --grep USE_WIFI --grep USE_BLE
+            options: --environment esp32p4-idf-tidy --grep USE_ESP32_VARIANT_ESP32P4 --grep CONFIG_IDF_TARGET_ESP32P4 --grep USE_ESP32_HOSTED --grep USE_WIFI --grep USE_BLE
             tidy_environment: esp32p4-idf-tidy
           - id: clang-tidy
             name: Run script/clang-tidy for ESP32 C6
             # yamllint disable-line rule:line-length
-            options: --environment esp32c6-idf-tidy --grep SOC_LP_I2C_SUPPORTED --grep SOC_LP_CORE_SUPPORTED --grep USE_ESP32_VARIANT_ESP32C6 --grep USE_OPENTHREAD --grep USE_ZIGBEE
+            options: --environment esp32c6-idf-tidy --grep SOC_LP_I2C_SUPPORTED --grep USE_ESP32_VARIANT_ESP32C6 --grep USE_OPENTHREAD --grep USE_ZIGBEE
             tidy_environment: esp32c6-idf-tidy
 
     steps:

.pre-commit-config.yaml

@@ -38,7 +38,7 @@ repos:
       - id: yamllint
         exclude: ^(\.clang-format|\.clang-tidy)$
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v23.1.3
+    rev: v13.0.1
     hooks:
       - id: clang-format
         types_or: [c, c++]

AGENTS.md

@@ -205,16 +205,15 @@ file does, and it is the authority when they disagree. The most useful starting
         for a table of structs copy the whole entry out and return the copy, never a pointer into flash.
         On other platforms they are a plain `memcpy` and dereference, so no `#ifdef` is needed. Declare log tags with
         `ESPHOME_LOG_TAG(TAG, "name")`, pass status text as `LOG_STR`, e.g.
-        `this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL))`. An action that only forwards a byte payload is
-        registered with `automation.ApplyBytes` (see Actions below), which keeps a constant payload in flash;
-        `TEMPLATABLE_BYTES` is for a `play()` that does more with the bytes.
+        `this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL))`, and give an action whose payload is a byte array
+        a `TEMPLATABLE_BYTES` field so a static code stays in flash.
     *   **Fixed sets of names** (status words, model names): a `PROGMEM_STRING_TABLE` (`esphome/core/progmem.h`),
         logged with `get_log_str` and `LOG_STR_ARG`, copied out with `ESPHOME_strncpy_P` before `publish_state`.
         A `dump_config` helper that picks a name returns `const LogString *` from `LOG_STR(...)`.
     *   **CRCs and bit tricks** come from `esphome/core/helpers.h` (`crc8`, `crc16`, `xor_bytes`, `sum16_bytes`,
-        `reverse_bits`, `encode_uint16`, `encode_value_le`, `sign_extend<BITS>`, `bcd_to_uint8`, `assign_bits`); pick
-        the helper's arguments instead of writing a loop. 7-byte BCD RTC calendars use `time::decode_bcd_calendar<LAYOUT>`
-        and `encode_bcd_calendar<LAYOUT>` with `EPSON_BCD_CALENDAR`, `DS_BCD_CALENDAR` or `PCF_BCD_CALENDAR`.
+        `reverse_bits`, `encode_uint16`, `encode_value_le`, `sign_extend<BITS>`, `bcd_to_uint8`); pick the helper's
+        arguments instead of writing a loop. Epson style 7-byte RTC calendars (one-hot weekday) use
+        `time::decode_bcd_calendar`.
     *   **Bus helpers:** UART drains with `read_available(on_byte)` and `discard_available()`, text lines with
         `LineReader<N>`; I2C has `update_register`, `write_registers` (PROGMEM `I2CRegValue` table), `check_chip_id`
         and `read_bytes_16_le`. `if (!this->status_comm_result(ok)) return;` sets or clears the warning.
@@ -605,9 +604,7 @@ file does, and it is the authority when they disagree. The most useful starting
         )
         ```
         The `ApplyField`, `ApplyCall` and `register_apply_action` docstrings in `esphome/automation.py` cover
-        the rest; `cover.control` and `cover.template.publish` are in-tree examples. An action whose input is a
-        byte payload passes `automation.ApplyBytes(CONF_DATA, "send({})")` in the same call; a constant payload
-        stays in flash and a lambda's vector is forwarded as data and size. `TEMPLATABLE_VALUE` with
+        the rest; `cover.control` and `cover.template.publish` are in-tree examples. `TEMPLATABLE_VALUE` with
         `cg.templatable` stays for actions whose `play()` has real logic beyond forwarding values.
 
     *   **Conditions:**

CODEOWNERS

@@ -205,7 +205,6 @@ esphome/components/esp32_hosted/update/* @swoboda1337
 esphome/components/esp32_power_management/* @rwrozelle
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
-esphome/components/esp32_ulp/* @swoboda1337
 esphome/components/esp8266/* @esphome/core
 esphome/components/esp_ldo/* @clydebarrow
 esphome/components/espectre/* @francescopace
@@ -695,12 +694,9 @@ esphome/components/usb_uart/* @clydebarrow
 esphome/components/valve/* @esphome/core
 esphome/components/vbus/* @ssieb
 esphome/components/veml3235/* @kbx81
-esphome/components/veml6040/* @aalaei
 esphome/components/veml7700/* @latonita
 esphome/components/version/* @esphome/core
 esphome/components/vevor_dtx/* @Bofr5555
-esphome/components/vl53l1x/* @will-tm
-esphome/components/vnc/* @MindFreeze
 esphome/components/voice_assistant/* @jesserockz @kahrendt
 esphome/components/wake_on_lan/* @clydebarrow @willwill2will54
 esphome/components/watchdog/* @oarcher

codecov.yml

@@ -11,9 +11,6 @@ coverage:
 ignore:
   - "esphome/components/**/*"
   - "esphome/analyze_memory/**/*"
-  # Run as standalone scripts under the ESP-IDF Python, never imported by pytest
-  - "esphome/espidf/get_idf_tool_paths.py"
-  - "esphome/espidf/get_idf_version.py"
   - "tests/integration/**/*"
 
 comment:

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.26.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.25.0
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/automation.py

@@ -24,7 +24,6 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, EsphomeError, HexInt, Lambda
 from esphome.cpp_generator import (
-    CallExpression,
     Expression,
     LambdaExpression,
     MockObj,
@@ -60,15 +59,10 @@ async def templatable_bytes(
     if cg.is_template(value):
         fn = await cg.templatable(value, args, cg.std_vector.template(cg.uint8))
         cg.add(set_template(fn))
+    elif len(value) > 0xFFFF:
+        raise EsphomeError(f"Byte payload is {len(value)} bytes; the maximum is 65535")
     else:
-        cg.add(set_static(*_static_bytes(table_name, value)))
-
-
-def _static_bytes(table_name: str, value: bytes | list[int]) -> tuple[MockObj, int]:
-    """The shared PROGMEM table for a constant payload and its length."""
-    if (size := len(value)) > 0xFFFF:
-        raise EsphomeError(f"Byte payload is {size} bytes; the maximum is 65535")
-    return progmem_bytes(table_name, value), size
+        cg.add(set_static(progmem_bytes(table_name, value), len(value)))
 
 
 def maybe_simple_id(*validators):
@@ -362,33 +356,6 @@ class ApplyField:
         return ApplyCall(target, ((self.conf_key, self.type_, self.const_fn),))
 
 
-@dataclass(frozen=True)
-class ApplyBytes:
-    """A byte payload key forwarded as ``target``, whose ``{}`` stands for ``data, len``.
-
-    A constant payload is a shared PROGMEM table passed as is; on ESP8266 it is first copied
-    out, to the stack up to ``stack`` bytes and to the heap beyond, unless ``progmem_target``
-    names a call that reads flash itself. A lambda's ``std::vector<uint8_t>`` is passed as
-    its data and size. The template may name the parent as ``{parent}``. An absent key
-    emits nothing.
-    """
-
-    conf_key: str | tuple[str, ...]
-    target: str
-    stack: int = 64
-    progmem_target: str | None = None
-
-    def __post_init__(self) -> None:
-        for target in (self.target, self.progmem_target):
-            if target is None:
-                continue
-            fields = [
-                f for _, f, _, _ in string.Formatter().parse(target) if f is not None
-            ]
-            if fields.count("") != 1 or any(f not in ("", "parent") for f in fields):
-                raise ValueError(f"apply bytes target {target!r} needs one {{}}")
-
-
 def _config_lookup(config: ConfigType, key: str | tuple[str, ...]) -> Any:
     if isinstance(key, str):
         return config.get(key)
@@ -447,17 +414,9 @@ async def _apply_parent(config: ConfigType, id_key: str = CONF_ID) -> str:
 
 
 def _apply_lambda_args(args: TemplateArgsType) -> TemplateArgsType:
-    # The generated function's parameters: a reference keeps its spelling, so a mutable
-    # one stays mutable; a value is taken by const reference, so a std::string is never copied.
+    # The generated function's parameters; a std::string arg is never copied.
     return [
-        (
-            (
-                t
-                if str(cg.safe_exp(t)).rstrip().endswith("&")
-                else cg.RawExpression(f"const std::remove_cvref_t<{cg.safe_exp(t)}> &")
-            ),
-            arg,
-        )
+        (cg.RawExpression(f"const std::remove_cvref_t<{cg.safe_exp(t)}> &"), arg)
         for t, arg in args
     ]
 
@@ -529,7 +488,7 @@ def _apply_values(config: ConfigType, members: list[tuple[Any, Any, Any]]) -> li
 def register_apply_action(
     name: str,
     schema: cv.Schema,
-    *fields: ApplyField | ApplyCall | ApplyBytes,
+    *fields: ApplyField | ApplyCall,
     call: str | None = None,
     id_key: str = CONF_ID,
 ) -> None:
@@ -545,7 +504,7 @@ def register_apply_action(
 def apply_action_builder(
     name: str,
     schema: cv.Schema,
-    *fields: ApplyField | ApplyCall | ApplyBytes,
+    *fields: ApplyField | ApplyCall,
     call: str | None = None,
     id_key: str = CONF_ID,
 ) -> Callable[..., Awaitable[MockObj]]:
@@ -558,20 +517,17 @@ def apply_action_builder(
     and ``apply_call.perform()`` is appended.
     """
     # An action stores the value, so a std::string constant stays in flash on ESP8266.
+    statements_spec = [
+        (
+            c.target,
+            _default_std_string(c.members, flash_string),
+        )
+        for c in (f if isinstance(f, ApplyCall) else f.call() for f in fields)
+    ]
     _check_key_in_schema(name, schema, id_key)
-    statements_spec: list[ApplyBytes | tuple[str, list[tuple[Any, Any, Any]]]] = []
-    for f in fields:
-        if isinstance(f, ApplyBytes):
-            _check_key_in_schema(name, schema, f.conf_key)
-            statements_spec.append(f)
-            continue
-        c = f if isinstance(f, ApplyCall) else f.call()
-        members = _default_std_string(c.members, flash_string)
+    for _, members in statements_spec:
         for conf_key, _, _ in members:
             _check_key_in_schema(name, schema, conf_key)
-        statements_spec.append((c.target, members))
-    # Named like the generated function, so it cannot clash with an SDK symbol
-    table_name = f"esphome__{name.replace('.', '_')}__bytes"
 
     async def builder(
         config: ConfigType,
@@ -583,15 +539,7 @@ def apply_action_builder(
         lambda_args = _apply_lambda_args(args)
         receiver = "apply_call." if call else f"{parent}->"
         statements: list[str] = []
-        for spec in statements_spec:
-            if isinstance(spec, ApplyBytes):
-                statements.extend(
-                    await _render_bytes(
-                        spec, config, receiver, parent, args, table_name
-                    )
-                )
-                continue
-            target, members = spec
+        for target, members in statements_spec:
             values = _apply_values(config, members)
             if not _apply_call_active(members, values):
                 continue
@@ -612,62 +560,6 @@ def apply_action_builder(
     return builder
 
 
-async def _render_bytes(
-    spec: ApplyBytes,
-    config: ConfigType,
-    receiver: str,
-    parent: str,
-    args: TemplateArgsType,
-    table_name: str,
-) -> list[str]:
-    """The statements for one ``ApplyBytes``: what ``TemplatableBytes::visit`` does, inlined.
-
-    The payload lambda keeps the automation's own argument types, as ``TemplatableBytes``
-    gave it, and is always called, so a body that modifies an argument still compiles.
-    """
-    value = _config_lookup(config, spec.conf_key)
-    if value is None:
-        return []
-
-    # The temporary carries the generated-name prefix so a trigger argument cannot shadow it
-    def send(target: str, data: str) -> str:
-        return f"{receiver}{target.format(data, parent=parent)};"
-
-    if isinstance(value, Lambda):
-        inner = await cg.process_lambda(
-            value, args, return_type=cg.std_vector.template(cg.uint8)
-        )
-        # Never reduced into the outer function, whose own parameters are const
-        call = CallExpression(inner, *[cg.MockObj(name) for _, name in args])
-        return [
-            "{",
-            f"  const std::vector<uint8_t> esphome__bytes = {call};",
-            f"  {send(spec.target, 'esphome__bytes.data(), esphome__bytes.size()')}",
-            "}",
-        ]
-    table, size = _static_bytes(table_name, value)
-    # Qualified so a trigger argument cannot shadow a reused table; an empty payload is nullptr
-    table_args = f"::{table}, {size}" if size else f"{table}, {size}"
-    if CORE.is_esp8266 and spec.progmem_target is not None:
-        return [send(spec.progmem_target, table_args)]
-    if not CORE.is_esp8266:
-        return [send(spec.target, table_args)]
-    # A PROGMEM table must be read with aligned loads on ESP8266, so copy it out first;
-    # the length is known here, so the copy is an exact array, on the heap past ``stack``.
-    # An empty payload still gets a one byte array: the raw lwIP socket rejects a null buffer.
-    if size <= spec.stack:
-        buffer, data = f"uint8_t esphome__bytes[{max(size, 1)}];", "esphome__bytes"
-    else:
-        buffer, data = (
-            f"auto esphome__bytes = std::make_unique<uint8_t[]>({size});",
-            "esphome__bytes.get()",
-        )
-    statements = ["{", f"  {buffer}"]
-    if size:
-        statements.append(f"  esphome::progmem_memcpy({data}, {table_args});")
-    return [*statements, f"  {send(spec.target, f'{data}, {size}')}", "}"]
-
-
 def _apply_call_active(members: list[tuple[Any, Any, Any]], values: list[Any]) -> bool:
     """An ``ApplyCall`` is emitted unless it has keys and none of them is set."""
     return not members or any(value is not None for value in values)

esphome/build_gen/espidf.py

@@ -8,14 +8,12 @@ import textwrap
 
 from esphome.build_helpers import pch
 from esphome.components.esp32 import (
-    KEY_SRC_CMAKE,
     get_esp32_variant,
     get_excluded_builtin_components,
     get_managed_component_require_names,
     idf_version,
 )
 import esphome.config_validation as cv
-from esphome.const import KEY_ESP32
 from esphome.core import CORE
 from esphome.espidf import variant_to_idf_target
 from esphome.framework_helpers import (
@@ -462,7 +460,6 @@ def get_component_cmakelists() -> str:
     # get_project_cmakelists so they reach every component, not just src/.
     link_opts = get_project_link_flags()
     link_opts_str = "\n    ".join(link_opts) if link_opts else ""
-    src_cmake = "\n".join(CORE.data[KEY_ESP32].get(KEY_SRC_CMAKE, []))
 
     return f"""\
 # Auto-generated by ESPHome
@@ -508,7 +505,6 @@ idf_component_register(
 target_link_options(${{COMPONENT_LIB}} PUBLIC
     {link_opts_str}
 )
-{src_cmake}
 {_pch_cmake_block()}"""
 
 

esphome/build_helpers/tool_runner.py

@@ -111,9 +111,7 @@ class ToolOutput(RedirectText):
 
     def _emit_line(self, line: str) -> None:
         if self._progress and _PROGRESS.match(line):
-            if self._is_filtered(line):
-                self._drop_line(line)
-            else:
+            if not self._is_filtered(line):
                 text = _fit_terminal(line.strip("\r\n"))
                 self._write_color_replace(f"\r{text}\x1b[K")
                 self._on_progress_line = True

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -10,7 +10,7 @@ void AbsoluteHumidityComponent::setup() {
     this->temperature_ = state;
     this->enable_loop();
   });
-  ESP_LOGD(TAG, "  Added callback for temperature '%s'", LOG_STR_ARG(this->temperature_sensor_->get_log_name()));
+  ESP_LOGD(TAG, "  Added callback for temperature '%s'", this->temperature_sensor_->get_name().c_str());
   // Get initial value
   if (this->temperature_sensor_->has_state()) {
     this->temperature_ = this->temperature_sensor_->get_state();
@@ -20,7 +20,7 @@ void AbsoluteHumidityComponent::setup() {
     this->humidity_ = state;
     this->enable_loop();
   });
-  ESP_LOGD(TAG, "  Added callback for relative humidity '%s'", LOG_STR_ARG(this->humidity_sensor_->get_log_name()));
+  ESP_LOGD(TAG, "  Added callback for relative humidity '%s'", this->humidity_sensor_->get_name().c_str());
   // Get initial value
   if (this->humidity_sensor_->has_state()) {
     this->humidity_ = this->humidity_sensor_->get_state();
@@ -49,8 +49,7 @@ void AbsoluteHumidityComponent::dump_config() {
                 "Sources\n"
                 "  Temperature: '%s'\n"
                 "  Relative Humidity: '%s'",
-                LOG_STR_ARG(this->temperature_sensor_->get_log_name()),
-                LOG_STR_ARG(this->humidity_sensor_->get_log_name()));
+                this->temperature_sensor_->get_name().c_str(), this->humidity_sensor_->get_name().c_str());
 }
 
 void AbsoluteHumidityComponent::loop() {

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -184,9 +184,11 @@ void AcDimmer::setup() {
   this->store_.zero_cross_pin_number = this->zero_cross_pin_->get_pin();
   this->store_.min_power = static_cast<uint16_t>(this->min_power_ * 1000);
   this->min_power_ = 0;
+  this->store_.method = this->method_;
 
   if (setup_zero_cross_pin) {
     this->zero_cross_pin_->setup();
+    this->store_.zero_cross_pin = this->zero_cross_pin_->to_isr();
     this->zero_cross_pin_->attach_interrupt(&AcDimmerDataStore::s_gpio_intr, &this->store_,
                                             this->zero_cross_interrupt_type_);
   }
@@ -225,18 +227,24 @@ void AcDimmer::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "AcDimmer:\n"
                 "  Min Power: %.1f%%\n"
-                "  Init with half cycle: %s\n"
-                "  Interrupt Type: %s\n"
-                "  Method: %s",
-                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_),
-                this->zero_cross_interrupt_type_ == gpio::INTERRUPT_RISING_EDGE    ? LOG_STR_LITERAL("rising")
-                : this->zero_cross_interrupt_type_ == gpio::INTERRUPT_FALLING_EDGE ? LOG_STR_LITERAL("falling")
-                                                                                   : LOG_STR_LITERAL("any"),
-                this->store_.method == DIM_METHOD_LEADING_PULSE ? LOG_STR_LITERAL("leading pulse")
-                : this->store_.method == DIM_METHOD_LEADING     ? LOG_STR_LITERAL("leading")
-                                                                : LOG_STR_LITERAL("trailing"));
+                "  Init with half cycle: %s",
+                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
   LOG_PIN("  Output Pin: ", this->gate_pin_);
   LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
+  if (this->zero_cross_interrupt_type_ == gpio::INTERRUPT_RISING_EDGE) {
+    ESP_LOGCONFIG(TAG, "  Interrupt Type: rising");
+  } else if (this->zero_cross_interrupt_type_ == gpio::INTERRUPT_FALLING_EDGE) {
+    ESP_LOGCONFIG(TAG, "  Interrupt Type: falling");
+  } else {
+    ESP_LOGCONFIG(TAG, "  Interrupt Type: any");
+  }
+  if (method_ == DIM_METHOD_LEADING_PULSE) {
+    ESP_LOGCONFIG(TAG, "  Method: leading pulse");
+  } else if (method_ == DIM_METHOD_LEADING) {
+    ESP_LOGCONFIG(TAG, "  Method: leading");
+  } else {
+    ESP_LOGCONFIG(TAG, "  Method: trailing");
+  }
   LOG_FLOAT_OUTPUT(this);
   ESP_LOGV(TAG, "  Estimated Frequency: %.3fHz", 1e6f / this->store_.cycle_time_us / 2);
 }

esphome/components/ac_dimmer/ac_dimmer.h

@@ -6,11 +6,19 @@
 
 namespace esphome::ac_dimmer {
 
-enum DimMethod : uint8_t { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TRAILING };
+enum DimMethod { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TRAILING };
 
 struct AcDimmerDataStore {
+  /// Zero-cross pin
+  ISRInternalGPIOPin zero_cross_pin;
+  /// Zero-cross pin number - used to share ZC pin across multiple dimmers
+  uint8_t zero_cross_pin_number;
   /// Output pin to write to
   ISRInternalGPIOPin gate_pin;
+  /// Value of the dimmer - 0 to 65535.
+  uint16_t value;
+  /// Minimum power for activation
+  uint16_t min_power;
   /// Time between the last two ZC pulses
   uint32_t cycle_time_us;
   /// Time (in micros()) of last ZC signal
@@ -19,12 +27,6 @@ struct AcDimmerDataStore {
   uint32_t enable_time_us;
   /// Time since last ZC pulse to disable gate pin. 0 means no disable.
   uint32_t disable_time_us;
-  /// Value of the dimmer - 0 to 65535.
-  uint16_t value;
-  /// Minimum power for activation
-  uint16_t min_power;
-  /// Zero-cross pin number - used to share ZC pin across multiple dimmers
-  uint8_t zero_cross_pin_number;
   /// Set to send the first half ac cycle complete
   bool init_cycle;
   /// Dimmer method
@@ -48,16 +50,17 @@ class AcDimmer final : public output::FloatOutput, public Component {
   void set_zero_cross_pin(InternalGPIOPin *zero_cross_pin) { zero_cross_pin_ = zero_cross_pin; }
   void set_zero_cross_interrupt_type(gpio::InterruptType type) { zero_cross_interrupt_type_ = type; }
   void set_init_with_half_cycle(bool init_with_half_cycle) { init_with_half_cycle_ = init_with_half_cycle; }
-  void set_method(DimMethod method) { this->store_.method = method; }
+  void set_method(DimMethod method) { method_ = method; }
 
  protected:
   void write_state(float state) override;
 
   InternalGPIOPin *gate_pin_;
   InternalGPIOPin *zero_cross_pin_;
-  AcDimmerDataStore store_;
   gpio::InterruptType zero_cross_interrupt_type_;
+  AcDimmerDataStore store_;
   bool init_with_half_cycle_;
+  DimMethod method_;
 };
 
 }  // namespace esphome::ac_dimmer

esphome/components/adc/adc_sensor_common.cpp

@@ -66,7 +66,7 @@ template class Aggregator<uint32_t>;
 
 void ADCSensor::update() {
   float value_v = this->sample();
-  ESP_LOGV(TAG, "'%s': Voltage=%.4fV", LOG_STR_ARG(this->get_log_name()), value_v);
+  ESP_LOGV(TAG, "'%s': Voltage=%.4fV", this->get_name().c_str(), value_v);
   this->publish_state(value_v);
 }
 

esphome/components/adc/adc_sensor_esp32.cpp

@@ -94,11 +94,11 @@ void ADCSensor::setup() {
     }
 #elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED)
     adc_cali_line_fitting_config_t cali_config = {
-        .unit_id = this->adc_unit_,
-        .atten = this->attenuation_,
-        .bitwidth = ADC_BITWIDTH_DEFAULT,
+      .unit_id = this->adc_unit_,
+      .atten = this->attenuation_,
+      .bitwidth = ADC_BITWIDTH_DEFAULT,
 #if !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
-        .default_vref = 1100,  // Default reference voltage in mV
+      .default_vref = 1100,  // Default reference voltage in mV
 #endif  // !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
     };
     err = adc_cali_create_scheme_line_fitting(&cali_config, &handle);
@@ -248,11 +248,11 @@ float ADCSensor::sample_autorange_() {
               (err == ESP_OK) ? "SUCCESS" : "FAILED", err);
 #elif defined(ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED)
     adc_cali_line_fitting_config_t cali_config = {
-        .unit_id = this->adc_unit_,
-        .atten = atten,
-        .bitwidth = ADC_BITWIDTH_DEFAULT,
+      .unit_id = this->adc_unit_,
+      .atten = atten,
+      .bitwidth = ADC_BITWIDTH_DEFAULT,
 #if !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
-        .default_vref = 1100,
+      .default_vref = 1100,
 #endif
     };
     err = adc_cali_create_scheme_line_fitting(&cali_config, &handle);

esphome/components/adc/adc_sensor_zephyr.cpp

@@ -111,8 +111,6 @@ static const LogString *input_to_str(uint8_t input) {
       return LOG_STR("VDD");
     case NRF_SAADC_INPUT_VDDHDIV5:
       return LOG_STR("VDDHDIV5");
-    default:
-      break;
   }
   return LOG_STR("undefined input");
 }

esphome/components/ads1115/sensor/ads1115_sensor.cpp

@@ -13,7 +13,7 @@ float ADS1115Sensor::sample() {
 void ADS1115Sensor::update() {
   float v = this->sample();
   if (!std::isnan(v)) {
-    ESP_LOGD(TAG, "'%s': Got Voltage=%fV", LOG_STR_ARG(this->get_log_name()), v);
+    ESP_LOGD(TAG, "'%s': Got Voltage=%fV", this->get_name().c_str(), v);
     this->publish_state(v);
   }
 }

esphome/components/ads1118/sensor/ads1118_sensor.cpp

@@ -21,7 +21,7 @@ float ADS1118Sensor::sample() {
 void ADS1118Sensor::update() {
   float v = this->sample();
   if (!std::isnan(v)) {
-    ESP_LOGD(TAG, "'%s': Got Voltage=%fV", LOG_STR_ARG(this->get_log_name()), v);
+    ESP_LOGD(TAG, "'%s': Got Voltage=%fV", this->get_name().c_str(), v);
     this->publish_state(v);
   }
 }

esphome/components/airton/airton.cpp

@@ -261,8 +261,6 @@ void AirtonClimate::parse_state_frame_(const uint8_t *frame) {
     case AIRTON_FAN_AUTO:
       this->fan_mode = climate::CLIMATE_FAN_AUTO;
       break;
-    default:
-      break;
   }
 
   this->target_temperature = (frame[3] & 0b00001111) + AIRTON_TEMP_MIN;

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -31,7 +31,7 @@ void AlarmControlPanel::publish_state(AlarmControlPanelState state) {
   this->last_update_ = millis();
   if (state != this->current_state_) {
     auto prev_state = this->current_state_;
-    ESP_LOGV(TAG, "'%s' >> %s (was %s)", LOG_STR_ARG(this->get_log_name()),
+    ESP_LOGV(TAG, "'%s' >> %s (was %s)", this->get_name().c_str(),
              LOG_STR_ARG(alarm_control_panel_state_to_string(state)),
              LOG_STR_ARG(alarm_control_panel_state_to_string(prev_state)));
     this->current_state_ = state;

esphome/components/am43/cover/am43_cover.cpp

@@ -30,9 +30,9 @@ void Am43Component::loop() {
     auto status =
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-    ESP_LOGI(TAG, "[%s] Logging into AM43", LOG_STR_ARG(this->get_log_name()));
+    ESP_LOGI(TAG, "[%s] Logging into AM43", this->get_name().c_str());
     if (status) {
-      ESP_LOGW(TAG, "[%s] Error writing set_pin to device, error = %d", LOG_STR_ARG(this->get_log_name()), status);
+      ESP_LOGW(TAG, "[%s] Error writing set_pin to device, error = %d", this->get_name().c_str(), status);
     } else {
       this->logged_in_ = true;
     }
@@ -50,7 +50,7 @@ CoverTraits Am43Component::get_traits() {
 
 void Am43Component::control(const CoverCall &call) {
   if (this->node_state != espbt::ClientState::ESTABLISHED) {
-    ESP_LOGW(TAG, "[%s] Cannot send cover control, not connected", LOG_STR_ARG(this->get_log_name()));
+    ESP_LOGW(TAG, "[%s] Cannot send cover control, not connected", this->get_name().c_str());
     return;
   }
   if (call.get_stop()) {
@@ -59,7 +59,7 @@ void Am43Component::control(const CoverCall &call) {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] Error writing stop command to device, error = %d", LOG_STR_ARG(this->get_log_name()), status);
+      ESP_LOGW(TAG, "[%s] Error writing stop command to device, error = %d", this->get_name().c_str(), status);
     }
   }
   auto opt_pos = call.get_position();
@@ -73,8 +73,7 @@ void Am43Component::control(const CoverCall &call) {
         esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(), this->char_handle_,
                                  packet->length, packet->data, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
     if (status) {
-      ESP_LOGW(TAG, "[%s] Error writing set_position command to device, error = %d", LOG_STR_ARG(this->get_log_name()),
-               status);
+      ESP_LOGW(TAG, "[%s] Error writing set_position command to device, error = %d", this->get_name().c_str(), status);
     }
   }
 }
@@ -90,9 +89,9 @@ void Am43Component::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       auto *chr = this->parent_->get_characteristic(AM43_SERVICE_UUID, AM43_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
         if (this->parent_->get_characteristic(AM43_TUYA_SERVICE_UUID, AM43_TUYA_CHARACTERISTIC_UUID) != nullptr) {
-          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.", LOG_STR_ARG(this->get_log_name()));
+          ESP_LOGE(TAG, "[%s] Detected a Tuya AM43 which is not supported, sorry.", this->get_name().c_str());
         } else {
-          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?", LOG_STR_ARG(this->get_log_name()));
+          ESP_LOGE(TAG, "[%s] No control service found at device, not an AM43..?", this->get_name().c_str());
         }
         break;
       }
@@ -101,8 +100,7 @@ void Am43Component::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       auto status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
                                                       chr->handle);
       if (status) {
-        ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", LOG_STR_ARG(this->get_log_name()),
-                 status);
+        ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
       }
       break;
     }
@@ -128,26 +126,25 @@ void Am43Component::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
 
       if (this->decoder_->has_pin_response()) {
         if (this->decoder_->pin_ok_) {
-          ESP_LOGI(TAG, "[%s] AM43 pin accepted.", LOG_STR_ARG(this->get_log_name()));
+          ESP_LOGI(TAG, "[%s] AM43 pin accepted.", this->get_name().c_str());
           auto *packet = this->encoder_->get_position_request();
           auto status = esp_ble_gattc_write_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
                                                  this->char_handle_, packet->length, packet->data,
                                                  ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
           if (status) {
-            ESP_LOGW(TAG, "[%s] Error writing set_position to device, error = %d", LOG_STR_ARG(this->get_log_name()),
-                     status);
+            ESP_LOGW(TAG, "[%s] Error writing set_position to device, error = %d", this->get_name().c_str(), status);
           }
         } else {
-          ESP_LOGW(TAG, "[%s] AM43 pin rejected!", LOG_STR_ARG(this->get_log_name()));
+          ESP_LOGW(TAG, "[%s] AM43 pin rejected!", this->get_name().c_str());
         }
       }
 
       if (this->decoder_->has_set_position_response() && !this->decoder_->set_position_ok_) {
-        ESP_LOGW(TAG, "[%s] Got nack after sending set_position. Bad pin?", LOG_STR_ARG(this->get_log_name()));
+        ESP_LOGW(TAG, "[%s] Got nack after sending set_position. Bad pin?", this->get_name().c_str());
       }
 
       if (this->decoder_->has_set_state_response() && !this->decoder_->set_state_ok_) {
-        ESP_LOGW(TAG, "[%s] Got nack after sending set_state. Bad pin?", LOG_STR_ARG(this->get_log_name()));
+        ESP_LOGW(TAG, "[%s] Got nack after sending set_state. Bad pin?", this->get_name().c_str());
       }
       break;
     }

esphome/components/anova/anova.cpp

@@ -67,9 +67,8 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
     case ESP_GATTC_SEARCH_CMPL_EVT: {
       auto *chr = this->parent_->get_characteristic(ANOVA_SERVICE_UUID, ANOVA_CHARACTERISTIC_UUID);
       if (chr == nullptr) {
-        ESP_LOGW(TAG, "[%s] No control service found at device, not an Anova..?", LOG_STR_ARG(this->get_log_name()));
-        ESP_LOGW(TAG, "[%s] Note, this component does not currently support Anova Nano.",
-                 LOG_STR_ARG(this->get_log_name()));
+        ESP_LOGW(TAG, "[%s] No control service found at device, not an Anova..?", this->get_name().c_str());
+        ESP_LOGW(TAG, "[%s] Note, this component does not currently support Anova Nano.", this->get_name().c_str());
         break;
       }
       this->char_handle_ = chr->handle;
@@ -77,8 +76,7 @@ void Anova::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_
       auto status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
                                                       chr->handle);
       if (status) {
-        ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", LOG_STR_ARG(this->get_log_name()),
-                 status);
+        ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
       }
       break;
     }

esphome/components/apc1/sensor.py

@@ -2,7 +2,7 @@ from esphome import automation, pins
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import sensor, uart
-from esphome.components.const import CONF_AQI, CONF_ERROR_CODE
+from esphome.components.const import CONF_AQI
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ECO2,
@@ -55,6 +55,7 @@ CONF_RAW_HUMIDITY = "raw_humidity"
 CONF_RS0 = "rs0"
 CONF_RS2 = "rs2"
 CONF_RS3 = "rs3"
+CONF_ERROR_CODE = "error_code"
 
 apc1_ns = cg.esphome_ns.namespace("apc1")
 APC1Component = apc1_ns.class_("APC1Component", uart.UARTDevice, cg.Component)

esphome/components/api/__init__.py

@@ -1,7 +1,5 @@
-from collections.abc import Callable
 from ipaddress import IPv4Address, IPv6Address
 import logging
-import math
 import re
 from typing import Any
 
@@ -9,7 +7,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components.const import CONF_DESCRIPTION, CONF_HOST
 from esphome.components.logger import request_log_listener
-from esphome.components.network import require_ipv4, require_ipv6
+from esphome.components.network import DOMAIN as NETWORK_DOMAIN
 
 # ENCRYPTION_SCHEMA and validate_encryption_key are re-exported for external
 # components and downstream consumers that import them from api
@@ -29,8 +27,8 @@ from esphome.const import (
     CONF_CAPTURE_RESPONSE,
     CONF_DATA,
     CONF_DATA_TEMPLATE,
-    CONF_DEFAULT,
     CONF_DELAY,
+    CONF_ENABLE_IPV6,
     CONF_ENCRYPTION,
     CONF_EVENT,
     CONF_ID,
@@ -54,6 +52,7 @@ from esphome.const import (
 )
 from esphome.core import CORE, ID, CoroPriority, EsphomeError, coroutine_with_priority
 from esphome.cpp_generator import Expression, MockObj, TemplateArgsType
+import esphome.final_validate as fv
 from esphome.helpers import fnv1_hash
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.types import ConfigFragmentType, ConfigType
@@ -139,7 +138,6 @@ SERVICE_ARG_FALLBACK_TYPES: dict[str, MockObj] = {
 CONF_BATCH_DELAY = "batch_delay"
 CONF_CUSTOM_SERVICES = "custom_services"
 CONF_EXAMPLE = "example"
-CONF_REQUIRED = "required"
 CONF_HOMEASSISTANT_SERVICES = "homeassistant_services"
 CONF_HOMEASSISTANT_STATES = "homeassistant_states"
 CONF_LISTEN_BACKLOG = "listen_backlog"
@@ -251,66 +249,12 @@ def _validate_supports_response(value: Any) -> str:
     return cv.enum(SUPPORTS_RESPONSE_OPTIONS, lower=True)(value)
 
 
-def _not_boolean(value: Any) -> Any:
-    # bool is an int subclass, and "true" cannot be parsed as a number by the client
-    if isinstance(value, bool):
-        raise cv.Invalid("Expected a number, got a boolean")
-    return value
-
-
-def _finite(value: float) -> float:
-    if not math.isfinite(value):
-        raise cv.Invalid("Expected a finite number")
-    return value
-
-
-def _no_nul(value: str) -> str:
-    # The default is a C string in flash, so a NUL would cut it short
-    if "\0" in value:
-        raise cv.Invalid("A default cannot contain a NUL character")
-    return value
-
-
-# The wire carries the default as text; the client parses it into ExecuteServiceArgument's
-# types, so the values are kept within what int32 and float hold
-FLOAT32_MAX = 3.4028235e38
-_DEFAULT_VALUE_VALIDATORS: dict[str, Callable[[Any], Any]] = {
-    "bool": cv.boolean,
-    "int": cv.All(_not_boolean, cv.int_range(min=-(2**31), max=2**31 - 1)),
-    "float": cv.All(
-        _not_boolean,
-        cv.float_,
-        _finite,
-        cv.float_range(min=-FLOAT32_MAX, max=FLOAT32_MAX),
-    ),
-    "string": cv.All(cv.string_strict, _no_nul),
-}
-assert _DEFAULT_VALUE_VALIDATORS.keys() == _SERVICE_ARG_SCALAR_TYPES.keys()
-
-
-def _validate_variable_optionality(value: ConfigType) -> ConfigType:
-    """Cross-validate required/default against the variable type."""
-    var_type = value[CONF_TYPE]
-    if _is_optional_var(value) and var_type not in _DEFAULT_VALUE_VALIDATORS:
-        raise cv.Invalid("Array variables cannot be optional")
-    if CONF_DEFAULT in value:
-        if value.get(CONF_REQUIRED) is True:
-            raise cv.Invalid("A variable with a default cannot set required: true")
-        value[CONF_DEFAULT] = _DEFAULT_VALUE_VALIDATORS[var_type](value[CONF_DEFAULT])
-    return value
-
-
-VARIABLE_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
-            cv.Optional(CONF_DESCRIPTION): cv.string_strict,
-            cv.Optional(CONF_EXAMPLE): cv.string_strict,
-            cv.Optional(CONF_REQUIRED): cv.boolean,
-            cv.Optional(CONF_DEFAULT): cv.valid,
-        }
-    ),
-    _validate_variable_optionality,
+VARIABLE_SCHEMA = cv.Schema(
+    {
+        cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
+        cv.Optional(CONF_DESCRIPTION): cv.string_strict,
+        cv.Optional(CONF_EXAMPLE): cv.string_strict,
+    }
 )
 
 # Accepts the plain `name: type` shorthand or the full mapping form
@@ -362,6 +306,11 @@ def _consume_api_sockets(config: ConfigType) -> ConfigType:
 def _validate_outgoing_connection(config: ConfigType) -> ConfigType:
     if (outgoing := config.get(CONF_OUTGOING_CONNECTION)) is None:
         return config
+    if CONF_ENCRYPTION not in config:
+        raise cv.Invalid(
+            "outgoing_connection requires 'encryption' so the peer is verified by key",
+            path=[CONF_OUTGOING_CONNECTION],
+        )
     # A device with no client reboots once reboot_timeout passes, so a delay that
     # reaches it would reboot the device before it ever dials
     reboot_timeout = config[CONF_REBOOT_TIMEOUT]
@@ -389,10 +338,7 @@ def _validate_outgoing_host(value: str) -> IPv4Address | IPv6Address:
                 "give the address without the '%' part"
             )
         if (mapped := address.ipv4_mapped) is not None:
-            address = mapped
-    # The build must carry the host's address family for the dial to work
-    require = require_ipv6 if isinstance(address, IPv6Address) else require_ipv4
-    require("api.outgoing_connection")(value)
+            return mapped
     return address
 
 
@@ -499,11 +445,6 @@ CONFIG_SCHEMA = cv.All(
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.rename_key(CONF_SERVICES, CONF_ACTIONS),
-    cv.key_requires(
-        CONF_OUTGOING_CONNECTION,
-        CONF_ENCRYPTION,
-        hint="The peer is verified by its key",
-    ),
     _validate_outgoing_connection,
     _consume_api_sockets,
     _register_provisioning_source,
@@ -522,28 +463,7 @@ def _has_action_metadata(actions: list[ConfigType]) -> bool:
     )
 
 
-def _is_optional_var(var_: ConfigType) -> bool:
-    return CONF_DEFAULT in var_ or var_.get(CONF_REQUIRED) is False
-
-
-def _has_optional_args(actions: list[ConfigType]) -> bool:
-    return any(
-        _is_optional_var(var_)
-        for conf in actions
-        for var_ in conf[CONF_VARIABLES].values()
-    )
-
-
-def _default_to_wire(value: Any) -> str:
-    """Serialize a validated default for the wire; clients coerce by arg type."""
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    return str(value)
-
-
-def _action_strings(
-    conf: ConfigType, has_metadata: bool, has_optional: bool
-) -> list[str | None]:
+def _action_strings(conf: ConfigType, has_metadata: bool) -> list[str | None]:
     """Strings of one action in the table order UserServiceStatic (user_services.h) expects."""
     # An empty description or example is treated as unset
     strings: list[str | None] = [conf[CONF_ACTION]]
@@ -556,24 +476,36 @@ def _action_strings(
                 var_.get(CONF_DESCRIPTION) or None,
                 var_.get(CONF_EXAMPLE) or None,
             ]
-        if has_optional:
-            # The default slot doubles as the optional flag: nullptr for a required variable,
-            # "" for an optional one without a default (an empty string default is the same)
-            if not _is_optional_var(var_):
-                strings.append(None)
-            elif (default := var_.get(CONF_DEFAULT)) is None:
-                strings.append("")
-            else:
-                strings.append(_default_to_wire(default))
     return strings
 
 
+def _validate_outgoing_host_ipv6(config: ConfigType) -> ConfigType:
+    """An IPv6 host can never be parsed, so never dialed, without IPv6."""
+    if (
+        (outgoing := config.get(CONF_OUTGOING_CONNECTION)) is None
+        or (host := outgoing.get(CONF_HOST)) is None
+        or host.version != 6
+    ):
+        return config
+    network_conf = fv.full_config.get().get(NETWORK_DOMAIN) or {}
+    if not network_conf.get(CONF_ENABLE_IPV6):
+        raise cv.Invalid(
+            "outgoing_connection host is an IPv6 address but IPv6 is not "
+            "enabled; set 'network: enable_ipv6: true'",
+            path=[CONF_OUTGOING_CONNECTION, CONF_HOST],
+        )
+    return config
+
+
 def _validate_wizard(config: ConfigType) -> ConfigType:
     wizard.final_validate(config)
     return config
 
 
-FINAL_VALIDATE_SCHEMA = _validate_wizard
+FINAL_VALIDATE_SCHEMA = cv.All(
+    _validate_outgoing_host_ipv6,
+    _validate_wizard,
+)
 
 
 def _add_action_strings(index: int, strings: list[str | None]) -> MockObj:
@@ -632,9 +564,6 @@ async def to_code(config: ConfigType) -> None:
         has_metadata = _has_action_metadata(actions)
         if has_metadata:
             cg.add_define("USE_API_USER_DEFINED_ACTION_METADATA")
-        has_optional = _has_optional_args(actions)
-        if has_optional:
-            cg.add_define("USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS")
         # Collect all triggers first, then register all at once with initializer_list
         triggers: list[cg.MockObj] = []
         for index, conf in enumerate(actions):
@@ -678,7 +607,7 @@ async def to_code(config: ConfigType) -> None:
                     native = SERVICE_ARG_NATIVE_TYPES[var_type]
                 service_template_args.append(native)
                 func_args.append((native, name))
-            strings = _action_strings(conf, has_metadata, has_optional)
+            strings = _action_strings(conf, has_metadata)
             table = _add_action_strings(index, strings)
             # Template args: supports_response mode, then user service arg types
             templ = cg.TemplateArguments(supports_response, *service_template_args)
@@ -799,6 +728,15 @@ VARIABLES_FIELDS_SCHEMA = cv.All(VARIABLES_SCHEMA, cv.Length(max=_FIELD_MAP_MAX)
 
 
 def _validate_response_config(config: ConfigType) -> ConfigType:
+    # Validate dependencies:
+    # - response_template requires capture_response: true
+    # - capture_response: true requires on_success
+    if CONF_RESPONSE_TEMPLATE in config and not config[CONF_CAPTURE_RESPONSE]:
+        raise cv.Invalid(
+            f"`{CONF_RESPONSE_TEMPLATE}` requires `{CONF_CAPTURE_RESPONSE}: true` to be set.",
+            path=[CONF_RESPONSE_TEMPLATE],
+        )
+
     if config[CONF_CAPTURE_RESPONSE] and CONF_ON_SUCCESS not in config:
         raise cv.Invalid(
             f"`{CONF_CAPTURE_RESPONSE}: true` requires `{CONF_ON_SUCCESS}` to be set.",
@@ -833,7 +771,6 @@ HOMEASSISTANT_ACTION_ACTION_SCHEMA = cv.All(
     ),
     cv.has_exactly_one_key(CONF_SERVICE, CONF_ACTION),
     cv.rename_key(CONF_SERVICE, CONF_ACTION),
-    cv.only_when(CONF_RESPONSE_TEMPLATE, CONF_CAPTURE_RESPONSE, True),
     _validate_response_config,
 )
 

esphome/components/api/api.proto

@@ -227,17 +227,11 @@ message AreaInfo {
   string name = 2 [(max_data_length) = 120, (force) = true];
 }
 
-enum DeviceRelation {
-  DEVICE_RELATION_VIA = 0;
-  DEVICE_RELATION_CHILD = 1;
-}
-
 message DeviceInfo {
   uint32 device_id = 1;
   // max_data_length matches core/config.FRIENDLY_NAME_MAX_LEN via DEVICE_SCHEMA
   string name = 2 [(max_data_length) = 120, (force) = true];
   uint32 area_id = 3;
-  DeviceRelation relation = 4;
 }
 
 enum SerialProxyPortType {
@@ -561,13 +555,13 @@ message ListEntitiesBinarySensorResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string device_class = 5 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 5 [(max_data_length) = 47];
   bool is_status_binary_sensor = 6;
   bool disabled_by_default = 7;
-  string icon = 8 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 8 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 9;
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
 }
@@ -595,20 +589,18 @@ message ListEntitiesCoverResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   bool assumed_state = 5;
   bool supports_position = 6;
   bool supports_tilt = 7;
-  string device_class = 8 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 8 [(max_data_length) = 47];
   bool disabled_by_default = 9;
-  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 11;
   bool supports_stop = 12;
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
-  bool supports_stop_tilt = 14;
-  bool supports_toggle = 15;
 }
 
 // Deprecated in API version 1.1
@@ -670,8 +662,6 @@ message CoverCommandRequest {
   float tilt = 7;
   bool stop = 8;
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
-  bool stop_tilt = 10;
-  bool toggle = 11;
 }
 
 // ==================== FAN ====================
@@ -683,7 +673,7 @@ message ListEntitiesFanResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   bool supports_oscillation = 5;
@@ -691,9 +681,9 @@ message ListEntitiesFanResponse {
   bool supports_direction = 7;
   int32 supported_speed_count = 8;
   bool disabled_by_default = 9;
-  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 10 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 11;
-  repeated string supported_preset_modes = 12 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
+  repeated string supported_preset_modes = 12 [(container_pointer_no_template) = "std::vector<const char *>"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields
@@ -771,7 +761,7 @@ message ListEntitiesLightResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   repeated ColorMode supported_color_modes = 12 [(container_pointer_no_template) = "light::ColorModeMask"];
@@ -788,7 +778,7 @@ message ListEntitiesLightResponse {
   float max_mireds = 10;
   repeated string effects = 11 [(container_pointer_no_template) = "light::LightEffectNames"];
   bool disabled_by_default = 13;
-  string icon = 14 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 14 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 15;
   uint32 device_id = 16 [(field_ifdef) = "USE_DEVICES"];
 }
@@ -876,14 +866,14 @@ message ListEntitiesSensorResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   string unit_of_measurement = 6 [(max_data_length) = 63];
   int32 accuracy_decimals = 7;
   bool force_update = 8;
-  string device_class = 9 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 9 [(max_data_length) = 47];
   SensorStateClass state_class = 10;
   // Last reset type removed in 2021.9.0
   // Deprecated in API version 1.5
@@ -917,14 +907,14 @@ message ListEntitiesSwitchResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool assumed_state = 6;
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
-  string device_class = 9 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 9 [(max_data_length) = 47];
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
 }
 message SwitchStateResponse {
@@ -962,13 +952,13 @@ message ListEntitiesTextSensorResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 8 [(max_data_length) = 47];
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
 }
 message TextSensorStateResponse {
@@ -1174,10 +1164,6 @@ message ListEntitiesServicesArgument {
   ServiceArgType type = 2;
   string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
   string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
-  // Advisory: ExecuteServiceRequest still requires every argument
-  bool optional = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS"];
-  // Always text: bool "true"/"false", numbers parseable as int/float; empty means no default
-  string default_value = 6 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS", (progmem) = true];
 }
 message ListEntitiesServicesResponse {
   option (id) = 41;
@@ -1237,10 +1223,10 @@ message ListEntitiesCameraResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
   bool disabled_by_default = 5;
-  string icon = 6 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 6 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
 }
@@ -1329,7 +1315,7 @@ message ListEntitiesClimateResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
   bool supports_current_temperature = 5; // Deprecated: use feature_flags
@@ -1345,11 +1331,11 @@ message ListEntitiesClimateResponse {
   bool supports_action = 12; // Deprecated: use feature_flags
   repeated ClimateFanMode supported_fan_modes = 13 [(container_pointer_no_template) = "climate::ClimateFanModeMask"];
   repeated ClimateSwingMode supported_swing_modes = 14 [(container_pointer_no_template) = "climate::ClimateSwingModeMask"];
-  repeated string supported_custom_fan_modes = 15 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer_no_template) = "std::vector<const char *>"];
   repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
+  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "std::vector<const char *>"];
   bool disabled_by_default = 18;
-  string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 20;
   float visual_current_temperature_step = 21;
   bool supports_current_humidity = 22; // Deprecated: use feature_flags
@@ -1444,8 +1430,8 @@ message ListEntitiesWaterHeaterResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
+  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 5;
   EntityCategory entity_category = 6;
   uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];
@@ -1524,10 +1510,10 @@ message ListEntitiesNumberResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   float min_value = 6;
   float max_value = 7;
   float step = 8;
@@ -1535,7 +1521,7 @@ message ListEntitiesNumberResponse {
   EntityCategory entity_category = 10;
   string unit_of_measurement = 11 [(max_data_length) = 63];
   NumberMode mode = 12;
-  string device_class = 13 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 13 [(max_data_length) = 47];
   uint32 device_id = 14 [(field_ifdef) = "USE_DEVICES"];
 }
 message NumberStateResponse {
@@ -1573,10 +1559,10 @@ message ListEntitiesSelectResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   repeated string options = 6 [(container_pointer_no_template) = "std::span<const char *const>"];
   bool disabled_by_default = 7;
   EntityCategory entity_category = 8;
@@ -1617,10 +1603,10 @@ message ListEntitiesSirenResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   repeated string tones = 7 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool supports_duration = 8;
@@ -1682,10 +1668,10 @@ message ListEntitiesLockResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   bool assumed_state = 8;
@@ -1731,13 +1717,13 @@ message ListEntitiesButtonResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 8 [(max_data_length) = 47];
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
 }
 message ButtonCommandRequest {
@@ -1789,8 +1775,6 @@ message MediaPlayerSupportedFormat {
   uint32 num_channels = 3;
   MediaPlayerFormatPurpose purpose = 4;
   uint32 sample_bytes = 5;
-  // Constant bitrate in kbps for lossy formats; 0 means no preference
-  uint32 bitrate = 6;
 }
 message ListEntitiesMediaPlayerResponse {
   option (id) = 63;
@@ -1800,10 +1784,10 @@ message ListEntitiesMediaPlayerResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
 
@@ -2392,9 +2376,9 @@ message ListEntitiesAlarmControlPanelResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 supported_features = 8;
@@ -2439,9 +2423,9 @@ message ListEntitiesTextResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
 
@@ -2487,10 +2471,10 @@ message ListEntitiesDateResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
@@ -2534,10 +2518,10 @@ message ListEntitiesTimeResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
@@ -2581,13 +2565,13 @@ message ListEntitiesEventResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 8 [(max_data_length) = 47];
 
   repeated string event_types = 9 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
   uint32 device_id = 10 [(field_ifdef) = "USE_DEVICES"];
@@ -2612,13 +2596,13 @@ message ListEntitiesValveResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 8 [(max_data_length) = 47];
 
   bool assumed_state = 9;
   bool supports_position = 10;
@@ -2667,10 +2651,10 @@ message ListEntitiesDateTimeResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
   uint32 device_id = 8 [(field_ifdef) = "USE_DEVICES"];
@@ -2710,13 +2694,13 @@ message ListEntitiesUpdateResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
   reserved 4; // Deprecated: was string unique_id
 
-  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
-  string device_class = 8 [(max_data_length) = 47, (progmem) = true];
+  string device_class = 8 [(max_data_length) = 47];
   uint32 device_id = 9 [(field_ifdef) = "USE_DEVICES"];
 }
 message UpdateStateResponse {
@@ -2810,8 +2794,8 @@ message ListEntitiesInfraredResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
+  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 5;
   EntityCategory entity_category = 6;
   uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];
@@ -2879,8 +2863,8 @@ message ListEntitiesRadioFrequencyResponse {
 
   string object_id = 1 [(max_data_length) = 120, (force) = true];
   fixed32 key = 2 [(force) = true];
-  string name = 3 [(max_data_length) = 120, (force) = true, (progmem) = true];
-  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63, (progmem) = true];
+  string name = 3 [(max_data_length) = 120, (force) = true];
+  string icon = 4 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   bool disabled_by_default = 5;
   EntityCategory entity_category = 6;
   uint32 device_id = 7 [(field_ifdef) = "USE_DEVICES"];

esphome/components/api/api_connection.cpp

@@ -24,7 +24,6 @@
 #endif
 #include "esphome/components/network/util.h"
 #include "esphome/core/application.h"
-#include "esphome/core/device.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -486,12 +485,13 @@ uint16_t APIConnection::fill_and_encode_entity_info(EntityBase *entity, InfoResp
   msg.key = entity->get_object_id_hash();
 
   if (entity->has_own_name()) {
-    msg.name = entity->get_name_progmem();
+    msg.name = entity->get_name();
   }
 
   // Set common EntityBase properties
 #ifdef USE_ENTITY_ICON
-  msg.icon = entity->get_icon_progmem();
+  char icon_buf[MAX_ICON_LENGTH];
+  msg.icon = StringRef(entity->get_icon_to(icon_buf));
 #endif
   msg.disabled_by_default = entity->is_disabled_by_default();
   msg.entity_category = static_cast<enums::EntityCategory>(entity->get_entity_category());
@@ -502,11 +502,12 @@ uint16_t APIConnection::fill_and_encode_entity_info(EntityBase *entity, InfoResp
 }
 
 uint16_t APIConnection::fill_and_encode_entity_info_with_device_class(EntityBase *entity, InfoResponseProtoMessage &msg,
-                                                                      ProgmemStringRef &device_class_field,
+                                                                      StringRef &device_class_field,
                                                                       CalculateSizeFn size_fn,
                                                                       MessageEncodeFn encode_fn, APIConnection *conn,
                                                                       uint32_t remaining_size) {
-  device_class_field = entity->get_device_class_progmem();
+  char dc_buf[MAX_DEVICE_CLASS_LENGTH];
+  device_class_field = StringRef(entity->get_device_class_to(dc_buf));
   return fill_and_encode_entity_info(entity, msg, size_fn, encode_fn, conn, remaining_size);
 }
 
@@ -554,8 +555,6 @@ uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *c
   msg.supports_position = traits.get_supports_position();
   msg.supports_tilt = traits.get_supports_tilt();
   msg.supports_stop = traits.get_supports_stop();
-  msg.supports_stop_tilt = traits.get_supports_stop_tilt();
-  msg.supports_toggle = traits.get_supports_toggle();
   return fill_and_encode_entity_info_with_device_class(cover, msg, msg.device_class, conn, remaining_size);
 }
 void APIConnection::on_cover_command_request(const CoverCommandRequest &msg) {
@@ -566,10 +565,6 @@ void APIConnection::on_cover_command_request(const CoverCommandRequest &msg) {
     call.set_tilt(msg.tilt);
   if (msg.stop)
     call.set_command_stop();
-  if (msg.stop_tilt)
-    call.set_command_stop_tilt();
-  if (msg.toggle)
-    call.set_command_toggle();
   call.perform();
 }
 #endif
@@ -1131,7 +1126,6 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
     media_format.num_channels = supported_format.num_channels;
     media_format.purpose = static_cast<enums::MediaPlayerFormatPurpose>(supported_format.purpose);
     media_format.sample_bytes = supported_format.sample_bytes;
-    media_format.bitrate = supported_format.bitrate;
   }
   return fill_and_encode_entity_info(media_player, msg, conn, remaining_size);
 }
@@ -2063,7 +2057,6 @@ bool APIConnection::send_device_info_response_() {
     device_info.device_id = device->get_device_id();
     device_info.name = StringRef(device->get_name());
     device_info.area_id = device->get_area_id();
-    device_info.relation = static_cast<enums::DeviceRelation>(device->get_relation());
   }
 #endif
 #ifdef USE_AREAS

esphome/components/api/api_connection.h

@@ -472,15 +472,15 @@ class APIConnection final : public APIServerConnectionBase {
 
   // Non-template core — fills device_class, then delegates to fill_and_encode_entity_info
   static uint16_t fill_and_encode_entity_info_with_device_class(EntityBase *entity, InfoResponseProtoMessage &msg,
-                                                                ProgmemStringRef &device_class_field,
-                                                                CalculateSizeFn size_fn, MessageEncodeFn encode_fn,
-                                                                APIConnection *conn, uint32_t remaining_size);
+                                                                StringRef &device_class_field, CalculateSizeFn size_fn,
+                                                                MessageEncodeFn encode_fn, APIConnection *conn,
+                                                                uint32_t remaining_size);
 
   // Thin template wrapper
   template<typename T>
   static uint16_t fill_and_encode_entity_info_with_device_class(EntityBase *entity, T &msg,
-                                                                ProgmemStringRef &device_class_field,
-                                                                APIConnection *conn, uint32_t remaining_size) {
+                                                                StringRef &device_class_field, APIConnection *conn,
+                                                                uint32_t remaining_size) {
     return fill_and_encode_entity_info_with_device_class(entity, msg, device_class_field, &T::calc_size_msg,
                                                          &T::encode_msg, conn, remaining_size);
   }

esphome/components/api/api_frame_helper.h

@@ -18,7 +18,7 @@
 namespace esphome::api {
 
 // uncomment to log raw packets
-// #define HELPER_LOG_PACKETS
+//#define HELPER_LOG_PACKETS
 
 // Maximum message size limits to prevent OOM on constrained devices
 // Handshake messages are limited to a small size for security

esphome/components/api/api_outgoing_connection.cpp

@@ -38,14 +38,12 @@ static bool peer_to_target(APIConnection *conn, SavedOutgoingTarget &target) {
     const auto *bytes = reinterpret_cast<const uint8_t *>(&addr6->sin6_addr);
     uint32_t prefix[3];
     memcpy(prefix, bytes, sizeof(prefix));
-#if USE_NETWORK_IPV4
     // A dual-stack listener reports an IPv4 peer as ::ffff:a.b.c.d
     if (prefix[0] == 0 && prefix[1] == 0 && prefix[2] == htonl(0xFFFFUL)) {
       target.family = AF_INET;
       memcpy(target.addr, bytes + sizeof(prefix), sizeof(struct in_addr));
       return true;
     }
-#endif
     // A link-local target is only reachable through the interface it came in
     // on. Device platforms number interfaces from one; a host build can hand
     // out an index too large to store, and a truncated one dials the wrong
@@ -59,7 +57,6 @@ static bool peer_to_target(APIConnection *conn, SavedOutgoingTarget &target) {
     return true;
   }
 #endif
-#if USE_NETWORK_IPV4
   if (family != AF_INET) {
     return false;
   }
@@ -67,9 +64,6 @@ static bool peer_to_target(APIConnection *conn, SavedOutgoingTarget &target) {
   target.family = AF_INET;
   memcpy(target.addr, &addr4->sin_addr, sizeof(addr4->sin_addr));
   return true;
-#else
-  return false;
-#endif
 }
 #endif
 
@@ -91,7 +85,6 @@ socklen_t OutgoingConnectionManager::target_sockaddr_(struct sockaddr_storage *a
     return sizeof(*addr6);
   }
 #endif
-#if USE_NETWORK_IPV4
   if (this->saved_.family != AF_INET) {
     return 0;
   }
@@ -101,9 +94,6 @@ socklen_t OutgoingConnectionManager::target_sockaddr_(struct sockaddr_storage *a
   addr4->sin_port = htons(API_OUTGOING_CONNECTION_PORT);
   memcpy(&addr4->sin_addr, this->saved_.addr, sizeof(addr4->sin_addr));
   return sizeof(*addr4);
-#else
-  return 0;
-#endif
 #endif
 }
 

esphome/components/api/api_pb2.h

@@ -19,10 +19,6 @@ enum DisconnectReason : uint32_t {
   DISCONNECT_REASON_UNSPECIFIED = 0,
   DISCONNECT_REASON_PROVISIONING_CLOSED = 1,
 };
-enum DeviceRelation : uint32_t {
-  DEVICE_RELATION_VIA = 0,
-  DEVICE_RELATION_CHILD = 1,
-};
 enum SerialProxyPortType : uint32_t {
   SERIAL_PROXY_PORT_TYPE_TTL = 0,
   SERIAL_PROXY_PORT_TYPE_RS232 = 1,
@@ -403,10 +399,10 @@ class InfoResponseProtoMessage : public ProtoMessage {
  public:
   StringRef object_id{};
   uint32_t key{0};
-  ProgmemStringRef name{};
+  StringRef name{};
   bool disabled_by_default{false};
 #ifdef USE_ENTITY_ICON
-  ProgmemStringRef icon{};
+  StringRef icon{nullptr, 0};  // null until set, encode only
 #endif
   enums::EntityCategory entity_category{};
 #ifdef USE_DEVICES
@@ -571,7 +567,6 @@ class DeviceInfo final : public ProtoMessage {
   uint32_t device_id{0};
   StringRef name{};
   uint32_t area_id{0};
-  enums::DeviceRelation relation{};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -871,7 +866,7 @@ class ListEntitiesBinarySensorResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_binary_sensor_response"); }
 #endif
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   bool is_status_binary_sensor{false};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -911,17 +906,15 @@ class BinarySensorStateResponse final : public StateResponseProtoMessage {
 class ListEntitiesCoverResponse final : public InfoResponseProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 13;
-  static constexpr uint8_t ESTIMATED_SIZE = 61;
+  static constexpr uint8_t ESTIMATED_SIZE = 57;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_cover_response"); }
 #endif
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_tilt{false};
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   bool supports_stop{false};
-  bool supports_stop_tilt{false};
-  bool supports_toggle{false};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -959,7 +952,7 @@ class CoverStateResponse final : public StateResponseProtoMessage {
 class CoverCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint16_t MESSAGE_TYPE = 30;
-  static constexpr uint8_t ESTIMATED_SIZE = 29;
+  static constexpr uint8_t ESTIMATED_SIZE = 25;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("cover_command_request"); }
 #endif
@@ -968,8 +961,6 @@ class CoverCommandRequest final : public CommandProtoMessage {
   bool has_tilt{false};
   float tilt{0.0f};
   bool stop{false};
-  bool stop_tilt{false};
-  bool toggle{false};
   void decode(const uint8_t *buffer, size_t length) {
     ProtoDecodableMessage::decode_fields(this, buffer, length, &decode_field);
   }
@@ -993,7 +984,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const ConstVector<const char *, true> *supported_preset_modes{};
+  const std::vector<const char *> *supported_preset_modes{};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1168,7 +1159,7 @@ class ListEntitiesSensorResponse final : public InfoResponseProtoMessage {
   StringRef unit_of_measurement{nullptr, 0};  // null until set, encode only
   int32_t accuracy_decimals{0};
   bool force_update{false};
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   enums::SensorStateClass state_class{};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1213,7 +1204,7 @@ class ListEntitiesSwitchResponse final : public InfoResponseProtoMessage {
   const LogString *message_name() const override { return LOG_STR("list_entities_switch_response"); }
 #endif
   bool assumed_state{false};
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1274,7 +1265,7 @@ class ListEntitiesTextSensorResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_text_sensor_response"); }
 #endif
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -1593,12 +1584,6 @@ class ListEntitiesServicesArgument final : public ProtoMessage {
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
   ProgmemStringRef example{};
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  bool optional{false};
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  ProgmemStringRef default_value{};
 #endif
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1792,9 +1777,9 @@ class ListEntitiesClimateResponse final : public InfoResponseProtoMessage {
   bool supports_action{false};
   const climate::ClimateFanModeMask *supported_fan_modes{};
   const climate::ClimateSwingModeMask *supported_swing_modes{};
-  const ConstVector<const char *, true> *supported_custom_fan_modes{};
+  const std::vector<const char *> *supported_custom_fan_modes{};
   const climate::ClimatePresetMask *supported_presets{};
-  const ConstVector<const char *, true> *supported_custom_presets{};
+  const std::vector<const char *> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};
@@ -1974,7 +1959,7 @@ class ListEntitiesNumberResponse final : public InfoResponseProtoMessage {
   float step{0.0f};
   StringRef unit_of_measurement{nullptr, 0};  // null until set, encode only
   enums::NumberMode mode{};
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -2230,7 +2215,7 @@ class ListEntitiesButtonResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_button_response"); }
 #endif
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -2269,7 +2254,6 @@ class MediaPlayerSupportedFormat final : public ProtoMessage {
   uint32_t num_channels{0};
   enums::MediaPlayerFormatPurpose purpose{};
   uint32_t sample_bytes{0};
-  uint32_t bitrate{0};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
@@ -3476,7 +3460,7 @@ class ListEntitiesEventResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_event_response"); }
 #endif
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   const ConstVector<const char *, true> *event_types{};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -3519,7 +3503,7 @@ class ListEntitiesValveResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_valve_response"); }
 #endif
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_stop{false};
@@ -3645,7 +3629,7 @@ class ListEntitiesUpdateResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const LogString *message_name() const override { return LOG_STR("list_entities_update_response"); }
 #endif
-  ProgmemStringRef device_class{};
+  StringRef device_class{nullptr, 0};  // null until set, encode only
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);

esphome/components/api/api_pb2_dump.cpp

@@ -154,16 +154,6 @@ template<> const char *proto_enum_to_string<enums::DisconnectReason>(enums::Disc
       return ESPHOME_PSTR("UNKNOWN");
   }
 }
-template<> const char *proto_enum_to_string<enums::DeviceRelation>(enums::DeviceRelation value) {
-  switch (value) {
-    case enums::DEVICE_RELATION_VIA:
-      return ESPHOME_PSTR("DEVICE_RELATION_VIA");
-    case enums::DEVICE_RELATION_CHILD:
-      return ESPHOME_PSTR("DEVICE_RELATION_CHILD");
-    default:
-      return ESPHOME_PSTR("UNKNOWN");
-  }
-}
 template<> const char *proto_enum_to_string<enums::SerialProxyPortType>(enums::SerialProxyPortType value) {
   switch (value) {
     case enums::SERIAL_PROXY_PORT_TYPE_TTL:
@@ -1015,7 +1005,6 @@ const char *DeviceInfo::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
   dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("area_id"), this->area_id);
-  dump_field(out, ESPHOME_PSTR("relation"), static_cast<enums::DeviceRelation>(this->relation));
   return out.c_str();
 }
 #endif
@@ -1202,12 +1191,12 @@ const char *ListEntitiesBinarySensorResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesBinarySensorResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
   dump_field(out, ESPHOME_PSTR("is_status_binary_sensor"), this->is_status_binary_sensor);
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
@@ -1231,22 +1220,20 @@ const char *ListEntitiesCoverResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesCoverResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
   dump_field(out, ESPHOME_PSTR("supports_position"), this->supports_position);
   dump_field(out, ESPHOME_PSTR("supports_tilt"), this->supports_tilt);
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
   dump_field(out, ESPHOME_PSTR("supports_stop"), this->supports_stop);
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, ESPHOME_PSTR("supports_stop_tilt"), this->supports_stop_tilt);
-  dump_field(out, ESPHOME_PSTR("supports_toggle"), this->supports_toggle);
   return out.c_str();
 }
 const char *CoverStateResponse::dump_to(DumpBuffer &out) const {
@@ -1271,8 +1258,6 @@ const char *CoverCommandRequest::dump_to(DumpBuffer &out) const {
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
-  dump_field(out, ESPHOME_PSTR("stop_tilt"), this->stop_tilt);
-  dump_field(out, ESPHOME_PSTR("toggle"), this->toggle);
   return out.c_str();
 }
 #endif
@@ -1281,14 +1266,14 @@ const char *ListEntitiesFanResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesFanResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("supports_oscillation"), this->supports_oscillation);
   dump_field(out, ESPHOME_PSTR("supports_speed"), this->supports_speed);
   dump_field(out, ESPHOME_PSTR("supports_direction"), this->supports_direction);
   dump_field(out, ESPHOME_PSTR("supported_speed_count"), this->supported_speed_count);
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
   for (const auto &it : *this->supported_preset_modes) {
@@ -1336,7 +1321,7 @@ const char *ListEntitiesLightResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesLightResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   for (const auto &it : *this->supported_color_modes) {
     dump_field(out, ESPHOME_PSTR("supported_color_modes"), static_cast<enums::ColorMode>(it), 4);
   }
@@ -1347,7 +1332,7 @@ const char *ListEntitiesLightResponse::dump_to(DumpBuffer &out) const {
   }
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
@@ -1415,14 +1400,14 @@ const char *ListEntitiesSensorResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSensorResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("unit_of_measurement"), this->unit_of_measurement);
   dump_field(out, ESPHOME_PSTR("accuracy_decimals"), this->accuracy_decimals);
   dump_field(out, ESPHOME_PSTR("force_update"), this->force_update);
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
   dump_field(out, ESPHOME_PSTR("state_class"), static_cast<enums::SensorStateClass>(this->state_class));
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -1447,14 +1432,14 @@ const char *ListEntitiesSwitchResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSwitchResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
@@ -1485,13 +1470,13 @@ const char *ListEntitiesTextSensorResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesTextSensorResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
@@ -1643,12 +1628,6 @@ const char *ListEntitiesServicesArgument::dump_to(DumpBuffer &out) const {
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
   dump_progmem_string_field(out, ESPHOME_PSTR("example"), this->example);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  dump_field(out, ESPHOME_PSTR("optional"), this->optional);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-  dump_progmem_string_field(out, ESPHOME_PSTR("default_value"), this->default_value);
 #endif
   return out.c_str();
 }
@@ -1722,10 +1701,10 @@ const char *ListEntitiesCameraResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesCameraResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
 #ifdef USE_DEVICES
@@ -1755,7 +1734,7 @@ const char *ListEntitiesClimateResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesClimateResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("supports_current_temperature"), this->supports_current_temperature);
   dump_field(out, ESPHOME_PSTR("supports_two_point_target_temperature"), this->supports_two_point_target_temperature);
   for (const auto &it : *this->supported_modes) {
@@ -1782,7 +1761,7 @@ const char *ListEntitiesClimateResponse::dump_to(DumpBuffer &out) const {
   }
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
   dump_field(out, ESPHOME_PSTR("visual_current_temperature_step"), this->visual_current_temperature_step);
@@ -1853,9 +1832,9 @@ const char *ListEntitiesWaterHeaterResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesWaterHeaterResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -1907,9 +1886,9 @@ const char *ListEntitiesNumberResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesNumberResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("min_value"), this->min_value);
   dump_field(out, ESPHOME_PSTR("max_value"), this->max_value);
@@ -1918,7 +1897,7 @@ const char *ListEntitiesNumberResponse::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
   dump_field(out, ESPHOME_PSTR("unit_of_measurement"), this->unit_of_measurement);
   dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::NumberMode>(this->mode));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
@@ -1949,9 +1928,9 @@ const char *ListEntitiesSelectResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSelectResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   for (const auto &it : *this->options) {
     dump_field(out, ESPHOME_PSTR("options"), it, 4);
@@ -1988,9 +1967,9 @@ const char *ListEntitiesSirenResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesSirenResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   for (const auto &it : *this->tones) {
@@ -2035,9 +2014,9 @@ const char *ListEntitiesLockResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesLockResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2076,13 +2055,13 @@ const char *ListEntitiesButtonResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesButtonResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
@@ -2105,16 +2084,15 @@ const char *MediaPlayerSupportedFormat::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("num_channels"), this->num_channels);
   dump_field(out, ESPHOME_PSTR("purpose"), static_cast<enums::MediaPlayerFormatPurpose>(this->purpose));
   dump_field(out, ESPHOME_PSTR("sample_bytes"), this->sample_bytes);
-  dump_field(out, ESPHOME_PSTR("bitrate"), this->bitrate);
   return out.c_str();
 }
 const char *ListEntitiesMediaPlayerResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesMediaPlayerResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2502,9 +2480,9 @@ const char *ListEntitiesAlarmControlPanelResponse::dump_to(DumpBuffer &out) cons
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesAlarmControlPanelResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2541,9 +2519,9 @@ const char *ListEntitiesTextResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesTextResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2581,9 +2559,9 @@ const char *ListEntitiesDateResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesDateResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2621,9 +2599,9 @@ const char *ListEntitiesTimeResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesTimeResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2661,13 +2639,13 @@ const char *ListEntitiesEventResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesEventResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
   for (const auto &it : *this->event_types) {
     dump_field(out, ESPHOME_PSTR("event_types"), it, 4);
   }
@@ -2691,13 +2669,13 @@ const char *ListEntitiesValveResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesValveResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
   dump_field(out, ESPHOME_PSTR("assumed_state"), this->assumed_state);
   dump_field(out, ESPHOME_PSTR("supports_position"), this->supports_position);
   dump_field(out, ESPHOME_PSTR("supports_stop"), this->supports_stop);
@@ -2733,9 +2711,9 @@ const char *ListEntitiesDateTimeResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesDateTimeResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2769,13 +2747,13 @@ const char *ListEntitiesUpdateResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesUpdateResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
-  dump_progmem_string_field(out, ESPHOME_PSTR("device_class"), this->device_class);
+  dump_field(out, ESPHOME_PSTR("device_class"), this->device_class);
 #ifdef USE_DEVICES
   dump_field(out, ESPHOME_PSTR("device_id"), this->device_id);
 #endif
@@ -2832,9 +2810,9 @@ const char *ListEntitiesInfraredResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesInfraredResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));
@@ -2890,9 +2868,9 @@ const char *ListEntitiesRadioFrequencyResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesRadioFrequencyResponse"));
   dump_field(out, ESPHOME_PSTR("object_id"), this->object_id);
   dump_field(out, ESPHOME_PSTR("key"), this->key);
-  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_field(out, ESPHOME_PSTR("name"), this->name);
 #ifdef USE_ENTITY_ICON
-  dump_progmem_string_field(out, ESPHOME_PSTR("icon"), this->icon);
+  dump_field(out, ESPHOME_PSTR("icon"), this->icon);
 #endif
   dump_field(out, ESPHOME_PSTR("disabled_by_default"), this->disabled_by_default);
   dump_field(out, ESPHOME_PSTR("entity_category"), static_cast<enums::EntityCategory>(this->entity_category));

esphome/components/api/api_pb2_service.h

@@ -19,242 +19,242 @@ class APIServerConnectionBase {
  public:
 #endif
 
-  void on_hello_request(const HelloRequest &value) {};
+  void on_hello_request(const HelloRequest &value){};
 
-  void on_disconnect_request(const DisconnectRequest &value) {};
-  void on_disconnect_response() {};
-  void on_ping_request() {};
-  void on_ping_response() {};
-  void on_device_info_request() {};
+  void on_disconnect_request(const DisconnectRequest &value){};
+  void on_disconnect_response(){};
+  void on_ping_request(){};
+  void on_ping_response(){};
+  void on_device_info_request(){};
 
-  void on_device_capabilities_request() {};
+  void on_device_capabilities_request(){};
 
 #ifdef USE_API_WIZARD
-  void on_device_wizard_request() {};
+  void on_device_wizard_request(){};
 #endif
 
 #ifdef USE_API_WIZARD_INPUTS
-  void on_wizard_input_set_request(const WizardInputSetRequest &value) {};
+  void on_wizard_input_set_request(const WizardInputSetRequest &value){};
 #endif
-  void on_list_entities_request() {};
+  void on_list_entities_request(){};
 
-  void on_subscribe_states_request() {};
+  void on_subscribe_states_request(){};
 
 #ifdef USE_COVER
-  void on_cover_command_request(const CoverCommandRequest &value) {};
+  void on_cover_command_request(const CoverCommandRequest &value){};
 #endif
 
 #ifdef USE_FAN
-  void on_fan_command_request(const FanCommandRequest &value) {};
+  void on_fan_command_request(const FanCommandRequest &value){};
 #endif
 
 #ifdef USE_LIGHT
-  void on_light_command_request(const LightCommandRequest &value) {};
+  void on_light_command_request(const LightCommandRequest &value){};
 #endif
 
 #ifdef USE_SWITCH
-  void on_switch_command_request(const SwitchCommandRequest &value) {};
+  void on_switch_command_request(const SwitchCommandRequest &value){};
 #endif
 
-  void on_subscribe_logs_request(const SubscribeLogsRequest &value) {};
+  void on_subscribe_logs_request(const SubscribeLogsRequest &value){};
 
 #ifdef USE_API_NOISE
-  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &value) {};
+  void on_noise_encryption_set_key_request(const NoiseEncryptionSetKeyRequest &value){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-  void on_subscribe_homeassistant_services_request() {};
+  void on_subscribe_homeassistant_services_request(){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
-  void on_homeassistant_action_response(const HomeassistantActionResponse &value) {};
+  void on_homeassistant_action_response(const HomeassistantActionResponse &value){};
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
-  void on_subscribe_home_assistant_states_request() {};
+  void on_subscribe_home_assistant_states_request(){};
 #endif
 
 #ifdef USE_API_HOMEASSISTANT_STATES
-  void on_home_assistant_state_response(const HomeAssistantStateResponse &value) {};
+  void on_home_assistant_state_response(const HomeAssistantStateResponse &value){};
 #endif
 
-  void on_get_time_response(const GetTimeResponse &value) {};
+  void on_get_time_response(const GetTimeResponse &value){};
 
 #ifdef USE_API_USER_DEFINED_ACTIONS
-  void on_execute_service_request(const ExecuteServiceRequest &value) {};
+  void on_execute_service_request(const ExecuteServiceRequest &value){};
 #endif
 
 #ifdef USE_CAMERA
-  void on_camera_image_request(const CameraImageRequest &value) {};
+  void on_camera_image_request(const CameraImageRequest &value){};
 #endif
 
 #ifdef USE_CLIMATE
-  void on_climate_command_request(const ClimateCommandRequest &value) {};
+  void on_climate_command_request(const ClimateCommandRequest &value){};
 #endif
 
 #ifdef USE_WATER_HEATER
-  void on_water_heater_command_request(const WaterHeaterCommandRequest &value) {};
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &value){};
 #endif
 
 #ifdef USE_NUMBER
-  void on_number_command_request(const NumberCommandRequest &value) {};
+  void on_number_command_request(const NumberCommandRequest &value){};
 #endif
 
 #ifdef USE_SELECT
-  void on_select_command_request(const SelectCommandRequest &value) {};
+  void on_select_command_request(const SelectCommandRequest &value){};
 #endif
 
 #ifdef USE_SIREN
-  void on_siren_command_request(const SirenCommandRequest &value) {};
+  void on_siren_command_request(const SirenCommandRequest &value){};
 #endif
 
 #ifdef USE_LOCK
-  void on_lock_command_request(const LockCommandRequest &value) {};
+  void on_lock_command_request(const LockCommandRequest &value){};
 #endif
 
 #ifdef USE_BUTTON
-  void on_button_command_request(const ButtonCommandRequest &value) {};
+  void on_button_command_request(const ButtonCommandRequest &value){};
 #endif
 
 #ifdef USE_MEDIA_PLAYER
-  void on_media_player_command_request(const MediaPlayerCommandRequest &value) {};
+  void on_media_player_command_request(const MediaPlayerCommandRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &value) {};
+  void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_device_request(const BluetoothDeviceRequest &value) {};
+  void on_bluetooth_device_request(const BluetoothDeviceRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &value) {};
+  void on_bluetooth_gatt_get_services_request(const BluetoothGATTGetServicesRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &value) {};
+  void on_bluetooth_gatt_read_request(const BluetoothGATTReadRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &value) {};
+  void on_bluetooth_gatt_write_request(const BluetoothGATTWriteRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &value) {};
+  void on_bluetooth_gatt_read_descriptor_request(const BluetoothGATTReadDescriptorRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &value) {};
+  void on_bluetooth_gatt_write_descriptor_request(const BluetoothGATTWriteDescriptorRequest &value){};
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &value) {};
+  void on_bluetooth_gatt_notify_request(const BluetoothGATTNotifyRequest &value){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_subscribe_bluetooth_connections_free_request() {};
+  void on_subscribe_bluetooth_connections_free_request(){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  void on_unsubscribe_bluetooth_le_advertisements_request() {};
+  void on_unsubscribe_bluetooth_le_advertisements_request(){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY
-  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &value) {};
+  void on_bluetooth_scanner_set_mode_request(const BluetoothScannerSetModeRequest &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &value) {};
+  void on_subscribe_voice_assistant_request(const SubscribeVoiceAssistantRequest &value){};
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_response(const VoiceAssistantResponse &value) {};
+  void on_voice_assistant_response(const VoiceAssistantResponse &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_event_response(const VoiceAssistantEventResponse &value) {};
+  void on_voice_assistant_event_response(const VoiceAssistantEventResponse &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_audio(const VoiceAssistantAudio &value) {};
+  void on_voice_assistant_audio(const VoiceAssistantAudio &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &value) {};
+  void on_voice_assistant_timer_event_response(const VoiceAssistantTimerEventResponse &value){};
 #endif
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &value) {};
+  void on_voice_assistant_announce_request(const VoiceAssistantAnnounceRequest &value){};
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &value) {};
+  void on_voice_assistant_configuration_request(const VoiceAssistantConfigurationRequest &value){};
 #endif
 
 #ifdef USE_VOICE_ASSISTANT
-  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &value) {};
+  void on_voice_assistant_set_configuration(const VoiceAssistantSetConfiguration &value){};
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
-  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &value) {};
+  void on_alarm_control_panel_command_request(const AlarmControlPanelCommandRequest &value){};
 #endif
 
 #ifdef USE_TEXT
-  void on_text_command_request(const TextCommandRequest &value) {};
+  void on_text_command_request(const TextCommandRequest &value){};
 #endif
 
 #ifdef USE_DATETIME_DATE
-  void on_date_command_request(const DateCommandRequest &value) {};
+  void on_date_command_request(const DateCommandRequest &value){};
 #endif
 
 #ifdef USE_DATETIME_TIME
-  void on_time_command_request(const TimeCommandRequest &value) {};
+  void on_time_command_request(const TimeCommandRequest &value){};
 #endif
 
 #ifdef USE_VALVE
-  void on_valve_command_request(const ValveCommandRequest &value) {};
+  void on_valve_command_request(const ValveCommandRequest &value){};
 #endif
 
 #ifdef USE_DATETIME_DATETIME
-  void on_date_time_command_request(const DateTimeCommandRequest &value) {};
+  void on_date_time_command_request(const DateTimeCommandRequest &value){};
 #endif
 
 #ifdef USE_UPDATE
-  void on_update_command_request(const UpdateCommandRequest &value) {};
+  void on_update_command_request(const UpdateCommandRequest &value){};
 #endif
 #ifdef USE_ZWAVE_PROXY
-  void on_z_wave_proxy_frame(const ZWaveProxyFrame &value) {};
+  void on_z_wave_proxy_frame(const ZWaveProxyFrame &value){};
 #endif
 #ifdef USE_ZWAVE_PROXY
-  void on_z_wave_proxy_request(const ZWaveProxyRequest &value) {};
+  void on_z_wave_proxy_request(const ZWaveProxyRequest &value){};
 #endif
 
 #ifdef USE_IR_RF
-  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value) {};
+  void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &value) {};
+  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_write_request(const SerialProxyWriteRequest &value) {};
+  void on_serial_proxy_write_request(const SerialProxyWriteRequest &value){};
 #endif
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &value) {};
+  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &value){};
 #endif
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &value) {};
+  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_request(const SerialProxyRequest &value) {};
+  void on_serial_proxy_request(const SerialProxyRequest &value){};
 #endif
 
 #ifdef USE_SERIAL_PROXY
-  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &value) {};
+  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &value){};
 #endif
 #ifdef USE_SERIAL_PROXY
-  void on_subscribe_serial_proxy_identity_request() {};
+  void on_subscribe_serial_proxy_identity_request(){};
 #endif
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value) {};
+  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
 #endif
 
 #ifdef USE_SENDSPIN
-  void on_sendspin_pairing_token_request() {};
+  void on_sendspin_pairing_token_request(){};
 #endif
 };
 

esphome/components/api/api_server.cpp

@@ -593,10 +593,7 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef
 void APIServer::add_state_subscription_(const char *entity_id, const char *attribute,
                                         std::function<void(StringRef)> &&f, bool once) {
   this->state_subs_.push_back(HomeAssistantStateSubscription{
-      .entity_id = entity_id,
-      .attribute = attribute,
-      .callback = std::move(f),
-      .once = once,
+      .entity_id = entity_id, .attribute = attribute, .callback = std::move(f), .once = once,
       // entity_id_dynamic_storage and attribute_dynamic_storage remain nullptr (no heap allocation)
   });
 }

esphome/components/api/homeassistant_service.h

@@ -20,8 +20,7 @@ namespace esphome::api {
 
 // Converts a lambda result to the string sent to Home Assistant
 template<typename T>
-  requires(!std::is_pointer_v<std::remove_cvref_t<T>>)
-std::string field_to_string(T &&val) {
+requires(!std::is_pointer_v<std::remove_cvref_t<T>>) std::string field_to_string(T &&val) {
   return to_string(std::forward<T>(val));  // NOLINT
 }
 inline std::string field_to_string(const char *val) { return val ? std::string(val) : std::string(); }

esphome/components/api/proto.h

@@ -301,7 +301,7 @@ constexpr uint32_t VARINT_MAX_1_BYTE = 1 << 7;   // 128
 constexpr uint32_t VARINT_MAX_2_BYTE = 1 << 14;  // 16384
 
 /// Generated encode body: writes the fields at pos, returns the cursor past them.
-using ProtoEncodeFn = uint8_t *(*)(const void *, uint8_t *PROTO_ENCODE_DEBUG_PARAM);
+using ProtoEncodeFn = uint8_t *(*) (const void *, uint8_t *PROTO_ENCODE_DEBUG_PARAM);
 
 /// Static encode helpers for the generated encode bodies. Each takes the write cursor by value and
 /// returns it advanced, so outlined calls at -Os chain through the return register instead of a
@@ -409,10 +409,6 @@ class ProtoEncode {
   /// Tag must be a single-byte varint (< 128). Always encodes (no zero check).
   [[nodiscard]] static inline uint8_t *encode_short_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                                  uint8_t tag, const StringRef &ref) {
-#ifdef USE_ESP8266
-    // memcpy_P reads RAM too, and sharing the progmem copy is smaller than an inline memcpy
-    return encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, tag, ProgmemStringRef(ref));
-#else
 #ifdef ESPHOME_DEBUG_API
     assert(ref.size() < 128 && "encode_short_string_force: string exceeds max_data_length < 128");
 #endif
@@ -421,7 +417,6 @@ class ProtoEncode {
     pos[1] = static_cast<uint8_t>(ref.size());
     std::memcpy(pos + 2, ref.c_str(), ref.size());
     return pos + 2 + ref.size();
-#endif
   }
   /// encode_short_string_force for a string that may be in flash (PROGMEM).
   [[nodiscard]] static inline uint8_t *encode_short_progmem_string_force(
@@ -501,22 +496,13 @@ class ProtoEncode {
   /// encode_progmem_bytes for a string field that may be in flash.
   [[nodiscard]] static inline uint8_t *encode_progmem_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                              uint32_t field_id, const ProgmemStringRef &ref) {
-#ifdef USE_ESP8266
     return encode_progmem_bytes(pos PROTO_ENCODE_DEBUG_ARG, field_id,
                                 reinterpret_cast<const uint8_t *>(ref.progmem_ptr()), ref.size());
-#else
-    // In RAM here, so share the plain string encoder
-    return encode_string(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.ram_ref());
-#endif
   }
   [[nodiscard]] static inline uint8_t *encode_progmem_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                                    uint32_t field_id, const ProgmemStringRef &ref) {
-#ifdef USE_ESP8266
     return encode_progmem_bytes_force(pos PROTO_ENCODE_DEBUG_ARG, field_id,
                                       reinterpret_cast<const uint8_t *>(ref.progmem_ptr()), ref.size());
-#else
-    return encode_string_force(pos PROTO_ENCODE_DEBUG_ARG, field_id, ref.ram_ref());
-#endif
   }
   [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                            uint32_t field_id, uint32_t value) {

esphome/components/api/user_services.cpp

@@ -31,13 +31,6 @@ ListEntitiesServicesResponse UserServiceStatic::encode_list_service_response_(
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
     arg.description = this->str_(base + 1);
     arg.example = this->str_(base + 2);
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-    // The default slot doubles as the optional flag: nullptr is required, "" optional without a default
-    const char *d = progmem_read_ptr(&this->strings_[base + USER_ACTION_ARG_BASE_STRINGS]);
-    arg.optional = d != nullptr;
-    if (d != nullptr)
-      arg.default_value = ProgmemStringRef(d, ESPHOME_strlen_P(d));
 #endif
   }
   return msg;

esphome/components/api/user_services.h

@@ -40,20 +40,13 @@ template<typename T> enums::ServiceArgType to_service_arg_type();
 // All strings live in one PROGMEM pointer table emitted by codegen (see _action_strings in
 // __init__.py), so each service costs a single pointer of RAM. Layout: the action name, then
 // each argument name; with USE_API_USER_DEFINED_ACTION_METADATA the action description follows
-// the name and every argument is (name, description, example); with
-// USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS every argument ends with its default: nullptr for a
-// required argument, "" for an optional one without a default. Unset is nullptr.
+// the name and every argument is (name, description, example). Unset metadata is nullptr.
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
 static constexpr size_t USER_ACTION_HEADER_STRINGS = 2;
-static constexpr size_t USER_ACTION_ARG_BASE_STRINGS = 3;
+static constexpr size_t USER_ACTION_ARG_STRINGS = 3;
 #else
 static constexpr size_t USER_ACTION_HEADER_STRINGS = 1;
-static constexpr size_t USER_ACTION_ARG_BASE_STRINGS = 1;
-#endif
-#ifdef USE_API_USER_DEFINED_ACTION_OPTIONAL_ARGS
-static constexpr size_t USER_ACTION_ARG_STRINGS = USER_ACTION_ARG_BASE_STRINGS + 1;
-#else
-static constexpr size_t USER_ACTION_ARG_STRINGS = USER_ACTION_ARG_BASE_STRINGS;
+static constexpr size_t USER_ACTION_ARG_STRINGS = 1;
 #endif
 class UserServiceStatic : public UserServiceDescriptor {
  public:

esphome/components/api/wizard.py

@@ -119,6 +119,11 @@ def _validate_multiple(conf: ConfigType) -> ConfigType:
             "is only for standalone inputs (id)",
             path=[CONF_MULTIPLE],
         )
+    if CONF_MAX_LENGTH in conf and not conf[CONF_MULTIPLE]:
+        raise cv.Invalid(
+            "max_length only applies to an input with multiple: true",
+            path=[CONF_MAX_LENGTH],
+        )
     return conf
 
 
@@ -145,7 +150,6 @@ WIZARD_INPUT_SCHEMA = cv.All(
     ),
     cv.has_exactly_one_key(CONF_ID, CONF_ENTITY),
     _validate_multiple,
-    cv.only_when(CONF_MAX_LENGTH, CONF_MULTIPLE, True),
 )
 
 WIZARD_PAGE_SCHEMA = cv.All(

esphome/components/aqi/aqi_sensor.cpp

@@ -30,10 +30,10 @@ void AQISensor::dump_config() {
   ESP_LOGCONFIG(TAG, "  Extended Range: %s",
                 this->extended_range_ ? LOG_STR_LITERAL("enabled") : LOG_STR_LITERAL("disabled"));
   if (this->pm_2_5_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  PM2.5 Sensor: '%s'", LOG_STR_ARG(this->pm_2_5_sensor_->get_log_name()));
+    ESP_LOGCONFIG(TAG, "  PM2.5 Sensor: '%s'", this->pm_2_5_sensor_->get_name().c_str());
   }
   if (this->pm_10_0_sensor_ != nullptr) {
-    ESP_LOGCONFIG(TAG, "  PM10 Sensor: '%s'", LOG_STR_ARG(this->pm_10_0_sensor_->get_log_name()));
+    ESP_LOGCONFIG(TAG, "  PM10 Sensor: '%s'", this->pm_10_0_sensor_->get_name().c_str());
   }
   LOG_SENSOR("  ", "AQI", this);
 }

esphome/components/aqi/caqi_calculator.h

@@ -26,17 +26,21 @@ class CAQICalculator : public AbstractAQICalculator {
   static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 25}, {26, 50}, {51, 75}, {76, 100}};
 
   static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {
+      // clang-format off
       {0.0f, 15.1f},
       {15.1f, 30.1f},
       {30.1f, 55.1f},
-      {55.1f, 110.1f},
+      {55.1f, 110.1f}
+      // clang-format on
   };
 
   static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
+      // clang-format off
       {0.0f, 25.1f},
       {25.1f, 50.1f},
       {50.1f, 90.1f},
-      {90.1f, 180.1f},
+      {90.1f, 180.1f}
+      // clang-format on
   };
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {

esphome/components/aqi/sensor.py

@@ -17,6 +17,16 @@ DEPENDENCIES = ["sensor"]
 AQISensor = aqi_ns.class_("AQISensor", sensor.Sensor, cg.Component)
 
 
+def _validate_extended_range(config: ConfigType) -> ConfigType:
+    if CONF_EXTENDED_RANGE in config and config[CONF_CALCULATION_TYPE] == "CAQI":
+        raise cv.Invalid(
+            f"'{CONF_EXTENDED_RANGE}' is not supported with 'calculation_type: CAQI'. "
+            "CAQI has no maximum value by specification, so it is always reported unbounded.",
+            [CONF_EXTENDED_RANGE],
+        )
+    return config
+
+
 CONFIG_SCHEMA = cv.All(
     sensor.sensor_schema(
         AQISensor,
@@ -35,13 +45,7 @@ CONFIG_SCHEMA = cv.All(
         }
     )
     .extend(cv.COMPONENT_SCHEMA),
-    cv.only_when(
-        CONF_EXTENDED_RANGE,
-        CONF_CALCULATION_TYPE,
-        "CAQI",
-        negate=True,
-        hint="CAQI has no maximum by specification, so it is always reported unbounded",
-    ),
+    _validate_extended_range,
 )
 
 

esphome/components/as5600/sensor/__init__.py

@@ -23,6 +23,7 @@ AS5600Sensor = as5600_ns.class_("AS5600Sensor", sensor.Sensor, cg.PollingCompone
 CONF_RAW_POSITION = "raw_position"
 CONF_SLOW_FILTER = "slow_filter"
 CONF_FAST_FILTER = "fast_filter"
+CONF_PWM_FREQUENCY = "pwm_frequency"
 CONF_BURN_COUNT = "burn_count"
 CONF_START_POSITION = "start_position"
 CONF_END_POSITION = "end_position"

esphome/components/atm90e32/atm90e32.cpp

@@ -639,7 +639,7 @@ float ATM90E32Component::get_chip_temperature_() {
 
 void ATM90E32Component::press_calibration_button(EntityBase *entity, void (ATM90E32Component::*action)(),
                                                  const LogString *hint, const LogString *hint2) {
-  ESP_LOGI(TAG, "%s", LOG_STR_ARG(entity->get_log_name()));
+  ESP_LOGI(TAG, "%s", entity->get_name().c_str());
   if (hint != nullptr) {
     ESP_LOGI(TAG, "%s", LOG_STR_ARG(hint));
   }
@@ -1295,7 +1295,7 @@ void ATM90E32Component::check_phase_status() {
     if (!status.empty()) {
       status.pop_back();  // remove space
       status.pop_back();  // remove semicolon
-      ESP_LOGW(TAG, "%s: %s", LOG_STR_ARG(sensor->get_log_name()), status.c_str());
+      ESP_LOGW(TAG, "%s: %s", sensor->get_name().c_str(), status.c_str());
       sensor->publish_state(status);
     } else {
       sensor->publish_state("Okay");

esphome/components/atm90e32/atm90e32.h

@@ -157,7 +157,7 @@ class ATM90E32Component final : public PollingComponent,
 #ifdef USE_NUMBER
     return (phase < 3 && ref_currents_[phase]) ? ref_currents_[phase]->state : 5.0f;  // Default current
 #else
-    return 5.0f;  // Default current
+    return 5.0f;   // Default current
 #endif
   }
   bool using_saved_calibrations_ = false;  // Track if stored calibrations are being used