Merge remote-tracking branch 'upstream/dev' into beta_premerge

.clang-tidy.hash

@@ -1 +1 @@
-0f2b9a65dce7c59289d3aeb40936360a62a7be937b585147b45bb1509eaafb36
+37ec8d5a343c8d0a485fd2118cbdabcbccd7b9bca197e4a392be75087974dced

esphome/analyze_memory/cli.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Callable
 import heapq
-import json
 from operator import itemgetter
 import sys
 from typing import TYPE_CHECKING
@@ -541,28 +540,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/codegen.py

@@ -11,7 +11,6 @@
 from esphome.cpp_generator import (  # noqa: F401
     ArrayInitializer,
     Expression,
-    FlashStringLiteral,
     LineComment,
     LogStringLiteral,
     MockObj,

esphome/components/api/__init__.py

@@ -524,24 +524,24 @@ async def homeassistant_service_to_code(
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, False)
-    templ = await cg.templatable(config[CONF_ACTION], args, cg.std_string)
+    templ = await cg.templatable(config[CONF_ACTION], args, None)
     cg.add(var.set_service(templ))
 
     # Initialize FixedVectors with exact sizes from config
     cg.add(var.init_data(len(config[CONF_DATA])))
     for key, value in config[CONF_DATA].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data(key, templ))
 
     cg.add(var.init_data_template(len(config[CONF_DATA_TEMPLATE])))
     for key, value in config[CONF_DATA_TEMPLATE].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data_template(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data_template(key, templ))
 
     cg.add(var.init_variables(len(config[CONF_VARIABLES])))
     for key, value in config[CONF_VARIABLES].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_variable(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_variable(key, templ))
 
     if on_error := config.get(CONF_ON_ERROR):
         cg.add_define("USE_API_HOMEASSISTANT_ACTION_RESPONSES")
@@ -609,24 +609,24 @@ async def homeassistant_event_to_code(config, action_id, template_arg, args):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    templ = await cg.templatable(config[CONF_EVENT], args, cg.std_string)
+    templ = await cg.templatable(config[CONF_EVENT], args, None)
     cg.add(var.set_service(templ))
 
     # Initialize FixedVectors with exact sizes from config
     cg.add(var.init_data(len(config[CONF_DATA])))
     for key, value in config[CONF_DATA].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data(key, templ))
 
     cg.add(var.init_data_template(len(config[CONF_DATA_TEMPLATE])))
     for key, value in config[CONF_DATA_TEMPLATE].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data_template(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data_template(key, templ))
 
     cg.add(var.init_variables(len(config[CONF_VARIABLES])))
     for key, value in config[CONF_VARIABLES].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_variable(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_variable(key, templ))
 
     return var
 
