Merge branch 'pi07' into pi08

Merge branch 'pi06' into pi07
Merge branch 'pi05' into pi06
2026-10-27 00:12:11 +00:00 · 2026-10-25 18:06:19 +11:00 · 2026-10-25 18:06:18 +11:00 · 2026-10-25 18:06:18 +11:00 · 2026-10-25 18:06:16 +11:00 · 2026-10-23 13:39:40 +11:00
876 changed files with 15378 additions and 18026 deletions
@@ -217,10 +217,9 @@ file does, and it is the authority when they disagree. The most useful starting
        the helper's arguments instead of writing a loop. 7-byte BCD RTC calendars use `time::decode_bcd_calendar<LAYOUT>`
        and `encode_bcd_calendar<LAYOUT>` with `EPSON_BCD_CALENDAR`, `DS_BCD_CALENDAR` or `PCF_BCD_CALENDAR`.
    *   **Bus helpers:** UART drains with `read_available(on_byte)` and `discard_available()`, text lines with
-        `LineReader<N>`, fixed-length binary frames with `FrameReader<N, HEADER...>`; 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)`.
+        `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.
@@ -444,16 +443,12 @@ file does, and it is the authority when they disagree. The most useful starting
          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.
-          `publish="momentary"` is only for legacy action switches (restart, factory reset): it publishes off and runs
-          the body only when turned on. Never use it for a new entity; an action is a button.
          ```python
          switches = switch.sub_switches(config, parent=hub)
          await switches(CONF_BLUETOOTH, None, apply="set_bluetooth(state)", publish="after")
          ```
          Restore an owned or standalone switch in `setup()` with `sw->restore()`, or `restore(default)`
          to still drive a state when the restore mode is disabled.
