Apply the simplify pass to the single-interface rework

Neutral fan-out runs before the legacy nodes so on_connect triggers observe
resolved gatt nodes (the neutral engine's order). Pending notify
registrations move to a fixed array (no post-setup heap). Gatt nodes also
join nodes_, collapsing the twin state loops. One define now means 'the
neutral node surface is compiled in' on both engines. The service count
moves into BluedroidServiceTable, free() resets it, bridge ops log failures,
the write action carries its own tag, and the automation headers drop
includes that left with the write actions.

esphome/components/ble_client/__init__.py

@@ -338,13 +338,13 @@ async def register_ble_node(var, config):
 
 
 def _request_gatt_node_build() -> None:
-    """Node storage plus, on esp32, the bridge and shared-materializer
-    defines one neutral node needs compiled in."""
+    """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 CORE.is_esp32:
         # Deliberately not ble_device_base.request_gatt_client(): that would
         # claim a phantom backend slot on combined proxy builds.
-        cg.add_define("USE_BLE_CLIENT_GATT_NODES")
         cg.add_define("USE_BLE_GATT_CLIENT")
         cg.add_define("USE_BLE_GATT_SERVICE_TABLE")
 
@@ -538,7 +538,9 @@ _request_node_slot = cg.slot_counter("ESPHOME_BLE_CLIENT_MAX_NODES")
 
 
 async def _to_code_gatt(config: ConfigType) -> cg.MockObj:
-    _request_node_slot()
+    # 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)

esphome/components/ble_client/automation.h

@@ -2,13 +2,8 @@
 
 #ifdef USE_ESP32
 
-#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"
 
 namespace esphome::ble_client {
 

esphome/components/ble_client/automation_gatt.h

@@ -12,12 +12,9 @@
 #if defined(USE_BLE_GATT_CLIENT) && !defined(USE_ESP32)
 
 #include <tuple>
-#include <vector>
 
 #include "ble_client_gatt.h"
 #include "esphome/core/automation.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 
 namespace esphome::ble_client {
 

esphome/components/ble_client/ble_client.cpp

@@ -9,6 +9,7 @@
 
 #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
 
 namespace esphome::ble_client {
@@ -60,7 +61,8 @@ bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
     int err = param->reg_for_notify.status == ESP_GATT_OK ? 0 : param->reg_for_notify.status;
     for (auto *node : this->gatt_nodes_)
       node->on_notify_state(param->reg_for_notify.handle, true, err);
-    // A retiring last registration must still release the cache.
+    // A retiring last registration must still release the cache (the counter
+    // was cleared above, before the node dispatch).
     this->maybe_release_services_();
     return true;
   }
@@ -68,18 +70,20 @@ bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t es
   if (!BLEClientBase::gattc_event_handler(event, esp_gattc_if, param))
     return false;
 
-  for (auto *node : this->nodes_)
-    node->gattc_event_handler(event, esp_gattc_if, param);
 #ifdef USE_BLE_CLIENT_GATT_NODES
+  // Before the legacy fan-out so gatt nodes resolve their handles before any
+  // legacy trigger (e.g. on_connect at SEARCH_CMPL) fires - the neutral
+  // engine's order.
   this->dispatch_gatt_event_(event, param);
 #endif
+  for (auto *node : this->nodes_)
+    node->gattc_event_handler(event, esp_gattc_if, param);
   this->maybe_release_services_();
   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");
@@ -102,14 +106,10 @@ void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_p
 
 void BLEClient::set_state(espbt::ClientState state) {
   BLEClientBase::set_state(state);
+  // ESTABLISHED never flows through here (the base sets it internally); gatt
+  // nodes (members of nodes_ too) are promoted after the on_connected fan-out.
   for (auto &node : nodes_)
     node->node_state = state;
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  // ESTABLISHED never flows through here (the base sets it internally);
-  // gatt nodes are promoted explicitly after the on_connected fan-out.
-  for (auto *node : this->gatt_nodes_)
-    node->node_state = state;
-#endif
 }
 
 bool BLEClient::all_nodes_established_() {
@@ -119,19 +119,12 @@ bool BLEClient::all_nodes_established_() {
     if (node->node_state != espbt::ClientState::ESTABLISHED)
       return false;
   }
-#ifdef USE_BLE_CLIENT_GATT_NODES
-  for (auto *node : this->gatt_nodes_) {
-    if (node->node_state != espbt::ClientState::ESTABLISHED)
-      return false;
-  }
-#endif
   return true;
 }
 
 #ifdef USE_BLE_CLIENT_GATT_NODES
 
 void BLEClient::register_gatt_node(BLEClientNode *node) {
-  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.
@@ -139,22 +132,21 @@ void BLEClient::register_gatt_node(BLEClientNode *node) {
     return;
   }
   this->gatt_nodes_.push_back(node);
+  // Membership in nodes_ covers the shared state bookkeeping (node_state,
+  // release condition); gatt_nodes_ is the neutral fan-out subset.
+  this->register_ble_node(node);
 }
 
 bool BLEClient::take_pending_gatt_reg_(uint16_t handle) {
-  bool found = false;
-  // Erase every match: a stale duplicate must never swallow a later legacy
-  // registration of the same handle.
-  auto &regs = this->pending_gatt_regs_;
-  for (auto it = regs.begin(); it != regs.end();) {
-    if (*it == handle) {
-      it = regs.erase(it);
-      found = true;
-    } else {
-      ++it;
+  // No duplicates possible: notify_characteristic() refuses a re-push while
+  // one is pending, so a single swap-with-last removal suffices.
+  for (uint8_t i = 0; i < this->pending_gatt_reg_count_; i++) {
+    if (this->pending_gatt_regs_[i] == handle) {
+      this->pending_gatt_regs_[i] = this->pending_gatt_regs_[--this->pending_gatt_reg_count_];
+      return true;
     }
   }
-  return found;
+  return false;
 }
 
 void BLEClient::dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param) {
@@ -199,18 +191,14 @@ void BLEClient::dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_c
 void BLEClient::handle_gatt_search_cmpl_(esp_gatt_status_t status) {
   // The base establishes without reading the search status; the neutral
   // contract treats a failed or empty discovery as a failed connection.
-  uint16_t primary = 0;
-  uint16_t secondary = 0;
-  bool counted = status == ESP_GATT_OK &&
-                 esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_PRIMARY_SERVICE, 0x0001,
-                                              0xFFFF, 0, &primary) == ESP_GATT_OK &&
-                 esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_SECONDARY_SERVICE, 0x0001,
-                                              0xFFFF, 0, &secondary) == ESP_GATT_OK;
+  uint16_t service_total = 0;
+  bool counted = status == ESP_GATT_OK && bluetooth_connection::BluedroidServiceTable::count_services(
+                                              this->gattc_if_, this->conn_id_, &service_total);
   // Stack-owned: freed on scope exit; nodes copy their handles during
   // on_connected() per the borrowed-table contract.
   bluetooth_connection::BluedroidServiceTable table;
-  if (!counted || primary + secondary == 0 ||
-      !table.build(this->gattc_if_, this->conn_id_, primary + secondary, this->connection_index_)) {
+  if (!counted || service_total == 0 ||
+      !table.build(this->gattc_if_, this->conn_id_, service_total, this->connection_index_)) {
     ESP_LOGW(TAG, "[%s] Service table is empty; treating as failed discovery", this->address_str());
     this->disconnect();
     return;
@@ -233,7 +221,7 @@ void BLEClient::handle_gatt_search_cmpl_(esp_gatt_status_t status) {
 }
 
 void BLEClient::on_disconnect_complete(esp_err_t reason) {
-  this->pending_gatt_regs_.clear();
+  this->pending_gatt_reg_count_ = 0;
   if (!this->gatt_connected_)
     return;  // Never-established links report nothing (neutral parity).
   this->gatt_connected_ = false;
@@ -241,45 +229,68 @@ void BLEClient::on_disconnect_complete(esp_err_t reason) {
     node->on_disconnected();
 }
 
+int BLEClient::check_gatt_op_(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 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);
+  return this->check_gatt_op_(
+      "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 esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
+  return this->check_gatt_op_("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 esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE);
+  return this->check_gatt_op_(
+      "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 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);
+  return this->check_gatt_op_(
+      "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) {
+    for (uint8_t i = 0; i < this->pending_gatt_reg_count_; i++) {
+      if (this->pending_gatt_regs_[i] == handle) {
+        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_ == ESPHOME_BLE_CLIENT_MAX_NODES) {
+      // Registering without a pending entry would let the base's automatic
+      // CCCD write through; refuse loudly instead.
+      ESP_LOGE(TAG, "[%s] Too many pending notify registrations", this->address_str());
+      return ble_device_base::GATT_ERR_NO_MEMORY;
+    }
     // Reuses the base helper so its pending count holds the service-release
     // until the registration completes; the completion is intercepted before
     // the base's automatic CCCD write.
-    if (this->take_pending_gatt_reg_(handle))
-      ESP_LOGW(TAG, "[%s] Duplicate notify registration for handle 0x%04x", this->address_str(), handle);
     esp_err_t err = this->register_for_notify(handle);
     if (err == ESP_OK)
-      this->pending_gatt_regs_.push_back(handle);
+      this->pending_gatt_regs_[this->pending_gatt_reg_count_++] = handle;
     return err;
   }
   return esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle);

esphome/components/ble_client/ble_client.h

@@ -10,10 +10,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-#ifdef USE_BLE_CLIENT_GATT_NODES
-#include "esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h"
-#endif
-
 #include <esp_bt_defs.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gatt_common_api.h>
@@ -65,6 +61,7 @@ class BLEClient final : public BLEClientBase {
   /// 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
 
@@ -72,6 +69,7 @@ class BLEClient final : public BLEClientBase {
   bool all_nodes_established_();
   void maybe_release_services_();
 #ifdef USE_BLE_CLIENT_GATT_NODES
+  int check_gatt_op_(const char *operation, esp_err_t err);
   void dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param);
   void handle_gatt_search_cmpl_(esp_gatt_status_t status);
   bool take_pending_gatt_reg_(uint16_t handle);
@@ -83,8 +81,10 @@ class BLEClient final : public BLEClientBase {
   // Nodes on the neutral surface; fed the translated callbacks and
   // auto-established after the on_connected fan-out.
   StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> gatt_nodes_;
-  // Bridge-initiated notify registrations awaiting REG_FOR_NOTIFY_EVT.
-  std::vector<uint16_t> pending_gatt_regs_;
+  // Bridge-initiated notify registrations awaiting REG_FOR_NOTIFY_EVT;
+  // bounded by the node count (one in-flight registration per node).
+  uint16_t pending_gatt_regs_[ESPHOME_BLE_CLIENT_MAX_NODES];
+  uint8_t pending_gatt_reg_count_{0};
   // on_connected fan-out started; on_disconnected is owed at teardown.
   bool gatt_connected_{false};
 #endif

esphome/components/ble_client/ble_client_node.h

@@ -24,7 +24,7 @@ class BLEClient;
 
 class BLEClientNode {
  public:
-#if defined(USE_BLE_CLIENT_GATT_NODES) || (defined(USE_BLE_GATT_CLIENT) && !defined(USE_ESP32))
+#ifdef USE_BLE_CLIENT_GATT_NODES
   // Neutral surface, delivered by both engines. The table is borrowed
   // backend storage, valid only for the duration of on_connected(): copy the
   // handles you need. All nodes see all completions/notifications; filter by

esphome/components/ble_client/ble_write_action.h

@@ -6,14 +6,14 @@
 
 #include "esphome/core/defines.h"
 
-#if defined(USE_BLE_CLIENT_GATT_NODES) || (defined(USE_BLE_GATT_CLIENT) && !defined(USE_ESP32))
+#ifdef USE_BLE_CLIENT_GATT_NODES
 
 #include <tuple>
 #include <vector>
 
-// One of the two resolves per build; both define class Automation's TAG box.
-#include "automation.h"
-#include "automation_gatt.h"
+// 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"
@@ -21,6 +21,8 @@
 
 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;
 
@@ -75,20 +77,20 @@ template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>
   // 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(Automation::TAG, "Cannot write to BLE characteristic - not connected");
+      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - not connected");
       return false;
     }
     if (!this->resolved_) {
-      esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - characteristic was not 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(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
+    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(Automation::TAG, "Error writing to characteristic: %d!", err);
+      esph_log_e(BLE_WRITE_TAG, "Error writing to characteristic: %d!", err);
       return false;
     }
     return true;
@@ -101,7 +103,7 @@ template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>
     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_action", "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
+      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;
     }
@@ -111,13 +113,13 @@ template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>
       this->write_response_ = false;
     } else {
       char char_buf[ble_device_base::UUID_STR_LEN];
-      esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+      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(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+    esph_log_d(BLE_WRITE_TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
                this->ble_client_->address_str());
   }
 
@@ -135,13 +137,13 @@ template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>
     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(Automation::TAG, "Write result for handle 0x%04x ignored, waiting on 0x%04x", handle,
+      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(Automation::TAG, "Write completed with status %d", error);
+      esph_log_w(BLE_WRITE_TAG, "Write completed with status %d", error);
     }
     this->ble_client_->run_later([this]() { this->play_next_tuple_(this->var_); });
   }
@@ -163,4 +165,4 @@ template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>
 
 }  // namespace esphome::ble_client
 
-#endif  // USE_BLE_CLIENT_GATT_NODES || (USE_BLE_GATT_CLIENT && !USE_ESP32)
+#endif  // USE_BLE_CLIENT_GATT_NODES

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.cpp

@@ -76,6 +76,20 @@ bool BluedroidServiceTable::walk_(ServiceFn &&on_service, CharFn &&on_char, Desc
   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;

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h

@@ -19,10 +19,13 @@ class BluedroidServiceTable {
  public:
   ~BluedroidServiceTable() { this->free(); }
 
-  /// Two-pass build from the stack's cached database. service_total MUST be
-  /// the esp_ble_gattc_get_attr_count(PRIMARY)+(SECONDARY) total, never the
-  /// SEARCH_RES event count. log_index labels warnings. Frees any previous
-  /// table first; on failure the table is left empty.
+  /// 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
@@ -45,6 +48,7 @@ class BluedroidServiceTable {
     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;
   }

esphome/core/defines.h

@@ -488,6 +488,7 @@
 #define ESPHOME_BLE_DEVICE_BASE_LISTENER_COUNT 1
 #define USE_BLE_SCAN_RESPONSE_MERGER
 #define USE_BLE_GATT_CLIENT
+#define USE_BLE_CLIENT_GATT_NODES
 #define ESPHOME_BLE_GATT_CLIENT_COUNT 3
 #define ESPHOME_BLE_CLIENT_MAX_NODES 1
 #define USE_RP2040_VARIANT_RP2040