@@ -649,11 +649,11 @@ async def homeassistant_tag_scanned_to_code(config, action_id, template_arg, arg
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    cg.add(var.set_service(cg.FlashStringLiteral("esphome.tag_scanned")))
+    cg.add(var.set_service("esphome.tag_scanned"))
     # Initialize FixedVector with exact size (1 data field)
     cg.add(var.init_data(1))
     templ = await cg.templatable(config[CONF_TAG], args, cg.std_string)
-    cg.add(var.add_data(cg.FlashStringLiteral("tag_id"), templ))
+    cg.add(var.add_data("tag_id", templ))
     return var
 
 

esphome/components/api/api_connection.cpp

@@ -133,8 +133,8 @@ void APIConnection::start() {
     return;
   }
   // Initialize client name with peername (IP address) until Hello message provides actual name
-  char peername[socket::SOCKADDR_STR_LEN];
-  this->helper_->set_client_name(this->helper_->get_peername_to(peername), strlen(peername));
+  const char *peername = this->helper_->get_client_peername();
+  this->helper_->set_client_name(peername, strlen(peername));
 }
 
 APIConnection::~APIConnection() {
@@ -179,8 +179,8 @@ void APIConnection::begin_iterator_(ActiveIterator type) {
 
 void APIConnection::loop() {
   if (this->flags_.next_close) {
-    // requested a disconnect - don't close socket here, let APIServer::loop() do it
-    // so getpeername() still works for the disconnect trigger
+    // requested a disconnect
+    this->helper_->close();
     this->flags_.remove = true;
     return;
   }
@@ -293,8 +293,7 @@ bool APIConnection::send_disconnect_response_() {
   return this->send_message(resp, DisconnectResponse::MESSAGE_TYPE);
 }
 void APIConnection::on_disconnect_response() {
-  // Don't close socket here, let APIServer::loop() do it
-  // so getpeername() still works for the disconnect trigger
+  this->helper_->close();
   this->flags_.remove = true;
 }
 
@@ -1466,11 +1465,8 @@ void APIConnection::complete_authentication_() {
   this->flags_.connection_state = static_cast<uint8_t>(ConnectionState::AUTHENTICATED);
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("connected"));
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  {
-    char peername[socket::SOCKADDR_STR_LEN];
-    this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
-                                                           std::string(this->helper_->get_peername_to(peername)));
-  }
+  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
+                                                         std::string(this->helper_->get_client_peername()));
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1489,9 +1485,8 @@ bool APIConnection::send_hello_response_(const HelloRequest &msg) {
   this->helper_->set_client_name(msg.client_info.c_str(), msg.client_info.size());
   this->client_api_version_major_ = msg.api_version_major;
   this->client_api_version_minor_ = msg.api_version_minor;
-  char peername[socket::SOCKADDR_STR_LEN];
   ESP_LOGV(TAG, "Hello from client: '%s' | %s | API Version %" PRIu32 ".%" PRIu32, this->helper_->get_client_name(),
-           this->helper_->get_peername_to(peername), this->client_api_version_major_, this->client_api_version_minor_);
+           this->helper_->get_client_peername(), this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
@@ -1839,8 +1834,7 @@ void APIConnection::on_no_setup_connection() {
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
 }
 void APIConnection::on_fatal_error() {
-  // Don't close socket here - keep it open so getpeername() works for logging
-  // Socket will be closed when client is removed from the list in APIServer::loop()
+  this->helper_->close();
   this->flags_.remove = true;
 }
 
@@ -2197,14 +2191,12 @@ void APIConnection::process_state_subscriptions_() {
 #endif  // USE_API_HOMEASSISTANT_STATES
 
 void APIConnection::log_client_(int level, const LogString *message) {
-  char peername[socket::SOCKADDR_STR_LEN];
   esp_log_printf_(level, TAG, __LINE__, ESPHOME_LOG_FORMAT("%s (%s): %s"), this->helper_->get_client_name(),
-                  this->helper_->get_peername_to(peername), LOG_STR_ARG(message));
+                  this->helper_->get_client_peername(), LOG_STR_ARG(message));
 }
 
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  char peername[socket::SOCKADDR_STR_LEN];
-  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_peername_to(peername),
+  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_client_peername(),
            LOG_STR_ARG(message), LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 

esphome/components/api/api_connection.h

@@ -276,10 +276,8 @@ class APIConnection final : public APIServerConnectionBase {
   bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) override;
 
   const char *get_name() const { return this->helper_->get_client_name(); }
-  /// Get peer name (IP address) into caller-provided buffer, returns buf for convenience
-  const char *get_peername_to(std::span<char, socket::SOCKADDR_STR_LEN> buf) const {
-    return this->helper_->get_peername_to(buf);
-  }
+  /// Get peer name (IP address) - cached at connection init time
+  const char *get_peername() const { return this->helper_->get_client_peername(); }
 
  protected:
   // Helper function to handle authentication completion

esphome/components/api/api_frame_helper.cpp

@@ -16,12 +16,7 @@ static const char *const TAG = "api.frame_helper";
 static constexpr size_t API_MAX_LOG_BYTES = 168;
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-#define HELPER_LOG(msg, ...) \
-  do { \
-    char peername_buf[socket::SOCKADDR_STR_LEN]; \
-    this->get_peername_to(peername_buf); \
-    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername_buf, ##__VA_ARGS__); \
-  } while (0)
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif
@@ -245,20 +240,13 @@ APIError APIFrameHelper::try_send_tx_buf_() {
   return APIError::OK;  // All buffers sent successfully
 }
 
-const char *APIFrameHelper::get_peername_to(std::span<char, socket::SOCKADDR_STR_LEN> buf) const {
-  if (this->socket_) {
-    this->socket_->getpeername_to(buf);
-  } else {
-    buf[0] = '\0';
-  }
-  return buf.data();
-}
-
 APIError APIFrameHelper::init_common_() {
   if (state_ != State::INITIALIZE || this->socket_ == nullptr) {
     HELPER_LOG("Bad state for init %d", (int) state_);
     return APIError::BAD_STATE;
   }
+  // Cache peername now while socket is valid - needed for error logging after socket failure
+  this->socket_->getpeername_to(this->client_peername_);
   int err = this->socket_->setblocking(false);
   if (err != 0) {
     state_ = State::FAILED;

esphome/components/api/api_frame_helper.h

@@ -90,9 +90,8 @@ class APIFrameHelper {
 
   // Get client name (null-terminated)
   const char *get_client_name() const { return this->client_name_; }
-  // Get client peername/IP into caller-provided buffer (fetches on-demand from socket)
-  // Returns pointer to buf for convenience in printf-style calls
-  const char *get_peername_to(std::span<char, socket::SOCKADDR_STR_LEN> buf) const;
+  // Get client peername/IP (null-terminated, cached at init time for availability after socket failure)
+  const char *get_client_peername() const { return this->client_peername_; }
   // Set client name from buffer with length (truncates if needed)
   void set_client_name(const char *name, size_t len) {
     size_t copy_len = std::min(len, sizeof(this->client_name_) - 1);
@@ -106,8 +105,6 @@ class APIFrameHelper {
   bool can_write_without_blocking() { return this->state_ == State::DATA && this->tx_buf_count_ == 0; }
   int getpeername(struct sockaddr *addr, socklen_t *addrlen) { return socket_->getpeername(addr, addrlen); }
   APIError close() {
-    if (state_ == State::CLOSED)
-      return APIError::OK;  // Already closed
     state_ = State::CLOSED;
     int err = this->socket_->close();
     if (err == -1)
@@ -234,6 +231,8 @@ class APIFrameHelper {
 
   // Client name buffer - stores name from Hello message or initial peername
   char client_name_[CLIENT_INFO_NAME_MAX_LEN]{};
+  // Cached peername/IP address - captured at init time for availability after socket failure
+  char client_peername_[socket::SOCKADDR_STR_LEN]{};
 
   // Group smaller types together
   uint16_t rx_buf_len_ = 0;

esphome/components/api/api_frame_helper_noise.cpp

@@ -29,12 +29,7 @@ static constexpr size_t PROLOGUE_INIT_LEN = 12;  // strlen("NoiseAPIInit")
 static constexpr size_t API_MAX_LOG_BYTES = 168;
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-#define HELPER_LOG(msg, ...) \
-  do { \
-    char peername_buf[socket::SOCKADDR_STR_LEN]; \
-    this->get_peername_to(peername_buf); \
-    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername_buf, ##__VA_ARGS__); \
-  } while (0)
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -21,12 +21,7 @@ static const char *const TAG = "api.plaintext";
 static constexpr size_t API_MAX_LOG_BYTES = 168;
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-#define HELPER_LOG(msg, ...) \
-  do { \
-    char peername_buf[socket::SOCKADDR_STR_LEN]; \
-    this->get_peername_to(peername_buf); \
-    ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, peername_buf, ##__VA_ARGS__); \
-  } while (0)
+#define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_server.cpp

@@ -192,15 +192,11 @@ void APIServer::loop() {
     ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Save client info before closing socket and removal for the trigger
-    char peername_buf[socket::SOCKADDR_STR_LEN];
+    // Save client info before removal for the trigger
     std::string client_name(client->get_name());
-    std::string client_peername(client->get_peername_to(peername_buf));
+    std::string client_peername(client->get_peername());
 #endif
 
-    // Close socket now (was deferred from on_fatal_error to allow getpeername)
-    client->helper_->close();
-
     // Swap with the last element and pop (avoids expensive vector shifts)
     if (client_index < this->clients_.size() - 1) {
       std::swap(this->clients_[client_index], this->clients_.back());

esphome/components/api/homeassistant_service.h

@@ -128,20 +128,6 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
     this->add_kv_(this->variables_, key, std::forward<V>(value));
   }
 
-#ifdef USE_ESP8266
-  // On ESP8266, ESPHOME_F() returns __FlashStringHelper* (PROGMEM pointer).
-  // Store as const char* — populate_service_map copies from PROGMEM at play() time.
-  template<typename V> void add_data(const __FlashStringHelper *key, V &&value) {
-    this->add_kv_(this->data_, reinterpret_cast<const char *>(key), std::forward<V>(value));
-  }
-  template<typename V> void add_data_template(const __FlashStringHelper *key, V &&value) {
-    this->add_kv_(this->data_template_, reinterpret_cast<const char *>(key), std::forward<V>(value));
-  }
-  template<typename V> void add_variable(const __FlashStringHelper *key, V &&value) {
-    this->add_kv_(this->variables_, reinterpret_cast<const char *>(key), std::forward<V>(value));
-  }
-#endif
-
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
   template<typename T> void set_response_template(T response_template) {
     this->response_template_ = response_template;
@@ -233,31 +219,7 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
                                    Ts... x) {
     dest.init(source.size());
 
-#ifdef USE_ESP8266
-    // On ESP8266, keys may be in PROGMEM (from ESPHOME_F in codegen) and
-    // FLASH_STRING values need copying via _P functions.
-    // Allocate storage for all keys + all values (2 entries per source item).
-    // strlen_P/memcpy_P handle both RAM and PROGMEM pointers safely.
-    value_storage.init(source.size() * 2);
-
-    for (auto &it : source) {
-      auto &kv = dest.emplace_back();
-
-      // Key: copy from possible PROGMEM
-      {
-        size_t key_len = strlen_P(it.key);
-        value_storage.push_back(std::string(key_len, '\0'));
-        memcpy_P(value_storage.back().data(), it.key, key_len);
-        kv.key = StringRef(value_storage.back());
-      }
-
-      // Value: value() handles FLASH_STRING via _P functions internally
-      value_storage.push_back(it.value.value(x...));
-      kv.value = StringRef(value_storage.back());
-    }
-#else
-    // On non-ESP8266, strings are directly readable from flash-mapped memory.
-    // Count non-static strings to allocate exact storage needed.
+    // Count non-static strings to allocate exact storage needed
     size_t lambda_count = 0;
     for (const auto &it : source) {
       if (!it.value.is_static_string()) {
@@ -271,15 +233,14 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
       kv.key = StringRef(it.key);
 
       if (it.value.is_static_string()) {
-        // Static string — pointer directly readable, zero allocation
+        // Static string from YAML - zero allocation
         kv.value = StringRef(it.value.get_static_string());
       } else {
-        // Lambda — evaluate and store result
+        // Lambda evaluation - store result, reference it
         value_storage.push_back(it.value.value(x...));
         kv.value = StringRef(value_storage.back());
       }
     }
-#endif
   }
 
   APIServer *parent_;

esphome/components/api/user_services.h

@@ -264,9 +264,9 @@ template<typename... Ts> class APIRespondAction : public Action<Ts...> {
       // Build and send JSON response
       json::JsonBuilder builder;
       this->json_builder_(x..., builder.root());
-      auto json_buf = builder.serialize();
+      std::string json_str = builder.serialize();
       this->parent_->send_action_response(call_id, success, StringRef(error_message),
-                                          reinterpret_cast<const uint8_t *>(json_buf.data()), json_buf.size());
+                                          reinterpret_cast<const uint8_t *>(json_str.data()), json_str.size());
       return;
     }
 #endif

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/bedjet/bedjet_hub.cpp

@@ -3,7 +3,6 @@
 #include "bedjet_hub.h"
 #include "bedjet_child.h"
 #include "bedjet_const.h"
-#include "esphome/components/esp32_ble/ble_uuid.h"
 #include "esphome/core/application.h"
 #include <cinttypes>
 

esphome/components/bk72xx/boards.py

@@ -159,10 +159,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "cbu": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -231,10 +227,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "generic-bk7231t-qfn32-tuya": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -303,10 +295,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "generic-bk7231n-qfn32-tuya": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -497,7 +485,8 @@ BK72XX_BOARD_PINS = {
     },
     "cb3s": {
         "WIRE1_SCL": 20,
-        "WIRE1_SDA": 21,
+        "WIRE1_SDA_0": 21,
+        "WIRE1_SDA_1": 21,
         "SERIAL1_RX": 10,
         "SERIAL1_TX": 11,
         "SERIAL2_TX": 0,
@@ -658,10 +647,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "generic-bk7252": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE1_SCL": 20,
         "WIRE1_SDA": 21,
         "WIRE2_SCL": 0,
@@ -1111,10 +1096,6 @@ BK72XX_BOARD_PINS = {
         "A0": 23,
     },
     "cb3se": {
-        "SPI0_CS": 15,
-        "SPI0_MISO": 17,
-        "SPI0_MOSI": 16,
-        "SPI0_SCK": 14,
         "WIRE2_SCL": 0,
         "WIRE2_SDA": 1,
         "SERIAL1_RX": 10,

esphome/components/bmp3xx_base/bmp3xx_base.cpp

@@ -6,9 +6,8 @@
 */
 
 #include "bmp3xx_base.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
+#include "esphome/core/hal.h"
 #include <cinttypes>
 
 namespace esphome {
@@ -27,18 +26,46 @@ static const LogString *chip_type_to_str(uint8_t chip_type) {
   }
 }
 
-// Oversampling strings indexed by Oversampling enum (0-5): NONE, X2, X4, X8, X16, X32
-PROGMEM_STRING_TABLE(OversamplingStrings, "None", "2x", "4x", "8x", "16x", "32x", "");
-
 static const LogString *oversampling_to_str(Oversampling oversampling) {
-  return OversamplingStrings::get_log_str(static_cast<uint8_t>(oversampling), OversamplingStrings::LAST_INDEX);
+  switch (oversampling) {
+    case Oversampling::OVERSAMPLING_NONE:
+      return LOG_STR("None");
+    case Oversampling::OVERSAMPLING_X2:
+      return LOG_STR("2x");
+    case Oversampling::OVERSAMPLING_X4:
+      return LOG_STR("4x");
+    case Oversampling::OVERSAMPLING_X8:
+      return LOG_STR("8x");
+    case Oversampling::OVERSAMPLING_X16:
+      return LOG_STR("16x");
+    case Oversampling::OVERSAMPLING_X32:
+      return LOG_STR("32x");
+    default:
+      return LOG_STR("");
+  }
 }
 
-// IIR filter strings indexed by IIRFilter enum (0-7): OFF, 2, 4, 8, 16, 32, 64, 128
-PROGMEM_STRING_TABLE(IIRFilterStrings, "OFF", "2x", "4x", "8x", "16x", "32x", "64x", "128x", "");
-
 static const LogString *iir_filter_to_str(IIRFilter filter) {
-  return IIRFilterStrings::get_log_str(static_cast<uint8_t>(filter), IIRFilterStrings::LAST_INDEX);
+  switch (filter) {
+    case IIRFilter::IIR_FILTER_OFF:
+      return LOG_STR("OFF");
+    case IIRFilter::IIR_FILTER_2:
+      return LOG_STR("2x");
+    case IIRFilter::IIR_FILTER_4:
+      return LOG_STR("4x");
+    case IIRFilter::IIR_FILTER_8:
+      return LOG_STR("8x");
+    case IIRFilter::IIR_FILTER_16:
+      return LOG_STR("16x");
+    case IIRFilter::IIR_FILTER_32:
+      return LOG_STR("32x");
+    case IIRFilter::IIR_FILTER_64:
+      return LOG_STR("64x");
+    case IIRFilter::IIR_FILTER_128:
+      return LOG_STR("128x");
+    default:
+      return LOG_STR("");
+  }
 }
 
 void BMP3XXComponent::setup() {

esphome/components/bmp581_base/bmp581_base.cpp

@@ -11,26 +11,57 @@
  */
 
 #include "bmp581_base.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
+#include "esphome/core/hal.h"
 
 namespace esphome::bmp581_base {
 
 static const char *const TAG = "bmp581";
 
-// Oversampling strings indexed by Oversampling enum (0-7): NONE, X2, X4, X8, X16, X32, X64, X128
-PROGMEM_STRING_TABLE(OversamplingStrings, "None", "2x", "4x", "8x", "16x", "32x", "64x", "128x", "");
-
 static const LogString *oversampling_to_str(Oversampling oversampling) {
-  return OversamplingStrings::get_log_str(static_cast<uint8_t>(oversampling), OversamplingStrings::LAST_INDEX);
+  switch (oversampling) {
+    case Oversampling::OVERSAMPLING_NONE:
+      return LOG_STR("None");
+    case Oversampling::OVERSAMPLING_X2:
+      return LOG_STR("2x");
+    case Oversampling::OVERSAMPLING_X4:
+      return LOG_STR("4x");
+    case Oversampling::OVERSAMPLING_X8:
+      return LOG_STR("8x");
+    case Oversampling::OVERSAMPLING_X16:
+      return LOG_STR("16x");
+    case Oversampling::OVERSAMPLING_X32:
+      return LOG_STR("32x");
+    case Oversampling::OVERSAMPLING_X64:
+      return LOG_STR("64x");
+    case Oversampling::OVERSAMPLING_X128:
+      return LOG_STR("128x");
+    default:
+      return LOG_STR("");
+  }
 }
 
-// IIR filter strings indexed by IIRFilter enum (0-7): OFF, 2, 4, 8, 16, 32, 64, 128
-PROGMEM_STRING_TABLE(IIRFilterStrings, "OFF", "2x", "4x", "8x", "16x", "32x", "64x", "128x", "");
-
 static const LogString *iir_filter_to_str(IIRFilter filter) {
-  return IIRFilterStrings::get_log_str(static_cast<uint8_t>(filter), IIRFilterStrings::LAST_INDEX);
+  switch (filter) {
+    case IIRFilter::IIR_FILTER_OFF:
+      return LOG_STR("OFF");
+    case IIRFilter::IIR_FILTER_2:
+      return LOG_STR("2x");
+    case IIRFilter::IIR_FILTER_4:
+      return LOG_STR("4x");
+    case IIRFilter::IIR_FILTER_8:
+      return LOG_STR("8x");
+    case IIRFilter::IIR_FILTER_16:
+      return LOG_STR("16x");
+    case IIRFilter::IIR_FILTER_32:
+      return LOG_STR("32x");
+    case IIRFilter::IIR_FILTER_64:
+      return LOG_STR("64x");
+    case IIRFilter::IIR_FILTER_128:
+      return LOG_STR("128x");
+    default:
+      return LOG_STR("");
+  }
 }
 
 void BMP581Component::dump_config() {

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/debug/debug_esp8266.cpp

@@ -1,7 +1,6 @@
 #include "debug_component.h"
 #ifdef USE_ESP8266
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include <Esp.h>
 
 extern "C" {
@@ -20,31 +19,27 @@ namespace debug {
 
 static const char *const TAG = "debug";
 
-// PROGMEM string table for reset reasons, indexed by reason code (0-6), with "Unknown" as fallback
-// clang-format off
-PROGMEM_STRING_TABLE(ResetReasonStrings,
-  "Power On",                  // 0 = REASON_DEFAULT_RST
-  "Hardware Watchdog",         // 1 = REASON_WDT_RST
-  "Exception",                 // 2 = REASON_EXCEPTION_RST
-  "Software Watchdog",         // 3 = REASON_SOFT_WDT_RST
-  "Software/System restart",   // 4 = REASON_SOFT_RESTART
-  "Deep-Sleep Wake",           // 5 = REASON_DEEP_SLEEP_AWAKE
-  "External System",           // 6 = REASON_EXT_SYS_RST
-  "Unknown"                    // 7 = fallback
-);
-// clang-format on
-static_assert(REASON_DEFAULT_RST == 0, "Reset reason enum values must match table indices");
-static_assert(REASON_EXT_SYS_RST == 6, "Reset reason enum values must match table indices");
-
-// PROGMEM string table for flash chip modes, indexed by mode code (0-3), with "UNKNOWN" as fallback
-PROGMEM_STRING_TABLE(FlashModeStrings, "QIO", "QOUT", "DIO", "DOUT", "UNKNOWN");
-static_assert(FM_QIO == 0, "Flash mode enum values must match table indices");
-static_assert(FM_DOUT == 3, "Flash mode enum values must match table indices");
-
 // Get reset reason string from reason code (no heap allocation)
 // Returns LogString* pointing to flash (PROGMEM) on ESP8266
 static const LogString *get_reset_reason_str(uint32_t reason) {
-  return ResetReasonStrings::get_log_str(reason, ResetReasonStrings::LAST_INDEX);
+  switch (reason) {
+    case REASON_DEFAULT_RST:
+      return LOG_STR("Power On");
+    case REASON_WDT_RST:
+      return LOG_STR("Hardware Watchdog");
+    case REASON_EXCEPTION_RST:
+      return LOG_STR("Exception");
+    case REASON_SOFT_WDT_RST:
+      return LOG_STR("Software Watchdog");
+    case REASON_SOFT_RESTART:
+      return LOG_STR("Software/System restart");
+    case REASON_DEEP_SLEEP_AWAKE:
+      return LOG_STR("Deep-Sleep Wake");
+    case REASON_EXT_SYS_RST:
+      return LOG_STR("External System");
+    default:
+      return LOG_STR("Unknown");
+  }
 }
 
 // Size for core version hex buffer
@@ -97,8 +92,23 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
   char *buf = buffer.data();
 
-  // NOLINTNEXTLINE(readability-static-accessed-through-instance)
-  const LogString *flash_mode = FlashModeStrings::get_log_str(ESP.getFlashChipMode(), FlashModeStrings::LAST_INDEX);
+  const LogString *flash_mode;
+  switch (ESP.getFlashChipMode()) {  // NOLINT(readability-static-accessed-through-instance)
+    case FM_QIO:
+      flash_mode = LOG_STR("QIO");
+      break;
+    case FM_QOUT:
+      flash_mode = LOG_STR("QOUT");
+      break;
+    case FM_DIO:
+      flash_mode = LOG_STR("DIO");
+      break;
+    case FM_DOUT:
+      flash_mode = LOG_STR("DOUT");
+      break;
+    default:
+      flash_mode = LOG_STR("UNKNOWN");
+  }
   uint32_t flash_size = ESP.getFlashChipSize() / 1024;       // NOLINT(readability-static-accessed-through-instance)
   uint32_t flash_speed = ESP.getFlashChipSpeed() / 1000000;  // NOLINT(readability-static-accessed-through-instance)
   ESP_LOGD(TAG, "Flash Chip: Size=%" PRIu32 "kB Speed=%" PRIu32 "MHz Mode=%s", flash_size, flash_speed,

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/display/__init__.py

@@ -63,13 +63,11 @@ def validate_auto_clear(value):
     return cv.boolean(value)
 
 
-def basic_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a basic display schema with configurable default update interval."""
-    return cv.Schema(
-        {
-            cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
-        }
-    ).extend(cv.polling_component_schema(default_update_interval))
+BASIC_DISPLAY_SCHEMA = cv.Schema(
+    {
+        cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
+    }
+).extend(cv.polling_component_schema("1s"))
 
 
 def _validate_test_card(config):
@@ -83,41 +81,34 @@ def _validate_test_card(config):
     return config
 
 
-def full_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a full display schema with configurable default update interval."""
-    schema = basic_display_schema(default_update_interval).extend(
-        {
-            cv.Optional(CONF_ROTATION): validate_rotation,
-            cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
-                cv.ensure_list(
-                    {
-                        cv.GenerateID(): cv.declare_id(DisplayPage),
-                        cv.Required(CONF_LAMBDA): cv.lambda_,
-                    }
-                ),
-                cv.Length(min=1),
-            ),
-            cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
+    {
+        cv.Optional(CONF_ROTATION): validate_rotation,
+        cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
+            cv.ensure_list(
                 {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        DisplayOnPageChangeTrigger
-                    ),
-                    cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
-                    cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+                    cv.GenerateID(): cv.declare_id(DisplayPage),
+                    cv.Required(CONF_LAMBDA): cv.lambda_,
                 }
             ),
-            cv.Optional(
-                CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
-            ): validate_auto_clear,
-            cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
-        }
-    )
-    schema.add_extra(_validate_test_card)
-    return schema
-
-
-BASIC_DISPLAY_SCHEMA = basic_display_schema("1s")
-FULL_DISPLAY_SCHEMA = full_display_schema("1s")
+            cv.Length(min=1),
+        ),
+        cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    DisplayOnPageChangeTrigger
+                ),
+                cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
+                cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+            }
+        ),
+        cv.Optional(
+            CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
+        ): validate_auto_clear,
+        cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
+    }
+)
+FULL_DISPLAY_SCHEMA.add_extra(_validate_test_card)
 
 
 async def setup_display_core_(var, config):

esphome/components/dlms_meter/dlms_meter.cpp

@@ -28,28 +28,15 @@ 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();
-  if (avail > 0) {
-    size_t remaining = MBUS_MAX_FRAME_LENGTH * 2 - this->receive_buffer_.size();
-    if (remaining == 0) {
+  while (this->available()) {
+    if (this->receive_buffer_.size() >= MBUS_MAX_FRAME_LENGTH * 2) {
       ESP_LOGW(TAG, "Receive buffer full, dropping remaining bytes");
-    } else {
-      // Read all available bytes in batches to reduce UART call overhead.
-      // Cap reads to remaining buffer capacity.
-      if (avail > remaining) {
-        avail = remaining;
-      }
-      uint8_t buf[64];
-      while (avail > 0) {
-        size_t to_read = std::min(avail, sizeof(buf));
-        if (!this->read_array(buf, to_read)) {
-          break;
-        }
-        avail -= to_read;
-        this->receive_buffer_.insert(this->receive_buffer_.end(), buf, buf + to_read);
-        this->last_read_ = millis();
-      }
+      break;
     }
+    uint8_t c;
+    this->read_byte(&c);
+    this->receive_buffer_.push_back(c);
+    this->last_read_ = millis();
   }
 
   if (!this->receive_buffer_.empty() && millis() - this->last_read_ > this->read_timeout_) {

esphome/components/dsmr/dsmr.cpp

@@ -40,7 +40,9 @@ bool Dsmr::ready_to_request_data_() {
       this->start_requesting_data_();
     }
     if (!this->requesting_data_) {
-      this->drain_rx_buffer_();
+      while (this->available()) {
+        this->read();
+      }
     }
   }
   return this->requesting_data_;
@@ -113,18 +115,10 @@ void Dsmr::stop_requesting_data_() {
     } else {
       ESP_LOGV(TAG, "Stop reading data from P1 port");
     }
-    this->drain_rx_buffer_();
-    this->requesting_data_ = false;
-  }
-}
-
-void Dsmr::drain_rx_buffer_() {
-  uint8_t buf[64];
-  size_t avail;
-  while ((avail = this->available()) > 0) {
-    if (!this->read_array(buf, std::min(avail, sizeof(buf)))) {
-      break;
+    while (this->available()) {
+      this->read();
     }
+    this->requesting_data_ = false;
   }
 }
 
@@ -134,148 +128,125 @@ 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();
-    while (avail > 0) {
-      size_t to_read = std::min(avail, sizeof(buf));
-      if (!this->read_array(buf, to_read))
-        return;
-      avail -= to_read;
+    const char c = this->read();
 
-      for (size_t i = 0; i < to_read; i++) {
-        const char c = static_cast<char>(buf[i]);
+    // Find a new telegram header, i.e. forward slash.
+    if (c == '/') {
+      ESP_LOGV(TAG, "Header of telegram found");
+      this->reset_telegram_();
+      this->header_found_ = true;
+    }
+    if (!this->header_found_)
+      continue;
 
-        // Find a new telegram header, i.e. forward slash.
-        if (c == '/') {
-          ESP_LOGV(TAG, "Header of telegram found");
-          this->reset_telegram_();
-          this->header_found_ = true;
-        }
-        if (!this->header_found_)
-          continue;
+    // Check for buffer overflow.
+    if (this->bytes_read_ >= this->max_telegram_len_) {
+      this->reset_telegram_();
+      ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+      return;
+    }
 
-        // Check for buffer overflow.
-        if (this->bytes_read_ >= this->max_telegram_len_) {
-          this->reset_telegram_();
-          ESP_LOGE(TAG, "Error: telegram larger than buffer (%d bytes)", this->max_telegram_len_);
-          return;
-        }
-
-        // Some v2.2 or v3 meters will send a new value which starts with '('
-        // in a new line, while the value belongs to the previous ObisId. For
-        // proper parsing, remove these new line characters.
-        if (c == '(') {
-          while (true) {
-            auto previous_char = this->telegram_[this->bytes_read_ - 1];
-            if (previous_char == '\n' || previous_char == '\r') {
-              this->bytes_read_--;
-            } else {
-              break;
-            }
-          }
-        }
-
-        // Store the byte in the buffer.
-        this->telegram_[this->bytes_read_] = c;
-        this->bytes_read_++;
-
-        // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
-        if (c == '!') {
-          ESP_LOGV(TAG, "Footer of telegram found");
-          this->footer_found_ = true;
-          continue;
-        }
-        // Check for the end of the hex checksum, i.e. a newline.
-        if (this->footer_found_ && c == '\n') {
-          // Parse the telegram and publish sensor values.
-          this->parse_telegram();
-          this->reset_telegram_();
-          return;
+    // Some v2.2 or v3 meters will send a new value which starts with '('
+    // in a new line, while the value belongs to the previous ObisId. For
+    // proper parsing, remove these new line characters.
+    if (c == '(') {
+      while (true) {
+        auto previous_char = this->telegram_[this->bytes_read_ - 1];
+        if (previous_char == '\n' || previous_char == '\r') {
+          this->bytes_read_--;
+        } else {
+          break;
         }
       }
     }
+
+    // Store the byte in the buffer.
+    this->telegram_[this->bytes_read_] = c;
+    this->bytes_read_++;
+
+    // Check for a footer, i.e. exclamation mark, followed by a hex checksum.
+    if (c == '!') {
+      ESP_LOGV(TAG, "Footer of telegram found");
+      this->footer_found_ = true;
+      continue;
+    }
+    // Check for the end of the hex checksum, i.e. a newline.
+    if (this->footer_found_ && c == '\n') {
+      // Parse the telegram and publish sensor values.
+      this->parse_telegram();
+      this->reset_telegram_();
+      return;
+    }
   }
 }
 
 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();
-    while (avail > 0) {
-      size_t to_read = std::min(avail, sizeof(buf));
-      if (!this->read_array(buf, to_read))
-        return;
-      avail -= to_read;
+    const char c = this->read();
 
-      for (size_t i = 0; i < to_read; i++) {
-        const char c = static_cast<char>(buf[i]);
-
-        // Find a new telegram start byte.
-        if (!this->header_found_) {
-          if ((uint8_t) c != 0xDB) {
-            continue;
-          }
-          ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
-          this->reset_telegram_();
-          this->header_found_ = true;
-        }
-
-        // Check for buffer overflow.
-        if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
-          this->reset_telegram_();
-          ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
-          return;
-        }
-
-        // Store the byte in the buffer.
-        this->crypt_telegram_[this->crypt_bytes_read_] = c;
-        this->crypt_bytes_read_++;
-
-        // Read the length of the incoming encrypted telegram.
-        if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
-          // Complete header + data bytes
-          this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
-          ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
-        }
-
-        // Check for the end of the encrypted telegram.
-        if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
-          continue;
-        }
-        ESP_LOGV(TAG, "End of encrypted telegram found");
-
-        // Decrypt the encrypted telegram.
-        GCM<AES128> *gcmaes128{new GCM<AES128>()};
-        gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
-        // the iv is 8 bytes of the system title + 4 bytes frame counter
-        // system title is at byte 2 and frame counter at byte 15
-        for (int i = 10; i < 14; i++)
-          this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
-        constexpr uint16_t iv_size{12};
-        gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
-        gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
-                           // the ciphertext start at byte 18
-                           &this->crypt_telegram_[18],
-                           // cipher size
-                           this->crypt_bytes_read_ - 17);
-        delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
-
-        this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
-        ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
-        ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
-
-        // Parse the decrypted telegram and publish sensor values.
-        this->parse_telegram();
-        this->reset_telegram_();
-        return;
+    // Find a new telegram start byte.
+    if (!this->header_found_) {
+      if ((uint8_t) c != 0xDB) {
+        continue;
       }
+      ESP_LOGV(TAG, "Start byte 0xDB of encrypted telegram found");
+      this->reset_telegram_();
+      this->header_found_ = true;
     }
+
+    // Check for buffer overflow.
+    if (this->crypt_bytes_read_ >= this->max_telegram_len_) {
+      this->reset_telegram_();
+      ESP_LOGE(TAG, "Error: encrypted telegram larger than buffer (%d bytes)", this->max_telegram_len_);
+      return;
+    }
+
+    // Store the byte in the buffer.
+    this->crypt_telegram_[this->crypt_bytes_read_] = c;
+    this->crypt_bytes_read_++;
+
+    // Read the length of the incoming encrypted telegram.
+    if (this->crypt_telegram_len_ == 0 && this->crypt_bytes_read_ > 20) {
+      // Complete header + data bytes
+      this->crypt_telegram_len_ = 13 + (this->crypt_telegram_[11] << 8 | this->crypt_telegram_[12]);
+      ESP_LOGV(TAG, "Encrypted telegram length: %d bytes", this->crypt_telegram_len_);
+    }
+
+    // Check for the end of the encrypted telegram.
+    if (this->crypt_telegram_len_ == 0 || this->crypt_bytes_read_ != this->crypt_telegram_len_) {
+      continue;
+    }
+    ESP_LOGV(TAG, "End of encrypted telegram found");
+
+    // Decrypt the encrypted telegram.
+    GCM<AES128> *gcmaes128{new GCM<AES128>()};
+    gcmaes128->setKey(this->decryption_key_.data(), gcmaes128->keySize());
+    // the iv is 8 bytes of the system title + 4 bytes frame counter
+    // system title is at byte 2 and frame counter at byte 15
+    for (int i = 10; i < 14; i++)
+      this->crypt_telegram_[i] = this->crypt_telegram_[i + 4];
+    constexpr uint16_t iv_size{12};
+    gcmaes128->setIV(&this->crypt_telegram_[2], iv_size);
+    gcmaes128->decrypt(reinterpret_cast<uint8_t *>(this->telegram_),
+                       // the ciphertext start at byte 18
+                       &this->crypt_telegram_[18],
+                       // cipher size
+                       this->crypt_bytes_read_ - 17);
+    delete gcmaes128;  // NOLINT(cppcoreguidelines-owning-memory)
+
+    this->bytes_read_ = strnlen(this->telegram_, this->max_telegram_len_);
+    ESP_LOGV(TAG, "Decrypted telegram size: %d bytes", this->bytes_read_);
+    ESP_LOGVV(TAG, "Decrypted telegram: %s", this->telegram_);
+
+    // Parse the decrypted telegram and publish sensor values.
+    this->parse_telegram();
+    this->reset_telegram_();
+    return;
   }
 }
 

esphome/components/dsmr/dsmr.h

@@ -85,7 +85,6 @@ class Dsmr : public Component, public uart::UARTDevice {
   void receive_telegram_();
   void receive_encrypted_telegram_();
   void reset_telegram_();
-  void drain_rx_buffer_();
 
   /// Wait for UART data to become available within the read timeout.
   ///

esphome/components/esp32/gpio.cpp

@@ -85,6 +85,7 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
       break;
   }
   gpio_set_intr_type(this->get_pin_num(), idf_type);
+  gpio_intr_enable(this->get_pin_num());
   if (!isr_service_installed) {
     auto res = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL3);
     if (res != ESP_OK) {
@@ -94,7 +95,6 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
     isr_service_installed = true;
   }
   gpio_isr_handler_add(this->get_pin_num(), func, arg);
-  gpio_intr_enable(this->get_pin_num());
 }
 
 size_t ESP32InternalGPIOPin::dump_summary(char *buffer, size_t len) const {

esphome/components/esp32/preferences.cpp

@@ -19,7 +19,16 @@ static constexpr size_t KEY_BUFFER_SIZE = 12;
 
 struct NVSData {
   uint32_t key;
-  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
+  std::unique_ptr<uint8_t[]> data;
+  size_t len;
+
+  void set_data(const uint8_t *src, size_t size) {
+    if (!this->data || this->len != size) {
+      this->data = std::make_unique<uint8_t[]>(size);
+      this->len = size;
+    }
+    memcpy(this->data.get(), src, size);
+  }
 };
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -32,14 +41,14 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        obj.data.set(data, len);
+        obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
     save.key = this->key;
-    save.data.set(data, len);
-    s_pending_save.push_back(std::move(save));
+    save.set_data(data, len);
+    s_pending_save.emplace_back(std::move(save));
     ESP_LOGVV(TAG, "s_pending_save: key: %" PRIu32 ", len: %zu", this->key, len);
     return true;
   }
@@ -47,11 +56,11 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        if (obj.data.size() != len) {
+        if (obj.len != len) {
           // size mismatch
           return false;
         }
-        memcpy(data, obj.data.data(), len);
+        memcpy(data, obj.data.get(), len);
         return true;
       }
     }
@@ -127,10 +136,10 @@ class ESP32Preferences : public ESPPreferences {
       snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
       ESP_LOGVV(TAG, "Checking if NVS data %s has changed", key_str);
       if (this->is_changed_(this->nvs_handle, save, key_str)) {
-        esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.data(), save.data.size());
-        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.data.size());
+        esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.get(), save.len);
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.len);
         if (err != 0) {
-          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", key_str, save.data.size(), esp_err_to_name(err));
+          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", key_str, save.len, esp_err_to_name(err));
           failed++;
           last_err = err;
           last_key = save.key;
@@ -138,7 +147,7 @@ class ESP32Preferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGV(TAG, "NVS data not changed skipping %" PRIu32 "  len=%zu", save.key, save.data.size());
+        ESP_LOGV(TAG, "NVS data not changed skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
       s_pending_save.erase(s_pending_save.begin() + i);
@@ -169,7 +178,7 @@ class ESP32Preferences : public ESPPreferences {
       return true;
     }
     // Check size first before allocating memory
-    if (actual_len != to_save.data.size()) {
+    if (actual_len != to_save.len) {
       return true;
     }
     // Most preferences are small, use stack buffer with heap fallback for large ones
@@ -179,7 +188,7 @@ class ESP32Preferences : public ESPPreferences {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key_str, esp_err_to_name(err));
       return true;
     }
-    return memcmp(to_save.data.data(), stored_data.get(), to_save.data.size()) != 0;
+    return memcmp(to_save.data.get(), stored_data.get(), to_save.len) != 0;
   }
 
   bool reset() override {

esphome/components/esp32_ble/ble.cpp

@@ -98,10 +98,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -28,7 +28,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,6 +1,5 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/ethernet/ethernet_component.cpp

@@ -811,8 +811,8 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
   ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
   char hex_buf[format_hex_pretty_size(PHY_REG_SIZE)];
-  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 #endif
+  ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s", format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
 
   /*
    * Bit 7 is `RMII Reference Clock Select`. Default is `0`.
@@ -829,10 +829,8 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
     ESPHL_ERROR_CHECK(err, "Write PHY Control 2 failed");
     err = mac->read_phy_reg(mac, this->phy_addr_, KSZ80XX_PC2R_REG_ADDR, &(phy_control_2));
     ESPHL_ERROR_CHECK(err, "Read PHY Control 2 failed");
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
     ESP_LOGVV(TAG, "KSZ8081 PHY Control 2: %s",
               format_hex_pretty_to(hex_buf, (uint8_t *) &phy_control_2, PHY_REG_SIZE));
-#endif
   }
 }
 #endif  // USE_ETHERNET_KSZ8081

esphome/components/fan/fan.cpp

@@ -68,7 +68,7 @@ void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
   if (this->speed_.has_value()) {
-    this->speed_ = clamp(*this->speed_, 1, static_cast<int>(traits.supported_speed_count()));
+    this->speed_ = clamp(*this->speed_, 1, traits.supported_speed_count());
 
     // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
     // "Manually setting a speed must disable any set preset mode"

esphome/components/fan/fan_traits.h

@@ -11,7 +11,7 @@ namespace fan {
 class FanTraits {
  public:
   FanTraits() = default;
-  FanTraits(bool oscillation, bool speed, bool direction, uint8_t speed_count)
+  FanTraits(bool oscillation, bool speed, bool direction, int speed_count)
       : oscillation_(oscillation), speed_(speed), direction_(direction), speed_count_(speed_count) {}
 
   /// Return if this fan supports oscillation.
@@ -23,9 +23,9 @@ class FanTraits {
   /// Set whether this fan supports speed levels.
   void set_speed(bool speed) { this->speed_ = speed; }
   /// Return how many speed levels the fan has
-  uint8_t supported_speed_count() const { return this->speed_count_; }
+  int supported_speed_count() const { return this->speed_count_; }
   /// Set how many speed levels this fan has.
-  void set_supported_speed_count(uint8_t speed_count) { this->speed_count_ = speed_count; }
+  void set_supported_speed_count(int speed_count) { this->speed_count_ = speed_count; }
   /// Return if this fan supports changing direction
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction
@@ -64,7 +64,7 @@ class FanTraits {
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
-  uint8_t speed_count_{};
+  int speed_count_{};
   std::vector<const char *> preset_modes_{};
 };
 

esphome/components/hbridge/fan/__init__.py

@@ -39,7 +39,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_DECAY_MODE, default="SLOW"): cv.enum(
                 DECAY_MODE_OPTIONS, upper=True
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_ENABLE_PIN): cv.use_id(output.FloatOutput),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }

esphome/components/hbridge/fan/hbridge_fan.h

@@ -15,7 +15,7 @@ enum DecayMode {
 
 class HBridgeFan : public Component, public fan::Fan {
  public:
-  HBridgeFan(uint8_t speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
+  HBridgeFan(int speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
 
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
@@ -33,7 +33,7 @@ class HBridgeFan : public Component, public fan::Fan {
   output::FloatOutput *pin_b_;
   output::FloatOutput *enable_{nullptr};
   output::BinaryOutput *oscillating_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};

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/http_request/update/http_request_update.cpp

@@ -90,14 +90,16 @@ void HttpRequestUpdate::update_task(void *params) {
     UPDATE_RETURN;
   }
   size_t read_index = container->get_bytes_read();
-  size_t content_length = container->content_length;
-
-  container->end();
-  container.reset();  // Release ownership of the container's shared_ptr
 
   bool valid = false;
-  {  // Scope to ensure JsonDocument is destroyed before deallocating buffer
-    valid = json::parse_json(data, read_index, [this_update](JsonObject root) -> bool {
+  {  // Ensures the response string falls out of scope and deallocates before the task ends
+    std::string response((char *) data, read_index);
+    allocator.deallocate(data, container->content_length);
+
+    container->end();
+    container.reset();  // Release ownership of the container's shared_ptr
+
+    valid = json::parse_json(response, [this_update](JsonObject root) -> bool {
       if (!root[ESPHOME_F("name")].is<const char *>() || !root[ESPHOME_F("version")].is<const char *>() ||
           !root[ESPHOME_F("builds")].is<JsonArray>()) {
         ESP_LOGE(TAG, "Manifest does not contain required fields");
@@ -135,7 +137,6 @@ void HttpRequestUpdate::update_task(void *params) {
       return false;
     });
   }
-  allocator.deallocate(data, content_length);
 
   if (!valid) {
     ESP_LOGE(TAG, "Failed to parse JSON from %s", this_update->source_url_.c_str());
@@ -156,12 +157,17 @@ void HttpRequestUpdate::update_task(void *params) {
     }
   }
 
+  {  // Ensures the current version string falls out of scope and deallocates before the task ends
+    std::string current_version;
 #ifdef ESPHOME_PROJECT_VERSION
-  this_update->update_info_.current_version = ESPHOME_PROJECT_VERSION;
+    current_version = ESPHOME_PROJECT_VERSION;
 #else
-  this_update->update_info_.current_version = ESPHOME_VERSION;
+    current_version = ESPHOME_VERSION;
 #endif
 
+    this_update->update_info_.current_version = current_version;
+  }
+
   bool trigger_update_available = false;
 
   if (this_update->update_info_.latest_version.empty() ||

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -119,7 +119,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/improv_serial/improv_serial_component.cpp

@@ -267,26 +267,16 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       for (auto &scan : results) {
         if (scan.get_is_hidden())
           continue;
-        const char *ssid_cstr = scan.get_ssid().c_str();
-        // Check if we've already sent this SSID
-        bool duplicate = false;
-        for (const auto &seen : networks) {
-          if (strcmp(seen.c_str(), ssid_cstr) == 0) {
-            duplicate = true;
-            break;
-          }
-        }
-        if (duplicate)
+        const std::string &ssid = scan.get_ssid();
+        if (std::find(networks.begin(), networks.end(), ssid) != networks.end())
           continue;
-        // Only allocate std::string after confirming it's not a duplicate
-        std::string ssid(ssid_cstr);
         // Send each ssid separately to avoid overflowing the buffer
         char rssi_buf[5];  // int8_t: -128 to 127, max 4 chars + null
         *int8_to_str(rssi_buf, scan.get_rssi()) = '\0';
         std::vector<uint8_t> data =
             improv::build_rpc_response(improv::GET_WIFI_NETWORKS, {ssid, rssi_buf, YESNO(scan.get_with_auth())}, false);
         this->send_response_(data);
-        networks.push_back(std::move(ssid));
+        networks.push_back(ssid);
       }
       // Send empty response to signify the end of the list.
       std::vector<uint8_t> data =

esphome/components/json/json_util.cpp

@@ -15,7 +15,7 @@ static const char *const TAG = "json";
 static SpiRamAllocator global_json_allocator;
 #endif
 
-SerializationBuffer<> build_json(const json_build_t &f) {
+std::string build_json(const json_build_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   JsonBuilder builder;
   JsonObject root = builder.root();
@@ -25,13 +25,8 @@ SerializationBuffer<> build_json(const json_build_t &f) {
 }
 
 bool parse_json(const std::string &data, const json_parse_t &f) {
-  // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  return parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size(), f);
-}
-
-bool parse_json(const uint8_t *data, size_t len, const json_parse_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-  JsonDocument doc = parse_json(data, len);
+  JsonDocument doc = parse_json(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
   if (doc.overflowed() || doc.isNull())
     return false;
   return f(doc.as<JsonObject>());
@@ -66,62 +61,14 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
-SerializationBuffer<> JsonBuilder::serialize() {
-  // ===========================================================================================
-  // CRITICAL: NRVO (Named Return Value Optimization) - DO NOT REFACTOR WITHOUT UNDERSTANDING
-  // ===========================================================================================
-  //
-  // This function is carefully structured to enable NRVO. The compiler constructs `result`
-  // directly in the caller's stack frame, eliminating the move constructor call entirely.
-  //
-  // WITHOUT NRVO: Each return would trigger SerializationBuffer's move constructor, which
-  // must memcpy up to 768 bytes of stack buffer content. This happens on EVERY JSON
-  // serialization (sensor updates, web server responses, MQTT publishes, etc.).
-  //
-  // WITH NRVO: Zero memcpy, zero move constructor overhead. The buffer lives directly
-  // where the caller needs it.
-  //
-  // Requirements for NRVO to work:
-  //   1. Single named variable (`result`) returned from ALL paths
-  //   2. All paths must return the SAME variable (not different variables)
-  //   3. No std::move() on the return statement
-  //
-  // If you must modify this function:
-  //   - Keep a single `result` variable declared at the top
-  //   - All code paths must return `result` (not a different variable)
-  //   - Verify NRVO still works by checking the disassembly for move constructor calls
-  //   - Test: objdump -d -C firmware.elf | grep "SerializationBuffer.*SerializationBuffer"
-  //     Should show only destructor, NOT move constructor
-  //
-  // Why we avoid measureJson(): It instantiates DummyWriter templates adding ~1KB flash.
-  // Instead, try stack buffer first. 768 bytes covers 99.9% of JSON payloads (sensors ~200B,
-  // lights ~170B, climate ~700B). Only entities with 40+ options exceed this.
-  //
-  // ===========================================================================================
-  constexpr size_t buf_size = SerializationBuffer<>::BUFFER_SIZE;
-  SerializationBuffer<> result(buf_size - 1);  // Max content size (reserve 1 for null)
-
+std::string JsonBuilder::serialize() {
   if (doc_.overflowed()) {
     ESP_LOGE(TAG, "JSON document overflow");
-    auto *buf = result.data_writable_();
-    buf[0] = '{';
-    buf[1] = '}';
-    buf[2] = '\0';
-    result.set_size_(2);
-    return result;
+    return "{}";
   }
-
-  size_t size = serializeJson(doc_, result.data_writable_(), buf_size);
-  if (size < buf_size) {
-    // Fits in stack buffer - update size to actual length
-    result.set_size_(size);
-    return result;
-  }
-
-  // Needs heap allocation - reallocate and serialize again with exact size
-  result.reallocate_heap_(size);
-  serializeJson(doc_, result.data_writable_(), size + 1);
-  return result;
+  std::string output;
+  serializeJson(doc_, output);
+  return output;
 }
 
 }  // namespace json

esphome/components/json/json_util.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cstring>
-#include <string>
 #include <vector>
 
 #include "esphome/core/defines.h"
@@ -16,108 +14,6 @@
 namespace esphome {
 namespace json {
 
-/// Buffer for JSON serialization that uses stack allocation for small payloads.
-/// Template parameter STACK_SIZE specifies the stack buffer size (default 768 bytes).
-/// Supports move semantics for efficient return-by-value.
-template<size_t STACK_SIZE = 768> class SerializationBuffer {
- public:
-  static constexpr size_t BUFFER_SIZE = STACK_SIZE;  ///< Stack buffer size for this instantiation
-
-  /// Construct with known size (typically from measureJson)
-  explicit SerializationBuffer(size_t size) : size_(size) {
-    if (size + 1 <= STACK_SIZE) {
-      buffer_ = stack_buffer_;
-    } else {
-      heap_buffer_ = new char[size + 1];
-      buffer_ = heap_buffer_;
-    }
-    buffer_[0] = '\0';
-  }
-
-  ~SerializationBuffer() { delete[] heap_buffer_; }
-
-  // Move constructor - works with same template instantiation
-  SerializationBuffer(SerializationBuffer &&other) noexcept : heap_buffer_(other.heap_buffer_), size_(other.size_) {
-    if (other.buffer_ == other.stack_buffer_) {
-      // Stack buffer - must copy content
-      std::memcpy(stack_buffer_, other.stack_buffer_, size_ + 1);
-      buffer_ = stack_buffer_;
-    } else {
-      // Heap buffer - steal ownership
-      buffer_ = heap_buffer_;
-      other.heap_buffer_ = nullptr;
-    }
-    // Leave moved-from object in valid empty state
-    other.stack_buffer_[0] = '\0';
-    other.buffer_ = other.stack_buffer_;
-    other.size_ = 0;
-  }
-
-  // Move assignment
-  SerializationBuffer &operator=(SerializationBuffer &&other) noexcept {
-    if (this != &other) {
-      delete[] heap_buffer_;
-      heap_buffer_ = other.heap_buffer_;
-      size_ = other.size_;
-      if (other.buffer_ == other.stack_buffer_) {
-        std::memcpy(stack_buffer_, other.stack_buffer_, size_ + 1);
-        buffer_ = stack_buffer_;
-      } else {
-        buffer_ = heap_buffer_;
-        other.heap_buffer_ = nullptr;
-      }
-      // Leave moved-from object in valid empty state
-      other.stack_buffer_[0] = '\0';
-      other.buffer_ = other.stack_buffer_;
-      other.size_ = 0;
-    }
-    return *this;
-  }
-
-  // Delete copy operations
-  SerializationBuffer(const SerializationBuffer &) = delete;
-  SerializationBuffer &operator=(const SerializationBuffer &) = delete;
-
-  /// Get null-terminated C string
-  const char *c_str() const { return buffer_; }
-  /// Get data pointer
-  const char *data() const { return buffer_; }
-  /// Get string length (excluding null terminator)
-  size_t size() const { return size_; }
-
-  /// Implicit conversion to std::string for backward compatibility
-  /// WARNING: This allocates a new std::string on the heap. Prefer using
-  /// c_str() or data()/size() directly when possible to avoid allocation.
-  operator std::string() const { return std::string(buffer_, size_); }  // NOLINT(google-explicit-constructor)
-
- private:
-  friend class JsonBuilder;  ///< Allows JsonBuilder::serialize() to call private methods
-
-  /// Get writable buffer (for serialization)
-  char *data_writable_() { return buffer_; }
-  /// Set actual size after serialization (must not exceed allocated size)
-  /// Also ensures null termination for c_str() safety
-  void set_size_(size_t size) {
-    size_ = size;
-    buffer_[size] = '\0';
-  }
-
-  /// Reallocate to heap buffer with new size (for when stack buffer is too small)
-  /// This invalidates any previous buffer content. Used by JsonBuilder::serialize().
-  void reallocate_heap_(size_t size) {
-    delete[] heap_buffer_;
-    heap_buffer_ = new char[size + 1];
-    buffer_ = heap_buffer_;
-    size_ = size;
-    buffer_[0] = '\0';
-  }
-
-  char stack_buffer_[STACK_SIZE];
-  char *heap_buffer_{nullptr};
-  char *buffer_;
-  size_t size_;
-};
-
 #ifdef USE_PSRAM
 // Build an allocator for the JSON Library using the RAMAllocator class
 // This is only compiled when PSRAM is enabled
@@ -150,13 +46,10 @@ using json_parse_t = std::function<bool(JsonObject)>;
 using json_build_t = std::function<void(JsonObject)>;
 
 /// Build a JSON string with the provided json build function.
-/// Returns SerializationBuffer for stack-first allocation; implicitly converts to std::string.
-SerializationBuffer<> build_json(const json_build_t &f);
+std::string build_json(const json_build_t &f);
 
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);
-/// Parse JSON from raw bytes and run the provided json parse function if it's valid.
-bool parse_json(const uint8_t *data, size_t len, const json_parse_t &f);
 
 /// Parse a JSON string and return the root JsonDocument (or an unbound object on error)
 JsonDocument parse_json(const uint8_t *data, size_t len);
@@ -176,9 +69,7 @@ class JsonBuilder {
     return root_;
   }
 
-  /// Serialize the JSON document to a SerializationBuffer (stack-first allocation)
-  /// Uses 768-byte stack buffer by default, falls back to heap for larger JSON
-  SerializationBuffer<> serialize();
+  std::string serialize();
 
  private:
 #ifdef USE_PSRAM

esphome/components/kuntze/kuntze.cpp

@@ -11,7 +11,7 @@ static const char *const TAG = "kuntze";
 static const uint8_t CMD_READ_REG = 0x03;
 static const uint16_t REGISTER[] = {4136, 4160, 4680, 6000, 4688, 4728, 5832};
 
-// Maximum bytes to log for Modbus responses (2 registers = 4 bytes, plus byte count = 5 bytes)
+// Maximum bytes to log for Modbus responses (2 registers = 4, plus count = 5)
 static constexpr size_t KUNTZE_MAX_LOG_BYTES = 8;
 
 void Kuntze::on_modbus_data(const std::vector<uint8_t> &data) {

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

@@ -335,10 +335,9 @@ void LD2420Component::revert_config_action() {
 
 void LD2420Component::loop() {
   // If there is a active send command do not process it here, the send command call will handle it.
-  if (this->cmd_active_) {
-    return;
+  while (!this->cmd_active_ && this->available()) {
+    this->readline_(this->read(), this->buffer_data_, MAX_LINE_LENGTH);
   }
-  this->read_batch_(this->buffer_data_);
 }
 
 void LD2420Component::update_radar_data(uint16_t const *gate_energy, uint8_t sample_number) {
@@ -540,23 +539,6 @@ 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();
-  uint8_t buf[MAX_LINE_LENGTH];
-  while (avail > 0) {
-    size_t to_read = std::min(avail, sizeof(buf));
-    if (!this->read_array(buf, to_read)) {
-      break;
-    }
-    avail -= to_read;
-
-    for (size_t i = 0; i < to_read; i++) {
-      this->readline_(buf[i], buffer.data(), buffer.size());
-    }
-  }
-}
-
 void LD2420Component::handle_ack_data_(uint8_t *buffer, int len) {
   this->cmd_reply_.command = buffer[CMD_FRAME_COMMAND];
   this->cmd_reply_.length = buffer[CMD_FRAME_DATA_LENGTH];

esphome/components/ld2420/ld2420.h

@@ -4,7 +4,6 @@
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"
-#include <span>
 #ifdef USE_TEXT_SENSOR
 #include "esphome/components/text_sensor/text_sensor.h"
 #endif
@@ -166,7 +165,6 @@ class LD2420Component : public Component, public uart::UARTDevice {
   void handle_energy_mode_(uint8_t *buffer, int len);
   void handle_ack_data_(uint8_t *buffer, int len);
   void readline_(int rx_data, uint8_t *buffer, int len);
-  void read_batch_(std::span<uint8_t, MAX_LINE_LENGTH> buffer);
   void set_calibration_(bool state) { this->calibration_ = state; };
   bool get_calibration_() { return this->calibration_; };
 

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/libretiny/__init__.py

@@ -193,14 +193,14 @@ def _notify_old_style(config):
 # The dev and latest branches will be at *least* this version, which is what matters.
 # Use GitHub releases directly to avoid PlatformIO moderation delays.
 ARDUINO_VERSIONS = {
-    "dev": (cv.Version(1, 12, 1), "https://github.com/libretiny-eu/libretiny.git"),
+    "dev": (cv.Version(1, 11, 0), "https://github.com/libretiny-eu/libretiny.git"),
     "latest": (
-        cv.Version(1, 12, 1),
-        "https://github.com/libretiny-eu/libretiny.git#v1.12.1",
+        cv.Version(1, 11, 0),
+        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
     ),
     "recommended": (
-        cv.Version(1, 12, 1),
-        "https://github.com/libretiny-eu/libretiny.git#v1.12.1",
+        cv.Version(1, 11, 0),
+        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
     ),
 }
 

esphome/components/libretiny/preferences.cpp

@@ -18,7 +18,16 @@ static constexpr size_t KEY_BUFFER_SIZE = 12;
 
 struct NVSData {
   uint32_t key;
-  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
+  std::unique_ptr<uint8_t[]> data;
+  size_t len;
+
+  void set_data(const uint8_t *src, size_t size) {
+    if (!this->data || this->len != size) {
+      this->data = std::make_unique<uint8_t[]>(size);
+      this->len = size;
+    }
+    memcpy(this->data.get(), src, size);
+  }
 };
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -33,14 +42,14 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        obj.data.set(data, len);
+        obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
     save.key = this->key;
-    save.data.set(data, len);
-    s_pending_save.push_back(std::move(save));
+    save.set_data(data, len);
+    s_pending_save.emplace_back(std::move(save));
     ESP_LOGVV(TAG, "s_pending_save: key: %" PRIu32 ", len: %zu", this->key, len);
     return true;
   }
@@ -49,11 +58,11 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        if (obj.data.size() != len) {
+        if (obj.len != len) {
           // size mismatch
           return false;
         }
-        memcpy(data, obj.data.data(), len);
+        memcpy(data, obj.data.get(), len);
         return true;
       }
     }
@@ -117,11 +126,11 @@ class LibreTinyPreferences : public ESPPreferences {
       snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
       ESP_LOGVV(TAG, "Checking if FDB data %s has changed", key_str);
       if (this->is_changed_(&this->db, save, key_str)) {
-        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.data.size());
-        fdb_blob_make(&this->blob, save.data.data(), save.data.size());
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.len);
+        fdb_blob_make(&this->blob, save.data.get(), save.len);
         fdb_err_t err = fdb_kv_set_blob(&this->db, key_str, &this->blob);
         if (err != FDB_NO_ERR) {
-          ESP_LOGV(TAG, "fdb_kv_set_blob('%s', len=%zu) failed: %d", key_str, save.data.size(), err);
+          ESP_LOGV(TAG, "fdb_kv_set_blob('%s', len=%zu) failed: %d", key_str, save.len, err);
           failed++;
           last_err = err;
           last_key = save.key;
@@ -129,7 +138,7 @@ class LibreTinyPreferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGD(TAG, "FDB data not changed; skipping %" PRIu32 "  len=%zu", save.key, save.data.size());
+        ESP_LOGD(TAG, "FDB data not changed; skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
       s_pending_save.erase(s_pending_save.begin() + i);
@@ -153,7 +162,7 @@ class LibreTinyPreferences : public ESPPreferences {
     }
 
     // Check size first - if different, data has changed
-    if (kv.value_len != to_save.data.size()) {
+    if (kv.value_len != to_save.len) {
       return true;
     }
 
@@ -167,7 +176,7 @@ class LibreTinyPreferences : public ESPPreferences {
     }
 
     // Compare the actual data
-    return memcmp(to_save.data.data(), stored_data.get(), kv.value_len) != 0;
+    return memcmp(to_save.data.get(), stored_data.get(), kv.value_len) != 0;
   }
 
   bool reset() override {

esphome/components/ln882x/boards.py

@@ -154,26 +154,28 @@ LN882X_BOARD_PINS = {
         "A7": 21,
     },
     "wb02a": {
-        "WIRE0_SCL_0": 1,
-        "WIRE0_SCL_1": 2,
+        "WIRE0_SCL_0": 7,
+        "WIRE0_SCL_1": 5,
         "WIRE0_SCL_2": 3,
-        "WIRE0_SCL_3": 4,
-        "WIRE0_SCL_4": 5,
-        "WIRE0_SCL_5": 7,
-        "WIRE0_SCL_6": 9,
-        "WIRE0_SCL_7": 10,
-        "WIRE0_SCL_8": 24,
-        "WIRE0_SCL_9": 25,
-        "WIRE0_SDA_0": 1,
-        "WIRE0_SDA_1": 2,
+        "WIRE0_SCL_3": 10,
+        "WIRE0_SCL_4": 2,
+        "WIRE0_SCL_5": 1,
+        "WIRE0_SCL_6": 4,
+        "WIRE0_SCL_7": 5,
+        "WIRE0_SCL_8": 9,
+        "WIRE0_SCL_9": 24,
+        "WIRE0_SCL_10": 25,
+        "WIRE0_SDA_0": 7,
+        "WIRE0_SDA_1": 5,
         "WIRE0_SDA_2": 3,
-        "WIRE0_SDA_3": 4,
-        "WIRE0_SDA_4": 5,
-        "WIRE0_SDA_5": 7,
-        "WIRE0_SDA_6": 9,
-        "WIRE0_SDA_7": 10,
-        "WIRE0_SDA_8": 24,
-        "WIRE0_SDA_9": 25,
+        "WIRE0_SDA_3": 10,
+        "WIRE0_SDA_4": 2,
+        "WIRE0_SDA_5": 1,
+        "WIRE0_SDA_6": 4,
+        "WIRE0_SDA_7": 5,
+        "WIRE0_SDA_8": 9,
+        "WIRE0_SDA_9": 24,
+        "WIRE0_SDA_10": 25,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,
@@ -219,32 +221,32 @@ LN882X_BOARD_PINS = {
         "A1": 4,
     },
     "wl2s": {
-        "WIRE0_SCL_0": 0,
-        "WIRE0_SCL_1": 1,
-        "WIRE0_SCL_2": 2,
-        "WIRE0_SCL_3": 3,
-        "WIRE0_SCL_4": 5,
-        "WIRE0_SCL_5": 7,
-        "WIRE0_SCL_6": 9,
-        "WIRE0_SCL_7": 10,
-        "WIRE0_SCL_8": 11,
-        "WIRE0_SCL_9": 12,
-        "WIRE0_SCL_10": 19,
-        "WIRE0_SCL_11": 24,
-        "WIRE0_SCL_12": 25,
-        "WIRE0_SDA_0": 0,
-        "WIRE0_SDA_1": 1,
-        "WIRE0_SDA_2": 2,
-        "WIRE0_SDA_3": 3,
-        "WIRE0_SDA_4": 5,
-        "WIRE0_SDA_5": 7,
-        "WIRE0_SDA_6": 9,
-        "WIRE0_SDA_7": 10,
-        "WIRE0_SDA_8": 11,
-        "WIRE0_SDA_9": 12,
-        "WIRE0_SDA_10": 19,
-        "WIRE0_SDA_11": 24,
-        "WIRE0_SDA_12": 25,
+        "WIRE0_SCL_0": 7,
+        "WIRE0_SCL_1": 12,
+        "WIRE0_SCL_2": 3,
+        "WIRE0_SCL_3": 10,
+        "WIRE0_SCL_4": 2,
+        "WIRE0_SCL_5": 0,
+        "WIRE0_SCL_6": 19,
+        "WIRE0_SCL_7": 11,
+        "WIRE0_SCL_8": 9,
+        "WIRE0_SCL_9": 24,
+        "WIRE0_SCL_10": 25,
+        "WIRE0_SCL_11": 5,
+        "WIRE0_SCL_12": 1,
+        "WIRE0_SDA_0": 7,
+        "WIRE0_SDA_1": 12,
+        "WIRE0_SDA_2": 3,
+        "WIRE0_SDA_3": 10,
+        "WIRE0_SDA_4": 2,
+        "WIRE0_SDA_5": 0,
+        "WIRE0_SDA_6": 19,
+        "WIRE0_SDA_7": 11,
+        "WIRE0_SDA_8": 9,
+        "WIRE0_SDA_9": 24,
+        "WIRE0_SDA_10": 25,
+        "WIRE0_SDA_11": 5,
+        "WIRE0_SDA_12": 1,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,
@@ -299,24 +301,24 @@ LN882X_BOARD_PINS = {
         "A2": 1,
     },
     "ln-02": {
-        "WIRE0_SCL_0": 0,
-        "WIRE0_SCL_1": 1,
-        "WIRE0_SCL_2": 2,
-        "WIRE0_SCL_3": 3,
-        "WIRE0_SCL_4": 9,
-        "WIRE0_SCL_5": 11,
-        "WIRE0_SCL_6": 19,
-        "WIRE0_SCL_7": 24,
-        "WIRE0_SCL_8": 25,
-        "WIRE0_SDA_0": 0,
-        "WIRE0_SDA_1": 1,
-        "WIRE0_SDA_2": 2,
-        "WIRE0_SDA_3": 3,
-        "WIRE0_SDA_4": 9,
-        "WIRE0_SDA_5": 11,
-        "WIRE0_SDA_6": 19,
-        "WIRE0_SDA_7": 24,
-        "WIRE0_SDA_8": 25,
+        "WIRE0_SCL_0": 11,
+        "WIRE0_SCL_1": 19,
+        "WIRE0_SCL_2": 3,
+        "WIRE0_SCL_3": 24,
+        "WIRE0_SCL_4": 2,
+        "WIRE0_SCL_5": 25,
+        "WIRE0_SCL_6": 1,
+        "WIRE0_SCL_7": 0,
+        "WIRE0_SCL_8": 9,
+        "WIRE0_SDA_0": 11,
+        "WIRE0_SDA_1": 19,
+        "WIRE0_SDA_2": 3,
+        "WIRE0_SDA_3": 24,
+        "WIRE0_SDA_4": 2,
+        "WIRE0_SDA_5": 25,
+        "WIRE0_SDA_6": 1,
+        "WIRE0_SDA_7": 0,
+        "WIRE0_SDA_8": 9,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,

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/logger_esp8266.cpp.bak

@@ -1,51 +0,0 @@
-#ifdef USE_ESP8266
-#include "logger.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-      case UART_SELECTION_UART0_SWAP:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        if (this->uart_ == UART_SELECTION_UART0_SWAP) {
-          Serial.swap();
-        }
-        Serial.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-        break;
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-        break;
-    }
-  } else {
-    uart_set_debug(UART_NO);
-  }
-
-  global_logger = this;
-
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-    case UART_SELECTION_UART0_SWAP:
-    default:
-      return LOG_STR("UART0_SWAP");
-  }
-}
-
-}  // namespace esphome::logger
-#endif

esphome/components/logger/logger_host.cpp.bak

@@ -1,22 +0,0 @@
-#if defined(USE_HOST)
-#include "logger.h"
-
-namespace esphome::logger {
-
-void HOT Logger::write_msg_(const char *msg) {
-  time_t rawtime;
-  struct tm *timeinfo;
-  char buffer[80];
-
-  time(&rawtime);
-  timeinfo = localtime(&rawtime);
-  strftime(buffer, sizeof buffer, "[%H:%M:%S]", timeinfo);
-  fputs(buffer, stdout);
-  puts(msg);
-}
-
-void Logger::pre_setup() { global_logger = this; }
-
-}  // namespace esphome::logger
-
-#endif

esphome/components/logger/logger_libretiny.cpp.bak

@@ -1,70 +0,0 @@
-#ifdef USE_LIBRETINY
-#include "logger.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-#if LT_HW_UART0
-      case UART_SELECTION_UART0:
-        this->hw_serial_ = &Serial0;
-        Serial0.begin(this->baud_rate_);
-        break;
-#endif
-#if LT_HW_UART1
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        break;
-#endif
-#if LT_HW_UART2
-      case UART_SELECTION_UART2:
-        this->hw_serial_ = &Serial2;
-        Serial2.begin(this->baud_rate_);
-        break;
-#endif
-      default:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        if (this->uart_ != UART_SELECTION_DEFAULT) {
-          ESP_LOGW(TAG, "  The chosen logger UART port is not available on this board."
-                        "The default port was used instead.");
-        }
-        break;
-    }
-
-    // change lt_log() port to match default Serial
-    if (this->uart_ == UART_SELECTION_DEFAULT) {
-      this->uart_ = (UARTSelection) (LT_UART_DEFAULT_SERIAL + 1);
-      lt_log_set_port(LT_UART_DEFAULT_SERIAL);
-    } else {
-      lt_log_set_port(this->uart_ - 1);
-    }
-  }
-
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_DEFAULT:
-      return LOG_STR("DEFAULT");
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-    case UART_SELECTION_UART2:
-    default:
-      return LOG_STR("UART2");
-  }
-}
-
-}  // namespace esphome::logger
-
-#endif  // USE_LIBRETINY

esphome/components/logger/logger_rp2040.cpp.bak

@@ -1,48 +0,0 @@
-#ifdef USE_RP2040
-#include "logger.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        break;
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial2;
-        Serial2.begin(this->baud_rate_);
-        break;
-      case UART_SELECTION_USB_CDC:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        break;
-    }
-  }
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-#ifdef USE_LOGGER_USB_CDC
-    case UART_SELECTION_USB_CDC:
-      return LOG_STR("USB_CDC");
-#endif
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-}  // namespace esphome::logger
-#endif  // USE_RP2040

esphome/components/logger/logger_zephyr.cpp.bak

@@ -1,96 +0,0 @@
-#ifdef USE_ZEPHYR
-
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-#include "logger.h"
-
-#include <zephyr/device.h>
-#include <zephyr/drivers/uart.h>
-#include <zephyr/usb/usb_device.h>
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-#ifdef USE_LOGGER_USB_CDC
-void Logger::loop() {
-  if (this->uart_ != UART_SELECTION_USB_CDC || nullptr == this->uart_dev_) {
-    return;
-  }
-  static bool opened = false;
-  uint32_t dtr = 0;
-  uart_line_ctrl_get(this->uart_dev_, UART_LINE_CTRL_DTR, &dtr);
-
-  /* Poll if the DTR flag was set, optional */
-  if (opened == dtr) {
-    return;
-  }
-
-  if (!opened) {
-    App.schedule_dump_config();
-  }
-  opened = !opened;
-}
-#endif
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    static const struct device *uart_dev = nullptr;
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(uart0));
-        break;
-      case UART_SELECTION_UART1:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(uart1));
-        break;
-#ifdef USE_LOGGER_USB_CDC
-      case UART_SELECTION_USB_CDC:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(cdc_acm_uart0));
-        if (device_is_ready(uart_dev)) {
-          usb_enable(nullptr);
-        }
-        break;
-#endif
-    }
-    if (!device_is_ready(uart_dev)) {
-      ESP_LOGE(TAG, "%s is not ready.", LOG_STR_ARG(get_uart_selection_()));
-    } else {
-      this->uart_dev_ = uart_dev;
-    }
-  }
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) {
-#ifdef CONFIG_PRINTK
-  printk("%s\n", msg);
-#endif
-  if (nullptr == this->uart_dev_) {
-    return;
-  }
-  while (*msg) {
-    uart_poll_out(this->uart_dev_, *msg);
-    ++msg;
-  }
-  uart_poll_out(this->uart_dev_, '\n');
-}
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-#ifdef USE_LOGGER_USB_CDC
-    case UART_SELECTION_USB_CDC:
-      return LOG_STR("USB_CDC");
-#endif
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-}  // namespace esphome::logger
-
-#endif

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

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

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;
     }