-          A hub that applies its switches' restored states itself reads `sw->get_initial_write_state()`, which
-          already applies `inverted`.

        - **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`)
@@ -196,6 +196,7 @@ esphome/components/ens160_base/* @latonita @vincentscode
 esphome/components/ens160_i2c/* @latonita
 esphome/components/ens160_spi/* @latonita
 esphome/components/ens210/* @itn3rd77
+esphome/components/entity_transport/* @clydebarrow
 esphome/components/epaper_spi/* @esphome/core
 esphome/components/es7210/* @kahrendt
 esphome/components/es7243/* @Chorty
@@ -641,7 +642,9 @@ esphome/components/sun_gtil2/* @Mat931
 esphome/components/switch/* @esphome/core
 esphome/components/switch/binary_sensor/* @ssieb
 esphome/components/sx126x/* @swoboda1337
+esphome/components/sx126x/packet_interface/* @clydebarrow
 esphome/components/sx127x/* @swoboda1337
+esphome/components/sx127x/packet_interface/* @clydebarrow
 esphome/components/sy6970/* @linkedupbits
 esphome/components/syslog/* @clydebarrow
 esphome/components/systa_bus/* @Mat931
@@ -653,6 +656,8 @@ esphome/components/tca8418/* @zebble
 esphome/components/tca9548a/* @andreashergert1984
 esphome/components/tca9555/* @mobrembski
 esphome/components/tcl112/* @glmnet
+esphome/components/tcp/* @clydebarrow
+esphome/components/tcp/packet_interface/* @clydebarrow
 esphome/components/tcp_uart/* @Bascht74
 esphome/components/tee501/* @Stock-M
 esphome/components/teleinfo/* @0hax @FredM67
@@ -1,18 +1,15 @@
 from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass, field
 import logging
-import math
 import string
 from typing import Any

 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ABOVE,
    CONF_ALL,
    CONF_ANY,
    CONF_AUTOMATION_ID,
-    CONF_BELOW,
    CONF_CONDITION,
    CONF_COUNT,
    CONF_ELSE,
@@ -366,25 +363,6 @@ class ApplyField:
        return ApplyCall(target, ((self.conf_key, self.type_, self.const_fn),))


-def _in_range_low(config: ConfigType, value: float) -> str:
-    return "-INFINITY" if math.isnan(value) else str(cg.safe_exp(value))
-
-
-def _in_range_high(config: ConfigType, value: float) -> str:
-    # With no lower bound, an unset upper bound stays NaN so the check is false, as before.
-    if math.isnan(value):
-        return "NAN" if math.isnan(config[CONF_ABOVE]) else "INFINITY"
-    return str(cg.safe_exp(value))
-
-
-# ``above <= state <= below`` on the parent's float ``state``; register with ``IN_RANGE_DEFAULTS``.
-IN_RANGE_CHECK = ApplyCall(
-    "state >= {} && {parent}->state <= {}",
-    ((CONF_ABOVE, cg.float_, _in_range_low), (CONF_BELOW, cg.float_, _in_range_high)),
-)
-IN_RANGE_DEFAULTS = {CONF_ABOVE: math.nan, CONF_BELOW: math.nan}
-
-
@dataclass(frozen=True)
 class ApplyBytes:
    """A byte payload key forwarded as ``target``, whose ``{}`` stands for ``data, len``.
@@ -713,11 +691,7 @@ async def _render_check(


 def register_apply_condition(
-    name: str,
-    schema: cv.Schema,
-    check: str | ApplyCall,
-    id_key: str = CONF_ID,
-    defaults: ConfigType | None = None,
+    name: str, schema: cv.Schema, check: str | ApplyCall, id_key: str = CONF_ID
 ) -> None:
    """Register a condition that is one expression on its parent, with no C++ class.

@@ -726,7 +700,6 @@ def register_apply_condition(
    against config values, all of which must be present. Write ``== false`` to negate.
    A ``cg.std_string`` constant stays in flash on ESP8266 and supports only ``==`` or ``!=``
    against a ``std::string`` or ``StringRef`` member; other string types are plain literals.
-    ``defaults`` fills absent keys at code generation only, so the validated config is unchanged.
    Generates one static predicate and an ``ApplyCondition`` templated on it.
    """
    call = check if isinstance(check, ApplyCall) else ApplyCall(check)
@@ -741,8 +714,6 @@ def register_apply_condition(
        template_arg: cg.TemplateArguments,
        args: TemplateArgsType,
    ) -> MockObj:
-        if defaults:
-            config = {**defaults, **config}
        parent = await _apply_parent(config, id_key)
        lambda_args = _apply_lambda_args(args)
        values = _apply_values(config, members)
@@ -7,7 +7,6 @@ import re
 import textwrap

 from esphome.build_helpers import pch
-from esphome.build_helpers.ccache import CCACHE_PCH_MIN_VERSION
 from esphome.components.esp32 import (
    KEY_SRC_CMAKE,
    get_esp32_variant,
@@ -516,7 +515,7 @@ target_link_options(${{COMPONENT_LIB}} PUBLIC
 # Where CMake puts the .gch of the src component; ccache reads the checksum
 # next to it in place of the .gch
 _PCH_SUM_PATH = "build/esp-idf/src/CMakeFiles/__idf_src.dir/cmake_pch.hxx.gch.sum"
-# Where the CMake gate records its choice
+# Where the Windows gate records its choice
 _PCH_CHOICE_VAR = "ESPHOME_PCH"


@@ -532,32 +531,16 @@ def _pch_cmake_block() -> str:
    block = f"""target_precompile_headers(${{COMPONENT_LIB}} PRIVATE
 {headers}
 )"""
-    if pch.pch_forced():
+    if not pch.pch_needs_gcc_check():
        return f"\n# ESPHome precompiled header\n{block}\n"
-    # Only CMake knows the compiler version before the first configure, and
-    # the ccache IDF found is the one the build runs
-    gcc_gate = ""
-    if pch.pch_needs_gcc_check():
-        gcc_gate = f"""if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND ({pch.PCH_WINDOWS_CMAKE_OLD_GCC}))
-  message(STATUS "ESPHome: GCC ${{CMAKE_CXX_COMPILER_VERSION}} cannot load a precompiled header on Windows; compiling without it")
-  set(_esphome_pch OFF)
-endif()
-"""
-    min_ccache = ".".join(map(str, CCACHE_PCH_MIN_VERSION))
+    # Before the first configure only CMake knows the compiler version
    return f"""
-# ESPHome precompiled header, unless a check below rules it out
-set(_esphome_pch ON)
-{gcc_gate}if(CCACHE_ENABLE AND CCACHE_FOUND)
-  execute_process(COMMAND "${{CCACHE_FOUND}}" --version OUTPUT_VARIABLE _esphome_ccache ERROR_QUIET)
-  if(_esphome_ccache MATCHES "ccache version ([0-9.]+)")
-    if(CMAKE_MATCH_1 VERSION_LESS {min_ccache})
-      message(STATUS "ESPHome: ccache ${{CMAKE_MATCH_1}} can reuse stale objects with a precompiled header; compiling without it (upgrade ccache to {min_ccache} or newer, or set ESPHOME_PCH_ENABLE=1 to force)")
-      set(_esphome_pch OFF)
-    endif()
-  endif()
-endif()
-set({_PCH_CHOICE_VAR} ${{_esphome_pch}} CACHE BOOL "ESPHome precompiled header in use" FORCE)
-if(_esphome_pch)
+# ESPHome precompiled header, unless GCC bug 14940 keeps it from loading
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND ({pch.PCH_WINDOWS_CMAKE_OLD_GCC}))
+  message(STATUS "ESPHome: GCC ${{CMAKE_CXX_COMPILER_VERSION}} cannot load a precompiled header on Windows; compiling without it")
+  set({_PCH_CHOICE_VAR} OFF CACHE BOOL "ESPHome precompiled header in use" FORCE)
+else()
+  set({_PCH_CHOICE_VAR} ON CACHE BOOL "ESPHome precompiled header in use" FORCE)
 {textwrap.indent(block, "  ")}
 endif()
 """
@@ -574,10 +557,10 @@ def write_pch_checksum() -> None:

    if not pch.pch_enabled():
        return
-    # Written whatever the gate chose last time: a build tree without that
-    # choice, or a reconfigure that turns the pch on, must not see a stale sum
-    if pch.pch_forced() or get_cmake_cache_value(_PCH_CHOICE_VAR) == "ON":
-        pch.log_pch_in_use()
+    # The gate's choice, cached by configure
+    if pch.pch_needs_gcc_check() and get_cmake_cache_value(_PCH_CHOICE_VAR) != "ON":
+        return
+    pch.log_pch_in_use()
    checksum = pch.pch_checksum(
        CORE.relative_src_path(),
        pch.PCH_DEFAULT_HEADERS,
@@ -3,68 +3,21 @@ resolution, and default ``CCACHE_*`` values."""

 from __future__ import annotations

-import functools
 import logging
 import os
 from pathlib import Path
-import re

-from esphome.framework_helpers import (
-    strip_win_long_path_prefix,
-    tool_version_probe,
-    tool_version_runs,
-)
+from esphome.framework_helpers import strip_win_long_path_prefix, tool_version_runs
 from esphome.helpers import FALSY_ENV_STRINGS, TRUTHY_ENV_STRINGS

 _LOGGER = logging.getLogger(__name__)


-# Before 4.7 ccache stores a pch consumer whose header is newer than one
-# second without that header, so a later build reuses it after the header
-# changed (#21621)
-CCACHE_PCH_MIN_VERSION = (4, 7)
-
-_VERSION_RE = re.compile(r"ccache version (\d+(?:\.\d+)*)")
-
-
-@functools.cache
-def _ccache_probe(ccache: str) -> str | Exception:
-    """``ccache --version``, run once per binary per process."""
-    return tool_version_probe(ccache)
-
-
 def _ccache_runs(ccache: str) -> bool:
    """Return True when the ``ccache`` found on PATH actually runs."""
    return tool_version_runs(
        ccache,
        "Ignoring ccache at %s because it failed to run; compiling without ccache",
-        probe=_ccache_probe,
-    )
-
-
-@functools.cache
-def _ccache_too_old_for_pch(ccache: str) -> bool:
-    output = _ccache_probe(ccache)
-    if not isinstance(output, str) or (found := _VERSION_RE.search(output)) is None:
-        return False
-    if tuple(map(int, found[1].split("."))) >= CCACHE_PCH_MIN_VERSION:
-        return False
-    _LOGGER.info(
-        "ccache %s at %s can reuse stale objects with a precompiled header; "
-        "compiling without it (upgrade ccache to %s or newer, or set "
-        "ESPHOME_PCH_ENABLE=1 to force)",
-        found[1],
-        ccache,
-        ".".join(map(str, CCACHE_PCH_MIN_VERSION)),
-    )
-    return True
-
-
-def ccache_breaks_pch() -> bool:
-    """Whether the ccache this build uses is too old for a precompiled header.
-    ESP-IDF builds check the ccache IDF finds in CMake instead (build_gen.espidf)."""
-    return (ccache := resolve_ccache_path()) is not None and _ccache_too_old_for_pch(
-        ccache
    )


@@ -12,11 +12,7 @@ import re
 import subprocess
 import sys

-from esphome.build_helpers.ccache import (
-    ccache_breaks_pch,
-    effective_ccache_basedir,
-    parse_enable_env,
-)
+from esphome.build_helpers.ccache import effective_ccache_basedir, parse_enable_env
 from esphome.const import PLATFORM_NRF52
 from esphome.helpers import write_file_if_changed

@@ -121,16 +117,9 @@ def pch_needs_gcc_check() -> bool:
    return sys.platform == "win32" and parse_enable_env("ESPHOME_PCH_ENABLE") is None


-def _ccache_rules_out_pch() -> bool:
-    """An old ccache, unless ``ESPHOME_PCH_ENABLE=1`` forces the pch on.
-    ESP-IDF runs the same check in CMake (build_gen.espidf)."""
-    return not pch_forced() and ccache_breaks_pch()
-
-
 def pch_usable(cxx: Sequence[Path | str]) -> bool:
-    """The knob plus the ccache and host rules; ``ESPHOME_PCH_ENABLE=1``
-    skips the rules."""
-    if not pch_enabled() or _ccache_rules_out_pch():
+    """The knob plus the host rule; ``ESPHOME_PCH_ENABLE=1`` skips the rule."""
+    if not pch_enabled():
        return False
    if not pch_needs_gcc_check():
        return True
@@ -173,11 +162,7 @@ def pch_script_enabled() -> bool:
    """Whether this PlatformIO build takes the pch script."""
    from esphome.core import CORE

-    return (
-        pch_enabled()
-        and CORE.target_platform not in PCH_SCRIPT_EXCLUDED_PLATFORMS
-        and not _ccache_rules_out_pch()
-    )
+    return pch_enabled() and CORE.target_platform not in PCH_SCRIPT_EXCLUDED_PLATFORMS


 def pch_header_text(include_headers: Iterable[str]) -> str:
@@ -90,10 +90,6 @@ class AirtonClimate : public climate_ir::ClimateIR {
  bool set_display_state(bool state);
  bool set_vertical_direction_state(VerticalDirection direction);
  void send_settings();
-  void control_vertical_direction(VerticalDirection direction) {
-    if (this->set_vertical_direction_state(direction))
-      this->send_settings();
-  }
  void set_setting(AirtonSetting setting, bool state) {
    const bool changed = setting == AirtonSetting::AIRTON_SETTING_DISPLAY ? this->set_display_state(state)
                                                                          : this->set_sleep_mode_state(state);
@@ -9,16 +9,18 @@ from ..climate import (
    CONF_VERTICAL_DIRECTION,
    VERTICAL_DIRECTIONS,
    AirtonClimate,
-    VerticalDirection,
+    airton_ns,
 )

 CODEOWNERS = ["@Procsiab"]

+VerticalDirectionSelect = airton_ns.class_("VerticalDirectionSelect", select.Select)
+
 CONFIG_SCHEMA = cv.Schema(
    {
        cv.GenerateID(CONF_AIRTON_ID): cv.use_id(AirtonClimate),
        cv.Optional(CONF_VERTICAL_DIRECTION): select.select_schema(
-            select.ApplySelect,
+            VerticalDirectionSelect,
            entity_category=ENTITY_CATEGORY_CONFIG,
        ),
    }
@@ -32,6 +34,4 @@ async def to_code(config: ConfigType) -> None:
        CONF_VERTICAL_DIRECTION,
        hub.set_vertical_direction_select,
        options=list(VERTICAL_DIRECTIONS),
-        # The options are in the order of the enum; the hub publishes the state
-        apply=f"control_vertical_direction(static_cast<{VerticalDirection}>(index))",
    )
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "../airton.h"
+
+namespace esphome::airton {
+
+class VerticalDirectionSelect : public select::Select, public Parented<AirtonClimate> {
+ protected:
+  // The options are in the order of the enum, so the index is the direction; the parent publishes the state
+  void control(size_t index) override {
+    if (this->parent_->set_vertical_direction_state(static_cast<VerticalDirection>(index)))
+      this->parent_->send_settings();
+  }
+};
+
+}  // namespace esphome::airton
@@ -1,6 +1,7 @@
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
+from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CODE,
@@ -9,11 +10,11 @@ from esphome.const import (
    CONF_ID,
    CONF_MQTT_ID,
    CONF_ON_STATE,
+    CONF_WEB_SERVER,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority, entity_helpers
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
-    mqtt_component_class,
    queue_entity_register,
    setup_entity,
 )
@@ -43,12 +44,12 @@ AlarmControlPanelState = alarm_control_panel_ns.enum("AlarmControlPanelState")


 _ALARM_CONTROL_PANEL_SCHEMA = (
-    cv.ENTITY_BASE_SCHEMA.extend(entity_helpers.WEBSERVER_SORTING_SCHEMA)
+    cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
    .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
    .extend(
        {
            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTAlarmControlPanelComponent")
+                mqtt.MQTTAlarmControlPanelComponent
            ),
            cv.Optional(CONF_ON_STATE): automation.validate_automation({}),
            cv.Optional(CONF_ON_TRIGGERED): automation.validate_automation({}),
@@ -165,7 +166,11 @@ _CALLBACK_AUTOMATIONS = (
@setup_entity("alarm_control_panel")
 async def setup_alarm_control_panel_core_(var, config):
    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
-    await entity_helpers.setup_entity_integrations(var, config)
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
+    if mqtt_id := config.get(CONF_MQTT_ID):
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
+        await mqtt.register_mqtt_component(mqtt_, config)


 async def register_alarm_control_panel(var, config):
@@ -11,52 +11,7 @@ ESPHOME_LOG_TAG(TAG, "apds9960");
    this->mark_failed(LOG_STR("Setting up APDS9960 registers failed")); \
    return; \
  }
-
-static constexpr i2c::I2CRegValue APDS9960_TIMING[] PROGMEM = {
-    // ATime (ADC integration time, 2.78ms increments, 0x81) -> 0xDB (103ms)
-    {0x81, 0xDB},
-    // WTime (Wait time, 0x83) -> 0xF6 (27ms)
-    {0x83, 0xF6},
-    // PPulse (0x8E) -> 0x87 (16us, 8 pulses)
-    {0x8E, 0x87},
-    // POffset UR (0x9D) -> 0 (no offset)
-    {0x9D, 0x00},
-    // POffset DL (0x9E) -> 0 (no offset)
-    {0x9E, 0x00},
-    // Config 1 (0x8D) -> 0x60 (no wtime factor)
-    {0x8D, 0x60},
-};
-
-static constexpr i2c::I2CRegValue APDS9960_INTERRUPT_GESTURE[] PROGMEM = {
-    // Pers (0x8C) -> 0x11 (2 consecutive proximity or ALS for interrupt)
-    {0x8C, 0x11},
-    // Config 2 (0x90) -> 0x01 (no saturation interrupts or LED boost)
-    {0x90, 0x01},
-    // Config 3 (0x9F) -> 0x00 (enable all photodiodes, no SAI)
-    {0x9F, 0x00},
-    // GPenTh (0xA0, gesture enter threshold) -> 0x28 (also 0x32)
-    {0xA0, 0x28},
-    // GPexTh (0xA1, gesture exit threshold) -> 0x1E
-    {0xA1, 0x1E},
-    // GConf 1 (0xA2, gesture config 1) -> 0x40 (4 gesture events for interrupt (GFIFO 3), 1 for exit)
-    {0xA2, 0x40},
-};
-
-static constexpr i2c::I2CRegValue APDS9960_GESTURE_OFFSETS[] PROGMEM = {
-    // GOffsetU (0xA4) -> 0x00 (no offset)
-    {0xA4, 0x00},
-    // GOffsetD (0xA5) -> 0x00 (no offset)
-    {0xA5, 0x00},
-    // GOffsetL (0xA7) -> 0x00 (no offset)
-    {0xA7, 0x00},
-    // GOffsetR (0xA9) -> 0x00 (no offset)
-    {0xA9, 0x00},
-    // GPulse (0xA6) -> 0xC9 (32 µs, 10 pulses)
-    {0xA6, 0xC9},
-    // GConf 3 (0xAA, gesture config 3) -> 0x00 (all photodiodes active during gesture, all gesture dimensions enabled)
-    // 0x00 -> all dimensions, 0x01 -> up down, 0x02 -> left right
-    {0xAA, 0x00},
-};
+#define APDS9960_WRITE_BYTE(reg, value) APDS9960_ERROR_CHECK(this->write_byte(reg, value));

 void APDS9960::setup() {
  uint8_t id;
@@ -70,27 +25,83 @@ void APDS9960::setup() {
    return;
  }

-  APDS9960_ERROR_CHECK(this->write_registers(APDS9960_TIMING));
+  // ATime (ADC integration time, 2.78ms increments, 0x81) -> 0xDB (103ms)
+  APDS9960_WRITE_BYTE(0x81, 0xDB);
+  // WTime (Wait time, 0x83) -> 0xF6 (27ms)
+  APDS9960_WRITE_BYTE(0x83, 0xF6);
+  // PPulse (0x8E) -> 0x87 (16us, 8 pulses)
+  APDS9960_WRITE_BYTE(0x8E, 0x87);
+  // POffset UR (0x9D) -> 0 (no offset)
+  APDS9960_WRITE_BYTE(0x9D, 0x00);
+  // POffset DL (0x9E) -> 0 (no offset)
+  APDS9960_WRITE_BYTE(0x9E, 0x00);
+  // Config 1 (0x8D) -> 0x60 (no wtime factor)
+  APDS9960_WRITE_BYTE(0x8D, 0x60);

-  // Control (0x8F): led drive (0 -> 100mA, 1 -> 50mA, 2 -> 25mA, 3 -> 12.5mA),
-  // proximity gain (0 -> 1x, 1 -> 2X, 2 -> 4X, 3 -> 8X), ambient light gain (0 -> 1x, 1 -> 4x, 2 -> 16x, 3 -> 64x)
-  APDS9960_ERROR_CHECK(this->update_register(
-      0x8F, 0b11001111,
-      (this->led_drive_ & 0b11) << 6 | (this->proximity_gain_ & 0b11) << 2 | (this->ambient_gain_ & 0b11)));
+  // Control (0x8F) ->
+  uint8_t val = 0;
+  APDS9960_ERROR_CHECK(this->read_byte(0x8F, &val));
+  val &= 0b00111111;
+  // led drive, 0 -> 100mA, 1 -> 50mA, 2 -> 25mA, 3 -> 12.5mA
+  val |= (this->led_drive_ & 0b11) << 6;

-  APDS9960_ERROR_CHECK(this->write_registers(APDS9960_INTERRUPT_GESTURE));
+  val &= 0b11110011;
+  // proximity gain, 0 -> 1x, 1 -> 2X, 2 -> 4X, 3 -> 8X
+  val |= (this->proximity_gain_ & 0b11) << 2;

-  // GConf 2 (0xA3): gesture gain (0 -> 1x, 1 -> 2x, 2 -> 4x, 3 -> 8x),
-  // gesture led drive (0 -> 100mA, 1 -> 50mA, 2 -> 25mA, 3 -> 12.5mA), gesture wait time
-  // (0 -> 0ms, 1 -> 2.8ms, 2 -> 5.6ms, 3 -> 8.4ms, 4 -> 14.0ms, 5 -> 22.4 ms, 6 -> 30.8ms, 7 -> 39.2 ms)
-  APDS9960_ERROR_CHECK(this->update_register(
-      0xA3, 0b01111111,
-      (this->gesture_gain_ & 0b11) << 5 | (this->gesture_led_drive_ & 0b11) << 3 | (this->gesture_wait_time_ & 0b111)));
+  val &= 0b11111100;
+  // ambient light gain, 0 -> 1x, 1 -> 4x, 2 -> 16x, 3 -> 64x
+  val |= (this->ambient_gain_ & 0b11) << 0;
+  APDS9960_WRITE_BYTE(0x8F, val);

-  APDS9960_ERROR_CHECK(this->write_registers(APDS9960_GESTURE_OFFSETS));
+  // Pers (0x8C) -> 0x11 (2 consecutive proximity or ALS for interrupt)
+  APDS9960_WRITE_BYTE(0x8C, 0x11);
+  // Config 2 (0x90) -> 0x01 (no saturation interrupts or LED boost)
+  APDS9960_WRITE_BYTE(0x90, 0x01);
+  // Config 3 (0x9F) -> 0x00 (enable all photodiodes, no SAI)
+  APDS9960_WRITE_BYTE(0x9F, 0x00);
+  // GPenTh (0xA0, gesture enter threshold) -> 0x28 (also 0x32)
+  APDS9960_WRITE_BYTE(0xA0, 0x28);
+  // GPexTh (0xA1, gesture exit threshold) -> 0x1E
+  APDS9960_WRITE_BYTE(0xA1, 0x1E);
+
+  // GConf 1 (0xA2, gesture config 1) -> 0x40 (4 gesture events for interrupt (GFIFO 3), 1 for exit)
+  APDS9960_WRITE_BYTE(0xA2, 0x40);
+
+  // GConf 2 (0xA3, gesture config 2) ->
+  APDS9960_ERROR_CHECK(this->read_byte(0xA3, &val));
+  val &= 0b10011111;
+  // gesture gain, 0 -> 1x, 1 -> 2x, 2 -> 4x, 3 -> 8x
+  val |= (this->gesture_gain_ & 0b11) << 5;
+
+  val &= 0b11100111;
+  // gesture led drive, 0 -> 100mA, 1 -> 50mA, 2 -> 25mA, 3 -> 12.5mA
+  val |= (this->gesture_led_drive_ & 0b11) << 3;
+
+  val &= 0b11111000;
+  // gesture wait time
+  // 0 -> 0ms, 1 -> 2.8ms, 2 -> 5.6ms, 3 -> 8.4ms
+  // 4 -> 14.0ms, 5 -> 22.4 ms, 6 -> 30.8ms, 7 -> 39.2 ms
+  val |= (this->gesture_wait_time_ & 0b111) << 0;
+  APDS9960_WRITE_BYTE(0xA3, val);
+
+  // GOffsetU (0xA4) -> 0x00 (no offset)
+  APDS9960_WRITE_BYTE(0xA4, 0x00);
+  // GOffsetD (0xA5) -> 0x00 (no offset)
+  APDS9960_WRITE_BYTE(0xA5, 0x00);
+  // GOffsetL (0xA7) -> 0x00 (no offset)
+  APDS9960_WRITE_BYTE(0xA7, 0x00);
+  // GOffsetR (0xA9) -> 0x00 (no offset)
+  APDS9960_WRITE_BYTE(0xA9, 0x00);
+  // GPulse (0xA6) -> 0xC9 (32 µs, 10 pulses)
+  APDS9960_WRITE_BYTE(0xA6, 0xC9);
+
+  // GConf 3 (0xAA, gesture config 3) -> 0x00 (all photodiodes active during gesture, all gesture dimensions enabled)
+  // 0x00 -> all dimensions, 0x01 -> up down, 0x02 -> left right
+  APDS9960_WRITE_BYTE(0xAA, 0x00);

  // Enable (0x80) ->
-  uint8_t val = 0;
+  val = 0;
  val |= (0b1) << 0;  // power on
  val |= (this->is_color_enabled_() & 0b1) << 1;
  val |= (this->is_proximity_enabled_() & 0b1) << 2;
@@ -98,7 +109,7 @@ void APDS9960::setup() {
  val |= 0b0 << 4;                                  // color interrupt disabled
  val |= 0b0 << 5;                                  // proximity interrupt disabled
  val |= (this->is_gesture_enabled_() & 0b1) << 6;  // proximity is required for gestures
-  APDS9960_ERROR_CHECK(this->write_byte(0x80, val));
+  APDS9960_WRITE_BYTE(0x80, val);
 }
 bool APDS9960::is_color_enabled_() const {
 #ifdef USE_SENSOR
@@ -1555,17 +1555,8 @@ void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequ
 // Event is a special case - unlike other entities with simple state fields,
 // events store their state in a member accessed via obj->get_last_event_type()
 void APIConnection::send_event(event::Event *event) {
-  const uint8_t type_index = event->get_last_event_type_index();
-  const size_t size_before = this->deferred_batch_.size();
-  if (this->deferred_batch_.contains(event, EventResponse::MESSAGE_TYPE)) {
-    // Sending now would overtake the older event of this entity that still waits in the batch
-    this->schedule_message_(event, EventResponse::MESSAGE_TYPE, EventResponse::ESTIMATED_SIZE, type_index);
-  } else {
-    this->send_message_smart_(event, EventResponse::MESSAGE_TYPE, EventResponse::ESTIMATED_SIZE, type_index);
-  }
-  // Events are rare, so a queued one sends the batch now rather than after batch_delay
-  if (this->deferred_batch_.size() > size_before)
-    this->make_batch_due_now_();
+  this->send_message_smart_(event, EventResponse::MESSAGE_TYPE, EventResponse::ESTIMATED_SIZE,
+                            event->get_last_event_type_index());
 }
 uint16_t APIConnection::try_send_event_response(event::Event *event, StringRef event_type, APIConnection *conn,
                                                uint32_t remaining_size) {
@@ -2,7 +2,6 @@

 #include "esphome/core/defines.h"
 #ifdef USE_API
-#include "api_deferred_batch.h"
 #include "api_frame_helper.h"
 #ifdef USE_API_NOISE
 #include "api_frame_helper_noise.h"
@@ -21,6 +20,7 @@
 #include "esphome/core/string_ref.h"

 #include <functional>
+#include <limits>
 #include <vector>

 namespace esphome {
@@ -656,6 +656,73 @@ class APIConnection final : public APIServerConnectionBase {
  // Function pointer type for message encoding
  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size);

+  // Generic batching mechanism for both state updates and entity info
+  struct DeferredBatch {
+    // Sentinel value for unused aux_data_index
+    static constexpr uint8_t AUX_DATA_UNUSED = std::numeric_limits<uint8_t>::max();
+
+    struct BatchItem {
+      EntityBase *entity;                       // 4 bytes - Entity pointer
+      uint16_t message_type;                    // 2 bytes - Message type for protocol and dispatch
+      uint8_t estimated_size;                   // 1 byte - Estimated message size (max 255 bytes)
+      uint8_t aux_data_index{AUX_DATA_UNUSED};  // 1 byte - For events: index into entity's event_types
+    };
+
+    std::vector<BatchItem> items;
+    uint32_t batch_start_time{0};
+
+    // No pre-allocation - log connections never use batching, and for
+    // connections that do, buffers are released after initial sync anyway
+
+    // Add item to the batch (with deduplication)
+    void add_item(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
+                  uint8_t aux_data_index = AUX_DATA_UNUSED) {
+      // Dedup: O(n) scan but optimized for RAM over performance
+      // Skip deduplication for events - they are edge-triggered, every occurrence matters
+#ifdef USE_EVENT
+      if (message_type != EventResponse::MESSAGE_TYPE)
+#endif
+      {
+        for (const auto &item : this->items) {
+          if (item.entity == entity && item.message_type == message_type)
+            return;  // Already queued
+        }
+      }
+      this->items.push_back({entity, message_type, estimated_size, aux_data_index});
+    }
+    // Add item to the front of the batch (for high priority messages like ping)
+    void add_item_front(EntityBase *entity, uint16_t message_type, uint8_t estimated_size) {
+      // Swap to front avoids expensive vector::insert which shifts all elements
+      this->items.push_back({entity, message_type, estimated_size, AUX_DATA_UNUSED});
+      if (this->items.size() > 1) {
+        std::swap(this->items.front(), this->items.back());
+      }
+    }
+
+    // Clear all items
+    void clear() {
+      items.clear();
+      batch_start_time = 0;
+    }
+
+    // Remove processed items from the front — noinline to keep memmove out of warm callers
+    void remove_front(size_t count) __attribute__((noinline)) { items.erase(items.begin(), items.begin() + count); }
+
+    bool empty() const { return items.empty(); }
+    size_t size() const { return items.size(); }
+    const BatchItem &operator[](size_t index) const { return items[index]; }
+
+    // Release excess capacity - only releases if items already empty
+    void release_buffer() {
+      // Safe to call: batch is processed before release_buffer is called,
+      // and if any items remain (partial processing), we must not clear them.
+      // Use swap trick since shrink_to_fit() is non-binding and may be ignored.
+      if (items.empty()) {
+        std::vector<BatchItem>().swap(items);
+      }
+    }
+  };
+
  // DeferredBatch here (16 bytes, 4-byte aligned)
  DeferredBatch deferred_batch_;

@@ -728,10 +795,6 @@ class APIConnection final : public APIServerConnectionBase {
  static constexpr size_t MAX_BATCH_PACKET_SIZE = 1390;  // MTU

  bool schedule_batch_();
-  // Sends the batch on the next loop, so a queued event does not wait for batch_delay; queued states go with it
-  void make_batch_due_now_() {
-    this->deferred_batch_.batch_start_time = App.get_loop_component_start_time() - this->get_batch_delay_ms_();
-  }
  void process_batch_();
  void process_batch_multi_(APIBuffer &shared_buf, size_t num_items, uint8_t header_padding, uint8_t footer_size)
      __attribute__((noinline));
@@ -1,88 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-#ifdef USE_API
-#include "api_pb2.h"
-#include "esphome/core/entity_base.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <limits>
-#include <vector>
-
-namespace esphome::api {
-
-// Generic batching mechanism for both state updates and entity info
-struct DeferredBatch {
-  // Sentinel value for unused aux_data_index
-  static constexpr uint8_t AUX_DATA_UNUSED = std::numeric_limits<uint8_t>::max();
-
-  struct BatchItem {
-    EntityBase *entity;                       // 4 bytes - Entity pointer
-    uint16_t message_type;                    // 2 bytes - Message type for protocol and dispatch
-    uint8_t estimated_size;                   // 1 byte - Estimated message size (max 255 bytes)
-    uint8_t aux_data_index{AUX_DATA_UNUSED};  // 1 byte - For events: index into entity's event_types
-  };
-
-  std::vector<BatchItem> items;
-  uint32_t batch_start_time{0};
-
-  // No pre-allocation - log connections never use batching, and for
-  // connections that do, buffers are released after initial sync anyway
-
-  // O(n) scan but optimized for RAM over performance
-  bool contains(EntityBase *entity, uint16_t message_type) const {
-    for (const auto &item : this->items) {
-      if (item.entity == entity && item.message_type == message_type)
-        return true;
-    }
-    return false;
-  }
-
-  // Add item to the batch (with deduplication)
-  void add_item(EntityBase *entity, uint16_t message_type, uint8_t estimated_size,
-                uint8_t aux_data_index = AUX_DATA_UNUSED) {
-    // Skip deduplication for events - they are edge-triggered, every occurrence matters
-#ifdef USE_EVENT
-    if (message_type != EventResponse::MESSAGE_TYPE)
-#endif
-    {
-      if (this->contains(entity, message_type))
-        return;  // Already queued
-    }
-    this->items.push_back({entity, message_type, estimated_size, aux_data_index});
-  }
-  // Add item to the front of the batch (for high priority messages like ping)
-  void add_item_front(EntityBase *entity, uint16_t message_type, uint8_t estimated_size) {
-    // Shift rather than swap, so the queued items keep their order (two events of one entity must not swap)
-    this->items.push_back({});
-    std::move_backward(this->items.begin(), this->items.end() - 1, this->items.end());
-    this->items.front() = {entity, message_type, estimated_size, AUX_DATA_UNUSED};
-  }
-
-  // Clear all items
-  void clear() {
-    items.clear();
-    batch_start_time = 0;
-  }
-
-  // Remove processed items from the front — noinline to keep memmove out of warm callers
-  void remove_front(size_t count) __attribute__((noinline)) { items.erase(items.begin(), items.begin() + count); }
-
-  bool empty() const { return items.empty(); }
-  size_t size() const { return items.size(); }
-  const BatchItem &operator[](size_t index) const { return items[index]; }
-
-  // Release excess capacity - only releases if items already empty
-  void release_buffer() {
-    // Safe to call: batch is processed before release_buffer is called,
-    // and if any items remain (partial processing), we must not clear them.
-    // Use swap trick since shrink_to_fit() is non-binding and may be ignored.
-    if (items.empty()) {
-      std::vector<BatchItem>().swap(items);
-    }
-  }
-};
-
-}  // namespace esphome::api
-#endif  // USE_API
@@ -6,11 +6,19 @@ namespace esphome::as3935_i2c {
 ESPHOME_LOG_TAG(TAG, "as3935_i2c");

 void I2CAS3935Component::write_register(uint8_t reg, uint8_t mask, uint8_t bits, uint8_t start_pos) {
-  const uint8_t value = bits << start_pos;
-  // Bits of value outside mask were ORed in before, so they stay part of the update
-  // Also called at runtime, so a transient bus error only warns, like read_register()
-  if (!this->update_register(reg, mask | value, value)) {
-    ESP_LOGW(TAG, "Failed to update register 0x%02X", reg);
+  uint8_t write_reg;
+  if (!this->read_byte(reg, &write_reg)) {
+    this->mark_failed();
+    ESP_LOGW(TAG, "read_byte failed - increase log level for more details!");
+    return;
+  }
+
+  write_reg &= (~mask);
+  write_reg |= (bits << start_pos);
+
+  if (!this->write_byte(reg, write_reg)) {
+    ESP_LOGW(TAG, "write_byte failed - increase log level for more details!");
+    return;
  }
 }

@@ -240,11 +240,17 @@ bool AS7341Component::write_register_bit(uint8_t address, bool value, uint8_t bi
 }

 bool AS7341Component::set_register_bit(uint8_t address, uint8_t bit_position) {
-  return this->update_register(address, 1 << bit_position, 1 << bit_position);
+  uint8_t data;
+  this->read_byte(address, &data);
+  data |= (1 << bit_position);
+  return this->write_byte(address, data);
 }

 bool AS7341Component::clear_register_bit(uint8_t address, uint8_t bit_position) {
-  return this->update_register(address, 1 << bit_position, 0);
+  uint8_t data;
+  this->read_byte(address, &data);
+  data &= ~(1 << bit_position);
+  return this->write_byte(address, data);
 }

 }  // namespace esphome::as7341
@@ -264,7 +264,12 @@ bool AS734XComponent::select_bank_(uint8_t reg) {
 }

 bool AS734XComponent::update_bits_(uint8_t reg, uint8_t mask, bool value) {
-  return this->select_bank_(reg) && this->update_register(reg, mask, value ? mask : 0);
+  uint8_t data = 0;
+  if (!this->select_bank_(reg) || !this->read_byte(reg, &data)) {
+    return false;
+  }
+  data = value ? (data | mask) : (data & ~mask);
+  return this->write_byte(reg, data);
 }

 // The exposure is applied before every measurement, so a gain, ATIME or ASTEP changed at runtime
@@ -108,7 +108,8 @@ CONFIG_SCHEMA = cv.Schema(


 def _final_validate(config: ConfigType) -> ConfigType:
-    hub = fv.get_declaring_config(config[CONF_AS734X_ID])
+    full = fv.full_config.get()
+    hub = full.get_config_for_path(full.get_path_for_id(config[CONF_AS734X_ID])[:-1])
    if hub[CONF_TYPE] != "AS7341":
        return config
    for key in _BAND_KEYS:
@@ -4,13 +4,14 @@ import esphome.config_validation as cv
 from esphome.const import DEVICE_CLASS_SWITCH, ICON_WIFI
 from esphome.types import ConfigType

-from .. import CONF_AT581X_ID, AT581XComponent
+from .. import CONF_AT581X_ID, AT581XComponent, at581x_ns

 DEPENDENCIES = ["at581x"]

+RFSwitch = at581x_ns.class_("RFSwitch", switch.Switch)

 CONFIG_SCHEMA = switch.switch_schema(
-    switch.ApplySwitch,
+    RFSwitch,
    device_class=DEVICE_CLASS_SWITCH,
    icon=ICON_WIFI,
 ).extend(
@@ -23,7 +24,7 @@ CONFIG_SCHEMA = switch.switch_schema(


 async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_AT581X_ID])
-    await switch.sub_switches(config, parent=hub).create(
-        config, hub.set_rf_power_switch, apply="set_rf_mode(state)", publish="before"
-    )
+    at581x_component = await cg.get_variable(config[CONF_AT581X_ID])
+    s = await switch.new_switch(config)
+    await cg.register_parented(s, config[CONF_AT581X_ID])
+    cg.add(at581x_component.set_rf_power_switch(s))
@@ -0,0 +1,10 @@
+#include "rf_switch.h"
+
+namespace esphome::at581x {
+
+void RFSwitch::write_state(bool state) {
+  this->publish_state(state);
+  this->parent_->set_rf_mode(state);
+}
+
+}  // namespace esphome::at581x
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "../at581x.h"
+
+namespace esphome::at581x {
+
+class RFSwitch final : public switch_::Switch, public Parented<AT581XComponent> {
+ protected:
+  void write_state(bool state) override;
+};
+
+}  // namespace esphome::at581x
@@ -58,7 +58,7 @@ optional<ParseResult> ATCMiThermometer::parse_header_(const ble_device_base::Ser
    return {};
  }

-  const auto &raw = service_data.data;
+  auto raw = service_data.data;
  if (raw.size() < 13) {
    ESP_LOGVV(TAG, "parse_header_(): service data too short (%zu).", raw.size());
    return {};
@@ -4,9 +4,7 @@
 #include "bedjet_child.h"
 #include "bedjet_const.h"
 #include "esphome/core/application.h"
-#include <algorithm>
 #include <cinttypes>
-#include <cstring>

 namespace esphome::bedjet {

@@ -42,7 +40,7 @@ void BedJetHub::upgrade_firmware() {
  auto status = this->write_bedjet_packet_(pkt);

  if (status) {
-    ESP_LOGW(TAG, "[%s] MAGIC_UPDATE button failed, status=%d", this->get_name(), status);
+    ESP_LOGW(TAG, "[%s] MAGIC_UPDATE button failed, status=%d", this->get_name().c_str(), status);
  }
 }

@@ -66,7 +64,7 @@ bool BedJetHub::set_fan_index(uint8_t fan_speed_index) {
  auto status = this->write_bedjet_packet_(pkt);

  if (status) {
-    ESP_LOGW(TAG, "[%s] writing fan speed failed, status=%d", this->get_name(), status);
+    ESP_LOGW(TAG, "[%s] writing fan speed failed, status=%d", this->get_name().c_str(), status);
  }
  return status == 0;
 }
@@ -84,7 +82,7 @@ bool BedJetHub::set_target_temp(float temp_c) {
  auto status = this->write_bedjet_packet_(pkt);

  if (status) {
-    ESP_LOGW(TAG, "[%s] writing target temp failed, status=%d", this->get_name(), status);
+    ESP_LOGW(TAG, "[%s] writing target temp failed, status=%d", this->get_name().c_str(), status);
  }
  return status == 0;
 }
@@ -95,7 +93,7 @@ bool BedJetHub::set_time_remaining(uint8_t hours, uint8_t mins) {
  auto status = this->write_bedjet_packet_(pkt);

  if (status) {
-    ESP_LOGW(TAG, "[%s] writing remaining runtime failed, status=%d", this->get_name(), status);
+    ESP_LOGW(TAG, "[%s] writing remaining runtime failed, status=%d", this->get_name().c_str(), status);
  }
  return status == 0;
 }
@@ -105,10 +103,11 @@ bool BedJetHub::send_button(BedjetButton button) {
  auto status = this->write_bedjet_packet_(pkt);

  if (status) {
-    ESP_LOGW(TAG, "[%s] writing button %s failed, status=%d", this->get_name(),
+    ESP_LOGW(TAG, "[%s] writing button %s failed, status=%d", this->get_name().c_str(),
             LOG_STR_ARG(bedjet_button_to_string(button)), status);
  } else {
-    ESP_LOGD(TAG, "[%s] writing button %s success", this->get_name(), LOG_STR_ARG(bedjet_button_to_string(button)));
+    ESP_LOGD(TAG, "[%s] writing button %s success", this->get_name().c_str(),
+             LOG_STR_ARG(bedjet_button_to_string(button)));
  }
  return status == 0;
 }
@@ -126,9 +125,9 @@ uint16_t BedJetHub::get_time_remaining() {
 uint8_t BedJetHub::write_bedjet_packet_(BedjetPacket *pkt) {
  if (!this->is_connected()) {
    if (!this->parent_->enabled) {
-      ESP_LOGI(TAG, "[%s] Cannot write packet: Not connected, enabled=false", this->get_name());
+      ESP_LOGI(TAG, "[%s] Cannot write packet: Not connected, enabled=false", this->get_name().c_str());
    } else {
-      ESP_LOGW(TAG, "[%s] Cannot write packet: Not connected", this->get_name());
+      ESP_LOGW(TAG, "[%s] Cannot write packet: Not connected", this->get_name().c_str());
    }
    return -1;
  }
@@ -145,16 +144,16 @@ uint8_t BedJetHub::set_notify_(const bool enable) {
    status = esp_ble_gattc_register_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
                                               this->char_handle_status_);
    if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_register_for_notify failed, status=%d", this->get_name().c_str(), status);
    }
  } else {
    status = esp_ble_gattc_unregister_for_notify(this->parent_->get_gattc_if(), this->parent_->get_remote_bda(),
                                                 this->char_handle_status_);
    if (status) {
-      ESP_LOGW(TAG, "[%s] esp_ble_gattc_unregister_for_notify failed, status=%d", this->get_name(), status);
+      ESP_LOGW(TAG, "[%s] esp_ble_gattc_unregister_for_notify failed, status=%d", this->get_name().c_str(), status);
    }
  }
-  ESP_LOGV(TAG, "[%s] set_notify: enable=%d; result=%d", this->get_name(), enable, status);
+  ESP_LOGV(TAG, "[%s] set_notify: enable=%d; result=%d", this->get_name().c_str(), enable, status);
  return status;
 }

@@ -165,7 +164,7 @@ bool BedJetHub::discover_characteristics_() {
  if (!this->char_handle_cmd_) {
    chr = this->parent_->get_characteristic(BEDJET_SERVICE_UUID, BEDJET_COMMAND_UUID);
    if (chr == nullptr) {
-      ESP_LOGW(TAG, "[%s] No control service found at device, not a BedJet..?", this->get_name());
+      ESP_LOGW(TAG, "[%s] No control service found at device, not a BedJet..?", this->get_name().c_str());
      result = false;
    } else {
      this->char_handle_cmd_ = chr->handle;
@@ -175,7 +174,7 @@ bool BedJetHub::discover_characteristics_() {
  if (!this->char_handle_status_) {
    chr = this->parent_->get_characteristic(BEDJET_SERVICE_UUID, BEDJET_STATUS_UUID);
    if (chr == nullptr) {
-      ESP_LOGW(TAG, "[%s] No status service found at device, not a BedJet..?", this->get_name());
+      ESP_LOGW(TAG, "[%s] No status service found at device, not a BedJet..?", this->get_name().c_str());
      result = false;
    } else {
      this->char_handle_status_ = chr->handle;
@@ -205,14 +204,14 @@ bool BedJetHub::discover_characteristics_() {
  if (!this->char_handle_name_) {
    chr = this->parent_->get_characteristic(BEDJET_SERVICE_UUID, BEDJET_NAME_UUID);
    if (chr == nullptr) {
-      ESP_LOGW(TAG, "[%s] No name service found at device, not a BedJet..?", this->get_name());
+      ESP_LOGW(TAG, "[%s] No name service found at device, not a BedJet..?", this->get_name().c_str());
      result = false;
    } else {
      this->char_handle_name_ = chr->handle;
      auto status = esp_ble_gattc_read_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
                                            this->char_handle_name_, ESP_GATT_AUTH_REQ_NONE);
      if (status) {
-        ESP_LOGI(TAG, "[%s] Unable to read name characteristic: %d", this->get_name(), status);
+        ESP_LOGI(TAG, "[%s] Unable to read name characteristic: %d", this->get_name().c_str(), status);
      }
    }
  }
@@ -223,7 +222,7 @@ bool BedJetHub::discover_characteristics_() {
           "     - Status char: 0x%x\n"
           "       - config descriptor: 0x%x\n"
           "     - Name char: 0x%x",
-           this->get_name(), this->char_handle_cmd_, this->char_handle_status_, this->config_descr_status_,
+           this->get_name().c_str(), this->char_handle_cmd_, this->char_handle_status_, this->config_descr_status_,
           this->char_handle_name_);

  return result;
@@ -242,7 +241,7 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
      auto result = this->discover_characteristics_();

      if (result) {
-        ESP_LOGD(TAG, "[%s] Services complete: obtained char handles.", this->get_name());
+        ESP_LOGD(TAG, "[%s] Services complete: obtained char handles.", this->get_name().c_str());
        this->node_state = espbt::ClientState::ESTABLISHED;
        this->set_notify_(true);

@@ -254,7 +253,7 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga

        this->dispatch_state_(true);
      } else {
-        ESP_LOGW(TAG, "[%s] Failed discovering service characteristics.", this->get_name());
+        ESP_LOGW(TAG, "[%s] Failed discovering service characteristics.", this->get_name().c_str());
        this->parent()->set_enabled(false);
        this->status_set_warning();
        this->dispatch_state_(false);
@@ -266,15 +265,15 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
        if (param->write.status == ESP_GATT_INVALID_ATTR_LEN) {
          // This probably means that our hack for notify_en (8 bit vs 16 bit) didn't work right.
          // Should we try to fall back to BLEClient's way?
-          ESP_LOGW(TAG, "[%s] Invalid attr length writing descr at handle 0x%04d, status=%d", this->get_name(),
+          ESP_LOGW(TAG, "[%s] Invalid attr length writing descr at handle 0x%04d, status=%d", this->get_name().c_str(),
                   param->write.handle, param->write.status);
        } else {
-          ESP_LOGW(TAG, "[%s] Error writing descr at handle 0x%04d, status=%d", this->get_name(), param->write.handle,
-                   param->write.status);
+          ESP_LOGW(TAG, "[%s] Error writing descr at handle 0x%04d, status=%d", this->get_name().c_str(),
+                   param->write.handle, param->write.status);
        }
        break;
      }
-      ESP_LOGD(TAG, "[%s] Write to handle 0x%04x status=%d", this->get_name(), param->write.handle,
+      ESP_LOGD(TAG, "[%s] Write to handle 0x%04x status=%d", this->get_name().c_str(), param->write.handle,
               param->write.status);
      break;
    }
@@ -307,11 +306,9 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
      } else if (param->read.handle == this->char_handle_name_) {
        // The data should represent the name.
        if (param->read.status == ESP_GATT_OK && param->read.value_len > 0) {
-          ESP_LOGV(TAG, "[%s] Got BedJet name: '%.*s'", this->get_name(), static_cast<int>(param->read.value_len),
-                   reinterpret_cast<const char *>(param->read.value));
-          const size_t len = std::min<size_t>(param->read.value_len, sizeof(this->name_) - 1);
-          memcpy(this->name_, param->read.value, len);
-          this->name_[len] = '\0';
+          std::string bedjet_name(reinterpret_cast<char const *>(param->read.value), param->read.value_len);
+          ESP_LOGV(TAG, "[%s] Got BedJet name: '%s'", this->get_name().c_str(), bedjet_name.c_str());
+          this->set_name_(bedjet_name);
        }
      }
      break;
@@ -325,8 +322,8 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
      // doesn't break anything.

      if (param->reg_for_notify.handle != this->char_handle_status_) {
-        ESP_LOGW(TAG, "[%s] Register for notify on unexpected handle 0x%04x, expecting 0x%04x", this->get_name(),
-                 param->reg_for_notify.handle, this->char_handle_status_);
+        ESP_LOGW(TAG, "[%s] Register for notify on unexpected handle 0x%04x, expecting 0x%04x",
+                 this->get_name().c_str(), param->reg_for_notify.handle, this->char_handle_status_);
        break;
      }

@@ -338,8 +335,8 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT: {
      // This event is not handled by the parent BLEClient, so we need to do this either way.
      if (param->unreg_for_notify.handle != this->char_handle_status_) {
-        ESP_LOGW(TAG, "[%s] Unregister for notify on unexpected handle 0x%04x, expecting 0x%04x", this->get_name(),
-                 param->unreg_for_notify.handle, this->char_handle_status_);
+        ESP_LOGW(TAG, "[%s] Unregister for notify on unexpected handle 0x%04x, expecting 0x%04x",
+                 this->get_name().c_str(), param->unreg_for_notify.handle, this->char_handle_status_);
        break;
      }

@@ -353,13 +350,13 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
        break;

      if (param->notify.conn_id != this->parent_->get_conn_id()) {
-        ESP_LOGW(TAG, "[%s] Received notify event for unexpected parent conn: expect %x, got %x", this->get_name(),
-                 this->parent_->get_conn_id(), param->notify.conn_id);
+        ESP_LOGW(TAG, "[%s] Received notify event for unexpected parent conn: expect %x, got %x",
+                 this->get_name().c_str(), this->parent_->get_conn_id(), param->notify.conn_id);
        // FIXME: bug in BLEClient holding wrong conn_id.
      }

      if (param->notify.handle != this->char_handle_status_) {
-        ESP_LOGW(TAG, "[%s] Unexpected notify handle, wanted %04X, got %04X", this->get_name(),
+        ESP_LOGW(TAG, "[%s] Unexpected notify handle, wanted %04X, got %04X", this->get_name().c_str(),
                 this->char_handle_status_, param->notify.handle);
        break;
      }
@@ -375,13 +372,13 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
      if (!this->force_refresh_ && this->codec_->compare(param->notify.value, param->notify.value_len)) {
        // If the packet is meaningfully different, trigger children as well
        this->force_refresh_ = true;
-        ESP_LOGV(TAG, "[%s] Incoming packet indicates a significant change.", this->get_name());
+        ESP_LOGV(TAG, "[%s] Incoming packet indicates a significant change.", this->get_name().c_str());
      }

      if (this->last_notify_ == 0 || delta > MIN_NOTIFY_THROTTLE || this->force_refresh_) {
        // Set reentrant flag to prevent processing multiple packets.
        this->processing_ = true;
-        ESP_LOGVV(TAG, "[%s] Decoding packet: last=%" PRId32 ", delta=%" PRId32 ", force=%s", this->get_name(),
+        ESP_LOGVV(TAG, "[%s] Decoding packet: last=%" PRId32 ", delta=%" PRId32 ", force=%s", this->get_name().c_str(),
                  this->last_notify_, delta, this->force_refresh_ ? "y" : "n");
        bool needs_extra = this->codec_->decode_notify(param->notify.value, param->notify.value_len);

@@ -391,7 +388,7 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
          auto status = esp_ble_gattc_read_char(this->parent_->get_gattc_if(), this->parent_->get_conn_id(),
                                                this->char_handle_status_, ESP_GATT_AUTH_REQ_NONE);
          if (status) {
-            ESP_LOGI(TAG, "[%s] Unable to read extended status packet", this->get_name());
+            ESP_LOGI(TAG, "[%s] Unable to read extended status packet", this->get_name().c_str());
          }
        } else {
          this->status_packet_ready_();
@@ -400,7 +397,7 @@ void BedJetHub::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t ga
      break;
    }
    default:
-      ESP_LOGVV(TAG, "[%s] gattc unhandled event: enum=%d", this->get_name(), event);
+      ESP_LOGVV(TAG, "[%s] gattc unhandled event: enum=%d", this->get_name().c_str(), event);
      break;
  }
 }
@@ -439,7 +436,7 @@ uint8_t BedJetHub::write_notify_config_descriptor_(bool enable) {
    ESP_LOGW(TAG, "esp_ble_gattc_write_char_descr error, status=%d", status);
    return status;
  }
-  ESP_LOGD(TAG, "[%s] wrote notify=%s to status config 0x%04x, for conn %d", this->get_name(),
+  ESP_LOGD(TAG, "[%s] wrote notify=%s to status config 0x%04x, for conn %d", this->get_name().c_str(),
           enable ? "true" : "false", handle, this->parent_->get_conn_id());
  return ESP_GATT_OK;
 }
@@ -471,7 +468,7 @@ void BedJetHub::setup_time_() {

 void BedJetHub::set_clock(uint8_t hour, uint8_t minute) {
  if (!this->is_connected()) {
-    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name());
+    ESP_LOGV(TAG, "[%s] Not connected, cannot send time.", this->get_name().c_str());
    return;
  }

@@ -480,7 +477,7 @@ void BedJetHub::set_clock(uint8_t hour, uint8_t minute) {
  if (status) {
    ESP_LOGW(TAG, "Failed setting BedJet clock: %d", status);
  } else {
-    ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name(), hour, minute);
+    ESP_LOGD(TAG, "[%s] BedJet clock set to: %d:%02d", this->get_name().c_str(), hour, minute);
  }
 }

@@ -498,7 +495,7 @@ void BedJetHub::dump_config() {
                "BedJet Hub '%s'\n"
                "  ble_client.app_id: %d\n"
                "  ble_client.conn_id: %d",
-                this->get_name(), this->parent()->app_id, this->parent()->get_conn_id());
+                this->get_name().c_str(), this->parent()->app_id, this->parent()->get_conn_id());
  LOG_UPDATE_INTERVAL(this);
  ESP_LOGCONFIG(TAG, "  Child components (%d):", this->children_.size());
  for (auto *child : this->children_) {
@@ -516,9 +513,10 @@ void BedJetHub::dispatch_status_() {
  auto *status = this->codec_->get_status_packet();

  if (!this->is_connected()) {
-    ESP_LOGD(TAG, "[%s] Not connected, will not send status.", this->get_name());
+    ESP_LOGD(TAG, "[%s] Not connected, will not send status.", this->get_name().c_str());
  } else if (status != nullptr) {
-    ESP_LOGD(TAG, "[%s] Notifying %d children of latest status @%p.", this->get_name(), this->children_.size(), status);
+    ESP_LOGD(TAG, "[%s] Notifying %d children of latest status @%p.", this->get_name().c_str(), this->children_.size(),
+             status);
    for (auto *child : this->children_) {
      child->on_status(status);
    }
@@ -532,13 +530,13 @@ void BedJetHub::dispatch_status_() {
      // We can try to unregister for notifications now, and then re-register, hoping to clear it up...
      // But how do we know for sure which state we're in, and how do we actually clear out the buggy state?

-      ESP_LOGI(TAG, "[%s] Still waiting for first GATT notify event.", this->get_name());
+      ESP_LOGI(TAG, "[%s] Still waiting for first GATT notify event.", this->get_name().c_str());
    } else if (diff > NOTIFY_WARN_THRESHOLD) {
-      ESP_LOGW(TAG, "[%s] Last GATT notify was %" PRId32 " seconds ago.", this->get_name(), diff / 1000);
+      ESP_LOGW(TAG, "[%s] Last GATT notify was %" PRId32 " seconds ago.", this->get_name().c_str(), diff / 1000);
    }

    if (this->timeout_ > 0 && diff > this->timeout_ && this->parent()->enabled) {
-      ESP_LOGW(TAG, "[%s] Timed out after %" PRId32 " sec. Retrying", this->get_name(), this->timeout_);
+      ESP_LOGW(TAG, "[%s] Timed out after %" PRId32 " sec. Retrying", this->get_name().c_str(), this->timeout_);
      // set_enabled(false) will only close the connection if state != IDLE.
      this->parent()->set_state(espbt::ClientState::CONNECTING);
      this->parent()->set_enabled(false);
@@ -119,7 +119,13 @@ class BedJetHub final : public esphome::ble_client::BLEClientNode, public Pollin
  float get_setup_priority() const override { return setup_priority::BLUETOOTH; }

  /** @return The BedJet's configured name, or the MAC address if not discovered yet. */
-  const char *get_name() const { return this->name_[0] == '\0' ? this->parent_->address_str() : this->name_; }
+  std::string get_name() {
+    if (this->name_.empty()) {
+      return this->parent_->address_str();
+    } else {
+      return this->name_;
+    }
+  }

  /* BLEClient overrides */

@@ -145,8 +151,9 @@ class BedJetHub final : public esphome::ble_client::BLEClientNode, public Pollin
  uint8_t set_notify_(bool enable);
  /** Send the `BedjetPacket` to the device. */
  uint8_t write_bedjet_packet_(BedjetPacket *pkt);
-  // Only used in log lines; longer names are truncated
-  char name_[24]{};
+  void set_name_(const std::string &name) { this->name_ = name; }
+
+  std::string name_;

  uint32_t last_notify_ = 0;
  inline void status_packet_ready_();
@@ -62,13 +62,6 @@ struct SpiData {

 static SpiData *spi_data = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)

-// BDK 3.0.78 makes REG_WRITE a statement expression that yields the volatile assignment,
-// a deprecated volatile read under clang
-static inline void reg_write(uint32_t addr, uint32_t value) {
-  // NOLINTNEXTLINE(performance-no-int-to-ptr) - MMIO register at a fixed address
-  *reinterpret_cast<volatile uint32_t *>(addr) = value;
-}
-
 static void set_spi_ctrl_register(uint32_t bit, bool val) {
  uint32_t value = REG_READ(SPI_CTRL);
  if (val == 0) {
@@ -76,7 +69,7 @@ static void set_spi_ctrl_register(uint32_t bit, bool val) {
  } else if (val == 1) {
    value |= bit;
  }
-  reg_write(SPI_CTRL, value);
+  REG_WRITE(SPI_CTRL, value);
 }

 #ifdef BEKEN_SPI_IS_N_LIKE
@@ -87,7 +80,7 @@ static void set_spi_config_register(uint32_t bit, bool val) {
  } else if (val == 1) {
    value |= bit;
  }
-  reg_write(SPI_CONFIG, value);
+  REG_WRITE(SPI_CONFIG, value);
 }
 #endif

@@ -143,7 +136,7 @@ static void spi_set_clock(uint32_t max_hz) {
  param = REG_READ(SPI_CTRL);
  param &= ~(SPI_CKR_MASK << SPI_CKR_POSI);
  param |= (div << SPI_CKR_POSI);
-  reg_write(SPI_CTRL, param);
+  REG_WRITE(SPI_CTRL, param);
 #ifdef BEKEN_SPI_IS_N_LIKE
  const int divisor = div;
 #else
@@ -236,7 +229,7 @@ void BekenSPILEDStripLightOutput::setup() {
  value = REG_READ(SPI_CTRL);
  value &= ~CTRL_NSSMD_3;
  value |= (1 << 17);
-  reg_write(SPI_CTRL, value);
+  REG_WRITE(SPI_CTRL, value);

 #ifdef BEKEN_SPI_IS_N_LIKE
  value = GFUNC_MODE_SPI_DMA;
@@ -286,7 +279,7 @@ void BekenSPILEDStripLightOutput::setup() {
  value = REG_READ(SPI_CONFIG);
  value &= ~(0xFFF << 8);
  value |= ((dma_buffer_size & 0xFFF) << 8);
-  reg_write(SPI_CONFIG, value);
+  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.
@@ -1,24 +1,28 @@
 import esphome.codegen as cg
 from esphome.components import output
 import esphome.config_validation as cv
+from esphome.const import CONF_ID
 from esphome.types import ConfigType

-from .. import CONF_BH1745_ID, BH1745Component
+from .. import CONF_BH1745_ID, BH1745Component, bh1745_ns

 DEPENDENCIES = ["bh1745"]

+BH1745InterruptPinOutput = bh1745_ns.class_(
+    "BH1745InterruptPinOutput", output.BinaryOutput
+)

 CONFIG_SCHEMA = output.BINARY_OUTPUT_SCHEMA.extend(
    {
-        cv.GenerateID(): cv.declare_id(output.ApplyBinaryOutput),
+        cv.GenerateID(): cv.declare_id(BH1745InterruptPinOutput),
        cv.GenerateID(CONF_BH1745_ID): cv.use_id(BH1745Component),
    }
 )


 async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await output.register_output(var, config)
    hub = await cg.get_variable(config[CONF_BH1745_ID])
-    await output.sub_binary_outputs(config, parent=hub).create(
-        config, None, apply="set_interrupt_state(state)"
-    )
+    await cg.register_parented(var, hub)
    cg.add(hub.enable_interrupt_output())
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "esphome/components/output/binary_output.h"
+#include "esphome/core/helpers.h"
+
+#include "../bh1745.h"
+
+namespace esphome::bh1745 {
+
+/// Drives the BH1745 INT pin, which switches the LEDs on breakout boards such as the Pimoroni one.
+class BH1745InterruptPinOutput : public output::BinaryOutput, public Parented<BH1745Component> {
+ protected:
+  void write_state(bool state) override { this->parent_->set_interrupt_state(state); }
+};
+
+}  // namespace esphome::bh1745
@@ -63,7 +63,6 @@ from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority, entity
 from esphome.core.entity_helpers import (
    SubEntities,
    entity_duplicate_validator,
-    lazy_load_setup,
    lazy_load_validator,
    mqtt_component_class,
    queue_entity_register,
@@ -622,7 +621,10 @@ async def setup_binary_sensor_core_(var, config):

    await entity_helpers.setup_entity_integrations(var, config)

-    await lazy_load_setup("zigbee", "setup_binary_sensor", var, config)
+    if "zigbee" in CORE.loaded_integrations:
+        from esphome.components import zigbee
+
+        await zigbee.setup_binary_sensor(var, config)


 async def register_binary_sensor(var, config):
@@ -29,7 +29,6 @@ from esphome.components.libretiny.const import (
 )
 from esphome.core import CORE
 from esphome.cpp_generator import MockObj
-from esphome.stacktrace import process_crash_handler_line as process_stacktrace  # noqa: F401
 from esphome.types import ConfigType

 from .boards import BK72XX_BOARD_PINS, BK72XX_BOARDS
@@ -21,10 +21,9 @@ public ble_api.h.
 """

 import logging
-import re

 import esphome.codegen as cg
-from esphome.components import libretiny
+from esphome.components import libretiny, wifi
 from esphome.components.libretiny.const import (
    FAMILY_BK7231N,
    FAMILY_BK7231Q,
@@ -33,30 +32,14 @@ from esphome.components.libretiny.const import (
    FAMILY_BK7251,
 )
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ENABLE_ON_BOOT,
-    CONF_ESPHOME,
-    CONF_ID,
-    CONF_PLATFORMIO_OPTIONS,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
-)
-from esphome.core import CORE, EsphomeError
-import esphome.final_validate as fv
+from esphome.const import CONF_ENABLE_ON_BOOT, CONF_ID
+from esphome.core import EsphomeError
 from esphome.types import ConfigType

 DEPENDENCIES = ["bk72xx"]
 CODEOWNERS = ["@Bl00d-B0b"]
 DOMAIN = "bk72xx_ble"

-BEKEN_BDK_VERSION_OPTION = "custom_versions.beken-bdk"
-# Older BDKs lay the BLE stack out differently and can crash at boot or erase the
-# bootloader with BLE compiled in; the libretiny platform builds with this one
-MIN_BDK_VERSION = (3, 0, 78)
-# Older LibreTiny releases arm the Beken MCU sleep with wifi power save, which halts
-# the device once the station stops while BLE runs (libretiny-eu/libretiny#414)
-MIN_LIBRETINY_VERSION = (1, 14, 0)
-
 _LOGGER = logging.getLogger(__name__)

 bk72xx_ble_ns = cg.esphome_ns.namespace("bk72xx_ble")
@@ -97,45 +80,20 @@ def _unsupported_family_message(family: str) -> str | None:
    return None


-def check_bdk_version(value: str | None) -> None:
-    """Reject a beken-bdk override older than the release the BLE stack needs."""
-    if value is None:
-        return
-    # LibreTiny appends the value to the package URL as a git ref and only builds
-    # 3.0.x releases; the 2021.06.07 tag is the pre 3.0 SDK
-    match = re.fullmatch(r"v?(\d+)\.(\d+)\.(\d+)", str(value))
-    if match is not None:
-        version = tuple(int(g) for g in match.groups())
-        if version[:2] == MIN_BDK_VERSION[:2] and version >= MIN_BDK_VERSION:
-            return
-    minimum = ".".join(str(part) for part in MIN_BDK_VERSION)
-    raise cv.Invalid(
-        f"bk72xx_ble needs beken-bdk {minimum} or a newer 3.0.x release, not "
-        f"'{value}': with BLE compiled in, an older BDK can crash at boot or erase "
-        "the bootloader"
-    )
-
-
-def check_libretiny_version(version: cv.Version) -> None:
-    """Reject a LibreTiny release older than the one whose WiFi sleep is safe with BLE."""
-    if (version.major, version.minor, version.patch) >= MIN_LIBRETINY_VERSION:
-        return
-    minimum = ".".join(str(part) for part in MIN_LIBRETINY_VERSION)
-    raise cv.Invalid(
-        f"bk72xx_ble needs LibreTiny {minimum} or newer, not {version}: older releases "
-        "arm the Beken MCU sleep with wifi power save and the device halts once the "
-        "station stops while BLE runs"
-    )
-
-
 def _final_validate(config: ConfigType) -> None:
    # Warn only: a hard error here would break the validate-only CI fixtures,
    # which run on a BLE 4.2 board. The hard error is raised at codegen.
    if msg := _unsupported_family_message(libretiny.get_libretiny_family()):
        _LOGGER.warning("%s (this configuration cannot compile)", msg)
-    options = fv.full_config.get()[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS) or {}
-    check_bdk_version(options.get(BEKEN_BDK_VERSION_OPTION))
-    check_libretiny_version(CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION])
+    # Any wifi power_save_mode other than NONE also arms the Beken SDK's MCU
+    # sleep. With the BLE controller running, that sleep never wakes up once the
+    # station is stopped (adapter restart after failed roams, wifi.disable): the
+    # device is dead until a power cycle (esphome#18592). Keep power save off
+    # until LibreTiny ships the SDK-side fix (libretiny-eu/libretiny#414).
+    wifi.force_power_save_off(
+        "with BLE running, the Beken SDK's MCU sleep halts the device once the "
+        "station is stopped (https://github.com/esphome/esphome/issues/18592)"
+    )


 FINAL_VALIDATE_SCHEMA = _final_validate
@@ -158,6 +116,20 @@ async def to_code(config: ConfigType) -> None:
    # so this =1 is the single CFG_SUPPORT_BLE define emitted.
    cg.add_platformio_option("custom_options.sys_config#h", ["CFG_SUPPORT_BLE=1"])

+    # Pin the Beken BDK release the BLE 5.x stack is validated against. The
+    # bundled 3.0.33 has an older BLE header/library layout — and with
+    # CFG_SUPPORT_BLE=1 the SDK runs its BLE init unconditionally during boot
+    # (the reason the libretiny platform sets =0 when BLE is unused), so a
+    # mismatched BDK can crash the device before WiFi comes up regardless of
+    # enable_on_boot. Pinning here makes a plain config build against the
+    # validated BDK without any manual platformio_options.
+    _LOGGER.warning(
+        "bk72xx_ble builds with beken-bdk 3.0.78 instead of the platform's bundled "
+        "default: the default's older BLE layout can crash the device at boot when "
+        "BLE is compiled in"
+    )
+    cg.add_platformio_option("custom_versions.beken-bdk", "3.0.78")
+
    # The BDK exposes the controller's BLE address as `common_default_bdaddr` on
    # BK7231N, but NOT on BK7238 (its BLE stack has no such symbol; the address is
    # derived from the WiFi MAC instead — the BDK's own fallback). Tell the C++
@@ -1,5 +1,4 @@
 #include "bl0939.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include <cinttypes>

@@ -21,7 +20,7 @@ static const uint8_t BL0939_REG_SOFT_RESET = 0x19;
 static const uint8_t BL0939_REG_USR_WRPROT = 0x1A;
 static const uint8_t BL0939_REG_TPS_CTRL = 0x1B;

-static constexpr uint8_t BL0939_INIT[6][6] PROGMEM = {
+const uint8_t BL0939_INIT[6][6] = {
    // Reset to default
    {BL0939_WRITE_COMMAND, BL0939_REG_SOFT_RESET, 0x5A, 0x5A, 0x5A, 0x33},
    // Enable User Operation Write
@@ -67,10 +66,8 @@ void BL0939::update() {
 }

 void BL0939::setup() {
-  uint8_t cmd[sizeof(BL0939_INIT[0])];
-  for (const auto *i : BL0939_INIT) {
-    progmem_memcpy(cmd, i, sizeof(cmd));
-    this->write_array(cmd, sizeof(cmd));
+  for (auto *i : BL0939_INIT) {
+    this->write_array(i, 6);
    delay(1);
  }
  this->flush();
@@ -1,23 +1,11 @@
-from collections.abc import Callable, Coroutine
-import functools
+from collections.abc import Coroutine
 from typing import Any

 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import ble_device_base, bluetooth_connection
-from esphome.components.ble_device_base import (
-    BT_UUID16_FORMAT as bt_uuid16_format,
-    BT_UUID32_FORMAT as bt_uuid32_format,
-    BT_UUID128_FORMAT as bt_uuid128_format,
-    as_hex,
-    as_reversed_hex_array,
-    bt_uuid,
-)
-from esphome.config_helpers import (
-    filter_source_files_from_platform,
-    frameworks_for_platforms,
-)
+from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
+from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_CHARACTERISTIC_UUID,
@@ -30,55 +18,15 @@ from esphome.const import (
    CONF_SERVICE_UUID,
    CONF_TRIGGER_ID,
    CONF_VALUE,
-    PLATFORM_ESP32,
-    PlatformFramework,
 )
-from esphome.core import CORE, ID
-from esphome.enum import StrEnum
-from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
+from esphome.core import ID
 from esphome.types import ConfigType

-# The esp32 BLE stack (esp32_ble, esp32_ble_tracker) is imported lazily inside
-# the esp32 schema/codegen arms: importing those modules registers esp32-only
-# automations as a side effect, which must not leak into the neutral
-# platforms' registries (the bluetooth_proxy pattern).
-
-
-def _legacy_engine() -> bool:
-    """True when the build uses the legacy raw-gattc engine - one line to
-    flip when esp32 moves to the neutral engine (with
-    USE_BLE_CLIENT_LEGACY_ENGINE in _to_code_esp32)."""
-    return CORE.is_esp32
-
-
-def AUTO_LOAD() -> list[str]:
-    """The engine's closure per platform: the legacy esp32 engine builds on
-    esp32_ble_client plus bluetooth_connection (the shared service-table
-    materializer; its sources compile empty in builds without a neutral
-    node), the neutral engine on the bluetooth_connection backend. The
-    platform-less arm is the union for manifest-resolving tooling."""
-    if _legacy_engine() or CORE.target_platform is None:
-        return ["bluetooth_connection", "esp32_ble_client"]
-    return ["bluetooth_connection"]
-
-
+AUTO_LOAD = ["esp32_ble_client"]
 CODEOWNERS = ["@buxtronix", "@clydebarrow"]
+DEPENDENCIES = ["esp32_ble_tracker"]
 DOMAIN = "ble_client"

-FILTER_SOURCE_FILES = filter_source_files_from_platform(
-    {
-        "ble_client.cpp": {
-            PlatformFramework.ESP32_ARDUINO,
-            PlatformFramework.ESP32_IDF,
-        },
-        # Every framework of every non-esp32 registry platform: a platform
-        # that validates the neutral arm must also compile the neutral engine.
-        "ble_client_gatt.cpp": frameworks_for_platforms(
-            set(bluetooth_connection.GATT_CLIENT_PLATFORMS) - {PLATFORM_ESP32}
-        ),
-    }
-)
-
 CONF_DESCRIPTOR_UUID = "descriptor_uuid"
 CONF_ON_NOTIFY = "on_notify"

@@ -114,12 +62,16 @@ def notify_from_on_notify(config: ConfigType) -> ConfigType:


 ble_client_ns = cg.esphome_ns.namespace("ble_client")
-# One codegen class for both engines: the exclusively-gated headers resolve
-# the name to exactly one C++ definition per build.
-BLEClient = ble_client_ns.class_("BLEClient", cg.Component)
+BLEClient = ble_client_ns.class_("BLEClient", esp32_ble_client.BLEClientBase)
 BLEClientNode = ble_client_ns.class_("BLEClientNode")
 BLEClientNodeConstRef = BLEClientNode.operator("ref").operator("const")
 # Triggers
+BLEClientConnectTrigger = ble_client_ns.class_(
+    "BLEClientConnectTrigger", automation.Trigger.template(BLEClientNodeConstRef)
+)
+BLEClientDisconnectTrigger = ble_client_ns.class_(
+    "BLEClientDisconnectTrigger", automation.Trigger.template(BLEClientNodeConstRef)
+)
 BLEClientPasskeyRequestTrigger = ble_client_ns.class_(
    "BLEClientPasskeyRequestTrigger", automation.Trigger.template(BLEClientNodeConstRef)
 )
@@ -157,175 +109,62 @@ CONF_AUTO_CONNECT = "auto_connect"

 MULTI_CONF = True

-# Keys shared by both engines' schemas.
-_COMMON_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(BLEClient),
-        cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
-        cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
-        cv.Optional(CONF_ON_CONNECT): automation.validate_automation({}),
-        cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation({}),
-    }
-).extend(cv.COMPONENT_SCHEMA)
-
-# Both engines register these on the client; the Bluedroid-security triggers below stay trigger classes
-_CALLBACK_AUTOMATIONS = (
-    automation.CallbackAutomation(CONF_ON_CONNECT, "add_on_connect_callback"),
-    automation.CallbackAutomation(CONF_ON_DISCONNECT, "add_on_disconnect_callback"),
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(BLEClient),
+            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+            cv.Optional(CONF_NAME): cv.string,
+            cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
+            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientConnectTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientDisconnectTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientPasskeyRequestTrigger
+                    ),
+                }
+            ),
+            cv.Optional(CONF_ON_PASSKEY_NOTIFICATION): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientPasskeyNotificationTrigger
+                    ),
+                }
+            ),
+            cv.Optional(
+                CONF_ON_NUMERIC_COMPARISON_REQUEST
+            ): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        BLEClientNumericComparisonRequestTrigger
+                    ),
+                }
+            ),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
+    esp32_ble.consume_connection_slots(1, "ble_client"),
 )

-
-@functools.cache
-def _esp32_config_schema() -> cv.All:
-    """The legacy engine's schema, byte-compatible with what esp32 always had
-    (including the Bluedroid security triggers)."""
-    from esphome.components import esp32_ble_tracker
-
-    return cv.All(
-        _COMMON_SCHEMA.extend(
-            {
-                # Accepted-but-unused legacy key; not propagated to the
-                # neutral schema.
-                cv.Optional(CONF_NAME): cv.string,
-                cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                            BLEClientPasskeyRequestTrigger
-                        ),
-                    }
-                ),
-                cv.Optional(
-                    CONF_ON_PASSKEY_NOTIFICATION
-                ): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                            BLEClientPasskeyNotificationTrigger
-                        ),
-                    }
-                ),
-                cv.Optional(
-                    CONF_ON_NUMERIC_COMPARISON_REQUEST
-                ): automation.validate_automation(
-                    {
-                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                            BLEClientNumericComparisonRequestTrigger
-                        ),
-                    }
-                ),
-            }
-        ).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
-        bluetooth_connection.consume_gatt_slot("ble_client"),
-    )
-
-
-@functools.cache
-def _gatt_config_schema(platform: str) -> cv.All:
-    """The neutral engine's schema: the shared keys plus the hub reference
-    (parsed-advertisement sightings) and the GATT backend declaration.
-    Keyed by platform - the backend fragment differs per platform."""
-    return cv.All(
-        _COMMON_SCHEMA.extend(ble_device_base.BLE_DEVICE_SCHEMA).extend(
-            bluetooth_connection.gatt_client_schema(platform)
-        ),
-        bluetooth_connection.consume_gatt_slot("ble_client"),
-    )
-
-
-@schema_extractor("schema")
-def _validate_platform(config: ConfigType) -> ConfigType:
-    if config is SCHEMA_EXTRACT:
-        # Deliberate gap (the bluetooth_proxy pattern): the dumper gets only
-        # this shape, so the neutral arm's ble_hub_id is absent from editor
-        # schemas and the esp32-only keys are advertised on every platform.
-        # The language-schema dumper runs without a platform; expose the
-        # esp32 (legacy-engine) shape.
-        return _esp32_config_schema()
-    if _legacy_engine():
-        return _esp32_config_schema()(config)
-    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
-        return _gatt_config_schema(CORE.target_platform)(config)
-    raise cv.Invalid(f"ble_client is not supported on {CORE.target_platform}")
-
-
-CONFIG_SCHEMA = _validate_platform
-
 CONF_BLE_CLIENT_ID = "ble_client_id"

-
-class BLEClientFeatures(StrEnum):
-    """Per-platform engine capabilities consumers declare against."""
-
-    # The platform-neutral node interface (on_connected/table + completion
-    # callbacks) - every platform with a ble_client engine.
-    GATT_NODE = "gatt_node"
-    # The raw esp32 GATT client event stream (gattc/gap handlers,
-    # node_state) - the legacy engine only.
-    RAW_GATTC = "raw_gattc"
-    # Pairing dialog replies and bond management (Bluedroid GAP/SMP).
-    SECURITY = "security"
-
-
-def _engine_features() -> set[BLEClientFeatures]:
-    """Features the validated platform's engine provides."""
-    if _legacy_engine():
-        return {
-            BLEClientFeatures.GATT_NODE,
-            BLEClientFeatures.RAW_GATTC,
-            BLEClientFeatures.SECURITY,
-        }
-    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
-        return {BLEClientFeatures.GATT_NODE}
-    return set()
-
-
-def requires_feature(
-    feature: BLEClientFeatures, description: str
-) -> Callable[[Any], Any]:
-    """Validator gating a consumer to platforms whose engine provides
-    `feature`, naming the missing capability in the error."""
-
-    def validator(value: Any) -> Any:
-        features = _engine_features()
-        if feature not in features:
-            available = (
-                f"; this platform's engine provides: {', '.join(sorted(features))}"
-                if features
-                else ""
-            )
-            raise cv.Invalid(
-                f"{description} requires the ble_client '{feature}' feature, "
-                f"which {CORE.target_platform} does not provide{available}"
-            )
-        return value
-
-    return validator
-
-
-# The one choke point for every node component still on the raw esp32 event
-# stream; migrating to the neutral interface (NODE_BLE_CLIENT_SCHEMA +
-# register_gatt_node) lifts it.
-_legacy_engine_only = requires_feature(
-    BLEClientFeatures.RAW_GATTC,
-    "This component drives the raw ESP32 GATT client events and has not "
-    "been migrated to the platform-neutral node interface yet; it",
-)
-
 BLE_CLIENT_SCHEMA = cv.Schema(
    {
-        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
-            cv.use_id(BLEClient), _legacy_engine_only
-        ),
-    }
-)
-
-# For node components on the neutral interface: valid wherever ble_client
-# itself is.
-NODE_BLE_CLIENT_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
-            cv.use_id(BLEClient),
-            requires_feature(BLEClientFeatures.GATT_NODE, "This component"),
-        ),
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
    }
 )

@@ -335,26 +174,6 @@ async def register_ble_node(var, config):
    cg.add(parent.register_ble_node(var))


-def _request_gatt_node_build() -> None:
-    """Node storage and the one define meaning "the neutral node surface is
-    compiled in", plus the esp32 bridge/materializer defines."""
-    _request_node_slot()
-    cg.add_define("USE_BLE_CLIENT_GATT_NODES")
-    if _legacy_engine():
-        # Deliberately not ble_device_base.request_gatt_client(): that would
-        # claim a phantom backend slot on combined proxy builds.
-        cg.add_define("USE_BLE_GATT_CLIENT")
-        cg.add_define("USE_BLE_GATT_BACKEND_BLUEDROID")
-        cg.add_define("USE_BLUEDROID_GATT_SERVICE_TABLE")
-
-
-async def register_gatt_node(var, config):
-    """Register a node on the platform-neutral interface (both engines)."""
-    parent = await cg.get_variable(config[CONF_BLE_CLIENT_ID])
-    _request_gatt_node_build()
-    cg.add(parent.register_gatt_node(var))
-
-
 def new_ble_node_component(
    config: ConfigType, *args: Any
 ) -> Coroutine[Any, Any, cg.MockObj]:
@@ -365,8 +184,8 @@ def new_ble_node_component(
 BLE_WRITE_ACTION_SCHEMA = cv.Schema(
    {
        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_SERVICE_UUID): bt_uuid,
-        cv.Required(CONF_CHARACTERISTIC_UUID): bt_uuid,
+        cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
+        cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
        cv.Required(CONF_VALUE): cv.templatable(cv.ensure_list(cv.hex_uint8_t)),
    }
 )
@@ -377,34 +196,25 @@ BLE_CONNECT_ACTION_SCHEMA = maybe_simple_id(
    }
 )

-BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.All(
-    requires_feature(BLEClientFeatures.SECURITY, "This action"),
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-            cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
-        }
-    ),
+BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+        cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
+    }
 )

-BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.All(
-    requires_feature(BLEClientFeatures.SECURITY, "This action"),
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-            cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
-        }
-    ),
+BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+        cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
+    }
 )


-BLE_REMOVE_BOND_ACTION_SCHEMA = cv.All(
-    requires_feature(BLEClientFeatures.SECURITY, "This action"),
-    cv.Schema(
-        {
-            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        }
-    ),
+BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+    }
 )


@@ -432,8 +242,6 @@ automation.register_simple_action(
 )
 async def ble_write_to_code(config, action_id, template_arg, args):
    parent = await cg.get_variable(config[CONF_ID])
-    # The action registers itself as a neutral node in its constructor.
-    _request_gatt_node_build()
    var = cg.new_Pvariable(action_id, template_arg, parent)

    value = config[CONF_VALUE]
@@ -448,20 +256,38 @@ async def ble_write_to_code(config, action_id, template_arg, args):
        arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*value))
        cg.add(var.set_value_simple(arr, len(value)))

-    if len(config[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
-        cg.add(var.set_service_uuid16(as_hex(config[CONF_SERVICE_UUID])))
-    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid32_format):
-        cg.add(var.set_service_uuid32(as_hex(config[CONF_SERVICE_UUID])))
-    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid128_format):
-        uuid128 = as_reversed_hex_array(config[CONF_SERVICE_UUID])
+    if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
+        cg.add(
+            var.set_service_uuid32(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
+        )
+    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
+        uuid128 = esp32_ble_tracker.as_reversed_hex_array(config[CONF_SERVICE_UUID])
        cg.add(var.set_service_uuid128(uuid128))

-    if len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid16_format):
-        cg.add(var.set_char_uuid16(as_hex(config[CONF_CHARACTERISTIC_UUID])))
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid32_format):
-        cg.add(var.set_char_uuid32(as_hex(config[CONF_CHARACTERISTIC_UUID])))
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid128_format):
-        uuid128 = as_reversed_hex_array(config[CONF_CHARACTERISTIC_UUID])
+    if len(config[CONF_CHARACTERISTIC_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
+        cg.add(
+            var.set_char_uuid16(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid32_format
+    ):
+        cg.add(
+            var.set_char_uuid32(
+                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
+            )
+        )
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
+        esp32_ble_tracker.bt_uuid128_format
+    ):
+        uuid128 = esp32_ble_tracker.as_reversed_hex_array(
+            config[CONF_CHARACTERISTIC_UUID]
+        )
        cg.add(var.set_char_uuid128(uuid128))

    return var
@@ -515,48 +341,22 @@ automation.register_simple_action(
 )


-async def _to_code_esp32(config: ConfigType) -> cg.MockObj:
-    from esphome.components import esp32_ble, esp32_ble_tracker
-    from esphome.components.esp32_ble import BTLoggers
-
+async def to_code(config):
    # Register the loggers this component needs
    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
    cg.add_define("USE_ESP32_BLE_UUID")
-    cg.add_define("USE_BLE_CLIENT_LEGACY_ENGINE")

    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await esp32_ble_tracker.register_client(var, config)
-    return var
-
-
-# Sizes the neutral client's node storage; the client itself requests a
-# baseline slot so the define exists on every build that compiles the engine.
-_request_node_slot = cg.slot_counter("ESPHOME_BLE_CLIENT_MAX_NODES")
-
-
-async def _to_code_gatt(config: ConfigType) -> cg.MockObj:
-    # The engine always carries the node surface (the client itself owns the
-    # baseline slot).
-    _request_gatt_node_build()
-    backend = await bluetooth_connection.new_gatt_backend(config)
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    cg.add(var.set_backend(backend))
-    # Sighting-gated connects: the client listens for the peer's parsed
-    # advertisements through the hub.
-    await ble_device_base.register_ble_device(var, config)
-    return var
-
-
-async def to_code(config: ConfigType) -> None:
-    if _legacy_engine():
-        var = await _to_code_esp32(config)
-    else:
-        var = await _to_code_gatt(config)
    cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
    cg.add(var.set_auto_connect(config[CONF_AUTO_CONNECT]))
-    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
+    for conf in config.get(CONF_ON_CONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
+    for conf in config.get(CONF_ON_DISCONNECT, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [], conf)
    for conf in config.get(CONF_ON_PASSKEY_REQUEST, []):
        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
        await automation.build_automation(trigger, [], conf)
@@ -0,0 +1,11 @@
+#ifdef USE_ESP32
+
+#include "automation.h"
+
+namespace esphome::ble_client {
+
+const char *const Automation::TAG = "ble_client.automation";  // NOLINT: ble_client never builds for ESP8266
+
+}  // namespace esphome::ble_client
+
+#endif
@@ -1,14 +1,27 @@
 #pragma once

-#include "esphome/core/defines.h"
+#ifdef USE_ESP32

-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+#include <utility>
+#include <vector>

 #include "esphome/core/automation.h"
 #include "esphome/components/ble_client/ble_client.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
+static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;

 namespace esphome::ble_client {

+// placeholder class for static TAG .
+class Automation {
+ public:
+  // could be made inline with C++17
+  static const char *const TAG;
+};
+
 // Base for nodes that never read the parent's services.
 // The parent releases its services only once every node reports Established, so a node that never
 // reports it keeps that memory allocated for the life of the connection.
@@ -26,6 +39,45 @@ class BLEClientServicelessNode : public BLEClientNode {
  virtual void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {}
 };

+// implement on_connect automation.
+class BLEClientConnectTrigger final : public Trigger<>, public BLEClientNode {
+ public:
+  explicit BLEClientConnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
+  void loop() override {}
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
+    if (event == ESP_GATTC_SEARCH_CMPL_EVT) {
+      this->node_state = espbt::ClientState::ESTABLISHED;
+      this->trigger();
+    }
+  }
+};
+
+// on_disconnect automation
+class BLEClientDisconnectTrigger final : public Trigger<>, public BLEClientNode {
+ public:
+  explicit BLEClientDisconnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
+  void loop() override {}
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
+    // test for CLOSE and not DISCONNECT - DISCONNECT can occur even if no virtual connection (OPEN event) occurred.
+    // So this will not trigger unless a complete open has previously succeeded.
+    switch (event) {
+      case ESP_GATTC_SEARCH_CMPL_EVT: {
+        this->node_state = espbt::ClientState::ESTABLISHED;
+        break;
+      }
+      case ESP_GATTC_CLOSE_EVT: {
+        this->trigger();
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+  }
+};
+
 class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientServicelessNode {
 public:
  explicit BLEClientPasskeyRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
@@ -58,6 +110,144 @@ class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>,
  }
 };

+// implement the ble_client.ble_write action.
+template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
+ public:
+  BLEClientWriteAction(BLEClient *ble_client) {
+    ble_client->register_ble_node(this);
+    ble_client_ = ble_client;
+  }
+
+  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+
+  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
+  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
+  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
+
+  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
+    this->value_.func = func;
+    this->len_ = -1;  // Sentinel value indicates template mode
+  }
+
+  // Store pointer to static data in flash (no RAM copy)
+  void set_value_simple(const uint8_t *data, size_t len) {
+    this->value_.data = data;
+    this->len_ = len;  // Length >= 0 indicates static mode
+  }
+
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    this->num_running_++;
+    this->var_ = std::make_tuple(x...);
+
+    bool result;
+    if (this->len_ >= 0) {
+      // Static mode: write directly from flash pointer
+      result = this->write(this->value_.data, this->len_);
+    } else {
+      // Template mode: call function and write the vector
+      std::vector<uint8_t> value = this->value_.func(x...);
+      result = this->write(value);
+    }
+
+    // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
+    if (!result)
+      this->play_next_(x...);
+  }
+
+  /**
+   * Note about logging: the esph_log_X macros are used here because the CI checks complain about use of the ESP LOG
+   * macros in header files (Can't even write it in a comment!)
+   * Not sure why, because they seem to work just fine.
+   * The problem is that the implementation of a templated class can't be placed in a .cpp file when using C++ less than
+   * 17, so the methods have to be here.  The esph_log_X macros are equivalent in function, but don't trigger the CI
+   * errors.
+   */
+  // initiate the write. Return true if all went well, will be followed by a WRITE_CHAR event.
+  bool write(const uint8_t *data, size_t len) {
+    if (this->node_state != espbt::ClientState::ESTABLISHED) {
+      esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
+      return false;
+    }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
+    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
+#endif
+    esp_err_t err =
+        esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
+                                 const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
+    if (err != ESP_OK) {
+      esph_log_e(Automation::TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
+      return false;
+    }
+    return true;
+  }
+
+  bool write(const std::vector<uint8_t> &value) { return this->write(value.data(), value.size()); }
+
+  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                           esp_ble_gattc_cb_param_t *param) override {
+    switch (event) {
+      case ESP_GATTC_WRITE_CHAR_EVT:
+        // upstream code checked the MAC address, verify the characteristic.
+        if (param->write.handle == this->char_handle_)
+          this->parent()->run_later([this]() { this->play_next_tuple_(this->var_); });
+        break;
+      case ESP_GATTC_DISCONNECT_EVT:
+        if (this->num_running_ != 0)
+          this->stop_complex();
+        break;
+      case ESP_GATTC_SEARCH_CMPL_EVT: {
+        auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
+        if (chr == nullptr) {
+          char char_buf[esp32_ble::UUID_STR_LEN];
+          char service_buf[esp32_ble::UUID_STR_LEN];
+          esph_log_w("ble_write_action", "Characteristic %s was not found in service %s",
+                     this->char_uuid_.to_str(char_buf), this->service_uuid_.to_str(service_buf));
+          break;
+        }
+        this->char_handle_ = chr->handle;
+        this->char_props_ = chr->properties;
+        if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE) {
+          this->write_type_ = ESP_GATT_WRITE_TYPE_RSP;
+          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_RSP");
+        } else if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE_NR) {
+          this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
+          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
+        } else {
+          char char_buf[esp32_ble::UUID_STR_LEN];
+          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+          break;
+        }
+        this->node_state = espbt::ClientState::ESTABLISHED;
+        char char_buf[esp32_ble::UUID_STR_LEN];
+        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+                   ble_client_->address_str());
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+ private:
+  BLEClient *ble_client_;
+  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
+  union Value {
+    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
+    const uint8_t *data;                  // Pointer to static data in flash
+  } value_;
+  espbt::ESPBTUUID service_uuid_;
+  espbt::ESPBTUUID char_uuid_;
+  std::tuple<Ts...> var_{};
+  uint16_t char_handle_{};
+  esp_gatt_char_prop_t char_props_{};
+  esp_gatt_write_type_t write_type_{};
+};
+
 template<typename... Ts> class BLEClientPasskeyReplyAction final : public Action<Ts...> {
 public:
  BLEClientPasskeyReplyAction(BLEClient *ble_client) { parent_ = ble_client; }
@@ -1,103 +0,0 @@
-// Neutral twins of the shared ble_client automations. Class names, namespace,
-// and codegen-visible signatures are IDENTICAL to automation.h so generated
-// main.cpp compiles against whichever engine the build gates in; only the
-// internals differ (client callbacks and the neutral node interface instead
-// of raw gattc events). The Bluedroid-security automations (passkey, numeric
-// comparison, remove bond) have no neutral equivalent and stay esp32-only.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if defined(USE_BLE_CLIENT_GATT_NODES) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
-
-#include <tuple>
-
-#include "ble_client_gatt.h"
-#include "esphome/core/automation.h"
-
-namespace esphome::ble_client {
-
-template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...> {
- public:
-  BLEClientConnectAction(BLEClient *ble_client) {
-    ble_client_ = ble_client;
-    ble_client->add_on_connect_callback([this]() {
-      if (this->num_running_ != 0)
-        this->play_next_tuple_(this->var_);
-    });
-    // A connect attempt that dies (or a later disconnect) terminates the
-    // chain - unless a fresh attempt is already in flight, meaning a user
-    // trigger on this same list started this action (an on_disconnect that
-    // reconnects) and the wait belongs to that attempt. Legacy split these:
-    // it aborted on DISCONNECT_EVT, the trigger fired on the later CLOSE_EVT.
-    auto terminate = [this]() {
-      if (this->num_running_ != 0 && this->ble_client_->idle())
-        this->stop_complex();
-    };
-    ble_client->add_on_connect_failed_callback(terminate);
-    ble_client->add_on_disconnect_callback(terminate);
-  }
-
-  // not used since we override play_complex_
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    // it makes no sense to have multiple instances of this running at the
-    // same time; cancel a re-trigger while still running.
-    if (this->num_running_ != 0) {
-      this->stop_complex();
-      return;
-    }
-    this->num_running_++;
-    if (this->ble_client_->connected()) {
-      this->play_next_(x...);
-    } else {
-      this->var_ = std::make_tuple(x...);
-      // No-op while already connecting; the callback resolves the wait.
-      this->ble_client_->connect();
-    }
-  }
-
- private:
-  BLEClient *ble_client_;
-  std::tuple<Ts...> var_{};
-};
-
-template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...> {
- public:
-  BLEClientDisconnectAction(BLEClient *ble_client) {
-    ble_client_ = ble_client;
-    // Both terminal outcomes resolve the wait: a completed teardown and a
-    // connect attempt that died on the way down.
-    ble_client->add_on_disconnect_callback([this]() {
-      if (this->num_running_ != 0)
-        this->play_next_tuple_(this->var_);
-    });
-    ble_client->add_on_connect_failed_callback([this]() {
-      if (this->num_running_ != 0)
-        this->play_next_tuple_(this->var_);
-    });
-  }
-
-  // not used since we override play_complex_
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    this->num_running_++;
-    if (this->ble_client_->idle()) {
-      this->play_next_(x...);
-    } else {
-      this->var_ = std::make_tuple(x...);
-      this->ble_client_->disconnect();
-    }
-  }
-
- private:
-  BLEClient *ble_client_;
-  std::tuple<Ts...> var_{};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_CLIENT_GATT_NODES && !USE_BLE_CLIENT_LEGACY_ENGINE
@@ -2,16 +2,10 @@
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/application.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-
-#ifdef USE_BLE_CLIENT_GATT_NODES
-#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
-#include "esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h"
-#endif
+#ifdef USE_ESP32

 namespace esphome::ble_client {

@@ -36,10 +30,6 @@ void BLEClient::dump_config() {
 bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
  if (!this->enabled)
    return false;
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  if (device.address_uint64() == this->address_ && this->gatt_backoff_.holding_off())
-    return false;
-#endif
  return BLEClientBase::parse_device(device);
 }

@@ -50,65 +40,24 @@ void BLEClient::set_enabled(bool enabled) {
  if (!enabled) {
    ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str());
    this->disconnect();
-    return;
  }
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // A re-enable clears the backoff (neutral-engine parity).
-  this->gatt_backoff_.reset();
-#endif
 }

 bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Bridge-initiated registrations bypass the base's REG_FOR_NOTIFY handling:
-  // its automatic CCCD write would double the node's own.
-  // Handle-keyed: mixed legacy/neutral subscriptions to one characteristic
-  // are unsupported during the migration window.
-  if (event == ESP_GATTC_REG_FOR_NOTIFY_EVT && esp_gattc_if == this->gattc_if_ &&
-      this->take_pending_gatt_reg_(param->reg_for_notify.handle)) {
-    if (this->pending_notify_regs_ > 0)
-      this->pending_notify_regs_--;
-    int err = param->reg_for_notify.status == ESP_GATT_OK ? 0 : param->reg_for_notify.status;
-    this->notify_state_to_gatt_nodes_(param->reg_for_notify.handle, true, err);
-    // A retiring last registration must still release the cache.
-    this->maybe_release_services_();
-    return true;
-  }
-#endif
  if (!BLEClientBase::gattc_event_handler(event, esp_gattc_if, param))
    return false;

-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Before the legacy fan-out so gatt nodes resolve before any trigger fires.
-  if (!this->gatt_nodes_.empty()) {
-    if (event == ESP_GATTC_SEARCH_CMPL_EVT) {
-      // A failed discovery tears the link down; the on_connect trigger must
-      // not fire into the teardown.
-      if (!this->handle_gatt_search_cmpl_(param->search_cmpl.status))
-        return true;
-    } else {
-      this->dispatch_gatt_event_(event, param);
-    }
-  }
-#endif
  for (auto *node : this->nodes_)
    node->gattc_event_handler(event, esp_gattc_if, param);
-  // The automations run after the nodes; on_connect runs before the release so it can still use the services
-  if (event == ESP_GATTC_SEARCH_CMPL_EVT)
-    this->connect_callbacks_.call();
-  this->maybe_release_services_();
-  if (event == ESP_GATTC_CLOSE_EVT)
-    this->disconnect_callbacks_.call();
-  return true;
-}

-void BLEClient::maybe_release_services_() {
  // The release frees the GATT cache that BLEClientBase's CCCD lookup still needs.
+  // The last REG_FOR_NOTIFY event clears the counter before node dispatch, so the release still runs here.
  if (!this->services_.empty() && !this->notify_registration_pending() && this->all_nodes_established_()) {
    this->release_services();
    ESP_LOGD(TAG, "All clients established, services released");
  }
+  return true;
 }

 void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
@@ -116,19 +65,10 @@ void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_p

  for (auto *node : this->nodes_)
    node->gap_event_handler(event, param);
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  if (event == ESP_GAP_BLE_AUTH_CMPL_EVT && this->check_addr(param->ble_security.auth_cmpl.bd_addr)) {
-    int status = param->ble_security.auth_cmpl.success ? 0 : param->ble_security.auth_cmpl.fail_reason;
-    for (auto *node : this->gatt_nodes_)
-      node->on_pairing_result(status);
-  }
-#endif
 }

 void BLEClient::set_state(espbt::ClientState state) {
  BLEClientBase::set_state(state);
-  // ESTABLISHED never flows through here; gatt nodes are promoted after the
-  // on_connected fan-out.
  for (auto &node : nodes_)
    node->node_state = state;
 }
@@ -143,221 +83,6 @@ bool BLEClient::all_nodes_established_() {
  return true;
 }

-#ifdef USE_BLE_CLIENT_GATT_NODES
-
-void BLEClient::register_gatt_node(BLEClientNode *node) {
-  // Parent before the capacity check so a dropped node still has a usable
-  // parent() (neutral-engine parity).
-  node->set_ble_client_parent(this);
-  if (this->gatt_nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
-    // push_back past capacity is a silent no-op; an undersized slot count
-    // must be loud at boot, not an unresolvable node at runtime.
-    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str());
-    this->status_set_error(LOG_STR("node capacity exceeded"));
-    return;
-  }
-  this->gatt_nodes_.push_back(node);
-  // nodes_ covers the shared state bookkeeping; gatt_nodes_ is the neutral
-  // fan-out subset.
-  this->register_ble_node(node);
-}
-
-int BLEClient::find_pending_gatt_reg_(uint16_t handle) const {
-  for (uint8_t i = 0; i < this->pending_gatt_reg_count_; i++) {
-    if (this->pending_gatt_regs_[i] == handle)
-      return i;
-  }
-  return -1;
-}
-
-bool BLEClient::take_pending_gatt_reg_(uint16_t handle) {
-  int i = this->find_pending_gatt_reg_(handle);
-  if (i < 0)
-    return false;
-  // No duplicates (notify_characteristic refuses a re-push); swap-with-last.
-  this->pending_gatt_regs_[i] = this->pending_gatt_regs_[--this->pending_gatt_reg_count_];
-  return true;
-}
-
-void BLEClient::notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error) {
-  if (error != 0) {
-    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str(),
-             enabled ? "enable" : "disable", handle, error);
-  }
-  for (auto *node : this->gatt_nodes_)
-    node->on_notify_state(handle, enabled, error);
-}
-
-void BLEClient::dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param) {
-  switch (event) {
-    case ESP_GATTC_READ_CHAR_EVT:
-    case ESP_GATTC_READ_DESCR_EVT: {
-      bool ok = param->read.status == ESP_GATT_OK;
-      if (!ok) {
-        // Breadcrumb even when no node claims the handle.
-        ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str(), param->read.handle,
-                 param->read.status);
-      }
-      for (auto *node : this->gatt_nodes_) {
-        node->on_read_result(param->read.handle, ok ? param->read.value : nullptr, ok ? param->read.value_len : 0,
-                             ok ? 0 : param->read.status);
-      }
-      break;
-    }
-    case ESP_GATTC_WRITE_CHAR_EVT:
-    case ESP_GATTC_WRITE_DESCR_EVT:
-      if (param->write.status != ESP_GATT_OK) {
-        // Breadcrumb even when no node claims the handle.
-        ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str(), param->write.handle,
-                 param->write.status);
-      }
-      for (auto *node : this->gatt_nodes_) {
-        node->on_write_result(param->write.handle, param->write.status == ESP_GATT_OK ? 0 : param->write.status);
-      }
-      break;
-    case ESP_GATTC_NOTIFY_EVT:
-      for (auto *node : this->gatt_nodes_) {
-        node->on_notify(param->notify.handle, param->notify.value, param->notify.value_len);
-      }
-      break;
-    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT:
-      // The base does no CCCD work for unregister; no interception needed.
-      this->notify_state_to_gatt_nodes_(
-          param->unreg_for_notify.handle, false,
-          param->unreg_for_notify.status == ESP_GATT_OK ? 0 : param->unreg_for_notify.status);
-      break;
-    default:
-      break;
-  }
-}
-
-bool BLEClient::handle_gatt_search_cmpl_(esp_gatt_status_t status) {
-  // The base ignores the search status; the neutral contract must not.
-  uint16_t service_total = 0;
-  bool counted = status == ESP_GATT_OK && bluetooth_connection::BluedroidServiceTable::count_services(
-                                              this->gattc_if_, this->conn_id_, &service_total);
-  if (!counted || service_total == 0) {
-    // A failed search poisons the whole discovery, legacy nodes included.
-    ESP_LOGW(TAG, "[%s] Discovery failed (status=%d, services=%u)", this->address_str(), status, service_total);
-    this->gatt_backoff_.register_failure(this->address_str());
-    this->disconnect();
-    return false;
-  }
-  // Stack-owned; nodes copy their handles during on_connected().
-  bluetooth_connection::BluedroidServiceTable table;
-  if (!table.build(this->gattc_if_, this->conn_id_, service_total, this->connection_index_)) {
-    if (!this->has_legacy_nodes_()) {
-      ESP_LOGW(TAG, "[%s] Service table build failed; treating as failed discovery", this->address_str());
-      this->gatt_backoff_.register_failure(this->address_str());
-      this->disconnect();
-      return false;
-    }
-    // Only the table build failed; legacy nodes read the base's services_
-    // and keep the link. Gatt nodes catch the next connection.
-    ESP_LOGW(TAG, "[%s] Service table build failed; gatt nodes skip this connection", this->address_str());
-    this->status_set_warning(LOG_STR("gatt nodes inactive: service table build failed"));
-    // A peer whose database never walks must not retry the build at
-    // advertisement cadence once the legacy nodes drop the link.
-    this->gatt_backoff_.register_failure(this->address_str());
-  } else {
-    this->gatt_connected_ = true;
-    auto view = table.view();
-    for (auto *node : this->gatt_nodes_) {
-      node->on_connected(view);
-      if (this->state() != espbt::ClientState::ESTABLISHED) {
-        // The node tore the link down; remaining nodes get on_disconnected
-        // with no preceding on_connected, so leave a trace of why.
-        ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str());
-        return false;
-      }
-    }
-    this->gatt_backoff_.reset();
-    this->status_clear_warning();
-  }
-  // Promote so the legacy release condition can fire.
-  for (auto *node : this->gatt_nodes_)
-    node->node_state = espbt::ClientState::ESTABLISHED;
-  return true;
-}
-
-void BLEClient::on_disconnect_complete(esp_err_t reason) {
-  this->pending_gatt_reg_count_ = 0;
-  if (!this->gatt_connected_)
-    return;  // Never-established links report nothing (neutral parity).
-  this->gatt_connected_ = false;
-  for (auto *node : this->gatt_nodes_)
-    node->on_disconnected();
-}
-
-int BLEClient::check_and_log_error_(const char *operation, esp_err_t err) {
-  if (err != ESP_OK)
-    this->log_gattc_warning_(operation, err);
-  return err;
-}
-
-int BLEClient::write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_(
-      "esp_ble_gattc_write_char",
-      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
-                               response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP,
-                               ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::read_characteristic(uint16_t handle) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_("esp_ble_gattc_read_char", esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_,
-                                                                                       handle, ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::read_descriptor(uint16_t handle) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_(
-      "esp_ble_gattc_read_char_descr",
-      esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  return this->check_and_log_error_(
-      "esp_ble_gattc_write_char_descr",
-      esp_ble_gattc_write_char_descr(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
-                                     ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE));
-}
-
-int BLEClient::notify_characteristic(uint16_t handle, bool enable) {
-  if (this->conn_id_ == UNSET_CONN_ID)
-    return ble_device_base::GATT_ERR_NOT_CONNECTED;
-  if (enable) {
-    if (this->find_pending_gatt_reg_(handle) >= 0) {
-      // ESP_OK: the in-flight registration's completion fans out to all nodes.
-      ESP_LOGW(TAG, "[%s] Notify registration already pending for handle 0x%04x", this->address_str(), handle);
-      return ESP_OK;
-    }
-    if (this->pending_gatt_reg_count_ == MAX_PENDING_NOTIFY_REGS) {
-      // An untracked registration would let the base's auto-CCCD through.
-      ESP_LOGE(TAG, "[%s] Too many pending notify registrations", this->address_str());
-      return ble_device_base::GATT_ERR_NO_MEMORY;
-    }
-    // The base helper's pending count holds the service-release until the
-    // (intercepted) completion.
-    esp_err_t err = this->register_for_notify(handle);
-    if (err == ESP_OK)
-      this->pending_gatt_regs_[this->pending_gatt_reg_count_++] = handle;
-    return this->check_and_log_error_("esp_ble_gattc_register_for_notify", err);
-  }
-  return this->check_and_log_error_("esp_ble_gattc_unregister_for_notify",
-                                    esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle));
-}
-
-int BLEClient::unpair() { return bluetooth_connection::unpair_device(this->get_address()); }
-
-#endif  // USE_BLE_CLIENT_GATT_NODES
-
 }  // namespace esphome::ble_client

 #endif
@@ -1,20 +1,18 @@
 #pragma once

-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-
-#include "ble_client_node.h"
-#include "connect_backoff.h"
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"

+#ifdef USE_ESP32
+
 #include <esp_bt_defs.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gatt_common_api.h>
 #include <esp_gattc_api.h>
+#include <array>
+#include <string>
 #include <vector>

 namespace esphome::ble_client {
@@ -23,6 +21,34 @@ namespace espbt = esphome::esp32_ble_tracker;

 using namespace esp32_ble_client;

+class BLEClient;
+
+class BLEClientNode {
+ public:
+  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                   esp_ble_gattc_cb_param_t *param) {};
+  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
+  virtual void loop() {}
+  void set_address(uint64_t address) { address_ = address; }
+  espbt::ESPBTClient *client;
+  // This should be transitioned to Established once the node no longer needs
+  // the services/descriptors/characteristics of the parent client. This will
+  // allow some memory to be freed.
+  // The parent frees the peer's GATT cache once every node reports Established.
+  // Never report Established while an operation that reads that cache is outstanding.
+  // - esp_ble_gattc_register_for_notify() completes asynchronously.
+  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
+  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
+  espbt::ClientState node_state;
+
+  BLEClient *parent() { return this->parent_; }
+  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
+
+ protected:
+  BLEClient *parent_;
+  uint64_t address_;
+};
+
 class BLEClient final : public BLEClientBase {
 public:
  void setup() override;
@@ -38,75 +64,19 @@ class BLEClient final : public BLEClientBase {
  void set_enabled(bool enabled);

  void register_ble_node(BLEClientNode *node) {
+    node->client = this;
    node->set_ble_client_parent(this);
    this->nodes_.push_back(node);
  }

-  // on_connect fires once discovery completes; on_disconnect on CLOSE_EVT, so only after a completed open
-  template<typename F> void add_on_connect_callback(F &&callback) {
-    this->connect_callbacks_.add(std::forward<F>(callback));
-  }
-  template<typename F> void add_on_disconnect_callback(F &&callback) {
-    this->disconnect_callbacks_.add(std::forward<F>(callback));
-  }
-
  bool enabled;

  void set_state(espbt::ClientState state) override;

-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // ---- the neutral node surface (signatures shared with the non-esp32
-  // engine, so nodes on the neutral interface compile against either) ----
-  void register_gatt_node(BLEClientNode *node);
-
-  bool idle() const { return this->state() == espbt::ClientState::IDLE; }
-
-  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response);
-  int read_characteristic(uint16_t handle);
-  int read_descriptor(uint16_t handle);
-  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len);
-  /// Local registration only; per the neutral contract the CCCD write is the
-  /// node's job (the legacy auto-CCCD is suppressed for these handles).
-  int notify_characteristic(uint16_t handle, bool enable);
-  // pair() comes from BLEClientBase, matching the neutral engine's.
-  int unpair();
-#endif
-
 protected:
  bool all_nodes_established_();
-  void maybe_release_services_();
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  int check_and_log_error_(const char *operation, esp_err_t err);
-  int find_pending_gatt_reg_(uint16_t handle) const;
-  void notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error);
-  void dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param);
-  // False = failed discovery: the link comes down and the caller suppresses
-  // the legacy fan-out.
-  bool handle_gatt_search_cmpl_(esp_gatt_status_t status);
-  bool take_pending_gatt_reg_(uint16_t handle);
-  void on_disconnect_complete(esp_err_t reason) override;
-#endif

  std::vector<BLEClientNode *> nodes_;
-  LazyCallbackManager<void()> connect_callbacks_;
-  LazyCallbackManager<void()> disconnect_callbacks_;
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Raise if a migrated node needs more concurrent registrations.
-  static constexpr uint8_t MAX_PENDING_NOTIFY_REGS = 4;
-
-  // Nodes on the neutral surface; fed the translated callbacks and
-  // auto-established after the on_connected fan-out. Every gatt node is
-  // also in nodes_ (registration pushes into both).
-  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> gatt_nodes_;
-  bool has_legacy_nodes_() const { return this->nodes_.size() > this->gatt_nodes_.size(); }
-  // Reconnect backoff after materializer failures.
-  ConnectBackoff gatt_backoff_;
-  // Bridge-initiated notify registrations awaiting REG_FOR_NOTIFY_EVT.
-  uint16_t pending_gatt_regs_[MAX_PENDING_NOTIFY_REGS];
-  uint8_t pending_gatt_reg_count_{0};
-  // on_connected fan-out started; on_disconnected is owed at teardown.
-  bool gatt_connected_{false};
-#endif
 };

 }  // namespace esphome::ble_client
@@ -1,261 +0,0 @@
-#include "ble_client_gatt.h"
-
-#if defined(USE_BLE_CLIENT_GATT_NODES) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-namespace esphome::ble_client {
-
-ESPHOME_LOG_TAG(TAG, "ble_client");
-
-void BLEClient::register_ble_node(BLEClientNode *node) {
-  node->set_ble_client_parent(this);
-  if (this->nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
-    // push_back past capacity is a silent no-op; an undersized slot count
-    // must be loud at boot, not an unresolvable node at runtime.
-    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str_);
-    this->status_set_error(LOG_STR("node capacity exceeded"));
-    return;
-  }
-  this->nodes_.push_back(node);
-}
-
-void BLEClient::set_address(uint64_t address) {
-  this->address_ = address;
-  uint8_t mac[6];
-  ble_device_base::uint64_to_mac_msb_first(address, mac);
-  format_mac_addr_upper(mac, this->address_str_);
-}
-
-void BLEClient::set_enabled(bool enabled) {
-  if (enabled == this->enabled)
-    return;
-  ESP_LOGI(TAG, "[%s] %s", this->address_str_, enabled ? "Enabled" : "Disabled");
-  this->enabled = enabled;
-  if (!enabled) {
-    this->disconnect();
-    return;
-  }
-  // A re-enable clears the backoff; the next sighting connects (legacy
-  // parity: enabling does not itself connect).
-  this->backoff_.reset();
-}
-
-bool BLEClient::parse_device(const ble_device_base::ESPBTDevice &device) {
-  if (device.address_uint64() != this->address_)
-    return false;
-  // The sighting is the source of truth for the address type.
-  this->address_type_ = device.get_address_type();
-  this->address_type_known_ = true;
-  if (!this->enabled || !this->auto_connect_ || this->state_ != State::IDLE)
-    return true;
-  if (this->backoff_.holding_off())
-    return true;
-  this->attempt_connect_();
-  return true;
-}
-
-void BLEClient::connect() {
-  if (this->state_ != State::IDLE) {
-    ESP_LOGD(TAG, "[%s] Connect requested while busy, ignoring", this->address_str_);
-    return;
-  }
-  // An absent peer can inhibit scanning for the backend's full connect
-  // timeout, so this is worth a breadcrumb - but it is a supported action.
-  ESP_LOGI(TAG, "[%s] Connecting on request", this->address_str_);
-  if (!this->address_type_known_) {
-    // Legacy parity: without a sighting the address type defaults to
-    // public, which never matches a random-static peer.
-    ESP_LOGW(TAG, "[%s] No sighting yet; assuming a public address type", this->address_str_);
-  }
-  this->attempt_connect_();
-}
-
-void BLEClient::attempt_connect_() {
-  int err = this->backend_->connect(this->address_, this->address_type_);
-  if (err != 0) {
-    // A refused connect never produces a callback: stay idle, charge the
-    // backoff, and resolve any waiting connect action through the failure
-    // path so its chain terminates.
-    ESP_LOGW(TAG, "[%s] Connect refused, err=%d", this->address_str_, err);
-    this->backoff_.register_failure(this->address_str_);
-    this->defer([this]() { this->connect_failed_callbacks_.call(); });
-    return;
-  }
-  ESP_LOGD(TAG, "[%s] Connecting", this->address_str_);
-  this->state_ = State::CONNECTING;
-}
-
-void BLEClient::disconnect() {
-  if (this->state_ == State::IDLE) {
-    ESP_LOGD(TAG, "[%s] Disconnect requested while idle, ignoring", this->address_str_);
-    return;
-  }
-  if (this->cancel_requested_) {
-    // The accepted teardown still reports; a refused second gatt_disconnect()
-    // would settle the link twice (phantom connect failure, backoff charge).
-    ESP_LOGD(TAG, "[%s] Disconnect already in flight, ignoring", this->address_str_);
-    return;
-  }
-  // A deliberate teardown's failure report must not feed the backoff.
-  this->cancel_requested_ = true;
-  int err = this->backend_->gatt_disconnect();
-  if (err != 0) {
-    // Refused synchronously: backend and client disagree about the link
-    // state. Warn, then settle through the deliberate-cancel path.
-    ESP_LOGW(TAG, "[%s] Disconnect refused, err=%d; settling locally", this->address_str_, err);
-    this->on_connection_state(false, 0, err);
-  }
-}
-
-void BLEClient::on_connection_state(bool connected, uint16_t mtu, int error) {
-  if (connected) {
-    this->state_ = State::DISCOVERING;
-    int discover_err = this->backend_->discover_services();
-    if (discover_err != 0) {
-      // Synchronous refusal: no discovery completion will follow.
-      ESP_LOGW(TAG, "[%s] Service discovery refused, err=%d", this->address_str_, discover_err);
-      this->backoff_.register_failure(this->address_str_);
-      // Deliberate teardown: its report must not charge the backoff again.
-      this->disconnect();
-    }
-    return;
-  }
-  bool was_connected = this->state_ == State::CONNECTED;
-  bool cancelled = this->cancel_requested_;
-  this->cancel_requested_ = false;
-  this->state_ = State::IDLE;
-  if (was_connected) {
-    ESP_LOGI(TAG, "[%s] Disconnected, status=%d", this->address_str_, error);
-    for (auto *node : this->nodes_) {
-      node->on_disconnected();
-    }
-    // Continuations leave the backend's event-drain stack first.
-    this->defer([this]() { this->disconnect_callbacks_.call(); });
-  } else {
-    if (cancelled) {
-      // status carries the refusal code when the teardown settled
-      // synchronously; 0 on a backend-completed cancel.
-      ESP_LOGD(TAG, "[%s] Connect attempt cancelled, status=%d", this->address_str_, error);
-    } else {
-      ESP_LOGW(TAG, "[%s] Connect failed, status=%d", this->address_str_, error);
-      this->backoff_.register_failure(this->address_str_);
-    }
-    this->defer([this]() { this->connect_failed_callbacks_.call(); });
-  }
-}
-
-void BLEClient::on_service_discovery_done(int error) {
-  if (this->state_ != State::DISCOVERING || this->cancel_requested_) {
-    // Raced a teardown; the terminal report settles the link.
-    ESP_LOGD(TAG, "[%s] Discovery completed during teardown, ignoring", this->address_str_);
-    this->backend_->release_services();
-    return;
-  }
-  if (error != 0) {
-    ESP_LOGW(TAG, "[%s] Service discovery failed, status=%d", this->address_str_, error);
-    this->backoff_.register_failure(this->address_str_);
-    // The teardown is deliberate: do not charge the backoff again for its
-    // connection report.
-    this->disconnect();
-    return;
-  }
-  ble_device_base::GattServiceTable table{};
-  if (!this->nodes_.empty()) {
-    // Materialize only when a node will read it: a client with no nodes
-    // would pay the build/free cycle on every (re)connect for nothing.
-    table = this->backend_->get_service_table();
-    if (table.service_count == 0) {
-      // A failed materialization is indistinguishable from a service-less
-      // peer, and a real GATT peer always exposes at least GAP/GATT: fail
-      // the discovery before CONNECTED so the teardown resolves through
-      // connect_failed, never a spurious on_disconnect.
-      ESP_LOGW(TAG, "[%s] Service table is empty; treating as failed discovery", this->address_str_);
-      this->backend_->release_services();
-      this->backoff_.register_failure(this->address_str_);
-      this->disconnect();
-      return;
-    }
-  }
-  // CONNECTED before the fan-out so nodes may consult connected() from
-  // their own on_connected().
-  this->state_ = State::CONNECTED;
-  for (auto *node : this->nodes_) {
-    node->on_connected(table);
-    if (this->state_ != State::CONNECTED || this->cancel_requested_) {
-      // A node tore the link down mid-fan-out: on_disconnect fires with no
-      // preceding on_connect, so leave a trace of why.
-      ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str_);
-      this->backend_->release_services();
-      return;
-    }
-  }
-  this->backend_->release_services();
-  this->backoff_.reset();
-  ESP_LOGI(TAG, "[%s] Connected", this->address_str_);
-  this->defer([this]() { this->connect_callbacks_.call(); });
-}
-
-void BLEClient::on_write_result(uint16_t handle, int error) {
-  if (error != 0) {
-    // Breadcrumb even when no node claims the handle.
-    ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str_, handle, error);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_write_result(handle, error);
-  }
-}
-
-void BLEClient::on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {
-  if (error != 0) {
-    // Breadcrumb even when no node claims the handle.
-    ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str_, handle, error);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_read_result(handle, data, len, error);
-  }
-}
-
-void BLEClient::on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) {
-  // Every node sees every notification and filters by handle (legacy parity).
-  for (auto *node : this->nodes_) {
-    node->on_notify(handle, data, len);
-  }
-}
-
-void BLEClient::on_notify_state(uint16_t handle, bool enabled, int error) {
-  if (error != 0) {
-    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str_,
-             enabled ? "enable" : "disable", handle, error);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_notify_state(handle, enabled, error);
-  }
-}
-
-void BLEClient::on_pairing_result(int status) {
-  if (status != 0) {
-    ESP_LOGW(TAG, "[%s] Pairing failed, status=%d", this->address_str_, status);
-  } else {
-    ESP_LOGI(TAG, "[%s] Paired", this->address_str_);
-  }
-  for (auto *node : this->nodes_) {
-    node->on_pairing_result(status);
-  }
-}
-
-void BLEClient::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "BLE Client:\n"
-                "  Address: %s\n"
-                "  Auto connect: %s",
-                this->address_str_, YESNO(this->auto_connect_));
-  if (this->enabled && this->state_ == State::IDLE) {
-    ESP_LOGCONFIG(TAG, "  Waiting for an advertisement from the device");
-  }
-}
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_CLIENT_GATT_NODES && !USE_BLE_CLIENT_LEGACY_ENGINE
@@ -1,151 +0,0 @@
-// Platform-neutral ble_client engine on the ble_device_base GATT contract.
-//
-// Compiled on every platform with a GATT backend except esp32, which keeps
-// the legacy BLEClientBase engine (ble_client.h) until its raw-gattc node
-// family migrates - the exclusive gates make the same class names resolve to
-// exactly one definition per build, so codegen is shared.
-//
-// Connects are sighting-gated like the legacy engine: the client is a parsed
-// advertisement listener, captures the peer's address type from the sighting,
-// and asks the backend to connect only when enabled and idle.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if defined(USE_BLE_CLIENT_GATT_NODES) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
-
-#include "ble_client_node.h"
-#include "connect_backoff.h"
-#include "esphome/components/ble_device_base/ble_device.h"
-#include "esphome/components/ble_device_base/ble_gatt_client.h"
-#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
-#include "esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h"
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-
-#include <cstdint>
-#include <functional>
-
-namespace esphome::ble_client {
-
-class BLEClient : public Component,
-                  public ble_device_base::ESPBTDeviceListener,
-                  public ble_device_base::GattClientListener {
- public:
-  void dump_config() override;
-
-  // Public field for legacy parity (the switch platform republishes it).
-  bool enabled{true};
-
-  void set_backend(ble_device_base::BLEGattConnection *backend) {
-    this->backend_ = backend;
-    backend->set_listener(this);
-  }
-  void set_address(uint64_t address);
-  void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
-  void set_enabled(bool enabled);
-  const char *address_str() const { return this->address_str_; }
-
-  void register_ble_node(BLEClientNode *node);
-  // One registration spelling shared with the esp32 engine's bridge.
-  void register_gatt_node(BLEClientNode *node) { this->register_ble_node(node); }
-
-  // An accepted teardown already owns the link: the pending report cannot be
-  // a connect. state_ stays put so that report still fires on_disconnect.
-  bool connected() const { return this->state_ == State::CONNECTED && !this->cancel_requested_; }
-  bool idle() const { return this->state_ == State::IDLE; }
-
-  /// Action-initiated connect (no sighting needed; uses the last captured
-  /// address type, public until a sighting arrives). No-op unless idle.
-  void connect();
-  void disconnect();
-
-  /// Legacy-named deferral used by the automation twins: neutral listener
-  /// callbacks run inside the backend's event drain, so automation chain
-  /// continuations must leave that stack first.
-  void run_later(std::function<void()> &&f) { this->defer(std::move(f)); }  // NOLINT
-
-  // Backend ops for nodes and actions - the frozen node-facing surface.
-  // Only write_characteristic has an in-tree caller; subscribing means
-  // notify_characteristic plus a CCCD write_descriptor (the caller's job
-  // per the contract).
-  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
-    return this->backend_->write_characteristic(handle, data, len, response);
-  }
-  int read_characteristic(uint16_t handle) { return this->backend_->read_characteristic(handle); }
-  int read_descriptor(uint16_t handle) { return this->backend_->read_descriptor(handle); }
-  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
-    return this->backend_->write_descriptor(handle, data, len);
-  }
-  int notify_characteristic(uint16_t handle, bool enable) {
-    return this->backend_->notify_characteristic(handle, enable);
-  }
-  int pair() { return this->backend_->pair(); }
-  int unpair() { return bluetooth_connection::unpair_device(this->address_); }
-
-  // Automation callback registration.
-  template<typename F> void add_on_connect_callback(F &&callback) {
-    this->connect_callbacks_.add(std::forward<F>(callback));
-  }
-  template<typename F> void add_on_disconnect_callback(F &&callback) {
-    this->disconnect_callbacks_.add(std::forward<F>(callback));
-  }
-  // Fired when a connect attempt dies before being established; the user
-  // on_disconnect trigger deliberately does NOT fire here (legacy parity).
-  template<typename F> void add_on_connect_failed_callback(F &&callback) {
-    this->connect_failed_callbacks_.add(std::forward<F>(callback));
-  }
-
-  // ---- ble_device_base::ESPBTDeviceListener ----
-  bool parse_device(const ble_device_base::ESPBTDevice &device) override;
-
-  // ---- ble_device_base::GattClientListener ----
-  void on_connection_state(bool connected, uint16_t mtu, int error) override;
-  void on_service_discovery_done(int error) override;
-  void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) override;
-  void on_write_result(uint16_t handle, int error) override;
-  void on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) override;
-  void on_notify_state(uint16_t handle, bool enabled, int error) override;
-  void on_pairing_result(int status) override;
-
- protected:
-  enum class State : uint8_t { IDLE, CONNECTING, DISCOVERING, CONNECTED };
-
-  void attempt_connect_();
-
-  // Group 1: pointers / containers
-  ble_device_base::BLEGattConnection *backend_{nullptr};
-  // Codegen-sized (ESPHOME_BLE_CLIENT_MAX_NODES); filled during setup.
-  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> nodes_;
-
-  // Group 2: 8-byte types
-  uint64_t address_{0};
-
-  // Group 3: callback managers (pointer-sized when empty)
-  LazyCallbackManager<void()> connect_callbacks_;
-  LazyCallbackManager<void()> disconnect_callbacks_;
-  LazyCallbackManager<void()> connect_failed_callbacks_;
-
-  // Group 4: 4-byte types
-  // Backoff so an undiscoverable database or a dead peer cannot produce a
-  // battery-draining connect loop.
-  ConnectBackoff backoff_;
-
-  // Group 5: arrays
-  char address_str_[MAC_ADDRESS_PRETTY_BUFFER_SIZE]{};
-
-  // Group 6: 1-byte types
-  State state_{State::IDLE};
-  uint8_t address_type_{0};  // BLE_ADDR_TYPE_*, captured from the sighting
-  // Distinguishes a captured public type from the never-sighted default.
-  bool address_type_known_{false};
-  bool auto_connect_{true};
-  // A user-initiated teardown in flight; its failure report is not a
-  // connect failure and must not feed the backoff.
-  bool cancel_requested_{false};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_CLIENT_GATT_NODES && !USE_BLE_CLIENT_LEGACY_ENGINE
@@ -1,68 +0,0 @@
-// The single BLEClientNode both ble_client engines share. The neutral
-// callback surface is the one interface node components build on; the raw
-// esp32 surface below it remains for components that have not migrated yet.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_GATT_CLIENT
-#include "esphome/components/ble_device_base/ble_gatt_client.h"
-#endif
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
-
-#include <esp_gap_ble_api.h>
-#include <esp_gattc_api.h>
-#endif
-
-#include <cstdint>
-
-namespace esphome::ble_client {
-
-class BLEClient;
-
-class BLEClientNode {
- public:
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // Neutral surface, delivered by both engines. The table is borrowed: copy
-  // handles during on_connected(). All nodes see all completions; filter by
-  // handle.
-  // A node that disconnects from inside on_connected() aborts the fan-out;
-  // the user's on_disconnect may then fire without a preceding on_connect.
-  virtual void on_connected(const ble_device_base::GattServiceTable &table) {}
-  virtual void on_disconnected() {}
-  virtual void on_notify(uint16_t handle, const uint8_t *data, uint16_t len) {}
-  // One in-flight registration per handle; its completion fans out to every
-  // node, so a refused duplicate request still sees on_notify_state.
-  virtual void on_notify_state(uint16_t handle, bool enabled, int error) {}
-  virtual void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {}
-  virtual void on_write_result(uint16_t handle, int error) {}
-  virtual void on_pairing_result(int status) {}
-#endif
-#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
-  // Legacy raw surface; components overriding these need the legacy engine
-  // until migrated to the neutral surface above.
-  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                                   esp_ble_gattc_cb_param_t *param) {}
-  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
-  virtual void loop() {}
-  // This should be transitioned to Established once the node no longer needs
-  // the services/descriptors/characteristics of the parent client. This will
-  // allow some memory to be freed.
-  // The parent frees the peer's GATT cache once every node reports Established.
-  // Never report Established while an operation that reads that cache is outstanding.
-  // - esp_ble_gattc_register_for_notify() completes asynchronously.
-  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
-  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
-  esp32_ble_tracker::ClientState node_state;
-#endif
-
-  BLEClient *parent() const { return this->parent_; }
-  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
-
- protected:
-  BLEClient *parent_{nullptr};
-};
-
-}  // namespace esphome::ble_client
@@ -1,172 +0,0 @@
-// The ble_client.ble_write action: a node on the platform-neutral interface,
-// so one implementation serves both engines (the esp32 bridge and the
-// neutral engine).
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_CLIENT_GATT_NODES
-
-#include <tuple>
-#include <vector>
-
-// One of the two engine headers resolves per build.
-#include "ble_client.h"
-#include "ble_client_gatt.h"
-#include "ble_client_node.h"
-#include "esphome/core/automation.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::ble_client {
-
-static const char *const BLE_WRITE_TAG = "ble_client.automation";
-
-// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
-static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
-
-template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
- public:
-  BLEClientWriteAction(BLEClient *ble_client) {
-    ble_client->register_gatt_node(this);
-    ble_client_ = ble_client;
-  }
-
-  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
-  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
-  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
-
-  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
-  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
-  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
-
-  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->value_.func = func;
-    this->len_ = -1;  // Sentinel value indicates template mode
-  }
-
-  // Store pointer to static data in flash (no RAM copy)
-  void set_value_simple(const uint8_t *data, size_t len) {
-    this->value_.data = data;
-    this->len_ = len;  // Length >= 0 indicates static mode
-  }
-
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    this->num_running_++;
-    this->var_ = std::make_tuple(x...);
-
-    bool result;
-    if (this->len_ >= 0) {
-      result = this->write(this->value_.data, this->len_);
-    } else {
-      std::vector<uint8_t> value = this->value_.func(x...);
-      result = this->write(value.data(), value.size());
-    }
-
-    // on write failure, continue the automation chain rather than stopping so
-    // that e.g. disconnect can work.
-    if (!result)
-      this->play_next_(x...);
-  }
-
-  // Initiate the write; the completion arrives in on_write_result. The
-  // response-less path can complete synchronously inside the call, so the
-  // handle is armed before the backend is touched.
-  bool write(const uint8_t *data, size_t len) {
-    if (!this->ble_client_->connected()) {
-      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - not connected");
-      return false;
-    }
-    if (!this->resolved_) {
-      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - characteristic was not resolved");
-      return false;
-    }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
-    esph_log_vv(BLE_WRITE_TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
-#endif
-    int err = this->ble_client_->write_characteristic(this->char_handle_, data, len, this->write_response_);
-    if (err != 0) {
-      esph_log_e(BLE_WRITE_TAG, "Error writing to characteristic: %d!", err);
-      return false;
-    }
-    return true;
-  }
-
-  void on_connected(const ble_device_base::GattServiceTable &table) override {
-    // Resolution comes from this table only; a re-discovery must not keep a
-    // stale handle.
-    this->resolved_ = false;
-    this->char_handle_ = 0;
-    const auto *service = ble_device_base::find_service(table, this->service_uuid_);
-    const auto *chr =
-        service == nullptr ? nullptr : ble_device_base::find_characteristic(table, *service, this->char_uuid_);
-    if (chr == nullptr) {
-      char char_buf[ble_device_base::UUID_STR_LEN];
-      char service_buf[ble_device_base::UUID_STR_LEN];
-      esph_log_w(BLE_WRITE_TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
-                 this->service_uuid_.to_str(service_buf));
-      return;
-    }
-    if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE) {
-      this->write_response_ = true;
-    } else if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE_NO_RSP) {
-      this->write_response_ = false;
-    } else {
-      char char_buf[ble_device_base::UUID_STR_LEN];
-      esph_log_e(BLE_WRITE_TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
-      return;
-    }
-    this->char_handle_ = chr->value_handle;
-    this->resolved_ = true;
-    char char_buf[ble_device_base::UUID_STR_LEN];
-    esph_log_d(BLE_WRITE_TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
-               this->ble_client_->address_str());
-  }
-
-  void on_disconnected() override {
-    this->resolved_ = false;
-    this->char_handle_ = 0;
-    if (this->num_running_ != 0)
-      this->stop_complex();
-  }
-
-  void on_write_result(uint16_t handle, int error) override {
-    if (this->num_running_ == 0) {
-      return;
-    }
-    if (!this->resolved_ || handle != this->char_handle_) {
-      // A parked chain waiting on a completion that never matches would
-      // otherwise stall silently until disconnect.
-      esph_log_d(BLE_WRITE_TAG, "Write result for handle 0x%04x ignored, waiting on 0x%04x", handle,
-                 this->char_handle_);
-      return;
-    }
-    if (error != 0) {
-      // Continue the chain (legacy parity) but leave a breadcrumb.
-      esph_log_w(BLE_WRITE_TAG, "Write completed with status %d", error);
-    }
-    this->ble_client_->run_later([this]() { this->play_next_tuple_(this->var_); });
-  }
-
- private:
-  BLEClient *ble_client_;
-  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
-  union Value {
-    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
-    const uint8_t *data;                  // Pointer to static data in flash
-  } value_;
-  ble_device_base::ESPBTUUID service_uuid_;
-  ble_device_base::ESPBTUUID char_uuid_;
-  std::tuple<Ts...> var_{};
-  uint16_t char_handle_{};
-  bool write_response_{false};
-  bool resolved_{false};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_CLIENT_GATT_NODES
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#ifdef USE_BLE_GATT_CLIENT
-
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <cstdint>
-
-namespace esphome::ble_client {
-
-/// Reconnect backoff after repeated connect/discovery failures, shared by
-/// both engines. 256 ms ticks in a uint16_t keep it 4 bytes; the ~4.7 h tick
-/// wrap can at worst reinstate one stale hold-off of a minute.
-class ConnectBackoff {
- public:
-  bool holding_off() const {
-    return this->failures_ != 0 && static_cast<uint16_t>(now() - this->start_) < this->failures_ * STEP_TICKS;
-  }
-  void register_failure(const char *address_str) {
-    if (this->failures_ < MAX_STEPS)
-      this->failures_++;
-    this->start_ = now();
-    esph_log_w("ble_client", "[%s] Holding off reconnect for %u s", address_str, this->failures_ * 10u);
-  }
-  void reset() { this->failures_ = 0; }
-
- private:
-  // ~10 s per consecutive failure, capped so a flapping peer retries within
-  // a minute at worst.
-  static constexpr uint16_t STEP_TICKS = 40;  // x 256 ms
-  static constexpr uint8_t MAX_STEPS = 6;
-  static uint16_t now() { return static_cast<uint16_t>(millis() >> 8); }
-
-  uint16_t start_{0};
-  uint8_t failures_{0};
-};
-
-}  // namespace esphome::ble_client
-
-#endif  // USE_BLE_GATT_CLIENT
@@ -1,48 +0,0 @@
-#include "ble_gatt_client.h"
-
-#ifdef USE_BLE_GATT_CLIENT
-
-#include "esphome/core/log.h"
-
-namespace esphome::ble_device_base {
-
-ESPHOME_LOG_TAG(TAG, "ble_device_base");
-
-const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
-                                              const ESPBTUUID &uuid) {
-  // 32-bit range math: a corrupt first/count pair cannot wrap past the check.
-  uint32_t end = uint32_t(service.first_characteristic) + service.characteristic_count;
-  if (end > table.characteristic_count) {
-    ESP_LOGW(TAG, "characteristic range out of bounds");
-    return nullptr;
-  }
-  for (uint32_t i = service.first_characteristic; i < end; i++) {
-    if (table.characteristics[i].uuid == uuid)
-      return &table.characteristics[i];
-  }
-  return nullptr;
-}
-
-const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
-                                      const ESPBTUUID &uuid) {
-  uint32_t end = uint32_t(characteristic.first_descriptor) + characteristic.descriptor_count;
-  if (end > table.descriptor_count) {
-    // Corrupt range, not a missing descriptor.
-    ESP_LOGW(TAG, "descriptor range out of bounds");
-    return nullptr;
-  }
-  for (uint32_t i = characteristic.first_descriptor; i < end; i++) {
-    if (table.descriptors[i].uuid == uuid)
-      return &table.descriptors[i];
-  }
-  return nullptr;
-}
-
-uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic) {
-  const GattDescriptor *desc = find_descriptor(table, characteristic, ESPBTUUID::from_uint16(CCCD_UUID));
-  return desc != nullptr ? desc->handle : 0;
-}
-
-}  // namespace esphome::ble_device_base
-
-#endif  // USE_BLE_GATT_CLIENT
@@ -11,16 +11,13 @@
 // interface. All listener calls are delivered on the ESPHome main loop;
 // borrowed data pointers are valid only for the duration of the call.
 //
-// Error domain (plain int, forwarded to the API without translation, so the
-// values are wire-frozen - API clients interpret them):
+// Error domain (plain int, forwarded to the API without translation):
 //   0            success
-//   1..0x11      ATT error codes (Bluetooth spec) - reserved; a backend whose
-//                native error codes land in this window must remap them out
+//   1..0x11      ATT error codes (Bluetooth spec; BTstack and Bluedroid agree)
 //   GATT_ERR_NOT_CONNECTED (-1)  no connection to the peer (on esp32 a raw
 //                ESP_FAIL from the stack shares this value; both read as a
 //                failed, unusable connection on the client side)
 //   GATT_ERR_NO_MEMORY (-2)      backend storage exhausted
-//   -1..-15      reserved for future contract sentinels
 //   anything else: platform stack error/status code, surfaced opaquely.
 // Connection events carry HCI status/disconnect reason codes (same code
 // space on every controller).
@@ -102,23 +99,9 @@ class GattClientListener {
 // The BLEGattConnection op surface, asserted where the alias binds
 // (bluetooth_connection_gatt_backend.h). Operations return 0 when accepted (completion arrives
 // through the listener) or a synchronous error (busy, not connected, stack
-// rejection); one operation may be outstanding at a time. A connection-state
-// or discovery completion always arrives from the event loop, never
-// synchronously from inside the op call - a synchronous terminal
-// on_connection_state from within gatt_disconnect() would re-enter the
-// consumer mid-teardown. A local-only completion may instead report inline,
-// before the op returns: notify_characteristic (a subscription-list edit on
-// the rp2 backend) and a write without response whose payload the stack took
-// immediately. Consumers must therefore arm whatever state their
-// on_write_result/on_notify_state reads before issuing the op, never after
-// the call returns. Semantics beyond the signatures:
+// rejection); one operation may be outstanding at a time. Semantics beyond
+// the signatures:
 // - connect: addr_type is a BLE_ADDR_TYPE_* constant (ble_device.h).
-//   Returning 0 means the request is accepted, not that the radio acted: the
-//   backend owns integration with its platform's scan/connect arbitration
-//   (Bluedroid parks the request for the tracker's promote loop, which owns
-//   scan-stop/coex/one-connect-at-a-time; the rp2 backend opens immediately
-//   and relies on sighting-gated consumers). Consumers must not assume
-//   connect timing.
 // - gatt_disconnect: also cancels a connect in progress (named to coexist
 //   with a platform stack's own void disconnect() on one backend class).
 //   Nonzero means nothing to tear down and no completion will follow; an
@@ -160,41 +143,6 @@ concept BLEGattConnectionContract = requires(T conn, GattClientListener *listene
  { conn.set_connection_type(ConnectionType{}) } -> std::same_as<void>;
 };

-// ---- service table lookup helpers ----
-//
-// Neutral, bounds-checked walks over a materialized GattServiceTable for
-// direct consumers that resolve a known device's handles by UUID (streaming
-// consumers forward the raw database and never need these). Linear search:
-// the table exists only between discovery and release_services(), for one
-// small known device.
-
-/// Client Characteristic Configuration descriptor UUID (Bluetooth spec).
-static constexpr uint16_t CCCD_UUID = 0x2902;
-
-// Characteristic property bits (the Bluetooth-spec declaration byte carried
-// in GattCharacteristic::properties; the ESP-IDF macros for these do not
-// exist on the other platforms).
-static constexpr uint8_t GATT_CHAR_PROP_WRITE_NO_RSP = 0x04;
-static constexpr uint8_t GATT_CHAR_PROP_WRITE = 0x08;
-
-inline const GattService *find_service(const GattServiceTable &table, const ESPBTUUID &uuid) {
-  for (uint16_t i = 0; i < table.service_count; i++) {
-    if (table.services[i].uuid == uuid)
-      return &table.services[i];
-  }
-  return nullptr;
-}
-
-const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
-                                              const ESPBTUUID &uuid);
-
-const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
-                                      const ESPBTUUID &uuid);
-
-/// Handle of the characteristic's Client Characteristic Configuration
-/// descriptor (0x2902), or 0 when it has none.
-uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic);
-
 }  // namespace esphome::ble_device_base

 #endif  // USE_BLE_GATT_CLIENT
@@ -1,14 +1,12 @@
 """Per-platform GATT connection backends and the helpers to embed one.

-Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; a
-consumer's codegen declares and registers the backend instances — the
-Bluetooth proxy through its per-slot connection wrappers (a streaming
-consumer), and the neutral ble_client through gatt_client_schema() +
-new_gatt_backend().
+Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; the
+Bluetooth proxy's codegen declares and registers the backend instances
+through gatt_client_schema()/hub_connection_schema() + new_gatt_backend().
 """

 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass

 import esphome.codegen as cg
 from esphome.components import rp2040_ble
@@ -25,8 +23,7 @@ from esphome.types import ConfigType
 def AUTO_LOAD() -> list[str]:
    """ble_device_base plus the platform BLE stack the build's backend
    registers with (the Bluedroid header includes the tracker's), so
-    consumers stay platform-blind. The platform-less arm serves tooling that
-    resolves the manifest without a target."""
+    consumers need not know. The platform-less arm serves manifest tooling."""
    if CORE.is_esp32:
        return ["ble_device_base", "esp32_ble_tracker"]
    if CORE.is_rp2:
@@ -66,8 +63,6 @@ DOMAIN = "bluetooth_connection"
@dataclass
 class _ConnectionData:
    rp2_backend_count: int = 0
-    # GATT connection slots claimed this run, for the platform cap check.
-    slot_consumers: list[str] = field(default_factory=list)


 def _get_data() -> _ConnectionData:
@@ -124,10 +119,6 @@ class _PlatformBackend:
    backend_class: cg.MockObjClass
    schema_fragment: Callable[[], cv.Schema]
    register: Callable[[cg.MockObj, ConfigType], Awaitable[None]]
-    # Selects the backend's alias-ladder arm (order-independent arms).
-    define: str
-    # The backend's on-demand materializer gate, when it has one.
-    materializer_define: str | None = None


 # The single registry of platforms with a GATT client backend; a platform
@@ -135,20 +126,11 @@ class _PlatformBackend:
 # platform's arm.
 _PLATFORM_BACKENDS: dict[str, _PlatformBackend] = {
    PLATFORM_ESP32: _PlatformBackend(
-        BluedroidGattClient,
-        _esp32_schema_fragment,
-        _esp32_register,
-        "USE_BLE_GATT_BACKEND_BLUEDROID",
-        materializer_define="USE_BLUEDROID_GATT_SERVICE_TABLE",
-    ),
-    PLATFORM_RP2: _PlatformBackend(
-        RP2GattClient, _rp2_schema_fragment, _rp2_register, "USE_BLE_GATT_BACKEND_RP2"
+        BluedroidGattClient, _esp32_schema_fragment, _esp32_register
    ),
+    PLATFORM_RP2: _PlatformBackend(RP2GattClient, _rp2_schema_fragment, _rp2_register),
 }

-# Gates dedicated-backend consumers (cv.only_on).
-GATT_CLIENT_PLATFORMS = list(_PLATFORM_BACKENDS)
-

 def _backend_entry(platform: str | None = None) -> _PlatformBackend:
    key = platform if platform is not None else CORE.target_platform
@@ -183,97 +165,21 @@ def hub_connection_schema(platform: str | None = None) -> cv.Schema:
    )


-def _charge_esp32_budget(count: int, consumer: str, config: ConfigType) -> None:
-    from esphome.components import esp32_ble
-
-    esp32_ble.consume_connection_slots(count, consumer)(config)
-
-
-def _charge_rp2_budget(count: int, consumer: str, config: ConfigType) -> None:
-    rp2040_ble.consume_connection_slots(count, consumer)(config)
-
-
-# Platforms whose BLE stack owns its own connection budget: the claim is
-# charged there and that stack's final validation is the one place an
-# overcommit is reported (never two messages for one misconfiguration). One
-# mapping drives both, so a platform can never be skipped without a charge.
-_STACK_BUDGETS: dict[str, Callable[[int, str, ConfigType], None]] = {
-    PLATFORM_ESP32: _charge_esp32_budget,
-    PLATFORM_RP2: _charge_rp2_budget,
-}
-
-
-def consume_gatt_slot(
-    consumer: str, count: int = 1
-) -> Callable[[ConfigType], ConfigType]:
-    """Validator claiming GATT connection slots - the one spelling for every
-    claimant. The neutral ledger covers backend platforms without a stack
-    budget (the cap check in FINAL_VALIDATE_SCHEMA)."""
-
-    def validator(config: ConfigType) -> ConfigType:
-        _get_data().slot_consumers.extend([consumer] * count)
-        if (charge := _STACK_BUDGETS.get(CORE.target_platform)) is not None:
-            charge(count, consumer, config)
-        return config
-
-    return validator
-
-
-def _validate_slot_totals(config: ConfigType) -> ConfigType:
-    # Skipped in testing mode so grouped component builds can co-exist
-    # (mirrors esp32_ble.validate_connection_slots).
-    if CORE.testing_mode:
-        return config
-    if CORE.target_platform in _STACK_BUDGETS:
-        return config
-    if (cap := HUB_MAX_CONNECTIONS.get(CORE.target_platform)) is None:
-        # Any backend platform without a stack budget must carry a cap here
-        # or fail loudly, never fail open.
-        if CORE.target_platform in _PLATFORM_BACKENDS:
-            raise cv.Invalid(
-                f"{CORE.target_platform} has a GATT backend but no slot cap "
-                "in HUB_MAX_CONNECTIONS"
-            )
-        return config
-    claimed = _get_data().slot_consumers
-    if len(claimed) > cap:
-        raise cv.Invalid(
-            f"{CORE.target_platform} supports at most {cap} GATT client "
-            f"connection(s); {len(claimed)} requested by: {', '.join(claimed)}"
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _validate_slot_totals
-
-
-async def new_gatt_backend(
-    config: ConfigType, *, service_table: bool = True
-) -> cg.MockObj:
+async def new_gatt_backend(config: ConfigType) -> cg.MockObj:
    """Instantiate the backend declared by gatt_client_schema() and register
    it with its platform stack. The connection slot is claimed at validation
-    (the consume_gatt_slot validators), not here.
-
-    service_table is honored by the Bluedroid backend only: forward
-    scaffolding for the first esp32 direct consumer, load-bearing on no
-    current build (rp2 ignores the define and always materializes - its
-    proxy hub streams through get_service_table(), so it must keep the
-    materializer regardless of the flag).
+    (the proxy's slot validators), not here.
    """
    from esphome.components import ble_device_base

-    entry = _backend_entry()
    ble_device_base.request_gatt_client()
-    cg.add_define(entry.define)
-    if service_table and entry.materializer_define is not None:
-        cg.add_define(entry.materializer_define)
    backend = cg.new_Pvariable(config[CONF_BACKEND_ID])
    # The backend is the slot's real Component: component keys from the
    # connection entry (setup_priority, ...) apply to it. Consumers whose own
    # schema carries keys that register_component would misapply to the
    # backend (e.g. a polling interval) must not put them in this config.
    await cg.register_component(backend, config)
-    await entry.register(backend, config)
+    await _backend_entry().register(backend, config)
    return backend


@@ -281,7 +187,6 @@ async def new_gatt_backend(
 # list (this module cannot import bluetooth_proxy to derive it).
 SOURCE_FILE_FRAMEWORKS: dict[str, set[PlatformFramework]] = {
    "bluetooth_connection_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
-    "gatt_service_table_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
    # Every hub platform the proxy admits (the file compiles empty where
    # USE_BLE_GATT_CLIENT is not defined), so a platform gaining a backend
    # cannot hit a missing-symbol trap here.
@@ -46,7 +46,7 @@ BatchClose close_service_batch(api::BluetoothGATTGetServicesResponse &resp, size

 #endif  // USE_BLUETOOTH_PROXY_CONNECTIONS

-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
 namespace esphome::bluetooth_connection {

 // Address-scoped Bluedroid maintenance. Gated with the connection surface:
@@ -65,4 +65,4 @@ conn_err_t clear_gatt_cache(uint64_t address) {
 }

 }  // namespace esphome::bluetooth_connection
-#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT
+#endif  // USE_ESP32 && USE_BLE_GATT_CLIENT
@@ -49,16 +49,15 @@ static constexpr conn_err_t CONN_OK = 0;
 // GATT contract so backend and wrapper cannot drift.
 static constexpr conn_err_t GATT_NOT_CONNECTED = ble_device_base::GATT_ERR_NOT_CONNECTED;

-// What the build's connection backend supports beyond GATT operations; the
-// proxy derives its feature flags and legacy version from these. Keyed on
-// the backend define, never the platform, so a second backend on one
-// platform carries its own facts.
-#if defined(USE_BLE_GATT_BACKEND_BLUEDROID)
+// What the platform's connection backend supports beyond GATT operations;
+// the proxy derives its feature flags and legacy version from these.
+#if defined(USE_ESP32)
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = true;
-#elif defined(USE_BLE_GATT_BACKEND_RP2)
+#elif defined(USE_RP2040_BLE) && defined(USE_BLE_GATT_CLIENT)
 // The rp2 BTstack backend pairs (just works + bonding); it has no service
-// cache to clear.
+// cache to clear. Keyed on the backend, not the generic client define, so a
+// future backend without pairing keeps the stub arm below.
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #else
@@ -66,14 +65,13 @@ static constexpr bool SUPPORTS_PAIRING = false;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #endif

-// Address-scoped (not connection-scoped) maintenance requests; keyed on the
-// stack (the calls need no backend instance).
-#if (defined(USE_ESP32_BLE) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
+// Address-scoped (not connection-scoped) maintenance requests.
+#if (defined(USE_ESP32) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t unpair_device(uint64_t address);
 #else
 inline conn_err_t unpair_device(uint64_t) { return GATT_NOT_CONNECTED; }
 #endif
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t clear_gatt_cache(uint64_t address);
 #else
 inline conn_err_t clear_gatt_cache(uint64_t) { return GATT_NOT_CONNECTED; }
@@ -2,11 +2,10 @@

 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)

-#include "bluetooth_connection.h"
-
 // The in-place streamer serves the proxy's service-discovery API; backend-only
 // builds compile without the proxy headers or the streamer.
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
+#include "bluetooth_connection.h"
 #include "bluetooth_connection_hub.h"

 #include "esphome/components/bluetooth_proxy/bluetooth_proxy.h"
@@ -346,9 +345,6 @@ int BluedroidGattClient::update_connection_params(uint16_t min_interval, uint16_

 void BluedroidGattClient::release_services() {
  this->service_total_ = 0;
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  this->table_.free();
-#endif
  // Always set: terminates any in-flight stream on every cache config.
  this->services_released_ = true;
 #ifndef CONFIG_BT_GATTC_CACHE_NVS_FLASH
@@ -361,24 +357,6 @@ void BluedroidGattClient::release_services() {
 #endif
 }

-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-ble_device_base::GattServiceTable BluedroidGattClient::get_service_table() {
-  // Lifetime: every teardown path (CLOSE_EVT, the safety timeout, stack-down,
-  // passive DISCONNECT) routes through release_services(), so a materialized
-  // table cannot outlive its link.
-  if (this->table_.empty() &&
-      (this->services_released_ || this->service_total_ == 0 ||
-       !this->table_.build(this->gattc_if_, this->conn_id_, this->service_total_, this->connection_index_))) {
-    // Released / no services / failed build all collapse to empty; the
-    // build failures warned above, log the quiet two.
-    ESP_LOGD(TAG, "[%d] No service table (released=%d, services=%u)", this->connection_index_, this->services_released_,
-             this->service_total_);
-    return {};
-  }
-  return this->table_.view();
-}
-#endif  // USE_BLUEDROID_GATT_SERVICE_TABLE
-
 // ---- internals ----

 bool BluedroidGattClient::check_addr_(const esp_bd_addr_t &addr) const {
@@ -425,11 +403,6 @@ void BluedroidGattClient::log_gattc_warning_(const char *operation, int code) {
 // ---- service streaming ----

 int BluedroidGattClient::handle_search_cmpl_(esp_gatt_status_t status) {
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  // Re-discovery moves the counts the table view derives offsets from; free
-  // the stale table.
-  this->table_.free();
-#endif
  // Step down from the fast discovery params.
  this->update_conn_params_(MEDIUM_MIN_CONN_INTERVAL, MEDIUM_MAX_CONN_INTERVAL, 0, MEDIUM_CONN_TIMEOUT, "medium");
  if (status != ESP_GATT_OK) {
@@ -11,9 +11,6 @@

 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)

-#include "bluetooth_connection.h"
-#include "gatt_service_table_bluedroid.h"
-
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
@@ -79,16 +76,11 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
  int notify_characteristic(uint16_t handle, bool enable);
  int pair();
  int update_connection_params(uint16_t min_interval, uint16_t max_interval, uint16_t latency, uint16_t timeout);
-  // On-demand table for direct consumers; the proxy streams instead, so the
-  // materializer compiles only under USE_BLUEDROID_GATT_SERVICE_TABLE (emitted by
-  // direct-consumer codegen, never by the proxy).
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  ble_device_base::GattServiceTable get_service_table();
-#else
-  // A direct consumer reaching this stub misconfigured its codegen
-  // (service_table=False): the empty table reads as a service-less peer.
+  // Contract stub: the proxy streams in place; the on-demand materializer
+  // for direct consumers lands with #18205. NOTE: a direct consumer reaching
+  // this stub gets an empty table indistinguishable from a service-less
+  // peer - do not ship one against this backend before the materializer.
  ble_device_base::GattServiceTable get_service_table() { return {}; }
-#endif
  void release_services();

 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
@@ -118,9 +110,6 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public

  // Group 1: pointers / composed objects
  ble_device_base::GattClientListener *listener_{nullptr};
-#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
-  BluedroidServiceTable table_;
-#endif
  // Group 2: 4-byte types
  uint32_t disconnecting_started_{0};

@@ -12,12 +12,10 @@

 #include "esphome/components/ble_device_base/ble_gatt_client.h"

-// Arms are keyed on codegen-emitted per-backend defines (_PLATFORM_BACKENDS
-// in __init__.py), so they are order-independent.
-#if defined(USE_BLE_GATT_BACKEND_RP2)
+#if defined(USE_RP2040_BLE)
 #include "bluetooth_connection_rp2.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::RP2GattClient
-#elif defined(USE_BLE_GATT_BACKEND_BLUEDROID)
+#elif defined(USE_ESP32_BLE)
 #include "bluetooth_connection_bluedroid.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::BluedroidGattClient
 #elif defined(USE_BLE_GATT_CLIENT_STUB_BACKEND)
@@ -1,198 +0,0 @@
-#include "gatt_service_table_bluedroid.h"
-
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
-
-#include "esphome/core/log.h"
-
-namespace esphome::bluetooth_connection {
-
-ESPHOME_LOG_TAG(TAG, "bluetooth_connection");
-
-// A stack that never reports end-of-range would otherwise walk forever.
-static constexpr uint16_t MAX_DESCRIPTORS_PER_CHARACTERISTIC = 64;
-
-// Shared enumeration for both build passes: an identical walk order is what
-// lets the counting pass size the block the filling pass fills.
-// INVALID_OFFSET/NOT_FOUND mean end-of-range; anything else is a failure.
-template<typename ServiceFn, typename CharFn, typename DescFn>
-bool BluedroidServiceTable::walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc) {
-  for (uint16_t s = 0; s < this->service_total_; s++) {
-    esp_gattc_service_elem_t svc;
-    uint16_t svc_count = 1;
-    auto svc_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr, &svc, &svc_count, s);
-    if (svc_status != ESP_GATT_OK || svc_count == 0) {
-      this->log_walk_warning_("esp_ble_gattc_get_service", svc_status);
-      return false;
-    }
-    if (!on_service(s, svc)) {
-      return false;
-    }
-    uint16_t svc_chars = 0;
-    auto count_status = esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
-                                                     svc.start_handle, svc.end_handle, 0, &svc_chars);
-    if (count_status != ESP_GATT_OK) {
-      this->log_walk_warning_("esp_ble_gattc_get_attr_count", count_status);
-      return false;
-    }
-    for (uint16_t c = 0; c < svc_chars; c++) {
-      esp_gattc_char_elem_t chr;
-      uint16_t char_count = 1;
-      auto status = esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, svc.start_handle, svc.end_handle, &chr,
-                                               &char_count, c);
-      if (status != ESP_GATT_OK || char_count == 0) {
-        // An early terminator contradicts svc_chars from the same cache;
-        // never build a silently truncated table.
-        this->log_walk_warning_("esp_ble_gattc_get_all_char", status);
-        return false;
-      }
-      if (!on_char(svc, chr)) {
-        return false;
-      }
-      for (uint16_t d = 0;; d++) {
-        if (d == MAX_DESCRIPTORS_PER_CHARACTERISTIC) {
-          // A stack that never reports end-of-range; fail like every other
-          // inconsistency instead of truncating the table silently.
-          ESP_LOGW(TAG, "[%d] Descriptor walk exceeded %u entries", this->log_index_,
-                   MAX_DESCRIPTORS_PER_CHARACTERISTIC);
-          return false;
-        }
-        esp_gattc_descr_elem_t desc;
-        uint16_t desc_count = 1;
-        auto desc_status =
-            esp_ble_gattc_get_all_descr(this->gattc_if_, this->conn_id_, chr.char_handle, &desc, &desc_count, d);
-        if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
-          break;
-        }
-        if (desc_status != ESP_GATT_OK || desc_count == 0) {
-          this->log_walk_warning_("esp_ble_gattc_get_all_descr", desc_status);
-          return false;
-        }
-        if (!on_desc(chr, desc)) {
-          return false;
-        }
-      }
-    }
-  }
-  return true;
-}
-
-bool BluedroidServiceTable::count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total) {
-  uint16_t primary = 0;
-  uint16_t secondary = 0;
-  if (esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_PRIMARY_SERVICE, 0x0001, 0xFFFF, 0, &primary) !=
-          ESP_GATT_OK ||
-      esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_SECONDARY_SERVICE, 0x0001, 0xFFFF, 0, &secondary) !=
-          ESP_GATT_OK) {
-    // A failed count must not read as an authoritative empty database.
-    return false;
-  }
-  *total = primary + secondary;
-  return true;
-}
-
-bool BluedroidServiceTable::build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index) {
-  this->free();
-  this->gattc_if_ = gattc_if;
-  this->conn_id_ = conn_id;
-  this->service_total_ = service_total;
-  this->log_index_ = log_index;
-
-  // Pass 1: count, so one exact-size block holds the whole table.
-  uint16_t char_total = 0;
-  uint16_t desc_total = 0;
-  bool counted = this->walk_([](uint16_t, const esp_gattc_service_elem_t &) { return true; },
-                             [&](const esp_gattc_service_elem_t &, const esp_gattc_char_elem_t &) {
-                               char_total++;
-                               return true;
-                             },
-                             [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &) {
-                               desc_total++;
-                               return true;
-                             });
-  if (!counted) {
-    ESP_LOGW(TAG, "[%d] Service table walk failed during count", this->log_index_);
-    this->free();
-    return false;
-  }
-
-  // The arrays share one block; carving stays aligned because each struct's
-  // strictest member is the UUID and array sizes are multiples of it.
-  static_assert(alignof(ble_device_base::GattService) >= alignof(ble_device_base::GattCharacteristic) &&
-                alignof(ble_device_base::GattCharacteristic) >= alignof(ble_device_base::GattDescriptor));
-  size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
-  size_t char_bytes = char_total * sizeof(ble_device_base::GattCharacteristic);
-  size_t total_bytes = svc_bytes + char_bytes + desc_total * sizeof(ble_device_base::GattDescriptor);
-  RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
-  this->storage_ = allocator.allocate(total_bytes);
-  if (this->storage_ == nullptr) {
-    ESP_LOGW(TAG, "[%d] Service table allocation failed (%u bytes)", this->log_index_,
-             static_cast<unsigned>(total_bytes));
-    this->free();
-    return false;
-  }
-  auto *services = reinterpret_cast<ble_device_base::GattService *>(this->storage_);
-  auto *characteristics = reinterpret_cast<ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes);
-  auto *descriptors = reinterpret_cast<ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes);
-
-  // Pass 2: fill, bounded by the pass-1 totals. A bound trip or a shortfall
-  // means the cached database changed between the passes; fail the build
-  // rather than serve an inconsistent table (the consumer retries).
-  uint16_t char_index = 0;
-  uint16_t desc_index = 0;
-  ble_device_base::GattService *cur_service = nullptr;
-  ble_device_base::GattCharacteristic *cur_char = nullptr;
-  bool filled = this->walk_(
-      [&](uint16_t s, const esp_gattc_service_elem_t &svc) {
-        cur_service = &services[s];
-        cur_service->uuid = ble_device_base::ESPBTUUID::from_uuid(svc.uuid);
-        cur_service->start_handle = svc.start_handle;
-        cur_service->end_handle = svc.end_handle;
-        cur_service->first_characteristic = char_index;
-        cur_service->characteristic_count = 0;
-        return true;
-      },
-      [&](const esp_gattc_service_elem_t &svc, const esp_gattc_char_elem_t &chr) {
-        if (char_index >= char_total) {
-          return false;
-        }
-        cur_char = &characteristics[char_index++];
-        cur_char->uuid = ble_device_base::ESPBTUUID::from_uuid(chr.uuid);
-        cur_char->value_handle = chr.char_handle;
-        // Bluedroid addresses descriptors by characteristic handle, so the
-        // table's end_handle only needs the service-bounded upper bound.
-        cur_char->end_handle = svc.end_handle;
-        cur_char->properties = chr.properties;
-        cur_char->first_descriptor = desc_index;
-        cur_char->descriptor_count = 0;
-        cur_service->characteristic_count++;
-        return true;
-      },
-      [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &desc) {
-        if (desc_index >= desc_total) {
-          return false;
-        }
-        descriptors[desc_index].uuid = ble_device_base::ESPBTUUID::from_uuid(desc.uuid);
-        descriptors[desc_index].handle = desc.handle;
-        desc_index++;
-        cur_char->descriptor_count++;
-        return true;
-      });
-  if (!filled || char_index != char_total || desc_index != desc_total) {
-    // Walk error or the database changed between passes; better an empty
-    // table than a corrupt one.
-    ESP_LOGW(TAG, "[%d] Service table walk mismatch, discarding", this->log_index_);
-    this->free();
-    return false;
-  }
-  this->char_total_ = char_total;
-  this->desc_total_ = desc_total;
-  return true;
-}
-
-void BluedroidServiceTable::log_walk_warning_(const char *operation, int code) {
-  ESP_LOGW(TAG, "[%d] %s failed, status=%d", this->log_index_, operation, code);
-}
-
-}  // namespace esphome::bluetooth_connection
-
-#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE
@@ -1,82 +0,0 @@
-// Owning two-pass materializer of one Bluedroid GATT database snapshot into
-// the neutral GattServiceTable layout, shared by the BluedroidGattClient
-// backend and ble_client's esp32 engine.
-
-#pragma once
-
-#include "esphome/core/defines.h"
-
-#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
-
-#include "esphome/components/ble_device_base/ble_gatt_client.h"
-#include "esphome/core/helpers.h"
-
-#include <esp_gattc_api.h>
-
-namespace esphome::bluetooth_connection {
-
-class BluedroidServiceTable {
- public:
-  ~BluedroidServiceTable() { this->free(); }
-  // Owns storage_; a copy would double-free. The default constructor is user
-  // provided, not "= default", so value-initializing the enclosing backend
-  // cannot zero-fill .bss that is already zero.
-  BluedroidServiceTable() {}
-  BluedroidServiceTable(const BluedroidServiceTable &) = delete;
-  BluedroidServiceTable &operator=(const BluedroidServiceTable &) = delete;
-
-  /// The service count build() requires: the stack's PRIMARY+SECONDARY
-  /// attribute totals, never the SEARCH_RES event count.
-  static bool count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total);
-
-  /// Two-pass build from the stack's cached database (service_total from
-  /// count_services()). log_index labels warnings. Frees any previous table
-  /// first; on failure the table is left empty.
-  bool build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index);
-
-  // The view is carved from the storage block and the counts on each call
-  // (a cold path) rather than cached, saving a per-instance table member.
-  ble_device_base::GattServiceTable view() const {
-    size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
-    size_t char_bytes = this->char_total_ * sizeof(ble_device_base::GattCharacteristic);
-    return {reinterpret_cast<const ble_device_base::GattService *>(this->storage_),
-            reinterpret_cast<const ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes),
-            reinterpret_cast<const ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes),
-            this->service_total_,
-            this->char_total_,
-            this->desc_total_};
-  }
-
-  // Always resets the counts: a failed build must never leave a non-zero
-  // service_total_ behind a null table.
-  void free() {
-    if (this->storage_ != nullptr) {
-      RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
-      allocator.deallocate(this->storage_, 0);
-      this->storage_ = nullptr;
-    }
-    this->service_total_ = 0;
-    this->char_total_ = 0;
-    this->desc_total_ = 0;
-  }
-
-  bool empty() const { return this->storage_ == nullptr; }
-
- private:
-  template<typename ServiceFn, typename CharFn, typename DescFn>
-  bool walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc);
-  void log_walk_warning_(const char *operation, int code);
-
-  uint8_t *storage_{nullptr};
-  uint16_t service_total_{0};
-  uint16_t char_total_{0};
-  uint16_t desc_total_{0};
-  // Walk context, set by build().
-  uint16_t conn_id_{0};
-  esp_gatt_if_t gattc_if_{};  // uint8_t width
-  uint8_t log_index_{0};
-};
-
-}  // namespace esphome::bluetooth_connection
-
-#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE
@@ -94,20 +94,10 @@ def _esp32_config_schema() -> cv.All:
    CONNECTION_SCHEMA = bluetooth_connection.hub_connection_schema(PLATFORM_ESP32)

    def validate_connections(config: ConfigType) -> ConfigType:
-        if CONF_CONNECTIONS in config:
-            # Explicit entries claim slots like the generated ones; dev
-            # historically skipped this, letting an explicit-connections
-            # config evade the controller budget.
-            bluetooth_connection.consume_gatt_slot(
-                "bluetooth_proxy", len(config[CONF_CONNECTIONS])
-            )(config)
-            return config
-        if not config[CONF_ACTIVE]:
+        if CONF_CONNECTIONS in config or not config[CONF_ACTIVE]:
            return config
        connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
-            config
-        )
+        esp32_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
        return {
            **config,
            CONF_CONNECTIONS: [CONNECTION_SCHEMA({}) for _ in range(connection_slots)],
@@ -159,14 +149,14 @@ def _rp2_config_schema() -> cv.All:
    connection_schema = bluetooth_connection.hub_connection_schema(PLATFORM_RP2)

    def populate_connections(config: ConfigType) -> ConfigType:
+        from esphome.components import rp2040_ble
+
        # One wrapper + backend pair per slot, declared during validation so
        # their ids exist for codegen (the esp32 arm's `connections` pattern).
        if not config[CONF_ACTIVE]:
            return config
        connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
-            config
-        )
+        rp2040_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
        return {
            **config,
            CONF_CONNECTIONS: [connection_schema({}) for _ in range(connection_slots)],
@@ -216,9 +206,7 @@ async def _connections_to_code(var: cg.MockObj, config: ConfigType) -> None:
        # sends those requests and their handlers and encoders are dead.
        cg.add_define("USE_BLUETOOTH_PROXY_CONNECTIONS")
    for connection_conf in connections:
-        backend = await bluetooth_connection.new_gatt_backend(
-            connection_conf, service_table=False
-        )
+        backend = await bluetooth_connection.new_gatt_backend(connection_conf)
        connection = cg.new_Pvariable(connection_conf[CONF_ID])
        cg.add(connection.set_backend(backend))
        cg.add(var.register_connection(connection))
@@ -139,24 +139,49 @@ bool BME680Component::setup_registers_() {
  this->calibration_.ambient_temperature = 25;  // prime ambient temperature

  // Config register
-  if (!this->update_register(BME680_REGISTER_CONFIG, 0b00011100, (this->iir_filter_ & 0b111) << 2)) {
+  uint8_t config_register;
+  if (!this->read_byte(BME680_REGISTER_CONFIG, &config_register)) {
+    return false;
+  }
+  config_register &= ~0b00011100;
+  config_register |= (this->iir_filter_ & 0b111) << 2;
+  if (!this->write_byte(BME680_REGISTER_CONFIG, config_register)) {
    return false;
  }

  // Humidity control register
-  if (!this->update_register(BME680_REGISTER_CONTROL_HUMIDITY, 0b00000111, this->humidity_oversampling_ & 0b111)) {
+  uint8_t hum_control;
+  if (!this->read_byte(BME680_REGISTER_CONTROL_HUMIDITY, &hum_control)) {
+    return false;
+  }
+  hum_control &= ~0b00000111;
+  hum_control |= this->humidity_oversampling_ & 0b111;
+  if (!this->write_byte(BME680_REGISTER_CONTROL_HUMIDITY, hum_control)) {
    return false;
  }

-  // Gas 1 control register: run gas, heater profile 0
-  if (!this->update_register(BME680_REGISTER_CONTROL_GAS1, 0b00011111, 1 << 4)) {
+  // Gas 1 control register
+  uint8_t gas1_control;
+  if (!this->read_byte(BME680_REGISTER_CONTROL_GAS1, &gas1_control)) {
+    return false;
+  }
+  gas1_control &= ~0b00011111;
+  gas1_control |= 1 << 4;
+  gas1_control |= 0;  // profile 0
+  if (!this->write_byte(BME680_REGISTER_CONTROL_GAS1, gas1_control)) {
    return false;
  }

  const bool heat_off = this->heater_temperature_ == 0 || this->heater_duration_ == 0;

  // Gas 0 control register
-  if (!this->update_register(BME680_REGISTER_CONTROL_GAS0, 0b00001000, heat_off << 3)) {
+  uint8_t gas0_control;
+  if (!this->read_byte(BME680_REGISTER_CONTROL_GAS0, &gas0_control)) {
+    return false;
+  }
+  gas0_control &= ~0b00001000;
+  gas0_control |= heat_off << 3;
+  if (!this->write_byte(BME680_REGISTER_CONTROL_GAS0, gas0_control)) {
    return false;
  }

@@ -66,7 +66,9 @@ CONFIG_SCHEMA = cv.typed_schema(
 def _final_validate(config: ConfigType) -> None:
    if config[CONF_TYPE] not in _MAGNETIC_FIELDS:
        return
-    bmi270_config = fv.get_declaring_config(config[CONF_BMI270_ID])
+    full_config = fv.full_config.get()
+    bmi270_path = full_config.get_path_for_id(config[CONF_BMI270_ID])[:-1]
+    bmi270_config = full_config.get_config_for_path(bmi270_path)
    if bmi270_config.get(CONF_AUX_DEVICE) != "BMM150":
        raise cv.Invalid(
            "This sensor requires the parent bmi270's 'aux_device' to be set to 'BMM150'",
@@ -80,8 +80,7 @@ void BP1658CJ::loop() {
  this->update_ = false;
 }

-void BP1658CJ::write_channel(uint8_t channel, float state) {
-  auto value = static_cast<uint16_t>(state * 0x3FF);
+void BP1658CJ::set_channel_value_(uint8_t channel, uint16_t value) {
  if (this->pwm_amounts_[channel] != value) {
    this->update_ = true;
    this->update_channel_ = channel;
@@ -2,12 +2,15 @@

 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
+#include "esphome/components/output/float_output.h"
 #include <vector>

 namespace esphome::bp1658cj {

 class BP1658CJ final : public Component {
 public:
+  class Channel;
+
  void set_data_pin(GPIOPin *data_pin) { data_pin_ = data_pin; }
  void set_clock_pin(GPIOPin *clock_pin) { clock_pin_ = clock_pin; }
  void set_max_power_color_channels(uint8_t max_power_color_channels) {
@@ -26,9 +29,23 @@ class BP1658CJ final : public Component {
  /// Send new values if they were updated.
  void loop() override;

-  void write_channel(uint8_t channel, float state);
+  class Channel final : public output::FloatOutput {
+   public:
+    void set_parent(BP1658CJ *parent) { parent_ = parent; }
+    void set_channel(uint8_t channel) { channel_ = channel; }
+
+   protected:
+    void write_state(float state) override {
+      auto amount = static_cast<uint16_t>(state * 0x3FF);
+      this->parent_->set_channel_value_(this->channel_, amount);
+    }
+
+    BP1658CJ *parent_;
+    uint8_t channel_;
+  };

 protected:
+  void set_channel_value_(uint8_t channel, uint16_t value);
  void write_bit_(bool value);
  void write_byte_(uint8_t data);
  void write_buffer_(uint8_t *buffer, uint8_t size);
@@ -1,3 +1,4 @@
+import esphome.codegen as cg
 from esphome.components import output
 import esphome.config_validation as cv
 from esphome.const import CONF_CHANNEL, CONF_ID
@@ -7,15 +8,16 @@ from . import BP1658CJ

 DEPENDENCIES = ["bp1658cj"]

+Channel = BP1658CJ.class_("Channel", output.FloatOutput)

 CONF_BP1658CJ_ID = "bp1658cj_id"
 CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
    {
        cv.GenerateID(CONF_BP1658CJ_ID): cv.use_id(BP1658CJ),
-        cv.Required(CONF_ID): cv.declare_id(output.ApplyFloatOutput),
+        cv.Required(CONF_ID): cv.declare_id(Channel),
        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=4),
    }
-)
+).extend(cv.COMPONENT_SCHEMA)


 FINAL_VALIDATE_SCHEMA = output.final_validate_unique_channel(
@@ -24,6 +26,8 @@ FINAL_VALIDATE_SCHEMA = output.final_validate_unique_channel(


 async def to_code(config: ConfigType) -> None:
-    await output.sub_float_outputs(config, parent=config[CONF_BP1658CJ_ID]).create(
-        config, None, config[CONF_CHANNEL], apply="write_channel(index, state)"
-    )
+    var = cg.new_Pvariable(config[CONF_ID])
+    await output.register_output(var, config)
+
+    await cg.register_parented(var, config[CONF_BP1658CJ_ID])
+    cg.add(var.set_channel(config[CONF_CHANNEL]))
@@ -7,7 +7,6 @@ from esphome.components import i2c
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_UPDATE_INTERVAL, CONF_WATCHDOG
 from esphome.core import CORE, ID, EsphomeError, Lambda, TimePeriod
-import esphome.final_validate as fv
 from esphome.types import ConfigType, TemplateArgsType

 CODEOWNERS = ["@Rapsssito"]
@@ -360,7 +359,8 @@ async def bq25186_configure_to_code(
    parent = await cg.get_variable(config[CONF_ID])

    # Options the action leaves out fall back to the component's configuration
-    parent_config = fv.get_declaring_config(config[CONF_ID], CORE.config)
+    path = CORE.config.get_path_for_id(config[CONF_ID])[:-1]
+    parent_config = CORE.config.get_config_for_path(path)
    merged = {**parent_config, **config}
    try:
        _check_watchdog(merged)
@@ -28,10 +28,13 @@ bool BQ25186Component::write_register_(uint8_t reg, uint8_t value) {
 }

 bool BQ25186Component::update_register_(uint8_t reg, uint8_t mask, uint8_t value) {
-  if (this->update_register(reg, mask, value))
-    return true;
-  ESP_LOGW(TAG, "Failed to update register 0x%02X", reg);
-  return false;
+  uint8_t reg_value;
+  if (!this->read_byte(reg, &reg_value)) {
+    ESP_LOGW(TAG, "Failed to read register 0x%02X", reg);
+    return false;
+  }
+  reg_value = (reg_value & ~mask) | (value & mask);
+  return this->write_register_(reg, reg_value);
 }

 uint8_t BQ25186Component::expected_register_(size_t index) const {
@@ -71,12 +71,12 @@ class BQ25186Component : public PollingComponent, public i2c::I2CDevice {

 protected:
  bool write_register_(uint8_t reg, uint8_t value);
-  bool update_register_(uint8_t reg, uint8_t mask, uint8_t value);
  uint8_t expected_register_(size_t index) const;
  bool config_matches_(const BQ25186StatusRegisters &regs) const;
 #ifdef USE_BQ25186_PG_GPO
  void check_pg_gpo_(const BQ25186StatusRegisters &status, bool &pending);
 #endif
+  bool update_register_(uint8_t reg, uint8_t mask, uint8_t value);

 #ifdef BQ25186_BINARY_SENSOR_COUNT
  StaticVector<BQ25186BinarySensor *, BQ25186_BINARY_SENSOR_COUNT> binary_sensors_;
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_BUTTON
+
+#include "bq25186.h"
+#include "esphome/components/button/button.h"
+
+namespace esphome::bq25186 {
+
+/// Writes one SHIP_RST field when pressed
+class BQ25186Button final : public button::Button, public Parented<BQ25186Component> {
+ public:
+  BQ25186Button(uint8_t mask, uint8_t value) : mask_(mask), value_(value) {}
+
+ protected:
+  void press_action() override { this->parent_->write_ship_rst(this->mask_, this->value_); }
+
+  const uint8_t mask_;
+  const uint8_t value_;
+};
+
+}  // namespace esphome::bq25186
+
+#endif  // USE_BUTTON
@@ -14,7 +14,11 @@ void BQ25186TextSensor::on_status(const BQ25186StatusRegisters &status) {
  if (value == this->last_)
    return;
  this->last_ = value;
-  this->publish_state(StatusStrings::get_progmem_str(this->first_ + value, StatusStrings::LAST_INDEX));
+  const ProgmemStr name = StatusStrings::get_progmem_str(this->first_ + value, StatusStrings::LAST_INDEX);
+  char text[32];
+  ESPHOME_strncpy_P(text, reinterpret_cast<ESPHOME_PGM_P>(name), sizeof(text));
+  text[sizeof(text) - 1] = '\0';
+  this->publish_state(text);
 }

 }  // namespace esphome::bq25186
@@ -1,3 +1,4 @@
+import esphome.codegen as cg
 from esphome.components import button
 import esphome.config_validation as cv
 from esphome.const import (
@@ -9,10 +10,11 @@ from esphome.const import (
 )
 from esphome.types import ConfigType

-from . import BQ25186_CHILD_SCHEMA, CONF_BQ25186_ID
+from . import BQ25186_CHILD_SCHEMA, CONF_BQ25186_ID, bq25186_ns

 DEPENDENCIES = ["bq25186"]

+BQ25186Button = bq25186_ns.class_("BQ25186Button", button.Button)

 # SHIP_RST: bit 7 is the software reset, bits 6:5 the shutdown, ship and hardware reset codes
 SOFTWARE_RESET_MASK = 0x80
@@ -31,7 +33,7 @@ CONFIG_SCHEMA = cv.All(
    BQ25186_CHILD_SCHEMA.extend(
        {
            cv.Optional(key): button.button_schema(
-                button.ApplyButton,
+                BQ25186Button,
                entity_category=ENTITY_CATEGORY_CONFIG,
                icon=icon,
                device_class=device_class,
@@ -44,6 +46,7 @@ CONFIG_SCHEMA = cv.All(


 async def to_code(config: ConfigType) -> None:
-    buttons = button.sub_buttons(config, parent=config[CONF_BQ25186_ID])
    for key, mask, value, _, _ in _BUTTONS:
-        await buttons(key, None, apply=f"write_ship_rst({mask:#04x}, {value:#04x})")
+        if (conf := config.get(key)) is not None:
+            var = await button.new_button(conf, mask, value)
+            await cg.register_parented(var, config[CONF_BQ25186_ID])
@@ -1,6 +1,7 @@
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
+from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_DEVICE_CLASS,
@@ -9,6 +10,7 @@ from esphome.const import (
    CONF_ID,
    CONF_MQTT_ID,
    CONF_ON_PRESS,
+    CONF_WEB_SERVER,
    DEVICE_CLASS_EMPTY,
    DEVICE_CLASS_IDENTIFY,
    DEVICE_CLASS_RESTART,
@@ -19,12 +21,11 @@ from esphome.const import (
    ICON_RESTART,
    ICON_RESTART_ALERT,
 )
-from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority, entity_helpers
+from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    ApplyEntity,
    SubEntities,
    entity_duplicate_validator,
-    mqtt_component_class,
    queue_entity_register,
    setup_device_class,
    setup_entity,
@@ -52,13 +53,11 @@ validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True, space="_")


 _BUTTON_SCHEMA = (
-    cv.ENTITY_BASE_SCHEMA.extend(entity_helpers.WEBSERVER_SORTING_SCHEMA)
+    cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
    .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
    .extend(
        {
-            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTButtonComponent")
-            ),
+            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTButtonComponent),
            cv.Optional(
                CONF_DEVICE_CLASS, visibility=cv.Visibility.ADVANCED
            ): validate_device_class,
@@ -136,7 +135,12 @@ async def setup_button_core_(var: MockObj, config: ConfigType) -> None:

    setup_device_class(config)

-    await entity_helpers.setup_entity_integrations(var, config)
+    if mqtt_id := config.get(CONF_MQTT_ID):
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)


 async def register_button(var: MockObj, config: ConfigType) -> None:
@@ -42,8 +42,10 @@ void CAP1188Component::finish_setup_() {
  }

  // Set sensitivity
-  // The threshold replaces the upper nibble and is ORed into the lower one, as before
-  this->update_register(CAP1188_SENSITVITY, 0xF0 | this->touch_threshold_, this->touch_threshold_);
+  uint8_t sensitivity = 0;
+  this->read_byte(CAP1188_SENSITVITY, &sensitivity);
+  sensitivity = sensitivity & 0x0f;
+  this->write_byte(CAP1188_SENSITVITY, sensitivity | this->touch_threshold_);

  // Allow multiple touches
  this->write_byte(CAP1188_MULTI_TOUCH, this->allow_multiple_touches_);
@@ -3,6 +3,7 @@ from typing import Any

 from esphome import automation
 import esphome.codegen as cg
+from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ACTION_STATE_TOPIC,
@@ -48,15 +49,15 @@ from esphome.const import (
    CONF_TEMPERATURE_STEP,
    CONF_UNIT_OF_MEASUREMENT,
    CONF_VISUAL,
+    CONF_WEB_SERVER,
    UNIT_KELVIN,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority, entity_helpers
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    TemperatureUnitResolver,
    convert_visual_temperatures,
    declare_fixed_temperature_unit,
    entity_duplicate_validator,
-    mqtt_component_class,
    queue_entity_register,
    setup_entity,
    setup_entity_temperature_unit,
@@ -176,13 +177,11 @@ _visual_temperatures_in_entity_unit = partial(


 _CLIMATE_SCHEMA = (
-    cv.ENTITY_BASE_SCHEMA.extend(entity_helpers.WEBSERVER_SORTING_SCHEMA)
+    cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
    .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
    .extend(
        {
-            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTClimateComponent")
-            ),
+            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTClimateComponent),
            cv.Optional(CONF_VISUAL, default={}): cv.Schema(
                {
                    cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature_with_unit,
@@ -354,8 +353,10 @@ async def setup_climate_core_(var: MockObj, config: ConfigType) -> None:
        cg.add(var.set_visual_max_humidity_override(max_humidity))
    setup_entity_temperature_unit(var, config)

-    mqtt_ = await entity_helpers.setup_entity_integrations(var, config)
-    if mqtt_ is not None:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+
        if (action_state_topic := config.get(CONF_ACTION_STATE_TOPIC)) is not None:
            cg.add(mqtt_.set_custom_action_state_topic(action_state_topic))
        if (away_command_topic := config.get(CONF_AWAY_COMMAND_TOPIC)) is not None:
@@ -485,6 +486,9 @@ async def setup_climate_core_(var: MockObj, config: ConfigType) -> None:

    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)

+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
+

 def set_custom_fan_modes(var: MockObj, modes: list[str]) -> None:
    """Point the climate at a shared flash table of custom fan modes."""
@@ -13,10 +13,19 @@ from esphome.const import (
 from esphome.core.entity_helpers import inherit_property_from
 from esphome.types import ConfigType

-CONFIG_SCHEMA = sensor.sensor_schema(sensor.Sensor).extend(
-    {
-        cv.Required(CONF_SOURCE_ID): cv.use_id(sensor.Sensor),
-    }
+from .. import copy_ns
+
+CopySensor = copy_ns.class_("CopySensor", sensor.Sensor, cg.Component)
+
+
+CONFIG_SCHEMA = (
+    sensor.sensor_schema(CopySensor)
+    .extend(
+        {
+            cv.Required(CONF_SOURCE_ID): cv.use_id(sensor.Sensor),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
 )

 FINAL_VALIDATE_SCHEMA = cv.All(
@@ -31,4 +40,6 @@ FINAL_VALIDATE_SCHEMA = cv.All(

 async def to_code(config: ConfigType) -> None:
    var = await sensor.new_sensor(config)
-    sensor.follow_sensor(var, await cg.get_variable(config[CONF_SOURCE_ID]))
+    await cg.register_component(var, config)
+
+    await cg.add_variable(var.set_source, config[CONF_SOURCE_ID])
@@ -0,0 +1,16 @@
+#include "copy_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::copy {
+
+ESPHOME_LOG_TAG(TAG, "copy.sensor");
+
+void CopySensor::setup() {
+  source_->add_on_state_callback([this](float value) { this->publish_state(value); });
+  if (source_->has_state())
+    this->publish_state(source_->state);
+}
+
+void CopySensor::dump_config() { LOG_SENSOR("", "Copy Sensor", this); }
+
+}  // namespace esphome::copy
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/sensor/sensor.h"
+
+namespace esphome::copy {
+
+class CopySensor final : public sensor::Sensor, public Component {
+ public:
+  void set_source(sensor::Sensor *source) { source_ = source; }
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  sensor::Sensor *source_;
+};
+
+}  // namespace esphome::copy
@@ -5,10 +5,19 @@ from esphome.const import CONF_ENTITY_CATEGORY, CONF_ICON, CONF_SOURCE_ID
 from esphome.core.entity_helpers import inherit_property_from
 from esphome.types import ConfigType

-CONFIG_SCHEMA = text_sensor.text_sensor_schema(text_sensor.TextSensor).extend(
-    {
-        cv.Required(CONF_SOURCE_ID): cv.use_id(text_sensor.TextSensor),
-    }
+from .. import copy_ns
+
+CopyTextSensor = copy_ns.class_("CopyTextSensor", text_sensor.TextSensor, cg.Component)
+
+
+CONFIG_SCHEMA = (
+    text_sensor.text_sensor_schema(CopyTextSensor)
+    .extend(
+        {
+            cv.Required(CONF_SOURCE_ID): cv.use_id(text_sensor.TextSensor),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
 )

 FINAL_VALIDATE_SCHEMA = cv.All(
@@ -19,4 +28,6 @@ FINAL_VALIDATE_SCHEMA = cv.All(

 async def to_code(config: ConfigType) -> None:
    var = await text_sensor.new_text_sensor(config)
-    text_sensor.follow_text_sensor(var, await cg.get_variable(config[CONF_SOURCE_ID]))
+    await cg.register_component(var, config)
+
+    await cg.add_variable(var.set_source, config[CONF_SOURCE_ID])
@@ -0,0 +1,16 @@
+#include "copy_text_sensor.h"
+#include "esphome/core/log.h"
+
+namespace esphome::copy {
+
+ESPHOME_LOG_TAG(TAG, "copy.text_sensor");
+
+void CopyTextSensor::setup() {
+  source_->add_on_state_callback([this](const std::string &value) { this->publish_state(value); });
+  if (source_->has_state())
+    this->publish_state(source_->state);
+}
+
+void CopyTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Copy Sensor", this); }
+
+}  // namespace esphome::copy
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/text_sensor/text_sensor.h"
+
+namespace esphome::copy {
+
+class CopyTextSensor final : public text_sensor::TextSensor, public Component {
+ public:
+  void set_source(text_sensor::TextSensor *source) { source_ = source; }
+  void setup() override;
+  void dump_config() override;
+
+ protected:
+  text_sensor::TextSensor *source_;
+};
+
+}  // namespace esphome::copy
@@ -3,6 +3,7 @@ import logging
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
+from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_DEVICE_CLASS,
@@ -22,6 +23,7 @@ from esphome.const import (
    CONF_TILT_COMMAND_TOPIC,
    CONF_TILT_STATE_TOPIC,
    CONF_TRIGGER_ID,
+    CONF_WEB_SERVER,
    DEVICE_CLASS_AWNING,
    DEVICE_CLASS_BLIND,
    DEVICE_CLASS_CURTAIN,
@@ -34,10 +36,9 @@ from esphome.const import (
    DEVICE_CLASS_SHUTTER,
    DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority, entity_helpers
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
-    mqtt_component_class,
    queue_entity_register,
    setup_device_class,
    setup_entity,
@@ -111,13 +112,11 @@ TRIGGERS = {


 _COVER_SCHEMA = (
-    cv.ENTITY_BASE_SCHEMA.extend(entity_helpers.WEBSERVER_SORTING_SCHEMA)
+    cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
    .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
    .extend(
        {
-            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTCoverComponent")
-            ),
+            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTCoverComponent),
            cv.Optional(CONF_MQTT_JSON_STATE_PAYLOAD): cv.All(
                cv.requires_component("mqtt"), cv.boolean
            ),
@@ -203,8 +202,10 @@ async def setup_cover_core_(var: MockObj, config: ConfigType) -> None:
            trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
            await automation.build_automation(trigger, [], conf)

-    mqtt_ = await entity_helpers.setup_entity_integrations(var, config)
-    if mqtt_ is not None:
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+
        if (position_state_topic := config.get(CONF_POSITION_STATE_TOPIC)) is not None:
            cg.add(mqtt_.set_custom_position_state_topic(position_state_topic))
        if (
@@ -219,6 +220,9 @@ async def setup_cover_core_(var: MockObj, config: ConfigType) -> None:
        if (tilt_command_topic := config.get(CONF_TILT_COMMAND_TOPIC)) is not None:
            cg.add(mqtt_.set_custom_tilt_command_topic(tilt_command_topic))

+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
+

 async def register_cover(var: MockObj, config: ConfigType) -> None:
    if not CORE.has_id(config[CONF_ID]):
@@ -28,23 +28,30 @@ void CSE7766Component::loop() {

  // Read all available bytes in batches to reduce UART call overhead.
  // At 4800 baud (~480 bytes/sec) with ~122 Hz loop rate, typically ~4 bytes per call.
-  this->read_available<CSE7766_RAW_DATA_SIZE>(
-      [this](uint8_t byte) {
-        this->raw_data_[this->raw_data_index_] = byte;
-        if (!this->check_byte_()) {
-          this->raw_data_index_ = 0;
-          this->status_set_warning();
-          return;
-        }
+  uint8_t buf[CSE7766_RAW_DATA_SIZE];
+  while (avail > 0) {
+    size_t to_read = std::min(avail, sizeof(buf));
+    if (!this->read_array(buf, to_read)) {
+      break;
+    }
+    avail -= to_read;

-        if (this->raw_data_index_ == CSE7766_RAW_DATA_SIZE - 1) {
-          this->parse_data_();
-          this->status_clear_warning();
-        }
+    for (size_t i = 0; i < to_read; i++) {
+      this->raw_data_[this->raw_data_index_] = buf[i];
+      if (!this->check_byte_()) {
+        this->raw_data_index_ = 0;
+        this->status_set_warning();
+        continue;
+      }

-        this->raw_data_index_ = (this->raw_data_index_ + 1) % CSE7766_RAW_DATA_SIZE;
-      },
-      avail);
+      if (this->raw_data_index_ == CSE7766_RAW_DATA_SIZE - 1) {
+        this->parse_data_();
+        this->status_clear_warning();
+      }
+
+      this->raw_data_index_ = (this->raw_data_index_ + 1) % CSE7766_RAW_DATA_SIZE;
+    }
+  }
 }

 bool CSE7766Component::check_byte_() {
@@ -163,21 +163,26 @@ void CW2017::update() {
  if (!this->ready_)
    return;

-  bool ok = true;
  if (this->battery_level_sensor_ != nullptr) {
    uint8_t soc = 0;
-    ok = this->read_byte(REG_SOC, &soc) && soc <= 100;
-    if (ok)
+    if (this->read_byte(REG_SOC, &soc) && soc <= 100) {
      this->battery_level_sensor_->publish_state(soc);
+    } else {
+      this->status_set_warning();
+      return;
+    }
  }

-  if (ok && this->battery_voltage_sensor_ != nullptr) {
+  if (this->battery_voltage_sensor_ != nullptr) {
    uint16_t raw = 0;
-    ok = this->read_byte_16(REG_VCELL, &raw);
-    if (ok)
+    if (this->read_byte_16(REG_VCELL, &raw)) {
      this->battery_voltage_sensor_->publish_state((raw & VCELL_MASK) * VCELL_VOLTS_PER_LSB);
+    } else {
+      this->status_set_warning();
+      return;
+    }
  }
-  this->status_comm_result(ok);
+  this->status_clear_warning();
 }

 void CW2017::dump_config() {
@@ -12,8 +12,8 @@ class CW2017 : public PollingComponent, public i2c::I2CDevice {
 public:
  explicit CW2017(const uint8_t *profile) : profile_(profile) {}

-  SUB_SENSOR(battery_level)
-  SUB_SENSOR(battery_voltage)
+  void set_battery_level_sensor(sensor::Sensor *sensor) { this->battery_level_sensor_ = sensor; }
+  void set_battery_voltage_sensor(sensor::Sensor *sensor) { this->battery_voltage_sensor_ = sensor; }

  void setup() override;
  void update() override;
@@ -29,6 +29,8 @@ class CW2017 : public PollingComponent, public i2c::I2CDevice {
  void wait_ready_(uint8_t attempt);

  const uint8_t *profile_;
+  sensor::Sensor *battery_level_sensor_{nullptr};
+  sensor::Sensor *battery_voltage_sensor_{nullptr};
  bool ready_{false};
  bool restart_pending_{false};
  uint8_t init_attempts_{0};
@@ -48,14 +48,15 @@ void DAC7678Output::dump_config() {
  }
 }

-void DAC7678Output::register_channel(uint8_t channel) {
-  this->min_channel_ = std::min(this->min_channel_, channel);
-  this->max_channel_ = std::max(this->max_channel_, channel);
-  ESP_LOGV(TAG, "Registered channel: %01u", channel);
+void DAC7678Output::register_channel(DAC7678Channel *channel) {
+  auto c = channel->channel_;
+  this->min_channel_ = std::min(this->min_channel_, c);
+  this->max_channel_ = std::max(this->max_channel_, c);
+  channel->set_parent(this);
+  ESP_LOGV(TAG, "Registered channel: %01u", channel->channel_);
 }

-void DAC7678Output::write_channel(uint8_t channel, float state) {
-  auto value = static_cast<uint16_t>(roundf(state * 0xFFF));
+void DAC7678Output::set_channel_value_(uint8_t channel, uint16_t value) {
  if (channel >= std::size(this->dac_input_reg_))
    return;
  if (this->dac_input_reg_[channel] != value) {
@@ -70,4 +71,10 @@ void DAC7678Output::write_channel(uint8_t channel, float state) {
  this->status_clear_warning();
 }

+void DAC7678Channel::write_state(float state) {
+  const float input_rounded = roundf(state * this->full_scale_);
+  auto input = static_cast<uint16_t>(input_rounded);
+  this->parent_->set_channel_value_(this->channel_, input);
+}
+
 }  // namespace esphome::dac7678
@@ -1,17 +1,34 @@
 #pragma once

 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/output/float_output.h"
 #include "esphome/components/i2c/i2c.h"

 namespace esphome::dac7678 {

+class DAC7678Output;
+
+class DAC7678Channel final : public output::FloatOutput, public Parented<DAC7678Output> {
+ public:
+  void set_channel(uint8_t channel) { channel_ = channel; }
+
+ protected:
+  friend class DAC7678Output;
+
+  const uint16_t full_scale_ = 0xFFF;
+
+  void write_state(float state) override;
+
+  uint8_t channel_;
+};
+
 /// DAC7678 float output component.
 class DAC7678Output final : public Component, public i2c::I2CDevice {
 public:
  DAC7678Output() {}

-  void register_channel(uint8_t channel);
-  void write_channel(uint8_t channel, float state);
+  void register_channel(DAC7678Channel *channel);

  void set_internal_reference(const bool value) { this->internal_reference_ = value; }

@@ -20,8 +37,12 @@ class DAC7678Output final : public Component, public i2c::I2CDevice {
  float get_setup_priority() const override { return setup_priority::HARDWARE; }

 protected:
+  friend DAC7678Channel;
+
  bool internal_reference_;

+  void set_channel_value_(uint8_t channel, uint16_t value);
+
  uint8_t min_channel_{0xFF};
  uint8_t max_channel_{0x00};
  uint16_t dac_input_reg_[8] = {
@@ -2,17 +2,19 @@ import esphome.codegen as cg
 from esphome.components import output
 import esphome.config_validation as cv
 from esphome.const import CONF_CHANNEL, CONF_ID
+from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType

-from . import DAC7678Output
+from . import DAC7678Output, dac7678_ns

 DEPENDENCIES = ["dac7678"]

+DAC7678Channel = dac7678_ns.class_("DAC7678Channel", output.FloatOutput)
 CONF_DAC7678_ID = "dac7678_id"

 CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
    {
-        cv.Required(CONF_ID): cv.declare_id(output.ApplyFloatOutput),
+        cv.Required(CONF_ID): cv.declare_id(DAC7678Channel),
        cv.GenerateID(CONF_DAC7678_ID): cv.use_id(DAC7678Output),
        cv.Required(CONF_CHANNEL): cv.int_range(min=0, max=7),
    }
@@ -24,9 +26,10 @@ FINAL_VALIDATE_SCHEMA = output.final_validate_unique_channel(
 )


-async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_DAC7678_ID])
-    await output.sub_float_outputs(config, parent=hub).create(
-        config, None, config[CONF_CHANNEL], apply="write_channel(index, state)"
-    )
-    cg.add(hub.register_channel(config[CONF_CHANNEL]))
+async def to_code(config: ConfigType) -> MockObj:
+    paren = await cg.get_variable(config[CONF_DAC7678_ID])
+    var = cg.new_Pvariable(config[CONF_ID])
+    cg.add(var.set_channel(config[CONF_CHANNEL]))
+    cg.add(paren.register_channel(var))
+    await output.register_output(var, config)
+    return var
@@ -2,6 +2,7 @@ from collections.abc import Callable

 from esphome import automation
 import esphome.codegen as cg
+from esphome.components import mqtt, time, web_server
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_DATE,
@@ -19,12 +20,12 @@ from esphome.const import (
    CONF_TIME_ID,
    CONF_TRIGGER_ID,
    CONF_TYPE,
+    CONF_WEB_SERVER,
    CONF_YEAR,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority, entity_helpers
+from esphome.core import CORE, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import (
    entity_duplicate_validator,
-    mqtt_component_class,
    queue_entity_register,
    setup_entity,
 )
@@ -37,10 +38,6 @@ DOMAIN = "datetime"
 IS_PLATFORM_COMPONENT = True

 datetime_ns = cg.esphome_ns.namespace("datetime")
-# Matches time.RealTimeClock by name without importing the time component
-_RealTimeClock = cg.esphome_ns.namespace("time").class_(
-    "RealTimeClock", cg.PollingComponent
-)
 DateTimeBase = datetime_ns.class_("DateTimeBase", cg.EntityBase)
 DateEntity = datetime_ns.class_("DateEntity", DateTimeBase)
 TimeEntity = datetime_ns.class_("TimeEntity", DateTimeBase)
@@ -67,7 +64,7 @@ DATETIME_MODES = [
 def _validate_time_present(config: ConfigType) -> ConfigType:
    config = config.copy()
    if CONF_ON_TIME in config and CONF_TIME_ID not in config:
-        time_id = cv.use_id(_RealTimeClock)(None)
+        time_id = cv.use_id(time.RealTimeClock)(None)
        config[CONF_TIME_ID] = time_id
    return config

@@ -76,10 +73,10 @@ _DATETIME_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
    cv.Schema(
        {
            cv.Optional(CONF_ON_VALUE): automation.validate_automation({}),
-            cv.Optional(CONF_TIME_ID): cv.use_id(_RealTimeClock),
+            cv.Optional(CONF_TIME_ID): cv.use_id(time.RealTimeClock),
        }
    )
-    .extend(entity_helpers.WEBSERVER_SORTING_SCHEMA)
+    .extend(web_server.WEBSERVER_SORTING_SCHEMA)
    .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
 ).add_extra(_validate_time_present)

@@ -90,9 +87,7 @@ def date_schema(class_: MockObjClass) -> cv.Schema:
    schema = cv.Schema(
        {
            cv.GenerateID(): cv.declare_id(class_),
-            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTDateComponent")
-            ),
+            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTDateComponent),
            cv.Optional(CONF_TYPE, default="DATE"): cv.one_of("DATE", upper=True),
        }
    )
@@ -103,9 +98,7 @@ def time_schema(class_: MockObjClass) -> cv.Schema:
    schema = cv.Schema(
        {
            cv.GenerateID(): cv.declare_id(class_),
-            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTTimeComponent")
-            ),
+            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTTimeComponent),
            cv.Optional(CONF_TYPE, default="TIME"): cv.one_of("TIME", upper=True),
            cv.Optional(CONF_ON_TIME): automation.validate_automation(
                {
@@ -122,7 +115,7 @@ def datetime_schema(class_: MockObjClass) -> cv.Schema:
        {
            cv.GenerateID(): cv.declare_id(class_),
            cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
-                mqtt_component_class("MQTTDateTimeComponent")
+                mqtt.MQTTDateTimeComponent
            ),
            cv.Optional(CONF_TYPE, default="DATETIME"): cv.one_of(
                "DATETIME", upper=True
@@ -139,7 +132,11 @@ def datetime_schema(class_: MockObjClass) -> cv.Schema:

@setup_entity("datetime")
 async def setup_datetime_core_(var: MockObj, config: ConfigType) -> None:
-    await entity_helpers.setup_entity_integrations(var, config)
+    if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
+        mqtt_ = cg.new_Pvariable(mqtt_id, var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
    # The state callback carries nothing; the automation gets the value as an ESPTime.
    for conf in config.get(CONF_ON_VALUE, []):
        await automation.build_callback_automation(
@@ -135,140 +135,153 @@ void DFPlayer::send_cmd_(uint8_t cmd, uint16_t argument) {
 }

 void DFPlayer::loop() {
-  this->read_available([this](uint8_t byte) {
-    if (this->read_pos_ == DFPLAYER_READ_BUFFER_LENGTH)
-      this->read_pos_ = 0;
-
-    switch (this->read_pos_) {
-      case 0:  // Start mark
-        if (byte != 0x7E)
-          return;
-        break;
-      case 1:  // Version
-        if (byte != 0xFF) {
-          ESP_LOGW(TAG, "Expected Version 0xFF, got %#02x", byte);
-          this->read_pos_ = 0;
-          return;
-        }
-        break;
-      case 2:  // Buffer length
-        if (byte != 0x06) {
-          ESP_LOGW(TAG, "Expected Buffer length 0x06, got %#02x", byte);
-          this->read_pos_ = 0;
-          return;
-        }
-        break;
-      case 9:  // End byte
-#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
-        char byte_sequence[100];
-        byte_sequence[0] = '\0';
-        for (size_t i = 0; i < this->read_pos_ + 1; ++i) {
-          snprintf(byte_sequence + strlen(byte_sequence), sizeof(byte_sequence) - strlen(byte_sequence), "%02X ",
-                   this->read_buffer_[i]);
-        }
-        ESP_LOGVV(TAG, "Received byte sequence: %s", byte_sequence);
-#endif
-        if (byte != 0xEF) {
-          ESP_LOGW(TAG, "Expected end byte 0xEF, got %#02x", byte);
-          this->read_pos_ = 0;
-          return;
-        }
-        // Parse valid received command
-        uint8_t cmd = this->read_buffer_[3];
-        uint16_t argument = (this->read_buffer_[5] << 8) | this->read_buffer_[6];
-
-        ESP_LOGV(TAG, "Received message cmd: %#02x arg %#04x", cmd, argument);
-
-        switch (cmd) {
-          case 0x3A:
-            if (argument == 1) {
-              ESP_LOGI(TAG, "USB loaded");
-            } else if (argument == 2) {
-              ESP_LOGI(TAG, "TF Card loaded");
-            }
-            break;
-          case 0x3B:
-            if (argument == 1) {
-              ESP_LOGI(TAG, "USB unloaded");
-            } else if (argument == 2) {
-              ESP_LOGI(TAG, "TF Card unloaded");
-            }
-            break;
-          case 0x3F:
-            if (argument == 1) {
-              ESP_LOGI(TAG, "USB available");
-            } else if (argument == 2) {
-              ESP_LOGI(TAG, "TF Card available");
-            } else if (argument == 3) {
-              ESP_LOGI(TAG, "USB, TF Card available");
-            }
-            break;
-          case 0x40:
-            ESP_LOGV(TAG, "Nack");
-            this->ack_set_is_playing_ = false;
-            this->ack_reset_is_playing_ = false;
-            switch (argument) {
-              case 0x01:
-                ESP_LOGE(TAG, "Module is busy or uninitialized");
-                break;
-              case 0x02:
-                ESP_LOGE(TAG, "Module is in sleep mode");
-                break;
-              case 0x03:
-                ESP_LOGE(TAG, "Serial receive error");
-                break;
-              case 0x04:
-                ESP_LOGE(TAG, "Checksum incorrect");
-                break;
-              case 0x05:
-                ESP_LOGE(TAG, "Specified track is out of current track scope");
-                this->is_playing_ = false;
-                break;
-              case 0x06:
-                ESP_LOGE(TAG, "Specified track is not found");
-                this->is_playing_ = false;
-                break;
-              case 0x07:
-                ESP_LOGE(TAG, "Insertion error (an inserting operation only can be done when a track is being played)");
-                break;
-              case 0x08:
-                ESP_LOGE(TAG, "SD card reading failed (SD card pulled out or damaged)");
-                break;
-              case 0x09:
-                ESP_LOGE(TAG, "Entered into sleep mode");
-                this->is_playing_ = false;
-                break;
-              default:
-                break;
-            }
-            break;
-          case 0x41:
-            ESP_LOGV(TAG, "Ack ok");
-            this->is_playing_ |= this->ack_set_is_playing_;
-            this->is_playing_ &= !this->ack_reset_is_playing_;
-            this->ack_set_is_playing_ = false;
-            this->ack_reset_is_playing_ = false;
-            break;
-          case 0x3C:
-            ESP_LOGV(TAG, "Playback finished (USB drive)");
-            this->is_playing_ = false;
-            this->on_finished_playback_callback_.call();
-            break;
-          case 0x3D:
-            ESP_LOGV(TAG, "Playback finished (SD card)");
-            this->is_playing_ = false;
-            this->on_finished_playback_callback_.call();
-            break;
-          default:
-            ESP_LOGE(TAG, "Received unknown cmd %#02x arg %#04x", cmd, argument);
-        }
-        this->sent_cmd_ = 0;
-        this->read_pos_ = 0;
-        return;
+  // Read all available bytes in batches to reduce UART call overhead.
+  size_t avail = this->available();
+  uint8_t buf[64];
+  while (avail > 0) {
+    size_t to_read = std::min(avail, sizeof(buf));
+    if (!this->read_array(buf, to_read)) {
+      break;
    }
-    this->read_buffer_[this->read_pos_] = byte;
-    this->read_pos_++;
-  });
+    avail -= to_read;
+    for (size_t bi = 0; bi < to_read; bi++) {
+      uint8_t byte = buf[bi];
+
+      if (this->read_pos_ == DFPLAYER_READ_BUFFER_LENGTH)
+        this->read_pos_ = 0;
+
+      switch (this->read_pos_) {
+        case 0:  // Start mark
+          if (byte != 0x7E)
+            continue;
+          break;
+        case 1:  // Version
+          if (byte != 0xFF) {
+            ESP_LOGW(TAG, "Expected Version 0xFF, got %#02x", byte);
+            this->read_pos_ = 0;
+            continue;
+          }
+          break;
+        case 2:  // Buffer length
+          if (byte != 0x06) {
+            ESP_LOGW(TAG, "Expected Buffer length 0x06, got %#02x", byte);
+            this->read_pos_ = 0;
+            continue;
+          }
+          break;
+        case 9:  // End byte
+#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
+          char byte_sequence[100];
+          byte_sequence[0] = '\0';
+          for (size_t i = 0; i < this->read_pos_ + 1; ++i) {
+            snprintf(byte_sequence + strlen(byte_sequence), sizeof(byte_sequence) - strlen(byte_sequence), "%02X ",
+                     this->read_buffer_[i]);
+          }
+          ESP_LOGVV(TAG, "Received byte sequence: %s", byte_sequence);
+#endif
+          if (byte != 0xEF) {
+            ESP_LOGW(TAG, "Expected end byte 0xEF, got %#02x", byte);
+            this->read_pos_ = 0;
+            continue;
+          }
+          // Parse valid received command
+          uint8_t cmd = this->read_buffer_[3];
+          uint16_t argument = (this->read_buffer_[5] << 8) | this->read_buffer_[6];
+
+          ESP_LOGV(TAG, "Received message cmd: %#02x arg %#04x", cmd, argument);
+
+          switch (cmd) {
+            case 0x3A:
+              if (argument == 1) {
+                ESP_LOGI(TAG, "USB loaded");
+              } else if (argument == 2) {
+                ESP_LOGI(TAG, "TF Card loaded");
+              }
+              break;
+            case 0x3B:
+              if (argument == 1) {
+                ESP_LOGI(TAG, "USB unloaded");
+              } else if (argument == 2) {
+                ESP_LOGI(TAG, "TF Card unloaded");
+              }
+              break;
+            case 0x3F:
+              if (argument == 1) {
+                ESP_LOGI(TAG, "USB available");
+              } else if (argument == 2) {
+                ESP_LOGI(TAG, "TF Card available");
+              } else if (argument == 3) {
+                ESP_LOGI(TAG, "USB, TF Card available");
+              }
+              break;
+            case 0x40:
+              ESP_LOGV(TAG, "Nack");
+              this->ack_set_is_playing_ = false;
+              this->ack_reset_is_playing_ = false;
+              switch (argument) {
+                case 0x01:
+                  ESP_LOGE(TAG, "Module is busy or uninitialized");
+                  break;
+                case 0x02:
+                  ESP_LOGE(TAG, "Module is in sleep mode");
+                  break;
+                case 0x03:
+                  ESP_LOGE(TAG, "Serial receive error");
+                  break;
+                case 0x04:
+                  ESP_LOGE(TAG, "Checksum incorrect");
+                  break;
+                case 0x05:
+                  ESP_LOGE(TAG, "Specified track is out of current track scope");
+                  this->is_playing_ = false;
+                  break;
+                case 0x06:
+                  ESP_LOGE(TAG, "Specified track is not found");
+                  this->is_playing_ = false;
+                  break;
+                case 0x07:
+                  ESP_LOGE(TAG,
+                           "Insertion error (an inserting operation only can be done when a track is being played)");
+                  break;
+                case 0x08:
+                  ESP_LOGE(TAG, "SD card reading failed (SD card pulled out or damaged)");
+                  break;
+                case 0x09:
+                  ESP_LOGE(TAG, "Entered into sleep mode");
+                  this->is_playing_ = false;
+                  break;
+                default:
+                  break;
+              }
+              break;
+            case 0x41:
+              ESP_LOGV(TAG, "Ack ok");
+              this->is_playing_ |= this->ack_set_is_playing_;
+              this->is_playing_ &= !this->ack_reset_is_playing_;
+              this->ack_set_is_playing_ = false;
+              this->ack_reset_is_playing_ = false;
+              break;
+            case 0x3C:
+              ESP_LOGV(TAG, "Playback finished (USB drive)");
+              this->is_playing_ = false;
+              this->on_finished_playback_callback_.call();
+              break;
+            case 0x3D:
+              ESP_LOGV(TAG, "Playback finished (SD card)");
+              this->is_playing_ = false;
+              this->on_finished_playback_callback_.call();
+              break;
+            default:
+              ESP_LOGE(TAG, "Received unknown cmd %#02x arg %#04x", cmd, argument);
+          }
+          this->sent_cmd_ = 0;
+          this->read_pos_ = 0;
+          continue;
+      }
+      this->read_buffer_[this->read_pos_] = byte;
+      this->read_pos_++;
+    }
+  }
 }
 void DFPlayer::dump_config() { ESP_LOGCONFIG(TAG, "DFPlayer:"); }

@@ -1,7 +1,5 @@
 #pragma once

-#include <algorithm>
-
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"

@@ -29,12 +27,9 @@ class DfrobotSen0395SettingsAction final : public Action<Ts...>, public Parented
  TEMPLATABLE_VALUE(float, det_max4)

  void play(const Ts &...x) override {
-    // Worst case: stop, factory reset, six settings, save, start
-    if (!this->parent_->has_queue_room(10))
-      return;
-    this->parent_->enqueue(CommandType::COMMAND_TYPE_POWER, false);
+    this->parent_->enqueue(make_unique<PowerCommand>(0));
    if (this->factory_reset_.has_value() && this->factory_reset_.value(x...) == true) {
-      this->parent_->enqueue(CommandType::COMMAND_TYPE_FACTORY_RESET);
+      this->parent_->enqueue(make_unique<FactoryResetCommand>());
    }
    if (this->det_min1_.has_value() && this->det_max1_.has_value()) {
      // Each segment is read once, so the guard and the command see the same values.
@@ -42,10 +37,10 @@ class DfrobotSen0395SettingsAction final : public Action<Ts...>, public Parented
      if (min1 >= 0) {
        const float max1 = this->det_max1_.value(x...);
        if (max1 >= 0) {
-          this->parent_->enqueue_det_range_cfg(min1, max1, this->det_min2_.value_or(x..., -1),
-                                               this->det_max2_.value_or(x..., -1), this->det_min3_.value_or(x..., -1),
-                                               this->det_max3_.value_or(x..., -1), this->det_min4_.value_or(x..., -1),
-                                               this->det_max4_.value_or(x..., -1));
+          this->parent_->enqueue(make_unique<DetRangeCfgCommand>(
+              min1, max1, this->det_min2_.value_or(x..., -1), this->det_max2_.value_or(x..., -1),
+              this->det_min3_.value_or(x..., -1), this->det_max3_.value_or(x..., -1),
+              this->det_min4_.value_or(x..., -1), this->det_max4_.value_or(x..., -1)));
        }
      }
    }
@@ -53,35 +48,38 @@ class DfrobotSen0395SettingsAction final : public Action<Ts...>, public Parented
      float detect = this->delay_after_detect_.value(x...);
      float disappear = this->delay_after_disappear_.value(x...);
      if (detect >= 0 && disappear >= 0) {
-        this->parent_->enqueue_set_latency(detect, disappear);
+        this->parent_->enqueue(make_unique<SetLatencyCommand>(detect, disappear));
      }
    }
    if (this->start_after_power_on_.has_value()) {
      int8_t val = this->start_after_power_on_.value(x...);
      if (val >= 0) {
-        this->parent_->enqueue(CommandType::COMMAND_TYPE_SENSOR_CFG_START, val);
+        this->parent_->enqueue(make_unique<SensorCfgStartCommand>(val));
      }
    }
    if (this->turn_on_led_.has_value()) {
      int8_t val = this->turn_on_led_.value(x...);
      if (val >= 0) {
-        this->parent_->enqueue(CommandType::COMMAND_TYPE_LED_MODE, val);
+        this->parent_->enqueue(make_unique<LedModeCommand>(val));
      }
    }
    if (this->presence_via_uart_.has_value()) {
      int8_t val = this->presence_via_uart_.value(x...);
      if (val >= 0) {
-        this->parent_->enqueue(CommandType::COMMAND_TYPE_UART_OUTPUT, val);
+        this->parent_->enqueue(make_unique<UartOutputCommand>(val));
      }
    }
    if (this->sensitivity_.has_value()) {
      int8_t val = this->sensitivity_.value(x...);
      if (val >= 0) {
-        this->parent_->enqueue(CommandType::COMMAND_TYPE_SENSITIVITY, std::min<int8_t>(val, 9));
+        if (val > 9) {
+          val = 9;
+        }
+        this->parent_->enqueue(make_unique<SensitivityCommand>(val));
      }
    }
-    this->parent_->enqueue(CommandType::COMMAND_TYPE_SAVE_CFG);
-    this->parent_->enqueue(CommandType::COMMAND_TYPE_POWER, true);
+    this->parent_->enqueue(make_unique<SaveCfgCommand>());
+    this->parent_->enqueue(make_unique<PowerCommand>(1));
  }
 };

@@ -0,0 +1,332 @@
+#include "commands.h"
+
+#include <cmath>
+
+#include "esphome/core/log.h"
+
+#include "dfrobot_sen0395.h"
+
+namespace esphome::dfrobot_sen0395 {
+
+ESPHOME_LOG_TAG(TAG, "dfrobot_sen0395.commands");
+
+uint8_t Command::execute(DfrobotSen0395Component *parent) {
+  this->parent_ = parent;
+  if (this->cmd_sent_) {
+    if (this->parent_->read_message_()) {
+      std::string message(this->parent_->read_buffer_);
+      if (message.rfind("is not recognized as a CLI command") != std::string::npos) {
+        ESP_LOGD(TAG, "Command not recognized properly by sensor");
+        if (this->retries_left_ > 0) {
+          this->retries_left_ -= 1;
+          this->cmd_sent_ = false;
+          ESP_LOGD(TAG, "Retrying");
+          return 0;
+        } else {
+          this->parent_->find_prompt_();
+          return 1;  // Command done
+        }
+      }
+      uint8_t rc = on_message(message);
+      if (rc == 2) {
+        if (this->retries_left_ > 0) {
+          this->retries_left_ -= 1;
+          this->cmd_sent_ = false;
+          ESP_LOGD(TAG, "Retrying");
+          return 0;
+        } else {
+          this->parent_->find_prompt_();
+          return 1;  // Command done
+        }
+      } else if (rc == 0) {
+        return 0;
+      } else {
+        this->parent_->find_prompt_();
+        return 1;
+      }
+    }
+    if (millis() - this->parent_->ts_last_cmd_sent_ > this->timeout_ms_) {
+      ESP_LOGD(TAG, "Command timeout");
+      if (this->retries_left_ > 0) {
+        this->retries_left_ -= 1;
+        this->cmd_sent_ = false;
+        ESP_LOGD(TAG, "Retrying");
+      } else {
+        return 1;  // Command done
+      }
+    }
+  } else if (this->parent_->send_cmd_(this->cmd_.c_str(), this->cmd_duration_ms_)) {
+    this->cmd_sent_ = true;
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t ReadStateCommand::execute(DfrobotSen0395Component *parent) {
+  this->parent_ = parent;
+  if (this->parent_->read_message_()) {
+    std::string message(this->parent_->read_buffer_);
+    if (message.rfind("$JYBSS,0, , , *") != std::string::npos) {
+      this->parent_->set_detected_(false);
+      this->parent_->set_active(true);
+      return 1;  // Command done
+    } else if (message.rfind("$JYBSS,1, , , *") != std::string::npos) {
+      this->parent_->set_detected_(true);
+      this->parent_->set_active(true);
+      return 1;  // Command done
+    }
+  }
+  if (millis() - this->parent_->ts_last_cmd_sent_ > this->timeout_ms_) {
+    return 1;  // Command done, timeout
+  }
+  return 0;  // Command not done yet.
+}
+
+uint8_t ReadStateCommand::on_message(std::string &message) { return 1; }
+
+uint8_t PowerCommand::on_message(std::string &message) {
+  if (message == "sensor stopped already") {
+    this->parent_->set_active(false);
+    ESP_LOGI(TAG, "Stopped sensor (already stopped)");
+    return 1;  // Command done
+  } else if (message == "sensor started already") {
+    this->parent_->set_active(true);
+    ESP_LOGI(TAG, "Started sensor (already started)");
+    return 1;  // Command done
+  } else if (message == "new parameter isn't save, can't startSensor") {
+    this->parent_->set_active(false);
+    ESP_LOGE(TAG, "Can't start sensor! (Use SaveCfgCommand to save config first)");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    this->parent_->set_active(this->power_on_);
+    if (this->power_on_) {
+      ESP_LOGI(TAG, "Started sensor");
+    } else {
+      ESP_LOGI(TAG, "Stopped sensor");
+    }
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet.
+}
+
+DetRangeCfgCommand::DetRangeCfgCommand(float min1, float max1, float min2, float max2, float min3, float max3,
+                                       float min4, float max4) {
+  // TODO: Print warning when values are rounded
+  if (min1 < 0 || max1 < 0) {
+    this->min1_ = min1 = 0;
+    this->max1_ = max1 = 0;
+    this->min2_ = min2 = this->max2_ = max2 = this->min3_ = min3 = this->max3_ = max3 = this->min4_ = min4 =
+        this->max4_ = max4 = -1;
+
+    ESP_LOGW(TAG, "DetRangeCfgCommand invalid input parameters. Using range config 0 0.");
+
+    this->cmd_ = "detRangeCfg -1 0 0";
+  } else if (min2 < 0 || max2 < 0) {
+    this->min1_ = min1 = roundf(min1 / 0.15f) * 0.15f;
+    this->max1_ = max1 = roundf(max1 / 0.15f) * 0.15f;
+    this->min2_ = min2 = this->max2_ = max2 = this->min3_ = min3 = this->max3_ = max3 = this->min4_ = min4 =
+        this->max4_ = max4 = -1;
+
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f", min1 / 0.15f, max1 / 0.15f);
+    this->cmd_ = buf;
+  } else if (min3 < 0 || max3 < 0) {
+    this->min1_ = min1 = roundf(min1 / 0.15f) * 0.15f;
+    this->max1_ = max1 = roundf(max1 / 0.15f) * 0.15f;
+    this->min2_ = min2 = roundf(min2 / 0.15f) * 0.15f;
+    this->max2_ = max2 = roundf(max2 / 0.15f) * 0.15f;
+    this->min3_ = min3 = this->max3_ = max3 = this->min4_ = min4 = this->max4_ = max4 = -1;
+
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f %.0f %.0f", min1 / 0.15f, max1 / 0.15f, min2 / 0.15f,
+             max2 / 0.15f);
+    this->cmd_ = buf;
+  } else if (min4 < 0 || max4 < 0) {
+    this->min1_ = min1 = roundf(min1 / 0.15f) * 0.15f;
+    this->max1_ = max1 = roundf(max1 / 0.15f) * 0.15f;
+    this->min2_ = min2 = roundf(min2 / 0.15f) * 0.15f;
+    this->max2_ = max2 = roundf(max2 / 0.15f) * 0.15f;
+    this->min3_ = min3 = roundf(min3 / 0.15f) * 0.15f;
+    this->max3_ = max3 = roundf(max3 / 0.15f) * 0.15f;
+    this->min4_ = min4 = this->max4_ = max4 = -1;
+
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f %.0f %.0f %.0f %.0f", min1 / 0.15f, max1 / 0.15f, min2 / 0.15f,
+             max2 / 0.15f, min3 / 0.15f, max3 / 0.15f);
+    this->cmd_ = buf;
+  } else {
+    this->min1_ = min1 = roundf(min1 / 0.15f) * 0.15f;
+    this->max1_ = max1 = roundf(max1 / 0.15f) * 0.15f;
+    this->min2_ = min2 = roundf(min2 / 0.15f) * 0.15f;
+    this->max2_ = max2 = roundf(max2 / 0.15f) * 0.15f;
+    this->min3_ = min3 = roundf(min3 / 0.15f) * 0.15f;
+    this->max3_ = max3 = roundf(max3 / 0.15f) * 0.15f;
+    this->min4_ = min4 = roundf(min4 / 0.15f) * 0.15f;
+    this->max4_ = max4 = roundf(max4 / 0.15f) * 0.15f;
+
+    char buf[72];  // max 72: "detRangeCfg -1 "(15) + 8 * (float(5) + space(1)) + null
+    snprintf(buf, sizeof(buf), "detRangeCfg -1 %.0f %.0f %.0f %.0f %.0f %.0f %.0f %.0f", min1 / 0.15f, max1 / 0.15f,
+             min2 / 0.15f, max2 / 0.15f, min3 / 0.15f, max3 / 0.15f, min4 / 0.15f, max4 / 0.15f);
+    this->cmd_ = buf;
+  }
+
+  this->min1_ = min1;
+  this->max1_ = max1;
+  this->min2_ = min2;
+  this->max2_ = max2;
+  this->min3_ = min3;
+  this->max3_ = max3;
+  this->min4_ = min4;
+  this->max4_ = max4;
+};
+
+uint8_t DetRangeCfgCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot configure range config. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG,
+             "Updated detection area config:\n"
+             "  Detection area 1 from %.02fm to %.02fm.",
+             this->min1_, this->max1_);
+    if (this->min2_ >= 0 && this->max2_ >= 0) {
+      ESP_LOGI(TAG, "  Detection area 2 from %.02fm to %.02fm.", this->min2_, this->max2_);
+    }
+    if (this->min3_ >= 0 && this->max3_ >= 0) {
+      ESP_LOGI(TAG, "  Detection area 3 from %.02fm to %.02fm.", this->min3_, this->max3_);
+    }
+    if (this->min4_ >= 0 && this->max4_ >= 0) {
+      ESP_LOGI(TAG, "  Detection area 4 from %.02fm to %.02fm.", this->min4_, this->max4_);
+    }
+    ESP_LOGD(TAG, "  Used command: %s", this->cmd_.c_str());
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet.
+}
+
+SetLatencyCommand::SetLatencyCommand(float delay_after_detection, float delay_after_disappear) {
+  delay_after_detection = std::round(delay_after_detection / 0.025f) * 0.025f;
+  delay_after_disappear = std::round(delay_after_disappear / 0.025f) * 0.025f;
+  this->delay_after_detection_ = clamp(delay_after_detection, 0.0f, 1638.375f);
+  this->delay_after_disappear_ = clamp(delay_after_disappear, 0.0f, 1638.375f);
+  // max 32: "setLatency "(11) + float(8) + " "(1) + float(8) + null, rounded to 32
+  char buf[32];
+  snprintf(buf, sizeof(buf), "setLatency %.03f %.03f", this->delay_after_detection_, this->delay_after_disappear_);
+  this->cmd_ = buf;
+};
+
+uint8_t SetLatencyCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot configure output latency. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG,
+             "Updated output latency config:\n"
+             "  Signal that someone was detected is delayed by %.03f s.\n"
+             "  Signal that nobody is detected anymore is delayed by %.03f s.",
+             this->delay_after_detection_, this->delay_after_disappear_);
+    ESP_LOGD(TAG, "  Used command: %s", this->cmd_.c_str());
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t SensorCfgStartCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot configure sensor startup behavior. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG, "Updated sensor startup behavior:");
+    if (startup_mode_) {
+      this->parent_->set_start_after_boot(true);
+      ESP_LOGI(TAG, "Sensor will start automatically after power-on.");
+    } else {
+      this->parent_->set_start_after_boot(false);
+      ESP_LOGI(TAG, "Sensor needs to be started manually after power-on.");
+    }
+    ESP_LOGD(TAG, "Used command: %s", this->cmd_.c_str());
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t FactoryResetCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot factory reset. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG, "Sensor factory reset done.");
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t ResetSystemCommand::on_message(std::string &message) {
+  if (message == "leapMMW:/>") {
+    ESP_LOGI(TAG, "Restarted sensor.");
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t SaveCfgCommand::on_message(std::string &message) {
+  if (message == "no parameter has changed") {
+    ESP_LOGI(TAG, "Not saving config (no parameter changed).");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG, "Saved config. Saving a lot may damage the sensor.");
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t LedModeCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot set led mode. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG, "Set led mode done.");
+    if (this->active_) {
+      this->parent_->set_led_active(true);
+      ESP_LOGI(TAG, "Sensor LED will blink.");
+    } else {
+      this->parent_->set_led_active(false);
+      ESP_LOGI(TAG, "Turned off LED.");
+    }
+    ESP_LOGD(TAG, "Used command: %s", this->cmd_.c_str());
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t UartOutputCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot set uart output mode. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG, "Set uart mode done.");
+    if (this->active_) {
+      this->parent_->set_uart_presence_active(true);
+      ESP_LOGI(TAG, "Presence information is sent via UART and GPIO.");
+    } else {
+      this->parent_->set_uart_presence_active(false);
+      ESP_LOGI(TAG, "Presence information is only sent via GPIO.");
+    }
+    ESP_LOGD(TAG, "Used command: %s", this->cmd_.c_str());
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+uint8_t SensitivityCommand::on_message(std::string &message) {
+  if (message == "sensor is not stopped") {
+    ESP_LOGE(TAG, "Cannot set sensitivity. Sensor is not stopped!");
+    return 1;  // Command done
+  } else if (message == "Done") {
+    ESP_LOGI(TAG, "Set sensitivity done. Set to value %d.", this->sensitivity_);
+    ESP_LOGD(TAG, "Used command: %s", this->cmd_.c_str());
+    return 1;  // Command done
+  }
+  return 0;  // Command not done yet
+}
+
+}  // namespace esphome::dfrobot_sen0395
@@ -0,0 +1,152 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include "esphome/core/helpers.h"
+
+namespace esphome::dfrobot_sen0395 {
+
+class DfrobotSen0395Component;
+
+// Use command queue and time stamps to avoid blocking.
+// When component has run time, check if minimum time (1s) between
+// commands has passed. After that run a command from the queue.
+class Command {
+ public:
+  virtual ~Command() = default;
+  virtual uint8_t execute(DfrobotSen0395Component *parent);
+  virtual uint8_t on_message(std::string &message) = 0;
+
+ protected:
+  DfrobotSen0395Component *parent_{nullptr};
+  std::string cmd_;
+  bool cmd_sent_{false};
+  int8_t retries_left_{2};
+  uint32_t cmd_duration_ms_{1000};
+  uint32_t timeout_ms_{1500};
+};
+
+class ReadStateCommand : public Command {
+ public:
+  ReadStateCommand() { timeout_ms_ = 500; }
+  uint8_t execute(DfrobotSen0395Component *parent) override;
+  uint8_t on_message(std::string &message) override;
+};
+
+class PowerCommand : public Command {
+ public:
+  PowerCommand(bool power_on) : power_on_(power_on) {
+    if (power_on) {
+      cmd_ = "sensorStart";
+    } else {
+      cmd_ = "sensorStop";
+    }
+  };
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  bool power_on_;
+};
+
+class DetRangeCfgCommand : public Command {
+ public:
+  DetRangeCfgCommand(float min1, float max1, float min2, float max2, float min3, float max3, float min4, float max4);
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  float min1_, max1_, min2_, max2_, min3_, max3_, min4_, max4_;
+  // TODO: Set min max values in component, so they can be published as sensor.
+};
+
+class SetLatencyCommand : public Command {
+ public:
+  SetLatencyCommand(float delay_after_detection, float delay_after_disappear);
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  float delay_after_detection_;
+  float delay_after_disappear_;
+};
+
+class SensorCfgStartCommand : public Command {
+ public:
+  SensorCfgStartCommand(bool startup_mode) : startup_mode_(startup_mode) {
+    char tmp_cmd[20];  // "sensorCfgStart " (15) + "0/1" (1) + null = 17
+    buf_append_printf(tmp_cmd, sizeof(tmp_cmd), 0, "sensorCfgStart %d", startup_mode);
+    cmd_ = std::string(tmp_cmd);
+  }
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  bool startup_mode_;
+};
+
+class FactoryResetCommand : public Command {
+ public:
+  FactoryResetCommand() { cmd_ = "factoryReset 0x45670123 0xCDEF89AB 0x956128C6 0xDF54AC89"; };
+  uint8_t on_message(std::string &message) override;
+};
+
+class ResetSystemCommand : public Command {
+ public:
+  ResetSystemCommand() { cmd_ = "resetSystem"; }
+  uint8_t on_message(std::string &message) override;
+};
+
+class SaveCfgCommand : public Command {
+ public:
+  SaveCfgCommand() {
+    cmd_ = "saveCfg 0x45670123 0xCDEF89AB 0x956128C6 0xDF54AC89";
+    cmd_duration_ms_ = 3000;
+    timeout_ms_ = 3500;
+  }
+  uint8_t on_message(std::string &message) override;
+};
+
+class LedModeCommand : public Command {
+ public:
+  LedModeCommand(bool active) : active_(active) {
+    if (active) {
+      cmd_ = "setLedMode 1 0";
+    } else {
+      cmd_ = "setLedMode 1 1";
+    }
+  };
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  bool active_;
+};
+
+class UartOutputCommand : public Command {
+ public:
+  UartOutputCommand(bool active) : active_(active) {
+    if (active) {
+      cmd_ = "setUartOutput 1 1";
+    } else {
+      cmd_ = "setUartOutput 1 0";
+    }
+  };
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  bool active_;
+};
+
+class SensitivityCommand : public Command {
+ public:
+  SensitivityCommand(uint8_t sensitivity) : sensitivity_(sensitivity) {
+    if (sensitivity > 9)
+      sensitivity_ = sensitivity = 9;
+    char tmp_cmd[20];  // "setSensitivity " (15) + "0-9" (1) + null = 17
+    buf_append_printf(tmp_cmd, sizeof(tmp_cmd), 0, "setSensitivity %d", sensitivity);
+    cmd_ = std::string(tmp_cmd);
+  };
+  uint8_t on_message(std::string &message) override;
+
+ protected:
+  uint8_t sensitivity_;
+};
+
+}  // namespace esphome::dfrobot_sen0395
@@ -1,27 +1,13 @@
 #include "dfrobot_sen0395.h"

-#include <cmath>
-#include <cstring>
-
-#include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"

 namespace esphome::dfrobot_sen0395 {

 ESPHOME_LOG_TAG(TAG, "dfrobot_sen0395");
-static constexpr char ASCII_CR = 0x0D;
-static constexpr char ASCII_LF = 0x0A;
-static constexpr float DET_RANGE_STEP_M = 0.15f;
-static constexpr float LATENCY_STEP_S = 0.025f;
-
-// What each CommandType cannot do while the sensor runs; empty for commands that do not need it stopped
-PROGMEM_STRING_TABLE(BusyActions, "", "configure range config", "configure output latency",
-                     "configure sensor startup behavior", "factory reset", "", "", "set led mode",
-                     "set uart output mode", "set sensitivity");
-static_assert(BusyActions::COUNT == static_cast<size_t>(CommandType::COMMAND_TYPE_SENSITIVITY) + 1,
-              "BusyActions needs one entry per CommandType");
+const char ASCII_CR = 0x0D;
+const char ASCII_LF = 0x0A;

 void DfrobotSen0395Component::dump_config() {
  ESP_LOGCONFIG(TAG, "Dfrobot Mmwave Radar:");
@@ -37,270 +23,23 @@ void DfrobotSen0395Component::dump_config() {
 }

 void DfrobotSen0395Component::loop() {
-  if (this->cmd_queue_.empty()) {
-    this->read_state_();
-    return;
+  if (cmd_queue_.is_empty()) {
+    // Command queue empty. Read sensor state.
+    cmd_queue_.enqueue(make_unique<ReadStateCommand>());
  }
-  // Commands are non-blocking and need to be called repeatedly
-  if (this->run_command_(this->cmd_queue_.front(), App.get_loop_component_start_time())) {
-    this->cmd_queue_.pop();
-    this->cmd_sent_ = false;
-    this->retries_left_ = 2;
+
+  // Commands are non-blocking and need to be called repeatedly.
+  if (cmd_queue_.process(this)) {
+    // Dequeue if command is done
+    cmd_queue_.dequeue();
  }
 }

-bool DfrobotSen0395Component::enqueue(CommandType type, uint8_t arg) {
-  if (!this->cmd_queue_.push({type, arg})) {
-    ESP_LOGE(TAG, "Command queue is full");
-    return false;
-  }
-  return true;
+int8_t DfrobotSen0395Component::enqueue(std::unique_ptr<Command> cmd) {
+  return cmd_queue_.enqueue(std::move(cmd));  // Transfer ownership using std::move
 }

-bool DfrobotSen0395Component::has_queue_room(size_t count) const {
-  if (COMMAND_QUEUE_SIZE - this->cmd_queue_.size() >= count)
-    return true;
-  ESP_LOGE(TAG, "Command queue is full");
-  return false;
-}
-
-void DfrobotSen0395Component::enqueue_det_range_cfg(float min1, float max1, float min2, float max2, float min3,
-                                                    float max3, float min4, float max4) {
-  // TODO: Print warning when values are rounded
-  const float values[8] = {min1, max1, min2, max2, min3, max3, min4, max4};
-  int16_t steps[8];
-  bool in_use = true;
-  for (size_t i = 0; i < 8; i += 2) {
-    in_use = in_use && values[i] >= 0 && values[i + 1] >= 0;
-    for (size_t j = i; j < i + 2; j++) {
-      steps[j] = in_use ? static_cast<int16_t>(clamp(roundf(values[j] / DET_RANGE_STEP_M), 0.0f, 32767.0f)) : -1;
-    }
-  }
-  if (steps[0] < 0) {
-    ESP_LOGW(TAG, "Invalid detection range, using 0 0");
-    steps[0] = steps[1] = 0;
-  }
-  if (this->enqueue(CommandType::COMMAND_TYPE_DET_RANGE_CFG))
-    memcpy(this->det_range_steps_, steps, sizeof(steps));
-}
-
-void DfrobotSen0395Component::enqueue_set_latency(float delay_after_detection, float delay_after_disappear) {
-  if (!this->enqueue(CommandType::COMMAND_TYPE_SET_LATENCY))
-    return;
-  // 1638.375 s is 65535 steps
-  this->latency_steps_[0] =
-      static_cast<uint16_t>(clamp(std::round(delay_after_detection / LATENCY_STEP_S), 0.0f, 65535.0f));
-  this->latency_steps_[1] =
-      static_cast<uint16_t>(clamp(std::round(delay_after_disappear / LATENCY_STEP_S), 0.0f, 65535.0f));
-}
-
-void DfrobotSen0395Component::enqueue_saved_setting(CommandType type, bool value) {
-  const bool was_active = this->active_;
-  if (!this->has_queue_room(was_active ? 4 : 2))
-    return;
-  if (was_active)
-    this->enqueue(CommandType::COMMAND_TYPE_POWER, false);
-  this->enqueue(type, value);
-  this->enqueue(CommandType::COMMAND_TYPE_SAVE_CFG);
-  if (was_active)
-    this->enqueue(CommandType::COMMAND_TYPE_POWER, true);
-}
-
-bool DfrobotSen0395Component::run_command_(const Command &cmd, uint32_t now) {
-  // The interval between two commands must be larger than the command duration
-  const uint32_t duration = cmd.type == CommandType::COMMAND_TYPE_SAVE_CFG ? 3000 : 1000;
-  if (!this->cmd_sent_) {
-    if (now - this->ts_last_cmd_sent_ > duration) {
-      char buf[64];  // "detRangeCfg -1" + 8 * " 32767" + null
-      this->format_command(cmd, buf, sizeof(buf));
-      ESP_LOGD(TAG, "Sending command: %s", buf);
-      this->write_str(buf);
-      this->ts_last_cmd_sent_ = now;
-      this->cmd_sent_ = true;
-    }
-    return false;  // Command not done yet
-  }
-
-  if (this->read_message_()) {
-    if (ESPHOME_strstr_P(this->read_buffer_, ESPHOME_PSTR("is not recognized as a CLI command")) == nullptr) {
-      if (!this->handle_reply_(cmd))
-        return false;         // Command not done yet
-      this->read_message_();  // Skip the prompt
-      return true;
-    }
-    ESP_LOGD(TAG, "Command not recognized properly by sensor");
-  } else if (now - this->ts_last_cmd_sent_ <= duration + 500) {
-    return false;  // Command not done yet
-  } else {
-    ESP_LOGD(TAG, "Command timeout");
-  }
-
-  if (this->retries_left_ == 0) {
-    this->read_message_();  // Skip the prompt
-    return true;            // Give up
-  }
-  this->retries_left_--;
-  this->cmd_sent_ = false;
-  ESP_LOGD(TAG, "Retrying");
-  return false;
-}
-
-void DfrobotSen0395Component::read_state_() {
-  if (!this->read_message_())
-    return;
-  if (ESPHOME_strstr_P(this->read_buffer_, ESPHOME_PSTR("$JYBSS,0, , , *")) != nullptr) {
-    this->set_detected_(false);
-    this->set_active(true);
-  } else if (ESPHOME_strstr_P(this->read_buffer_, ESPHOME_PSTR("$JYBSS,1, , , *")) != nullptr) {
-    this->set_detected_(true);
-    this->set_active(true);
-  }
-}
-
-static size_t append_cfg_key(char *buf, size_t size, size_t pos) {
-  return buf_append_str(buf, size, pos, " 0x45670123 0xCDEF89AB 0x956128C6 0xDF54AC89");
-}
-
-void DfrobotSen0395Component::format_command(const Command &cmd, char *buf, size_t size) const {
-  buf[0] = '\0';
-  switch (cmd.type) {
-    case CommandType::COMMAND_TYPE_POWER:
-      if (cmd.arg) {
-        buf_append_str(buf, size, 0, "sensorStart");
-      } else {
-        buf_append_str(buf, size, 0, "sensorStop");
-      }
-      break;
-    case CommandType::COMMAND_TYPE_DET_RANGE_CFG: {
-      size_t pos = buf_append_str(buf, size, 0, "detRangeCfg -1");
-      for (size_t i = 0; i < 8 && this->det_range_steps_[i] >= 0; i += 2) {
-        pos = buf_append_printf(buf, size, pos, " %d %d", this->det_range_steps_[i], this->det_range_steps_[i + 1]);
-      }
-      break;
-    }
-    case CommandType::COMMAND_TYPE_SET_LATENCY:
-      buf_append_printf(buf, size, 0, "setLatency %.03f %.03f", this->latency_steps_[0] * LATENCY_STEP_S,
-                        this->latency_steps_[1] * LATENCY_STEP_S);
-      break;
-    case CommandType::COMMAND_TYPE_SENSOR_CFG_START:
-      buf_append_printf(buf, size, 0, "sensorCfgStart %d", cmd.arg);
-      break;
-    case CommandType::COMMAND_TYPE_FACTORY_RESET:
-      append_cfg_key(buf, size, buf_append_str(buf, size, 0, "factoryReset"));
-      break;
-    case CommandType::COMMAND_TYPE_RESET_SYSTEM:
-      buf_append_str(buf, size, 0, "resetSystem");
-      break;
-    case CommandType::COMMAND_TYPE_SAVE_CFG:
-      append_cfg_key(buf, size, buf_append_str(buf, size, 0, "saveCfg"));
-      break;
-    case CommandType::COMMAND_TYPE_LED_MODE:
-      buf_append_printf(buf, size, 0, "setLedMode 1 %d", cmd.arg ? 0 : 1);
-      break;
-    case CommandType::COMMAND_TYPE_UART_OUTPUT:
-      buf_append_printf(buf, size, 0, "setUartOutput 1 %d", cmd.arg ? 1 : 0);
-      break;
-    case CommandType::COMMAND_TYPE_SENSITIVITY:
-      buf_append_printf(buf, size, 0, "setSensitivity %d", cmd.arg);
-      break;
-  }
-}
-
-bool DfrobotSen0395Component::handle_reply_(const Command &cmd) {
-  const char *message = this->read_buffer_;
-  auto is = [message](ESPHOME_PGM_P text) { return ESPHOME_strcmp_P(message, text) == 0; };
-
-  // Commands with their own replies
-  switch (cmd.type) {
-    case CommandType::COMMAND_TYPE_POWER:
-      if (is(ESPHOME_PSTR("sensor stopped already"))) {
-        this->set_active(false);
-        ESP_LOGI(TAG, "Stopped sensor (already stopped)");
-      } else if (is(ESPHOME_PSTR("sensor started already"))) {
-        this->set_active(true);
-        ESP_LOGI(TAG, "Started sensor (already started)");
-      } else if (is(ESPHOME_PSTR("new parameter isn't save, can't startSensor"))) {
-        this->set_active(false);
-        ESP_LOGE(TAG, "Can't start sensor! (Use SaveCfgCommand to save config first)");
-      } else if (is(ESPHOME_PSTR("Done"))) {
-        this->set_active(cmd.arg);
-        ESP_LOGI(TAG, "%s", cmd.arg ? LOG_STR_LITERAL("Started sensor") : LOG_STR_LITERAL("Stopped sensor"));
-      } else {
-        return false;
-      }
-      return true;
-    case CommandType::COMMAND_TYPE_RESET_SYSTEM:
-      if (!is(ESPHOME_PSTR("leapMMW:/>")))
-        return false;
-      ESP_LOGI(TAG, "Restarted sensor.");
-      return true;
-    case CommandType::COMMAND_TYPE_SAVE_CFG:
-      if (is(ESPHOME_PSTR("no parameter has changed"))) {
-        ESP_LOGI(TAG, "Not saving config (no parameter changed).");
-      } else if (is(ESPHOME_PSTR("Done"))) {
-        ESP_LOGI(TAG, "Saved config. Saving a lot may damage the sensor.");
-      } else {
-        return false;
-      }
-      return true;
-    default:
-      break;
-  }
-
-  // Configuration commands, which need the sensor stopped
-  if (is(ESPHOME_PSTR("sensor is not stopped"))) {
-    ESP_LOGE(TAG, "Cannot %s. Sensor is not stopped!",
-             LOG_STR_ARG(BusyActions::get_log_str(static_cast<uint8_t>(cmd.type), 0)));
-    return true;
-  }
-  if (!is(ESPHOME_PSTR("Done")))
-    return false;
-
-  switch (cmd.type) {
-    case CommandType::COMMAND_TYPE_DET_RANGE_CFG:
-      ESP_LOGI(TAG, "Updated detection area config:");
-      for (size_t i = 0; i < 8 && this->det_range_steps_[i] >= 0; i += 2) {
-        ESP_LOGI(TAG, "  Detection area %u from %.02fm to %.02fm.", static_cast<unsigned>(i / 2 + 1),
-                 this->det_range_steps_[i] * DET_RANGE_STEP_M, this->det_range_steps_[i + 1] * DET_RANGE_STEP_M);
-      }
-      break;
-    case CommandType::COMMAND_TYPE_SET_LATENCY:
-      ESP_LOGI(TAG,
-               "Updated output latency config:\n"
-               "  Signal that someone was detected is delayed by %.03f s.\n"
-               "  Signal that nobody is detected anymore is delayed by %.03f s.",
-               this->latency_steps_[0] * LATENCY_STEP_S, this->latency_steps_[1] * LATENCY_STEP_S);
-      break;
-    case CommandType::COMMAND_TYPE_SENSOR_CFG_START:
-      this->set_start_after_boot(cmd.arg);
-      ESP_LOGI(TAG, "Updated sensor startup behavior: %s",
-               cmd.arg ? LOG_STR_LITERAL("sensor will start automatically after power-on.")
-                       : LOG_STR_LITERAL("sensor needs to be started manually after power-on."));
-      break;
-    case CommandType::COMMAND_TYPE_FACTORY_RESET:
-      ESP_LOGI(TAG, "Sensor factory reset done.");
-      break;
-    case CommandType::COMMAND_TYPE_LED_MODE:
-      this->set_led_active(cmd.arg);
-      ESP_LOGI(TAG, "Set led mode done. %s",
-               cmd.arg ? LOG_STR_LITERAL("Sensor LED will blink.") : LOG_STR_LITERAL("Turned off LED."));
-      break;
-    case CommandType::COMMAND_TYPE_UART_OUTPUT:
-      this->set_uart_presence_active(cmd.arg);
-      ESP_LOGI(TAG, "Set uart mode done. %s",
-               cmd.arg ? LOG_STR_LITERAL("Presence information is sent via UART and GPIO.")
-                       : LOG_STR_LITERAL("Presence information is only sent via GPIO."));
-      break;
-    case CommandType::COMMAND_TYPE_SENSITIVITY:
-      ESP_LOGI(TAG, "Set sensitivity done. Set to value %d.", cmd.arg);
-      break;
-    default:
-      break;
-  }
-  return true;
-}
-
-bool DfrobotSen0395Component::read_message_() {
+uint8_t DfrobotSen0395Component::read_message_() {
  while (this->available()) {
    uint8_t byte;
    this->read_byte(&byte);
@@ -323,11 +62,33 @@ bool DfrobotSen0395Component::read_message_() {
      this->read_buffer_[this->read_pos_] = 0;
      this->read_pos_ = 0;
      ESP_LOGV(TAG, "Message: %s", this->read_buffer_);
-      return true;  // Full message in buffer
+      return 1;  // Full message in buffer
+    } else {
+      this->read_pos_++;
    }
-    this->read_pos_++;
  }
-  return false;  // No full message yet
+  return 0;  // No full message yet
+}
+
+uint8_t DfrobotSen0395Component::find_prompt_() {
+  if (this->read_message_()) {
+    std::string message(this->read_buffer_);
+    if (message.rfind("leapMMW:/>") != std::string::npos) {
+      return 1;  // Prompt found
+    }
+  }
+  return 0;  // Not found yet
+}
+
+uint8_t DfrobotSen0395Component::send_cmd_(const char *cmd, uint32_t duration) {
+  // The interval between two commands must be larger than the specified duration (in ms).
+  if (millis() - ts_last_cmd_sent_ > duration) {
+    this->write_str(cmd);
+    ts_last_cmd_sent_ = millis();
+    return 1;  // Command sent
+  }
+  // Could not send command yet as command duration did not fully pass yet.
+  return 0;
 }

 void DfrobotSen0395Component::set_detected_(bool detected) {
@@ -338,4 +99,44 @@ void DfrobotSen0395Component::set_detected_(bool detected) {
 #endif
 }

+int8_t CircularCommandQueue::enqueue(std::unique_ptr<Command> cmd) {
+  if (this->is_full()) {
+    ESP_LOGE(TAG, "Command queue is full");
+    return -1;
+  } else if (this->is_empty()) {
+    front_++;
+  }
+  rear_ = (rear_ + 1) % COMMAND_QUEUE_SIZE;
+  commands_[rear_] = std::move(cmd);  // Transfer ownership using std::move
+  return 1;
+}
+
+std::unique_ptr<Command> CircularCommandQueue::dequeue() {
+  if (this->is_empty())
+    return nullptr;
+  std::unique_ptr<Command> dequeued_cmd = std::move(commands_[front_]);
+  if (front_ == rear_) {
+    front_ = -1;
+    rear_ = -1;
+  } else {
+    front_ = (front_ + 1) % COMMAND_QUEUE_SIZE;
+  }
+
+  return dequeued_cmd;
+}
+
+bool CircularCommandQueue::is_empty() { return front_ == -1; }
+
+bool CircularCommandQueue::is_full() { return (rear_ + 1) % COMMAND_QUEUE_SIZE == front_; }
+
+// Run execute method of first in line command.
+// Execute is non-blocking and has to be called until it returns 1.
+uint8_t CircularCommandQueue::process(DfrobotSen0395Component *parent) {
+  if (!is_empty()) {
+    return commands_[front_]->execute(parent);
+  } else {
+    return 1;
+  }
+}
+
 }  // namespace esphome::dfrobot_sen0395
@@ -3,7 +3,6 @@
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
-#include "esphome/core/helpers.h"

 #ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
@@ -12,30 +11,29 @@
 #include "esphome/components/switch/switch.h"
 #endif

+#include "commands.h"
+
 namespace esphome::dfrobot_sen0395 {

-static constexpr uint8_t MMWAVE_READ_BUFFER_LENGTH = 255;
-static constexpr uint8_t COMMAND_QUEUE_SIZE = 20;
+const uint8_t MMWAVE_READ_BUFFER_LENGTH = 255;

-// Keep in sync with the BusyActions table in dfrobot_sen0395.cpp
-enum class CommandType : uint8_t {
-  COMMAND_TYPE_POWER,
-  COMMAND_TYPE_DET_RANGE_CFG,
-  COMMAND_TYPE_SET_LATENCY,
-  COMMAND_TYPE_SENSOR_CFG_START,
-  COMMAND_TYPE_FACTORY_RESET,
-  COMMAND_TYPE_RESET_SYSTEM,
-  COMMAND_TYPE_SAVE_CFG,
-  COMMAND_TYPE_LED_MODE,
-  COMMAND_TYPE_UART_OUTPUT,
-  COMMAND_TYPE_SENSITIVITY,
-};
+// forward declaration due to circular dependency
+class DfrobotSen0395Component;

-/// A queued command. arg is the on/off flag, startup mode or sensitivity; the detection range and
-/// latency values are held by the component.
-struct Command {
-  CommandType type;
-  uint8_t arg;
+static const uint8_t COMMAND_QUEUE_SIZE = 20;
+
+class CircularCommandQueue {
+ public:
+  int8_t enqueue(std::unique_ptr<Command> cmd);
+  std::unique_ptr<Command> dequeue();
+  bool is_empty();
+  bool is_full();
+  uint8_t process(DfrobotSen0395Component *parent);
+
+ protected:
+  int front_{-1};
+  int rear_{-1};
+  std::unique_ptr<Command> commands_[COMMAND_QUEUE_SIZE];
 };

 class DfrobotSen0395Component final : public uart::UARTDevice, public Component {
@@ -95,21 +93,9 @@ class DfrobotSen0395Component final : public uart::UARTDevice, public Component
  }
 #endif

-  // Commands run one at a time from a queue, at least 1 s apart, so loop() never blocks
-  bool enqueue(CommandType type, uint8_t arg = 0);
-  /// True when count more commands fit; logs when they do not, so a stop/start sequence is never queued in part
-  bool has_queue_room(size_t count) const;
-  /// Queue a detection range config; segments are used up to the first one with a negative bound
-  void enqueue_det_range_cfg(float min1, float max1, float min2, float max2, float min3, float max3, float min4,
-                             float max4);
-  /// Queue an output latency config, both delays in seconds
-  void enqueue_set_latency(float delay_after_detection, float delay_after_disappear);
-  /// Queue a setting change, stopping the sensor around it and saving it when the sensor is running
-  void enqueue_saved_setting(CommandType type, bool value);
+  int8_t enqueue(std::unique_ptr<Command> cmd);
  /// Queue a sensor reset
-  void reset_system() { this->enqueue(CommandType::COMMAND_TYPE_RESET_SYSTEM); }
-  /// Write the text sent to the sensor for cmd into buf
-  void format_command(const Command &cmd, char *buf, size_t size) const;
+  void reset_system() { this->enqueue(make_unique<ResetSystemCommand>()); }

 protected:
 #ifdef USE_BINARY_SENSOR
@@ -123,22 +109,17 @@ class DfrobotSen0395Component final : public uart::UARTDevice, public Component
  bool start_after_boot_{false};
  char read_buffer_[MMWAVE_READ_BUFFER_LENGTH];
  size_t read_pos_{0};
-  bool cmd_sent_{false};
-  uint8_t retries_left_{2};
-  StaticRingBuffer<Command, COMMAND_QUEUE_SIZE> cmd_queue_;
+  CircularCommandQueue cmd_queue_;
  uint32_t ts_last_cmd_sent_{0};
-  // Range and latency of the queued commands, in sensor steps (0.15 m, 0.025 s); a later command overwrites them
-  int16_t det_range_steps_[8]{};
-  uint16_t latency_steps_[2]{};

-  bool read_message_();
-  void read_state_();
-  /// Run the command at the front of the queue; true when it is done
-  bool run_command_(const Command &cmd, uint32_t now);
-  /// Handle a reply to a sent command; true when the command is done
-  bool handle_reply_(const Command &cmd);
+  uint8_t read_message_();
+  uint8_t find_prompt_();
+  uint8_t send_cmd_(const char *cmd, uint32_t duration);

  void set_detected_(bool detected);
+
+  friend class Command;
+  friend class ReadStateCommand;
 };

 }  // namespace esphome::dfrobot_sen0395
@@ -2,49 +2,63 @@ import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import CONF_TYPE, ENTITY_CATEGORY_CONFIG
+from esphome.cpp_generator import MockObjClass
 from esphome.types import ConfigType

-from .. import CONF_DFROBOT_SEN0395_ID, DfrobotSen0395Component, dfrobot_sen0395_ns
+from .. import CONF_DFROBOT_SEN0395_ID, DfrobotSen0395Component

 DEPENDENCIES = ["dfrobot_sen0395"]

-CommandType = dfrobot_sen0395_ns.enum("CommandType", is_class=True)
+dfrobot_sen0395_ns = cg.esphome_ns.namespace("dfrobot_sen0395")
+DfrobotSen0395Switch = dfrobot_sen0395_ns.class_(
+    "DfrobotSen0395Switch",
+    switch.Switch,
+    cg.Component,
+    cg.Parented.template(DfrobotSen0395Component),
+)

-_SWITCH_SCHEMA = switch.switch_schema(
-    switch.ApplySwitch,
-    entity_category=ENTITY_CATEGORY_CONFIG,
-).extend(
+Sen0395PowerSwitch = dfrobot_sen0395_ns.class_(
+    "Sen0395PowerSwitch", DfrobotSen0395Switch
+)
+Sen0395LedSwitch = dfrobot_sen0395_ns.class_("Sen0395LedSwitch", DfrobotSen0395Switch)
+Sen0395UartPresenceSwitch = dfrobot_sen0395_ns.class_(
+    "Sen0395UartPresenceSwitch", DfrobotSen0395Switch
+)
+Sen0395StartAfterBootSwitch = dfrobot_sen0395_ns.class_(
+    "Sen0395StartAfterBootSwitch", DfrobotSen0395Switch
+)
+
+
+def _switch_schema(class_: MockObjClass) -> cv.Schema:
+    return (
+        switch.switch_schema(
+            class_,
+            entity_category=ENTITY_CATEGORY_CONFIG,
+        )
+        .extend(
+            {
+                cv.GenerateID(CONF_DFROBOT_SEN0395_ID): cv.use_id(
+                    DfrobotSen0395Component
+                ),
+            }
+        )
+        .extend(cv.COMPONENT_SCHEMA)
+    )
+
+
+CONFIG_SCHEMA = cv.typed_schema(
    {
-        cv.GenerateID(CONF_DFROBOT_SEN0395_ID): cv.use_id(DfrobotSen0395Component),
+        "sensor_active": _switch_schema(Sen0395PowerSwitch),
+        "turn_on_led": _switch_schema(Sen0395LedSwitch),
+        "presence_via_uart": _switch_schema(Sen0395UartPresenceSwitch),
+        "start_after_boot": _switch_schema(Sen0395StartAfterBootSwitch),
    }
 )

-# Per type: the hub setter that stores the switch, and the command its writes queue
-_SWITCHES = {
-    "sensor_active": (
-        lambda hub: hub.set_sensor_active_switch,
-        f"enqueue({CommandType.COMMAND_TYPE_POWER}, state)",
-    ),
-    "turn_on_led": (
-        lambda hub: hub.set_turn_on_led_switch,
-        f"enqueue_saved_setting({CommandType.COMMAND_TYPE_LED_MODE}, state)",
-    ),
-    "presence_via_uart": (
-        lambda hub: hub.set_presence_via_uart_switch,
-        f"enqueue_saved_setting({CommandType.COMMAND_TYPE_UART_OUTPUT}, state)",
-    ),
-    "start_after_boot": (
-        lambda hub: hub.set_start_after_boot_switch,
-        f"enqueue_saved_setting({CommandType.COMMAND_TYPE_SENSOR_CFG_START}, state)",
-    ),
-}
-
-CONFIG_SCHEMA = cv.typed_schema(dict.fromkeys(_SWITCHES, _SWITCH_SCHEMA))
-

 async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_DFROBOT_SEN0395_ID])
-    setter, apply = _SWITCHES[config[CONF_TYPE]]
-    await switch.sub_switches(config, parent=hub).create(
-        config, setter(hub), apply=apply
-    )
+    parent = await cg.get_variable(config[CONF_DFROBOT_SEN0395_ID])
+    var = await switch.new_switch(config)
+    await cg.register_component(var, config)
+    await cg.register_parented(var, parent)
+    cg.add(getattr(parent, f"set_{config[CONF_TYPE]}_switch")(var))
@@ -0,0 +1,46 @@
+#include "dfrobot_sen0395_switch.h"
+
+namespace esphome::dfrobot_sen0395 {
+
+void Sen0395PowerSwitch::write_state(bool state) { this->parent_->enqueue(make_unique<PowerCommand>(state)); }
+
+void Sen0395LedSwitch::write_state(bool state) {
+  bool was_active = false;
+  if (this->parent_->is_active()) {
+    was_active = true;
+    this->parent_->enqueue(make_unique<PowerCommand>(false));
+  }
+  this->parent_->enqueue(make_unique<LedModeCommand>(state));
+  this->parent_->enqueue(make_unique<SaveCfgCommand>());
+  if (was_active) {
+    this->parent_->enqueue(make_unique<PowerCommand>(true));
+  }
+}
+
+void Sen0395UartPresenceSwitch::write_state(bool state) {
+  bool was_active = false;
+  if (this->parent_->is_active()) {
+    was_active = true;
+    this->parent_->enqueue(make_unique<PowerCommand>(false));
+  }
+  this->parent_->enqueue(make_unique<UartOutputCommand>(state));
+  this->parent_->enqueue(make_unique<SaveCfgCommand>());
+  if (was_active) {
+    this->parent_->enqueue(make_unique<PowerCommand>(true));
+  }
+}
+
+void Sen0395StartAfterBootSwitch::write_state(bool state) {
+  bool was_active = false;
+  if (this->parent_->is_active()) {
+    was_active = true;
+    this->parent_->enqueue(make_unique<PowerCommand>(false));
+  }
+  this->parent_->enqueue(make_unique<SensorCfgStartCommand>(state));
+  this->parent_->enqueue(make_unique<SaveCfgCommand>());
+  if (was_active) {
+    this->parent_->enqueue(make_unique<PowerCommand>(true));
+  }
+}
+
+}  // namespace esphome::dfrobot_sen0395
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "esphome/components/switch/switch.h"
+#include "esphome/core/component.h"
+
+#include "../dfrobot_sen0395.h"
+
+namespace esphome::dfrobot_sen0395 {
+
+class DfrobotSen0395Switch : public switch_::Switch, public Component, public Parented<DfrobotSen0395Component> {};
+
+class Sen0395PowerSwitch final : public DfrobotSen0395Switch {
+ public:
+  void write_state(bool state) override;
+};
+
+class Sen0395LedSwitch final : public DfrobotSen0395Switch {
+ public:
+  void write_state(bool state) override;
+};
+
+class Sen0395UartPresenceSwitch final : public DfrobotSen0395Switch {
+ public:
+  void write_state(bool state) override;
+};
+
+class Sen0395StartAfterBootSwitch final : public DfrobotSen0395Switch {
+ public:
+  void write_state(bool state) override;
+};
+
+}  // namespace esphome::dfrobot_sen0395
@@ -34,7 +34,10 @@ DFRobotSEN0465Component = dfrobot_sen0465_base_ns.class_(
    "DFRobotSEN0465Component", cg.PollingComponent
 )
 AlarmType = dfrobot_sen0465_base_ns.enum("AlarmType", is_class=True)
-ALARM_TYPES = AlarmType.options("LOW", "HIGH", prefix="ALARM_TYPE_")
+ALARM_TYPES = {
+    "LOW": AlarmType.ALARM_TYPE_LOW,
+    "HIGH": AlarmType.ALARM_TYPE_HIGH,
+}

 # One piece of the temperature compensation from the DFRobot_MultiGasSensor library:
 # for low < T <= high, compensated = raw / (a * T + b) - (c * T + d)
@@ -72,7 +72,10 @@ void DFRobotSEN0465Component::dump_config() {
  if (this->alarm_type_ == AlarmType::ALARM_TYPE_OFF) {
    ESP_LOGCONFIG(TAG, "  Alarm: off");
  } else {
-    const float threshold = this->alarm_threshold_ / pow10_int(this->alarm_decimals_);
+    float scale = 1.0f;
+    for (uint8_t i = 0; i < this->alarm_decimals_; i++)
+      scale *= 10.0f;
+    const float threshold = this->alarm_threshold_ / scale;
    ESP_LOGCONFIG(TAG, "  Alarm: %s %.*f",
                  this->alarm_type_ == AlarmType::ALARM_TYPE_HIGH ? LOG_STR_LITERAL("above") : LOG_STR_LITERAL("below"),
                  this->alarm_decimals_, threshold);
@@ -80,6 +83,9 @@ void DFRobotSEN0465Component::dump_config() {
  if (this->setup_incomplete_) {
    ESP_LOGCONFIG(TAG, "  Setup incomplete: yes");
  }
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  }
  LOG_UPDATE_INTERVAL(this);
  LOG_SENSOR("  ", "Concentration", this->concentration_sensor_);
  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
@@ -222,14 +228,23 @@ void DFRobotSEN0465Component::handle_data_(const uint8_t *frame) {
    return;
  }

-  if (frame[5] > 2) {
-    ESP_LOGW(TAG, "Invalid number of decimal places: %u", frame[5]);
-    if (this->concentration_sensor_ != nullptr)
-      this->concentration_sensor_->publish_state(NAN);
-    this->status_set_warning();
-    return;
+  float concentration = encode_uint16(frame[2], frame[3]);
+  switch (frame[5]) {
+    case 0:
+      break;
+    case 1:
+      concentration *= 0.1f;
+      break;
+    case 2:
+      concentration *= 0.01f;
+      break;
+    default:
+      ESP_LOGW(TAG, "Invalid number of decimal places: %u", frame[5]);
+      if (this->concentration_sensor_ != nullptr)
+        this->concentration_sensor_->publish_state(NAN);
+      this->status_set_warning();
+      return;
  }
-  float concentration = encode_uint16(frame[2], frame[3]) * pow10_int(-frame[5]);

 #ifdef USE_DFROBOT_SEN0465_TEMPERATURE_COMPENSATION
  if (!this->compensation_.empty())
@@ -1,7 +1,10 @@
 #include "dfrobot_sen0465_uart.h"

+#include <algorithm>
+
 namespace esphome::dfrobot_sen0465_uart {

+using dfrobot_sen0465_base::FRAME_HEAD;
 using dfrobot_sen0465_base::FRAME_SIZE;
 using dfrobot_sen0465_base::RESPONSE_TIMEOUT_ID;

@@ -15,21 +18,30 @@ void DFRobotSEN0465UARTComponent::setup() {
 }

 void DFRobotSEN0465UARTComponent::loop() {
-  // The tail of a reading the probe sent on its own may precede the answer; the reader skips to the frame head.
-  const uint8_t *frame = nullptr;
-  this->read_available<FRAME_SIZE>([&](uint8_t c) { return (frame = this->reader_.feed(c)) == nullptr; });
-  if (frame == nullptr)
+  // The tail of a reading the probe sent on its own may precede the answer; start at the next frame head.
+  uint8_t byte;
+  while (this->rx_count_ == 0 && this->peek_byte(&byte) && byte != FRAME_HEAD)
+    this->read_byte(&byte);
+  const size_t available = this->available();
+  if (available == 0)
+    return;
+  const size_t len = std::min<size_t>(available, FRAME_SIZE - this->rx_count_);
+  if (!this->read_array(this->rx_buffer_ + this->rx_count_, len))
+    return;
+  this->rx_count_ += len;
+  if (this->rx_count_ < FRAME_SIZE)
    return;

+  this->rx_count_ = 0;
  this->cancel_timeout(RESPONSE_TIMEOUT_ID);
  this->disable_loop();
-  this->handle_response_(frame);
+  this->handle_response_(this->rx_buffer_);
 }

 bool DFRobotSEN0465UARTComponent::write_frame(const uint8_t *frame) {
  // Drop anything left over, such as the answer to the mode change or readings sent before passive mode was set
  this->discard_available();
-  this->reader_.reset();
+  this->rx_count_ = 0;
  this->write_array(frame, FRAME_SIZE);
  return true;
 }
@@ -38,7 +50,7 @@ void DFRobotSEN0465UARTComponent::read_response() {
  this->enable_loop();
  this->set_timeout(RESPONSE_TIMEOUT_ID, RESPONSE_TIMEOUT_MS, [this]() {
    this->disable_loop();
-    this->reader_.reset();
+    this->rx_count_ = 0;
    this->handle_no_response_();
  });
 }
@@ -2,7 +2,6 @@

 #include "esphome/components/dfrobot_sen0465_base/dfrobot_sen0465_base.h"
 #include "esphome/components/uart/uart.h"
-#include "esphome/core/frame_reader.h"

 namespace esphome::dfrobot_sen0465_uart {

@@ -18,7 +17,8 @@ class DFRobotSEN0465UARTComponent final : public dfrobot_sen0465_base::DFRobotSE
  bool write_frame(const uint8_t *frame) override;
  void read_response() override;

-  FrameReader<dfrobot_sen0465_base::FRAME_SIZE, dfrobot_sen0465_base::FRAME_HEAD> reader_;
+  uint8_t rx_buffer_[dfrobot_sen0465_base::FRAME_SIZE];
+  uint8_t rx_count_{0};
 };

 }  // namespace esphome::dfrobot_sen0465_uart
@@ -3,7 +3,8 @@ from collections.abc import Callable
 import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
-from esphome.const import CONF_MODE, CONF_MODEL
+from esphome.const import CONF_ID, CONF_MODE, CONF_MODEL
+from esphome.core import ID
 import esphome.final_validate as fv
 from esphome.types import ConfigType

@@ -58,11 +59,16 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
 )


+def get_hub_config(root: ConfigType, hub_id: ID) -> ConfigType:
+    """Return the configuration of the hub with the given id."""
+    return next(conf for conf in root[DOMAIN] if conf[CONF_ID] == hub_id)
+
+
 def final_validate_mode(keys: dict[str, str]) -> Callable[[ConfigType], None]:
    """Reject entity keys that need a different hub mode; `keys` maps each key to the mode it needs."""

    def validator(config: ConfigType) -> None:
-        hub = fv.get_declaring_config(config[CONF_DFROBOT_SEN0609_ID])
+        hub = get_hub_config(fv.full_config.get(), config[CONF_DFROBOT_SEN0609_ID])
        for key, mode in keys.items():
            if key in config and hub[CONF_MODE] != mode:
                raise cv.Invalid(
@@ -2,19 +2,44 @@ import esphome.codegen as cg
 from esphome.components import button
 from esphome.components.const import CONF_QUERY_PARAMS
 import esphome.config_validation as cv
-from esphome.const import CONF_FACTORY_RESET, CONF_ID, CONF_RESTART
+from esphome.const import (
+    CONF_FACTORY_RESET,
+    CONF_ID,
+    CONF_RESTART,
+    DEVICE_CLASS_RESTART,
+    ENTITY_CATEGORY_CONFIG,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_DATABASE,
+    ICON_RESTART,
+    ICON_RESTART_ALERT,
+)
 from esphome.types import ConfigType

-from .. import CONF_DFROBOT_SEN0609_ID, DFRobotSEN0609Component
+from .. import CONF_DFROBOT_SEN0609_ID, DFRobotSEN0609Component, dfrobot_sen0609_ns
+
+DFRobotSEN0609Button = dfrobot_sen0609_ns.class_("DFRobotSEN0609Button", button.Button)
+ButtonAction = dfrobot_sen0609_ns.enum("ButtonAction")

 CONFIG_SCHEMA = {
    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
    cv.GenerateID(CONF_DFROBOT_SEN0609_ID): cv.use_id(DFRobotSEN0609Component),
-    cv.Optional(CONF_FACTORY_RESET): button.factory_reset_button_schema(
-        button.ApplyButton
+    cv.Optional(CONF_FACTORY_RESET): button.button_schema(
+        DFRobotSEN0609Button,
+        device_class=DEVICE_CLASS_RESTART,
+        entity_category=ENTITY_CATEGORY_CONFIG,
+        icon=ICON_RESTART_ALERT,
+    ),
+    cv.Optional(CONF_QUERY_PARAMS): button.button_schema(
+        DFRobotSEN0609Button,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        icon=ICON_DATABASE,
+    ),
+    cv.Optional(CONF_RESTART): button.button_schema(
+        DFRobotSEN0609Button,
+        device_class=DEVICE_CLASS_RESTART,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+        icon=ICON_RESTART,
    ),
-    cv.Optional(CONF_QUERY_PARAMS): button.query_button_schema(button.ApplyButton),
-    cv.Optional(CONF_RESTART): button.restart_button_schema(button.ApplyButton),
 }


@@ -22,7 +47,11 @@ async def to_code(config: ConfigType) -> None:
    hub = await cg.get_variable(config[CONF_DFROBOT_SEN0609_ID])
    buttons = button.sub_buttons(config, parent=hub)
    await buttons(
-        CONF_FACTORY_RESET, hub.set_factory_reset_button, apply="factory_reset()"
+        CONF_FACTORY_RESET,
+        hub.set_factory_reset_button,
+        ButtonAction.BUTTON_FACTORY_RESET,
    )
-    await buttons(CONF_QUERY_PARAMS, hub.set_query_button, apply="query_params()")
-    await buttons(CONF_RESTART, hub.set_restart_button, apply="restart()")
+    await buttons(
+        CONF_QUERY_PARAMS, hub.set_query_button, ButtonAction.BUTTON_QUERY_PARAMS
+    )
+    await buttons(CONF_RESTART, hub.set_restart_button, ButtonAction.BUTTON_RESTART)
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "esphome/components/button/button.h"
+#include "../dfrobot_sen0609.h"
+
+namespace esphome::dfrobot_sen0609 {
+
+class DFRobotSEN0609Button final : public button::Button, public Parented<DFRobotSEN0609Component> {
+ public:
+  explicit DFRobotSEN0609Button(ButtonAction action) : action_(action) {}
+
+ protected:
+  void press_action() override {
+    switch (this->action_) {
+      case BUTTON_RESTART:
+        this->parent_->restart();
+        break;
+      case BUTTON_FACTORY_RESET:
+        this->parent_->factory_reset();
+        break;
+      case BUTTON_QUERY_PARAMS:
+        this->parent_->query_params();
+        break;
+    }
+  }
+
+  ButtonAction action_;
+};
+
+}  // namespace esphome::dfrobot_sen0609
@@ -5,6 +5,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/progmem.h"

+#include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <cstring>
@@ -94,6 +95,12 @@ static bool answer_means_done(Operation operation, const char *line) {
  }
 }

+static bool parse_float(const char *str, float &value) {
+  char *end;
+  value = strtof(str, &end);
+  return end != str && *end == '\0';
+}
+
 static const LogString *operation_to_str(Operation operation) {
  switch (operation) {
    case Operation::OPERATION_STOP:
@@ -131,9 +138,9 @@ void DFRobotSEN0609Component::dump_config() {
  LOG_BINARY_SENSOR("  ", "HasTarget", this->has_target_binary_sensor_);
 #endif
 #ifdef USE_SENSOR
-  LOG_SENSOR_WITH_DEDUP("  ", "TargetDistance", this->target_distance_sensor_);
-  LOG_SENSOR_WITH_DEDUP("  ", "TargetSpeed", this->target_speed_sensor_);
-  LOG_SENSOR_WITH_DEDUP("  ", "TargetEnergy", this->target_energy_sensor_);
+  LOG_SENSOR("  ", "TargetDistance", this->target_distance_sensor_);
+  LOG_SENSOR("  ", "TargetSpeed", this->target_speed_sensor_);
+  LOG_SENSOR("  ", "TargetEnergy", this->target_energy_sensor_);
 #endif
 #ifdef USE_TEXT_SENSOR
  LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
@@ -166,19 +173,29 @@ void DFRobotSEN0609Component::setup() {
    switch_::Switch *sw = this->switches_[i];
    if (sw == nullptr)
      continue;
-    // A disabled restore mode leaves the switch on, which an inverted switch writes as off
-    this->publish_switch_(static_cast<SwitchSetting>(i), sw->get_initial_write_state().value_or(!sw->is_inverted()));
+    const bool on = sw->get_initial_state_with_restore_mode().value_or(true);
+    this->publish_switch_(static_cast<SwitchSetting>(i), on != sw->is_inverted());
  }
 #endif
  this->queue_configuration_();
 }

 void DFRobotSEN0609Component::loop() {
-  if (this->read_available<MAX_LINE_LENGTH>([this](uint8_t b) { this->readline_(b); })) {
+  uint8_t buf[MAX_LINE_LENGTH];
+  size_t avail = this->available();
+  while (avail > 0) {
+    const size_t to_read = std::min(avail, sizeof(buf));
+    if (!this->read_array(buf, to_read)) {
+      if (!this->read_failed_) {
+        ESP_LOGW(TAG, "UART read failed");
+      }
+      this->read_failed_ = true;
+      break;
+    }
    this->read_failed_ = false;
-  } else if (!this->read_failed_) {
-    ESP_LOGW(TAG, "UART read failed");
-    this->read_failed_ = true;
+    avail -= to_read;
+    for (size_t i = 0; i < to_read; i++)
+      this->readline_(buf[i]);
  }
  this->run_sequencer_();
 }
@@ -269,6 +286,9 @@ void DFRobotSEN0609Component::handle_frame_(char *line) {
    return;
  }
  char *fields[FRAME_FIELDS];
+  float distance;
+  float speed;
+  float energy;
  if (split_fields(line + 7, fields, FRAME_FIELDS) < FRAME_FIELDS) {
    this->log_bad_frame_(LOG_STR("Malformed target frame"), line);
    return;
@@ -288,10 +308,7 @@ void DFRobotSEN0609Component::handle_frame_(char *line) {
 #endif
    return;
  }
-  const optional<float> distance = parse_number<float>(fields[2]);
-  const optional<float> speed = parse_number<float>(fields[3]);
-  const optional<float> energy = parse_number<float>(fields[4]);
-  if (!distance.has_value() || !speed.has_value() || !energy.has_value()) {
+  if (!parse_float(fields[2], distance) || !parse_float(fields[3], speed) || !parse_float(fields[4], energy)) {
    this->log_bad_frame_(LOG_STR("Malformed target frame"), line);
    return;
  }
@@ -300,7 +317,7 @@ void DFRobotSEN0609Component::handle_frame_(char *line) {
    this->has_target_binary_sensor_->publish_state(true);
 #endif
 #ifdef USE_SENSOR
-  this->publish_target_(*distance, *speed, *energy);
+  this->publish_target_(distance, speed, energy);
 #endif
 }

@@ -313,18 +330,17 @@ void DFRobotSEN0609Component::log_bad_frame_(const LogString *problem, const cha
 }

 #ifdef USE_SENSOR
-static void publish_deduplicated(sensor::SensorWithDedup<float> &sens, float value) {
-  if (std::isnan(value)) {
-    sens.publish_state_unknown();
-  } else {
-    sens.publish_state_if_not_dup(value);
-  }
+static void publish_deduplicated(sensor::Sensor *sens, Deduplicator<float> &dedup, float value) {
+  if (sens == nullptr)
+    return;
+  if (std::isnan(value) ? dedup.next_unknown() : dedup.next(value))
+    sens->publish_state(value);
 }

 void DFRobotSEN0609Component::publish_target_(float distance, float speed, float energy) {
-  publish_deduplicated(this->target_distance_sensor_, distance);
-  publish_deduplicated(this->target_speed_sensor_, speed);
-  publish_deduplicated(this->target_energy_sensor_, energy);
+  publish_deduplicated(this->target_distance_sensor_, this->distance_dedup_, distance);
+  publish_deduplicated(this->target_speed_sensor_, this->speed_dedup_, speed);
+  publish_deduplicated(this->target_energy_sensor_, this->energy_dedup_, energy);
 }
 #endif

@@ -443,15 +459,6 @@ void DFRobotSEN0609Component::control_number(NumberSetting setting, float value)
  this->request_write_(static_cast<Param>(progmem_read_byte(&NUMBER_PARAMS[setting])));
 }

-void DFRobotSEN0609Component::control_number(number::Number *number, float value) {
-  for (uint8_t i = 0; i < NUMBER_COUNT; i++) {
-    if (this->numbers_[i] == number) {
-      this->control_number(static_cast<NumberSetting>(i), value);
-      return;
-    }
-  }
-}
-
 void DFRobotSEN0609Component::forget_number_changes_(Param param, bool unknown) {
  for (uint8_t i = 0; i < NUMBER_COUNT; i++) {
    if (progmem_read_byte(&NUMBER_PARAMS[i]) != param)
@@ -7,7 +7,7 @@
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
 #ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor_with_dedup.h"
+#include "esphome/components/sensor/sensor.h"
 #endif
 #ifdef USE_TEXT_SENSOR
 #include "esphome/components/text_sensor/text_sensor.h"
@@ -62,6 +62,12 @@ enum SwitchSetting : uint8_t {
  SWITCH_COUNT,
 };

+enum ButtonAction : uint8_t {
+  BUTTON_RESTART,
+  BUTTON_FACTORY_RESET,
+  BUTTON_QUERY_PARAMS,
+};
+
 /// Module parameters; a write or read of each is one command. Pending work runs in this order.
 enum Param : uint8_t {
  PARAM_RUN_APP,
@@ -97,9 +103,9 @@ class DFRobotSEN0609Component final : public Component, public uart::UARTDevice
  SUB_BINARY_SENSOR(has_target)
 #endif
 #ifdef USE_SENSOR
-  SUB_SENSOR_WITH_DEDUP(target_distance, float)
-  SUB_SENSOR_WITH_DEDUP(target_speed, float)
-  SUB_SENSOR_WITH_DEDUP(target_energy, float)
+  SUB_SENSOR(target_distance)
+  SUB_SENSOR(target_speed)
+  SUB_SENSOR(target_energy)
 #endif
 #ifdef USE_TEXT_SENSOR
  SUB_TEXT_SENSOR(version)
@@ -124,8 +130,6 @@ class DFRobotSEN0609Component final : public Component, public uart::UARTDevice
 #ifdef USE_NUMBER
  void set_number(NumberSetting setting, number::Number *number) { this->numbers_[setting] = number; }
  void control_number(NumberSetting setting, float value);
-  // Finds the setting by pointer so every number shares one Apply function
-  void control_number(number::Number *number, float value);
 #endif
 #ifdef USE_SWITCH
  void set_switch(SwitchSetting setting, switch_::Switch *sw) { this->switches_[setting] = sw; }
@@ -171,6 +175,9 @@ class DFRobotSEN0609Component final : public Component, public uart::UARTDevice
 #endif
 #ifdef USE_SENSOR
  void publish_target_(float distance, float speed, float energy);
+  Deduplicator<float> distance_dedup_;
+  Deduplicator<float> speed_dedup_;
+  Deduplicator<float> energy_dedup_;
 #endif

 #ifdef USE_NUMBER
@@ -18,7 +18,6 @@ from esphome.const import (
    UNIT_SECOND,
 )
 from esphome.core import CORE
-import esphome.final_validate as fv
 from esphome.types import ConfigType

 from .. import (
@@ -29,8 +28,10 @@ from .. import (
    DFRobotSEN0609Component,
    dfrobot_sen0609_ns,
    final_validate_mode,
+    get_hub_config,
 )

+DFRobotSEN0609Number = dfrobot_sen0609_ns.class_("DFRobotSEN0609Number", number.Number)
 NumberSetting = dfrobot_sen0609_ns.enum("NumberSetting")

 CONF_HOLD_SENSITIVITY = "hold_sensitivity"
@@ -54,7 +55,7 @@ class Setting(NamedTuple):

 def _distance(icon: str = ICON_RULER) -> cv.Schema:
    return number.number_schema(
-        number.ApplyNumber,
+        DFRobotSEN0609Number,
        device_class=DEVICE_CLASS_DISTANCE,
        entity_category=ENTITY_CATEGORY_CONFIG,
        icon=icon,
@@ -64,7 +65,7 @@ def _distance(icon: str = ICON_RULER) -> cv.Schema:

 def _duration() -> cv.Schema:
    return number.number_schema(
-        number.ApplyNumber,
+        DFRobotSEN0609Number,
        device_class=DEVICE_CLASS_DURATION,
        entity_category=ENTITY_CATEGORY_CONFIG,
        icon=ICON_TIMELAPSE,
@@ -74,7 +75,7 @@ def _duration() -> cv.Schema:

 def _plain() -> cv.Schema:
    return number.number_schema(
-        number.ApplyNumber,
+        DFRobotSEN0609Number,
        entity_category=ENTITY_CATEGORY_CONFIG,
        icon=ICON_MOTION_SENSOR,
    )
@@ -180,14 +181,14 @@ FINAL_VALIDATE_SCHEMA = final_validate_mode(
 async def to_code(config: ConfigType) -> None:
    hub_id = config[CONF_DFROBOT_SEN0609_ID]
    hub = await cg.get_variable(hub_id)
-    max_range = MAX_RANGES[fv.get_declaring_config(hub_id, CORE.config)[CONF_MODEL]]
+    max_range = MAX_RANGES[get_hub_config(CORE.config, hub_id)[CONF_MODEL]]
    numbers = number.sub_numbers(config, parent=hub)
    for s in SETTINGS:
        await numbers(
            s.key,
            lambda n, setting=s.setting: hub.set_number(setting, n),
+            s.setting,
            min_value=s.min_value,
            max_value=max_range if s.max_value is None else s.max_value,
            step=s.step,
-            apply="control_number(entity, value)",
        )