Merge branch 'rf_bridge_batch_read' into integration_batch_read

The ack polling loop has a tight timing requirement with
delay_microseconds_safe(1450) between iterations. Snapshotting
available() once could leave partial ack response bytes unread
until after the delay, potentially breaking cold boot timing
on some ld2420 units. Keep batch reads only in loop().

esphome/components/api/api_connection.h

@@ -28,7 +28,7 @@ static constexpr size_t MAX_INITIAL_PER_BATCH = 34;         // For clients >= AP
 static_assert(MAX_MESSAGES_PER_BATCH >= MAX_INITIAL_PER_BATCH,
               "MAX_MESSAGES_PER_BATCH must be >= MAX_INITIAL_PER_BATCH");
 
-class APIConnection final : public APIServerConnectionBase {
+class APIConnection final : public APIServerConnection {
  public:
   friend class APIServer;
   friend class ListEntitiesIterator;

esphome/components/api/api_pb2.h

@@ -440,6 +440,19 @@ class PingResponse final : public ProtoMessage {
 
  protected:
 };
+class DeviceInfoRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 9;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "device_info_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 #ifdef USE_AREAS
 class AreaInfo final : public ProtoMessage {
  public:
@@ -533,6 +546,19 @@ class DeviceInfoResponse final : public ProtoMessage {
 
  protected:
 };
+class ListEntitiesRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 11;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "list_entities_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 class ListEntitiesDoneResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 19;
@@ -546,6 +572,19 @@ class ListEntitiesDoneResponse final : public ProtoMessage {
 
  protected:
 };
+class SubscribeStatesRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 20;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "subscribe_states_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 #ifdef USE_BINARY_SENSOR
 class ListEntitiesBinarySensorResponse final : public InfoResponseProtoMessage {
  public:
@@ -998,6 +1037,19 @@ class NoiseEncryptionSetKeyResponse final : public ProtoMessage {
 };
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
+class SubscribeHomeassistantServicesRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 34;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "subscribe_homeassistant_services_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 class HomeassistantServiceMap final : public ProtoMessage {
  public:
   StringRef key{};
@@ -1065,6 +1117,19 @@ class HomeassistantActionResponse final : public ProtoDecodableMessage {
 };
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
+class SubscribeHomeAssistantStatesRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 38;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "subscribe_home_assistant_states_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 class SubscribeHomeAssistantStateResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 39;
@@ -2095,6 +2160,19 @@ class BluetoothGATTNotifyDataResponse final : public ProtoMessage {
 
  protected:
 };
+class SubscribeBluetoothConnectionsFreeRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 80;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "subscribe_bluetooth_connections_free_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 class BluetoothConnectionsFreeResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 81;
@@ -2201,6 +2279,19 @@ class BluetoothDeviceUnpairingResponse final : public ProtoMessage {
 
  protected:
 };
+class UnsubscribeBluetoothLEAdvertisementsRequest final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 87;
+  static constexpr uint8_t ESTIMATED_SIZE = 0;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "unsubscribe_bluetooth_le_advertisements_request"; }
+#endif
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 class BluetoothDeviceClearCacheResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 88;

esphome/components/api/api_pb2_dump.cpp

@@ -764,6 +764,10 @@ const char *PingResponse::dump_to(DumpBuffer &out) const {
   out.append("PingResponse {}");
   return out.c_str();
 }
+const char *DeviceInfoRequest::dump_to(DumpBuffer &out) const {
+  out.append("DeviceInfoRequest {}");
+  return out.c_str();
+}
 #ifdef USE_AREAS
 const char *AreaInfo::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "AreaInfo");
@@ -844,10 +848,18 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
 #endif
   return out.c_str();
 }
+const char *ListEntitiesRequest::dump_to(DumpBuffer &out) const {
+  out.append("ListEntitiesRequest {}");
+  return out.c_str();
+}
 const char *ListEntitiesDoneResponse::dump_to(DumpBuffer &out) const {
   out.append("ListEntitiesDoneResponse {}");
   return out.c_str();
 }
+const char *SubscribeStatesRequest::dump_to(DumpBuffer &out) const {
+  out.append("SubscribeStatesRequest {}");
+  return out.c_str();
+}
 #ifdef USE_BINARY_SENSOR
 const char *ListEntitiesBinarySensorResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "ListEntitiesBinarySensorResponse");
@@ -1179,6 +1191,10 @@ const char *NoiseEncryptionSetKeyResponse::dump_to(DumpBuffer &out) const {
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
+const char *SubscribeHomeassistantServicesRequest::dump_to(DumpBuffer &out) const {
+  out.append("SubscribeHomeassistantServicesRequest {}");
+  return out.c_str();
+}
 const char *HomeassistantServiceMap::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "HomeassistantServiceMap");
   dump_field(out, "key", this->key);
@@ -1229,6 +1245,10 @@ const char *HomeassistantActionResponse::dump_to(DumpBuffer &out) const {
 }
 #endif
 #ifdef USE_API_HOMEASSISTANT_STATES
+const char *SubscribeHomeAssistantStatesRequest::dump_to(DumpBuffer &out) const {
+  out.append("SubscribeHomeAssistantStatesRequest {}");
+  return out.c_str();
+}
 const char *SubscribeHomeAssistantStateResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "SubscribeHomeAssistantStateResponse");
   dump_field(out, "entity_id", this->entity_id);
@@ -1904,6 +1924,10 @@ const char *BluetoothGATTNotifyDataResponse::dump_to(DumpBuffer &out) const {
   dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
   return out.c_str();
 }
+const char *SubscribeBluetoothConnectionsFreeRequest::dump_to(DumpBuffer &out) const {
+  out.append("SubscribeBluetoothConnectionsFreeRequest {}");
+  return out.c_str();
+}
 const char *BluetoothConnectionsFreeResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "BluetoothConnectionsFreeResponse");
   dump_field(out, "free", this->free);
@@ -1946,6 +1970,10 @@ const char *BluetoothDeviceUnpairingResponse::dump_to(DumpBuffer &out) const {
   dump_field(out, "error", this->error);
   return out.c_str();
 }
+const char *UnsubscribeBluetoothLEAdvertisementsRequest::dump_to(DumpBuffer &out) const {
+  out.append("UnsubscribeBluetoothLEAdvertisementsRequest {}");
+  return out.c_str();
+}
 const char *BluetoothDeviceClearCacheResponse::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "BluetoothDeviceClearCacheResponse");
   dump_field(out, "address", this->address);

esphome/components/api/api_pb2_service.cpp

@@ -21,23 +21,6 @@ void APIServerConnectionBase::log_receive_message_(const LogString *name) {
 #endif
 
 void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
-  // Check authentication/connection requirements
-  switch (msg_type) {
-    case HelloRequest::MESSAGE_TYPE:       // No setup required
-    case DisconnectRequest::MESSAGE_TYPE:  // No setup required
-    case PingRequest::MESSAGE_TYPE:        // No setup required
-      break;
-    case 9 /* DeviceInfoRequest is empty */:  // Connection setup only
-      if (!this->check_connection_setup_()) {
-        return;
-      }
-      break;
-    default:
-      if (!this->check_authenticated_()) {
-        return;
-      }
-      break;
-  }
   switch (msg_type) {
     case HelloRequest::MESSAGE_TYPE: {
       HelloRequest msg;
@@ -76,21 +59,21 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_ping_response();
       break;
     }
-    case 9 /* DeviceInfoRequest is empty */: {
+    case DeviceInfoRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_device_info_request"));
 #endif
       this->on_device_info_request();
       break;
     }
-    case 11 /* ListEntitiesRequest is empty */: {
+    case ListEntitiesRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_list_entities_request"));
 #endif
       this->on_list_entities_request();
       break;
     }
-    case 20 /* SubscribeStatesRequest is empty */: {
+    case SubscribeStatesRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_subscribe_states_request"));
 #endif
@@ -151,7 +134,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
     }
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-    case 34 /* SubscribeHomeassistantServicesRequest is empty */: {
+    case SubscribeHomeassistantServicesRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_subscribe_homeassistant_services_request"));
 #endif
@@ -169,7 +152,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       break;
     }
 #ifdef USE_API_HOMEASSISTANT_STATES
-    case 38 /* SubscribeHomeAssistantStatesRequest is empty */: {
+    case SubscribeHomeAssistantStatesRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_subscribe_home_assistant_states_request"));
 #endif
@@ -376,7 +359,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
     }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-    case 80 /* SubscribeBluetoothConnectionsFreeRequest is empty */: {
+    case SubscribeBluetoothConnectionsFreeRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_connections_free_request"));
 #endif
@@ -385,7 +368,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
     }
 #endif
 #ifdef USE_BLUETOOTH_PROXY
-    case 87 /* UnsubscribeBluetoothLEAdvertisementsRequest is empty */: {
+    case UnsubscribeBluetoothLEAdvertisementsRequest::MESSAGE_TYPE: {
 #ifdef HAS_PROTO_MESSAGE_DUMP
       this->log_receive_message_(LOG_STR("on_unsubscribe_bluetooth_le_advertisements_request"));
 #endif
@@ -640,4 +623,28 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
   }
 }
 
+void APIServerConnection::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {
+  // Check authentication/connection requirements for messages
+  switch (msg_type) {
+    case HelloRequest::MESSAGE_TYPE:       // No setup required
+    case DisconnectRequest::MESSAGE_TYPE:  // No setup required
+    case PingRequest::MESSAGE_TYPE:        // No setup required
+      break;                               // Skip all checks for these messages
+    case DeviceInfoRequest::MESSAGE_TYPE:  // Connection setup only
+      if (!this->check_connection_setup_()) {
+        return;  // Connection not setup
+      }
+      break;
+    default:
+      // All other messages require authentication (which includes connection check)
+      if (!this->check_authenticated_()) {
+        return;  // Authentication failed
+      }
+      break;
+  }
+
+  // Call base implementation to process the message
+  APIServerConnectionBase::read_message(msg_size, msg_type, msg_data);
+}
+
 }  // namespace esphome::api

esphome/components/api/api_pb2_service.h

@@ -228,4 +228,9 @@ class APIServerConnectionBase : public ProtoService {
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };
 
+class APIServerConnection : public APIServerConnectionBase {
+ protected:
+  void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
+};
+
 }  // namespace esphome::api

esphome/components/api/homeassistant_service.h

@@ -25,9 +25,7 @@ template<typename... X> class TemplatableStringValue : public TemplatableValue<s
 
  private:
   // Helper to convert value to string - handles the case where value is already a string
-  template<typename T> static std::string value_to_string(T &&val) {
-    return to_string(std::forward<T>(val));  // NOLINT
-  }
+  template<typename T> static std::string value_to_string(T &&val) { return to_string(std::forward<T>(val)); }
 
   // Overloads for string types - needed because std::to_string doesn't support them
   static std::string value_to_string(char *val) {

esphome/components/aqi/aqi_calculator.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <algorithm>
 #include <cmath>
 #include <limits>
 #include "abstract_aqi_calculator.h"
@@ -15,11 +14,7 @@ class AQICalculator : public AbstractAQICalculator {
     float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
     float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
 
-    float aqi = std::max(pm2_5_index, pm10_0_index);
-    if (aqi < 0.0f) {
-      aqi = 0.0f;
-    }
-    return static_cast<uint16_t>(std::lround(aqi));
+    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
   }
 
  protected:
@@ -27,27 +22,13 @@ class AQICalculator : public AbstractAQICalculator {
 
   static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 50}, {51, 100}, {101, 150}, {151, 200}, {201, 300}, {301, 500}};
 
-  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {
-      // clang-format off
-      {0.0f, 9.1f},
-      {9.1f, 35.5f},
-      {35.5f, 55.5f},
-      {55.5f, 125.5f},
-      {125.5f, 225.5f},
-      {225.5f, std::numeric_limits<float>::max()}
-      // clang-format on
-  };
+  static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {{0.0f, 9.0f},     {9.1f, 35.4f},
+                                                      {35.5f, 55.4f},   {55.5f, 125.4f},
+                                                      {125.5f, 225.4f}, {225.5f, std::numeric_limits<float>::max()}};
 
-  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
-      // clang-format off
-      {0.0f, 55.0f},
-      {55.0f, 155.0f},
-      {155.0f, 255.0f},
-      {255.0f, 355.0f},
-      {355.0f, 425.0f},
-      {425.0f, std::numeric_limits<float>::max()}
-      // clang-format on
-  };
+  static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {{0.0f, 54.0f},    {55.0f, 154.0f},
+                                                       {155.0f, 254.0f}, {255.0f, 354.0f},
+                                                       {355.0f, 424.0f}, {425.0f, std::numeric_limits<float>::max()}};
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
     int grid_index = get_grid_index(value, array);