esphome/components/mqtt/mqtt_client.cpp

@@ -170,8 +170,10 @@ void MQTTClientComponent::send_device_info_() {
 void MQTTClientComponent::on_log(uint8_t level, const char *tag, const char *message, size_t message_len) {
   (void) tag;
   if (level <= this->log_level_ && this->is_connected()) {
-    this->publish(this->log_message_.topic.c_str(), message, message_len, this->log_message_.qos,
-                  this->log_message_.retain);
+    this->publish({.topic = this->log_message_.topic,
+                   .payload = std::string(message, message_len),
+                   .qos = this->log_message_.qos,
+                   .retain = this->log_message_.retain});
   }
 }
 #endif
@@ -540,8 +542,8 @@ bool MQTTClientComponent::publish(const char *topic, const char *payload, size_t
 }
 
 bool MQTTClientComponent::publish_json(const char *topic, const json::json_build_t &f, uint8_t qos, bool retain) {
-  auto message = json::build_json(f);
-  return this->publish(topic, message.c_str(), message.size(), qos, retain);
+  std::string message = json::build_json(f);
+  return this->publish(topic, message.c_str(), message.length(), qos, retain);
 }
 
 void MQTTClientComponent::enable() {

esphome/components/mqtt/mqtt_climate.cpp

@@ -300,11 +300,9 @@ const EntityBase *MQTTClimateComponent::get_entity() const { return this->device
 
 bool MQTTClimateComponent::publish_state_() {
   auto traits = this->device_->get_traits();
-  // Reusable stack buffer for topic construction (avoids heap allocation per publish)
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   // mode
   bool success = true;
-  if (!this->publish(this->get_mode_state_topic_to(topic_buf), climate_mode_to_mqtt_str(this->device_->mode)))
+  if (!this->publish(this->get_mode_state_topic(), climate_mode_to_mqtt_str(this->device_->mode)))
     success = false;
   int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
   int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
@@ -313,70 +311,68 @@ bool MQTTClimateComponent::publish_state_() {
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE) &&
       !std::isnan(this->device_->current_temperature)) {
     len = value_accuracy_to_buf(payload, this->device_->current_temperature, current_accuracy);
-    if (!this->publish(this->get_current_temperature_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_current_temperature_state_topic(), payload, len))
       success = false;
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                climate::CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
     len = value_accuracy_to_buf(payload, this->device_->target_temperature_low, target_accuracy);
-    if (!this->publish(this->get_target_temperature_low_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_temperature_low_state_topic(), payload, len))
       success = false;
     len = value_accuracy_to_buf(payload, this->device_->target_temperature_high, target_accuracy);
-    if (!this->publish(this->get_target_temperature_high_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_temperature_high_state_topic(), payload, len))
       success = false;
   } else {
     len = value_accuracy_to_buf(payload, this->device_->target_temperature, target_accuracy);
-    if (!this->publish(this->get_target_temperature_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_temperature_state_topic(), payload, len))
       success = false;
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY) &&
       !std::isnan(this->device_->current_humidity)) {
     len = value_accuracy_to_buf(payload, this->device_->current_humidity, 0);
-    if (!this->publish(this->get_current_humidity_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_current_humidity_state_topic(), payload, len))
       success = false;
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY) &&
       !std::isnan(this->device_->target_humidity)) {
     len = value_accuracy_to_buf(payload, this->device_->target_humidity, 0);
-    if (!this->publish(this->get_target_humidity_state_topic_to(topic_buf), payload, len))
+    if (!this->publish(this->get_target_humidity_state_topic(), payload, len))
       success = false;
   }
 
   if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
     if (this->device_->has_custom_preset()) {
-      if (!this->publish(this->get_preset_state_topic_to(topic_buf), this->device_->get_custom_preset().c_str()))
+      if (!this->publish(this->get_preset_state_topic(), this->device_->get_custom_preset()))
         success = false;
     } else if (this->device_->preset.has_value()) {
-      if (!this->publish(this->get_preset_state_topic_to(topic_buf),
-                         climate_preset_to_mqtt_str(this->device_->preset.value())))
+      if (!this->publish(this->get_preset_state_topic(), climate_preset_to_mqtt_str(this->device_->preset.value())))
         success = false;
-    } else if (!this->publish(this->get_preset_state_topic_to(topic_buf), "")) {
+    } else if (!this->publish(this->get_preset_state_topic(), "")) {
       success = false;
     }
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    if (!this->publish(this->get_action_state_topic_to(topic_buf), climate_action_to_mqtt_str(this->device_->action)))
+    if (!this->publish(this->get_action_state_topic(), climate_action_to_mqtt_str(this->device_->action)))
       success = false;
   }
 
   if (traits.get_supports_fan_modes()) {
     if (this->device_->has_custom_fan_mode()) {
-      if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf), this->device_->get_custom_fan_mode().c_str()))
+      if (!this->publish(this->get_fan_mode_state_topic(), this->device_->get_custom_fan_mode()))
         success = false;
     } else if (this->device_->fan_mode.has_value()) {
-      if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf),
+      if (!this->publish(this->get_fan_mode_state_topic(),
                          climate_fan_mode_to_mqtt_str(this->device_->fan_mode.value())))
         success = false;
