Merge remote-tracking branch 'origin/dev' into neutral-ble-client

# Conflicts:
#	esphome/components/ble_client/ble_client.h

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

@@ -93,13 +93,15 @@ ESP-IDF OTA image: `.esphome/build/<name>/build/firmware.ota.bin`. LibreTiny OTA
 - `ports.py`: list ports with VID:PID, product, serial and a board guess; `--wait VID[:PID]`,
   `--product NAME`, `--serial SN` (one specific board, whatever path it comes back under) and
   `--serial-of PORT` (the serial number behind a path).
-- `serial_capture.py PORT SECONDS OUT [--baud] [--released] [--reset] [--append]`: bounded timestamped
-  capture, ANSI stripped, `LOG_SECRET` text written as `<secret>`, reopens a vanished port, exits at the
+- `serial_capture.py PORT SECONDS OUT [--baud] [--released] [--reset] [--append] [--ms]`: bounded timestamped
+  capture (`--ms` adds milliseconds for timing work), ANSI stripped, `LOG_SECRET` text written as `<secret>`, reopens a vanished port, exits at the
   deadline. OUT is truncated unless `--append` is given, so counts over it cover one run.
 - `flash_rtl87xx_kit.py`: ltchiptool wrapper for the BW15 kit whose CH340 drives CEN (RTS) and the boot
   strap (DTR). `flash read` needs the family `realtek-ambz2`; `flash write` does not.
 - `flash_bk72xx.py`: ltchiptool wrapper for BK72xx boards whose RTS drives CEN. It misses the link now
   and then; retry up to three times.
+- `api_button.py HOST KEY list|press NAME [...]`: list a device's template buttons or press them over the API; the
+  recipes drive their test configs with it.
 - `wifisave_hammer.sh KIND DUT_PORT DUT_YAML DUT_TREE CLIENT_PORT CLIENT_YAML CLIENT_TREE [SETTLE]`:
   the fallback AP plus captive portal hammer end to end (compile, flash, capture, counts) with the
   templates below. KIND is `esp`, `pico`, `bw15` or `bk`. It ends with `RESULT PASS` (exit 0),