@@ -64,10 +45,7 @@ class AQICalculator : public AbstractAQICalculator {
 
   static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
     for (int i = 0; i < NUM_LEVELS; i++) {
-      const bool in_range =
-          (value >= array[i][0]) && ((i == NUM_LEVELS - 1) ? (value <= array[i][1])   // last bucket inclusive
-                                                           : (value < array[i][1]));  // others exclusive on hi
-      if (in_range) {
+      if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }
     }

esphome/components/aqi/caqi_calculator.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <algorithm>
 #include <cmath>
 #include <limits>
 #include "abstract_aqi_calculator.h"
@@ -13,11 +12,7 @@ class CAQICalculator : public AbstractAQICalculator {
     float pm2_5_index = calculate_index(pm2_5_value, PM2_5_GRID);
     float pm10_0_index = calculate_index(pm10_0_value, PM10_0_GRID);
 
-    float aqi = std::max(pm2_5_index, pm10_0_index);
-    if (aqi < 0.0f) {
-      aqi = 0.0f;
-    }
-    return static_cast<uint16_t>(std::lround(aqi));
+    return static_cast<uint16_t>(std::round((pm2_5_index < pm10_0_index) ? pm10_0_index : pm2_5_index));
   }
 
  protected:
@@ -26,24 +21,10 @@ class CAQICalculator : public AbstractAQICalculator {
   static constexpr int INDEX_GRID[NUM_LEVELS][2] = {{0, 25}, {26, 50}, {51, 75}, {76, 100}, {101, 400}};
 
   static constexpr float PM2_5_GRID[NUM_LEVELS][2] = {
-      // clang-format off
-      {0.0f, 15.1f},
-      {15.1f, 30.1f},
-      {30.1f, 55.1f},
-      {55.1f, 110.1f},
-      {110.1f, std::numeric_limits<float>::max()}
-      // clang-format on
-  };
+      {0.0f, 15.0f}, {15.1f, 30.0f}, {30.1f, 55.0f}, {55.1f, 110.0f}, {110.1f, std::numeric_limits<float>::max()}};
 
   static constexpr float PM10_0_GRID[NUM_LEVELS][2] = {
-      // clang-format off
-      {0.0f, 25.1f},
-      {25.1f, 50.1f},
-      {50.1f, 90.1f},
-      {90.1f, 180.1f},
-      {180.1f, std::numeric_limits<float>::max()}
-      // clang-format on
-  };
+      {0.0f, 25.0f}, {25.1f, 50.0f}, {50.1f, 90.0f}, {90.1f, 180.0f}, {180.1f, std::numeric_limits<float>::max()}};
 
   static float calculate_index(float value, const float array[NUM_LEVELS][2]) {
     int grid_index = get_grid_index(value, array);
@@ -61,10 +42,7 @@ class CAQICalculator : public AbstractAQICalculator {
 
   static int get_grid_index(float value, const float array[NUM_LEVELS][2]) {
     for (int i = 0; i < NUM_LEVELS; i++) {
-      const bool in_range =
-          (value >= array[i][0]) && ((i == NUM_LEVELS - 1) ? (value <= array[i][1])   // last bucket inclusive
-                                                           : (value < array[i][1]));  // others exclusive on hi
-      if (in_range) {
+      if (value >= array[i][0] && value <= array[i][1]) {
         return i;
       }
     }

esphome/components/binary_sensor/automation.cpp

@@ -5,14 +5,6 @@ namespace esphome::binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-// MultiClickTrigger timeout IDs.
-// MultiClickTrigger is its own Component instance, so the scheduler scopes
-// IDs by component pointer — no risk of collisions between instances.
-constexpr uint32_t MULTICLICK_TRIGGER_ID = 0;
-constexpr uint32_t MULTICLICK_COOLDOWN_ID = 1;
-constexpr uint32_t MULTICLICK_IS_VALID_ID = 2;
-constexpr uint32_t MULTICLICK_IS_NOT_VALID_ID = 3;
-
 void MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
@@ -35,7 +27,7 @@ void MultiClickTrigger::on_state_(bool state) {
                evt.min_length, evt.max_length);
       this->at_index_ = 1;
       if (this->timing_.size() == 1 && evt.max_length == 4294967294UL) {
-        this->set_timeout(MULTICLICK_TRIGGER_ID, evt.min_length, [this]() { this->trigger_(); });
+        this->set_timeout("trigger", evt.min_length, [this]() { this->trigger_(); });
       } else {
         this->schedule_is_valid_(evt.min_length);
         this->schedule_is_not_valid_(evt.max_length);
@@ -65,13 +57,13 @@ void MultiClickTrigger::on_state_(bool state) {
     this->schedule_is_not_valid_(evt.max_length);
   } else if (*this->at_index_ + 1 != this->timing_.size()) {
     ESP_LOGV(TAG, "B i=%zu min=%" PRIu32, *this->at_index_, evt.min_length);  // NOLINT
-    this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
+    this->cancel_timeout("is_not_valid");
     this->schedule_is_valid_(evt.min_length);
   } else {
     ESP_LOGV(TAG, "C i=%zu min=%" PRIu32, *this->at_index_, evt.min_length);  // NOLINT
     this->is_valid_ = false;
-    this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
-    this->set_timeout(MULTICLICK_TRIGGER_ID, evt.min_length, [this]() { this->trigger_(); });
+    this->cancel_timeout("is_not_valid");
+    this->set_timeout("trigger", evt.min_length, [this]() { this->trigger_(); });
   }
 
   *this->at_index_ = *this->at_index_ + 1;
@@ -79,14 +71,14 @@ void MultiClickTrigger::on_state_(bool state) {
 void MultiClickTrigger::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
   this->is_in_cooldown_ = true;
-  this->set_timeout(MULTICLICK_COOLDOWN_ID, this->invalid_cooldown_, [this]() {
+  this->set_timeout("cooldown", this->invalid_cooldown_, [this]() {
     ESP_LOGV(TAG, "Multi Click: Cooldown ended, matching is now enabled again.");
     this->is_in_cooldown_ = false;
   });
   this->at_index_.reset();
-  this->cancel_timeout(MULTICLICK_TRIGGER_ID);
-  this->cancel_timeout(MULTICLICK_IS_VALID_ID);
-  this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
+  this->cancel_timeout("trigger");
+  this->cancel_timeout("is_valid");
+  this->cancel_timeout("is_not_valid");
 }
 void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
@@ -94,13 +86,13 @@ void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     return;
   }
   this->is_valid_ = false;
-  this->set_timeout(MULTICLICK_IS_VALID_ID, min_length, [this]() {
+  this->set_timeout("is_valid", min_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You can now %s the button.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = true;
   });
 }
 void MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
-  this->set_timeout(MULTICLICK_IS_NOT_VALID_ID, max_length, [this]() {
+  this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;
     this->schedule_cooldown_();
@@ -114,9 +106,9 @@ void MultiClickTrigger::cancel() {
 void MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
-  this->cancel_timeout(MULTICLICK_TRIGGER_ID);
-  this->cancel_timeout(MULTICLICK_IS_VALID_ID);
-  this->cancel_timeout(MULTICLICK_IS_NOT_VALID_ID);
+  this->cancel_timeout("trigger");
+  this->cancel_timeout("is_valid");
+  this->cancel_timeout("is_not_valid");
   this->trigger();
 }
 

esphome/components/binary_sensor/filter.cpp

@@ -6,14 +6,6 @@ namespace esphome::binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
-// Timeout IDs for filter classes.
-// Each filter is its own Component instance, so the scheduler scopes
-// IDs by component pointer — no risk of collisions between instances.
-constexpr uint32_t FILTER_TIMEOUT_ID = 0;
-// AutorepeatFilter needs two distinct IDs (both timeouts on the same component)
-constexpr uint32_t AUTOREPEAT_TIMING_ID = 0;
-constexpr uint32_t AUTOREPEAT_ON_OFF_ID = 1;
-
 void Filter::output(bool value) {
   if (this->next_ == nullptr) {
     this->parent_->send_state_internal(value);
@@ -31,16 +23,16 @@ void Filter::input(bool value) {
 }
 
 void TimeoutFilter::input(bool value) {
-  this->set_timeout(FILTER_TIMEOUT_ID, this->timeout_delay_.value(), [this]() { this->parent_->invalidate_state(); });
+  this->set_timeout("timeout", this->timeout_delay_.value(), [this]() { this->parent_->invalidate_state(); });
   // we do not de-dup here otherwise changes from invalid to valid state will not be output
   this->output(value);
 }
 
 optional<bool> DelayedOnOffFilter::new_value(bool value) {
   if (value) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->on_delay_.value(), [this]() { this->output(true); });
+    this->set_timeout("ON_OFF", this->on_delay_.value(), [this]() { this->output(true); });
   } else {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->off_delay_.value(), [this]() { this->output(false); });
+    this->set_timeout("ON_OFF", this->off_delay_.value(), [this]() { this->output(false); });
   }
   return {};
 }
@@ -49,10 +41,10 @@ float DelayedOnOffFilter::get_setup_priority() const { return setup_priority::HA
 
 optional<bool> DelayedOnFilter::new_value(bool value) {
   if (value) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this]() { this->output(true); });
+    this->set_timeout("ON", this->delay_.value(), [this]() { this->output(true); });
     return {};
   } else {
-    this->cancel_timeout(FILTER_TIMEOUT_ID);
+    this->cancel_timeout("ON");
     return false;
   }
 }
@@ -61,10 +53,10 @@ float DelayedOnFilter::get_setup_priority() const { return setup_priority::HARDW
 
 optional<bool> DelayedOffFilter::new_value(bool value) {
   if (!value) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this]() { this->output(false); });
+    this->set_timeout("OFF", this->delay_.value(), [this]() { this->output(false); });
     return {};
   } else {
-    this->cancel_timeout(FILTER_TIMEOUT_ID);
+    this->cancel_timeout("OFF");
     return true;
   }
 }
@@ -84,8 +76,8 @@ optional<bool> AutorepeatFilter::new_value(bool value) {
     this->next_timing_();
     return true;
   } else {
-    this->cancel_timeout(AUTOREPEAT_TIMING_ID);
-    this->cancel_timeout(AUTOREPEAT_ON_OFF_ID);
+    this->cancel_timeout("TIMING");
+    this->cancel_timeout("ON_OFF");
     this->active_timing_ = 0;
     return false;
   }
@@ -96,10 +88,8 @@ void AutorepeatFilter::next_timing_() {
   // 1st time: starts waiting the first delay
   // 2nd time: starts waiting the second delay and starts toggling with the first time_off / _on
   // last time: no delay to start but have to bump the index to reflect the last
-  if (this->active_timing_ < this->timings_.size()) {
-    this->set_timeout(AUTOREPEAT_TIMING_ID, this->timings_[this->active_timing_].delay,
-                      [this]() { this->next_timing_(); });
-  }
+  if (this->active_timing_ < this->timings_.size())
+    this->set_timeout("TIMING", this->timings_[this->active_timing_].delay, [this]() { this->next_timing_(); });
 
   if (this->active_timing_ <= this->timings_.size()) {
     this->active_timing_++;
@@ -114,8 +104,7 @@ void AutorepeatFilter::next_timing_() {
 void AutorepeatFilter::next_value_(bool val) {
   const AutorepeatFilterTiming &timing = this->timings_[this->active_timing_ - 2];
   this->output(val);  // This is at least the second one so not initial
-  this->set_timeout(AUTOREPEAT_ON_OFF_ID, val ? timing.time_on : timing.time_off,
-                    [this, val]() { this->next_value_(!val); });
+  this->set_timeout("ON_OFF", val ? timing.time_on : timing.time_off, [this, val]() { this->next_value_(!val); });
 }
 
 float AutorepeatFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
@@ -126,7 +115,7 @@ optional<bool> LambdaFilter::new_value(bool value) { return this->f_(value); }
 
 optional<bool> SettleFilter::new_value(bool value) {
   if (!this->steady_) {
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this, value]() {
+    this->set_timeout("SETTLE", this->delay_.value(), [this, value]() {
       this->steady_ = true;
       this->output(value);
     });
@@ -134,7 +123,7 @@ optional<bool> SettleFilter::new_value(bool value) {
   } else {
     this->steady_ = false;
     this->output(value);
-    this->set_timeout(FILTER_TIMEOUT_ID, this->delay_.value(), [this]() { this->steady_ = true; });
+    this->set_timeout("SETTLE", this->delay_.value(), [this]() { this->steady_ = true; });
     return value;
   }
 }

esphome/components/bl0942/bl0942.cpp

@@ -46,16 +46,16 @@ static const uint32_t PKT_TIMEOUT_MS = 200;
 
 void BL0942::loop() {
   DataPacket buffer;
-  size_t avail = this->available();
+  int avail = this->available();
 
   if (!avail) {
     return;
   }
-  if (avail < sizeof(buffer)) {
+  if (static_cast<size_t>(avail) < sizeof(buffer)) {
     if (!this->rx_start_) {
       this->rx_start_ = millis();
     } else if (millis() > this->rx_start_ + PKT_TIMEOUT_MS) {
-      ESP_LOGW(TAG, "Junk on wire. Throwing away partial message (%zu bytes)", avail);
+      ESP_LOGW(TAG, "Junk on wire. Throwing away partial message (%d bytes)", avail);
       this->read_array((uint8_t *) &buffer, avail);
       this->rx_start_ = 0;
     }

esphome/components/cse7766/cse7766.cpp

@@ -16,8 +16,8 @@ void CSE7766Component::loop() {
   }
 
   // Early return prevents updating last_transmission_ when no data is available.
-  size_t avail = this->available();
-  if (avail == 0) {
+  int avail = this->available();
+  if (avail <= 0) {
     return;
   }
 
@@ -27,7 +27,7 @@ void CSE7766Component::loop() {
   // At 4800 baud (~480 bytes/sec) with ~122 Hz loop rate, typically ~4 bytes per call.
   uint8_t buf[CSE7766_RAW_DATA_SIZE];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/dfplayer/dfplayer.cpp

@@ -133,10 +133,10 @@ void DFPlayer::send_cmd_(uint8_t cmd, uint16_t argument) {
 
 void DFPlayer::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/dlms_meter/dlms_meter.cpp

@@ -28,7 +28,7 @@ void DlmsMeterComponent::dump_config() {
 
 void DlmsMeterComponent::loop() {
   // Read while data is available, netznoe uses two frames so allow 2x max frame length
-  size_t avail = this->available();
+  int avail = this->available();
   if (avail > 0) {
     size_t remaining = MBUS_MAX_FRAME_LENGTH * 2 - this->receive_buffer_.size();
     if (remaining == 0) {
@@ -36,12 +36,12 @@ void DlmsMeterComponent::loop() {
     } else {
       // Read all available bytes in batches to reduce UART call overhead.
       // Cap reads to remaining buffer capacity.
-      if (avail > remaining) {
+      if (static_cast<size_t>(avail) > remaining) {
         avail = remaining;
       }
       uint8_t buf[64];
       while (avail > 0) {
-        size_t to_read = std::min(avail, sizeof(buf));
+        size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
         if (!this->read_array(buf, to_read)) {
           break;
         }

esphome/components/dsmr/dsmr.cpp

@@ -120,9 +120,9 @@ void Dsmr::stop_requesting_data_() {
 
 void Dsmr::drain_rx_buffer_() {
   uint8_t buf[64];
-  size_t avail;
+  int avail;
   while ((avail = this->available()) > 0) {
-    if (!this->read_array(buf, std::min(avail, sizeof(buf)))) {
+    if (!this->read_array(buf, std::min(static_cast<size_t>(avail), sizeof(buf)))) {
       break;
     }
   }
@@ -134,15 +134,16 @@ void Dsmr::reset_telegram_() {
   this->bytes_read_ = 0;
   this->crypt_bytes_read_ = 0;
   this->crypt_telegram_len_ = 0;
+  this->last_read_time_ = 0;
 }
 
 void Dsmr::receive_telegram_() {
   while (this->available_within_timeout_()) {
     // Read all available bytes in batches to reduce UART call overhead.
     uint8_t buf[64];
-    size_t avail = this->available();
+    int avail = this->available();
     while (avail > 0) {
-      size_t to_read = std::min(avail, sizeof(buf));
+      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
       if (!this->read_array(buf, to_read))
         return;
       avail -= to_read;
@@ -206,9 +207,9 @@ void Dsmr::receive_encrypted_telegram_() {
   while (this->available_within_timeout_()) {
     // Read all available bytes in batches to reduce UART call overhead.
     uint8_t buf[64];
-    size_t avail = this->available();
+    int avail = this->available();
     while (avail > 0) {
-      size_t to_read = std::min(avail, sizeof(buf));
+      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
       if (!this->read_array(buf, to_read))
         return;
       avail -= to_read;

esphome/components/esp32/__init__.py

@@ -1435,10 +1435,6 @@ async def to_code(config):
         CORE.relative_internal_path(".espressif")
     )
 
-    # Set the uv cache inside the data dir so "Clean All" clears it.
-    # Avoids persistent corrupted cache from mid-stream download failures.
-    os.environ["UV_CACHE_DIR"] = str(CORE.relative_internal_path(".uv_cache"))
-
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         cg.add_build_flag("-DUSE_ESP_IDF")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")

esphome/components/esp32_ble/ble.cpp

@@ -369,9 +369,42 @@ bool ESP32BLE::ble_dismantle_() {
 }
 
 void ESP32BLE::loop() {
-  if (this->state_ != BLE_COMPONENT_STATE_ACTIVE) {
-    this->loop_handle_state_transition_not_active_();
-    return;
+  switch (this->state_) {
+    case BLE_COMPONENT_STATE_OFF:
+    case BLE_COMPONENT_STATE_DISABLED:
+      return;
+    case BLE_COMPONENT_STATE_DISABLE: {
+      ESP_LOGD(TAG, "Disabling");
+
+#ifdef ESPHOME_ESP32_BLE_BLE_STATUS_EVENT_HANDLER_COUNT
+      for (auto *ble_event_handler : this->ble_status_event_handlers_) {
+        ble_event_handler->ble_before_disabled_event_handler();
+      }
+#endif
+
+      if (!ble_dismantle_()) {
+        ESP_LOGE(TAG, "Could not be dismantled");
+        this->mark_failed();
+        return;
+      }
+      this->state_ = BLE_COMPONENT_STATE_DISABLED;
+      return;
+    }
+    case BLE_COMPONENT_STATE_ENABLE: {
+      ESP_LOGD(TAG, "Enabling");
+      this->state_ = BLE_COMPONENT_STATE_OFF;
+
+      if (!ble_setup_()) {
+        ESP_LOGE(TAG, "Could not be set up");
+        this->mark_failed();
+        return;
+      }
+
+      this->state_ = BLE_COMPONENT_STATE_ACTIVE;
+      return;
+    }
+    case BLE_COMPONENT_STATE_ACTIVE:
+      break;
   }
 
   BLEEvent *ble_event = this->ble_events_.pop();
@@ -487,37 +520,6 @@ void ESP32BLE::loop() {
   }
 }
 
-void ESP32BLE::loop_handle_state_transition_not_active_() {
-  // Caller ensures state_ != ACTIVE
-  if (this->state_ == BLE_COMPONENT_STATE_DISABLE) {
-    ESP_LOGD(TAG, "Disabling");
-
-#ifdef ESPHOME_ESP32_BLE_BLE_STATUS_EVENT_HANDLER_COUNT
-    for (auto *ble_event_handler : this->ble_status_event_handlers_) {
-      ble_event_handler->ble_before_disabled_event_handler();
-    }
-#endif
-
-    if (!ble_dismantle_()) {
-      ESP_LOGE(TAG, "Could not be dismantled");
-      this->mark_failed();
-      return;
-    }
-    this->state_ = BLE_COMPONENT_STATE_DISABLED;
-  } else if (this->state_ == BLE_COMPONENT_STATE_ENABLE) {
-    ESP_LOGD(TAG, "Enabling");
-    this->state_ = BLE_COMPONENT_STATE_OFF;
-
-    if (!ble_setup_()) {
-      ESP_LOGE(TAG, "Could not be set up");
-      this->mark_failed();
-      return;
-    }
-
-    this->state_ = BLE_COMPONENT_STATE_ACTIVE;
-  }
-}
-
 // Helper function to load new event data based on type
 void load_ble_event(BLEEvent *event, esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
   event->load_gap_event(e, p);

esphome/components/esp32_ble/ble.h

@@ -155,10 +155,6 @@ class ESP32BLE : public Component {
 #endif
   static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
 
-  // Handle DISABLE and ENABLE transitions when not in the ACTIVE state.
-  // Other non-ACTIVE states (e.g. OFF, DISABLED) are currently treated as no-ops.
-  void __attribute__((noinline)) loop_handle_state_transition_not_active_();
-
   bool ble_setup_();
   bool ble_dismantle_();
   bool ble_pre_setup_();

esphome/components/esp32_ble/ble_uuid.h

@@ -48,7 +48,7 @@ class ESPBTUUID {
 
   // Remove before 2026.8.0
   ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
-  std::string to_string() const;  // NOLINT
+  std::string to_string() const;
   const char *to_str(std::span<char, UUID_STR_LEN> output) const;
 
  protected:

esphome/components/hlk_fm22x/hlk_fm22x.cpp

@@ -1,16 +1,20 @@
 #include "hlk_fm22x.h"
 #include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include <array>
 #include <cinttypes>
 
 namespace esphome::hlk_fm22x {
 
 static const char *const TAG = "hlk_fm22x";
 
+// Maximum response size is 36 bytes (VERIFY reply: face_id + 32-byte name)
+static constexpr size_t HLK_FM22X_MAX_RESPONSE_SIZE = 36;
+
 void HlkFm22xComponent::setup() {
   ESP_LOGCONFIG(TAG, "Setting up HLK-FM22X...");
   this->set_enrolling_(false);
-  while (this->available() > 0) {
+  while (this->available()) {
     this->read();
   }
   this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_STATUS); });
@@ -31,7 +35,7 @@ void HlkFm22xComponent::update() {
 }
 
 void HlkFm22xComponent::enroll_face(const std::string &name, HlkFm22xFaceDirection direction) {
-  if (name.length() > HLK_FM22X_NAME_SIZE - 1) {
+  if (name.length() > 31) {
     ESP_LOGE(TAG, "enroll_face(): name too long '%s'", name.c_str());
     return;
   }
@@ -84,7 +88,7 @@ void HlkFm22xComponent::send_command_(HlkFm22xCommand command, const uint8_t *da
   }
   this->wait_cycles_ = 0;
   this->active_command_ = command;
-  while (this->available() > 0)
+  while (this->available())
     this->read();
   this->write((uint8_t) (START_CODE >> 8));
   this->write((uint8_t) (START_CODE & 0xFF));
@@ -133,24 +137,17 @@ void HlkFm22xComponent::recv_command_() {
   checksum ^= byte;
   length |= byte;
 
-  if (length > HLK_FM22X_MAX_RESPONSE_SIZE) {
-    ESP_LOGE(TAG, "Response too large: %u bytes", length);
-    // Discard exactly the remaining payload and checksum for this frame
-    for (uint16_t i = 0; i < length + 1 && this->available() > 0; ++i)
-      this->read();
-    return;
-  }
-
+  std::vector<uint8_t> data;
+  data.reserve(length);
   for (uint16_t idx = 0; idx < length; ++idx) {
     byte = this->read();
     checksum ^= byte;
-    this->recv_buf_[idx] = byte;
+    data.push_back(byte);
   }
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   char hex_buf[format_hex_pretty_size(HLK_FM22X_MAX_RESPONSE_SIZE)];
-  ESP_LOGV(TAG, "Recv type: 0x%.2X, data: %s", response_type,
-           format_hex_pretty_to(hex_buf, this->recv_buf_.data(), length));
+  ESP_LOGV(TAG, "Recv type: 0x%.2X, data: %s", response_type, format_hex_pretty_to(hex_buf, data.data(), data.size()));
 #endif
 
   byte = this->read();
@@ -160,10 +157,10 @@ void HlkFm22xComponent::recv_command_() {
   }
   switch (response_type) {
     case HlkFm22xResponseType::NOTE:
-      this->handle_note_(this->recv_buf_.data(), length);
+      this->handle_note_(data);
       break;
     case HlkFm22xResponseType::REPLY:
-      this->handle_reply_(this->recv_buf_.data(), length);
+      this->handle_reply_(data);
       break;
     default:
       ESP_LOGW(TAG, "Unexpected response type: 0x%.2X", response_type);
@@ -171,15 +168,11 @@ void HlkFm22xComponent::recv_command_() {
   }
 }
 
-void HlkFm22xComponent::handle_note_(const uint8_t *data, size_t length) {
-  if (length < 1) {
-    ESP_LOGE(TAG, "Empty note data");
-    return;
-  }
+void HlkFm22xComponent::handle_note_(const std::vector<uint8_t> &data) {
   switch (data[0]) {
     case HlkFm22xNoteType::FACE_STATE:
-      if (length < 17) {
-        ESP_LOGE(TAG, "Invalid face note data size: %zu", length);
+      if (data.size() < 17) {
+        ESP_LOGE(TAG, "Invalid face note data size: %u", data.size());
         break;
       }
       {
@@ -216,13 +209,9 @@ void HlkFm22xComponent::handle_note_(const uint8_t *data, size_t length) {
   }
 }
 
-void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
+void HlkFm22xComponent::handle_reply_(const std::vector<uint8_t> &data) {
   auto expected = this->active_command_;
   this->active_command_ = HlkFm22xCommand::NONE;
-  if (length < 2) {
-    ESP_LOGE(TAG, "Reply too short: %zu bytes", length);
-    return;
-  }
   if (data[0] != (uint8_t) expected) {
     ESP_LOGE(TAG, "Unexpected response command. Expected: 0x%.2X, Received: 0x%.2X", expected, data[0]);
     return;
@@ -249,20 +238,16 @@ void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
   }
   switch (expected) {
     case HlkFm22xCommand::VERIFY: {
-      if (length < 4 + HLK_FM22X_NAME_SIZE) {
-        ESP_LOGE(TAG, "VERIFY response too short: %zu bytes", length);
-        break;
-      }
       int16_t face_id = ((int16_t) data[2] << 8) | data[3];
-      const char *name_ptr = reinterpret_cast<const char *>(data + 4);
-      ESP_LOGD(TAG, "Face verified. ID: %d, name: %.*s", face_id, (int) HLK_FM22X_NAME_SIZE, name_ptr);
+      std::string name(data.begin() + 4, data.begin() + 36);
+      ESP_LOGD(TAG, "Face verified. ID: %d, name: %s", face_id, name.c_str());
       if (this->last_face_id_sensor_ != nullptr) {
         this->last_face_id_sensor_->publish_state(face_id);
       }
       if (this->last_face_name_text_sensor_ != nullptr) {
-        this->last_face_name_text_sensor_->publish_state(name_ptr, HLK_FM22X_NAME_SIZE);
+        this->last_face_name_text_sensor_->publish_state(name);
       }
-      this->face_scan_matched_callback_.call(face_id, std::string(name_ptr, HLK_FM22X_NAME_SIZE));
+      this->face_scan_matched_callback_.call(face_id, name);
       break;
     }
     case HlkFm22xCommand::ENROLL: {
@@ -281,8 +266,9 @@ void HlkFm22xComponent::handle_reply_(const uint8_t *data, size_t length) {
       this->defer([this]() { this->send_command_(HlkFm22xCommand::GET_VERSION); });
       break;
     case HlkFm22xCommand::GET_VERSION:
-      if (this->version_text_sensor_ != nullptr && length > 2) {
-        this->version_text_sensor_->publish_state(reinterpret_cast<const char *>(data + 2), length - 2);
+      if (this->version_text_sensor_ != nullptr) {
+        std::string version(data.begin() + 2, data.end());
+        this->version_text_sensor_->publish_state(version);
       }
       this->defer([this]() { this->get_face_count_(); });
       break;

esphome/components/hlk_fm22x/hlk_fm22x.h

@@ -7,15 +7,12 @@
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "esphome/components/uart/uart.h"
 
-#include <array>
 #include <utility>
+#include <vector>
 
 namespace esphome::hlk_fm22x {
 
 static const uint16_t START_CODE = 0xEFAA;
-static constexpr size_t HLK_FM22X_NAME_SIZE = 32;
-// Maximum response payload: command(1) + result(1) + face_id(2) + name(32) = 36
-static constexpr size_t HLK_FM22X_MAX_RESPONSE_SIZE = 36;
 enum HlkFm22xCommand {
   NONE = 0x00,
   RESET = 0x10,
@@ -121,11 +118,10 @@ class HlkFm22xComponent : public PollingComponent, public uart::UARTDevice {
   void get_face_count_();
   void send_command_(HlkFm22xCommand command, const uint8_t *data = nullptr, size_t size = 0);
   void recv_command_();
-  void handle_note_(const uint8_t *data, size_t length);
-  void handle_reply_(const uint8_t *data, size_t length);
+  void handle_note_(const std::vector<uint8_t> &data);
+  void handle_reply_(const std::vector<uint8_t> &data);
   void set_enrolling_(bool enrolling);
 
-  std::array<uint8_t, HLK_FM22X_MAX_RESPONSE_SIZE> recv_buf_;
   HlkFm22xCommand active_command_ = HlkFm22xCommand::NONE;
   uint16_t wait_cycles_ = 0;
   sensor::Sensor *face_count_sensor_{nullptr};

esphome/components/i2c/i2c_bus_arduino.cpp

@@ -134,23 +134,25 @@ ErrorCode ArduinoI2CBus::write_readv(uint8_t address, const uint8_t *write_buffe
     for (size_t j = 0; j != read_count; j++)
       read_buffer[j] = wire_->read();
   }
-  // Avoid switch to prevent compiler-generated lookup table in RAM on ESP8266
-  if (status == 0)
-    return ERROR_OK;
-  if (status == 1) {
-    ESP_LOGVV(TAG, "TX failed: buffer not large enough");
-    return ERROR_UNKNOWN;
+  switch (status) {
+    case 0:
+      return ERROR_OK;
+    case 1:
+      // transmit buffer not large enough
+      ESP_LOGVV(TAG, "TX failed: buffer not large enough");
+      return ERROR_UNKNOWN;
+    case 2:
+    case 3:
+      ESP_LOGVV(TAG, "TX failed: not acknowledged: %d", status);
+      return ERROR_NOT_ACKNOWLEDGED;
+    case 5:
+      ESP_LOGVV(TAG, "TX failed: timeout");
+      return ERROR_UNKNOWN;
+    case 4:
+    default:
+      ESP_LOGVV(TAG, "TX failed: unknown error %u", status);
+      return ERROR_UNKNOWN;
   }
-  if (status == 2 || status == 3) {
-    ESP_LOGVV(TAG, "TX failed: not acknowledged: %u", status);
-    return ERROR_NOT_ACKNOWLEDGED;
-  }
-  if (status == 5) {
-    ESP_LOGVV(TAG, "TX failed: timeout");
-    return ERROR_UNKNOWN;
-  }
-  ESP_LOGVV(TAG, "TX failed: unknown error %u", status);
-  return ERROR_UNKNOWN;
 }
 
 /// Perform I2C bus recovery, see:

esphome/components/ld2410/ld2410.cpp

@@ -276,10 +276,10 @@ void LD2410Component::restart_and_read_all_info() {
 
 void LD2410Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/ld2412/ld2412.cpp

@@ -311,10 +311,10 @@ void LD2412Component::restart_and_read_all_info() {
 
 void LD2412Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/ld2420/ld2420.cpp

@@ -542,10 +542,10 @@ void LD2420Component::handle_simple_mode_(const uint8_t *inbuf, int len) {
 
 void LD2420Component::read_batch_(std::span<uint8_t, MAX_LINE_LENGTH> buffer) {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/ld2450/ld2450.cpp

@@ -277,10 +277,10 @@ void LD2450Component::dump_config() {
 
 void LD2450Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[MAX_LINE_LENGTH];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/logger/logger.cpp

@@ -36,9 +36,8 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
 #endif
 
   // Fast path: main thread, no recursion (99.9% of all logs)
-  // Pass nullptr for thread_name since we already know this is the main task
   if (is_main_task && !this->main_task_recursion_guard_) [[likely]] {
-    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args, nullptr);
+    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args);
     return;
   }
 
@@ -48,23 +47,21 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
   }
 
   // Non-main thread handling (~0.1% of logs)
-  // Resolve thread name once and pass it through the logging chain.
-  // ESP32/LibreTiny: use TaskHandle_t overload to avoid redundant xTaskGetCurrentTaskHandle()
-  // (we already have the handle from the main task check above).
-  // Host: pass a stack buffer for pthread_getname_np to write into.
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  const char *thread_name = get_thread_name_(current_task);
+  this->log_vprintf_non_main_thread_(level, tag, line, format, args, current_task);
 #else  // USE_HOST
-  char thread_name_buf[THREAD_NAME_BUF_SIZE];
-  const char *thread_name = this->get_thread_name_(thread_name_buf);
+  this->log_vprintf_non_main_thread_(level, tag, line, format, args);
 #endif
-  this->log_vprintf_non_main_thread_(level, tag, line, format, args, thread_name);
 }
 
 // Handles non-main thread logging only
 // Kept separate from hot path to improve instruction cache performance
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
 void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                          const char *thread_name) {
+                                          TaskHandle_t current_task) {
+#else  // USE_HOST
+void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args) {
+#endif
   // Check if already in recursion for this non-main thread/task
   if (this->is_non_main_task_recursive_()) {
     return;
@@ -76,8 +73,12 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
   bool message_sent = false;
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // For non-main threads/tasks, queue the message for callbacks
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
   message_sent =
-      this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), thread_name, format, args);
+      this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), current_task, format, args);
+#else  // USE_HOST
+  message_sent = this->log_buffer_->send_message_thread_safe(level, tag, static_cast<uint16_t>(line), format, args);
+#endif
   if (message_sent) {
     // Enable logger loop to process the buffered message
     // This is safe to call from any context including ISRs
@@ -100,27 +101,19 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
 #endif
     char console_buffer[MAX_CONSOLE_LOG_MSG_SIZE];  // MUST be stack allocated for thread safety
     LogBuffer buf{console_buffer, MAX_CONSOLE_LOG_MSG_SIZE};
-    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf, thread_name);
+    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
     this->write_to_console_(buf);
   }
 
   // RAII guard automatically resets on return
 }
 #else
-// Implementation for single-task platforms (ESP8266, RP2040, Zephyr)
-// TODO: Zephyr may have multiple threads (work queues, etc.) but uses this single-task path.
-// Logging calls are NOT thread-safe: global_recursion_guard_ is a plain bool and tx_buffer_ has no locking.
-// Not a problem in practice yet since Zephyr has no API support (logs are console-only).
+// Implementation for all other platforms (single-task, no threading)
 void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
-#ifdef USE_ZEPHYR
-  char tmp[MAX_POINTER_REPRESENTATION];
-  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args,
-                                        this->get_thread_name_(tmp));
-#else  // Other single-task platforms don't have thread names, so pass nullptr
-  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args, nullptr);
-#endif
+
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_ESP32 / USE_HOST / USE_LIBRETINY
 
@@ -136,7 +129,7 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args, nullptr);
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 

esphome/components/logger/logger.h

@@ -2,7 +2,6 @@
 
 #include <cstdarg>
 #include <map>
-#include <span>
 #include <type_traits>
 #if defined(USE_ESP32) || defined(USE_HOST)
 #include <pthread.h>
@@ -125,10 +124,6 @@ static constexpr uint16_t MAX_HEADER_SIZE = 128;
 // "0x" + 2 hex digits per byte + '\0'
 static constexpr size_t MAX_POINTER_REPRESENTATION = 2 + sizeof(void *) * 2 + 1;
 
-// Stack buffer size for retrieving thread/task names from the OS
-// macOS allows up to 64 bytes, Linux up to 16
-static constexpr size_t THREAD_NAME_BUF_SIZE = 64;
-
 // Buffer wrapper for log formatting functions
 struct LogBuffer {
   char *data;
@@ -413,24 +408,34 @@ class Logger : public Component {
 
 #if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY)
   // Handles non-main thread logging only (~0.1% of calls)
-  // thread_name is resolved by the caller from the task handle, avoiding redundant lookups
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  // ESP32/LibreTiny: Pass task handle to avoid calling xTaskGetCurrentTaskHandle() twice
   void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                    const char *thread_name);
+                                    TaskHandle_t current_task);
+#else  // USE_HOST
+  // Host: No task handle parameter needed (not used in send_message_thread_safe)
+  void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args);
+#endif
 #endif
   void process_messages_();
   void write_msg_(const char *msg, uint16_t len);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
-  // thread_name: name of the calling thread/task, or nullptr for main task (callers already know which task they're on)
   inline void HOT format_log_to_buffer_with_terminator_(uint8_t level, const char *tag, int line, const char *format,
-                                                        va_list args, LogBuffer &buf, const char *thread_name) {
-    buf.write_header(level, tag, line, thread_name);
+                                                        va_list args, LogBuffer &buf) {
+#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_HOST)
+    buf.write_header(level, tag, line, this->get_thread_name_());
+#elif defined(USE_ZEPHYR)
+    char tmp[MAX_POINTER_REPRESENTATION];
+    buf.write_header(level, tag, line, this->get_thread_name_(tmp));
+#else
+    buf.write_header(level, tag, line, nullptr);
+#endif
     buf.format_body(format, args);
   }
 
 #ifdef USE_STORE_LOG_STR_IN_FLASH
   // Format a log message with flash string format and write it to a buffer with header, footer, and null terminator
-  // ESP8266-only (single-task), thread_name is always nullptr
   inline void HOT format_log_to_buffer_with_terminator_P_(uint8_t level, const char *tag, int line,
                                                           const __FlashStringHelper *format, va_list args,
                                                           LogBuffer &buf) {
@@ -461,10 +466,9 @@ class Logger : public Component {
 
   // Helper to format and send a log message to both console and listeners
   // Template handles both const char* (RAM) and __FlashStringHelper* (flash) format strings
-  // thread_name: name of the calling thread/task, or nullptr for main task
   template<typename FormatType>
   inline void HOT log_message_to_buffer_and_send_(bool &recursion_guard, uint8_t level, const char *tag, int line,
-                                                  FormatType format, va_list args, const char *thread_name) {
+                                                  FormatType format, va_list args) {
     RecursionGuard guard(recursion_guard);
     LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
 #ifdef USE_STORE_LOG_STR_IN_FLASH
@@ -473,7 +477,7 @@ class Logger : public Component {
     } else
 #endif
     {
-      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf, thread_name);
+      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
     }
     this->notify_listeners_(level, tag, buf);
     this->write_log_buffer_to_console_(buf);
@@ -561,57 +565,37 @@ class Logger : public Component {
   bool global_recursion_guard_{false};  // Simple global recursion guard for single-task platforms
 #endif
 
-  // --- get_thread_name_ overloads (per-platform) ---
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  // Primary overload - takes a task handle directly to avoid redundant xTaskGetCurrentTaskHandle() calls
-  // when the caller already has the handle (e.g. from the main task check in log_vprintf_)
-  const char *get_thread_name_(TaskHandle_t task) {
-    if (task == this->main_task_) {
-      return nullptr;  // Main task
-    }
-#if defined(USE_ESP32)
-    return pcTaskGetName(task);
-#elif defined(USE_LIBRETINY)
-    return pcTaskGetTaskName(task);
+#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
+  const char *HOT get_thread_name_(
+#ifdef USE_ZEPHYR
+      char *buff
 #endif
-  }
-
-  // Convenience overload - gets the current task handle and delegates
-  const char *HOT get_thread_name_() { return this->get_thread_name_(xTaskGetCurrentTaskHandle()); }
-
-#elif defined(USE_HOST)
-  // Takes a caller-provided buffer for the thread name (stack-allocated for thread safety)
-  const char *HOT get_thread_name_(std::span<char> buff) {
-    pthread_t current_thread = pthread_self();
-    if (pthread_equal(current_thread, main_thread_)) {
-      return nullptr;  // Main thread
-    }
-    // For non-main threads, get the thread name into the caller-provided buffer
-    if (pthread_getname_np(current_thread, buff.data(), buff.size()) == 0) {
-      return buff.data();
-    }
-    return nullptr;
-  }
-
-#elif defined(USE_ZEPHYR)
-  const char *HOT get_thread_name_(std::span<char> buff) {
+  ) {
+#ifdef USE_ZEPHYR
     k_tid_t current_task = k_current_get();
+#else
+    TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
+#endif
     if (current_task == main_task_) {
       return nullptr;  // Main task
+    } else {
+#if defined(USE_ESP32)
+      return pcTaskGetName(current_task);
+#elif defined(USE_LIBRETINY)
+      return pcTaskGetTaskName(current_task);
+#elif defined(USE_ZEPHYR)
+      const char *name = k_thread_name_get(current_task);
+      if (name) {
+        // zephyr print task names only if debug component is present
+        return name;
+      }
+      std::snprintf(buff, MAX_POINTER_REPRESENTATION, "%p", current_task);
+      return buff;
+#endif
     }
-    const char *name = k_thread_name_get(current_task);
-    if (name) {
-      // zephyr print task names only if debug component is present
-      return name;
-    }
-    std::snprintf(buff.data(), buff.size(), "%p", current_task);
-    return buff.data();
   }
 #endif
 
-  // --- Non-main task recursion guards (per-platform) ---
-
 #if defined(USE_ESP32) || defined(USE_HOST)
   // RAII guard for non-main task recursion using pthread TLS
   class NonMainTaskRecursionGuard {
@@ -651,6 +635,22 @@ class Logger : public Component {
   inline RecursionGuard make_non_main_task_guard_() { return RecursionGuard(non_main_task_recursion_guard_); }
 #endif
 
+#ifdef USE_HOST
+  const char *HOT get_thread_name_() {
+    pthread_t current_thread = pthread_self();
+    if (pthread_equal(current_thread, main_thread_)) {
+      return nullptr;  // Main thread
+    }
+    // For non-main threads, return the thread name
+    // We store it in thread-local storage to avoid allocation
+    static thread_local char thread_name_buf[32];
+    if (pthread_getname_np(current_thread, thread_name_buf, sizeof(thread_name_buf)) == 0) {
+      return thread_name_buf;
+    }
+    return nullptr;
+  }
+#endif
+
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   // Disable loop when task buffer is empty (with USB CDC check on ESP32)
   inline void disable_loop_when_buffer_empty_() {

esphome/components/logger/task_log_buffer_esp32.cpp

@@ -59,7 +59,7 @@ void TaskLogBuffer::release_message_main_loop(void *token) {
   last_processed_counter_ = message_counter_.load(std::memory_order_relaxed);
 }
 
-bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
+bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
                                              const char *format, va_list args) {
   // First, calculate the exact length needed using a null buffer (no actual writing)
   va_list args_copy;
@@ -95,6 +95,7 @@ bool TaskLogBuffer::send_message_thread_safe(uint8_t level, const char *tag, uin
   // Store the thread name now instead of waiting until main loop processing
   // This avoids crashes if the task completes or is deleted between when this message
   // is enqueued and when it's processed by the main loop
+  const char *thread_name = pcTaskGetName(task_handle);
   if (thread_name != nullptr) {
     strncpy(msg->thread_name, thread_name, sizeof(msg->thread_name) - 1);
     msg->thread_name[sizeof(msg->thread_name) - 1] = '\0';  // Ensure null termination

esphome/components/logger/task_log_buffer_esp32.h

@@ -58,7 +58,7 @@ class TaskLogBuffer {
   void release_message_main_loop(void *token);
 
   // Thread-safe - send a message to the ring buffer from any thread
-  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
                                 const char *format, va_list args);
 
   // Check if there are messages ready to be processed using an atomic counter for performance

esphome/components/logger/task_log_buffer_host.cpp

@@ -70,8 +70,8 @@ void TaskLogBufferHost::commit_write_slot_(int slot_index) {
   }
 }
 
-bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
-                                                 const char *format, va_list args) {
+bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *format,
+                                                 va_list args) {
   // Acquire a slot
   int slot_index = this->acquire_write_slot_();
   if (slot_index < 0) {
@@ -85,9 +85,11 @@ bool TaskLogBufferHost::send_message_thread_safe(uint8_t level, const char *tag,
   msg.tag = tag;
   msg.line = line;
 
-  // Store the thread name now to avoid crashes if thread exits before processing
-  if (thread_name != nullptr) {
-    strncpy(msg.thread_name, thread_name, sizeof(msg.thread_name) - 1);
+  // Get thread name using pthread
+  char thread_name_buf[LogMessage::MAX_THREAD_NAME_SIZE];
+  // pthread_getname_np works the same on Linux and macOS
+  if (pthread_getname_np(pthread_self(), thread_name_buf, sizeof(thread_name_buf)) == 0) {
+    strncpy(msg.thread_name, thread_name_buf, sizeof(msg.thread_name) - 1);
     msg.thread_name[sizeof(msg.thread_name) - 1] = '\0';
   } else {
     msg.thread_name[0] = '\0';

esphome/components/logger/task_log_buffer_host.h

@@ -86,8 +86,7 @@ class TaskLogBufferHost {
 
   // Thread-safe - send a message to the buffer from any thread
   // Returns true if message was queued, false if buffer is full
-  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
-                                const char *format, va_list args);
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *format, va_list args);
 
   // Check if there are messages ready to be processed
   inline bool HOT has_messages() const {

esphome/components/logger/task_log_buffer_libretiny.cpp

@@ -101,7 +101,7 @@ void TaskLogBufferLibreTiny::release_message_main_loop() {
 }
 
 bool TaskLogBufferLibreTiny::send_message_thread_safe(uint8_t level, const char *tag, uint16_t line,
-                                                      const char *thread_name, const char *format, va_list args) {
+                                                      TaskHandle_t task_handle, const char *format, va_list args) {
   // First, calculate the exact length needed using a null buffer (no actual writing)
   va_list args_copy;
   va_copy(args_copy, args);
@@ -162,6 +162,7 @@ bool TaskLogBufferLibreTiny::send_message_thread_safe(uint8_t level, const char
   msg->line = line;
 
   // Store the thread name now to avoid crashes if task is deleted before processing
+  const char *thread_name = pcTaskGetTaskName(task_handle);
   if (thread_name != nullptr) {
     strncpy(msg->thread_name, thread_name, sizeof(msg->thread_name) - 1);
     msg->thread_name[sizeof(msg->thread_name) - 1] = '\0';

esphome/components/logger/task_log_buffer_libretiny.h

@@ -70,7 +70,7 @@ class TaskLogBufferLibreTiny {
   void release_message_main_loop();
 
   // Thread-safe - send a message to the buffer from any thread
-  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, const char *thread_name,
+  bool send_message_thread_safe(uint8_t level, const char *tag, uint16_t line, TaskHandle_t task_handle,
                                 const char *format, va_list args);
 
   // Fast check using volatile counter - no lock needed

esphome/components/mipi_dsi/models/waveshare.py

@@ -120,101 +120,3 @@ DriverChip(
         (0xB2, 0x10),
     ],
 )
-
-DriverChip(
-    "WAVESHARE-ESP32-P4-WIFI6-TOUCH-LCD-3.4C",
-    height=800,
-    width=800,
-    hsync_back_porch=20,
-    hsync_pulse_width=20,
-    hsync_front_porch=40,
-    vsync_back_porch=12,
-    vsync_pulse_width=4,
-    vsync_front_porch=24,
-    pclk_frequency="80MHz",
-    lane_bit_rate="1.5Gbps",
-    swap_xy=cv.UNDEFINED,
-    color_order="RGB",
-    initsequence=[
-        (0xE0, 0x00),  # select userpage
-        (0xE1, 0x93), (0xE2, 0x65), (0xE3, 0xF8),
-        (0x80, 0x01),  # Select number of lanes (2)
-        (0xE0, 0x01),  # select page 1
-        (0x00, 0x00), (0x01, 0x41), (0x03, 0x10), (0x04, 0x44), (0x17, 0x00), (0x18, 0xD0), (0x19, 0x00), (0x1A, 0x00),
-        (0x1B, 0xD0), (0x1C, 0x00), (0x24, 0xFE), (0x35, 0x26), (0x37, 0x09), (0x38, 0x04), (0x39, 0x08), (0x3A, 0x0A),
-        (0x3C, 0x78), (0x3D, 0xFF), (0x3E, 0xFF), (0x3F, 0xFF), (0x40, 0x00), (0x41, 0x64), (0x42, 0xC7), (0x43, 0x18),
-        (0x44, 0x0B), (0x45, 0x14), (0x55, 0x02), (0x57, 0x49), (0x59, 0x0A), (0x5A, 0x1B), (0x5B, 0x19), (0x5D, 0x7F),
-        (0x5E, 0x56), (0x5F, 0x43), (0x60, 0x37), (0x61, 0x33), (0x62, 0x25), (0x63, 0x2A), (0x64, 0x16), (0x65, 0x30),
-        (0x66, 0x2F), (0x67, 0x32), (0x68, 0x53), (0x69, 0x43), (0x6A, 0x4C), (0x6B, 0x40), (0x6C, 0x3D), (0x6D, 0x31),
-        (0x6E, 0x20), (0x6F, 0x0F), (0x70, 0x7F), (0x71, 0x56), (0x72, 0x43), (0x73, 0x37), (0x74, 0x33), (0x75, 0x25),
-        (0x76, 0x2A), (0x77, 0x16), (0x78, 0x30), (0x79, 0x2F), (0x7A, 0x32), (0x7B, 0x53), (0x7C, 0x43), (0x7D, 0x4C),
-        (0x7E, 0x40), (0x7F, 0x3D), (0x80, 0x31), (0x81, 0x20), (0x82, 0x0F),
-        (0xE0, 0x02),  # select page 2
-        (0x00, 0x5F), (0x01, 0x5F), (0x02, 0x5E), (0x03, 0x5E), (0x04, 0x50), (0x05, 0x48), (0x06, 0x48), (0x07, 0x4A),
-        (0x08, 0x4A), (0x09, 0x44), (0x0A, 0x44), (0x0B, 0x46), (0x0C, 0x46), (0x0D, 0x5F), (0x0E, 0x5F), (0x0F, 0x57),
-        (0x10, 0x57), (0x11, 0x77), (0x12, 0x77), (0x13, 0x40), (0x14, 0x42), (0x15, 0x5F), (0x16, 0x5F), (0x17, 0x5F),
-        (0x18, 0x5E), (0x19, 0x5E), (0x1A, 0x50), (0x1B, 0x49), (0x1C, 0x49), (0x1D, 0x4B), (0x1E, 0x4B), (0x1F, 0x45),
-        (0x20, 0x45), (0x21, 0x47), (0x22, 0x47), (0x23, 0x5F), (0x24, 0x5F), (0x25, 0x57), (0x26, 0x57), (0x27, 0x77),
-        (0x28, 0x77), (0x29, 0x41), (0x2A, 0x43), (0x2B, 0x5F), (0x2C, 0x1E), (0x2D, 0x1E), (0x2E, 0x1F), (0x2F, 0x1F),
-        (0x30, 0x10), (0x31, 0x07), (0x32, 0x07), (0x33, 0x05), (0x34, 0x05), (0x35, 0x0B), (0x36, 0x0B), (0x37, 0x09),
-        (0x38, 0x09), (0x39, 0x1F), (0x3A, 0x1F), (0x3B, 0x17), (0x3C, 0x17), (0x3D, 0x17), (0x3E, 0x17), (0x3F, 0x03),
-        (0x40, 0x01), (0x41, 0x1F), (0x42, 0x1E), (0x43, 0x1E), (0x44, 0x1F), (0x45, 0x1F), (0x46, 0x10), (0x47, 0x06),
-        (0x48, 0x06), (0x49, 0x04), (0x4A, 0x04), (0x4B, 0x0A), (0x4C, 0x0A), (0x4D, 0x08), (0x4E, 0x08), (0x4F, 0x1F),
-        (0x50, 0x1F), (0x51, 0x17), (0x52, 0x17), (0x53, 0x17), (0x54, 0x17), (0x55, 0x02), (0x56, 0x00), (0x57, 0x1F),
-        (0xE0, 0x02),  # select page 2
-        (0x58, 0x40), (0x59, 0x00), (0x5A, 0x00), (0x5B, 0x30), (0x5C, 0x01), (0x5D, 0x30), (0x5E, 0x01), (0x5F, 0x02),
-        (0x60, 0x30), (0x61, 0x03), (0x62, 0x04), (0x63, 0x04), (0x64, 0xA6), (0x65, 0x43), (0x66, 0x30), (0x67, 0x73),
-        (0x68, 0x05), (0x69, 0x04), (0x6A, 0x7F), (0x6B, 0x08), (0x6C, 0x00), (0x6D, 0x04), (0x6E, 0x04), (0x6F, 0x88),
-        (0x75, 0xD9), (0x76, 0x00), (0x77, 0x33), (0x78, 0x43),
-        (0xE0, 0x00),  # select userpage
-    ],
-)
-
-DriverChip(
-    "WAVESHARE-ESP32-P4-WIFI6-TOUCH-LCD-4C",
-    height=720,
-    width=720,
-    hsync_back_porch=20,
-    hsync_pulse_width=20,
-    hsync_front_porch=40,
-    vsync_back_porch=12,
-    vsync_pulse_width=4,
-    vsync_front_porch=24,
-    pclk_frequency="80MHz",
-    lane_bit_rate="1.5Gbps",
-    swap_xy=cv.UNDEFINED,
-    color_order="RGB",
-    initsequence=[
-        (0xE0, 0x00),  # select userpage
-        (0xE1, 0x93), (0xE2, 0x65), (0xE3, 0xF8),
-        (0x80, 0x01),  # Select number of lanes (2)
-        (0xE0, 0x01),  # select page 1
-        (0x00, 0x00), (0x01, 0x41), (0x03, 0x10), (0x04, 0x44), (0x17, 0x00), (0x18, 0xD0), (0x19, 0x00), (0x1A, 0x00),
-        (0x1B, 0xD0), (0x1C, 0x00), (0x24, 0xFE), (0x35, 0x26), (0x37, 0x09), (0x38, 0x04), (0x39, 0x08), (0x3A, 0x0A),
-        (0x3C, 0x78), (0x3D, 0xFF), (0x3E, 0xFF), (0x3F, 0xFF), (0x40, 0x04), (0x41, 0x64), (0x42, 0xC7), (0x43, 0x18),
-        (0x44, 0x0B), (0x45, 0x14), (0x55, 0x02), (0x57, 0x49), (0x59, 0x0A), (0x5A, 0x1B), (0x5B, 0x19), (0x5D, 0x7F),
-        (0x5E, 0x56), (0x5F, 0x43), (0x60, 0x37), (0x61, 0x33), (0x62, 0x25), (0x63, 0x2A), (0x64, 0x16), (0x65, 0x30),
-        (0x66, 0x2F), (0x67, 0x32), (0x68, 0x53), (0x69, 0x43), (0x6A, 0x4C), (0x6B, 0x40), (0x6C, 0x3D), (0x6D, 0x31),
-        (0x6E, 0x20), (0x6F, 0x0F), (0x70, 0x7F), (0x71, 0x56), (0x72, 0x43), (0x73, 0x37), (0x74, 0x33), (0x75, 0x25),
-        (0x76, 0x2A), (0x77, 0x16), (0x78, 0x30), (0x79, 0x2F), (0x7A, 0x32), (0x7B, 0x53), (0x7C, 0x43), (0x7D, 0x4C),
-        (0x7E, 0x40), (0x7F, 0x3D), (0x80, 0x31), (0x81, 0x20), (0x82, 0x0F),
-        (0xE0, 0x02),  # select page 2
-        (0x00, 0x5F), (0x01, 0x5F), (0x02, 0x5E), (0x03, 0x5E), (0x04, 0x50), (0x05, 0x48), (0x06, 0x48), (0x07, 0x4A),
-        (0x08, 0x4A), (0x09, 0x44), (0x0A, 0x44), (0x0B, 0x46), (0x0C, 0x46), (0x0D, 0x5F), (0x0E, 0x5F), (0x0F, 0x57),
-        (0x10, 0x57), (0x11, 0x77), (0x12, 0x77), (0x13, 0x40), (0x14, 0x42), (0x15, 0x5F), (0x16, 0x5F), (0x17, 0x5F),
-        (0x18, 0x5E), (0x19, 0x5E), (0x1A, 0x50), (0x1B, 0x49), (0x1C, 0x49), (0x1D, 0x4B), (0x1E, 0x4B), (0x1F, 0x45),
-        (0x20, 0x45), (0x21, 0x47), (0x22, 0x47), (0x23, 0x5F), (0x24, 0x5F), (0x25, 0x57), (0x26, 0x57), (0x27, 0x77),
-        (0x28, 0x77), (0x29, 0x41), (0x2A, 0x43), (0x2B, 0x5F), (0x2C, 0x1E), (0x2D, 0x1E), (0x2E, 0x1F), (0x2F, 0x1F),
-        (0x30, 0x10), (0x31, 0x07), (0x32, 0x07), (0x33, 0x05), (0x34, 0x05), (0x35, 0x0B), (0x36, 0x0B), (0x37, 0x09),
-        (0x38, 0x09), (0x39, 0x1F), (0x3A, 0x1F), (0x3B, 0x17), (0x3C, 0x17), (0x3D, 0x17), (0x3E, 0x17), (0x3F, 0x03),
-        (0x40, 0x01), (0x41, 0x1F), (0x42, 0x1E), (0x43, 0x1E), (0x44, 0x1F), (0x45, 0x1F), (0x46, 0x10), (0x47, 0x06),
-        (0x48, 0x06), (0x49, 0x04), (0x4A, 0x04), (0x4B, 0x0A), (0x4C, 0x0A), (0x4D, 0x08), (0x4E, 0x08), (0x4F, 0x1F),
-        (0x50, 0x1F), (0x51, 0x17), (0x52, 0x17), (0x53, 0x17), (0x54, 0x17), (0x55, 0x02), (0x56, 0x00), (0x57, 0x1F),
-        (0xE0, 0x02),  # select page 2
-        (0x58, 0x40), (0x59, 0x00), (0x5A, 0x00), (0x5B, 0x30), (0x5C, 0x01), (0x5D, 0x30), (0x5E, 0x01), (0x5F, 0x02),
-        (0x60, 0x30), (0x61, 0x03), (0x62, 0x04), (0x63, 0x04), (0x64, 0xA6), (0x65, 0x43), (0x66, 0x30), (0x67, 0x73),
-        (0x68, 0x05), (0x69, 0x04), (0x6A, 0x7F), (0x6B, 0x08), (0x6C, 0x00), (0x6D, 0x04), (0x6E, 0x04), (0x6F, 0x88),
-        (0x75, 0xD9), (0x76, 0x00), (0x77, 0x33), (0x78, 0x43),
-        (0xE0, 0x00),  # select userpage
-    ]
-)

esphome/components/mipi_rgb/display.py

@@ -11,7 +11,7 @@ from esphome.components.const import (
     CONF_DRAW_ROUNDING,
 )
 from esphome.components.display import CONF_SHOW_TEST_CARD
-from esphome.components.esp32 import VARIANT_ESP32P4, VARIANT_ESP32S3, only_on_variant
+from esphome.components.esp32 import VARIANT_ESP32S3, only_on_variant
 from esphome.components.mipi import (
     COLOR_ORDERS,
     CONF_DE_PIN,
@@ -225,7 +225,7 @@ def _config_schema(config):
     return cv.All(
         schema,
         cv.only_on_esp32,
-        only_on_variant(supported=[VARIANT_ESP32S3, VARIANT_ESP32P4]),
+        only_on_variant(supported=[VARIANT_ESP32S3]),
     )(config)
 
 

esphome/components/mipi_rgb/mipi_rgb.cpp

@@ -1,4 +1,4 @@
-#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
+#ifdef USE_ESP32_VARIANT_ESP32S3
 #include "mipi_rgb.h"
 #include "esphome/core/gpio.h"
 #include "esphome/core/hal.h"
@@ -401,4 +401,4 @@ void MipiRgb::dump_config() {
 
 }  // namespace mipi_rgb
 }  // namespace esphome
-#endif  // defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
+#endif  // USE_ESP32_VARIANT_ESP32S3

esphome/components/mipi_rgb/mipi_rgb.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4)
+#ifdef USE_ESP32_VARIANT_ESP32S3
 #include "esphome/core/gpio.h"
 #include "esphome/components/display/display.h"
 #include "esp_lcd_panel_ops.h"
@@ -28,7 +28,7 @@ class MipiRgb : public display::Display {
   void setup() override;
   void loop() override;
   void update() override;
-  void fill(Color color) override;
+  void fill(Color color);
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                       display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
   void write_to_display_(int x_start, int y_start, int w, int h, const uint8_t *ptr, int x_offset, int y_offset,
@@ -115,7 +115,7 @@ class MipiRgbSpi : public MipiRgb,
   void write_command_(uint8_t value);
   void write_data_(uint8_t value);
   void write_init_sequence_();
-  void dump_config() override;
+  void dump_config();
 
   GPIOPin *dc_pin_{nullptr};
   std::vector<uint8_t> init_sequence_;

esphome/components/modbus/modbus.cpp

@@ -20,10 +20,10 @@ void Modbus::loop() {
   const uint32_t now = App.get_loop_component_start_time();
 
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }
@@ -228,50 +228,39 @@ void Modbus::send(uint8_t address, uint8_t function_code, uint16_t start_address
     return;
   }
 
-  static constexpr size_t ADDR_SIZE = 1;
-  static constexpr size_t FC_SIZE = 1;
-  static constexpr size_t START_ADDR_SIZE = 2;
-  static constexpr size_t NUM_ENTITIES_SIZE = 2;
-  static constexpr size_t BYTE_COUNT_SIZE = 1;
-  static constexpr size_t MAX_PAYLOAD_SIZE = std::numeric_limits<uint8_t>::max();
-  static constexpr size_t CRC_SIZE = 2;
-  static constexpr size_t MAX_FRAME_SIZE =
-      ADDR_SIZE + FC_SIZE + START_ADDR_SIZE + NUM_ENTITIES_SIZE + BYTE_COUNT_SIZE + MAX_PAYLOAD_SIZE + CRC_SIZE;
-  uint8_t data[MAX_FRAME_SIZE];
-  size_t pos = 0;
-
-  data[pos++] = address;
-  data[pos++] = function_code;
+  std::vector<uint8_t> data;
+  data.push_back(address);
+  data.push_back(function_code);
   if (this->role == ModbusRole::CLIENT) {
-    data[pos++] = start_address >> 8;
-    data[pos++] = start_address >> 0;
+    data.push_back(start_address >> 8);
+    data.push_back(start_address >> 0);
     if (function_code != ModbusFunctionCode::WRITE_SINGLE_COIL &&
         function_code != ModbusFunctionCode::WRITE_SINGLE_REGISTER) {
-      data[pos++] = number_of_entities >> 8;
-      data[pos++] = number_of_entities >> 0;
+      data.push_back(number_of_entities >> 8);
+      data.push_back(number_of_entities >> 0);
     }
   }
 
   if (payload != nullptr) {
     if (this->role == ModbusRole::SERVER || function_code == ModbusFunctionCode::WRITE_MULTIPLE_COILS ||
         function_code == ModbusFunctionCode::WRITE_MULTIPLE_REGISTERS) {  // Write multiple
-      data[pos++] = payload_len;                                          // Byte count is required for write
+      data.push_back(payload_len);                                        // Byte count is required for write
     } else {
       payload_len = 2;  // Write single register or coil
     }
     for (int i = 0; i < payload_len; i++) {
-      data[pos++] = payload[i];
+      data.push_back(payload[i]);
     }
   }
 
-  auto crc = crc16(data, pos);
-  data[pos++] = crc >> 0;
-  data[pos++] = crc >> 8;
+  auto crc = crc16(data.data(), data.size());
+  data.push_back(crc >> 0);
+  data.push_back(crc >> 8);
 
   if (this->flow_control_pin_ != nullptr)
     this->flow_control_pin_->digital_write(true);
 
-  this->write_array(data, pos);
+  this->write_array(data);
   this->flush();
 
   if (this->flow_control_pin_ != nullptr)
@@ -281,7 +270,7 @@ void Modbus::send(uint8_t address, uint8_t function_code, uint16_t start_address
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   char hex_buf[format_hex_pretty_size(MODBUS_MAX_LOG_BYTES)];
 #endif
-  ESP_LOGV(TAG, "Modbus write: %s", format_hex_pretty_to(hex_buf, data, pos));
+  ESP_LOGV(TAG, "Modbus write: %s", format_hex_pretty_to(hex_buf, data.data(), data.size()));
 }
 
 // Helper function for lambdas

esphome/components/nextion/nextion.cpp

@@ -398,10 +398,10 @@ bool Nextion::remove_from_q_(bool report_empty) {
 
 void Nextion::process_serial_() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/pipsolar/pipsolar.cpp

@@ -14,9 +14,9 @@ void Pipsolar::setup() {
 
 void Pipsolar::empty_uart_buffer_() {
   uint8_t buf[64];
-  size_t avail;
+  int avail;
   while ((avail = this->available()) > 0) {
-    if (!this->read_array(buf, std::min(avail, sizeof(buf)))) {
+    if (!this->read_array(buf, std::min(static_cast<size_t>(avail), sizeof(buf)))) {
       break;
     }
   }
@@ -97,10 +97,10 @@ void Pipsolar::loop() {
   }
 
   if (this->state_ == STATE_COMMAND || this->state_ == STATE_POLL) {
-    size_t avail = this->available();
+    int avail = this->available();
     while (avail > 0) {
       uint8_t buf[64];
-      size_t to_read = std::min(avail, sizeof(buf));
+      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
       if (!this->read_array(buf, to_read)) {
         break;
       }

esphome/components/pylontech/pylontech.cpp

@@ -56,14 +56,14 @@ void PylontechComponent::setup() {
 void PylontechComponent::update() { this->write_str("pwr\n"); }
 
 void PylontechComponent::loop() {
-  size_t avail = this->available();
+  int avail = this->available();
   if (avail > 0) {
     // pylontech sends a lot of data very suddenly
     // we need to quickly put it all into our own buffer, otherwise the uart's buffer will overflow
     int recv = 0;
     uint8_t buf[64];
     while (avail > 0) {
-      size_t to_read = std::min(avail, sizeof(buf));
+      size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
       if (!this->read_array(buf, to_read)) {
         break;
       }

esphome/components/rd03d/rd03d.cpp

@@ -82,10 +82,10 @@ void RD03DComponent::dump_config() {
 
 void RD03DComponent::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/rf_bridge/rf_bridge.cpp

@@ -136,10 +136,10 @@ void RFBridgeComponent::loop() {
     this->last_bridge_byte_ = now;
   }
 
-  size_t avail = this->available();
+  int avail = this->available();
   while (avail > 0) {
     uint8_t buf[64];
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/seeed_mr24hpc1/seeed_mr24hpc1.cpp

@@ -107,10 +107,10 @@ void MR24HPC1Component::update_() {
 // main loop
 void MR24HPC1Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/seeed_mr60bha2/seeed_mr60bha2.cpp

@@ -31,10 +31,10 @@ void MR60BHA2Component::dump_config() {
 // main loop
 void MR60BHA2Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -50,10 +50,10 @@ void MR60FDA2Component::setup() {
 // main loop
 void MR60FDA2Component::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/sensor/filter.cpp

@@ -9,11 +9,6 @@ namespace esphome::sensor {
 
 static const char *const TAG = "sensor.filter";
 
-// Filter scheduler IDs.
-// Each filter is its own Component instance, so the scheduler scopes
-// IDs by component pointer — no risk of collisions between instances.
-constexpr uint32_t FILTER_ID = 0;
-
 // Filter
 void Filter::input(float value) {
   ESP_LOGVV(TAG, "Filter(%p)::input(%f)", this, value);
@@ -196,7 +191,7 @@ optional<float> ThrottleAverageFilter::new_value(float value) {
   return {};
 }
 void ThrottleAverageFilter::setup() {
-  this->set_interval(FILTER_ID, this->time_period_, [this]() {
+  this->set_interval("throttle_average", this->time_period_, [this]() {
     ESP_LOGVV(TAG, "ThrottleAverageFilter(%p)::interval(sum=%f, n=%i)", this, this->sum_, this->n_);
     if (this->n_ == 0) {
       if (this->have_nan_)
@@ -388,7 +383,7 @@ optional<float> TimeoutFilterConfigured::new_value(float value) {
 
 // DebounceFilter
 optional<float> DebounceFilter::new_value(float value) {
-  this->set_timeout(FILTER_ID, this->time_period_, [this, value]() { this->output(value); });
+  this->set_timeout("debounce", this->time_period_, [this, value]() { this->output(value); });
 
   return {};
 }
@@ -411,7 +406,7 @@ optional<float> HeartbeatFilter::new_value(float value) {
 }
 
 void HeartbeatFilter::setup() {
-  this->set_interval(FILTER_ID, this->time_period_, [this]() {
+  this->set_interval("heartbeat", this->time_period_, [this]() {
     ESP_LOGVV(TAG, "HeartbeatFilter(%p)::interval(has_value=%s, last_input=%f)", this, YESNO(this->has_value_),
               this->last_input_);
     if (!this->has_value_)

esphome/components/tormatic/tormatic_cover.cpp

@@ -251,7 +251,7 @@ void Tormatic::stop_at_target_() {
 // Read a GateStatus from the unit. The unit only sends messages in response to
 // status requests or commands, so a message needs to be sent first.
 optional<GateStatus> Tormatic::read_gate_status_() {
-  if (this->available() < sizeof(MessageHeader)) {
+  if (this->available() < static_cast<int>(sizeof(MessageHeader))) {
     return {};
   }
 

esphome/components/tuya/tuya.cpp

@@ -32,10 +32,10 @@ void Tuya::setup() {
 
 void Tuya::loop() {
   // Read all available bytes in batches to reduce UART call overhead.
-  size_t avail = this->available();
+  int avail = this->available();
   uint8_t buf[64];
   while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
+    size_t to_read = std::min(static_cast<size_t>(avail), sizeof(buf));
     if (!this->read_array(buf, to_read)) {
       break;
     }

esphome/components/uart/uart.cpp

@@ -3,16 +3,12 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include <cinttypes>
 
 namespace esphome::uart {
 
 static const char *const TAG = "uart";
 
-// UART parity strings indexed by UARTParityOptions enum (0-2): NONE, EVEN, ODD
-PROGMEM_STRING_TABLE(UARTParityStrings, "NONE", "EVEN", "ODD", "UNKNOWN");
-
 void UARTDevice::check_uart_settings(uint32_t baud_rate, uint8_t stop_bits, UARTParityOptions parity,
                                      uint8_t data_bits) {
   if (this->parent_->get_baud_rate() != baud_rate) {
@@ -34,7 +30,16 @@ void UARTDevice::check_uart_settings(uint32_t baud_rate, uint8_t stop_bits, UART
 }
 
 const LogString *parity_to_str(UARTParityOptions parity) {
-  return UARTParityStrings::get_log_str(static_cast<uint8_t>(parity), UARTParityStrings::LAST_INDEX);
+  switch (parity) {
+    case UART_CONFIG_PARITY_NONE:
+      return LOG_STR("NONE");
+    case UART_CONFIG_PARITY_EVEN:
+      return LOG_STR("EVEN");
+    case UART_CONFIG_PARITY_ODD:
+      return LOG_STR("ODD");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 }  // namespace esphome::uart

esphome/components/uart/uart.h

@@ -43,7 +43,7 @@ class UARTDevice {
     return res;
   }
 
-  size_t available() { return this->parent_->available(); }
+  int available() { return this->parent_->available(); }
 
   void flush() { this->parent_->flush(); }
 

esphome/components/uart/uart_component.cpp

@@ -5,13 +5,13 @@ namespace esphome::uart {
 static const char *const TAG = "uart";
 
 bool UARTComponent::check_read_timeout_(size_t len) {
-  if (this->available() >= len)
+  if (this->available() >= int(len))
     return true;
 
   uint32_t start_time = millis();
-  while (this->available() < len) {
+  while (this->available() < int(len)) {
     if (millis() - start_time > 100) {
-      ESP_LOGE(TAG, "Reading from UART timed out at byte %zu!", this->available());
+      ESP_LOGE(TAG, "Reading from UART timed out at byte %u!", this->available());
       return false;
     }
     yield();

esphome/components/uart/uart_component.h

@@ -69,7 +69,7 @@ class UARTComponent {
 
   // Pure virtual method to return the number of bytes available for reading.
   // @return Number of available bytes.
-  virtual size_t available() = 0;
+  virtual int available() = 0;
 
   // Pure virtual method to block until all bytes have been written to the UART bus.
   virtual void flush() = 0;

esphome/components/uart/uart_component_esp8266.cpp

@@ -206,7 +206,7 @@ bool ESP8266UartComponent::read_array(uint8_t *data, size_t len) {
 #endif
   return true;
 }
-size_t ESP8266UartComponent::available() {
+int ESP8266UartComponent::available() {
   if (this->hw_serial_ != nullptr) {
     return this->hw_serial_->available();
   } else {
@@ -329,14 +329,11 @@ uint8_t ESP8266SoftwareSerial::peek_byte() {
 void ESP8266SoftwareSerial::flush() {
   // Flush is a NO-OP with software serial, all bytes are written immediately.
 }
-size_t ESP8266SoftwareSerial::available() {
-  // Read volatile rx_in_pos_ once to avoid TOCTOU race with ISR.
-  // When in >= out, data is contiguous: [out..in).
-  // When in < out, data wraps: [out..buf_size) + [0..in).
-  size_t in = this->rx_in_pos_;
-  if (in >= this->rx_out_pos_)
-    return in - this->rx_out_pos_;
-  return this->rx_buffer_size_ - this->rx_out_pos_ + in;
+int ESP8266SoftwareSerial::available() {
+  int avail = int(this->rx_in_pos_) - int(this->rx_out_pos_);
+  if (avail < 0)
+    return avail + this->rx_buffer_size_;
+  return avail;
 }
 
 }  // namespace esphome::uart

esphome/components/uart/uart_component_esp8266.h

@@ -23,7 +23,7 @@ class ESP8266SoftwareSerial {
 
   void write_byte(uint8_t data);
 
-  size_t available();
+  int available();
 
  protected:
   static void gpio_intr(ESP8266SoftwareSerial *arg);
@@ -57,7 +57,7 @@ class ESP8266UartComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  size_t available() override;
+  int available() override;
   void flush() override;
 
   uint32_t get_config();

esphome/components/uart/uart_component_esp_idf.cpp

@@ -338,7 +338,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   return read_len == (int32_t) length_to_read;
 }
 
-size_t IDFUARTComponent::available() {
+int IDFUARTComponent::available() {
   size_t available = 0;
   esp_err_t err;
 

esphome/components/uart/uart_component_esp_idf.h

@@ -22,7 +22,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  size_t available() override;
+  int available() override;
   void flush() override;
 
   uint8_t get_hw_serial_number() { return this->uart_num_; }

esphome/components/uart/uart_component_host.cpp

@@ -265,7 +265,7 @@ bool HostUartComponent::read_array(uint8_t *data, size_t len) {
   return true;
 }
 
-size_t HostUartComponent::available() {
+int HostUartComponent::available() {
   if (this->file_descriptor_ == -1) {
     return 0;
   }
@@ -275,10 +275,9 @@ size_t HostUartComponent::available() {
     this->update_error_(strerror(errno));
     return 0;
   }
-  size_t result = available;
   if (this->has_peek_)
-    result++;
-  return result;
+    available++;
+  return available;
 };
 
 void HostUartComponent::flush() {

esphome/components/uart/uart_component_host.h

@@ -17,7 +17,7 @@ class HostUartComponent : public UARTComponent, public Component {
   void write_array(const uint8_t *data, size_t len) override;
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
-  size_t available() override;
+  int available() override;
   void flush() override;
   void set_name(std::string port_name) { port_name_ = port_name; };
 

esphome/components/uart/uart_component_libretiny.cpp

@@ -169,7 +169,7 @@ bool LibreTinyUARTComponent::read_array(uint8_t *data, size_t len) {
   return true;
 }
 
-size_t LibreTinyUARTComponent::available() { return this->serial_->available(); }
+int LibreTinyUARTComponent::available() { return this->serial_->available(); }
 void LibreTinyUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();

esphome/components/uart/uart_component_libretiny.h

@@ -21,7 +21,7 @@ class LibreTinyUARTComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  size_t available() override;
+  int available() override;
   void flush() override;
 
   uint16_t get_config();

esphome/components/uart/uart_component_rp2040.cpp

@@ -186,7 +186,7 @@ bool RP2040UartComponent::read_array(uint8_t *data, size_t len) {
 #endif
   return true;
 }
-size_t RP2040UartComponent::available() { return this->serial_->available(); }
+int RP2040UartComponent::available() { return this->serial_->available(); }
 void RP2040UartComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
   this->serial_->flush();

esphome/components/uart/uart_component_rp2040.h

@@ -24,7 +24,7 @@ class RP2040UartComponent : public UARTComponent, public Component {
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
 
-  size_t available() override;
+  int available() override;
   void flush() override;
 
   uint16_t get_config();

esphome/components/usb_cdc_acm/usb_cdc_acm.h

@@ -81,7 +81,7 @@ class USBCDCACMInstance : public uart::UARTComponent, public Parented<USBCDCACMC
   void write_array(const uint8_t *data, size_t len) override;
   bool peek_byte(uint8_t *data) override;
   bool read_array(uint8_t *data, size_t len) override;
-  size_t available() override;
+  int available() override;
   void flush() override;
 
  protected:

esphome/components/usb_cdc_acm/usb_cdc_acm_esp32.cpp

@@ -318,12 +318,12 @@ bool USBCDCACMInstance::read_array(uint8_t *data, size_t len) {
   return bytes_read == original_len;
 }
 
-size_t USBCDCACMInstance::available() {
+int USBCDCACMInstance::available() {
   UBaseType_t waiting = 0;
   if (this->usb_rx_ringbuf_ != nullptr) {
     vRingbufferGetInfo(this->usb_rx_ringbuf_, nullptr, nullptr, nullptr, nullptr, &waiting);
   }
-  return waiting + (this->has_peek_ ? 1 : 0);
+  return static_cast<int>(waiting) + (this->has_peek_ ? 1 : 0);
 }
 
 void USBCDCACMInstance::flush() {

esphome/components/usb_uart/usb_uart.h

@@ -97,7 +97,7 @@ class USBUartChannel : public uart::UARTComponent, public Parented<USBUartCompon
   bool peek_byte(uint8_t *data) override;
   ;
   bool read_array(uint8_t *data, size_t len) override;
-  size_t available() override { return this->input_buffer_.get_available(); }
+  int available() override { return static_cast<int>(this->input_buffer_.get_available()); }
   void flush() override {}
   void check_logger_conflict() override {}
   void set_parity(UARTParityOptions parity) { this->parity_ = parity; }

esphome/components/voice_assistant/__init__.py

@@ -371,12 +371,7 @@ async def to_code(config):
     if on_timer_tick := config.get(CONF_ON_TIMER_TICK):
         await automation.build_automation(
             var.get_timer_tick_trigger(),
-            [
-                (
-                    cg.std_vector.template(Timer).operator("const").operator("ref"),
-                    "timers",
-                )
-            ],
+            [(cg.std_vector.template(Timer), "timers")],
             on_timer_tick,
         )
         has_timers = True

esphome/components/voice_assistant/voice_assistant.cpp

@@ -859,43 +859,35 @@ void VoiceAssistant::on_audio(const api::VoiceAssistantAudio &msg) {
 }
 
 void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse &msg) {
-  // Find existing timer or add a new one
-  auto it = this->timers_.begin();
-  for (; it != this->timers_.end(); ++it) {
-    if (it->id == msg.timer_id)
-      break;
-  }
-  if (it == this->timers_.end()) {
-    this->timers_.push_back({});
-    it = this->timers_.end() - 1;
-  }
-  it->id = msg.timer_id;
-  it->name = msg.name;
-  it->total_seconds = msg.total_seconds;
-  it->seconds_left = msg.seconds_left;
-  it->is_active = msg.is_active;
-
+  Timer timer = {
+      .id = msg.timer_id,
+      .name = msg.name,
+      .total_seconds = msg.total_seconds,
+      .seconds_left = msg.seconds_left,
+      .is_active = msg.is_active,
+  };
+  this->timers_[timer.id] = timer;
   char timer_buf[Timer::TO_STR_BUFFER_SIZE];
   ESP_LOGD(TAG,
            "Timer Event\n"
            "  Type: %" PRId32 "\n"
            "  %s",
-           msg.event_type, it->to_str(timer_buf));
+           msg.event_type, timer.to_str(timer_buf));
 
   switch (msg.event_type) {
     case api::enums::VOICE_ASSISTANT_TIMER_STARTED:
-      this->timer_started_trigger_.trigger(*it);
+      this->timer_started_trigger_.trigger(timer);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_UPDATED:
-      this->timer_updated_trigger_.trigger(*it);
+      this->timer_updated_trigger_.trigger(timer);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_CANCELLED:
-      this->timer_cancelled_trigger_.trigger(*it);
-      this->timers_.erase(it);
+      this->timer_cancelled_trigger_.trigger(timer);
+      this->timers_.erase(timer.id);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_FINISHED:
-      this->timer_finished_trigger_.trigger(*it);
-      this->timers_.erase(it);
+      this->timer_finished_trigger_.trigger(timer);
+      this->timers_.erase(timer.id);
       break;
   }
 
@@ -909,12 +901,16 @@ void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse
 }
 
 void VoiceAssistant::timer_tick_() {
-  for (auto &timer : this->timers_) {
+  std::vector<Timer> res;
+  res.reserve(this->timers_.size());
+  for (auto &pair : this->timers_) {
+    auto &timer = pair.second;
     if (timer.is_active && timer.seconds_left > 0) {
       timer.seconds_left--;
     }
+    res.push_back(timer);
   }
-  this->timer_tick_trigger_.trigger(this->timers_);
+  this->timer_tick_trigger_.trigger(res);
 }
 
 void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg) {

esphome/components/voice_assistant/voice_assistant.h

@@ -24,6 +24,7 @@
 #include "esphome/components/socket/socket.h"
 
 #include <span>
+#include <unordered_map>
 #include <vector>
 
 namespace esphome {
@@ -82,7 +83,7 @@ struct Timer {
   }
   // Remove before 2026.8.0
   ESPDEPRECATED("Use to_str() instead. Removed in 2026.8.0", "2026.2.0")
-  std::string to_string() const {  // NOLINT
+  std::string to_string() const {
     char buffer[TO_STR_BUFFER_SIZE];
     return this->to_str(buffer);
   }
@@ -225,9 +226,9 @@ class VoiceAssistant : public Component {
   Trigger<Timer> *get_timer_updated_trigger() { return &this->timer_updated_trigger_; }
   Trigger<Timer> *get_timer_cancelled_trigger() { return &this->timer_cancelled_trigger_; }
   Trigger<Timer> *get_timer_finished_trigger() { return &this->timer_finished_trigger_; }
-  Trigger<const std::vector<Timer> &> *get_timer_tick_trigger() { return &this->timer_tick_trigger_; }
+  Trigger<std::vector<Timer>> *get_timer_tick_trigger() { return &this->timer_tick_trigger_; }
   void set_has_timers(bool has_timers) { this->has_timers_ = has_timers; }
-  const std::vector<Timer> &get_timers() const { return this->timers_; }
+  const std::unordered_map<std::string, Timer> &get_timers() const { return this->timers_; }
 
  protected:
   bool allocate_buffers_();
@@ -266,13 +267,13 @@ class VoiceAssistant : public Component {
 
   api::APIConnection *api_client_{nullptr};
 
-  std::vector<Timer> timers_;
+  std::unordered_map<std::string, Timer> timers_;
   void timer_tick_();
   Trigger<Timer> timer_started_trigger_;
   Trigger<Timer> timer_finished_trigger_;
   Trigger<Timer> timer_updated_trigger_;
   Trigger<Timer> timer_cancelled_trigger_;
-  Trigger<const std::vector<Timer> &> timer_tick_trigger_;
+  Trigger<std::vector<Timer>> timer_tick_trigger_;
   bool has_timers_{false};
   bool timer_tick_running_{false};
 

esphome/components/water_heater/water_heater.h

@@ -90,22 +90,9 @@ class WaterHeaterCall {
   float get_target_temperature_low() const { return this->target_temperature_low_; }
   float get_target_temperature_high() const { return this->target_temperature_high_; }
   /// Get state flags value
-  ESPDEPRECATED("get_state() is deprecated, use get_away() and get_on() instead. (Removed in 2026.8.0)", "2026.2.0")
   uint32_t get_state() const { return this->state_; }
-
-  optional<bool> get_away() const {
-    if (this->state_mask_ & WATER_HEATER_STATE_AWAY) {
-      return (this->state_ & WATER_HEATER_STATE_AWAY) != 0;
-    }
-    return {};
-  }
-
-  optional<bool> get_on() const {
-    if (this->state_mask_ & WATER_HEATER_STATE_ON) {
-      return (this->state_ & WATER_HEATER_STATE_ON) != 0;
-    }
-    return {};
-  }
+  /// Get mask of state flags that are being changed
+  uint32_t get_state_mask() const { return this->state_mask_; }
 
  protected:
   void validate_();

esphome/components/web_server_base/__init__.py

@@ -1,11 +1,8 @@
-from pathlib import Path
-
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
-from esphome.helpers import copy_file_if_changed
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network"]
@@ -52,15 +49,5 @@ async def to_code(config):
             CORE.add_platformio_option(
                 "lib_ignore", ["ESPAsyncTCP", "AsyncTCP", "AsyncTCP_RP2040W"]
             )
-            # ESPAsyncWebServer uses Hash library for sha1() on RP2040
-            cg.add_library("Hash", None)
-            # Fix Hash.h include conflict: Crypto-no-arduino (used by dsmr)
-            # provides a Hash.h that shadows the framework's Hash library.
-            # Prepend the framework Hash path so it's found first.
-            copy_file_if_changed(
-                Path(__file__).parent / "fix_rp2040_hash.py.script",
-                CORE.relative_build_path("fix_rp2040_hash.py"),
-            )
-            cg.add_platformio_option("extra_scripts", ["pre:fix_rp2040_hash.py"])
         # https://github.com/ESP32Async/ESPAsyncWebServer/blob/main/library.json
         cg.add_library("ESP32Async/ESPAsyncWebServer", "3.9.6")

esphome/components/web_server_base/fix_rp2040_hash.py.script

@@ -1,11 +0,0 @@
-# ESPAsyncWebServer includes <Hash.h> expecting the Arduino-Pico framework's Hash
-# library (which provides sha1() functions). However, the Crypto-no-arduino library
-# (used by dsmr) also provides a Hash.h that can shadow the framework version when
-# PlatformIO's chain+ LDF mode auto-discovers it as a dependency.
-# Prepend the framework Hash path to CXXFLAGS so it is found first.
-import os
-
-Import("env")
-framework_dir = env.PioPlatform().get_package_dir("framework-arduinopico")
-hash_src = os.path.join(framework_dir, "libraries", "Hash", "src")
-env.Prepend(CXXFLAGS=["-I" + hash_src])

esphome/components/weikai/weikai.cpp

@@ -401,7 +401,7 @@ bool WeikaiChannel::peek_byte(uint8_t *buffer) {
   return this->receive_buffer_.peek(*buffer);
 }
 
-size_t WeikaiChannel::available() {
+int WeikaiChannel::available() {
   size_t available = this->receive_buffer_.count();
   if (!available)
     available = xfer_fifo_to_buffer_();

esphome/components/weikai/weikai.h

@@ -374,7 +374,7 @@ class WeikaiChannel : public uart::UARTComponent {
 
   /// @brief Returns the number of bytes in the receive buffer
   /// @return the number of bytes available in the receiver fifo
-  size_t available() override;
+  int available() override;
 
   /// @brief Flush the output fifo.
   /// @details If we refer to Serial.flush() in Arduino it says: ** Waits for the transmission of outgoing serial data

esphome/components/zigbee/zigbee_zephyr.cpp

@@ -3,7 +3,6 @@
 #include "esphome/core/log.h"
 #include <zephyr/settings/settings.h>
 #include <zephyr/storage/flash_map.h>
-#include "esphome/core/hal.h"
 
 extern "C" {
 #include <zboss_api.h>
@@ -224,7 +223,6 @@ void ZigbeeComponent::dump_config() {
                 get_wipe_on_boot(), YESNO(zb_zdo_joined()), zb_get_current_channel(), zb_get_current_page(),
                 zb_get_sleep_threshold(), role(), ieee_addr_buf, zb_get_short_address(), extended_pan_id_buf,
                 zb_get_pan_id());
-  dump_reporting_();
 }
 
 static void send_attribute_report(zb_bufid_t bufid, zb_uint16_t cmd_id) {
@@ -246,33 +244,6 @@ void ZigbeeComponent::factory_reset() {
   ZB_SCHEDULE_APP_CALLBACK(zb_bdb_reset_via_local_action, 0);
 }
 
-void ZigbeeComponent::dump_reporting_() {
-#ifdef ESPHOME_LOG_HAS_VERBOSE
-  auto now = millis();
-  bool first = true;
-  for (zb_uint8_t j = 0; j < ZCL_CTX().device_ctx->ep_count; j++) {
-    if (ZCL_CTX().device_ctx->ep_desc_list[j]->reporting_info) {
-      zb_zcl_reporting_info_t *rep_info = ZCL_CTX().device_ctx->ep_desc_list[j]->reporting_info;
-      for (zb_uint8_t i = 0; i < ZCL_CTX().device_ctx->ep_desc_list[j]->rep_info_count; i++) {
-        if (!first) {
-          ESP_LOGV(TAG, "");
-        }
-        first = false;
-        ESP_LOGV(TAG, "Endpoint: %d, cluster_id %d, attr_id %d, flags %d, report in %ums", rep_info->ep,
-                 rep_info->cluster_id, rep_info->attr_id, rep_info->flags,
-                 ZB_ZCL_GET_REPORTING_FLAG(rep_info, ZB_ZCL_REPORT_TIMER_STARTED)
-                     ? ZB_TIME_BEACON_INTERVAL_TO_MSEC(rep_info->run_time) - now
-                     : 0);
-        ESP_LOGV(TAG, "Min_interval %ds, max_interval %ds, def_min_interval %ds, def_max_interval %ds",
-                 rep_info->u.send_info.min_interval, rep_info->u.send_info.max_interval,
-                 rep_info->u.send_info.def_min_interval, rep_info->u.send_info.def_max_interval);
-        rep_info++;
-      }
-    }
-  }
-#endif
-}
-
 }  // namespace esphome::zigbee
 
 extern "C" void zboss_signal_handler(zb_uint8_t param) {

esphome/components/zigbee/zigbee_zephyr.h

@@ -87,7 +87,6 @@ class ZigbeeComponent : public Component {
 #ifdef USE_ZIGBEE_WIPE_ON_BOOT
   void erase_flash_(int area);
 #endif
-  void dump_reporting_();
   std::array<std::function<void(zb_bufid_t bufid)>, ZIGBEE_ENDPOINTS_COUNT> callbacks_{};
   CallbackManager<void()> join_cb_;
   Trigger<> join_trigger_;

esphome/core/base_automation.h

@@ -191,17 +191,15 @@ template<typename... Ts> class DelayAction : public Action<Ts...>, public Compon
     // instead of std::bind to avoid bind overhead (~16 bytes heap + faster execution)
     if constexpr (sizeof...(Ts) == 0) {
       App.scheduler.set_timer_common_(
-          this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::NUMERIC_ID_INTERNAL, nullptr,
-          static_cast<uint32_t>(InternalSchedulerID::DELAY_ACTION), this->delay_.value(),
+          this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::STATIC_STRING, "delay", 0, this->delay_.value(),
           [this]() { this->play_next_(); },
           /* is_retry= */ false, /* skip_cancel= */ this->num_running_ > 1);
     } else {
       // For delays with arguments, use std::bind to preserve argument values
       // Arguments must be copied because original references may be invalid after delay
       auto f = std::bind(&DelayAction<Ts...>::play_next_, this, x...);
-      App.scheduler.set_timer_common_(this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::NUMERIC_ID_INTERNAL,
-                                      nullptr, static_cast<uint32_t>(InternalSchedulerID::DELAY_ACTION),
-                                      this->delay_.value(x...), std::move(f),
+      App.scheduler.set_timer_common_(this, Scheduler::SchedulerItem::TIMEOUT, Scheduler::NameType::STATIC_STRING,
+                                      "delay", 0, this->delay_.value(x...), std::move(f),
                                       /* is_retry= */ false, /* skip_cancel= */ this->num_running_ > 1);
     }
   }
@@ -210,7 +208,7 @@ template<typename... Ts> class DelayAction : public Action<Ts...>, public Compon
   void play(const Ts &...x) override { /* ignore - see play_complex */
   }
 
-  void stop() override { this->cancel_timeout(InternalSchedulerID::DELAY_ACTION); }
+  void stop() override { this->cancel_timeout("delay"); }
 };
 
 template<typename... Ts> class LambdaAction : public Action<Ts...> {

esphome/core/component.cpp

@@ -152,10 +152,7 @@ void Component::set_retry(const std::string &name, uint32_t initial_wait_time, u
 
 void Component::set_retry(const char *name, uint32_t initial_wait_time, uint8_t max_attempts,
                           std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_retry(this, name, initial_wait_time, max_attempts, std::move(f), backoff_increase_factor);
-#pragma GCC diagnostic pop
 }
 
 bool Component::cancel_retry(const std::string &name) {  // NOLINT
@@ -166,10 +163,7 @@ bool Component::cancel_retry(const std::string &name) {  // NOLINT
 }
 
 bool Component::cancel_retry(const char *name) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return App.scheduler.cancel_retry(this, name);
-#pragma GCC diagnostic pop
 }
 
 void Component::set_timeout(const std::string &name, uint32_t timeout, std::function<void()> &&f) {  // NOLINT
@@ -201,38 +195,18 @@ void Component::set_timeout(uint32_t id, uint32_t timeout, std::function<void()>
 
 bool Component::cancel_timeout(uint32_t id) { return App.scheduler.cancel_timeout(this, id); }
 
-void Component::set_timeout(InternalSchedulerID id, uint32_t timeout, std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_timeout(this, id, timeout, std::move(f));
-}
-
-bool Component::cancel_timeout(InternalSchedulerID id) { return App.scheduler.cancel_timeout(this, id); }
-
 void Component::set_interval(uint32_t id, uint32_t interval, std::function<void()> &&f) {  // NOLINT
   App.scheduler.set_interval(this, id, interval, std::move(f));
 }
 
 bool Component::cancel_interval(uint32_t id) { return App.scheduler.cancel_interval(this, id); }
 
-void Component::set_interval(InternalSchedulerID id, uint32_t interval, std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_interval(this, id, interval, std::move(f));
-}
-
-bool Component::cancel_interval(InternalSchedulerID id) { return App.scheduler.cancel_interval(this, id); }
-
 void Component::set_retry(uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,
                           std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_retry(this, id, initial_wait_time, max_attempts, std::move(f), backoff_increase_factor);
-#pragma GCC diagnostic pop
 }
 
-bool Component::cancel_retry(uint32_t id) {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  return App.scheduler.cancel_retry(this, id);
-#pragma GCC diagnostic pop
-}
+bool Component::cancel_retry(uint32_t id) { return App.scheduler.cancel_retry(this, id); }
 
 void Component::call_loop() { this->loop(); }
 void Component::call_setup() { this->setup(); }
@@ -397,10 +371,7 @@ void Component::set_interval(uint32_t interval, std::function<void()> &&f) {  //
 }
 void Component::set_retry(uint32_t initial_wait_time, uint8_t max_attempts, std::function<RetryResult(uint8_t)> &&f,
                           float backoff_increase_factor) {  // NOLINT
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   App.scheduler.set_retry(this, "", initial_wait_time, max_attempts, std::move(f), backoff_increase_factor);
-#pragma GCC diagnostic pop
 }
 bool Component::is_failed() const { return (this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_FAILED; }
 bool Component::is_ready() const {
@@ -545,12 +516,12 @@ void PollingComponent::call_setup() {
 
 void PollingComponent::start_poller() {
   // Register interval.
-  this->set_interval(InternalSchedulerID::POLLING_UPDATE, this->get_update_interval(), [this]() { this->update(); });
+  this->set_interval("update", this->get_update_interval(), [this]() { this->update(); });
 }
 
 void PollingComponent::stop_poller() {
   // Clear the interval to suspend component
-  this->cancel_interval(InternalSchedulerID::POLLING_UPDATE);
+  this->cancel_interval("update");
 }
 
 uint32_t PollingComponent::get_update_interval() const { return this->update_interval_; }

esphome/core/component.h

@@ -49,14 +49,6 @@ extern const float LATE;
 
 static const uint32_t SCHEDULER_DONT_RUN = 4294967295UL;
 
-/// Type-safe scheduler IDs for core base classes.
-/// Uses a separate NameType (NUMERIC_ID_INTERNAL) so IDs can never collide
-/// with component-level NUMERIC_ID values, even if the uint32_t values overlap.
-enum class InternalSchedulerID : uint32_t {
-  POLLING_UPDATE = 0,  // PollingComponent interval
-  DELAY_ACTION = 1,    // DelayAction timeout
-};
-
 // Forward declaration
 class PollingComponent;
 
@@ -76,7 +68,6 @@ extern const uint8_t STATUS_LED_OK;
 extern const uint8_t STATUS_LED_WARNING;
 extern const uint8_t STATUS_LED_ERROR;
 
-// Remove before 2026.8.0
 enum class RetryResult { DONE, RETRY };
 
 extern const uint16_t WARN_IF_BLOCKING_OVER_MS;
@@ -343,8 +334,6 @@ class Component {
    */
   void set_interval(uint32_t id, uint32_t interval, std::function<void()> &&f);  // NOLINT
 
-  void set_interval(InternalSchedulerID id, uint32_t interval, std::function<void()> &&f);  // NOLINT
-
   void set_interval(uint32_t interval, std::function<void()> &&f);  // NOLINT
 
   /** Cancel an interval function.
@@ -357,42 +346,69 @@ class Component {
   bool cancel_interval(const std::string &name);  // NOLINT
   bool cancel_interval(const char *name);         // NOLINT
   bool cancel_interval(uint32_t id);              // NOLINT
-  bool cancel_interval(InternalSchedulerID id);   // NOLINT
 
-  /// @deprecated set_retry is deprecated. Use set_timeout or set_interval instead. Removed in 2026.8.0.
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
+  /** Set an retry function with a unique name. Empty name means no cancelling possible.
+   *
+   * This will call the retry function f on the next scheduler loop. f should return RetryResult::DONE if
+   * it is successful and no repeat is required. Otherwise, returning RetryResult::RETRY will call f
+   * again in the future.
+   *
+   * The first retry of f happens after `initial_wait_time` milliseconds. The delay between retries is
+   * increased by multiplying by `backoff_increase_factor` each time. If no backoff_increase_factor is
+   * supplied (default = 1.0), the wait time will stay constant.
+   *
+   * The retry function f needs to accept a single argument: the number of attempts remaining. On the
+   * final retry of f, this value will be 0.
+   *
+   * This retry function can also be cancelled by name via cancel_retry().
+   *
+   * IMPORTANT: Do not rely on this having correct timing. This is only called from
+   * loop() and therefore can be significantly delayed.
+   *
+   * REMARK: It is an error to supply a negative or zero `backoff_increase_factor`, and 1.0 will be used instead.
+   *
+   * REMARK: The interval between retries is stored into a `uint32_t`, so this doesn't behave correctly
+   * if `initial_wait_time * (backoff_increase_factor ** (max_attempts - 2))` overflows.
+   *
+   * @param name The identifier for this retry function.
+   * @param initial_wait_time The time in ms before f is called again
+   * @param max_attempts The maximum number of executions
+   * @param f The function (or lambda) that should be called
+   * @param backoff_increase_factor time between retries is multiplied by this factor on every retry after the first
+   * @see cancel_retry()
+   */
+  // Remove before 2026.7.0
+  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_retry(const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,       // NOLINT
                  std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
   void set_retry(const char *name, uint32_t initial_wait_time, uint8_t max_attempts,              // NOLINT
                  std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
+  /** Set a retry function with a numeric ID (zero heap allocation).
+   *
+   * @param id The numeric identifier for this retry function
+   * @param initial_wait_time The wait time after the first execution
+   * @param max_attempts The max number of attempts
+   * @param f The function to call
+   * @param backoff_increase_factor The factor to increase the retry interval by
+   */
   void set_retry(uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,                   // NOLINT
                  std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor = 1.0f);  // NOLINT
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
   void set_retry(uint32_t initial_wait_time, uint8_t max_attempts, std::function<RetryResult(uint8_t)> &&f,  // NOLINT
                  float backoff_increase_factor = 1.0f);                                                      // NOLINT
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("cancel_retry is deprecated and will be removed in 2026.8.0.", "2026.2.0")
+  /** Cancel a retry function.
+   *
+   * @param name The identifier for this retry function.
+   * @return Whether a retry function was deleted.
+   */
+  // Remove before 2026.7.0
+  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_retry(const std::string &name);  // NOLINT
-  // Remove before 2026.8.0
-  ESPDEPRECATED("cancel_retry is deprecated and will be removed in 2026.8.0.", "2026.2.0")
-  bool cancel_retry(const char *name);  // NOLINT
-  // Remove before 2026.8.0
-  ESPDEPRECATED("cancel_retry is deprecated and will be removed in 2026.8.0.", "2026.2.0")
-  bool cancel_retry(uint32_t id);  // NOLINT
+  bool cancel_retry(const char *name);         // NOLINT
+  bool cancel_retry(uint32_t id);              // NOLINT
 
   /** Set a timeout function with a unique name.
    *
@@ -436,8 +452,6 @@ class Component {
    */
   void set_timeout(uint32_t id, uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
-  void set_timeout(InternalSchedulerID id, uint32_t timeout, std::function<void()> &&f);  // NOLINT
-
   void set_timeout(uint32_t timeout, std::function<void()> &&f);  // NOLINT
 
   /** Cancel a timeout function.
@@ -450,7 +464,6 @@ class Component {
   bool cancel_timeout(const std::string &name);  // NOLINT
   bool cancel_timeout(const char *name);         // NOLINT
   bool cancel_timeout(uint32_t id);              // NOLINT
-  bool cancel_timeout(InternalSchedulerID id);   // NOLINT
 
   /** Defer a callback to the next loop() call.
    *

esphome/core/scheduler.cpp

@@ -53,12 +53,9 @@ struct SchedulerNameLog {
     } else if (name_type == NameType::HASHED_STRING) {
       ESPHOME_snprintf_P(buffer, sizeof(buffer), ESPHOME_PSTR("hash:0x%08" PRIX32), hash_or_id);
       return buffer;
-    } else if (name_type == NameType::NUMERIC_ID) {
+    } else {  // NUMERIC_ID
       ESPHOME_snprintf_P(buffer, sizeof(buffer), ESPHOME_PSTR("id:%" PRIu32), hash_or_id);
       return buffer;
-    } else {  // NUMERIC_ID_INTERNAL
-      ESPHOME_snprintf_P(buffer, sizeof(buffer), ESPHOME_PSTR("iid:%" PRIu32), hash_or_id);
-      return buffer;
     }
   }
 };
@@ -140,9 +137,6 @@ void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type
     case NameType::NUMERIC_ID:
       item->set_numeric_id(hash_or_id);
       break;
-    case NameType::NUMERIC_ID_INTERNAL:
-      item->set_internal_id(hash_or_id);
-      break;
   }
   item->type = type;
   item->callback = std::move(func);
@@ -258,11 +252,6 @@ bool HOT Scheduler::cancel_interval(Component *component, uint32_t id) {
   return this->cancel_item_(component, NameType::NUMERIC_ID, nullptr, id, SchedulerItem::INTERVAL);
 }
 
-// Suppress deprecation warnings for RetryResult usage in the still-present (but deprecated) retry implementation.
-// Remove before 2026.8.0 along with all retry code.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
 struct RetryArgs {
   // Ordered to minimize padding on 32-bit systems
   std::function<RetryResult(uint8_t)> func;
@@ -375,8 +364,6 @@ bool HOT Scheduler::cancel_retry(Component *component, uint32_t id) {
   return this->cancel_retry_(component, NameType::NUMERIC_ID, nullptr, id);
 }
 
-#pragma GCC diagnostic pop  // End suppression of deprecated RetryResult warnings
-
 optional<uint32_t> HOT Scheduler::next_schedule_in(uint32_t now) {
   // IMPORTANT: This method should only be called from the main thread (loop task).
   // It performs cleanup and accesses items_[0] without holding a lock, which is only

esphome/core/scheduler.h

@@ -46,20 +46,11 @@ class Scheduler {
   void set_timeout(Component *component, const char *name, uint32_t timeout, std::function<void()> func);
   /// Set a timeout with a numeric ID (zero heap allocation)
   void set_timeout(Component *component, uint32_t id, uint32_t timeout, std::function<void()> func);
-  /// Set a timeout with an internal scheduler ID (separate namespace from component NUMERIC_ID)
-  void set_timeout(Component *component, InternalSchedulerID id, uint32_t timeout, std::function<void()> func) {
-    this->set_timer_common_(component, SchedulerItem::TIMEOUT, NameType::NUMERIC_ID_INTERNAL, nullptr,
-                            static_cast<uint32_t>(id), timeout, std::move(func));
-  }
 
   ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_timeout(Component *component, const std::string &name);
   bool cancel_timeout(Component *component, const char *name);
   bool cancel_timeout(Component *component, uint32_t id);
-  bool cancel_timeout(Component *component, InternalSchedulerID id) {
-    return this->cancel_item_(component, NameType::NUMERIC_ID_INTERNAL, nullptr, static_cast<uint32_t>(id),
-                              SchedulerItem::TIMEOUT);
-  }
 
   ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_interval(Component *component, const std::string &name, uint32_t interval, std::function<void()> func);
@@ -75,45 +66,24 @@ class Scheduler {
   void set_interval(Component *component, const char *name, uint32_t interval, std::function<void()> func);
   /// Set an interval with a numeric ID (zero heap allocation)
   void set_interval(Component *component, uint32_t id, uint32_t interval, std::function<void()> func);
-  /// Set an interval with an internal scheduler ID (separate namespace from component NUMERIC_ID)
-  void set_interval(Component *component, InternalSchedulerID id, uint32_t interval, std::function<void()> func) {
-    this->set_timer_common_(component, SchedulerItem::INTERVAL, NameType::NUMERIC_ID_INTERNAL, nullptr,
-                            static_cast<uint32_t>(id), interval, std::move(func));
-  }
 
   ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_interval(Component *component, const std::string &name);
   bool cancel_interval(Component *component, const char *name);
   bool cancel_interval(Component *component, uint32_t id);
-  bool cancel_interval(Component *component, InternalSchedulerID id) {
-    return this->cancel_item_(component, NameType::NUMERIC_ID_INTERNAL, nullptr, static_cast<uint32_t>(id),
-                              SchedulerItem::INTERVAL);
-  }
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
+  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   void set_retry(Component *component, const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,
                  std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
   void set_retry(Component *component, const char *name, uint32_t initial_wait_time, uint8_t max_attempts,
                  std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
-  // Remove before 2026.8.0
-  ESPDEPRECATED("set_retry is deprecated and will be removed in 2026.8.0. Use set_timeout or set_interval instead.",
-                "2026.2.0")
+  /// Set a retry with a numeric ID (zero heap allocation)
   void set_retry(Component *component, uint32_t id, uint32_t initial_wait_time, uint8_t max_attempts,
                  std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
 
-  // Remove before 2026.8.0
-  ESPDEPRECATED("cancel_retry is deprecated and will be removed in 2026.8.0.", "2026.2.0")
+  ESPDEPRECATED("Use const char* or uint32_t overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_retry(Component *component, const std::string &name);
-  // Remove before 2026.8.0
-  ESPDEPRECATED("cancel_retry is deprecated and will be removed in 2026.8.0.", "2026.2.0")
   bool cancel_retry(Component *component, const char *name);
-  // Remove before 2026.8.0
-  ESPDEPRECATED("cancel_retry is deprecated and will be removed in 2026.8.0.", "2026.2.0")
   bool cancel_retry(Component *component, uint32_t id);
 
   // Calculate when the next scheduled item should run
@@ -130,12 +100,11 @@ class Scheduler {
   void process_to_add();
 
   // Name storage type discriminator for SchedulerItem
-  // Used to distinguish between static strings, hashed strings, numeric IDs, and internal numeric IDs
+  // Used to distinguish between static strings, hashed strings, and numeric IDs
   enum class NameType : uint8_t {
-    STATIC_STRING = 0,       // const char* pointer to static/flash storage
-    HASHED_STRING = 1,       // uint32_t FNV-1a hash of a runtime string
-    NUMERIC_ID = 2,          // uint32_t numeric identifier (component-level)
-    NUMERIC_ID_INTERNAL = 3  // uint32_t numeric identifier (core/internal, separate namespace)
+    STATIC_STRING = 0,  // const char* pointer to static/flash storage
+    HASHED_STRING = 1,  // uint32_t FNV-1a hash of a runtime string
+    NUMERIC_ID = 2      // uint32_t numeric identifier
   };
 
  protected:
@@ -166,7 +135,7 @@ class Scheduler {
 
     // Bit-packed fields (4 bits used, 4 bits padding in 1 byte)
     enum Type : uint8_t { TIMEOUT, INTERVAL } type : 1;
-    NameType name_type_ : 2;  // Discriminator for name_ union (0–3, see NameType enum)
+    NameType name_type_ : 2;  // Discriminator for name_ union (STATIC_STRING, HASHED_STRING, NUMERIC_ID)
     bool is_retry : 1;        // True if this is a retry timeout
                               // 4 bits padding
 #else
@@ -174,7 +143,7 @@ class Scheduler {
     // Bit-packed fields (5 bits used, 3 bits padding in 1 byte)
     enum Type : uint8_t { TIMEOUT, INTERVAL } type : 1;
     bool remove : 1;
-    NameType name_type_ : 2;  // Discriminator for name_ union (0–3, see NameType enum)
+    NameType name_type_ : 2;  // Discriminator for name_ union (STATIC_STRING, HASHED_STRING, NUMERIC_ID)
     bool is_retry : 1;        // True if this is a retry timeout
                               // 3 bits padding
 #endif
@@ -237,12 +206,6 @@ class Scheduler {
       name_type_ = NameType::NUMERIC_ID;
     }
 
-    // Helper to set an internal numeric ID (separate namespace from NUMERIC_ID)
-    void set_internal_id(uint32_t id) {
-      name_.hash_or_id = id;
-      name_type_ = NameType::NUMERIC_ID_INTERNAL;
-    }
-
     static bool cmp(const std::unique_ptr<SchedulerItem> &a, const std::unique_ptr<SchedulerItem> &b);
 
     // Note: We use 48 bits total (32 + 16), stored in a 64-bit value for API compatibility.
@@ -268,14 +231,11 @@ class Scheduler {
                          uint32_t hash_or_id, uint32_t delay, std::function<void()> func, bool is_retry = false,
                          bool skip_cancel = false);
 
-  // Common implementation for retry - Remove before 2026.8.0
+  // Common implementation for retry
   // name_type determines storage type: STATIC_STRING uses static_name, others use hash_or_id
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   void set_retry_common_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id,
                          uint32_t initial_wait_time, uint8_t max_attempts, std::function<RetryResult(uint8_t)> func,
                          float backoff_increase_factor);
-#pragma GCC diagnostic pop
   // Common implementation for cancel_retry
   bool cancel_retry_(Component *component, NameType name_type, const char *static_name, uint32_t hash_or_id);
 

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools==82.0.0", "wheel>=0.43,<0.47"]
+requires = ["setuptools==80.10.2", "wheel>=0.43,<0.47"]
 build-backend = "setuptools.build_meta"
 
 [project]

script/api_protobuf/api_protobuf.py

@@ -2277,12 +2277,6 @@ ifdefs: dict[str, str] = {}
 # Track messages with no fields (empty messages) for parameter elision
 EMPTY_MESSAGES: set[str] = set()
 
-# Track empty SOURCE_CLIENT messages that don't need class generation
-# These messages have no fields and are only received (never sent), so the
-# class definition (vtable, dump_to, message_name, ESTIMATED_SIZE) is dead code
-# that the compiler compiles but the linker strips away.
-SKIP_CLASS_GENERATION: set[str] = set()
-
 
 def get_opt(
     desc: descriptor.DescriptorProto,
@@ -2533,11 +2527,7 @@ def build_service_message_type(
             case += "#endif\n"
         case += f"this->{func}({'msg' if not is_empty else ''});\n"
         case += "break;"
-        if mt.name in SKIP_CLASS_GENERATION:
-            case_label = f"{id_} /* {mt.name} is empty */"
-        else:
-            case_label = f"{mt.name}::MESSAGE_TYPE"
-        RECEIVE_CASES[id_] = (case, ifdef, case_label)
+        RECEIVE_CASES[id_] = (case, ifdef, mt.name)
 
         # Only close ifdef if we opened it
         if ifdef is not None:
@@ -2733,19 +2723,6 @@ static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint
 
     mt = file.message_type
 
-    # Identify empty SOURCE_CLIENT messages that don't need class generation
-    for m in mt:
-        if m.options.deprecated:
-            continue
-        if not m.options.HasExtension(pb.id):
-            continue
-        source = message_source_map.get(m.name)
-        if source != SOURCE_CLIENT:
-            continue
-        has_fields = any(not field.options.deprecated for field in m.field)
-        if not has_fields:
-            SKIP_CLASS_GENERATION.add(m.name)
-
     # Collect messages by base class
     base_class_groups = collect_messages_by_base_class(mt)
 
@@ -2778,10 +2755,6 @@ static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint
         if m.name not in used_messages and not m.options.HasExtension(pb.id):
             continue
 
-        # Skip class generation for empty SOURCE_CLIENT messages
-        if m.name in SKIP_CLASS_GENERATION:
-            continue
-
         s, c, dc = build_message_type(m, base_class_fields, message_source_map)
         msg_ifdef = message_ifdef_map.get(m.name)
 
@@ -2908,8 +2881,33 @@ static const char *const TAG = "api.service";
 
     cases = list(RECEIVE_CASES.items())
     cases.sort()
+    hpp += " protected:\n"
+    hpp += "  void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;\n"
+    out = f"void {class_name}::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {{\n"
+    out += "  switch (msg_type) {\n"
+    for i, (case, ifdef, message_name) in cases:
+        if ifdef is not None:
+            out += f"#ifdef {ifdef}\n"
+
+        c = f"    case {message_name}::MESSAGE_TYPE: {{\n"
+        c += indent(case, "      ") + "\n"
+        c += "    }"
+        out += c + "\n"
+        if ifdef is not None:
+            out += "#endif\n"
+    out += "    default:\n"
+    out += "      break;\n"
+    out += "  }\n"
+    out += "}\n"
+    cpp += out
+    hpp += "};\n"
 
     serv = file.service[0]
+    class_name = "APIServerConnection"
+    hpp += "\n"
+    hpp += f"class {class_name} : public {class_name}Base {{\n"
+    hpp_protected = ""
+    cpp += "\n"
 
     # Build a mapping of message input types to their authentication requirements
     message_auth_map: dict[str, bool] = {}
@@ -2924,90 +2922,67 @@ static const char *const TAG = "api.service";
         message_auth_map[inp] = needs_auth
         message_conn_map[inp] = needs_conn
 
+    # Generate optimized read_message with authentication checking
     # Categorize messages by their authentication requirements
     no_conn_ids: set[int] = set()
     conn_only_ids: set[int] = set()
 
-    # Build a reverse lookup from message id to message name for auth lookups
-    id_to_msg_name: dict[int, str] = {}
-    for mt in file.message_type:
-        id_ = get_opt(mt, pb.id)
-        if id_ is not None and not mt.options.deprecated:
-            id_to_msg_name[id_] = mt.name
-
-    for id_, (_, _, case_label) in cases:
-        msg_name = id_to_msg_name.get(id_, "")
-        if msg_name in message_auth_map:
-            needs_auth = message_auth_map[msg_name]
-            needs_conn = message_conn_map[msg_name]
+    for id_, (_, _, case_msg_name) in cases:
+        if case_msg_name in message_auth_map:
+            needs_auth = message_auth_map[case_msg_name]
+            needs_conn = message_conn_map[case_msg_name]
 
             if not needs_conn:
                 no_conn_ids.add(id_)
             elif not needs_auth:
                 conn_only_ids.add(id_)
 
-    # Helper to generate case statements with ifdefs
-    def generate_cases(ids: set[int], comment: str) -> str:
-        result = ""
-        for id_ in sorted(ids):
-            _, ifdef, case_label = RECEIVE_CASES[id_]
-            if ifdef:
-                result += f"#ifdef {ifdef}\n"
-            result += f"    case {case_label}:  {comment}\n"
-            if ifdef:
-                result += "#endif\n"
-        return result
-
-    # Generate read_message with auth check before dispatch
-    hpp += " protected:\n"
-    hpp += "  void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;\n"
-
-    out = f"void {class_name}::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {{\n"
-
-    # Auth check block before dispatch switch
-    out += "  // Check authentication/connection requirements\n"
+    # Generate override if we have messages that skip checks
     if no_conn_ids or conn_only_ids:
-        out += "  switch (msg_type) {\n"
+        # Helper to generate case statements with ifdefs
+        def generate_cases(ids: set[int], comment: str) -> str:
+            result = ""
+            for id_ in sorted(ids):
+                _, ifdef, msg_name = RECEIVE_CASES[id_]
+                if ifdef:
+                    result += f"#ifdef {ifdef}\n"
+                result += f"    case {msg_name}::MESSAGE_TYPE:  {comment}\n"
+                if ifdef:
+                    result += "#endif\n"
+            return result
 
+        hpp_protected += "  void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;\n"
+
+        cpp += f"\nvoid {class_name}::read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) {{\n"
+        cpp += "  // Check authentication/connection requirements for messages\n"
+        cpp += "  switch (msg_type) {\n"
+
+        # Messages that don't need any checks
         if no_conn_ids:
-            out += generate_cases(no_conn_ids, "// No setup required")
-            out += "      break;\n"
+            cpp += generate_cases(no_conn_ids, "// No setup required")
+            cpp += "      break;  // Skip all checks for these messages\n"
 
+        # Messages that only need connection setup
         if conn_only_ids:
-            out += generate_cases(conn_only_ids, "// Connection setup only")
-            out += "      if (!this->check_connection_setup_()) {\n"
-            out += "        return;\n"
-            out += "      }\n"
-            out += "      break;\n"
+            cpp += generate_cases(conn_only_ids, "// Connection setup only")
+            cpp += "      if (!this->check_connection_setup_()) {\n"
+            cpp += "        return;  // Connection not setup\n"
+            cpp += "      }\n"
+            cpp += "      break;\n"
 
-        out += "    default:\n"
-        out += "      if (!this->check_authenticated_()) {\n"
-        out += "        return;\n"
-        out += "      }\n"
-        out += "      break;\n"
-        out += "  }\n"
-    else:
-        out += "  if (!this->check_authenticated_()) {\n"
-        out += "    return;\n"
-        out += "  }\n"
+        cpp += "    default:\n"
+        cpp += "      // All other messages require authentication (which includes connection check)\n"
+        cpp += "      if (!this->check_authenticated_()) {\n"
+        cpp += "        return;  // Authentication failed\n"
+        cpp += "      }\n"
+        cpp += "      break;\n"
+        cpp += "  }\n\n"
+        cpp += "  // Call base implementation to process the message\n"
+        cpp += f"  {class_name}Base::read_message(msg_size, msg_type, msg_data);\n"
+        cpp += "}\n"
 
-    # Dispatch switch
-    out += "  switch (msg_type) {\n"
-    for i, (case, ifdef, case_label) in cases:
-        if ifdef is not None:
-            out += f"#ifdef {ifdef}\n"
-
-        c = f"    case {case_label}: {{\n"
-        c += indent(case, "      ") + "\n"
-        c += "    }"
-        out += c + "\n"
-        if ifdef is not None:
-            out += "#endif\n"
-    out += "    default:\n"
-    out += "      break;\n"
-    out += "  }\n"
-    out += "}\n"
-    cpp += out
+    hpp += " protected:\n"
+    hpp += hpp_protected
     hpp += "};\n"
 
     hpp += """\

script/ci-custom.py

@@ -756,53 +756,6 @@ def lint_no_sprintf(fname, match):
     )
 
 
-@lint_re_check(
-    # Match std::to_string() or unqualified to_string() calls
-    # The esphome namespace has "using std::to_string;" so unqualified calls resolve to std::to_string
-    # Use negative lookbehind for unqualified calls to avoid matching:
-    #   - Function definitions: "const char *to_string(" or "std::string to_string("
-    #   - Method definitions: "Class::to_string("
-    #   - Method calls: ".to_string(" or "->to_string("
-    #   - Other identifiers: "_to_string("
-    # Also explicitly match std::to_string since : is in the lookbehind
-    r"(?:(?<![*&.\w>:])to_string|std\s*::\s*to_string)\s*\(" + CPP_RE_EOL,
-    include=cpp_include,
-    exclude=[
-        # Vendored library
-        "esphome/components/http_request/httplib.h",
-        # Deprecated helpers that return std::string
-        "esphome/core/helpers.cpp",
-        # The using declaration itself
-        "esphome/core/helpers.h",
-        # Test fixtures - not production embedded code
-        "tests/integration/fixtures/*",
-    ],
-)
-def lint_no_std_to_string(fname, match):
-    return (
-        f"{highlight('std::to_string()')} (including unqualified {highlight('to_string()')}) "
-        f"allocates heap memory. On long-running embedded devices, repeated heap allocations "
-        f"fragment memory over time.\n"
-        f"Please use {highlight('snprintf()')} with a stack buffer instead.\n"
-        f"\n"
-        f"Buffer sizes and format specifiers (sizes include sign and null terminator):\n"
-        f"  uint8_t:          4 chars   - %u (or PRIu8)\n"
-        f"  int8_t:           5 chars   - %d (or PRId8)\n"
-        f"  uint16_t:         6 chars   - %u (or PRIu16)\n"
-        f"  int16_t:          7 chars   - %d (or PRId16)\n"
-        f"  uint32_t:         11 chars  - %" + "PRIu32\n"
-        "  int32_t:          12 chars  - %" + "PRId32\n"
-        "  uint64_t:         21 chars  - %" + "PRIu64\n"
-        "  int64_t:          21 chars  - %" + "PRId64\n"
-        f"  float/double:     24 chars  - %.8g (15 digits + sign + decimal + e+XXX)\n"
-        f"                    317 chars - %f (for DBL_MAX: 309 int digits + decimal + 6 frac + sign)\n"
-        f"\n"
-        f"For sensor values, use value_accuracy_to_buf() from helpers.h.\n"
-        f'Example: char buf[11]; snprintf(buf, sizeof(buf), "%" PRIu32, value);\n'
-        f"(If strictly necessary, add `{highlight('// NOLINT')}` to the end of the line)"
-    )
-
-
 @lint_re_check(
     # Match scanf family functions: scanf, sscanf, fscanf, vscanf, vsscanf, vfscanf
     # Also match std:: prefixed versions

tests/components/mipi_rgb/common.yaml

@@ -1,52 +0,0 @@
-display:
-  - platform: mipi_rgb
-    spi_id: spi_bus
-    model: ZX2D10GE01R-V4848
-    update_interval: 1s
-    color_order: BGR
-    draw_rounding: 2
-    pixel_mode: 18bit
-    invert_colors: false
-    use_axis_flips: true
-    pclk_frequency: 15000000.0
-    pclk_inverted: true
-    byte_order: big_endian
-    hsync_pulse_width: 10
-    hsync_back_porch: 10
-    hsync_front_porch: 10
-    vsync_pulse_width: 2
-    vsync_back_porch: 12
-    vsync_front_porch: 14
-    data_pins:
-      red:
-        - number: 10
-        - number: 16
-        - number: 9
-        - number: 15
-        - number: 46
-      green:
-        - number: 8
-        - number: 13
-        - number: 18
-        - number: 12
-        - number: 11
-        - number: 17
-      blue:
-        - number: 47
-        - number: 1
-        - number: 0
-        - number: 42
-        - number: 14
-    de_pin:
-      number: 39
-    pclk_pin:
-      number: 45
-    hsync_pin:
-      number: 38
-    vsync_pin:
-      number: 48
-    data_rate: 1000000.0
-    spi_mode: MODE0
-    cs_pin:
-      number: 21
-    show_test_card: true

tests/components/mipi_rgb/test.esp32-p4-idf.yaml

@@ -1,6 +0,0 @@
-packages:
-  spi: !include ../../test_build_components/common/spi/esp32-p4-idf.yaml
-
-psram:
-
-<<: !include common.yaml

tests/components/mipi_rgb/test.esp32-s3-idf.yaml

@@ -4,4 +4,58 @@ packages:
 psram:
   mode: octal
 
-<<: !include common.yaml
+display:
+  - platform: mipi_rgb
+    spi_id: spi_bus
+    model: ZX2D10GE01R-V4848
+    update_interval: 1s
+    color_order: BGR
+    draw_rounding: 2
+    pixel_mode: 18bit
+    invert_colors: false
+    use_axis_flips: true
+    pclk_frequency: 15000000.0
+    pclk_inverted: true
+    byte_order: big_endian
+    hsync_pulse_width: 10
+    hsync_back_porch: 10
+    hsync_front_porch: 10
+    vsync_pulse_width: 2
+    vsync_back_porch: 12
+    vsync_front_porch: 14
+    data_pins:
+      red:
+        - number: 10
+        - number: 16
+        - number: 9
+        - number: 15
+        - number: 46
+          ignore_strapping_warning: true
+      green:
+        - number: 8
+        - number: 13
+        - number: 18
+        - number: 12
+        - number: 11
+        - number: 17
+      blue:
+        - number: 47
+        - number: 1
+        - number: 0
+          ignore_strapping_warning: true
+        - number: 42
+        - number: 14
+    de_pin:
+      number: 39
+    pclk_pin:
+      number: 45
+      ignore_strapping_warning: true
+    hsync_pin:
+      number: 38
+    vsync_pin:
+      number: 48
+    data_rate: 1000000.0
+    spi_mode: MODE0
+    cs_pin:
+      number: 21
+    show_test_card: true

tests/components/uart/common.h

@@ -29,7 +29,7 @@ class MockUARTComponent : public UARTComponent {
 
   MOCK_METHOD(bool, read_array, (uint8_t * data, size_t len), (override));
   MOCK_METHOD(bool, peek_byte, (uint8_t * data), (override));
-  MOCK_METHOD(size_t, available, (), (override));
+  MOCK_METHOD(int, available, (), (override));
   MOCK_METHOD(void, flush, (), (override));
   MOCK_METHOD(void, check_logger_conflict, (), (override));
 };

tests/components/voice_assistant/common-idf.yaml

@@ -68,24 +68,3 @@ voice_assistant:
     - logger.log:
         format: "Voice assistant error - code %s, message: %s"
         args: [code.c_str(), message.c_str()]
-  on_timer_started:
-    - logger.log:
-        format: "Timer started: %s"
-        args: [timer.id.c_str()]
-  on_timer_updated:
-    - logger.log:
-        format: "Timer updated: %s"
-        args: [timer.id.c_str()]
-  on_timer_cancelled:
-    - logger.log:
-        format: "Timer cancelled: %s"
-        args: [timer.id.c_str()]
-  on_timer_finished:
-    - logger.log:
-        format: "Timer finished: %s"
-        args: [timer.id.c_str()]
-  on_timer_tick:
-    - lambda: |-
-        for (auto &timer : timers) {
-          ESP_LOGD("timer", "Timer %s: %" PRIu32 "s left", timer.name.c_str(), timer.seconds_left);
-        }

tests/components/voice_assistant/common.yaml

@@ -58,24 +58,3 @@ voice_assistant:
     - logger.log:
         format: "Voice assistant error - code %s, message: %s"
         args: [code.c_str(), message.c_str()]
-  on_timer_started:
-    - logger.log:
-        format: "Timer started: %s"
-        args: [timer.id.c_str()]
-  on_timer_updated:
-    - logger.log:
-        format: "Timer updated: %s"
-        args: [timer.id.c_str()]
-  on_timer_cancelled:
-    - logger.log:
-        format: "Timer cancelled: %s"
-        args: [timer.id.c_str()]
-  on_timer_finished:
-    - logger.log:
-        format: "Timer finished: %s"
-        args: [timer.id.c_str()]
-  on_timer_tick:
-    - lambda: |-
-        for (auto &timer : timers) {
-          ESP_LOGD("timer", "Timer %s: %" PRIu32 "s left", timer.name.c_str(), timer.seconds_left);
-        }

tests/integration/fixtures/scheduler_internal_id_no_collision.yaml

@@ -1,109 +0,0 @@
-esphome:
-  name: scheduler-internal-id-test
-  on_boot:
-    priority: -100
-    then:
-      - logger.log: "Starting scheduler internal ID collision tests"
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-globals:
-  - id: tests_done
-    type: bool
-    initial_value: 'false'
-
-script:
-  - id: test_internal_id_no_collision
-    then:
-      - logger.log: "Testing NUMERIC_ID_INTERNAL vs NUMERIC_ID isolation"
-      - lambda: |-
-          // All tests use the same component and the same uint32_t value (0).
-          // NUMERIC_ID_INTERNAL and NUMERIC_ID are separate NameType values,
-          // so the scheduler must treat them as independent timers.
-          auto *comp = id(test_sensor);
-
-          // ---- Test 1: Both timeout types fire independently ----
-          // Set an internal timeout with ID 0
-          App.scheduler.set_timeout(comp, InternalSchedulerID{0}, 50, []() {
-            ESP_LOGI("test", "Internal timeout 0 fired");
-          });
-          // Set a component numeric timeout with the same ID 0
-          App.scheduler.set_timeout(comp, 0U, 50, []() {
-            ESP_LOGI("test", "Numeric timeout 0 fired");
-          });
-
-          // ---- Test 2: Cancelling numeric ID does NOT cancel internal ID ----
-          // Set an internal timeout with ID 1
-          App.scheduler.set_timeout(comp, InternalSchedulerID{1}, 100, []() {
-            ESP_LOGI("test", "Internal timeout 1 survived cancel");
-          });
-          // Set a numeric timeout with the same ID 1
-          App.scheduler.set_timeout(comp, 1U, 100, []() {
-            ESP_LOGE("test", "ERROR: Numeric timeout 1 should have been cancelled");
-          });
-          // Cancel only the numeric one
-          App.scheduler.cancel_timeout(comp, 1U);
-
-          // ---- Test 3: Cancelling internal ID does NOT cancel numeric ID ----
-          // Set a numeric timeout with ID 2
-          App.scheduler.set_timeout(comp, 2U, 150, []() {
-            ESP_LOGI("test", "Numeric timeout 2 survived cancel");
-          });
-          // Set an internal timeout with the same ID 2
-          App.scheduler.set_timeout(comp, InternalSchedulerID{2}, 150, []() {
-            ESP_LOGE("test", "ERROR: Internal timeout 2 should have been cancelled");
-          });
-          // Cancel only the internal one
-          App.scheduler.cancel_timeout(comp, InternalSchedulerID{2});
-
-          // ---- Test 4: Both interval types fire independently ----
-          static int internal_interval_count = 0;
-          static int numeric_interval_count = 0;
-          App.scheduler.set_interval(comp, InternalSchedulerID{3}, 100, []() {
-            internal_interval_count++;
-            if (internal_interval_count == 2) {
-              ESP_LOGI("test", "Internal interval 3 fired twice");
-              App.scheduler.cancel_interval(id(test_sensor), InternalSchedulerID{3});
-            }
-          });
-          App.scheduler.set_interval(comp, 3U, 100, []() {
-            numeric_interval_count++;
-            if (numeric_interval_count == 2) {
-              ESP_LOGI("test", "Numeric interval 3 fired twice");
-              App.scheduler.cancel_interval(id(test_sensor), 3U);
-            }
-          });
-
-          // ---- Test 5: String name does NOT collide with internal ID ----
-          // Use string name and internal ID 10 on same component
-          App.scheduler.set_timeout(comp, "collision_test", 200, []() {
-            ESP_LOGI("test", "String timeout collision_test fired");
-          });
-          App.scheduler.set_timeout(comp, InternalSchedulerID{10}, 200, []() {
-            ESP_LOGI("test", "Internal timeout 10 fired");
-          });
-
-          // Log completion after all timers should have fired
-          App.scheduler.set_timeout(comp, 9999U, 1500, []() {
-            ESP_LOGI("test", "All collision tests complete");
-          });
-
-sensor:
-  - platform: template
-    name: Test Sensor
-    id: test_sensor
-    lambda: return 1.0;
-    update_interval: never
-
-interval:
-  - interval: 0.1s
-    then:
-      - if:
-          condition:
-            lambda: 'return id(tests_done) == false;'
-          then:
-            - lambda: 'id(tests_done) = true;'
-            - script.execute: test_internal_id_no_collision

tests/integration/test_scheduler_internal_id_no_collision.py

@@ -1,124 +0,0 @@
-"""Test that NUMERIC_ID_INTERNAL and NUMERIC_ID cannot collide.
-
-Verifies that InternalSchedulerID (used by core base classes like
-PollingComponent and DelayAction) and uint32_t numeric IDs (used by
-components) are in completely separate matching namespaces, even when
-the underlying uint32_t values are identical and on the same component.
-"""
-
-import asyncio
-import re
-
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_scheduler_internal_id_no_collision(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test that internal and numeric IDs with same value don't collide."""
-    # Test 1: Both types fire independently with same ID
-    internal_timeout_0_fired = asyncio.Event()
-    numeric_timeout_0_fired = asyncio.Event()
-
-    # Test 2: Cancelling numeric doesn't cancel internal
-    internal_timeout_1_survived = asyncio.Event()
-    numeric_timeout_1_error = asyncio.Event()
-
-    # Test 3: Cancelling internal doesn't cancel numeric
-    numeric_timeout_2_survived = asyncio.Event()
-    internal_timeout_2_error = asyncio.Event()
-
-    # Test 4: Both interval types fire independently
-    internal_interval_3_done = asyncio.Event()
-    numeric_interval_3_done = asyncio.Event()
-
-    # Test 5: String name doesn't collide with internal ID
-    string_timeout_fired = asyncio.Event()
-    internal_timeout_10_fired = asyncio.Event()
-
-    # Completion
-    all_tests_complete = asyncio.Event()
-
-    def on_log_line(line: str) -> None:
-        clean_line = re.sub(r"\x1b\[[0-9;]*m", "", line)
-
-        if "Internal timeout 0 fired" in clean_line:
-            internal_timeout_0_fired.set()
-        elif "Numeric timeout 0 fired" in clean_line:
-            numeric_timeout_0_fired.set()
-        elif "Internal timeout 1 survived cancel" in clean_line:
-            internal_timeout_1_survived.set()
-        elif "ERROR: Numeric timeout 1 should have been cancelled" in clean_line:
-            numeric_timeout_1_error.set()
-        elif "Numeric timeout 2 survived cancel" in clean_line:
-            numeric_timeout_2_survived.set()
-        elif "ERROR: Internal timeout 2 should have been cancelled" in clean_line:
-            internal_timeout_2_error.set()
-        elif "Internal interval 3 fired twice" in clean_line:
-            internal_interval_3_done.set()
-        elif "Numeric interval 3 fired twice" in clean_line:
-            numeric_interval_3_done.set()
-        elif "String timeout collision_test fired" in clean_line:
-            string_timeout_fired.set()
-        elif "Internal timeout 10 fired" in clean_line:
-            internal_timeout_10_fired.set()
-        elif "All collision tests complete" in clean_line:
-            all_tests_complete.set()
-
-    async with (
-        run_compiled(yaml_config, line_callback=on_log_line),
-        api_client_connected() as client,
-    ):
-        device_info = await client.device_info()
-        assert device_info is not None
-        assert device_info.name == "scheduler-internal-id-test"
-
-        try:
-            await asyncio.wait_for(all_tests_complete.wait(), timeout=5.0)
-        except TimeoutError:
-            pytest.fail("Not all collision tests completed within 5 seconds")
-
-        # Test 1: Both timeout types with same ID 0 must fire
-        assert internal_timeout_0_fired.is_set(), (
-            "Internal timeout with ID 0 should have fired"
-        )
-        assert numeric_timeout_0_fired.is_set(), (
-            "Numeric timeout with ID 0 should have fired"
-        )
-
-        # Test 2: Cancelling numeric ID must NOT cancel internal ID
-        assert internal_timeout_1_survived.is_set(), (
-            "Internal timeout 1 should survive cancellation of numeric timeout 1"
-        )
-        assert not numeric_timeout_1_error.is_set(), (
-            "Numeric timeout 1 should have been cancelled"
-        )
-
-        # Test 3: Cancelling internal ID must NOT cancel numeric ID
-        assert numeric_timeout_2_survived.is_set(), (
-            "Numeric timeout 2 should survive cancellation of internal timeout 2"
-        )
-        assert not internal_timeout_2_error.is_set(), (
-            "Internal timeout 2 should have been cancelled"
-        )
-
-        # Test 4: Both interval types with same ID must fire independently
-        assert internal_interval_3_done.is_set(), (
-            "Internal interval 3 should have fired at least twice"
-        )
-        assert numeric_interval_3_done.is_set(), (
-            "Numeric interval 3 should have fired at least twice"
-        )
-
-        # Test 5: String name and internal ID don't collide
-        assert string_timeout_fired.is_set(), (
-            "String timeout 'collision_test' should have fired"
-        )
-        assert internal_timeout_10_fired.is_set(), (
-            "Internal timeout 10 should have fired alongside string timeout"
-        )

tests/test_build_components/common/spi/esp32-p4-idf.yaml

@@ -1,12 +0,0 @@
-# Common SPI configuration for ESP32-P4 IDF tests
-
-substitutions:
-  clk_pin: GPIO36
-  mosi_pin: GPIO32
-  miso_pin: GPIO33
-
-spi:
-  - id: spi_bus
-    clk_pin: ${clk_pin}
-    mosi_pin: ${mosi_pin}
-    miso_pin: ${miso_pin}