-    } else if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf), "")) {
+    } else if (!this->publish(this->get_fan_mode_state_topic(), "")) {
       success = false;
     }
   }
 
   if (traits.get_supports_swing_modes()) {
-    if (!this->publish(this->get_swing_mode_state_topic_to(topic_buf),
-                       climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
+    if (!this->publish(this->get_swing_mode_state_topic(), climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
       success = false;
   }
 

esphome/components/mqtt/mqtt_component.h

@@ -59,11 +59,6 @@ void log_mqtt_component(const char *tag, MQTTComponent *obj, bool state_topic, b
 \
  public: \
   void set_custom_##name##_##type##_topic(const std::string &topic) { this->custom_##name##_##type##_topic_ = topic; } \
-  StringRef get_##name##_##type##_topic_to(std::span<char, MQTT_DEFAULT_TOPIC_MAX_LEN> buf) const { \
-    if (!this->custom_##name##_##type##_topic_.empty()) \
-      return StringRef(this->custom_##name##_##type##_topic_.data(), this->custom_##name##_##type##_topic_.size()); \
-    return this->get_default_topic_for_to_(buf, #name "/" #type, sizeof(#name "/" #type) - 1); \
-  } \
   std::string get_##name##_##type##_topic() const { \
     if (this->custom_##name##_##type##_topic_.empty()) \
       return this->get_default_topic_for_(#name "/" #type); \

esphome/components/mqtt/mqtt_cover.cpp

@@ -112,19 +112,19 @@ bool MQTTCoverComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTCoverComponent::publish_state() {
   auto traits = this->cover_->get_traits();
   bool success = true;
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (traits.get_supports_position()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
     size_t len = value_accuracy_to_buf(pos, roundf(this->cover_->position * 100), 0);
-    if (!this->publish(this->get_position_state_topic_to(topic_buf), pos, len))
+    if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
   if (traits.get_supports_tilt()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
     size_t len = value_accuracy_to_buf(pos, roundf(this->cover_->tilt * 100), 0);
-    if (!this->publish(this->get_tilt_state_topic_to(topic_buf), pos, len))
+    if (!this->publish(this->get_tilt_state_topic(), pos, len))
       success = false;
   }
+  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (!this->publish(this->get_state_topic_to_(topic_buf),
                      cover_state_to_mqtt_str(this->cover_->current_operation, this->cover_->position,
                                              traits.get_supports_position())))

esphome/components/mqtt/mqtt_fan.cpp

@@ -173,20 +173,19 @@ bool MQTTFanComponent::publish_state() {
   this->publish(this->get_state_topic_to_(topic_buf), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
-    bool success = this->publish(this->get_direction_state_topic_to(topic_buf),
-                                 fan_direction_to_mqtt_str(this->state_->direction));
+    bool success = this->publish(this->get_direction_state_topic(), fan_direction_to_mqtt_str(this->state_->direction));
     failed = failed || !success;
   }
   if (this->state_->get_traits().supports_oscillation()) {
-    bool success = this->publish(this->get_oscillation_state_topic_to(topic_buf),
-                                 fan_oscillation_to_mqtt_str(this->state_->oscillating));
+    bool success =
+        this->publish(this->get_oscillation_state_topic(), fan_oscillation_to_mqtt_str(this->state_->oscillating));
     failed = failed || !success;
   }
   auto traits = this->state_->get_traits();
   if (traits.supports_speed()) {
     char buf[12];
     size_t len = buf_append_printf(buf, sizeof(buf), 0, "%d", this->state_->speed);
-    bool success = this->publish(this->get_speed_level_state_topic_to(topic_buf), buf, len);
+    bool success = this->publish(this->get_speed_level_state_topic(), buf, len);
     failed = failed || !success;
   }
   return !failed;

esphome/components/mqtt/mqtt_valve.cpp

@@ -87,13 +87,13 @@ bool MQTTValveComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTValveComponent::publish_state() {
   auto traits = this->valve_->get_traits();
   bool success = true;
-  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (traits.get_supports_position()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
     size_t len = value_accuracy_to_buf(pos, roundf(this->valve_->position * 100), 0);
-    if (!this->publish(this->get_position_state_topic_to(topic_buf), pos, len))
+    if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
+  char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
   if (!this->publish(this->get_state_topic_to_(topic_buf),
                      valve_state_to_mqtt_str(this->valve_->current_operation, this->valve_->position,
                                              traits.get_supports_position())))

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,23 +56,17 @@ void PylontechComponent::setup() {
 void PylontechComponent::update() { this->write_str("pwr\n"); }
 
 void PylontechComponent::loop() {
-  size_t avail = this->available();
-  if (avail > 0) {
+  if (this->available() > 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
+    uint8_t data;
     int recv = 0;
-    uint8_t buf[64];
-    while (avail > 0) {
-      size_t to_read = std::min(avail, sizeof(buf));
-      if (!this->read_array(buf, to_read)) {
-        break;
-      }
-      avail -= to_read;
-      recv += to_read;
-
-      for (size_t i = 0; i < to_read; i++) {
-        buffer_[buffer_index_write_] += (char) buf[i];
-        if (buf[i] == ASCII_LF || buffer_[buffer_index_write_].length() >= MAX_DATA_LENGTH_BYTES) {
+    while (this->available() > 0) {
+      if (this->read_byte(&data)) {
+        buffer_[buffer_index_write_] += (char) data;
+        recv++;
+        if (buffer_[buffer_index_write_].back() == static_cast<char>(ASCII_LF) ||
+            buffer_[buffer_index_write_].length() >= MAX_DATA_LENGTH_BYTES) {
           // complete line received
           buffer_index_write_ = (buffer_index_write_ + 1) % NUM_BUFFERS;
         }

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/rtl87xx/boards.py

@@ -71,10 +71,6 @@ RTL87XX_BOARDS = {
         "name": "WR3L Wi-Fi Module",
         "family": FAMILY_RTL8710B,
     },
-    "wbru": {
-        "name": "WBRU Wi-Fi Module",
-        "family": FAMILY_RTL8720C,
-    },
     "wr2le": {
         "name": "WR2LE Wi-Fi Module",
         "family": FAMILY_RTL8710B,
@@ -87,14 +83,6 @@ RTL87XX_BOARDS = {
         "name": "T103_V1.0",
         "family": FAMILY_RTL8710B,
     },
-    "cr3l": {
-        "name": "CR3L Wi-Fi Module",
-        "family": FAMILY_RTL8720C,
-    },
-    "generic-rtl8720cm-4mb-1712k": {
-        "name": "Generic - RTL8720CM (4M/1712k)",
-        "family": FAMILY_RTL8720C,
-    },
     "generic-rtl8720cf-2mb-896k": {
         "name": "Generic - RTL8720CF (2M/896k)",
         "family": FAMILY_RTL8720C,
@@ -115,10 +103,6 @@ RTL87XX_BOARDS = {
         "name": "WR2L Wi-Fi Module",
         "family": FAMILY_RTL8710B,
     },
-    "wbr1": {
-        "name": "WBR1 Wi-Fi Module",
-        "family": FAMILY_RTL8720C,
-    },
     "wr1": {
         "name": "WR1 Wi-Fi Module",
         "family": FAMILY_RTL8710B,
@@ -135,10 +119,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 22,
-        "WIRE0_SCL_1": 29,
-        "WIRE0_SDA_0": 19,
-        "WIRE0_SDA_1": 30,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
+        "WIRE0_SDA_0": 30,
+        "WIRE0_SDA_1": 19,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,
@@ -246,10 +230,10 @@ RTL87XX_BOARD_PINS = {
         "A1": 41,
     },
     "wbr3": {
-        "WIRE0_SCL_0": 2,
-        "WIRE0_SCL_1": 11,
-        "WIRE0_SCL_2": 15,
-        "WIRE0_SCL_3": 19,
+        "WIRE0_SCL_0": 11,
+        "WIRE0_SCL_1": 2,
+        "WIRE0_SCL_2": 19,
+        "WIRE0_SCL_3": 15,
         "WIRE0_SDA_0": 3,
         "WIRE0_SDA_1": 12,
         "WIRE0_SDA_2": 16,
@@ -258,10 +242,10 @@ RTL87XX_BOARD_PINS = {
         "SERIAL0_TX_0": 11,
         "SERIAL0_TX_1": 14,
         "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 0,
-        "SERIAL1_RX_1": 2,
-        "SERIAL1_TX_0": 1,
-        "SERIAL1_TX_1": 3,
+        "SERIAL1_RX_0": 2,
+        "SERIAL1_RX_1": 0,
+        "SERIAL1_TX_0": 3,
+        "SERIAL1_TX_1": 1,
         "SERIAL2_CTS": 19,
         "SERIAL2_RX": 15,
         "SERIAL2_TX": 16,
@@ -312,12 +296,6 @@ RTL87XX_BOARD_PINS = {
     },
     "generic-rtl8710bn-2mb-468k": {
         "SPI0_CS": 19,
-        "SPI0_FCS": 6,
-        "SPI0_FD0": 9,
-        "SPI0_FD1": 7,
-        "SPI0_FD2": 8,
-        "SPI0_FD3": 11,
-        "SPI0_FSCK": 10,
         "SPI0_MISO": 22,
         "SPI0_MOSI": 23,
         "SPI0_SCK": 18,
@@ -418,10 +396,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 22,
-        "WIRE0_SCL_1": 29,
-        "WIRE0_SDA_0": 19,
-        "WIRE0_SDA_1": 30,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
+        "WIRE0_SDA_0": 30,
+        "WIRE0_SDA_1": 19,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,
@@ -485,10 +463,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 22,
-        "WIRE0_SCL_1": 29,
-        "WIRE0_SDA_0": 19,
-        "WIRE0_SDA_1": 30,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
+        "WIRE0_SDA_0": 30,
+        "WIRE0_SDA_1": 19,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,
@@ -736,12 +714,6 @@ RTL87XX_BOARD_PINS = {
     },
     "generic-rtl8710bn-2mb-788k": {
         "SPI0_CS": 19,
-        "SPI0_FCS": 6,
-        "SPI0_FD0": 9,
-        "SPI0_FD1": 7,
-        "SPI0_FD2": 8,
-        "SPI0_FD3": 11,
-        "SPI0_FSCK": 10,
         "SPI0_MISO": 22,
         "SPI0_MOSI": 23,
         "SPI0_SCK": 18,
@@ -835,12 +807,6 @@ RTL87XX_BOARD_PINS = {
     },
     "generic-rtl8710bx-4mb-980k": {
         "SPI0_CS": 19,
-        "SPI0_FCS": 6,
-        "SPI0_FD0": 9,
-        "SPI0_FD1": 7,
-        "SPI0_FD2": 8,
-        "SPI0_FD3": 11,
-        "SPI0_FSCK": 10,
         "SPI0_MISO": 22,
         "SPI0_MOSI": 23,
         "SPI0_SCK": 18,
@@ -991,8 +957,8 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 22,
-        "WIRE0_SCL_1": 29,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
         "WIRE0_SDA_0": 19,
         "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
@@ -1122,99 +1088,6 @@ RTL87XX_BOARD_PINS = {
         "A0": 19,
         "A1": 41,
     },
-    "wbru": {
-        "SPI0_CS_0": 2,
-        "SPI0_CS_1": 7,
-        "SPI0_CS_2": 15,
-        "SPI0_MISO_0": 10,
-        "SPI0_MISO_1": 20,
-        "SPI0_MOSI_0": 4,
-        "SPI0_MOSI_1": 9,
-        "SPI0_MOSI_2": 19,
-        "SPI0_SCK_0": 3,
-        "SPI0_SCK_1": 8,
-        "SPI0_SCK_2": 16,
-        "WIRE0_SCL_0": 2,
-        "WIRE0_SCL_1": 11,
-        "WIRE0_SCL_2": 15,
-        "WIRE0_SCL_3": 19,
-        "WIRE0_SDA_0": 3,
-        "WIRE0_SDA_1": 12,
-        "WIRE0_SDA_2": 16,
-        "WIRE0_SDA_3": 20,
-        "SERIAL0_CTS": 10,
-        "SERIAL0_RTS": 9,
-        "SERIAL0_RX_0": 12,
-        "SERIAL0_RX_1": 13,
-        "SERIAL0_TX_0": 11,
-        "SERIAL0_TX_1": 14,
-        "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 0,
-        "SERIAL1_RX_1": 2,
-        "SERIAL1_TX": 3,
-        "SERIAL2_CTS": 19,
-        "SERIAL2_RTS": 20,
-        "SERIAL2_RX": 15,
-        "SERIAL2_TX": 16,
-        "CS0": 7,
-        "CTS0": 10,
-        "CTS1": 4,
-        "CTS2": 19,
-        "MOSI0": 19,
-        "PA00": 0,
-        "PA0": 0,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA07": 7,
-        "PA7": 7,
-        "PA08": 8,
-        "PA8": 8,
-        "PA09": 9,
-        "PA9": 9,
-        "PA10": 10,
-        "PA11": 11,
-        "PA12": 12,
-        "PA13": 13,
-        "PA14": 14,
-        "PA15": 15,
-        "PA16": 16,
-        "PA17": 17,
-        "PA18": 18,
-        "PA19": 19,
-        "PA20": 20,
-        "PWM0": 0,
-        "PWM1": 12,
-        "PWM5": 17,
-        "PWM6": 18,
-        "RTS0": 9,
-        "RTS2": 20,
-        "RX2": 15,
-        "SCK0": 16,
-        "TX1": 3,
-        "TX2": 16,
-        "D0": 8,
-        "D1": 9,
-        "D2": 2,
-        "D3": 3,
-        "D4": 4,
-        "D5": 15,
-        "D6": 16,
-        "D7": 11,
-        "D8": 12,
-        "D9": 17,
-        "D10": 18,
-        "D11": 19,
-        "D12": 14,
-        "D13": 13,
-        "D14": 20,
-        "D15": 0,
-        "D16": 10,
-        "D17": 7,
-    },
     "wr2le": {
         "MISO0": 22,
         "MISO1": 22,
@@ -1243,21 +1116,21 @@ RTL87XX_BOARD_PINS = {
         "SPI0_MISO": 20,
         "SPI0_MOSI_0": 4,
         "SPI0_MOSI_1": 19,
-        "SPI0_SCK_0": 3,
-        "SPI0_SCK_1": 16,
+        "SPI0_SCK_0": 16,
+        "SPI0_SCK_1": 3,
         "WIRE0_SCL_0": 2,
         "WIRE0_SCL_1": 15,
         "WIRE0_SCL_2": 19,
-        "WIRE0_SDA_0": 3,
+        "WIRE0_SDA_0": 20,
         "WIRE0_SDA_1": 16,
-        "WIRE0_SDA_2": 20,
+        "WIRE0_SDA_2": 3,
         "SERIAL0_RX": 13,
         "SERIAL0_TX": 14,
         "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 0,
-        "SERIAL1_RX_1": 2,
-        "SERIAL1_TX_0": 1,
-        "SERIAL1_TX_1": 3,
+        "SERIAL1_RX_0": 2,
+        "SERIAL1_RX_1": 0,
+        "SERIAL1_TX_0": 3,
+        "SERIAL1_TX_1": 1,
         "SERIAL2_CTS": 19,
         "SERIAL2_RTS": 20,
         "SERIAL2_RX": 15,
@@ -1378,168 +1251,6 @@ RTL87XX_BOARD_PINS = {
         "A0": 19,
         "A1": 41,
     },
-    "cr3l": {
-        "SPI0_CS_0": 2,
-        "SPI0_CS_1": 15,
-        "SPI0_MISO": 20,
-        "SPI0_MOSI_0": 4,
-        "SPI0_MOSI_1": 19,
-        "SPI0_SCK_0": 3,
-        "SPI0_SCK_1": 16,
-        "WIRE0_SCL_0": 2,
-        "WIRE0_SCL_1": 15,
-        "WIRE0_SCL_2": 19,
-        "WIRE0_SDA_0": 3,
-        "WIRE0_SDA_1": 16,
-        "WIRE0_SDA_2": 20,
-        "SERIAL0_RX": 13,
-        "SERIAL0_TX": 14,
-        "SERIAL1_CTS": 4,
-        "SERIAL1_RX": 2,
-        "SERIAL1_TX": 3,
-        "SERIAL2_CTS": 19,
-        "SERIAL2_RTS": 20,
-        "SERIAL2_RX": 15,
-        "SERIAL2_TX": 16,
-        "CTS1": 4,
-        "CTS2": 19,
-        "MISO0": 20,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA13": 13,
-        "PA14": 14,
-        "PA15": 15,
-        "PA16": 16,
-        "PA17": 17,
-        "PA18": 18,
-        "PA19": 19,
-        "PA20": 20,
-        "PWM0": 20,
-        "PWM5": 17,
-        "PWM6": 18,
-        "RTS2": 20,
-        "RX0": 13,
-        "RX1": 2,
-        "RX2": 15,
-        "SCL0": 19,
-        "SDA0": 16,
-        "TX0": 14,
-        "TX1": 3,
-        "TX2": 16,
-        "D0": 20,
-        "D1": 2,
-        "D2": 3,
-        "D3": 4,
-        "D4": 15,
-        "D5": 16,
-        "D6": 17,
-        "D7": 18,
-        "D8": 19,
-        "D9": 13,
-        "D10": 14,
-    },
-    "generic-rtl8720cm-4mb-1712k": {
-        "SPI0_CS_0": 2,
-        "SPI0_CS_1": 7,
-        "SPI0_CS_2": 15,
-        "SPI0_MISO_0": 10,
-        "SPI0_MISO_1": 20,
-        "SPI0_MOSI_0": 4,
-        "SPI0_MOSI_1": 9,
-        "SPI0_MOSI_2": 19,
-        "SPI0_SCK_0": 3,
-        "SPI0_SCK_1": 8,
-        "SPI0_SCK_2": 16,
-        "WIRE0_SCL_0": 2,
-        "WIRE0_SCL_1": 11,
-        "WIRE0_SCL_2": 15,
-        "WIRE0_SCL_3": 19,
-        "WIRE0_SDA_0": 3,
-        "WIRE0_SDA_1": 12,
-        "WIRE0_SDA_2": 16,
-        "WIRE0_SDA_3": 20,
-        "SERIAL0_CTS": 10,
-        "SERIAL0_RTS": 9,
-        "SERIAL0_RX_0": 12,
-        "SERIAL0_RX_1": 13,
-        "SERIAL0_TX_0": 11,
-        "SERIAL0_TX_1": 14,
-        "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 0,
-        "SERIAL1_RX_1": 2,
-        "SERIAL1_TX_0": 1,
-        "SERIAL1_TX_1": 3,
-        "SERIAL2_CTS": 19,
-        "SERIAL2_RTS": 20,
-        "SERIAL2_RX": 15,
-        "SERIAL2_TX": 16,
-        "CS0": 15,
-        "CTS0": 10,
-        "CTS1": 4,
-        "CTS2": 19,
-        "MOSI0": 19,
-        "PA00": 0,
-        "PA0": 0,
-        "PA01": 1,
-        "PA1": 1,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA07": 7,
-        "PA7": 7,
-        "PA08": 8,
-        "PA8": 8,
-        "PA09": 9,
-        "PA9": 9,
-        "PA10": 10,
-        "PA11": 11,
-        "PA12": 12,
-        "PA13": 13,
-        "PA14": 14,
-        "PA15": 15,
-        "PA16": 16,
-        "PA17": 17,
-        "PA18": 18,
-        "PA19": 19,
-        "PA20": 20,
-        "PA23": 23,
-        "PWM0": 20,
-        "PWM5": 17,
-        "PWM6": 18,
-        "PWM7": 23,
-        "RTS0": 9,
-        "RTS2": 20,
-        "RX2": 15,
-        "SCK0": 16,
-        "TX2": 16,
-        "D0": 0,
-        "D1": 1,
-        "D2": 2,
-        "D3": 3,
-        "D4": 4,
-        "D5": 7,
-        "D6": 8,
-        "D7": 9,
-        "D8": 10,
-        "D9": 11,
-        "D10": 12,
-        "D11": 13,
-        "D12": 14,
-        "D13": 15,
-        "D14": 16,
-        "D15": 17,
-        "D16": 18,
-        "D17": 19,
-        "D18": 20,
-        "D19": 23,
-    },
     "generic-rtl8720cf-2mb-896k": {
         "SPI0_CS_0": 2,
         "SPI0_CS_1": 7,
@@ -1745,8 +1456,8 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 22,
-        "WIRE0_SCL_1": 29,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
         "WIRE0_SDA_0": 19,
         "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
@@ -1874,65 +1585,6 @@ RTL87XX_BOARD_PINS = {
         "D4": 12,
         "A0": 19,
     },
-    "wbr1": {
-        "WIRE0_SCL_0": 2,
-        "WIRE0_SCL_1": 11,
-        "WIRE0_SCL_2": 15,
-        "WIRE0_SDA_0": 3,
-        "WIRE0_SDA_1": 12,
-        "WIRE0_SDA_2": 16,
-        "SERIAL0_RX_0": 12,
-        "SERIAL0_RX_1": 13,
-        "SERIAL0_TX_0": 11,
-        "SERIAL0_TX_1": 14,
-        "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 0,
-        "SERIAL1_RX_1": 2,
-        "SERIAL1_TX_0": 1,
-        "SERIAL1_TX_1": 3,
-        "SERIAL2_RX": 15,
-        "SERIAL2_TX": 16,
-        "CTS1": 4,
-        "MOSI0": 4,
-        "PA00": 0,
-        "PA0": 0,
-        "PA01": 1,
-        "PA1": 1,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA11": 11,
-        "PA12": 12,
-        "PA13": 13,
-        "PA14": 14,
-        "PA15": 15,
-        "PA16": 16,
-        "PA17": 17,
-        "PA18": 18,
-        "PWM5": 17,
-        "PWM6": 18,
-        "PWM7": 13,
-        "RX2": 15,
-        "SCL0": 15,
-        "SDA0": 12,
-        "TX2": 16,
-        "D0": 14,
-        "D1": 13,
-        "D2": 2,
-        "D3": 3,
-        "D4": 16,
-        "D5": 4,
-        "D6": 11,
-        "D7": 15,
-        "D8": 12,
-        "D9": 17,
-        "D10": 18,
-        "D11": 0,
-        "D12": 1,
-    },
     "wr1": {
         "SPI0_CS": 19,
         "SPI0_MISO": 22,
@@ -1942,10 +1594,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 22,
-        "WIRE0_SCL_1": 29,
-        "WIRE0_SDA_0": 19,
-        "WIRE0_SDA_1": 30,
+        "WIRE0_SCL_0": 29,
+        "WIRE0_SCL_1": 22,
+        "WIRE0_SDA_0": 30,
+        "WIRE0_SDA_1": 19,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,

esphome/components/rtttl/rtttl.cpp

@@ -2,7 +2,6 @@
 #include <cmath>
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome {
 namespace rtttl {
@@ -376,13 +375,22 @@ void Rtttl::loop() {
 }
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-// RTTTL state strings indexed by State enum (0-4): STOPPED, INIT, STARTING, RUNNING, STOPPING
-PROGMEM_STRING_TABLE(RtttlStateStrings, "STATE_STOPPED", "STATE_INIT", "STATE_STARTING", "STATE_RUNNING",
-                     "STATE_STOPPING", "UNKNOWN");
-
 static const LogString *state_to_string(State state) {
-  return RtttlStateStrings::get_log_str(static_cast<uint8_t>(state), RtttlStateStrings::LAST_INDEX);
-}
+  switch (state) {
+    case STATE_STOPPED:
+      return LOG_STR("STATE_STOPPED");
+    case STATE_STARTING:
+      return LOG_STR("STATE_STARTING");
+    case STATE_RUNNING:
+      return LOG_STR("STATE_RUNNING");
+    case STATE_STOPPING:
+      return LOG_STR("STATE_STOPPING");
+    case STATE_INIT:
+      return LOG_STR("STATE_INIT");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+};
 #endif
 
 void Rtttl::set_state_(State state) {

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/select/select.h

@@ -78,21 +78,23 @@ class Select : public EntityBase {
 
   void add_on_state_callback(std::function<void(size_t)> &&callback);
 
-  /** Set the value of the select by index, this is an optional virtual method.
-   *
-   * This method is called by the SelectCall when the index is already known.
-   * Default implementation converts to string and calls control().
-   * Override this to work directly with indices and avoid string conversions.
-   *
-   * @param index The index as validated by the SelectCall.
-   */
-  virtual void control(size_t index) { this->control(this->option_at(index)); }
-
  protected:
   friend class SelectCall;
 
   size_t active_index_{0};
 
+  /** Set the value of the select by index, this is an optional virtual method.
+   *
+   * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.
+   * Overriding this index-based version is PREFERRED as it avoids string conversions.
+   *
+   * This method is called by the SelectCall when the index is already known.
+   * Default implementation converts to string and calls control(const std::string&).
+   *
+   * @param index The index as validated by the SelectCall.
+   */
+  virtual void control(size_t index) { this->control(this->option_at(index)); }
+
   /** Set the value of the select, this is a virtual method that each select integration can implement.
    *
    * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.

esphome/components/speed/fan/__init__.py

@@ -25,7 +25,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_SPEED): cv.invalid(
                 "Configuring individual speeds is deprecated."
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
     )

esphome/components/speed/fan/speed_fan.h

@@ -10,7 +10,7 @@ namespace speed {
 
 class SpeedFan : public Component, public fan::Fan {
  public:
-  SpeedFan(uint8_t speed_count) : speed_count_(speed_count) {}
+  SpeedFan(int speed_count) : speed_count_(speed_count) {}
   void setup() override;
   void dump_config() override;
   void set_output(output::FloatOutput *output) { this->output_ = output; }
@@ -26,7 +26,7 @@ class SpeedFan : public Component, public fan::Fan {
   output::FloatOutput *output_;
   output::BinaryOutput *oscillating_{nullptr};
   output::BinaryOutput *direction_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};
 };

esphome/components/sprinkler/sprinkler.cpp

@@ -4,7 +4,6 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include <cinttypes>
 #include <utility>
 
@@ -1545,19 +1544,42 @@ void Sprinkler::log_multiplier_zero_warning_(const LogString *method_name) {
   ESP_LOGW(TAG, "%s called but multiplier is set to zero; no action taken", LOG_STR_ARG(method_name));
 }
 
-// Request origin strings indexed by SprinklerValveRunRequestOrigin enum (0-2): USER, CYCLE, QUEUE
-PROGMEM_STRING_TABLE(SprinklerRequestOriginStrings, "USER", "CYCLE", "QUEUE", "UNKNOWN");
-
 const LogString *Sprinkler::req_as_str_(SprinklerValveRunRequestOrigin origin) {
-  return SprinklerRequestOriginStrings::get_log_str(static_cast<uint8_t>(origin),
-                                                    SprinklerRequestOriginStrings::LAST_INDEX);
+  switch (origin) {
+    case USER:
+      return LOG_STR("USER");
+
+    case CYCLE:
+      return LOG_STR("CYCLE");
+
+    case QUEUE:
+      return LOG_STR("QUEUE");
+
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
-// Sprinkler state strings indexed by SprinklerState enum (0-4): IDLE, STARTING, ACTIVE, STOPPING, BYPASS
-PROGMEM_STRING_TABLE(SprinklerStateStrings, "IDLE", "STARTING", "ACTIVE", "STOPPING", "BYPASS", "UNKNOWN");
-
 const LogString *Sprinkler::state_as_str_(SprinklerState state) {
-  return SprinklerStateStrings::get_log_str(static_cast<uint8_t>(state), SprinklerStateStrings::LAST_INDEX);
+  switch (state) {
+    case IDLE:
+      return LOG_STR("IDLE");
+
+    case STARTING:
+      return LOG_STR("STARTING");
+
+    case ACTIVE:
+      return LOG_STR("ACTIVE");
+
+    case STOPPING:
+      return LOG_STR("STOPPING");
+
+    case BYPASS:
+      return LOG_STR("BYPASS");
+
+    default:
+      return LOG_STR("UNKNOWN");
+  }
 }
 
 void Sprinkler::start_timer_(const SprinklerTimerIndex timer_index) {

esphome/components/ssd1306_base/ssd1306_base.cpp

@@ -1,7 +1,6 @@
 #include "ssd1306_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 
 namespace esphome {
 namespace ssd1306_base {
@@ -41,55 +40,6 @@ static const uint8_t SSD1305_COMMAND_SET_AREA_COLOR = 0xD8;
 static const uint8_t SH1107_COMMAND_SET_START_LINE = 0xDC;
 static const uint8_t SH1107_COMMAND_CHARGE_PUMP = 0xAD;
 
-// Verify first enum value and table sizes match SSD1306_MODEL_COUNT
-static_assert(SSD1306_MODEL_128_32 == 0, "SSD1306Model enum must start at 0");
-
-// PROGMEM lookup table indexed by SSD1306Model enum (width, height per model)
-struct ModelDimensions {
-  uint8_t width;
-  uint8_t height;
-};
-static const ModelDimensions MODEL_DIMS[] PROGMEM = {
-    {128, 32},   // SSD1306_MODEL_128_32
-    {128, 64},   // SSD1306_MODEL_128_64
-    {96, 16},    // SSD1306_MODEL_96_16
-    {64, 48},    // SSD1306_MODEL_64_48
-    {64, 32},    // SSD1306_MODEL_64_32
-    {72, 40},    // SSD1306_MODEL_72_40
-    {128, 32},   // SH1106_MODEL_128_32
-    {128, 64},   // SH1106_MODEL_128_64
-    {96, 16},    // SH1106_MODEL_96_16
-    {64, 48},    // SH1106_MODEL_64_48
-    {64, 128},   // SH1107_MODEL_128_64 (note: width is 64, height is 128)
-    {128, 128},  // SH1107_MODEL_128_128
-    {128, 32},   // SSD1305_MODEL_128_32
-    {128, 64},   // SSD1305_MODEL_128_64
-};
-
-// clang-format off
-PROGMEM_STRING_TABLE(ModelStrings,
-    "SSD1306 128x32",  // SSD1306_MODEL_128_32
-    "SSD1306 128x64",  // SSD1306_MODEL_128_64
-    "SSD1306 96x16",   // SSD1306_MODEL_96_16
-    "SSD1306 64x48",   // SSD1306_MODEL_64_48
-    "SSD1306 64x32",   // SSD1306_MODEL_64_32
-    "SSD1306 72x40",   // SSD1306_MODEL_72_40
-    "SH1106 128x32",   // SH1106_MODEL_128_32
-    "SH1106 128x64",   // SH1106_MODEL_128_64
-    "SH1106 96x16",    // SH1106_MODEL_96_16
-    "SH1106 64x48",    // SH1106_MODEL_64_48
-    "SH1107 128x64",   // SH1107_MODEL_128_64
-    "SH1107 128x128",  // SH1107_MODEL_128_128
-    "SSD1305 128x32",  // SSD1305_MODEL_128_32
-    "SSD1305 128x64",  // SSD1305_MODEL_128_64
-    "Unknown"          // fallback
-);
-// clang-format on
-static_assert(sizeof(MODEL_DIMS) / sizeof(MODEL_DIMS[0]) == SSD1306_MODEL_COUNT,
-              "MODEL_DIMS must have one entry per SSD1306Model");
-static_assert(ModelStrings::COUNT == SSD1306_MODEL_COUNT + 1,
-              "ModelStrings must have one entry per SSD1306Model plus fallback");
-
 void SSD1306::setup() {
   this->init_internal_(this->get_buffer_length_());
 
@@ -324,14 +274,54 @@ void SSD1306::turn_off() {
   this->is_on_ = false;
 }
 int SSD1306::get_height_internal() {
-  if (this->model_ >= SSD1306_MODEL_COUNT)
-    return 0;
-  return progmem_read_byte(&MODEL_DIMS[this->model_].height);
+  switch (this->model_) {
+    case SH1107_MODEL_128_64:
+    case SH1107_MODEL_128_128:
+      return 128;
+    case SSD1306_MODEL_128_32:
+    case SSD1306_MODEL_64_32:
+    case SH1106_MODEL_128_32:
+    case SSD1305_MODEL_128_32:
+      return 32;
+    case SSD1306_MODEL_128_64:
+    case SH1106_MODEL_128_64:
+    case SSD1305_MODEL_128_64:
+      return 64;
+    case SSD1306_MODEL_96_16:
+    case SH1106_MODEL_96_16:
+      return 16;
+    case SSD1306_MODEL_64_48:
+    case SH1106_MODEL_64_48:
+      return 48;
+    case SSD1306_MODEL_72_40:
+      return 40;
+    default:
+      return 0;
+  }
 }
 int SSD1306::get_width_internal() {
-  if (this->model_ >= SSD1306_MODEL_COUNT)
-    return 0;
-  return progmem_read_byte(&MODEL_DIMS[this->model_].width);
+  switch (this->model_) {
+    case SSD1306_MODEL_128_32:
+    case SH1106_MODEL_128_32:
+    case SSD1306_MODEL_128_64:
+    case SH1106_MODEL_128_64:
+    case SSD1305_MODEL_128_32:
+    case SSD1305_MODEL_128_64:
+    case SH1107_MODEL_128_128:
+      return 128;
+    case SSD1306_MODEL_96_16:
+    case SH1106_MODEL_96_16:
+      return 96;
+    case SSD1306_MODEL_64_48:
+    case SSD1306_MODEL_64_32:
+    case SH1106_MODEL_64_48:
+    case SH1107_MODEL_128_64:
+      return 64;
+    case SSD1306_MODEL_72_40:
+      return 72;
+    default:
+      return 0;
+  }
 }
 size_t SSD1306::get_buffer_length_() {
   return size_t(this->get_width_internal()) * size_t(this->get_height_internal()) / 8u;
@@ -371,8 +361,37 @@ void SSD1306::init_reset_() {
     this->reset_pin_->digital_write(true);
   }
 }
-const LogString *SSD1306::model_str_() {
-  return ModelStrings::get_log_str(static_cast<uint8_t>(this->model_), ModelStrings::LAST_INDEX);
+const char *SSD1306::model_str_() {
+  switch (this->model_) {
+    case SSD1306_MODEL_128_32:
+      return "SSD1306 128x32";
+    case SSD1306_MODEL_128_64:
+      return "SSD1306 128x64";
+    case SSD1306_MODEL_64_32:
+      return "SSD1306 64x32";
+    case SSD1306_MODEL_96_16:
+      return "SSD1306 96x16";
+    case SSD1306_MODEL_64_48:
+      return "SSD1306 64x48";
+    case SSD1306_MODEL_72_40:
+      return "SSD1306 72x40";
+    case SH1106_MODEL_128_32:
+      return "SH1106 128x32";
+    case SH1106_MODEL_128_64:
+      return "SH1106 128x64";
+    case SH1106_MODEL_96_16:
+      return "SH1106 96x16";
+    case SH1106_MODEL_64_48:
+      return "SH1106 64x48";
+    case SH1107_MODEL_128_64:
+      return "SH1107 128x64";
+    case SSD1305_MODEL_128_32:
+      return "SSD1305 128x32";
+    case SSD1305_MODEL_128_64:
+      return "SSD1305 128x64";
+    default:
+      return "Unknown";
+  }
 }
 
 }  // namespace ssd1306_base

esphome/components/ssd1306_base/ssd1306_base.h

@@ -22,9 +22,6 @@ enum SSD1306Model {
   SH1107_MODEL_128_128,
   SSD1305_MODEL_128_32,
   SSD1305_MODEL_128_64,
-  // When adding a new model, add it before SSD1306_MODEL_COUNT and update
-  // MODEL_DIMS and ModelStrings tables in ssd1306_base.cpp
-  SSD1306_MODEL_COUNT,  // must be last
 };
 
 class SSD1306 : public display::DisplayBuffer {
@@ -73,7 +70,7 @@ class SSD1306 : public display::DisplayBuffer {
   int get_height_internal() override;
   int get_width_internal() override;
   size_t get_buffer_length_();
-  const LogString *model_str_();
+  const char *model_str_();
 
   SSD1306Model model_{SSD1306_MODEL_128_64};
   GPIOPin *reset_pin_{nullptr};

esphome/components/ssd1306_i2c/ssd1306_i2c.cpp

@@ -28,7 +28,7 @@ void I2CSSD1306::dump_config() {
                 "  Offset X: %d\n"
                 "  Offset Y: %d\n"
                 "  Inverted Color: %s",
-                LOG_STR_ARG(this->model_str_()), YESNO(this->external_vcc_), YESNO(this->flip_x_), YESNO(this->flip_y_),
+                this->model_str_(), YESNO(this->external_vcc_), YESNO(this->flip_x_), YESNO(this->flip_y_),
                 this->offset_x_, this->offset_y_, YESNO(this->invert_));
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);

esphome/components/ssd1306_spi/ssd1306_spi.cpp

@@ -24,7 +24,7 @@ void SPISSD1306::dump_config() {
                 "  Offset X: %d\n"
                 "  Offset Y: %d\n"
                 "  Inverted Color: %s",
-                LOG_STR_ARG(this->model_str_()), YESNO(this->external_vcc_), YESNO(this->flip_x_), YESNO(this->flip_y_),
+                this->model_str_(), YESNO(this->external_vcc_), YESNO(this->flip_x_), YESNO(this->flip_y_),
                 this->offset_x_, this->offset_y_, YESNO(this->invert_));
   LOG_PIN("  CS Pin: ", this->cs_);
   LOG_PIN("  DC Pin: ", this->dc_pin_);

esphome/components/template/fan/__init__.py

@@ -19,7 +19,7 @@ CONFIG_SCHEMA = (
         {
             cv.Optional(CONF_HAS_DIRECTION, default=False): cv.boolean,
             cv.Optional(CONF_HAS_OSCILLATING, default=False): cv.boolean,
-            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
     )

esphome/components/template/fan/template_fan.h

@@ -12,7 +12,7 @@ class TemplateFan final : public Component, public fan::Fan {
   void dump_config() override;
   void set_has_direction(bool has_direction) { this->has_direction_ = has_direction; }
   void set_has_oscillating(bool has_oscillating) { this->has_oscillating_ = has_oscillating; }
-  void set_speed_count(uint8_t count) { this->speed_count_ = count; }
+  void set_speed_count(int count) { this->speed_count_ = count; }
   void set_preset_modes(std::initializer_list<const char *> presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
@@ -21,7 +21,7 @@ class TemplateFan final : public Component, public fan::Fan {
 
   bool has_oscillating_{false};
   bool has_direction_{false};
-  uint8_t speed_count_{0};
+  int speed_count_{0};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};
 };

esphome/components/time/posix_tz.cpp

@@ -1,481 +0,0 @@
-#include "esphome/core/defines.h"
-
-#ifdef USE_TIME_TIMEZONE
-
-#include "posix_tz.h"
-#include <cctype>
-
-namespace esphome::time {
-
-// Global timezone - set once at startup, rarely changes
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - intentional mutable state
-static ParsedTimezone global_tz_{};
-
-void set_global_tz(const ParsedTimezone &tz) { global_tz_ = tz; }
-
-const ParsedTimezone &get_global_tz() { return global_tz_; }
-
-namespace internal {
-
-// Helper to parse an unsigned integer from string, updating pointer
-static uint32_t parse_uint(const char *&p) {
-  uint32_t value = 0;
-  while (std::isdigit(static_cast<unsigned char>(*p))) {
-    value = value * 10 + (*p - '0');
-    p++;
-  }
-  return value;
-}
-
-bool is_leap_year(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }
-
-// Get days in year (avoids duplicate is_leap_year calls)
-static inline int days_in_year(int year) { return is_leap_year(year) ? 366 : 365; }
-
-// Convert days since epoch to year, updating days to remainder
-static int __attribute__((noinline)) days_to_year(int64_t &days) {
-  int year = 1970;
-  int diy;
-  while (days >= (diy = days_in_year(year))) {
-    days -= diy;
-    year++;
-  }
-  while (days < 0) {
-    year--;
-    days += days_in_year(year);
-  }
-  return year;
-}
-
-// Extract just the year from a UTC epoch
-static int epoch_to_year(time_t epoch) {
-  int64_t days = epoch / 86400;
-  if (epoch < 0 && epoch % 86400 != 0)
-    days--;
-  return days_to_year(days);
-}
-
-int days_in_month(int year, int month) {
-  switch (month) {
-    case 2:
-      return is_leap_year(year) ? 29 : 28;
-    case 4:
-    case 6:
-    case 9:
-    case 11:
-      return 30;
-    default:
-      return 31;
-  }
-}
-
-// Zeller-like algorithm for day of week (0 = Sunday)
-int __attribute__((noinline)) day_of_week(int year, int month, int day) {
-  // Adjust for January/February
-  if (month < 3) {
-    month += 12;
-    year--;
-  }
-  int k = year % 100;
-  int j = year / 100;
-  int h = (day + (13 * (month + 1)) / 5 + k + k / 4 + j / 4 - 2 * j) % 7;
-  // Convert from Zeller (0=Sat) to standard (0=Sun)
-  return ((h + 6) % 7);
-}
-
-void __attribute__((noinline)) epoch_to_tm_utc(time_t epoch, struct tm *out_tm) {
-  // Days since epoch
-  int64_t days = epoch / 86400;
-  int32_t remaining_secs = epoch % 86400;
-  if (remaining_secs < 0) {
-    days--;
-    remaining_secs += 86400;
-  }
-
-  out_tm->tm_sec = remaining_secs % 60;
-  remaining_secs /= 60;
-  out_tm->tm_min = remaining_secs % 60;
-  out_tm->tm_hour = remaining_secs / 60;
-
-  // Day of week (Jan 1, 1970 was Thursday = 4)
-  out_tm->tm_wday = static_cast<int>((days + 4) % 7);
-  if (out_tm->tm_wday < 0)
-    out_tm->tm_wday += 7;
-
-  // Calculate year (updates days to day-of-year)
-  int year = days_to_year(days);
-  out_tm->tm_year = year - 1900;
-  out_tm->tm_yday = static_cast<int>(days);
-
-  // Calculate month and day
-  int month = 1;
-  int dim;
-  while (days >= (dim = days_in_month(year, month))) {
-    days -= dim;
-    month++;
-  }
-
-  out_tm->tm_mon = month - 1;
-  out_tm->tm_mday = static_cast<int>(days) + 1;
-  out_tm->tm_isdst = 0;
-}
-
-bool skip_tz_name(const char *&p) {
-  if (*p == '<') {
-    // Angle-bracket quoted name: <+07>, <-03>, <AEST>
-    p++;  // skip '<'
-    while (*p && *p != '>') {
-      p++;
-    }
-    if (*p == '>') {
-      p++;  // skip '>'
-      return true;
-    }
-    return false;  // Unterminated
-  }
-
-  // Standard name: 3+ letters
-  const char *start = p;
-  while (*p && std::isalpha(static_cast<unsigned char>(*p))) {
-    p++;
-  }
-  return (p - start) >= 3;
-}
-
-int32_t __attribute__((noinline)) parse_offset(const char *&p) {
-  int sign = 1;
-  if (*p == '-') {
-    sign = -1;
-    p++;
-  } else if (*p == '+') {
-    p++;
-  }
-
-  int hours = parse_uint(p);
-  int minutes = 0;
-  int seconds = 0;
-
-  if (*p == ':') {
-    p++;
-    minutes = parse_uint(p);
-    if (*p == ':') {
-      p++;
-      seconds = parse_uint(p);
-    }
-  }
-
-  return sign * (hours * 3600 + minutes * 60 + seconds);
-}
-
-// Helper to parse the optional /time suffix (reuses parse_offset logic)
-static void parse_transition_time(const char *&p, DSTRule &rule) {
-  rule.time_seconds = 2 * 3600;  // Default 02:00
-  if (*p == '/') {
-    p++;
-    rule.time_seconds = parse_offset(p);
-  }
-}
-
-void __attribute__((noinline)) julian_to_month_day(int julian_day, int &out_month, int &out_day) {
-  // J format: day 1-365, Feb 29 is NOT counted even in leap years
-  // So day 60 is always March 1
-  // Iterate forward through months (no array needed)
-  int remaining = julian_day;
-  out_month = 1;
-  while (out_month <= 12) {
-    // Days in month for non-leap year (J format ignores leap years)
-    int dim = days_in_month(2001, out_month);  // 2001 is non-leap year
-    if (remaining <= dim) {
-      out_day = remaining;
-      return;
-    }
-    remaining -= dim;
-    out_month++;
-  }
-  out_day = remaining;
-}
-
-void __attribute__((noinline)) day_of_year_to_month_day(int day_of_year, int year, int &out_month, int &out_day) {
-  // Plain format: day 0-365, Feb 29 IS counted in leap years
-  // Day 0 = Jan 1
-  int remaining = day_of_year;
-  out_month = 1;
-
-  while (out_month <= 12) {
-    int days_this_month = days_in_month(year, out_month);
-    if (remaining < days_this_month) {
-      out_day = remaining + 1;
-      return;
-    }
-    remaining -= days_this_month;
-    out_month++;
-  }
-
-  // Shouldn't reach here with valid input
-  out_month = 12;
-  out_day = 31;
-}
-
-bool parse_dst_rule(const char *&p, DSTRule &rule) {
-  rule = {};  // Zero initialize
-
-  if (*p == 'M' || *p == 'm') {
-    // M format: Mm.w.d (month.week.day)
-    rule.type = DSTRuleType::MONTH_WEEK_DAY;
-    p++;
-
-    rule.month = parse_uint(p);
-    if (rule.month < 1 || rule.month > 12)
-      return false;
-
-    if (*p++ != '.')
-      return false;
-
-    rule.week = parse_uint(p);
-    if (rule.week < 1 || rule.week > 5)
-      return false;
-
-    if (*p++ != '.')
-      return false;
-
-    rule.day_of_week = parse_uint(p);
-    if (rule.day_of_week > 6)
-      return false;
-
-  } else if (*p == 'J' || *p == 'j') {
-    // J format: Jn (Julian day 1-365, not counting Feb 29)
-    rule.type = DSTRuleType::JULIAN_NO_LEAP;
-    p++;
-
-    rule.day = parse_uint(p);
-    if (rule.day < 1 || rule.day > 365)
-      return false;
-
-  } else if (std::isdigit(static_cast<unsigned char>(*p))) {
-    // Plain number format: n (day 0-365, counting Feb 29)
-    rule.type = DSTRuleType::DAY_OF_YEAR;
-
-    rule.day = parse_uint(p);
-    if (rule.day > 365)
-      return false;
-
-  } else {
-    return false;
-  }
-
-  // Parse optional /time suffix
-  parse_transition_time(p, rule);
-
-  return true;
-}
-
-// Calculate days from Jan 1 of given year to given month/day
-static int __attribute__((noinline)) days_from_year_start(int year, int month, int day) {
-  int days = day - 1;
-  for (int m = 1; m < month; m++) {
-    days += days_in_month(year, m);
-  }
-  return days;
-}
-
-// Calculate days from epoch to Jan 1 of given year (for DST transition calculations)
-// Only supports years >= 1970. Timezone is either compiled in from YAML or set by
-// Home Assistant, so pre-1970 dates are not a concern.
-static int64_t __attribute__((noinline)) days_to_year_start(int year) {
-  int64_t days = 0;
-  for (int y = 1970; y < year; y++) {
-    days += days_in_year(y);
-  }
-  return days;
-}
-
-time_t __attribute__((noinline)) calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds) {
-  int month, day;
-
-  switch (rule.type) {
-    case DSTRuleType::MONTH_WEEK_DAY: {
-      // Find the nth occurrence of day_of_week in the given month
-      int first_dow = day_of_week(year, rule.month, 1);
-
-      // Days until first occurrence of target day
-      int days_until_first = (rule.day_of_week - first_dow + 7) % 7;
-      int first_occurrence = 1 + days_until_first;
-
-      if (rule.week == 5) {
-        // "Last" occurrence - find the last one in the month
-        int dim = days_in_month(year, rule.month);
-        day = first_occurrence;
-        while (day + 7 <= dim) {
-          day += 7;
-        }
-      } else {
-        // nth occurrence
-        day = first_occurrence + (rule.week - 1) * 7;
-      }
-      month = rule.month;
-      break;
-    }
-
-    case DSTRuleType::JULIAN_NO_LEAP:
-      // J format: day 1-365, Feb 29 not counted
-      julian_to_month_day(rule.day, month, day);
-      break;
-
-    case DSTRuleType::DAY_OF_YEAR:
-      // Plain format: day 0-365, Feb 29 counted
-      day_of_year_to_month_day(rule.day, year, month, day);
-      break;
-
-    case DSTRuleType::NONE:
-      // Should never be called with NONE, but handle it gracefully
-      month = 1;
-      day = 1;
-      break;
-  }
-
-  // Calculate days from epoch to this date
-  int64_t days = days_to_year_start(year) + days_from_year_start(year, month, day);
-
-  // Convert to epoch and add transition time and base offset
-  return days * 86400 + rule.time_seconds + base_offset_seconds;
-}
-
-}  // namespace internal
-
-bool __attribute__((noinline)) is_in_dst(time_t utc_epoch, const ParsedTimezone &tz) {
-  if (!tz.has_dst()) {
-    return false;
-  }
-
-  int year = internal::epoch_to_year(utc_epoch);
-
-  // Calculate DST start and end for this year
-  // DST start transition happens in standard time
-  time_t dst_start = internal::calculate_dst_transition(year, tz.dst_start, tz.std_offset_seconds);
-  // DST end transition happens in daylight time
-  time_t dst_end = internal::calculate_dst_transition(year, tz.dst_end, tz.dst_offset_seconds);
-
-  if (dst_start < dst_end) {
-    // Northern hemisphere: DST is between start and end
-    return (utc_epoch >= dst_start && utc_epoch < dst_end);
-  } else {
-    // Southern hemisphere: DST is outside the range (wraps around year)
-    return (utc_epoch >= dst_start || utc_epoch < dst_end);
-  }
-}
-
-bool parse_posix_tz(const char *tz_string, ParsedTimezone &result) {
-  if (!tz_string || !*tz_string) {
-    return false;
-  }
-
-  const char *p = tz_string;
-
-  // Initialize result (dst_start/dst_end default to type=NONE, so has_dst() returns false)
-  result.std_offset_seconds = 0;
-  result.dst_offset_seconds = 0;
-  result.dst_start = {};
-  result.dst_end = {};
-
-  // Skip standard timezone name
-  if (!internal::skip_tz_name(p)) {
-    return false;
-  }
-
-  // Parse standard offset (required)
-  if (!*p || (!std::isdigit(static_cast<unsigned char>(*p)) && *p != '+' && *p != '-')) {
-    return false;
-  }
-  result.std_offset_seconds = internal::parse_offset(p);
-
-  // Check for DST name
-  if (!*p) {
-    return true;  // No DST
-  }
-
-  // If next char is comma, there's no DST name but there are rules (invalid)
-  if (*p == ',') {
-    return false;
-  }
-
-  // Check if there's something that looks like a DST name start
-  // (letter or angle bracket). If not, treat as trailing garbage and return success.
-  if (!std::isalpha(static_cast<unsigned char>(*p)) && *p != '<') {
-    return true;  // No DST, trailing characters ignored
-  }
-
-  if (!internal::skip_tz_name(p)) {
-    return false;  // Invalid DST name (started but malformed)
-  }
-
-  // Optional DST offset (default is std - 1 hour)
-  if (*p && *p != ',' && (std::isdigit(static_cast<unsigned char>(*p)) || *p == '+' || *p == '-')) {
-    result.dst_offset_seconds = internal::parse_offset(p);
-  } else {
-    result.dst_offset_seconds = result.std_offset_seconds - 3600;
-  }
-
-  // Parse DST rules (required when DST name is present)
-  if (*p != ',') {
-    // DST name without rules - treat as no DST since we can't determine transitions
-    return true;
-  }
-
-  p++;
-  if (!internal::parse_dst_rule(p, result.dst_start)) {
-    return false;
-  }
-
-  // Second rule is required per POSIX
-  if (*p != ',') {
-    return false;
-  }
-  p++;
-  // has_dst() now returns true since dst_start.type was set by parse_dst_rule
-  return internal::parse_dst_rule(p, result.dst_end);
-}
-
-bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm) {
-  if (!out_tm) {
-    return false;
-  }
-
-  // Determine DST status once (avoids duplicate is_in_dst calculation)
-  bool in_dst = is_in_dst(utc_epoch, tz);
-  int32_t offset = in_dst ? tz.dst_offset_seconds : tz.std_offset_seconds;
-
-  // Apply offset (POSIX offset is positive west, so subtract to get local)
-  time_t local_epoch = utc_epoch - offset;
-
-  internal::epoch_to_tm_utc(local_epoch, out_tm);
-  out_tm->tm_isdst = in_dst ? 1 : 0;
-
-  return true;
-}
-
-}  // namespace esphome::time
-
-#ifndef USE_HOST
-// Override libc's localtime functions to use our timezone on embedded platforms.
-// This allows user lambdas calling ::localtime() to get correct local time
-// without needing the TZ environment variable (which pulls in scanf bloat).
-// On host, we use the normal TZ mechanism since there's no memory constraint.
-
-// Thread-safe version
-extern "C" struct tm *localtime_r(const time_t *timer, struct tm *result) {
-  if (timer == nullptr || result == nullptr) {
-    return nullptr;
-  }
-  esphome::time::epoch_to_local_tm(*timer, esphome::time::get_global_tz(), result);
-  return result;
-}
-
-// Non-thread-safe version (uses static buffer, standard libc behavior)
-extern "C" struct tm *localtime(const time_t *timer) {
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  static struct tm localtime_buf;
-  return localtime_r(timer, &localtime_buf);
-}
-#endif  // !USE_HOST
-
-#endif  // USE_TIME_TIMEZONE

esphome/components/time/posix_tz.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#ifdef USE_TIME_TIMEZONE
-
-#include <cstdint>
-#include <ctime>
-
-namespace esphome::time {
-
-/// Type of DST transition rule
-enum class DSTRuleType : uint8_t {
-  NONE = 0,        ///< No DST rule (used to indicate no DST)
-  MONTH_WEEK_DAY,  ///< M format: Mm.w.d (e.g., M3.2.0 = 2nd Sunday of March)
-  JULIAN_NO_LEAP,  ///< J format: Jn (day 1-365, Feb 29 not counted)
-  DAY_OF_YEAR,     ///< Plain number: n (day 0-365, Feb 29 counted in leap years)
-};
-
-/// Rule for DST transition (packed for 32-bit: 12 bytes)
-struct DSTRule {
-  int32_t time_seconds;  ///< Seconds after midnight (default 7200 = 2:00 AM)
-  uint16_t day;          ///< Day of year (for JULIAN_NO_LEAP and DAY_OF_YEAR)
-  DSTRuleType type;      ///< Type of rule
-  uint8_t month;         ///< Month 1-12 (for MONTH_WEEK_DAY)
-  uint8_t week;          ///< Week 1-5, 5 = last (for MONTH_WEEK_DAY)
-  uint8_t day_of_week;   ///< Day 0-6, 0 = Sunday (for MONTH_WEEK_DAY)
-};
-
-/// Parsed POSIX timezone information (packed for 32-bit: 32 bytes)
-struct ParsedTimezone {
-  int32_t std_offset_seconds;  ///< Standard time offset from UTC in seconds (positive = west)
-  int32_t dst_offset_seconds;  ///< DST offset from UTC in seconds
-  DSTRule dst_start;           ///< When DST starts
-  DSTRule dst_end;             ///< When DST ends
-
-  /// Check if this timezone has DST rules
-  bool has_dst() const { return this->dst_start.type != DSTRuleType::NONE; }
-};
-
-/// Parse a POSIX TZ string into a ParsedTimezone struct.
-/// Supports formats like:
-///   - "EST5" (simple offset, no DST)
-///   - "EST5EDT,M3.2.0,M11.1.0" (with DST, M-format rules)
-///   - "CST6CDT,M3.2.0/2,M11.1.0/2" (with transition times)
-///   - "<+07>-7" (angle-bracket notation for special names)
-///   - "IST-5:30" (half-hour offsets)
-///   - "EST5EDT,J60,J300" (J-format: Julian day without leap day)
-///   - "EST5EDT,60,300" (plain day number: day of year with leap day)
-/// @param tz_string The POSIX TZ string to parse
-/// @param result Output: the parsed timezone data
-/// @return true if parsing succeeded, false on error
-bool parse_posix_tz(const char *tz_string, ParsedTimezone &result);
-
-/// Convert a UTC epoch to local time using the parsed timezone.
-/// This replaces libc's localtime() to avoid scanf dependency.
-/// @param utc_epoch Unix timestamp in UTC
-/// @param tz The parsed timezone
-/// @param[out] out_tm Output tm struct with local time
-/// @return true on success
-bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm);
-
-/// Set the global timezone used by epoch_to_local_tm() when called without a timezone.
-/// This is called by RealTimeClock::apply_timezone_() to enable ESPTime::from_epoch_local()
-/// to work without libc's localtime().
-void set_global_tz(const ParsedTimezone &tz);
-
-/// Get the global timezone.
-const ParsedTimezone &get_global_tz();
-
-/// Check if a given UTC epoch falls within DST for the parsed timezone.
-/// @param utc_epoch Unix timestamp in UTC
-/// @param tz The parsed timezone
-/// @return true if DST is in effect at the given time
-bool is_in_dst(time_t utc_epoch, const ParsedTimezone &tz);
-
-// Internal helper functions exposed for testing
-
-namespace internal {
-
-/// Skip a timezone name (letters or <...> quoted format)
-/// @param p Pointer to current position, updated on return
-/// @return true if a valid name was found
-bool skip_tz_name(const char *&p);
-
-/// Parse an offset in format [-]hh[:mm[:ss]]
-/// @param p Pointer to current position, updated on return
-/// @return Offset in seconds
-int32_t parse_offset(const char *&p);
-
-/// Parse a DST rule in format Mm.w.d[/time], Jn[/time], or n[/time]
-/// @param p Pointer to current position, updated on return
-/// @param rule Output: the parsed rule
-/// @return true if parsing succeeded
-bool parse_dst_rule(const char *&p, DSTRule &rule);
-
-/// Convert Julian day (J format, 1-365 not counting Feb 29) to month/day
-/// @param julian_day Day number 1-365
-/// @param[out] month Output: month 1-12
-/// @param[out] day Output: day of month
-void julian_to_month_day(int julian_day, int &month, int &day);
-
-/// Convert day of year (plain format, 0-365 counting Feb 29) to month/day
-/// @param day_of_year Day number 0-365
-/// @param year The year (for leap year calculation)
-/// @param[out] month Output: month 1-12
-/// @param[out] day Output: day of month
-void day_of_year_to_month_day(int day_of_year, int year, int &month, int &day);
-
-/// Calculate day of week for any date (0 = Sunday)
-/// Uses a simplified algorithm that works for years 1970-2099
-int day_of_week(int year, int month, int day);
-
-/// Get the number of days in a month
-int days_in_month(int year, int month);
-
-/// Check if a year is a leap year
-bool is_leap_year(int year);
-
-/// Convert epoch to year/month/day/hour/min/sec (UTC)
-void epoch_to_tm_utc(time_t epoch, struct tm *out_tm);
-
-/// Calculate the epoch timestamp for a DST transition in a given year.
-/// @param year The year (e.g., 2026)
-/// @param rule The DST rule (month, week, day_of_week, time)
-/// @param base_offset_seconds The timezone offset to apply (std or dst depending on context)
-/// @return Unix epoch timestamp of the transition
-time_t calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds);
-
-}  // namespace internal
-
-}  // namespace esphome::time
-
-#endif  // USE_TIME_TIMEZONE

esphome/components/time/real_time_clock.cpp

@@ -14,8 +14,8 @@
 #include <sys/time.h>
 #endif
 #include <cerrno>
+
 #include <cinttypes>
-#include <cstdlib>
 
 namespace esphome::time {
 
@@ -23,33 +23,9 @@ static const char *const TAG = "time";
 
 RealTimeClock::RealTimeClock() = default;
 
-ESPTime __attribute__((noinline)) RealTimeClock::now() {
-#ifdef USE_TIME_TIMEZONE
-  time_t epoch = this->timestamp_now();
-  struct tm local_tm;
-  if (epoch_to_local_tm(epoch, get_global_tz(), &local_tm)) {
-    return ESPTime::from_c_tm(&local_tm, epoch);
-  }
-  // Fallback to UTC if parsing failed
-  return ESPTime::from_epoch_utc(epoch);
-#else
-  return ESPTime::from_epoch_local(this->timestamp_now());
-#endif
-}
-
 void RealTimeClock::dump_config() {
 #ifdef USE_TIME_TIMEZONE
-  const auto &tz = get_global_tz();
-  // POSIX offset is positive west, negate for conventional UTC+X display
-  int std_h = -tz.std_offset_seconds / 3600;
-  int std_m = (std::abs(tz.std_offset_seconds) % 3600) / 60;
-  if (tz.has_dst()) {
-    int dst_h = -tz.dst_offset_seconds / 3600;
-    int dst_m = (std::abs(tz.dst_offset_seconds) % 3600) / 60;
-    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d (DST UTC%+d:%02d)", std_h, std_m, dst_h, dst_m);
-  } else {
-    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d", std_h, std_m);
-  }
+  ESP_LOGCONFIG(TAG, "Timezone: '%s'", this->timezone_.c_str());
 #endif
   auto time = this->now();
   ESP_LOGCONFIG(TAG, "Current time: %04d-%02d-%02d %02d:%02d:%02d", time.year, time.month, time.day_of_month, time.hour,
@@ -96,6 +72,11 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
     ret = settimeofday(&timev, nullptr);
   }
 
+#ifdef USE_TIME_TIMEZONE
+  // Move timezone back to local timezone.
+  this->apply_timezone_();
+#endif
+
   if (ret != 0) {
     ESP_LOGW(TAG, "setimeofday() failed with code %d", ret);
   }
@@ -108,29 +89,9 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
 }
 
 #ifdef USE_TIME_TIMEZONE
-void RealTimeClock::apply_timezone_(const char *tz) {
-  ParsedTimezone parsed{};
-
-  // Handle null or empty input - use UTC
-  if (tz == nullptr || *tz == '\0') {
-    set_global_tz(parsed);
-    return;
-  }
-
-#ifdef USE_HOST
-  // On host platform, also set TZ environment variable for libc compatibility
-  setenv("TZ", tz, 1);
+void RealTimeClock::apply_timezone_() {
+  setenv("TZ", this->timezone_.c_str(), 1);
   tzset();
-#endif
-
-  // Parse the POSIX TZ string using our custom parser
-  if (!parse_posix_tz(tz, parsed)) {
-    ESP_LOGW(TAG, "Failed to parse timezone: %s", tz);
-    // parsed stays as default (UTC) on failure
-  }
-
-  // Set global timezone for all time conversions
-  set_global_tz(parsed);
 }
 #endif
 

esphome/components/time/real_time_clock.h

@@ -6,9 +6,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/time.h"
-#ifdef USE_TIME_TIMEZONE
-#include "posix_tz.h"
-#endif
 
 namespace esphome::time {
 
@@ -23,31 +20,26 @@ class RealTimeClock : public PollingComponent {
   explicit RealTimeClock();
 
 #ifdef USE_TIME_TIMEZONE
-  /// Set the time zone from a POSIX TZ string.
-  void set_timezone(const char *tz) { this->apply_timezone_(tz); }
-
-  /// Set the time zone from a character buffer with known length.
-  /// The buffer does not need to be null-terminated.
-  void set_timezone(const char *tz, size_t len) {
-    if (tz == nullptr) {
-      this->apply_timezone_(nullptr);
-      return;
-    }
-    // Stack buffer - TZ strings from tzdata are typically short (< 50 chars)
-    char buf[128];
-    if (len >= sizeof(buf))
-      len = sizeof(buf) - 1;
-    memcpy(buf, tz, len);
-    buf[len] = '\0';
-    this->apply_timezone_(buf);
+  /// Set the time zone.
+  void set_timezone(const std::string &tz) {
+    this->timezone_ = tz;
+    this->apply_timezone_();
   }
 
-  /// Set the time zone from a std::string.
-  void set_timezone(const std::string &tz) { this->apply_timezone_(tz.c_str()); }
+  /// Set the time zone from raw buffer, only if it differs from the current one.
+  void set_timezone(const char *tz, size_t len) {
+    if (this->timezone_.length() != len || memcmp(this->timezone_.c_str(), tz, len) != 0) {
+      this->timezone_.assign(tz, len);
+      this->apply_timezone_();
+    }
+  }
+
+  /// Get the time zone currently in use.
+  std::string get_timezone() { return this->timezone_; }
 #endif
 
   /// Get the time in the currently defined timezone.
-  ESPTime now();
+  ESPTime now() { return ESPTime::from_epoch_local(this->timestamp_now()); }
 
   /// Get the time without any time zone or DST corrections.
   ESPTime utcnow() { return ESPTime::from_epoch_utc(this->timestamp_now()); }
@@ -66,7 +58,8 @@ class RealTimeClock : public PollingComponent {
   void synchronize_epoch_(uint32_t epoch);
 
 #ifdef USE_TIME_TIMEZONE
-  void apply_timezone_(const char *tz);
+  std::string timezone_{};
+  void apply_timezone_();
 #endif
 
   LazyCallbackManager<void()> time_sync_callback_;