@@ -113,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).
+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), `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 WebSocket listeners, test CA, transport case runner).
 
 ## Templates in `$SKILL/templates`
 
@@ -125,7 +127,12 @@ capture decoder).
 - Per-topic device configs, each described in `reference/recipes/<component>.md`: `online-image-dut.yaml`,
   `usb-cdc-acm-dongle-dut.yaml`, `nrf52-preferences-dut.yaml`, `rtsp-waveshare-s3-eth-dut.yaml`,
   `waveshare-s3-eth-camdiag.yaml`, `s31-cse7766-dut.yaml`, `nrf52-coredump-crash-dut.yaml`,
-  `bk72xx-rtc-prefs-dut.yaml`, `bk72xx-crash-probe-dut.yaml`, `dut-ap-only-wipe-once-bk72xx.yaml`.
+  `bk72xx-rtc-prefs-dut.yaml`, `bk72xx-crash-probe-dut.yaml`, `dut-ap-only-wipe-once-bk72xx.yaml`,
+  `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`.
 
 ## When something looks wrong
 
@@ -139,6 +146,10 @@ capture decoder).
   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/recipes/README.md

@@ -4,14 +4,14 @@ 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
+- [`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
+- [`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
+- [`mqtt.md`](mqtt.md): broker bench, QoS, reconnect, crash log over MQTT, WebSocket transports with a local and a public broker
 - [`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
@@ -24,3 +24,9 @@ One file per component, named after it:
 - [`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
+- [`globals.md`](globals.md): restoring globals with storage rtc and flash across every reset kind
+- [`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

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

@@ -5,3 +5,26 @@
 Host side timing is useless on a weak link; use an on-device bench with the minimum of five runs over
 two boots. Provision a key with `noise_encryption_set_key` through aioesphomeapi and upload with
 `espota2.run_ota(host, 8266, None, bin, noise_psk=key)` when the key is not in the yaml.
+
+## Outgoing connection wake timing on a deep sleep build (#21077)
+
+`templates/deep-sleep-outgoing-dut.yaml`: classic ESP32 ESP-IDF, `wifi: fast_connect`, `api: encryption` with a bare
+`outgoing_connection:`, `deep_sleep` 15 s run and 15 s sleep, a `homeassistant` text sensor, and `millis()` logged
+from `wifi: on_connect`, `api: on_client_connected` and the sensor's first `on_value`. Home Assistant's dial-in
+listener is on 6054; reuse a device name it already has. Flash by USB, `serial_capture.py PORT 360 OUT --reset` for
+12 cycles, then `scripts/api_outgoing/cycles.py OUT LABEL` prints per cycle the wifi, client and state millis with
+the client-wifi and state-client gaps. Wi-Fi takes 4 to 8 s after a wake, so compare the client-wifi gap, and run
+the PR twice around one base run because the spread is a few hundred ms.
+Results: https://github.com/esphome/esphome/pull/21077#issuecomment-6254098014
+
+## Outgoing connection on a mains build after a Wi-Fi drop (#21085)
+
+`templates/outgoing-wifi-drop-dut.yaml`: classic ESP32, `outgoing_connection: delay: 2s`, a "Wifi cycle" button doing
+`wifi.disable`, 4 s, `wifi.enable`, a `debug` loop-time sensor, millis from the wifi and api triggers. Flash by USB,
+`serial_capture.py PORT SECONDS OUT --ms`, press the button N times 40 s apart with `api_button.py DEV_IP KEY press
+"Wifi cycle"`, then `wificycles.py CAPTURE LABEL` prints per drop the Wi-Fi-to-dial gap, dials and dials closed, who
+connected first, and the loop-time maxima. For the loop cost of polling, repeat with an unreachable
+`host: 192.0.2.1`. Home Assistant refuses a dial-in while its own session is READY (`Refusing dial-in adoption`),
+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

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

@@ -0,0 +1,21 @@
+# dfrobot_sen0395
+
+## DFRobot SEN0395 mmWave on an ESP32 DevKit V1 (#20906, #20979)
+
+Wiring: V to VIN (5 V, the module wants 3.6 to 5 V), G to GND, sensor TX to GPIO16 (RX2), sensor RX to GPIO17
+(TX2), IO2 to GPIO18 (presence output, a gpio binary sensor), I1 unconnected. `templates/dfrobot-sen0395-dut.yaml`
+has the hub, both detection binary sensors, the four switches, settings buttons and junk-line buttons.
+`scripts/dfrobot_sen0395/ctl.py HOST KEY press:NAME sw:NAME=on|off wait:S` drives it and prints binary sensor and
+switch updates; `cases.sh DEV_IP KEY CAPTURE LABEL` runs the whole flow against a running serial capture. Flash by
+USB, `serial_capture.py PORT 540 CAPTURE --reset`, then the cases; compare the `Sending command` and `Message:` lines
+and the counts of `Done`, `Error`, prompts and frames between builds. The module echoes every command, so the echoed
+lines are the bytes the component sent and can be compared between builds as a set.
+
+Module facts: it answers `Done` or `Error` and then the `leapMMW:/>` prompt without a line end; a junk line gets
+`<line> is not recognized as a CLI command` (36 chars longer than the line, so 220 and 240 byte junk gives 256 and
+276 char replies); input lines of 256 bytes or more make the module assert (`..\User_code\main.c line:232`) and
+restart, after which the sensor is stopped; a factory reset restarts the module about 7 s later; `sensorStop` on a
+stopped sensor answers `sensor stopped already` then `Error`; a settings press takes 5 to 6 s (stop, change, save,
+start). Free heap on the ESP32 is Wi-Fi noise (192 to 198 kB) and says nothing about the component.
+Results: https://github.com/esphome/esphome/pull/20979#issuecomment-6279129146 and
+https://github.com/esphome/esphome/pull/20906#issuecomment-6279129604

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

@@ -0,0 +1,15 @@
+# globals
+
+## Restoring globals with storage: rtc and flash (#13954)
+
+`templates/globals-storage-dut.yaml` is the shared package: five restoring globals (rtc int, flash int, default int,
+rtc `std::string`, rtc `uint8_t[2]`), bumped and logged with the reset reason on every boot, saved and synced after
+2 s, odd boots `App.safe_reboot()`. Platform files add the board (`packages: dut: !include globals-storage-dut.yaml`), the `debug` reset-reason text sensor and, on the
+ESP32, `deep_sleep: run_duration: 12s, sleep_duration: 8s` (even boots sleep). No network needed: flash by USB,
+`serial_capture.py PORT 110 OUT --reset` gives the reset pulse plus a run of soft restarts and sleeps; the ESP32's
+EN pulse is a `POWERON_RESET` that empties RTC memory, the D1 mini's RST pulse (`rst cause:2`) keeps it, so the
+ESP8266 needs a real power cut by hand; arm long `--released` captures on both ports first (the capture
+reopens the port when it comes back, the very first boot lines are still lost, read the next boot's restored
+values). Unchanged-build check: the config with every `storage:` removed, built on the PR and on the dev merge
+commit under the PR's own commits (not the merge base, which is older dev), `cmp -l` plus an `nm -S` symbol diff;
+only the template names differ. Results: https://github.com/esphome/esphome/pull/13954#issuecomment-6254794712

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

@@ -0,0 +1,47 @@
+# homeassistant
+
+## homeassistant light platform against a local Home Assistant (#11354)
+
+A local Home Assistant dev install (`hass -c config`, https://127.0.0.1:8123 with a self-signed cert); its ESPHome
+entries and entity ids are in `config/.storage/`. Two ESPHome RGBCW bulbs with a plaintext API are the lights, so an
+"HA side" change is made directly on a bulb with `scripts/homeassistant_light/bulb.py BULB_IP - on|off|state|restart`.
+Add the test devices to HA by hand with the shared `api_key` and "Allow the device to perform Home Assistant actions".
+
+`templates/homeassistant-light-dut.yaml` is a package: two mirrors, buttons for each change, a "Log state" button, a
+30 s alive line, an `on_boot` `light.turn_on` for the change-before-first-write path, and VERBOSE logging with the
+noisy tags at DEBUG (a tag cannot exceed the global level). A platform file sets the board and includes it:
+
+```yaml
+esphome:
+  name: ha-light-dut
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+packages:
+  dut: !include homeassistant-light-dut.yaml
+```
+
+Flash by USB, start a bounded `esphome logs` capture per device, then press buttons with
+`scripts/api_button.py DEV_IP KEY press "Button"` and read the bulb with `bulb.py`. Cases: each
+button against the bulb and the device log; a direct bulb change that both mirrors follow; restart the bulb, send a
+change, expect the 5 s `did not report the change back` and the fallback (with an off and with an on last report);
+OTA reboot with a serial capture running to see the boot-time change (the API log client reconnects too late).
+
+Lessons: the light core clamps mireds to the range HA reported; a flash sends nothing; a change sent while HA is
+connected but not yet subscribed is dropped by the api server (`client has not subscribed to actions (yet)`); after a
+fallback to an off report the mirror keeps the unsent brightness; a mirror that never saw its light on since boot has
+no levels to restore. Results: https://github.com/esphome/esphome/pull/11354#issuecomment-6253630336 and
+https://github.com/esphome/esphome/pull/11354#issuecomment-6254161409
+
+## Held report versus a later call (#21144)
+
+A report that arrives during a transition is held and applied when the transition ends, unless a call came after
+it. `scripts/homeassistant_light/heldcase.py DEV_IP KEY BULB_IP same|many [BULB_KEY]` (a key of `-` is plaintext) keeps one API connection to the mirror
+device and one to the bulb so the steps land inside a 3 s fade: press "A 50 fade 3s", 0.7 s later set the bulb to
+90% directly (the report is held), 1.4 s in press the same fade again (or "A many calls", 16 calls in one loop
+pass). Pass: the mirror and the bulb end at the second call's target. Only `same` reproduces the bug: a build
+without the fix logs `Applying the report that arrived during the transition` and the bulb stays at 90%. `many`
+ends at 100% on both builds because the last call's target differs from the held report, so it is a regression
+check only, not a reproduction. Separate button presses are too slow (about 1.5 s each) to land inside the fade.
+The mirrors are not API entities, so read their state from the "Log state" button's line. Results: https://github.com/esphome/esphome/pull/21144#issuecomment-6278257695

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

@@ -5,3 +5,11 @@
 To make a target "leave" without anyone moving, set the radar's Zone-1 numbers over the target and
 switch the zone type to `Filter` (the count drops to 0 within 0.5 s); set it back to `Disabled` after.
 Writing those numbers blocks the ld2450 loop about 50 ms.
+
+## Zone numbers round trip (#21146)
+
+`scripts/ld2450/zonedrive.py HOST KEY(- for plaintext) set:NAME=VALUE sel:NAME=OPTION wait:S list` sets numbers and
+selects over the API and prints every LD2450 state update. After each set the hub sends the set zone command, queries
+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

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

@@ -10,3 +10,22 @@ 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 its three ports answer 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

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

@@ -0,0 +1,19 @@
+# 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/usb_audio.md

@@ -0,0 +1,52 @@
+# usb_audio
+
+## USB audio on the Waveshare ESP32-S3-ETH (#21081, #11728)
+
+`templates/usb-audio-waveshare-s3-eth-dut.yaml`: ESP-IDF, PoE, logs over the API on Ethernet (the native USB port is
+the host port, so there is no console), `usb_audio` hub, a 48 kHz 16-bit microphone, a 48 kHz 24-bit speaker (many
+speakerphones offer only 24-bit; a wrong format logs the device's alternates), buttons for capture start and stop,
+a non-blocking beep fed from an 8 ms interval with `play(buf, len, 0)` (a blocking `play()` on the main loop trips
+the task watchdog), and a status interval with mic bytes, speaker state and heap. Drive the buttons with
+`scripts/api_button.py IP KEY press "Beep"`. Expect 192 kB/s microphone bytes and the FIFO split
+RX 80 / NPTX 16 / PTX 104 in the build's `defines.h`; with the balanced split the 294-byte OUT pipe is refused
+(`EP MPS (294) exceeds supported limit (128)`). A device whose OUT endpoint is larger than 600 bytes cannot be
+claimed on an S3 at all.
+
+## Music Assistant through sendspin
+
+`templates/usb-audio-sendspin-s3-eth-dut.yaml` overlays the template above with the Apollo CAST-1 wiring: resampler
+speakers into a mixer whose inputs never time out, `speaker_source` media player with the sendspin source, and
+`sendspin: unpaired_access: true`. A `media_player: platform: speaker` is not a media-source consumer and gives
+"Player over its buffer", no audio. Music Assistant finds the device by mDNS within 15 s of boot.
+
+Read the result from the device, not only by ear: sendspin's sync task logs `Lost sync (N us off)` (DEBUG, tag
+`SsSync`) for every correction over 5 ms, a positive N inserts that much silence, and each one is an audible click.
+For the chunk lead histogram, edit the managed library in the build directory,
+`.esphome/build/<name>/managed_components/sendspin__sendspin-cpp/src/sync_task.cpp` (an `SS_LOGD` before the
+late-chunk skip in `decode_chunk()` printing the chunk's lead against `new_audio_client_playtime`), update only that
+file's `size` and sha256 `hash` in the component's `CHECKSUMS.json`, and compile again; deleting `.component_hash` or
+recomputing it makes the manager refuse or refetch. Check the edit is in the image with `strings firmware.ota.bin`.
+A lead below -5 ms makes the library skip the whole chunk; an I2S speaker keeps it within 0.1 ms of zero, which is
+the figure a USB speaker has to match.
+
+Gotchas: wait two minutes after a reboot before the measured stream (safe mode's boot counter write stalls the cores
+for about 140 ms once, 60 to 75 s after boot); with the serial console on, a DEBUG log line per report saturates
+UART0 and trips the task watchdog, so use `logger: baud_rate: 0` and the API log; two overlapping `esphome logs`
+captures double every count; and every audio test must include a pause and resume cycle, since a stream end that
+leaves less than one transfer parked in the driver was what hung the speaker after #11728 merged.
+
+## Controls
+
+Apollo CAST PRO-1 (`templates/cast-pro-1-sendspin-control.yaml`): `Core.yaml` next to it is
+`Integrations/ESPHome/Core.yaml` from ApolloAutomation/CAST_PRO-1, which also defines the `version` substitution.
+Keep its framework log level at ERROR (DEBUG floods driver output and trips the watchdog); the package reboots itself
+into Ethernet-only once it sees a link and appends the MAC suffix to the name. `wifi: enable_on_boot: false` keeps
+sendspin off Wi-Fi.
+
+Nabu Casa Connect AUX-2 (a pre-production unit): build from `packages/aux-2-pre-prod.yaml` at NabuCasa/aux-2 commit
+283f2e64 (dropped in bde41e01), not the public `aux-2.yaml`, whose W5500, codec and I2S pins differ (the public one
+reads W5500 chip ID 0x00 and fails the codec's I2C writes). Point its local `external_components` source at
+`github://NabuCasa/aux-2@main`. Templates `aux-2-preprod-stock-dut.yaml` (I2S codec) and
+`aux-2-preprod-usb-audio-dut.yaml` (the USB speaker as the mixer output via `!extend mixing_speaker`). The console is
+the CH343 (1a86:55d3); first flash over it, OTA after. Forcing the Wi-Fi flag off with `restore_value: no` boot-loops
+when Ethernet fails, so let the package switch itself.

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

@@ -0,0 +1,31 @@
+# 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

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

@@ -0,0 +1,33 @@
+"""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)
+"""
+
+import asyncio
+import sys
+
+from aioesphomeapi import APIClient, ButtonInfo
+
+HOST, KEY = sys.argv[1], sys.argv[2]
+CMD, ARGS = sys.argv[3], sys.argv[4:]
+
+
+async def main() -> None:
+    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
+    await c.connect(login=True)
+    ents, _ = await c.list_entities_services()
+    buttons = {e.name: e for e in ents if isinstance(e, ButtonInfo)}
+    if CMD == "list":
+        print("\n".join(sorted(buttons)))
+    else:
+        for name in ARGS:
+            if name not in buttons:
+                sys.exit(f"no button named {name!r}; have {sorted(buttons)}")
+            c.button_command(buttons[name].key)
+            print("pressed", name)
+            await asyncio.sleep(0.3)
+    await asyncio.sleep(0.5)
+    await c.disconnect()
+
+
+asyncio.run(main())

.agents/skills/hardware-test/scripts/api_outgoing/cycles.py

@@ -0,0 +1,73 @@
+"""Per wake cycle timings from a serial capture of the deep sleep timing config.
+
+usage: cycles.py CAPTURE [LABEL]
+A cycle starts at the boot banner; the numbers are the device's millis() from the timing lines, and the
+capture clock gap from the first line of the cycle to the "Dialing" line.
+"""
+
+import pathlib
+import re
+import statistics
+import sys
+
+cap = (
+    pathlib.Path(sys.argv[1]).read_text(encoding="utf-8", errors="replace").splitlines()
+)
+label = sys.argv[2] if len(sys.argv) > 2 else ""
+TS = re.compile(r"^\[(\d\d):(\d\d):(\d\d)(?:\.(\d+))?\]")
+
+
+def secs(line):
+    m = TS.match(line)
+    if not m:
+        return None
+    h, mi, s, f = m.groups()
+    return int(h) * 3600 + int(mi) * 60 + int(s) + (int(f) / 10 ** len(f) if f else 0)
+
+
+cycles = []
+cur = None
+for line in cap:
+    if "rst:0x" in line or (cur is None and "Log initialized" in line):
+        cur = {"start": secs(line), "reset": line.split("]", 1)[-1].strip()[:60]}
+        cycles.append(cur)
+        continue
+    if cur is None:
+        continue
+    if "Dialing" in line:
+        cur.setdefault("dial_cap", secs(line))
+    m = re.search(r"wifi connected at (\d+) ms", line)
+    if m:
+        cur.setdefault("wifi", int(m.group(1)))
+    m = re.search(r"client connected at (\d+) ms \((.*?)\)", line)
+    if m and "client" not in cur:
+        cur["client"] = int(m.group(1))
+        cur["who"] = m.group(2)
+    m = re.search(r"first HA state '(.*?)' at (\d+) ms", line)
+    if m and "state" not in cur:
+        cur["state"] = int(m.group(2))
+
+print(f"{label} cycles: {len(cycles)}")
+print(
+    f"{'n':>2} {'wifi ms':>8} {'dial +ms':>9} {'client ms':>10} {'state ms':>9} {'client-wifi':>11} {'state-client':>12}  client  reset"
+)
+for i, c in enumerate(cycles, 1):
+    dial = ""
+    if c.get("dial_cap") is not None and c.get("start") is not None:
+        dial = f"{(c['dial_cap'] - c['start']) * 1000:.0f}"
+    cw = c["client"] - c["wifi"] if "client" in c and "wifi" in c else ""
+    sc = c["state"] - c["client"] if "state" in c and "client" in c else ""
+    print(
+        f"{i:>2} {c.get('wifi', ''):>8} {dial:>9} {c.get('client', ''):>10} {c.get('state', ''):>9} {cw:>11} {sc:>12}  {c.get('who', '')}  {c.get('reset', '')[:28]}"
+    )
+for c in cycles:
+    if "client" in c and "wifi" in c:
+        c["client-wifi"] = c["client"] - c["wifi"]
+    if "state" in c and "client" in c:
+        c["state-client"] = c["state"] - c["client"]
+for key in ("wifi", "client", "state", "client-wifi", "state-client"):
+    vals = [c[key] for c in cycles if key in c]
+    if vals:
+        print(
+            f"{key}: n={len(vals)} min={min(vals)} median={statistics.median(vals):.0f} max={max(vals)}"
+        )

.agents/skills/hardware-test/scripts/api_outgoing/wificycles.py

@@ -0,0 +1,107 @@
+"""Per Wi-Fi drop timings from a serial capture of the outgoing connection timing config.
+
+usage: wificycles.py CAPTURE [LABEL]
+A cycle starts at "wifi cycle disabling"; the numbers are the device's millis() from the timing lines.
+"dial" says whether the client that connected first came from the device's own dial ("Dialing" seen after the
+reconnect and before the hello) or from an incoming connection ("Accept" seen first).
+"""
+
+import pathlib
+import re
+import statistics
+import sys
+
+cap = (
+    pathlib.Path(sys.argv[1]).read_text(encoding="utf-8", errors="replace").splitlines()
+)
+label = sys.argv[2] if len(sys.argv) > 2 else ""
+TS = re.compile(r"^\[(\d\d):(\d\d):(\d\d)(?:\.(\d+))?\]")
+
+
+def secs(line):
+    m = TS.match(line)
+    if not m:
+        return None
+    h, mi, se, f = m.groups()
+    return int(h) * 3600 + int(mi) * 60 + int(se) + (int(f) / 10 ** len(f) if f else 0)
+
+
+cycles = []
+cur = None
+loop_max = []
+for line in cap:
+    m = re.search(r"loop time max (\d+) ms", line)
+    if m:
+        loop_max.append(int(m.group(1)))
+    if "wifi cycle disabling" in line:
+        cur = {"order": []}
+        cycles.append(cur)
+        continue
+    if cur is None:
+        continue
+    m = re.search(r"wifi connected at (\d+) ms", line)
+    if m and "wifi" not in cur:
+        cur["wifi"] = int(m.group(1))
+        cur["wifi_cap"] = secs(line)
+    if "Dialing" in line:
+        cur["order"].append("dial")
+        cur["dials"] = cur.get("dials", 0) + 1
+        if "dial_cap" not in cur and "wifi_cap" in cur:
+            cur["dial_cap"] = secs(line)
+        elif "dial_cap" not in cur and "dial_before_wifi_cap" not in cur:
+            cur["dial_before_wifi_cap"] = secs(line)
+    if (
+        re.search(r"client disconnected at \d+ ms \(\d+\.\d+\.\d+\.\d+\)", line)
+        and "wifi" in cur
+        and "client" not in cur
+    ):
+        cur["dial_closed"] = cur.get("dial_closed", 0) + 1
+    if "Accept " in line and "wifi" in cur:
+        cur["order"].append("accept")
+    m = re.search(r"client connected at (\d+) ms \((.*?)\)", line)
+    if m and "wifi" in cur and "client" not in cur:
+        cur["client"] = int(m.group(1))
+        cur["who"] = m.group(2).split(" ")[0]
+        cur["via"] = cur["order"][0] if cur["order"] else "?"
+    m = re.search(r"Connect (failed|timeout)", line)
+    if m:
+        cur.setdefault("connect_errors", 0)
+        cur["connect_errors"] += 1
+
+print(f"{label} cycles: {len(cycles)}")
+print(
+    f"{'n':>2} {'wifi ms':>8} {'dial-wifi cap ms':>16} {'client ms':>10} {'client-wifi':>11}  via     dials closed  client"
+)
+for i, c in enumerate(cycles, 1):
+    cw = c["client"] - c["wifi"] if "client" in c and "wifi" in c else ""
+    c["client-wifi"] = cw
+    dw = ""
+    if "wifi_cap" in c and c.get("wifi_cap") is not None:
+        # the first dial of the cycle, whether it was logged before or after the Wi-Fi line
+        if c.get("dial_before_wifi_cap") is not None:
+            dw = f"{(c['dial_before_wifi_cap'] - c['wifi_cap']) * 1000:.0f}"
+        elif "dial_cap" in c and c["dial_cap"] is not None:
+            dw = f"{(c['dial_cap'] - c['wifi_cap']) * 1000:.0f}"
+    c["dial-wifi"] = dw
+    print(
+        f"{i:>2} {c.get('wifi', ''):>8} {dw:>16} {c.get('client', ''):>10} {cw:>11}  {c.get('via', ''):7s} {c.get('dials', 0):>5} {c.get('dial_closed', 0):>6}  {c.get('who', '')}"
+    )
+for via in ("dial", "accept"):
+    vals = [
+        c["client-wifi"]
+        for c in cycles
+        if c.get("via") == via and c["client-wifi"] != ""
+    ]
+    if vals:
+        print(
+            f"client-wifi via {via}: n={len(vals)} min={min(vals)} median={statistics.median(vals):.0f} max={max(vals)}"
+        )
+dws = [float(c["dial-wifi"]) for c in cycles if c.get("dial-wifi") not in ("", None)]
+if dws:
+    print(
+        f"dial after wifi connected (capture clock): n={len(dws)} min={min(dws):.0f} median={statistics.median(dws):.0f} max={max(dws):.0f}"
+    )
+if loop_max:
+    print(
+        f"loop time max per 5 s: n={len(loop_max)} min={min(loop_max)} median={statistics.median(loop_max):.0f} max={max(loop_max)}"
+    )

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

@@ -0,0 +1,22 @@
+#!/bin/sh
+# cases.sh DEV_IP KEY CAPTURE LABEL : the SEN0395 flow (settings, switches, junk lines, factory reset, reset) against
+# templates/dfrobot-sen0395-dut.yaml, with a serial capture of the device running into CAPTURE
+D=$1; K=$2; LOG=$3; LABEL=$4; PY=${PYTHON:-python3}; CTL="$(dirname "$0")/ctl.py"
+show() { tail -n +$(($1+1)) "$LOG" | sed 's/\x1b\[[0-9;]*m//g' | grep -a 'dfrobot\|Detected\|\[W\]\|\[E\]\|sen\]' | grep -a -v 'JYBSS\|took a long time' | cut -c1-200; }
+step() { n0=$(wc -l < "$LOG"); echo "=== $LABEL: $1 ($(date +%T))"; shift; $PY "$CTL" "$D" "$K" "$@" || { rc=$?; echo "driver failed ($rc), aborting"; exit $rc; }; echo "--- device log:"; show "$n0"; }
+frames() { echo "frames: $(tail -n +$(($1+1)) "$LOG" | grep -a -c 'JYBSS,1') present, $(tail -n +$(($1+1)) "$LOG" | grep -a -c 'JYBSS,0') absent"; }
+n0=$(wc -l < "$LOG"); echo "=== $LABEL: 20 s of frames ($(date +%T))"; sleep 20; frames "$n0"
+step "range 0 to 3 m" "press:Range 0 to 3m" wait:12
+step "range 0 to 9 m" "press:Range 0 to 9m" wait:12
+step "latency 1 s / 2 s" "press:Latency 1s 2s" wait:12
+step "latency 0 / 0" "press:Latency 0 0" wait:12
+step "sensitivity 7" "press:Sensitivity 7" wait:12
+step "LED off then on" "sw:LED=off" wait:10 "sw:LED=on" wait:10
+step "sensor active off then on" "sw:Sensor active=off" wait:10 "sw:Sensor active=on" wait:10
+step "presence via UART off then on" "sw:Presence via UART=off" wait:10 "sw:Presence via UART=on" wait:10
+step "start after boot off then on" "sw:Start after boot=off" wait:10 "sw:Start after boot=on" wait:10
+for n in 100 160 200 220 240 256; do step "junk line of $n bytes" "press:Junk $n" wait:7; done
+step "junk 220 then a command" "press:Junk 220" wait:6 "press:Range 0 to 9m" wait:12
+step "factory reset" "press:Factory reset" wait:15
+step "reset" "press:Reset" wait:15
+n0=$(wc -l < "$LOG"); echo "=== $LABEL: 20 s of frames after ($(date +%T))"; sleep 20; frames "$n0"

.agents/skills/hardware-test/scripts/dfrobot_sen0395/ctl.py

@@ -0,0 +1,63 @@
+"""Drive the SEN0395 test device over the API and print its binary sensor and switch updates.
+usage: ctl.py HOST KEY(- for plaintext) OP [OP ...]   OP: press:NAME | sw:NAME=on|off | wait:SECONDS
+"""
+
+import asyncio
+import sys
+import time
+
+from aioesphomeapi import (
+    APIClient,
+    BinarySensorState,
+    ButtonInfo,
+    SwitchInfo,
+    SwitchState,
+)
+
+HOST, KEY = sys.argv[1], sys.argv[2]
+OPS = sys.argv[3:]
+T0 = time.time()
+
+
+async def main() -> None:
+    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
+    await c.connect(login=True)
+    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)}
+    switches = {e.name: e for e in ents if isinstance(e, SwitchInfo)}
+
+    def on_state(s) -> None:
+        e = by_key.get(s.key)
+        if isinstance(s, BinarySensorState):
+            print(
+                f"{time.time() - T0:7.3f} BIN {e.name} = {'ON' if s.state else 'off'}"
+            )
+        elif isinstance(s, SwitchState):
+            print(
+                f"{time.time() - T0:7.3f} SW  {e.name} = {'on' if s.state else 'off'}"
+            )
+
+    c.subscribe_states(on_state)
+    await asyncio.sleep(1.0)
+    for op in OPS:
+        kind, _, rest = op.partition(":")
+        if kind == "wait":
+            await asyncio.sleep(float(rest))
+        elif kind == "press":
+            if rest not in buttons:
+                sys.exit(f"no button {rest!r}; have {sorted(buttons)}")
+            print(f"{time.time() - T0:7.3f} >>> press {rest}")
+            c.button_command(buttons[rest].key)
+        elif kind == "sw":
+            name, _, val = rest.partition("=")
+            if name not in switches:
+                sys.exit(f"no switch {name!r}; have {sorted(switches)}")
+            print(f"{time.time() - T0:7.3f} >>> switch {name} {val}")
+            c.switch_command(switches[name].key, val == "on")
+        else:
+            sys.exit(f"unknown op {op!r}")
+    await c.disconnect()
+
+
+asyncio.run(main())

.agents/skills/hardware-test/scripts/homeassistant_light/bulb.py

@@ -0,0 +1,78 @@
+"""Read or drive a bulb directly over its own ESPHome API (an HA-side change, independent of the mirror).
+
+usage: bulb.py HOST KEY state | on [brightness 0-1] [ct_mireds|rgb r,g,b] | off | restart
+"""
+
+import asyncio
+import sys
+
+from aioesphomeapi import APIClient, ButtonInfo, LightColorCapability, LightInfo
+
+HOST, KEY, CMD = sys.argv[1], sys.argv[2], sys.argv[3]
+ARGS = sys.argv[4:]
+
+
+async def main() -> None:
+    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
+    await c.connect(login=True)
+    ents, _ = await c.list_entities_services()
+    light = next((e for e in ents if isinstance(e, LightInfo)), None)
+    if light is None:
+        sys.exit("no light entity on this device; is HOST a bulb?")
+    if CMD == "state":
+        fut = asyncio.get_running_loop().create_future()
+
+        def on_state(st):
+            if getattr(st, "key", None) == light.key and not fut.done():
+                fut.set_result(st)
+
+        c.subscribe_states(on_state)
+        st = await asyncio.wait_for(fut, 5)
+        print(
+            f"{light.name}: on={st.state} mode={st.color_mode} bri={st.brightness:.2f} "
+            f"ct={st.color_temperature:.1f} rgb={st.red:.2f}/{st.green:.2f}/{st.blue:.2f} "
+            f"white={st.white:.2f} cold={st.cold_white:.2f} warm={st.warm_white:.2f}"
+        )
+    elif CMD == "on":
+        kw = {"state": True}
+        if ARGS:
+            kw["brightness"] = float(ARGS[0])
+        if len(ARGS) > 1:
+            if "," in ARGS[1]:
+                r, g, b = (float(x) for x in ARGS[1].split(","))
+                kw["rgb"] = (r, g, b)
+                kw["color_mode"] = (
+                    LightColorCapability.RGB
+                    | LightColorCapability.ON_OFF
+                    | LightColorCapability.BRIGHTNESS
+                )
+            else:
+                kw["color_temperature"] = float(ARGS[1])
+                kw["color_mode"] = (
+                    LightColorCapability.COLOR_TEMPERATURE
+                    | LightColorCapability.ON_OFF
+                    | LightColorCapability.BRIGHTNESS
+                )
+        c.light_command(light.key, **kw)
+        print("bulb on", kw)
+    elif CMD == "off":
+        c.light_command(light.key, state=False)
+        print("bulb off")
+    elif CMD == "restart":
+        btn = next(
+            (
+                e
+                for e in ents
+                if isinstance(e, ButtonInfo) and "restart" in e.name.lower()
+            ),
+            None,
+        )
+        if btn is None:
+            sys.exit("no restart button on this device")
+        c.button_command(btn.key)
+        print("bulb restart pressed")
+    await asyncio.sleep(0.5)
+    await c.disconnect()
+
+
+asyncio.run(main())

.agents/skills/hardware-test/scripts/homeassistant_light/heldcase.py

@@ -0,0 +1,71 @@
+"""Held-report cases for esphome#21144 with persistent API connections, so the steps land inside the 3 s fade.
+usage: heldcase.py DEV_IP KEY BULB_IP same|many [BULB_KEY]   (KEY or BULB_KEY of - means plaintext)
+  t0      press "A 50 fade 3s" on the mirror device (3 s fade to 50%)
+  t0+0.7  set the bulb directly to 90% (Home Assistant reports it to the mirror during the fade: held)
+  t0+1.4  same:  press "A 50 fade 3s" again (same target as the running fade)
+          many:  press "A many calls" (16 calls in one loop pass, the last one 100% with a 1 s fade)
+  t0+6.5  read the bulb, press Log state so the mirror prints its state
+"""
+
+import asyncio
+import sys
+import time
+
+from aioesphomeapi import APIClient, ButtonInfo, LightInfo, LightState
+
+DEV, KEY, BULB, CASE = sys.argv[1:5]
+BULB_KEY = sys.argv[5] if len(sys.argv) > 5 else "-"
+if CASE not in ("same", "many"):
+    sys.exit(f"case must be same or many, got {CASE!r}")
+T0 = time.time()
+
+
+def stamp() -> str:
+    return f"{time.time() - T0:6.3f}"
+
+
+async def main() -> None:
+    dev = APIClient(DEV, 6053, None, noise_psk=None if KEY == "-" else KEY)
+    bulb = APIClient(BULB, 6053, None, noise_psk=None if BULB_KEY == "-" else BULB_KEY)
+    await dev.connect(login=True)
+    await bulb.connect(login=True)
+    dents, _ = await dev.list_entities_services()
+    bents, _ = await bulb.list_entities_services()
+    buttons = {e.name: e for e in dents if isinstance(e, ButtonInfo)}
+    blight = next(e for e in bents if isinstance(e, LightInfo))
+    states = {}
+
+    def on_bulb(s) -> None:
+        if isinstance(s, LightState) and s.key == blight.key:
+            states["bulb"] = s
+            print(f"{stamp()} bulb state: on={s.state} bri={s.brightness:.2f}")
+
+    bulb.subscribe_states(on_bulb)
+    await asyncio.sleep(1.0)
+    print(f"{stamp()} >>> bulb to 100% (precondition)")
+    bulb.light_command(blight.key, state=True, brightness=1.0)
+    await asyncio.sleep(4.0)
+    t = time.time()
+    print(f"{stamp()} >>> t0 press A 50 fade 3s")
+    dev.button_command(buttons["A 50 fade 3s"].key)
+    await asyncio.sleep(0.7 - (time.time() - t))
+    print(f"{stamp()} >>> bulb direct to 90%")
+    bulb.light_command(blight.key, state=True, brightness=0.9)
+    await asyncio.sleep(1.4 - (time.time() - t))
+    name = "A 50 fade 3s" if CASE == "same" else "A many calls"
+    print(f"{stamp()} >>> press {name}")
+    dev.button_command(buttons[name].key)
+    await asyncio.sleep(6.5 - (time.time() - t))
+    print(f"{stamp()} >>> press Log state (the mirror's state is in the device log)")
+    dev.button_command(buttons["Log state"].key)
+    await asyncio.sleep(1.0)
+    b = states.get("bulb")
+    print(
+        f"{stamp()} RESULT bulb "
+        + (f"bri={b.brightness:.2f}" if b is not None else "no state")
+    )
+    await dev.disconnect()
+    await bulb.disconnect()
+
+
+asyncio.run(main())

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

@@ -0,0 +1,85 @@
+"""Drive LD2450 numbers and selects over the API while printing every LD2450 state update.
+usage: zonedrive.py HOST KEY(- for plaintext) OP [OP ...]
+  OP: set:NAME=VALUE | sel:NAME=OPTION | wait:SECONDS | list
+Every state update of an entity whose name contains "LD2450" is printed with a timestamp.
+"""
+
+import asyncio
+import sys
+import time
+
+from aioesphomeapi import (
+    APIClient,
+    NumberInfo,
+    NumberState,
+    SelectInfo,
+    SelectState,
+    SensorInfo,
+    SensorState,
+)
+
+HOST, KEY = sys.argv[1], sys.argv[2]
+OPS = sys.argv[3:]
+T0 = time.time()
+
+
+def stamp() -> str:
+    return f"{time.time() - T0:7.3f}"
+
+
+async def main() -> None:
+    c = APIClient(HOST, 6053, None, noise_psk=None if KEY == "-" else KEY)
+    await c.connect(login=True)
+    ents, _ = await c.list_entities_services()
+    by_key = {e.key: e for e in ents}
+    numbers = {e.name: e for e in ents if isinstance(e, NumberInfo)}
+    selects = {e.name: e for e in ents if isinstance(e, SelectInfo)}
+    sensors = {e.name: e for e in ents if isinstance(e, SensorInfo)}
+
+    def on_state(s) -> None:
+        e = by_key.get(s.key)
+        if e is None or "LD2450" not in e.name:
+            return
+        if isinstance(s, NumberState):
+            print(
+                f"{stamp()} NUM {e.name} = {s.state:.0f}{' (missing)' if s.missing_state else ''}"
+            )
+        elif isinstance(s, SelectState):
+            print(f"{stamp()} SEL {e.name} = {s.state}")
+        elif isinstance(s, SensorState) and "Count" in e.name:
+            print(f"{stamp()} CNT {e.name} = {s.state:.0f}")
+
+    c.subscribe_states(on_state)
+    await asyncio.sleep(1.5)
+    for op in OPS:
+        if op == "list":
+            for n in sorted(numbers):
+                print("number:", n)
+            for n in sorted(selects):
+                print("select:", n, selects[n].options)
+            for n in sorted(sensors):
+                if "Count" in n:
+                    print("sensor:", n)
+            continue
+        kind, _, rest = op.partition(":")
+        if kind == "wait":
+            await asyncio.sleep(float(rest))
+            continue
+        name, _, value = rest.partition("=")
+        if kind == "set":
+            if name not in numbers:
+                sys.exit(f"no number named {name!r}; have {sorted(numbers)}")
+            print(f"{stamp()} >>> set {name} = {value}")
+            c.number_command(numbers[name].key, float(value))
+        elif kind == "sel":
+            if name not in selects:
+                sys.exit(f"no select named {name!r}; have {sorted(selects)}")
+            print(f"{stamp()} >>> select {name} = {value}")
+            c.select_command(selects[name].key, value)
+        else:
+            sys.exit(f"unknown op {op!r}")
+        await asyncio.sleep(0.3)
+    await c.disconnect()
+
+
+asyncio.run(main())

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

@@ -0,0 +1,42 @@
+#!/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; }
+  (cd "$WORK" && mosquitto -c mosquitto-ws.conf > mosquitto.out 2>&1 & echo $! > "$WORK/mosquitto.pid"); sleep 25
+  for port in 1883 9001 9002; 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/make_test_ca.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+# make_test_ca.sh BROKER_IP : a throwaway CA and a server certificate for the broker address (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);
+# other-ca.crt is a second CA for the negative case.
+set -e
+IP=$1
+openssl req -x509 -newkey rsa:2048 -nodes -keyout ca.key -out ca.crt -days 30 -subj "/CN=hwtest-ca"
+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 -x509 -newkey rsa:2048 -nodes -keyout other-ca.key -out other-ca.crt -days 30 -subj "/CN=other-ca"
+openssl verify -CAfile ca.crt server.crt

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

@@ -0,0 +1,14 @@
+# 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 WebSocket, and MQTT over WebSocket with TLS (server.crt and
+# server.key from make_test_ca.sh in the same directory). log_type all gives the listener port per connection.
+listener 1883
+protocol mqtt
+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/serial_capture.py

@@ -1,6 +1,6 @@
 """Bounded, timestamped serial capture that always exits and closes the port.
 
-  serial_capture.py PORT SECONDS OUTFILE [--baud 115200] [--released] [--reset] [--append]
+  serial_capture.py PORT SECONDS OUTFILE [--baud 115200] [--released] [--reset] [--append] [--ms]
 
   default      open with DTR/RTS as pyserial leaves them (asserted); fine for ESP devkits and the Pico.
   --released   drive DTR and RTS low before opening: the BW15 and BK7238 CH340 kits strap the boot pin
@@ -76,14 +76,21 @@ def open_port(args: argparse.Namespace, path: str) -> serial.Serial:
     return s
 
 
-def write_line(out, tag: bytes, data: bytes) -> None:
-    stamp = time.strftime("[%H:%M:%S]").encode()
+def write_line(out, tag: bytes, data: bytes, ms: bool = False) -> None:
+    if ms:
+        now = time.time()
+        stamp = (
+            time.strftime("[%H:%M:%S", time.localtime(now))
+            + f".{int(now * 1000) % 1000:03d}]"
+        ).encode()
+    else:
+        stamp = time.strftime("[%H:%M:%S]").encode()
     out.write(stamp + tag + ANSI.sub(b"", SECRET.sub(b"<secret>", data)) + b"\n")
     out.flush()
 
 
-def note(out, text: str) -> None:
-    write_line(out, b"[capture] ", text.encode())
+def note(out, text: str, ms: bool = False) -> None:
+    write_line(out, b"[capture] ", text.encode(), ms)
 
 
 def capture(args: argparse.Namespace, out) -> int:
@@ -102,18 +109,18 @@ def capture(args: argparse.Namespace, out) -> int:
                 if serial_number is None:
                     serial_number, index = identify(path)
                 if path != args.port:
-                    note(out, f"reopened as {path}")
+                    note(out, f"reopened as {path}", args.ms)
             except PORT_ERRORS as err:
-                note(out, f"open failed: {err}")
+                note(out, f"open failed: {err}", args.ms)
                 time.sleep(1)
                 continue
         try:
             data = s.read(4096)
         except PORT_ERRORS as err:
             if buf:  # keep the cut-off line apart from the next boot's first line
-                write_line(out, b"[partial]", buf)
+                write_line(out, b"[partial]", buf, args.ms)
                 buf = b""
-            note(out, f"port lost: {err}")
+            note(out, f"port lost: {err}", args.ms)
             with contextlib.suppress(*PORT_ERRORS):
                 s.close()
             s = None
@@ -125,9 +132,9 @@ def capture(args: argparse.Namespace, out) -> int:
         buf += data
         while b"\n" in buf:
             line, buf = buf.split(b"\n", 1)
-            write_line(out, b"", line.rstrip(b"\r"))
+            write_line(out, b"", line.rstrip(b"\r"), args.ms)
     if buf:
-        write_line(out, b"[partial]", buf)
+        write_line(out, b"[partial]", buf, args.ms)
     if s is not None:
         s.close()
     return received
@@ -144,6 +151,7 @@ def main() -> int:
     ap.add_argument("--released", action="store_true")
     ap.add_argument("--reset", action="store_true")
     ap.add_argument("--append", action="store_true")
+    ap.add_argument("--ms", action="store_true", help="millisecond timestamps")
     args = ap.parse_args()
     with pathlib.Path(args.outfile).open("ab" if args.append else "wb") as out:
         received = capture(args, out)

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

@@ -0,0 +1,12 @@
+#!/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

@@ -0,0 +1,50 @@
+"""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/usb_audio/playurl.py

@@ -0,0 +1,30 @@
+"""Play a URL on the speaker_source media player over the API (no sync task involved).
+
+usage: playurl.py HOST KEY URL [PLAYER_NAME]
+"""
+
+import asyncio
+import sys
+
+from aioesphomeapi import APIClient, MediaPlayerInfo
+
+HOST, KEY, URL = sys.argv[1], sys.argv[2], sys.argv[3]
+PLAYER = sys.argv[4] if len(sys.argv) > 4 else "Player"
+
+
+async def main() -> None:
+    c = APIClient(HOST, 6053, None, noise_psk=KEY)
+    await c.connect(login=True)
+    ents, _ = await c.list_entities_services()
+    players = {e.name: e for e in ents if isinstance(e, MediaPlayerInfo)}
+    print("media players:", sorted(players))
+    if PLAYER not in players:
+        sys.exit(f"no media player named {PLAYER!r}; have {sorted(players)}")
+    p = players[PLAYER]
+    c.media_player_command(p.key, media_url=URL)
+    print("sent play_media to", PLAYER)
+    await asyncio.sleep(1)
+    await c.disconnect()
+
+
+asyncio.run(main())

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

@@ -0,0 +1,17 @@
+#!/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

@@ -0,0 +1,26 @@
+#!/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

@@ -0,0 +1,187 @@
+"""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

@@ -0,0 +1,19 @@
+#!/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

@@ -0,0 +1,25 @@
+#!/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/aux-2-preprod-speaker-player-dut.yaml

@@ -0,0 +1,66 @@
+# 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/aux-2-preprod-stock-dut.yaml

@@ -0,0 +1,23 @@
+# Needs packages/aux-2-pre-prod.yaml from NabuCasa/aux-2 at commit 283f2e64 next to this file, with its local
+# external_components source pointed at github://NabuCasa/aux-2@main (see reference/recipes/usb_audio.md).
+# Nabu Casa Connect AUX-2 on the usb_audio PR tree: stock package (I2S PCM5122 output) as a control.
+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

.agents/skills/hardware-test/templates/aux-2-preprod-usb-audio-dut.yaml

@@ -0,0 +1,39 @@
+# Needs packages/aux-2-pre-prod.yaml from NabuCasa/aux-2 at commit 283f2e64 next to this file, with its local
+# external_components source pointed at github://NabuCasa/aux-2@main (see reference/recipes/usb_audio.md).
+# Nabu Casa Connect AUX-2 on the usb_audio PR tree: the Anker S330 on the USB host port as the mixer output.
+packages:
+  core: !include aux-2-pre-prod.yaml
+
+esphome:
+  name: aux-2-usb-dut
+  name_add_mac_suffix: false
+
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
+
+api:
+  encryption:
+    key: !secret api_key
+
+logger:
+  level: DEBUG
+  baud_rate: 0
+
+sendspin:
+  unpaired_access: true
+
+usb_audio:
+  id: usb_audio_id
+
+speaker:
+  - platform: usb_audio
+    id: usb_speaker
+    usb_audio_id: usb_audio_id
+    sample_rate: 48000
+    bits_per_sample: 24bit
+    num_channels: 2
+    buffer_size: 28800
+    write_timeout: 50ms
+  - id: !extend mixing_speaker
+    output_speaker: usb_speaker

.agents/skills/hardware-test/templates/cast-pro-1-sendspin-control.yaml

@@ -0,0 +1,27 @@
+# CAST PRO-1 control for the sendspin sync comparison: Apollo's current package, DEBUG logging as on the S3.
+esphome:
+  name: "cast-pro-1-dut"
+  friendly_name: CAST PRO-1 test
+  project:
+    name: "ApolloAutomation.CAST_PRO-1"
+    version: ${version}
+
+packages:
+  core: !include Core.yaml
+
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
+  enable_on_boot: false
+
+logger:
+  level: DEBUG
+
+api:
+  encryption:
+    key: !secret api_key
+
+sendspin:
+  manufacturer: Apollo
+  model: CAST PRO-1 control
+  unpaired_access: true

.agents/skills/hardware-test/templates/deep-sleep-outgoing-dut.yaml

@@ -0,0 +1,46 @@
+# Deep sleep wake timing for the outgoing API connection: boot -> dial -> client hello -> first HA state.
+esphome:
+  name: deep-sleep-dut
+  on_boot:
+    priority: -100
+    then:
+      - lambda: ESP_LOGI("timing", "setup done at %u ms", (unsigned) millis());
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+logger:
+  level: DEBUG
+
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
+  fast_connect: true
+  on_connect:
+    - lambda: ESP_LOGI("timing", "wifi connected at %u ms", (unsigned) millis());
+
+api:
+  encryption:
+    key: !secret api_key
+  outgoing_connection:
+  on_client_connected:
+    - lambda: ESP_LOGI("timing", "client connected at %u ms (%s %s)", (unsigned) millis(), client_info.c_str(), client_address.c_str());
+  on_client_disconnected:
+    - lambda: ESP_LOGI("timing", "client disconnected at %u ms", (unsigned) millis());
+
+ota:
+  - platform: esphome
+
+text_sensor:
+  - platform: homeassistant
+    id: ha_state
+    entity_id: light.ENTITY
+    on_value:
+      - lambda: ESP_LOGI("timing", "first HA state '%s' at %u ms", x.c_str(), (unsigned) millis());
+
+deep_sleep:
+  id: ds
+  run_duration: 15s
+  sleep_duration: 15s

.agents/skills/hardware-test/templates/dfrobot-sen0395-dut.yaml

@@ -0,0 +1,186 @@
+# DFRobot SEN0395 on an ESP32 DevKit V1: V to VIN (5 V), G to GND, sensor TX to GPIO16 (RX2), sensor RX to GPIO17 (TX2),
+# IO2 to GPIO18, I1 unconnected. Settings buttons, the four switches and junk-line buttons whose echo and
+# "is not recognized" reply come back as lines of known length (220 and 240 bytes give replies over 252 chars).
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+logger:
+  level: VERBOSE
+  logs:
+    api: DEBUG
+    api.connection: DEBUG
+    api.service: DEBUG
+    wifi: DEBUG
+    mdns: DEBUG
+    scheduler: DEBUG
+    component: DEBUG
+    esp32: DEBUG
+    uart: DEBUG
+
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
+
+api:
+  encryption:
+    key: !secret api_key
+  reboot_timeout: 0s
+
+ota:
+  - platform: esphome
+
+uart:
+  id: mmwave_uart
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+  baud_rate: 115200
+
+dfrobot_sen0395:
+  id: mmwave
+  uart_id: mmwave_uart
+
+binary_sensor:
+  - platform: dfrobot_sen0395
+    dfrobot_sen0395_id: mmwave
+    name: Detected via UART
+    id: uart_detected
+  - platform: gpio
+    name: Detected via GPIO
+    device_class: motion
+    pin:
+      number: GPIO18
+      mode: INPUT_PULLDOWN
+
+switch:
+  - platform: dfrobot_sen0395
+    dfrobot_sen0395_id: mmwave
+    type: sensor_active
+    name: Sensor active
+  - platform: dfrobot_sen0395
+    dfrobot_sen0395_id: mmwave
+    type: presence_via_uart
+    name: Presence via UART
+  - platform: dfrobot_sen0395
+    dfrobot_sen0395_id: mmwave
+    type: turn_on_led
+    name: LED
+  - platform: dfrobot_sen0395
+    dfrobot_sen0395_id: mmwave
+    type: start_after_boot
+    name: Start after boot
+
+button:
+  - platform: template
+    name: Range 0 to 3m
+    on_press:
+      - dfrobot_sen0395.settings:
+          id: mmwave
+          detection_segments:
+            - [0cm, 3m]
+  - platform: template
+    name: Range 0 to 9m
+    on_press:
+      - dfrobot_sen0395.settings:
+          id: mmwave
+          detection_segments:
+            - [0cm, 9m]
+  - platform: template
+    name: Latency 1s 2s
+    on_press:
+      - dfrobot_sen0395.settings:
+          id: mmwave
+          output_latency:
+            delay_after_detect: 1s
+            delay_after_disappear: 2s
+  - platform: template
+    name: Latency 0 0
+    on_press:
+      - dfrobot_sen0395.settings:
+          id: mmwave
+          output_latency:
+            delay_after_detect: 0s
+            delay_after_disappear: 0s
+  - platform: template
+    name: Sensitivity 7
+    on_press:
+      - dfrobot_sen0395.settings:
+          id: mmwave
+          sensitivity: 7
+  - platform: template
+    name: Factory reset
+    on_press:
+      - dfrobot_sen0395.settings:
+          id: mmwave
+          factory_reset: true
+  - platform: template
+    name: Reset
+    on_press:
+      - dfrobot_sen0395.reset:
+          id: mmwave
+  - platform: template
+    name: Junk 100
+    on_press:
+      - uart.write:
+          id: mmwave_uart
+          data: !lambda |-
+            std::vector<uint8_t> v(100, 'x');
+            v.push_back('\r');
+            v.push_back('\n');
+            return v;
+  - platform: template
+    name: Junk 160
+    on_press:
+      - uart.write:
+          id: mmwave_uart
+          data: !lambda |-
+            std::vector<uint8_t> v(160, 'x');
+            v.push_back('\r');
+            v.push_back('\n');
+            return v;
+  - platform: template
+    name: Junk 200
+    on_press:
+      - uart.write:
+          id: mmwave_uart
+          data: !lambda |-
+            std::vector<uint8_t> v(200, 'x');
+            v.push_back('\r');
+            v.push_back('\n');
+            return v;
+  - platform: template
+    name: Junk 220
+    on_press:
+      - uart.write:
+          id: mmwave_uart
+          data: !lambda |-
+            std::vector<uint8_t> v(220, 'x');
+            v.push_back('\r');
+            v.push_back('\n');
+            return v;
+  - platform: template
+    name: Junk 240
+    on_press:
+      - uart.write:
+          id: mmwave_uart
+          data: !lambda |-
+            std::vector<uint8_t> v(240, 'x');
+            v.push_back('\r');
+            v.push_back('\n');
+            return v;
+  - platform: template
+    name: Junk 256
+    on_press:
+      - uart.write:
+          id: mmwave_uart
+          data: !lambda |-
+            std::vector<uint8_t> v(256, 'x');
+            v.push_back('\r');
+            v.push_back('\n');
+            return v;
+
+interval:
+  - interval: 30s
+    then:
+      - lambda: 'ESP_LOGI("sen", "alive uart_detected=%d heap=%u", id(uart_detected).state, (unsigned) esp_get_free_heap_size());'

.agents/skills/hardware-test/templates/globals-storage-dut.yaml

@@ -0,0 +1,66 @@
+# Restoring globals with every storage choice; each boot bumps the counters, logs them with the reset reason, saves
+# and syncs; odd boots soft restart, even boots deep sleep (ESP32) or idle (D1 mini). The host's reset pulse and a
+# power cut give the other reset kinds.
+logger:
+  level: DEBUG
+
+preferences:
+  flash_write_interval: 1s
+
+globals:
+  - id: cnt_rtc
+    type: int
+    restore_value: true
+    storage: rtc
+    initial_value: "0"
+  - id: cnt_flash
+    type: int
+    restore_value: true
+    storage: flash
+    initial_value: "0"
+  - id: cnt_default
+    type: int
+    restore_value: true
+    initial_value: "0"
+  - id: str_rtc
+    type: std::string
+    restore_value: true
+    storage: rtc
+    max_restore_data_length: 24
+    initial_value: '"fresh"'
+  - id: arr_rtc
+    type: uint8_t[2]
+    restore_value: true
+    storage: rtc
+    initial_value: "{0, 0}"
+
+esphome:
+  on_boot:
+    priority: -100
+    then:
+      - lambda: |-
+          id(cnt_rtc) += 1;
+          id(cnt_flash) += 1;
+          id(cnt_default) += 1;
+          id(arr_rtc)[0] += 1;
+          id(arr_rtc)[1] += 2;
+          char buf[24];
+          snprintf(buf, sizeof(buf), "boot%d", id(cnt_rtc));
+          ESP_LOGI("gl", "restored rtc=%d flash=%d default=%d str='%s' arr=%u/%u (values before this boot's bump: one less)",
+                   id(cnt_rtc) - 1, id(cnt_flash) - 1, id(cnt_default) - 1, id(str_rtc).c_str(), id(arr_rtc)[0] - 1, id(arr_rtc)[1] - 2);
+          id(str_rtc) = buf;
+      - delay: 2s
+      - lambda: |-
+          global_preferences->sync();
+          ESP_LOGI("gl", "saved rtc=%d flash=%d default=%d str='%s' arr=%u/%u", id(cnt_rtc), id(cnt_flash), id(cnt_default),
+                   id(str_rtc).c_str(), id(arr_rtc)[0], id(arr_rtc)[1]);
+      - if:
+          condition:
+            lambda: 'return id(cnt_rtc) % 2 == 1;'
+          then:
+            - delay: 3s
+            - lambda: 'ESP_LOGI("gl", "odd boot, soft restart now"); App.safe_reboot();'
+
+button:
+  - platform: restart
+    name: Restart

.agents/skills/hardware-test/templates/homeassistant-light-dut.yaml

@@ -0,0 +1,159 @@
+# shared part: two Home Assistant lights mirrored on the device plus buttons that drive them
+esphome:
+  # A local change made before the light core's first write (b19a776 sends it instead of merging it).
+  on_boot:
+    priority: -100
+    then:
+      - lambda: 'ESP_LOGI("halight", "on_boot turning B on at 35 percent before the first write");'
+      - light.turn_on:
+          id: bulb_b
+          brightness: 35%
+logger:
+  level: VERBOSE
+  logs:
+    api: DEBUG
+    api.connection: DEBUG
+    api.service: DEBUG
+    wifi: DEBUG
+    scheduler: DEBUG
+    component: DEBUG
+    sensor: DEBUG
+    mdns: DEBUG
+    ota: DEBUG
+    socket: DEBUG
+    esp-idf: DEBUG
+    preferences: DEBUG
+
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
+
+api:
+  encryption:
+    key: !secret api_key
+  reboot_timeout: 0s
+
+ota:
+  - platform: esphome
+
+light:
+  - platform: homeassistant
+    id: bulb_a
+    name: Mirror A
+    entity_id: light.ENTITY_A
+    report_timeout: 5s
+    on_turn_on:
+      - logger.log: "bulb_a on_turn_on"
+    on_turn_off:
+      - logger.log: "bulb_a on_turn_off"
+  - platform: homeassistant
+    id: bulb_b
+    name: Mirror B
+    entity_id: light.ENTITY_B
+    report_timeout: 5s
+
+button:
+  - platform: template
+    name: A warm 40
+    id: a_warm_40
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 40%
+          color_temperature: 370 mireds
+  - platform: template
+    name: A cool 100
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 100%
+          color_temperature: 153 mireds
+  - platform: template
+    name: A red
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 80%
+          red: 100%
+          green: 0%
+          blue: 0%
+  - platform: template
+    name: A green dim
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 20%
+          red: 0%
+          green: 100%
+          blue: 0%
+  - platform: template
+    name: A brightness only 60
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 60%
+  - platform: template
+    name: A transition 100
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 100%
+          transition_length: 3s
+  - platform: template
+    name: A flash
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          flash_length: 1s
+  - platform: template
+    name: A off
+    on_press:
+      - light.turn_off: bulb_a
+  - platform: template
+    name: A toggle
+    on_press:
+      - light.toggle: bulb_a
+  - platform: template
+    name: B warm 50
+    on_press:
+      - light.turn_on:
+          id: bulb_b
+          brightness: 50%
+          color_temperature: 300 mireds
+  - platform: template
+    name: B off
+    on_press:
+      - light.turn_off: bulb_b
+  - platform: template
+    name: A 50 fade 3s
+    on_press:
+      - light.turn_on:
+          id: bulb_a
+          brightness: 50%
+          transition_length: 3s
+  - platform: template
+    name: A many calls
+    on_press:
+      - lambda: |-
+          for (int i = 0; i < 16; i++) {
+            id(bulb_a).make_call().set_brightness(i == 15 ? 1.0f : 0.6f).set_transition_length(1000).perform();
+          }
+  - platform: template
+    name: Log state
+    on_press:
+      - lambda: |-
+          auto v = id(bulb_a).current_values;
+          ESP_LOGI("halight", "A: on=%d mode=%d bri=%.2f ct=%.1f rgb=%.2f/%.2f/%.2f  B: on=%d bri=%.2f",
+                   v.is_on(), (int) v.get_color_mode(), v.get_brightness(), v.get_color_temperature(),
+                   v.get_red(), v.get_green(), v.get_blue(), id(bulb_b).current_values.is_on(),
+                   id(bulb_b).current_values.get_brightness());
+
+interval:
+  - interval: 30s
+    then:
+      - lambda: |-
+          auto v = id(bulb_a).current_values;
+          ESP_LOGI("halight", "alive A: on=%d mode=%d bri=%.2f ct=%.1f rgb=%.2f/%.2f/%.2f  B: on=%d bri=%.2f",
+                   v.is_on(), (int) v.get_color_mode(), v.get_brightness(), v.get_color_temperature(),
+                   v.get_red(), v.get_green(), v.get_blue(), id(bulb_b).current_values.is_on(),
+                   id(bulb_b).current_values.get_brightness());

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

@@ -0,0 +1,88 @@
+# 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/outgoing-wifi-drop-dut.yaml

@@ -0,0 +1,55 @@
+# Mains build (no deep sleep): outgoing API connection timing after a Wi-Fi drop, and the loop cost while a
+# connect is pending or the network is down.
+esphome:
+  name: wifi-drop-dut
+
+esp32:
+  board: esp32dev
+  framework:
+    type: esp-idf
+
+logger:
+  level: DEBUG
+
+wifi:
+  ssid: !secret wifi_ssid
+  password: !secret wifi_password
+  fast_connect: true
+  on_connect:
+    - lambda: ESP_LOGI("timing", "wifi connected at %u ms", (unsigned) millis());
+  on_disconnect:
+    - lambda: ESP_LOGI("timing", "wifi disconnected at %u ms", (unsigned) millis());
+
+api:
+  encryption:
+    key: !secret api_key
+  reboot_timeout: 0s
+  outgoing_connection:
+    delay: 2s
+  on_client_connected:
+    - lambda: ESP_LOGI("timing", "client connected at %u ms (%s %s)", (unsigned) millis(), client_info.c_str(), client_address.c_str());
+  on_client_disconnected:
+    - lambda: ESP_LOGI("timing", "client disconnected at %u ms (%s)", (unsigned) millis(), client_info.c_str());
+
+ota:
+  - platform: esphome
+
+debug:
+  update_interval: 5s
+
+sensor:
+  - platform: debug
+    loop_time:
+      name: Loop Time
+      on_value:
+        - lambda: ESP_LOGI("timing", "loop time max %.0f ms over the last 5 s at %u ms", x, (unsigned) millis());
+
+button:
+  - platform: template
+    name: Wifi cycle
+    on_press:
+      - lambda: ESP_LOGI("timing", "wifi cycle disabling at %u ms", (unsigned) millis());
+      - wifi.disable:
+      - delay: 4s
+      - lambda: ESP_LOGI("timing", "wifi cycle enabling at %u ms", (unsigned) millis());
+      - wifi.enable:

.agents/skills/hardware-test/templates/usb-audio-sendspin-s3-eth-dut.yaml

@@ -0,0 +1,76 @@
+# Music Assistant target: the plain USB audio template plus the CAST-1 style sendspin wiring (resampler speakers
+# into a mixer whose inputs never time out, speaker_source media player, sendspin hub and sources).
+packages:
+  base: !include usb-audio-waveshare-s3-eth-dut.yaml
+
+# Logs over the API only: a DEBUG line per report would saturate UART0 and trip the task watchdog.
+logger:
+  baud_rate: 0
+
+speaker:
+  - id: !extend usb_speaker
+    buffer_size: 28800
+    write_timeout: 50ms
+  - platform: mixer
+    id: mixer_speaker_id
+    output_speaker: usb_speaker
+    num_channels: 2
+    task_stack_in_psram: true
+    source_speakers:
+      - id: announcement_mixer_input
+        timeout: never
+      - id: media_mixer_input
+        timeout: never
+  - platform: resampler
+    id: announcement_resampling_speaker
+    output_speaker: announcement_mixer_input
+    sample_rate: 48000
+    bits_per_sample: 16
+  - platform: resampler
+    id: media_resampling_speaker
+    output_speaker: media_mixer_input
+    sample_rate: 48000
+    bits_per_sample: 16
+
+sendspin:
+  id: sendspin_hub
+  # PSRAM stack skews time sync; keep internal
+  task_stack_in_psram: false
+  manufacturer: Waveshare
+  model: ESP32-S3-ETH USB audio
+  firmware_version: "0.1"
+  unpaired_access: true
+
+media_source:
+  - platform: sendspin
+    id: sendspin_source
+  - platform: audio_http
+    id: http_media_source
+    buffer_size: 500000
+  - platform: audio_http
+    id: http_announcement_source
+    buffer_size: 250000
+
+media_player:
+  - platform: sendspin
+    id: sendspin_group_media_player
+    name: Sendspin Player
+  - platform: speaker_source
+    id: external_media_player
+    name: Player
+    volume_increment: 0.05
+    announcement_pipeline:
+      format: FLAC
+      num_channels: 1
+      sample_rate: 48000
+      speaker: announcement_resampling_speaker
+      sources:
+        - http_announcement_source
+    media_pipeline:
+      speaker: media_resampling_speaker
+      format: FLAC
+      num_channels: 2
+      sample_rate: 48000
+      sources:
+        - sendspin_source
+        - http_media_source

.agents/skills/hardware-test/templates/usb-audio-waveshare-s3-eth-dut.yaml

@@ -0,0 +1,142 @@
+# Waveshare ESP32-S3-ETH: USB host for a speakerphone (usb_audio), logs over Ethernet, the USB port is the host port
+esphome:
+  name: usb-audio-dut
+
+esp32:
+  board: esp32-s3-devkitc-1
+  variant: esp32s3
+  flash_size: 16MB
+  framework:
+    type: esp-idf
+
+psram:
+  mode: octal
+  speed: 80MHz
+
+logger:
+  level: DEBUG
+  hardware_uart: UART0
+  logs:
+    usb_host: DEBUG
+
+ethernet:
+  type: W5500
+  clk_pin: GPIO13
+  mosi_pin: GPIO11
+  miso_pin: GPIO12
+  cs_pin: GPIO14
+  interrupt_pin: GPIO10
+  reset_pin: GPIO9
+
+api:
+  encryption:
+    key: !secret api_key
+  reboot_timeout: 0s
+
+ota:
+  - platform: esphome
+
+usb_audio:
+  id: usb_audio_id
+
+microphone:
+  - platform: usb_audio
+    id: usb_mic
+    usb_audio_id: usb_audio_id
+    sample_rate: 48000
+    bits_per_sample: 16bit
+    num_channels: 2
+    buffer_size: 9600
+    on_data:
+      - lambda: |-
+          id(mic_bytes) += x.size();
+          id(mic_chunks) += 1;
+
+speaker:
+  - platform: usb_audio
+    id: usb_speaker
+    usb_audio_id: usb_audio_id
+    sample_rate: 48000
+    bits_per_sample: 24bit
+    num_channels: 2
+    buffer_size: 9600
+    write_timeout: 20ms
+
+globals:
+  - id: beep_left
+    type: int
+    initial_value: "0"
+  - id: beep_written
+    type: uint32_t
+    initial_value: "0"
+  - id: beep_short
+    type: uint32_t
+    initial_value: "0"
+  - id: beep_phase
+    type: float
+    initial_value: "0"
+  - id: mic_bytes
+    type: uint32_t
+    initial_value: "0"
+  - id: mic_chunks
+    type: uint32_t
+    initial_value: "0"
+
+button:
+  - platform: template
+    name: Mic start
+    on_press:
+      - microphone.capture: usb_mic
+  - platform: template
+    name: Mic stop
+    on_press:
+      - microphone.stop_capture: usb_mic
+  - platform: template
+    name: Beep
+    on_press:
+      - lambda: |-
+          // 2 s of a 1 kHz tone at 48 kHz 24-bit stereo, fed 10 ms at a time from the interval below
+          id(beep_left) = 200;
+          id(beep_written) = 0;
+          id(beep_short) = 0;
+          id(beep_phase) = 0.0f;
+          id(usb_speaker).start();
+          ESP_LOGI("uatest", "beep started");
+  - platform: template
+    name: Speaker stop
+    on_press:
+      - speaker.stop: usb_speaker
+  - platform: template
+    name: Restart
+    on_press:
+      - lambda: App.safe_reboot();
+
+interval:
+  - interval: 8ms
+    then:
+      - lambda: |-
+          if (id(beep_left) <= 0) return;
+          // 10 ms of 48 kHz stereo 24-bit samples, 3 bytes little-endian per sample
+          static uint8_t buf[480 * 2 * 3];
+          float phase = id(beep_phase);
+          for (int i = 0; i < 480; i++) {
+            int32_t s = (int32_t) (1500000.0f * sinf(phase));
+            phase += 2.0f * 3.14159265f * 1000.0f / 48000.0f;
+            if (phase > 6.2831853f) phase -= 6.2831853f;
+            for (int c = 0; c < 2; c++) {
+              uint8_t *o = buf + (i * 2 + c) * 3;
+              o[0] = s & 0xFF; o[1] = (s >> 8) & 0xFF; o[2] = (s >> 16) & 0xFF;
+            }
+          }
+          size_t n = id(usb_speaker).play(buf, sizeof(buf), 0);
+          if (n == 0) { id(beep_short) += 1; return; }  // not accepted yet, try the same chunk next time
+          id(beep_phase) = phase;
+          id(beep_written) += n;
+          id(beep_left) -= 1;
+          if (id(beep_left) == 0) ESP_LOGI("uatest", "beep done: %u bytes queued, %u retries", (unsigned) id(beep_written), (unsigned) id(beep_short));
+  - interval: 5s
+    then:
+      - lambda: |-
+          ESP_LOGI("uatest", "mic capturing=%d bytes=%u chunks=%u | speaker running=%d | heap free %u",
+                   id(usb_mic).is_running(), (unsigned) id(mic_bytes), (unsigned) id(mic_chunks),
+                   id(usb_speaker).is_running(), (unsigned) heap_caps_get_free_size(MALLOC_CAP_INTERNAL));

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

@@ -0,0 +1,136 @@
+# 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'));
+          }

.devcontainer/devcontainer.json

@@ -28,7 +28,6 @@
         // python
         "ms-python.python",
         "ms-python.pylint",
-        "ms-python.flake8",
         "charliermarsh.ruff",
         "visualstudioexptteam.vscodeintellicode",
         // yaml
@@ -48,9 +47,6 @@
         "pylint.args": [
           "--rcfile=${workspaceFolder}/pyproject.toml"
         ],
-        "flake8.args": [
-          "--config=${workspaceFolder}/.flake8"
-        ],
         "ruff.configuration": "${workspaceFolder}/pyproject.toml",
         "[python]": {
           // VS will say "Value is not accepted" before building the devcontainer, but the warning

.flake8

@@ -1,42 +0,0 @@
-[flake8]
-max-line-length = 120
-# Following 4 for black compatibility
-# E501: line too long
-# W503: Line break occurred before a binary operator
-# E203: Whitespace before ':'
-# D202 No blank lines allowed after function docstring
-
-# TODO fix flake8
-# D100 Missing docstring in public module
-# D101 Missing docstring in public class
-# D102 Missing docstring in public method
-# D103 Missing docstring in public function
-# D104 Missing docstring in public package
-# D105 Missing docstring in magic method
-# D107 Missing docstring in __init__
-# D200 One-line docstring should fit on one line with quotes
-# D205 1 blank line required between summary line and description
-# D209 Multi-line docstring closing quotes should be on a separate line
-# D400 First line should end with a period
-# D401 First line should be in imperative mood
-
-ignore =
-  E501,
-  W503,
-  E203,
-  D202,
-
-  D100,
-  D101,
-  D102,
-  D103,
-  D104,
-  D105,
-  D107,
-  D200,
-  D205,
-  D209,
-  D400,
-  D401,
-
-exclude = api_pb2.py

.github/workflows/ci.yml

@@ -313,6 +313,7 @@ jobs:
           - "3.12"
           - "3.13"
           - "3.14"
+          - "3.15"
         os:
           - ubuntu-latest
           - macOS-latest
@@ -629,7 +630,7 @@ jobs:
             apt-get install -y libc6-dbg
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@f842b9a3ffe213dbb81768fd7f7eeb4dfcf1c369 # v5.4.2
+        uses: CodSpeedHQ/action@821a40cd6c80e3cfe387caf55668287addd808da # v5.5.0
         with:
           run: |
             . venv/bin/activate
@@ -1006,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 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 SOC_RISCV_COPROC_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 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 SOC_LP_CORE_SUPPORTED --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 USE_ESP32_VARIANT_ESP32C6 --grep USE_OPENTHREAD --grep USE_ZIGBEE
+            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
             tidy_environment: esp32c6-idf-tidy
 
     steps:

.github/workflows/codeql.yml

@@ -56,7 +56,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/init@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/analyze@6f2ac81f5cd81fe351a197ba0b00d91d03cd2aee # v4.39.0
         with:
           category: "/language:${{matrix.language}}"

.github/workflows/lock.yml

@@ -14,4 +14,4 @@ jobs:
     permissions:
       issues: write         # issues.lock on closed issues
       pull-requests: write  # issues.lock on closed pull requests
-    uses: esphome/workflows/.github/workflows/lock.yml@cc3e76de337dc59bc1cba8da58d963cd23b873f1  # 2026.9.0
+    uses: esphome/workflows/.github/workflows/lock.yml@31d160e5f0ffa0ee65d5b27cb55c153d415f2abe  # 2026.10.2

.github/workflows/matchers/lint-python.json

@@ -1,39 +0,0 @@
-{
-  "problemMatcher": [
-    {
-      "owner": "ruff",
-      "severity": "error",
-      "pattern": [
-        {
-          "regexp": "^(.*): (Please format this file with the ruff formatter)",
-          "file": 1,
-          "message": 2
-        }
-      ]
-    },
-    {
-      "owner": "flake8",
-      "severity": "error",
-      "pattern": [
-          {
-          "regexp": "^(.*):(\\d+): ([EFCDNW]\\d{3}.*)$",
-          "file": 1,
-          "line": 2,
-          "message": 3
-          }
-      ]
-    },
-    {
-      "owner": "pylint",
-      "severity": "error",
-      "pattern": [
-        {
-          "regexp": "^(.*):(\\d+): (\\[[EFCRW]\\d{4}\\(.*\\),.*\\].*)$",
-          "file": 1,
-          "line": 2,
-          "message": 3
-        }
-      ]
-    }
-  ]
-}

.github/workflows/stale.yml

@@ -16,7 +16,7 @@ jobs:
     # No GITHUB_TOKEN permissions: the reusable workflow mints an ESPHome
     # GitHub App token so the labels, comments and closures come from
     # esphome[bot] instead of github-actions[bot].
-    uses: esphome/workflows/.github/workflows/stale.yml@4fbce13026c393d6eb6b247e394dcd9ef1af76c2  # main
+    uses: esphome/workflows/.github/workflows/stale.yml@31d160e5f0ffa0ee65d5b27cb55c153d415f2abe  # main
     secrets:
       ESPHOME_GITHUB_APP_PRIVATE_KEY: ${{ secrets.ESPHOME_GITHUB_APP_PRIVATE_KEY }}
     with:

.github/workflows/sync-device-classes.yml

@@ -85,7 +85,7 @@ jobs:
       - name: Verify prek clean
         # Second pass: re-run all hooks against the now-fixed tree.
         # Auto-fixers exit 0 (nothing to change); any remaining failure
-        # from a check-only hook (flake8 / yamllint / ci-custom) is a
+        # from a check-only hook (yamllint / ci-custom) is a
         # real issue and fails the workflow loudly. Same PREK_SKIP list as
         # above for the same reasons.
         env:

.pre-commit-config.yaml

@@ -10,21 +10,13 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.17.0
+    rev: v0.17.1
     hooks:
       # Run the linter.
       - id: ruff
         args: [--fix]
       # Run the formatter.
       - id: ruff-format
-  - repo: https://github.com/PyCQA/flake8
-    rev: 7.4.1
-    hooks:
-      - id: flake8
-        additional_dependencies:
-          - flake8-docstrings==1.7.0
-          - pydocstyle==5.1.1
-        files: ^(esphome|tests)/.+\.py$
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v5.0.0
     hooks:
@@ -46,7 +38,7 @@ repos:
       - id: yamllint
         exclude: ^(\.clang-format|\.clang-tidy)$
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v13.0.1
+    rev: v22.1.8
     hooks:
       - id: clang-format
         types_or: [c, c++]

AGENTS.md

@@ -55,7 +55,7 @@ file does, and it is the authority when they disagree. The most useful starting
 *   https://developers.esphome.io/contributing/code/ - contribution rules, public API and breaking changes.
 
 *   **Formatting:**
-    *   **Python:** Uses `ruff` and `flake8` for linting and formatting. Configuration is in `pyproject.toml`.
+    *   **Python:** Uses `ruff` for linting and formatting. Configuration is in `pyproject.toml`.
     *   **C++:** Uses `clang-format` for formatting. Configuration is in `.clang-format`.
 
 *   **Naming Conventions:**
@@ -80,13 +80,15 @@ file does, and it is the authority when they disagree. The most useful starting
         ```python
         # Bad - looks up CONF_BLAH twice
         if CONF_BLAH in config:
-            cg.add(var.set_blah(config[CONF_BLAH]))
+            cg.add(var.set_blah_ms(config[CONF_BLAH].total_milliseconds))
 
         # Good - single lookup, value bound inline
         if (blah := config.get(CONF_BLAH)) is not None:
-            cg.add(var.set_blah(blah))
+            cg.add(var.set_blah_ms(blah.total_milliseconds))
         ```
         The same applies to `while` loops and comprehensions where it avoids recomputing a value. Don't contort code to use it — reach for `:=` only when it genuinely cuts repetition or an extra assignment line.
+        When the setter takes the value unchanged, use `cg.add_optional(var.set_blah, config.get(CONF_BLAH))`
+        instead; it is not awaited, and it skips only `None`, so `0` and `False` are still set.
 
 *   **C++ Field Visibility:**
     *   **Prefer `protected`:** Use `protected` for most class fields to enable extensibility and testing. Fields should be `lower_snake_case_with_trailing_underscore_`.
@@ -208,8 +210,14 @@ file does, and it is the authority when they disagree. The most useful starting
     *   **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`, `reverse_bits`, `encode_uint16`);
-        pick the helper's polynomial and bit-order arguments instead of writing a CRC loop.
+    *   **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`); 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.
+        A child sensor that skips repeated values is `SUB_SENSOR_WITH_DEDUP(name, type)`.
     *   **An unset float is `NAN`**, not `optional<float>`; the optional costs 4 to 8 bytes of padding per member.
     *   **`PollingComponent` first runs `update()`** after a random share of the interval; call `this->update()` at the
         end of `setup()` when the entities need a state at boot.
@@ -429,6 +437,22 @@ file does, and it is the authority when they disagree. The most useful starting
           and `await cg.add_variable(var.set_bus, config[CONF_BUS_ID])`; both skip a `None` value, so pass
           `config.get(KEY)` for an optional key, and return what they created. Use `cg.register_parented` for `set_parent`.
 
+        - **Hub forwarding entities need no C++ class:** a button, switch, number or select that only calls its hub
+          uses `button.ApplyButton` (`switch.ApplySwitch`, `number.ApplyNumber`, `select.ApplySelect`) in its schema
+          and `apply=` on the `sub_*` call. The body is a call on the hub with `entity` and `state`, `value` or
+          `index`/`option` in scope; on a switch, number or select `publish="before"` or `"after"` publishes the state.
+          ```python
+          switches = switch.sub_switches(config, parent=hub)
+          await switches(CONF_BLUETOOTH, None, apply="set_bluetooth(state)", publish="after")
+          ```
+
+        - **Other codegen helpers:** `uart.new_uart_component(config, *ctor_args)` (and `i2c.new_i2c_component`,
+          `spi.new_spi_component`, `modbus.new_modbus_client_component`, `ble_client.new_ble_node_component`)
+          constructs, registers and attaches in one call; `display.add_writer(var, config)` sets the lambda;
+          `MyEnum.options("on", prefix="MY_ENUM_")` builds an enum dict; `button.restart_button_schema(cls)` (and
+          `factory_reset_`, `query_`) are button presets; `fv.get_declaring_config(id)` finds a hub's config in
+          final validation.
+
 *   **Automations (Triggers, Actions, Conditions):**
 
     Automations have three building blocks: **Triggers** (fire when something happens), **Actions** (do something), and **Conditions** (check if something is true).

CODEOWNERS

@@ -133,7 +133,7 @@ esphome/components/climate/* @esphome/core
 esphome/components/climate_ir/* @glmnet
 esphome/components/cm1106/* @andrewjswan
 esphome/components/color_temperature/* @jesserockz
-esphome/components/combination/* @Cat-Ion @kahrendt
+esphome/components/combination/* @kahrendt
 esphome/components/const/* @esphome/core
 esphome/components/coolix/* @glmnet
 esphome/components/copy/* @OttoWinter
@@ -205,6 +205,7 @@ 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
@@ -601,7 +602,10 @@ esphome/components/ssd1331_base/* @kbx81
 esphome/components/ssd1331_spi/* @kbx81
 esphome/components/ssd1351_base/* @kbx81
 esphome/components/ssd1351_spi/* @kbx81
+esphome/components/st25r/* @JohnMcLear
+esphome/components/st25r_spi/* @JohnMcLear
 esphome/components/st7123/* @miniskipper
+esphome/components/st7305/* @clydebarrow
 esphome/components/st7567_base/* @latonita
 esphome/components/st7567_i2c/* @latonita
 esphome/components/st7567_spi/* @latonita
@@ -684,6 +688,7 @@ esphome/components/ultrasonic/* @ssieb @swoboda1337
 esphome/components/unicode/* @esphome/core
 esphome/components/update/* @jesserockz
 esphome/components/uponor_smatrix/* @kroimon
+esphome/components/usb_audio/* @ab-tools
 esphome/components/usb_cdc_acm/* @kbx81
 esphome/components/usb_host/* @clydebarrow
 esphome/components/usb_uart/* @clydebarrow
@@ -693,6 +698,7 @@ esphome/components/veml3235/* @kbx81
 esphome/components/veml7700/* @latonita
 esphome/components/version/* @esphome/core
 esphome/components/vevor_dtx/* @Bofr5555
+esphome/components/vl53l1x/* @will-tm
 esphome/components/voice_assistant/* @jesserockz @kahrendt
 esphome/components/wake_on_lan/* @clydebarrow @willwill2will54
 esphome/components/watchdog/* @oarcher

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.24.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.25.0
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/__main__.py

@@ -791,6 +791,7 @@ def write_cpp(config: ConfigType) -> int:
 
     if not get_bool_env(ENV_NOGITIGNORE):
         writer.write_gitignore()
+    writer.check_build_tree_not_tracked()
 
     generate_cpp_contents(config)
     return write_cpp_file()

esphome/automation.py

@@ -430,12 +430,20 @@ def _apply_function(
 ) -> MockObj:
     """Emit the generated function and declare ``id_`` as the ``ApplyAction`` or
     ``ApplyCondition`` templated on it, so ``play()`` calls it directly."""
-    fn = cg.static_function(
-        f"esphome__{id_.id}__fn", return_type, lambda_args, statements
-    )
+    fn = apply_static_function(id_, return_type, lambda_args, statements)
     return cg.new_Pvariable(id_, cg.TemplateArguments(fn, *template_arg))
 
 
+def apply_static_function(
+    id_: ID,
+    return_type: SafeExpType,
+    params: TemplateArgsType,
+    statements: list[str],
+) -> MockObj:
+    """Emit the static function generated for ``id_`` and return an expression naming it."""
+    return cg.static_function(f"esphome__{id_.id}__fn", return_type, params, statements)
+
+
 async def _render_values(
     name: str,
     target: str,

esphome/build_gen/espidf.py

@@ -8,12 +8,14 @@ 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 (
@@ -460,6 +462,7 @@ 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
@@ -505,6 +508,7 @@ idf_component_register(
 target_link_options(${{COMPONENT_LIB}} PUBLIC
     {link_opts_str}
 )
+{src_cmake}
 {_pch_cmake_block()}"""
 
 

esphome/codegen.py

@@ -53,6 +53,7 @@ from esphome.cpp_generator import (  # noqa: F401
     with_local_variable,
 )
 from esphome.cpp_helpers import (  # noqa: F401
+    add_optional,
     add_pin,
     add_variable,
     build_registry_entry,

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -184,11 +184,9 @@ 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_);
   }
@@ -227,24 +225,18 @@ void AcDimmer::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "AcDimmer:\n"
                 "  Min Power: %.1f%%\n"
-                "  Init with half cycle: %s",
-                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
+                "  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"));
   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,19 +6,11 @@
 
 namespace esphome::ac_dimmer {
 
-enum DimMethod { DIM_METHOD_LEADING_PULSE = 0, DIM_METHOD_LEADING, DIM_METHOD_TRAILING };
+enum DimMethod : uint8_t { 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
@@ -27,6 +19,12 @@ 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
@@ -50,17 +48,16 @@ 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) { method_ = method; }
+  void set_method(DimMethod method) { this->store_.method = method; }
 
  protected:
   void write_state(float state) override;
 
   InternalGPIOPin *gate_pin_;
   InternalGPIOPin *zero_cross_pin_;
-  gpio::InterruptType zero_cross_interrupt_type_;
   AcDimmerDataStore store_;
+  gpio::InterruptType zero_cross_interrupt_type_;
   bool init_with_half_cycle_;
-  DimMethod method_;
 };
 
 }  // namespace esphome::ac_dimmer

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/airton/airton.cpp

@@ -136,13 +136,7 @@ void AirtonClimate::transmit_state() {
   data->set_carrier_frequency(AIRTON_IR_FREQUENCY);
   data->mark(AIRTON_HEADER_MARK);
   data->space(AIRTON_HEADER_SPACE);
-  for (uint8_t payload_byte : remote_state) {
-    for (uint8_t payload_bit_cursor = 0; payload_bit_cursor < 8; payload_bit_cursor++) {
-      data->mark(AIRTON_BIT_MARK);
-      bool bit = payload_byte & (1 << payload_bit_cursor);
-      data->space(bit ? AIRTON_ONE_SPACE : AIRTON_ZERO_SPACE);
-    }
-  }
+  data->item_bytes<AIRTON_BIT_TIMINGS>(remote_state, AIRTON_STATE_FRAME_SIZE);
 
   data->mark(AIRTON_BIT_MARK);
   data->space(AIRTON_MESSAGE_SPACE);
@@ -284,20 +278,14 @@ void AirtonClimate::parse_state_frame_(const uint8_t *frame) {
 }
 
 bool AirtonClimate::on_receive(remote_base::RemoteReceiveData data) {
-  uint8_t remote_state[AIRTON_STATE_FRAME_SIZE] = {};
+  uint8_t remote_state[AIRTON_STATE_FRAME_SIZE];
   if (!data.expect_item(AIRTON_HEADER_MARK, AIRTON_HEADER_SPACE)) {
     ESP_LOGV(TAG, "Wrong header encoding detected!");
     return false;
   }
-  for (int i = 0; i < AIRTON_STATE_FRAME_SIZE; i++) {
-    for (int j = 0; j < 8; j++) {
-      if (data.expect_item(AIRTON_BIT_MARK, AIRTON_ONE_SPACE)) {
-        remote_state[i] |= 1 << j;
-      } else if (!data.expect_item(AIRTON_BIT_MARK, AIRTON_ZERO_SPACE)) {
-        ESP_LOGV(TAG, "Wrong modulation encoding for: Byte %d, bit %d", i, j);
-        return false;
-      }
-    }
+  if (!data.expect_bytes<AIRTON_BIT_TIMINGS>(remote_state, AIRTON_STATE_FRAME_SIZE)) {
+    ESP_LOGV(TAG, "Wrong modulation encoding");
+    return false;
   }
 
   if (remote_state[0] != AIRTON_HEADER_BYTE0 || remote_state[1] != AIRTON_HEADER_BYTE1) {

esphome/components/airton/airton.h

@@ -36,8 +36,8 @@ static constexpr uint32_t AIRTON_IR_FREQUENCY = 38000;
 static constexpr uint32_t AIRTON_HEADER_MARK = 6630;
 static constexpr uint32_t AIRTON_HEADER_SPACE = 3350;
 static constexpr uint32_t AIRTON_BIT_MARK = 400;
-static constexpr uint32_t AIRTON_ONE_SPACE = 1260;
-static constexpr uint32_t AIRTON_ZERO_SPACE = 430;
+static constexpr remote_base::BitTimings AIRTON_BIT_TIMINGS{
+    .bit_mark = AIRTON_BIT_MARK, .one_space = 1260, .zero_space = 430};
 static constexpr uint32_t AIRTON_MESSAGE_SPACE = 100000;
 
 static constexpr uint8_t AIRTON_STATE_FRAME_SIZE = 7;

esphome/components/airton/switch/__init__.py

@@ -8,19 +8,18 @@ from ..climate import CONF_AIRTON_ID, CONF_SLEEP_MODE, AirtonClimate, airton_ns
 
 CODEOWNERS = ["@Procsiab"]
 
-AirtonSwitch = airton_ns.class_("AirtonSwitch", switch.Switch)
 AirtonSetting = airton_ns.enum("AirtonSetting", is_class=True)
 
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_AIRTON_ID): cv.use_id(AirtonClimate),
         cv.Optional(CONF_DISPLAY): switch.switch_schema(
-            AirtonSwitch,
+            switch.ApplySwitch,
             entity_category=ENTITY_CATEGORY_CONFIG,
             default_restore_mode="DISABLED",
         ),
         cv.Optional(CONF_SLEEP_MODE): switch.switch_schema(
-            AirtonSwitch,
+            switch.ApplySwitch,
             entity_category=ENTITY_CATEGORY_CONFIG,
             default_restore_mode="DISABLED",
         ),
@@ -32,10 +31,12 @@ async def to_code(config: ConfigType) -> None:
     hub = await cg.get_variable(config[CONF_AIRTON_ID])
     switches = switch.sub_switches(config, parent=hub)
     await switches(
-        CONF_DISPLAY, hub.set_display_switch, AirtonSetting.AIRTON_SETTING_DISPLAY
+        CONF_DISPLAY,
+        hub.set_display_switch,
+        apply=f"set_setting({AirtonSetting.AIRTON_SETTING_DISPLAY}, state)",
     )
     await switches(
         CONF_SLEEP_MODE,
         hub.set_sleep_mode_switch,
-        AirtonSetting.AIRTON_SETTING_SLEEP_MODE,
+        apply=f"set_setting({AirtonSetting.AIRTON_SETTING_SLEEP_MODE}, state)",
     )

esphome/components/airton/switch/airton_switch.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include "esphome/components/switch/switch.h"
-#include "../airton.h"
-
-namespace esphome::airton {
-
-// One of the unit's on/off settings; the parent sends the state and publishes it back
-class AirtonSwitch : public switch_::Switch, public Parented<AirtonClimate> {
- public:
-  explicit AirtonSwitch(AirtonSetting setting) : setting_(setting) {}
-
- protected:
-  void write_state(bool state) override { this->parent_->set_setting(this->setting_, state); }
-
-  AirtonSetting setting_;
-};
-
-}  // namespace esphome::airton

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
+from esphome.components.const import CONF_AQI, CONF_ERROR_CODE
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ECO2,
@@ -55,7 +55,6 @@ 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

@@ -306,11 +306,6 @@ 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]
@@ -445,6 +440,11 @@ 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,
@@ -728,15 +728,6 @@ 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.",
@@ -771,6 +762,7 @@ 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

@@ -142,7 +142,7 @@ message HelloResponse {
   // A string identifying the server (ESP); like client info this may be empty
   // and only exists for debugging/logging purposes.
   // Currently set to ESPHOME_VERSION string literal.
-  string server_info = 3 [(max_data_length) = 32, (force) = true];
+  string server_info = 3 [(max_data_length) = 32, (force) = true, (progmem) = true];
 
   // The name of the server (App.get_name() - device hostname)
   // max_data_length matches ESPHOME_DEVICE_NAME_MAX_LEN (validated by validate_hostname)
@@ -278,7 +278,7 @@ message DeviceInfoResponse {
   string mac_address = 3 [(max_data_length) = 17, (force) = true];
 
   // A string describing the ESPHome version. For example "1.10.0"
-  string esphome_version = 4 [(max_data_length) = 32, (force) = true];
+  string esphome_version = 4 [(max_data_length) = 32, (force) = true, (progmem) = true];
 
   // A string describing the date of compilation, this is generated by the compiler
   // and therefore may not be in the same format all the time.
@@ -287,14 +287,14 @@ message DeviceInfoResponse {
 
   // The model of the board. For example NodeMCU
   // max_data_length matches core/config.BOARD_MAX_LENGTH (validated in platform schemas)
-  string model = 6 [(max_data_length) = 127, (force) = true];
+  string model = 6 [(max_data_length) = 127, (force) = true, (progmem) = true];
 
   bool has_deep_sleep = 7 [(field_ifdef) = "USE_DEEP_SLEEP"];
 
   // The esphome project details if set
   // max_data_length matches core/config.PROJECT_MAX_LENGTH
-  string project_name = 8 [(max_data_length) = 127, (force) = true, (field_ifdef) = "ESPHOME_PROJECT_NAME"];
-  string project_version = 9 [(max_data_length) = 127, (force) = true, (field_ifdef) = "ESPHOME_PROJECT_NAME"];
+  string project_name = 8 [(max_data_length) = 127, (force) = true, (field_ifdef) = "ESPHOME_PROJECT_NAME", (progmem) = true];
+  string project_version = 9 [(max_data_length) = 127, (force) = true, (field_ifdef) = "ESPHOME_PROJECT_NAME", (progmem) = true];
 
   uint32 webserver_port = 10 [(field_ifdef) = "USE_WEBSERVER"];
 
@@ -304,7 +304,7 @@ message DeviceInfoResponse {
   // Superseded by DeviceCapabilitiesResponse.bluetooth_proxy as of API 1.15.
   uint32 bluetooth_proxy_feature_flags = 15 [(field_ifdef) = "USE_BLUETOOTH_PROXY"];
 
-  string manufacturer = 12 [(max_data_length) = 20, (force) = true];
+  string manufacturer = 12 [(max_data_length) = 20, (force) = true, (progmem) = true];
 
   string friendly_name = 13 [(max_data_length) = 120, (force) = true];
 
@@ -683,7 +683,7 @@ message ListEntitiesFanResponse {
   bool disabled_by_default = 9;
   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) = "std::vector<const char *>"];
+  repeated string supported_preset_modes = 12 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
   uint32 device_id = 13 [(field_ifdef) = "USE_DEVICES"];
 }
 // Deprecated in API version 1.6 - only used in deprecated fields
@@ -1331,9 +1331,9 @@ 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) = "std::vector<const char *>"];
+  repeated string supported_custom_fan_modes = 15 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
   repeated ClimatePreset supported_presets = 16 [(container_pointer_no_template) = "climate::ClimatePresetMask"];
-  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "std::vector<const char *>"];
+  repeated string supported_custom_presets = 17 [(container_pointer_no_template) = "ConstVector<const char *, true>"];
   bool disabled_by_default = 18;
   string icon = 19 [(field_ifdef) = "USE_ENTITY_ICON", (max_data_length) = 63];
   EntityCategory entity_category = 20;

esphome/components/api/api_connection.cpp

@@ -28,6 +28,7 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/version.h"
 #ifdef USE_PROVISIONING
 #include "esphome/components/provisioning/provisioning.h"
@@ -84,8 +85,6 @@ static constexpr uint32_t KEEPALIVE_DISCONNECT_TIMEOUT = (KEEPALIVE_TIMEOUT_MS *
 // 28-30s. See https://github.com/esphome/esphome/issues/14999
 static constexpr uint32_t HANDSHAKE_TIMEOUT_MS = 60000;
 
-static constexpr auto ESPHOME_VERSION_REF = StringRef::from_lit(ESPHOME_VERSION);
-
 // Cross-validate C++ constants against proto max_data_length annotations in api.proto
 static_assert(MAC_ADDRESS_PRETTY_BUFFER_SIZE - 1 == 17,
               "Update max_data_length for mac_address/bluetooth_mac_address in api.proto");
@@ -1899,6 +1898,11 @@ void APIConnection::complete_authentication_() {
 #endif
 }
 
+// A flash string on ESP8266, a mergeable literal elsewhere; #undef after the device info reply
+#define PROGMEM_STRING_REF(s) ProgmemStringRef(ESPHOME_PSTR(s), sizeof(s) - 1)
+// One flash copy for the hello and device info replies
+static ProgmemStringRef esphome_version_ref() { return PROGMEM_STRING_REF(ESPHOME_VERSION); }
+
 bool APIConnection::send_hello_response_(const HelloRequest &msg) {
   // Copy client name with truncation if needed (set_client_name handles truncation)
   this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
@@ -1914,7 +1918,7 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {
   resp.api_version_major = 1;
   resp.api_version_minor = 19;
   // Send only the version string - the client only logs this for debugging and doesn't use it otherwise
-  resp.server_info = ESPHOME_VERSION_REF;
+  resp.server_info = esphome_version_ref();
   resp.name = StringRef(App.get_name());
 
 #ifdef USE_PROVISIONING
@@ -1969,14 +1973,13 @@ bool APIConnection::send_device_info_response_() {
   format_mac_addr_upper(mac, mac_address);
   resp.mac_address = StringRef(mac_address);
 
-  resp.esphome_version = ESPHOME_VERSION_REF;
+  resp.esphome_version = esphome_version_ref();
 
   // Stack buffer for build time string
   char build_time_str[Application::BUILD_TIME_STR_SIZE];
   App.get_build_time_string(build_time_str);
   resp.compilation_time = StringRef(build_time_str);
 
-  // Manufacturer string - define once, handle ESP8266 PROGMEM separately
 #if defined(USE_ESP8266) || defined(USE_ESP32)
 #define ESPHOME_MANUFACTURER "Espressif"
 #elif defined(USE_RP2)
@@ -1993,48 +1996,19 @@ bool APIConnection::send_device_info_response_() {
 #define ESPHOME_MANUFACTURER "Host"
 #endif
 
-#ifdef USE_ESP8266
-  // ESP8266 requires PROGMEM for flash storage, copy to stack for memcpy compatibility
-  static const char MANUFACTURER_PROGMEM[] PROGMEM = ESPHOME_MANUFACTURER;
-  char manufacturer_buf[sizeof(MANUFACTURER_PROGMEM)];
-  memcpy_P(manufacturer_buf, MANUFACTURER_PROGMEM, sizeof(MANUFACTURER_PROGMEM));
-  resp.manufacturer = StringRef(manufacturer_buf, sizeof(MANUFACTURER_PROGMEM) - 1);
-#else
-  static constexpr auto MANUFACTURER = StringRef::from_lit(ESPHOME_MANUFACTURER);
-  resp.manufacturer = MANUFACTURER;
-#endif
+  resp.manufacturer = PROGMEM_STRING_REF(ESPHOME_MANUFACTURER);
   static_assert(sizeof(ESPHOME_MANUFACTURER) - 1 <= 20, "Update max_data_length for manufacturer in api.proto");
 #undef ESPHOME_MANUFACTURER
 
-#ifdef USE_ESP8266
-  static const char MODEL_PROGMEM[] PROGMEM = ESPHOME_BOARD;
-  char model_buf[sizeof(MODEL_PROGMEM)];
-  memcpy_P(model_buf, MODEL_PROGMEM, sizeof(MODEL_PROGMEM));
-  resp.model = StringRef(model_buf, sizeof(MODEL_PROGMEM) - 1);
-#else
-  static constexpr auto MODEL = StringRef::from_lit(ESPHOME_BOARD);
-  resp.model = MODEL;
-#endif
+  resp.model = PROGMEM_STRING_REF(ESPHOME_BOARD);
 #ifdef USE_DEEP_SLEEP
   resp.has_deep_sleep = deep_sleep::global_has_deep_sleep;
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-#ifdef USE_ESP8266
-  static const char PROJECT_NAME_PROGMEM[] PROGMEM = ESPHOME_PROJECT_NAME;
-  static const char PROJECT_VERSION_PROGMEM[] PROGMEM = ESPHOME_PROJECT_VERSION;
-  char project_name_buf[sizeof(PROJECT_NAME_PROGMEM)];
-  char project_version_buf[sizeof(PROJECT_VERSION_PROGMEM)];
-  memcpy_P(project_name_buf, PROJECT_NAME_PROGMEM, sizeof(PROJECT_NAME_PROGMEM));
-  memcpy_P(project_version_buf, PROJECT_VERSION_PROGMEM, sizeof(PROJECT_VERSION_PROGMEM));
-  resp.project_name = StringRef(project_name_buf, sizeof(PROJECT_NAME_PROGMEM) - 1);
-  resp.project_version = StringRef(project_version_buf, sizeof(PROJECT_VERSION_PROGMEM) - 1);
-#else
-  static constexpr auto PROJECT_NAME = StringRef::from_lit(ESPHOME_PROJECT_NAME);
-  static constexpr auto PROJECT_VERSION = StringRef::from_lit(ESPHOME_PROJECT_VERSION);
-  resp.project_name = PROJECT_NAME;
-  resp.project_version = PROJECT_VERSION;
-#endif
+  resp.project_name = PROGMEM_STRING_REF(ESPHOME_PROJECT_NAME);
+  resp.project_version = PROGMEM_STRING_REF(ESPHOME_PROJECT_VERSION);
 #endif
+#undef PROGMEM_STRING_REF
 #ifdef USE_WEBSERVER
   resp.webserver_port = USE_WEBSERVER_PORT;
 #endif

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_pb2.cpp

@@ -31,7 +31,7 @@ uint8_t *HelloResponse::encode_msg(const void *self, uint8_t *__restrict__ pos P
   const auto &msg = *static_cast<const HelloResponse *>(self);
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.api_version_major);
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.api_version_minor);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.server_info);
+  pos = ProtoEncode::encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.server_info);
   pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, msg.name);
   return pos;
 }
@@ -117,17 +117,17 @@ uint8_t *DeviceInfoResponse::encode_msg(const void *self, uint8_t *__restrict__
   const auto &msg = *static_cast<const DeviceInfoResponse *>(self);
   pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 18, msg.name);
   pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 26, msg.mac_address);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, msg.esphome_version);
+  pos = ProtoEncode::encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, 34, msg.esphome_version);
   pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 42, msg.compilation_time);
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 50, msg.model);
+  pos = ProtoEncode::encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, 50, msg.model);
 #ifdef USE_DEEP_SLEEP
   pos = ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 7, msg.has_deep_sleep);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 66, msg.project_name);
+  pos = ProtoEncode::encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, 66, msg.project_name);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 74, msg.project_version);
+  pos = ProtoEncode::encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, 74, msg.project_version);
 #endif
 #ifdef USE_WEBSERVER
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 10, msg.webserver_port);
@@ -135,7 +135,7 @@ uint8_t *DeviceInfoResponse::encode_msg(const void *self, uint8_t *__restrict__
 #ifdef USE_BLUETOOTH_PROXY
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 15, msg.bluetooth_proxy_feature_flags);
 #endif
-  pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 98, msg.manufacturer);
+  pos = ProtoEncode::encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, 98, msg.manufacturer);
   pos = ProtoEncode::encode_short_string_force(pos PROTO_ENCODE_DEBUG_ARG, 106, msg.friendly_name);
 #ifdef USE_VOICE_ASSISTANT
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 17, msg.voice_assistant_feature_flags);
@@ -924,8 +924,7 @@ uint32_t ListEntitiesSensorResponse::calc_size_msg(const void *self) {
   return size;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SensorStateResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+uint8_t *SensorStateResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const SensorStateResponse *>(self);
   pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 13, msg.key);
   if (uint32_t raw = float_to_raw(msg.state); raw != 0) [[likely]] {
@@ -938,8 +937,7 @@ SensorStateResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROT
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SensorStateResponse::calc_size_msg(const void *self) {
+uint32_t SensorStateResponse::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const SensorStateResponse *>(self);
   uint32_t size = 0;
   size += 5;
@@ -1096,8 +1094,7 @@ void SubscribeLogsRequest::decode_field(void *self, uint32_t tag, const uint8_t
   }
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SubscribeLogsResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+uint8_t *SubscribeLogsResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const SubscribeLogsResponse *>(self);
   pos = ProtoEncode::encode_uint32_force(pos PROTO_ENCODE_DEBUG_ARG, 1, static_cast<uint32_t>(msg.level));
   pos = ProtoEncode::write_raw_byte(pos PROTO_ENCODE_DEBUG_ARG, 26);
@@ -1106,8 +1103,7 @@ SubscribeLogsResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PR
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SubscribeLogsResponse::calc_size_msg(const void *self) {
+uint32_t SubscribeLogsResponse::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const SubscribeLogsResponse *>(self);
   uint32_t size = 0;
   size += 2;
@@ -2448,8 +2444,8 @@ void SubscribeBluetoothLEAdvertisementsRequest::decode_field(void *self, uint32_
   }
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-BluetoothLERawAdvertisementsResponse::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+uint8_t *BluetoothLERawAdvertisementsResponse::encode_msg(const void *self,
+                                                          uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const BluetoothLERawAdvertisementsResponse *>(self);
   for (uint16_t i = 0; i < msg.advertisements_len; i++) {
     auto &sub_msg = msg.advertisements[i];
@@ -2472,8 +2468,7 @@ BluetoothLERawAdvertisementsResponse::encode_msg(const void *self, uint8_t *__re
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-BluetoothLERawAdvertisementsResponse::calc_size_msg(const void *self) {
+uint32_t BluetoothLERawAdvertisementsResponse::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const BluetoothLERawAdvertisementsResponse *>(self);
   uint32_t size = 0;
   for (uint16_t i = 0; i < msg.advertisements_len; i++) {
@@ -3820,15 +3815,13 @@ void ZWaveProxyFrame::decode_field(void *self, uint32_t tag, const uint8_t *data
   }
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-ZWaveProxyFrame::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+uint8_t *ZWaveProxyFrame::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const ZWaveProxyFrame *>(self);
   pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.data, msg.data_len);
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-ZWaveProxyFrame::calc_size_msg(const void *self) {
+uint32_t ZWaveProxyFrame::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const ZWaveProxyFrame *>(self);
   uint32_t size = 0;
   size += ProtoSize::calc_length(1, msg.data_len);
@@ -3943,8 +3936,7 @@ void InfraredRFTransmitRawTimingsRequest::decode_field(void *self, uint32_t tag,
   }
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-InfraredRFReceiveEvent::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+uint8_t *InfraredRFReceiveEvent::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const InfraredRFReceiveEvent *>(self);
 #ifdef USE_DEVICES
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.device_id);
@@ -3956,8 +3948,7 @@ InfraredRFReceiveEvent::encode_msg(const void *self, uint8_t *__restrict__ pos P
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-InfraredRFReceiveEvent::calc_size_msg(const void *self) {
+uint32_t InfraredRFReceiveEvent::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const InfraredRFReceiveEvent *>(self);
   uint32_t size = 0;
 #ifdef USE_DEVICES
@@ -4061,16 +4052,14 @@ void SerialProxyConfigureRequest::decode_field(void *self, uint32_t tag, const u
   }
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint8_t *
-SerialProxyDataReceived::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
+uint8_t *SerialProxyDataReceived::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const SerialProxyDataReceived *>(self);
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.instance);
   pos = ProtoEncode::encode_bytes(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.data_ptr_, msg.data_len_);
   return pos;
 }
 __attribute__((optimize("O2")))  // NOLINT(clang-diagnostic-unknown-attributes)
-uint32_t
-SerialProxyDataReceived::calc_size_msg(const void *self) {
+uint32_t SerialProxyDataReceived::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const SerialProxyDataReceived *>(self);
   uint32_t size = 0;
   size += ProtoSize::calc_uint32(1, msg.instance);

esphome/components/api/api_pb2.h

@@ -466,7 +466,7 @@ class HelloResponse final : public ProtoMessage {
 #endif
   uint32_t api_version_major{0};
   uint32_t api_version_minor{0};
-  StringRef server_info{};
+  ProgmemStringRef server_info{};
   StringRef name{};
   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 {
@@ -608,17 +608,17 @@ class DeviceInfoResponse final : public ProtoMessage {
 #endif
   StringRef name{};
   StringRef mac_address{};
-  StringRef esphome_version{};
+  ProgmemStringRef esphome_version{};
   StringRef compilation_time{};
-  StringRef model{};
+  ProgmemStringRef model{};
 #ifdef USE_DEEP_SLEEP
   bool has_deep_sleep{false};
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  StringRef project_name{};
+  ProgmemStringRef project_name{};
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  StringRef project_version{};
+  ProgmemStringRef project_version{};
 #endif
 #ifdef USE_WEBSERVER
   uint32_t webserver_port{0};
@@ -626,7 +626,7 @@ class DeviceInfoResponse final : public ProtoMessage {
 #ifdef USE_BLUETOOTH_PROXY
   uint32_t bluetooth_proxy_feature_flags{0};
 #endif
-  StringRef manufacturer{};
+  ProgmemStringRef manufacturer{};
   StringRef friendly_name{};
 #ifdef USE_VOICE_ASSISTANT
   uint32_t voice_assistant_feature_flags{0};
@@ -984,7 +984,7 @@ class ListEntitiesFanResponse final : public InfoResponseProtoMessage {
   bool supports_speed{false};
   bool supports_direction{false};
   int32_t supported_speed_count{0};
-  const std::vector<const char *> *supported_preset_modes{};
+  const ConstVector<const char *, true> *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);
@@ -1777,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 std::vector<const char *> *supported_custom_fan_modes{};
+  const ConstVector<const char *, true> *supported_custom_fan_modes{};
   const climate::ClimatePresetMask *supported_presets{};
-  const std::vector<const char *> *supported_custom_presets{};
+  const ConstVector<const char *, true> *supported_custom_presets{};
   float visual_current_temperature_step{0.0f};
   bool supports_current_humidity{false};
   bool supports_target_humidity{false};

esphome/components/api/api_pb2_dump.cpp

@@ -970,7 +970,7 @@ const char *HelloResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("HelloResponse"));
   dump_field(out, ESPHOME_PSTR("api_version_major"), this->api_version_major);
   dump_field(out, ESPHOME_PSTR("api_version_minor"), this->api_version_minor);
-  dump_field(out, ESPHOME_PSTR("server_info"), this->server_info);
+  dump_progmem_string_field(out, ESPHOME_PSTR("server_info"), this->server_info);
   dump_field(out, ESPHOME_PSTR("name"), this->name);
   return out.c_str();
 }
@@ -1021,17 +1021,17 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("DeviceInfoResponse"));
   dump_field(out, ESPHOME_PSTR("name"), this->name);
   dump_field(out, ESPHOME_PSTR("mac_address"), this->mac_address);
-  dump_field(out, ESPHOME_PSTR("esphome_version"), this->esphome_version);
+  dump_progmem_string_field(out, ESPHOME_PSTR("esphome_version"), this->esphome_version);
   dump_field(out, ESPHOME_PSTR("compilation_time"), this->compilation_time);
-  dump_field(out, ESPHOME_PSTR("model"), this->model);
+  dump_progmem_string_field(out, ESPHOME_PSTR("model"), this->model);
 #ifdef USE_DEEP_SLEEP
   dump_field(out, ESPHOME_PSTR("has_deep_sleep"), this->has_deep_sleep);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  dump_field(out, ESPHOME_PSTR("project_name"), this->project_name);
+  dump_progmem_string_field(out, ESPHOME_PSTR("project_name"), this->project_name);
 #endif
 #ifdef ESPHOME_PROJECT_NAME
-  dump_field(out, ESPHOME_PSTR("project_version"), this->project_version);
+  dump_progmem_string_field(out, ESPHOME_PSTR("project_version"), this->project_version);
 #endif
 #ifdef USE_WEBSERVER
   dump_field(out, ESPHOME_PSTR("webserver_port"), this->webserver_port);
@@ -1039,7 +1039,7 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_BLUETOOTH_PROXY
   dump_field(out, ESPHOME_PSTR("bluetooth_proxy_feature_flags"), this->bluetooth_proxy_feature_flags);
 #endif
-  dump_field(out, ESPHOME_PSTR("manufacturer"), this->manufacturer);
+  dump_progmem_string_field(out, ESPHOME_PSTR("manufacturer"), this->manufacturer);
   dump_field(out, ESPHOME_PSTR("friendly_name"), this->friendly_name);
 #ifdef USE_VOICE_ASSISTANT
   dump_field(out, ESPHOME_PSTR("voice_assistant_feature_flags"), this->voice_assistant_feature_flags);

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,7 +593,10 @@ 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,7 +20,8 @@ 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/wizard.py

@@ -119,11 +119,6 @@ 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
 
 
@@ -150,6 +145,7 @@ 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/caqi_calculator.h

@@ -26,21 +26,17 @@ 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}
-      // clang-format on
+      {55.1f, 110.1f},
   };
 
   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}
-      // clang-format on
+      {90.1f, 180.1f},
   };
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {

esphome/components/aqi/sensor.py

@@ -17,16 +17,6 @@ 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,
@@ -45,7 +35,13 @@ CONFIG_SCHEMA = cv.All(
         }
     )
     .extend(cv.COMPONENT_SCHEMA),
-    _validate_extended_range,
+    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",
+    ),
 )
 
 

esphome/components/atm90e32/atm90e32.cpp

@@ -637,6 +637,18 @@ float ATM90E32Component::get_chip_temperature_() {
   return (float) ctemp;
 }
 
+void ATM90E32Component::press_calibration_button(EntityBase *entity, void (ATM90E32Component::*action)(),
+                                                 const LogString *hint, const LogString *hint2) {
+  ESP_LOGI(TAG, "%s", entity->get_name().c_str());
+  if (hint != nullptr) {
+    ESP_LOGI(TAG, "%s", LOG_STR_ARG(hint));
+  }
+  if (hint2 != nullptr) {
+    ESP_LOGI(TAG, "%s", LOG_STR_ARG(hint2));
+  }
+  (this->*action)();
+}
+
 void ATM90E32Component::run_gain_calibrations() {
   const char *cs = this->get_calibration_id_();
   if (!this->enable_gain_calibration_) {

esphome/components/atm90e32/atm90e32.h

@@ -139,6 +139,9 @@ class ATM90E32Component final : public PollingComponent,
   int16_t calibrate_offset(uint8_t phase, bool voltage);
   int16_t calibrate_power_offset(uint8_t phase, bool reactive);
   void run_gain_calibrations();
+  // Body of the calibration buttons: logs the button name and the hint lines, then runs action.
+  void press_calibration_button(EntityBase *entity, void (ATM90E32Component::*action)(),
+                                const LogString *hint = nullptr, const LogString *hint2 = nullptr);
 #ifdef USE_NUMBER
   void set_reference_voltage(uint8_t phase, number::Number *ref_voltage) { ref_voltages_[phase] = ref_voltage; }
   void set_reference_current(uint8_t phase, number::Number *ref_current) { ref_currents_[phase] = ref_current; }
@@ -154,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

esphome/components/atm90e32/button/__init__.py

@@ -4,7 +4,6 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID, ENTITY_CATEGORY_CONFIG, ICON_SCALE
 from esphome.types import ConfigType
 
-from .. import atm90e32_ns
 from ..sensor import ATM90E32Component
 
 CONF_RUN_GAIN_CALIBRATION = "run_gain_calibration"
@@ -14,83 +13,68 @@ CONF_CLEAR_OFFSET_CALIBRATION = "clear_offset_calibration"
 CONF_RUN_POWER_OFFSET_CALIBRATION = "run_power_offset_calibration"
 CONF_CLEAR_POWER_OFFSET_CALIBRATION = "clear_power_offset_calibration"
 
-ATM90E32GainCalibrationButton = atm90e32_ns.class_(
-    "ATM90E32GainCalibrationButton", button.Button
-)
-ATM90E32ClearGainCalibrationButton = atm90e32_ns.class_(
-    "ATM90E32ClearGainCalibrationButton", button.Button
-)
-ATM90E32OffsetCalibrationButton = atm90e32_ns.class_(
-    "ATM90E32OffsetCalibrationButton", button.Button
-)
-ATM90E32ClearOffsetCalibrationButton = atm90e32_ns.class_(
-    "ATM90E32ClearOffsetCalibrationButton", button.Button
-)
-ATM90E32PowerOffsetCalibrationButton = atm90e32_ns.class_(
-    "ATM90E32PowerOffsetCalibrationButton", button.Button
-)
-ATM90E32ClearPowerOffsetCalibrationButton = atm90e32_ns.class_(
-    "ATM90E32ClearPowerOffsetCalibrationButton", button.Button
-)
+
+def _calibration_button(icon: str) -> cv.Schema:
+    return button.button_schema(
+        button.ApplyButton, entity_category=ENTITY_CATEGORY_CONFIG, icon=icon
+    )
+
 
 CONFIG_SCHEMA = {
     cv.GenerateID(CONF_ID): cv.use_id(ATM90E32Component),
-    cv.Optional(CONF_RUN_GAIN_CALIBRATION): button.button_schema(
-        ATM90E32GainCalibrationButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon="mdi:scale-balance",
-    ),
-    cv.Optional(CONF_CLEAR_GAIN_CALIBRATION): button.button_schema(
-        ATM90E32ClearGainCalibrationButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon="mdi:delete",
-    ),
-    cv.Optional(CONF_RUN_OFFSET_CALIBRATION): button.button_schema(
-        ATM90E32OffsetCalibrationButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon=ICON_SCALE,
-    ),
-    cv.Optional(CONF_CLEAR_OFFSET_CALIBRATION): button.button_schema(
-        ATM90E32ClearOffsetCalibrationButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon="mdi:delete",
-    ),
-    cv.Optional(CONF_RUN_POWER_OFFSET_CALIBRATION): button.button_schema(
-        ATM90E32PowerOffsetCalibrationButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon=ICON_SCALE,
-    ),
-    cv.Optional(CONF_CLEAR_POWER_OFFSET_CALIBRATION): button.button_schema(
-        ATM90E32ClearPowerOffsetCalibrationButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon="mdi:delete",
-    ),
+    cv.Optional(CONF_RUN_GAIN_CALIBRATION): _calibration_button("mdi:scale-balance"),
+    cv.Optional(CONF_CLEAR_GAIN_CALIBRATION): _calibration_button("mdi:delete"),
+    cv.Optional(CONF_RUN_OFFSET_CALIBRATION): _calibration_button(ICON_SCALE),
+    cv.Optional(CONF_CLEAR_OFFSET_CALIBRATION): _calibration_button("mdi:delete"),
+    cv.Optional(CONF_RUN_POWER_OFFSET_CALIBRATION): _calibration_button(ICON_SCALE),
+    cv.Optional(CONF_CLEAR_POWER_OFFSET_CALIBRATION): _calibration_button("mdi:delete"),
 }
 
 
+def _press(action: str, hint: str | None = None, hint2: str | None = None) -> str:
+    """press_calibration_button() logs at most two hint lines."""
+    args = "".join(
+        f", {cg.LogStringLiteral(h)}" for h in (hint, hint2) if h is not None
+    )
+    return f"press_calibration_button(entity, &{ATM90E32Component}::{action}{args})"
+
+
 async def to_code(config: ConfigType) -> None:
-    parent = await cg.get_variable(config[CONF_ID])
-
-    if run_gain := config.get(CONF_RUN_GAIN_CALIBRATION):
-        b = await button.new_button(run_gain)
-        await cg.register_parented(b, parent)
-
-    if clear_gain := config.get(CONF_CLEAR_GAIN_CALIBRATION):
-        b = await button.new_button(clear_gain)
-        await cg.register_parented(b, parent)
-
-    if run_offset := config.get(CONF_RUN_OFFSET_CALIBRATION):
-        b = await button.new_button(run_offset)
-        await cg.register_parented(b, parent)
-
-    if clear_offset := config.get(CONF_CLEAR_OFFSET_CALIBRATION):
-        b = await button.new_button(clear_offset)
-        await cg.register_parented(b, parent)
-
-    if run_power := config.get(CONF_RUN_POWER_OFFSET_CALIBRATION):
-        b = await button.new_button(run_power)
-        await cg.register_parented(b, parent)
-
-    if clear_power := config.get(CONF_CLEAR_POWER_OFFSET_CALIBRATION):
-        b = await button.new_button(clear_power)
-        await cg.register_parented(b, parent)
+    buttons = button.sub_buttons(config, parent=config[CONF_ID])
+    await buttons(
+        CONF_RUN_GAIN_CALIBRATION,
+        None,
+        apply=_press(
+            "run_gain_calibrations",
+            "[CALIBRATION] Use gain_ct: & gain_voltage: under each phase_x: in your config file to save these values",
+        ),
+    )
+    await buttons(
+        CONF_CLEAR_GAIN_CALIBRATION, None, apply=_press("clear_gain_calibrations")
+    )
+    await buttons(
+        CONF_RUN_OFFSET_CALIBRATION,
+        None,
+        apply=_press(
+            "run_offset_calibrations",
+            "[CALIBRATION] **NOTE: CTs and ACVs must be 0 during this process. USB power only**",
+            "[CALIBRATION] Use offset_voltage: & offset_current: under each phase_x: in your config file to save these values",
+        ),
+    )
+    await buttons(
+        CONF_CLEAR_OFFSET_CALIBRATION, None, apply=_press("clear_offset_calibrations")
+    )
+    await buttons(
+        CONF_RUN_POWER_OFFSET_CALIBRATION,
+        None,
+        apply=_press(
+            "run_power_offset_calibrations",
+            "[CALIBRATION] **NOTE: CTs must be 0 during this process. Voltage reference should be present**",
+            "[CALIBRATION] Use offset_active_power: & offset_reactive_power: under each phase_x: in your config file to save these values",
+        ),
+    )
+    await buttons(
+        CONF_CLEAR_POWER_OFFSET_CALIBRATION,
+        None,
+        apply=_press("clear_power_offset_calibrations"),
+    )

esphome/components/atm90e32/button/atm90e32_button.cpp

@@ -1,77 +0,0 @@
-#include "atm90e32_button.h"
-#include "esphome/core/component.h"
-#include "esphome/core/log.h"
-
-namespace esphome::atm90e32 {
-
-ESPHOME_LOG_TAG(TAG, "atm90e32.button");
-
-void ATM90E32GainCalibrationButton::press_action() {
-  if (this->parent_ == nullptr) {
-    ESP_LOGW(TAG, "[CALIBRATION] No meters assigned to Gain Calibration button [%s]", this->get_name().c_str());
-    return;
-  }
-
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  ESP_LOGI(TAG,
-           "[CALIBRATION] Use gain_ct: & gain_voltage: under each phase_x: in your config file to save these values");
-  this->parent_->run_gain_calibrations();
-}
-
-void ATM90E32ClearGainCalibrationButton::press_action() {
-  if (this->parent_ == nullptr) {
-    ESP_LOGW(TAG, "[CALIBRATION] No meters assigned to Clear Gain button [%s]", this->get_name().c_str());
-    return;
-  }
-
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  this->parent_->clear_gain_calibrations();
-}
-
-void ATM90E32OffsetCalibrationButton::press_action() {
-  if (this->parent_ == nullptr) {
-    ESP_LOGW(TAG, "[CALIBRATION] No meters assigned to Offset Calibration button [%s]", this->get_name().c_str());
-    return;
-  }
-
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  ESP_LOGI(TAG, "[CALIBRATION] **NOTE: CTs and ACVs must be 0 during this process. USB power only**");
-  ESP_LOGI(TAG, "[CALIBRATION] Use offset_voltage: & offset_current: under each phase_x: in your config file to save "
-                "these values");
-  this->parent_->run_offset_calibrations();
-}
-
-void ATM90E32ClearOffsetCalibrationButton::press_action() {
-  if (this->parent_ == nullptr) {
-    ESP_LOGW(TAG, "[CALIBRATION] No meters assigned to Clear Offset button [%s]", this->get_name().c_str());
-    return;
-  }
-
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  this->parent_->clear_offset_calibrations();
-}
-
-void ATM90E32PowerOffsetCalibrationButton::press_action() {
-  if (this->parent_ == nullptr) {
-    ESP_LOGW(TAG, "[CALIBRATION] No meters assigned to Power Calibration button [%s]", this->get_name().c_str());
-    return;
-  }
-
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  ESP_LOGI(TAG, "[CALIBRATION] **NOTE: CTs must be 0 during this process. Voltage reference should be present**");
-  ESP_LOGI(TAG, "[CALIBRATION] Use offset_active_power: & offset_reactive_power: under each phase_x: in your config "
-                "file to save these values");
-  this->parent_->run_power_offset_calibrations();
-}
-
-void ATM90E32ClearPowerOffsetCalibrationButton::press_action() {
-  if (this->parent_ == nullptr) {
-    ESP_LOGW(TAG, "[CALIBRATION] No meters assigned to Clear Power button [%s]", this->get_name().c_str());
-    return;
-  }
-
-  ESP_LOGI(TAG, "%s", this->get_name().c_str());
-  this->parent_->clear_power_offset_calibrations();
-}
-
-}  // namespace esphome::atm90e32

esphome/components/atm90e32/button/atm90e32_button.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/atm90e32/atm90e32.h"
-#include "esphome/components/button/button.h"
-
-namespace esphome::atm90e32 {
-
-class ATM90E32GainCalibrationButton final : public button::Button, public Parented<ATM90E32Component> {
- public:
-  ATM90E32GainCalibrationButton() = default;
-
- protected:
-  void press_action() override;
-};
-
-class ATM90E32ClearGainCalibrationButton final : public button::Button, public Parented<ATM90E32Component> {
- public:
-  ATM90E32ClearGainCalibrationButton() = default;
-
- protected:
-  void press_action() override;
-};
-
-class ATM90E32OffsetCalibrationButton final : public button::Button, public Parented<ATM90E32Component> {
- public:
-  ATM90E32OffsetCalibrationButton() = default;
-
- protected:
-  void press_action() override;
-};
-
-class ATM90E32ClearOffsetCalibrationButton final : public button::Button, public Parented<ATM90E32Component> {
- public:
-  ATM90E32ClearOffsetCalibrationButton() = default;
-
- protected:
-  void press_action() override;
-};
-
-class ATM90E32PowerOffsetCalibrationButton final : public button::Button, public Parented<ATM90E32Component> {
- public:
-  ATM90E32PowerOffsetCalibrationButton() = default;
-
- protected:
-  void press_action() override;
-};
-
-class ATM90E32ClearPowerOffsetCalibrationButton final : public button::Button, public Parented<ATM90E32Component> {
- public:
-  ATM90E32ClearPowerOffsetCalibrationButton() = default;
-
- protected:
-  void press_action() override;
-};
-
-}  // namespace esphome::atm90e32

esphome/components/audio/audio.h

@@ -22,7 +22,7 @@ class AudioStreamInfo {
    */
  public:
   AudioStreamInfo()
-      : AudioStreamInfo(16, 1, 16000){};  // Default values represent ESPHome's audio components historical values
+      : AudioStreamInfo(16, 1, 16000) {};  // Default values represent ESPHome's audio components historical values
   AudioStreamInfo(uint8_t bits_per_sample, uint8_t channels, uint32_t sample_rate);
 
   uint8_t get_bits_per_sample() const { return this->bits_per_sample_; }

esphome/components/ballu/ballu.cpp

@@ -8,8 +8,8 @@ ESPHOME_LOG_TAG(TAG, "ballu.climate");
 const uint16_t BALLU_HEADER_MARK = 9000;
 const uint16_t BALLU_HEADER_SPACE = 4500;
 const uint16_t BALLU_BIT_MARK = 575;
-const uint16_t BALLU_ONE_SPACE = 1675;
-const uint16_t BALLU_ZERO_SPACE = 550;
+static constexpr remote_base::BitTimings BALLU_BIT_TIMINGS{
+    .bit_mark = BALLU_BIT_MARK, .one_space = 1675, .zero_space = 550};
 
 const uint32_t BALLU_CARRIER_FREQUENCY = 38000;
 
@@ -104,13 +104,7 @@ void BalluClimate::transmit_state() {
   data->mark(BALLU_HEADER_MARK);
   data->space(BALLU_HEADER_SPACE);
   // Data
-  for (uint8_t i : remote_state) {
-    for (uint8_t j = 0; j < 8; j++) {
-      data->mark(BALLU_BIT_MARK);
-      bool bit = i & (1 << j);
-      data->space(bit ? BALLU_ONE_SPACE : BALLU_ZERO_SPACE);
-    }
-  }
+  data->item_bytes<BALLU_BIT_TIMINGS>(remote_state, BALLU_STATE_LENGTH);
   // Footer
   data->mark(BALLU_BIT_MARK);
 
@@ -124,21 +118,10 @@ bool BalluClimate::on_receive(remote_base::RemoteReceiveData data) {
     return false;
   }
 
-  uint8_t remote_state[BALLU_STATE_LENGTH] = {0};
-  // Read all bytes.
-  for (int i = 0; i < BALLU_STATE_LENGTH; i++) {
-    // Read bit
-    for (int j = 0; j < 8; j++) {
-      if (data.expect_item(BALLU_BIT_MARK, BALLU_ONE_SPACE)) {
-        remote_state[i] |= 1 << j;
-
-      } else if (!data.expect_item(BALLU_BIT_MARK, BALLU_ZERO_SPACE)) {
-        ESP_LOGV(TAG, "Byte %d bit %d fail", i, j);
-        return false;
-      }
-    }
-
-    ESP_LOGVV(TAG, "Byte %d %02X", i, remote_state[i]);
+  uint8_t remote_state[BALLU_STATE_LENGTH];
+  if (!data.expect_bytes<BALLU_BIT_TIMINGS>(remote_state, BALLU_STATE_LENGTH)) {
+    ESP_LOGV(TAG, "Data fail");
+    return false;
   }
   // Validate footer
   if (!data.expect_mark(BALLU_BIT_MARK)) {

esphome/components/bedjet/__init__.py

@@ -43,5 +43,4 @@ async def register_bedjet_child(var: MockObj, config: ConfigType) -> None:
 async def to_code(config: ConfigType) -> None:
     var = await ble_client.new_ble_node_component(config)
     await cg.add_variable(var.set_time_id, config.get(CONF_TIME_ID))
-    if (receive_timeout := config.get(CONF_RECEIVE_TIMEOUT)) is not None:
-        cg.add(var.set_status_timeout(receive_timeout))
+    cg.add_optional(var.set_status_timeout, config.get(CONF_RECEIVE_TIMEOUT))

esphome/components/bedjet/bedjet_const.h

@@ -92,10 +92,8 @@ enum BedjetCommand : uint8_t {
 };
 
 #define BEDJET_FAN_STEP_NAMES_ \
-  { \
-    "5%", "10%", "15%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", "55%", "60%", "65%", "70%", "75%", "80%", \
-        "85%", "90%", "95%", "100%" \
-  }
+  {"5%",  "10%", "15%", "20%", "25%", "30%", "35%", "40%", "45%", "50%", \
+   "55%", "60%", "65%", "70%", "75%", "80%", "85%", "90%", "95%", "100%"}
 
 static const uint8_t BEDJET_FAN_SPEED_COUNT = 20;
 

esphome/components/bedjet/climate/bedjet_climate.cpp

@@ -61,7 +61,7 @@ void BedJetClimate::dump_config() {
 
 void BedJetClimate::setup() {
   // Set custom modes once during setup — stored on Climate base class, wired via get_traits()
-  this->set_supported_custom_fan_modes(BEDJET_FAN_STEP_NAMES);
+  this->set_supported_custom_fan_modes_static(BEDJET_FAN_STEP_NAMES, BEDJET_FAN_SPEED_COUNT);
   this->set_supported_custom_presets({
       this->heating_mode_ == HEAT_MODE_EXTENDED ? "LTD HT" : "EXT HT",
       "M1",

esphome/components/bedjet/fan/bedjet_fan.h

@@ -20,7 +20,7 @@ class BedJetFan final : public fan::Fan, public BedJetClient, public PollingComp
 
   /* BedJetClient status update */
   void on_status(const BedjetStatusPacket *data) override;
-  void on_bedjet_state(bool is_ready) override{};
+  void on_bedjet_state(bool is_ready) override {};
   std::string describe() override;
 
   fan::FanTraits get_traits() override { return fan::FanTraits(false, true, false, BEDJET_FAN_SPEED_COUNT); }

esphome/components/beken_spi_led_strip/led_strip.cpp

@@ -20,18 +20,35 @@ extern "C" {
 
 static const uint32_t SPI_TX_DMA_CHANNEL = GDMA_CHANNEL_3;
 
-// TODO: Check if SPI_PERI_CLK_DCO depends on the chip variant
 static const uint32_t SPI_PERI_CLK_26M = 26000000;
+
+#if defined(USE_LIBRETINY_VARIANT_BK7251)
+static const uint32_t SPI_PERI_CLK_DCO = 180000000;
+#else
 static const uint32_t SPI_PERI_CLK_DCO = 120000000;
+#endif
+
+// The beken378 SDK has two SPI register layouts:
+//   N-like (BK7231N, BK7238, BK7252N): CTRL +0x00, CONFIG +0x04, STAT +0x08, DAT +0x0C
+//   T-like (BK7231T, BK7251):          CTRL +0x00, STAT +0x04, DAT +0x08
+// The N-like variants also have TX enable / transfer length / TX finish bits in CONFIG.
+// The T-like variants have no CONFIG address.
+#if defined(USE_LIBRETINY_VARIANT_BK7231N) || defined(USE_LIBRETINY_VARIANT_BK7238)
+#define BEKEN_SPI_IS_N_LIKE
+#endif
 
 static const uint32_t SPI_BASE = 0x00802700;
+#ifdef BEKEN_SPI_IS_N_LIKE
 static const uint32_t SPI_DAT = SPI_BASE + 3 * 4;
 static const uint32_t SPI_CONFIG = SPI_BASE + 1 * 4;
-
 static const uint32_t SPI_TX_EN = 1 << 0;
-static const uint32_t CTRL_NSSMD_3 = 1 << 17;
 static const uint32_t SPI_TX_FINISH_EN = 1 << 2;
 static const uint32_t SPI_RX_FINISH_EN = 1 << 3;
+#else
+static const uint32_t SPI_DAT = SPI_BASE + 2 * 4;
+#endif
+
+static const uint32_t CTRL_NSSMD_3 = 1 << 17;
 
 namespace esphome::beken_spi_led_strip {
 
@@ -55,6 +72,7 @@ static void set_spi_ctrl_register(uint32_t bit, bool val) {
   REG_WRITE(SPI_CTRL, value);
 }
 
+#ifdef BEKEN_SPI_IS_N_LIKE
 static void set_spi_config_register(uint32_t bit, bool val) {
   uint32_t value = REG_READ(SPI_CONFIG);
   if (val == 0) {
@@ -64,10 +82,13 @@ static void set_spi_config_register(uint32_t bit, bool val) {
   }
   REG_WRITE(SPI_CONFIG, value);
 }
+#endif
 
 void spi_dma_tx_enable(bool enable) {
   GDMA_CFG_ST en_cfg;
+#ifdef BEKEN_SPI_IS_N_LIKE
   set_spi_config_register(SPI_TX_EN, enable);
+#endif
   en_cfg.channel = SPI_TX_DMA_CHANNEL;
   en_cfg.param = enable ? 1 : 0;
   sddev_control(GDMA_DEV_NAME, CMD_GDMA_SET_DMA_ENABLE, &en_cfg);
@@ -100,7 +121,13 @@ static void spi_set_clock(uint32_t max_hz) {
     param = PCLK_POSI_SPI;
     sddev_control(ICU_DEV_NAME, CMD_CONF_PCLK_26M, &param);
   }
+#ifdef BEKEN_SPI_IS_N_LIKE
+  // N-like variants: spi_clk = source_clk / (2 * div)
   div = ((source_clk >> 1) / spi_clk);
+#else
+  // T-like variants: spi_clk = source_clk / (2 * (div + 1))
+  div = ((source_clk >> 1) / spi_clk) - 1;
+#endif
   if (div < 2) {
     div = 2;
   } else if (div >= 255) {
@@ -110,7 +137,12 @@ static void spi_set_clock(uint32_t max_hz) {
   param &= ~(SPI_CKR_MASK << SPI_CKR_POSI);
   param |= (div << SPI_CKR_POSI);
   REG_WRITE(SPI_CTRL, param);
-  ESP_LOGD(TAG, "target frequency: %" PRIu32 ", actual frequency: %d", max_hz, source_clk / 2 / div);
+#ifdef BEKEN_SPI_IS_N_LIKE
+  const int divisor = div;
+#else
+  const int divisor = div + 1;
+#endif
+  ESP_LOGD(TAG, "target frequency: %" PRIu32 ", actual frequency: %d", max_hz, source_clk / 2 / divisor);
 }
 
 void spi_dma_tx_finish_callback(unsigned int param) {
@@ -187,8 +219,10 @@ void BekenSPILEDStripLightOutput::setup() {
 
   set_spi_ctrl_register(TXINT_EN, false);
   set_spi_ctrl_register(RXINT_EN, false);
+#ifdef BEKEN_SPI_IS_N_LIKE
   set_spi_config_register(SPI_TX_FINISH_EN, true);
   set_spi_config_register(SPI_RX_FINISH_EN, true);
+#endif
   set_spi_ctrl_register(RXOVR_EN, false);
   set_spi_ctrl_register(TXOVR_EN, false);
 
@@ -197,9 +231,17 @@ void BekenSPILEDStripLightOutput::setup() {
   value |= (1 << 17);
   REG_WRITE(SPI_CTRL, value);
 
+#ifdef BEKEN_SPI_IS_N_LIKE
   value = GFUNC_MODE_SPI_DMA;
+#else
+  // For T-like variants, GFUNC_MODE_SPI_DMA identifies an SPI-DMA peripheral
+  // with a different base address. We want the regular SPI controller here.
+  value = GFUNC_MODE_SPI;
+#endif
   sddev_control(GPIO_DEV_NAME, CMD_GPIO_ENABLE_SECOND, &value);
+#ifdef BEKEN_SPI_IS_N_LIKE
   set_spi_ctrl_register(SPI_S_CS_UP_INT_EN, false);
+#endif
 
   GDMA_CFG_ST en_cfg;
   GDMACFG_TPYES_ST init_cfg;
@@ -232,10 +274,16 @@ void BekenSPILEDStripLightOutput::setup() {
 
   spi_dma_tx_enable(false);
 
+#ifdef BEKEN_SPI_IS_N_LIKE
+  // N-like variants: The SPI controller must be told how many bytes to clock out.
   value = REG_READ(SPI_CONFIG);
   value &= ~(0xFFF << 8);
   value |= ((dma_buffer_size & 0xFFF) << 8);
   REG_WRITE(SPI_CONFIG, value);
+#else
+  // T-like variants: No transfer-length register. The SPI controller shifts out
+  // everything the DMA writes into SPI_DAT.
+#endif
 }
 
 void BekenSPILEDStripLightOutput::set_led_params(uint8_t bit0, uint8_t bit1, uint32_t spi_frequency) {
@@ -265,13 +313,35 @@ void BekenSPILEDStripLightOutput::write_state(light::LightState *state) {
   }
 
   if (!spi_data->first_run && !xSemaphoreTake(spi_data->dma_tx_semaphore, 10 / portTICK_PERIOD_MS)) {
+    // Recover so the next update can try again instead of being stuck forever.
     ESP_LOGE(TAG, "Timed out waiting for semaphore");
+    spi_dma_tx_enable(false);
+    spi_data->tx_in_progress = false;
+    xSemaphoreGive(spi_data->dma_tx_semaphore);
+    this->status_set_warning();
+    this->schedule_show();
     return;
   }
 
+#ifndef BEKEN_SPI_IS_N_LIKE
+  if (!spi_data->first_run) {
+    // For T-like variants, the GDMA finish interrupt only means that all bytes were written into
+    // the SPI TX FIFO. We must still wait for it to drain before refilling it.
+    uint32_t wait_start = micros();
+    while (!(REG_READ(SPI_STAT) & TXFIFO_EMPTY)) {
+      if (micros() - wait_start > 2000) {
+        ESP_LOGW(TAG, "SPI TX FIFO did not drain in time");
+        break;
+      }
+    }
+  }
+#endif
+
   if (spi_data->tx_in_progress) {
     ESP_LOGE(TAG, "tx_in_progress is set");
+    xSemaphoreGive(spi_data->dma_tx_semaphore);
     this->status_set_warning();
+    this->schedule_show();
     return;
   }
 

esphome/components/beken_spi_led_strip/light.py

@@ -32,19 +32,12 @@ class LEDStripTimings:
     spi_frequency: int
 
 
+# The SPI clock divider depends on the chip family and is calculated in led_strip.cpp.
 CHIPSETS = {
-    "WS2812": LEDStripTimings(
-        0b11100000, 0b11111100, 6666666
-    ),  # Clock divider: 9, Bit time: 1350ns
-    "SK6812": LEDStripTimings(
-        0b11000000, 0b11111000, 7500000
-    ),  # Clock divider: 8, Bit time: 1200ns
-    "APA106": LEDStripTimings(
-        0b11000000, 0b11111110, 5454545
-    ),  # Clock divider: 11, Bit time: 1650ns
-    "SM16703": LEDStripTimings(
-        0b11000000, 0b11111110, 7500000
-    ),  # Clock divider: 8, Bit time: 1200ns
+    "WS2812": LEDStripTimings(0b11100000, 0b11111100, 6666666),
+    "SK6812": LEDStripTimings(0b11000000, 0b11111000, 7500000),
+    "APA106": LEDStripTimings(0b11000000, 0b11111110, 5454545),
+    "SM16703": LEDStripTimings(0b11000000, 0b11111110, 7500000),
 }
 
 
@@ -111,8 +104,7 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_num_leds(config[CONF_NUM_LEDS]))
     cg.add(var.set_pin(config[CONF_PIN]))
 
-    if CONF_MAX_REFRESH_RATE in config:
-        cg.add(var.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
+    cg.add_optional(var.set_max_refresh_rate, config.get(CONF_MAX_REFRESH_RATE))
 
     chipset = CHIPSETS[config[CONF_CHIPSET]]
     cg.add(

esphome/components/binary_sensor/binary_sensor.cpp

@@ -9,11 +9,9 @@ ESPHOME_LOG_TAG(TAG, "binary_sensor");
 
 // Function implementation of LOG_BINARY_SENSOR macro to reduce code size
 void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj) {
-  if (obj == nullptr) {
+  if (!log_entity_header(tag, prefix, type, obj)) {
     return;
   }
-
-  ESP_LOGCONFIG(tag, "%s%s '%s'", prefix, type, obj->get_name().c_str());
   LOG_ENTITY_DEVICE_CLASS(tag, prefix, *obj);
 }
 

esphome/components/bl0940/bl0940.cpp

@@ -122,6 +122,7 @@ float BL0940::calculate_energy_reference_() {
 float BL0940::calculate_calibration_value_(float state) { return (100 + state) / 100; }
 
 void BL0940::reset_calibration() {
+  ESP_LOGI(TAG, "Resetting calibration defaults...");
 #ifdef USE_NUMBER
   if (this->current_calibration_number_ != nullptr && this->current_cal_ != 1) {
     this->current_calibration_number_->make_call().set_value(0).perform();

esphome/components/bl0940/button/__init__.py

@@ -1,28 +1,19 @@
-import esphome.codegen as cg
 from esphome.components import button
 import esphome.config_validation as cv
 from esphome.const import ENTITY_CATEGORY_CONFIG, ICON_RESTART
 from esphome.types import ConfigType
 
-from .. import CONF_BL0940_ID, bl0940_ns
+from .. import CONF_BL0940_ID
 from ..sensor import BL0940
 
-CalibrationResetButton = bl0940_ns.class_(
-    "CalibrationResetButton", button.Button, cg.Component
-)
-
-CONFIG_SCHEMA = cv.All(
-    button.button_schema(
-        CalibrationResetButton,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-        icon=ICON_RESTART,
-    )
-    .extend({cv.GenerateID(CONF_BL0940_ID): cv.use_id(BL0940)})
-    .extend(cv.COMPONENT_SCHEMA)
-)
+CONFIG_SCHEMA = button.button_schema(
+    button.ApplyButton,
+    entity_category=ENTITY_CATEGORY_CONFIG,
+    icon=ICON_RESTART,
+).extend({cv.GenerateID(CONF_BL0940_ID): cv.use_id(BL0940)})
 
 
 async def to_code(config: ConfigType) -> None:
-    var = await button.new_button(config)
-    await cg.register_component(var, config)
-    await cg.register_parented(var, config[CONF_BL0940_ID])
+    await button.sub_buttons(config, parent=config[CONF_BL0940_ID]).create(
+        config, None, apply="reset_calibration()"
+    )

esphome/components/bl0940/button/calibration_reset_button.cpp

@@ -1,18 +0,0 @@
-#include "calibration_reset_button.h"
-#include "../bl0940.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-#include "esphome/core/application.h"
-
-namespace esphome::bl0940 {
-
-ESPHOME_LOG_TAG(TAG, "bl0940.button.calibration_reset");
-
-void CalibrationResetButton::dump_config() { LOG_BUTTON("", "Calibration Reset Button", this); }
-
-void CalibrationResetButton::press_action() {
-  ESP_LOGI(TAG, "Resetting calibration defaults...");
-  this->parent_->reset_calibration();
-}
-
-}  // namespace esphome::bl0940

esphome/components/bl0940/button/calibration_reset_button.h

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/button/button.h"
-
-namespace esphome::bl0940 {
-
-class BL0940;  // Forward declaration of BL0940 class
-
-class CalibrationResetButton final : public button::Button, public Component, public Parented<BL0940> {
- public:
-  void dump_config() override;
-
-  void press_action() override;
-};
-
-}  // namespace esphome::bl0940

esphome/components/bl0940/sensor.py

@@ -91,23 +91,6 @@ def calculate_energy_reference(power_reference: float) -> float:
     return power_reference * 3600000 / (1638.4 * 256)
 
 
-def validate_legacy_mode(config: ConfigType) -> ConfigType:
-    # Only allow schematic calibration options if legacy_mode is False
-    if config.get(CONF_LEGACY_MODE, True):
-        forbidden = [
-            CONF_REFERENCE_VOLTAGE,
-            CONF_RESISTOR_SHUNT,
-            CONF_RESISTOR_ONE,
-            CONF_RESISTOR_TWO,
-        ]
-        for key in forbidden:
-            if key in config:
-                raise cv.Invalid(
-                    f"Option '{key}' is only allowed when legacy_mode: false"
-                )
-    return config
-
-
 def set_command_defaults(config: ConfigType) -> ConfigType:
     # Set defaults for read_command and write_command based on legacy_mode
     legacy = config.get(CONF_LEGACY_MODE, True)
@@ -153,7 +136,7 @@ def set_reference_values(config: ConfigType) -> ConfigType:
     return config
 
 
-CONFIG_SCHEMA = (
+CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(BL0940),
@@ -208,9 +191,18 @@ CONFIG_SCHEMA = (
     )
     .extend(cv.polling_component_schema("60s"))
     .extend(uart.UART_DEVICE_SCHEMA)
-    .add_extra(validate_legacy_mode)
     .add_extra(set_command_defaults)
-    .add_extra(set_reference_values)
+    .add_extra(set_reference_values),
+    cv.only_when(
+        (
+            CONF_REFERENCE_VOLTAGE,
+            CONF_RESISTOR_SHUNT,
+            CONF_RESISTOR_ONE,
+            CONF_RESISTOR_TWO,
+        ),
+        CONF_LEGACY_MODE,
+        False,
+    ),
 )
 
 # BL0940 datasheet: 4800 baud, 8 data bits, no parity (stop bits are 1.5 -- not