[light] Eliminate redundant clamp in LightCall::validate_() and normalize_color()

After clamp_and_log_if_invalid() clamps the value in-place, the
LightColorValues setter's clamp() is guaranteed to be a no-op. For 5
of 9 fields the compiler was inlining the setter's clamp, generating
~18 bytes of redundant float compare + conditional move per field.

Use friend access to assign directly to LightColorValues fields,
bypassing the setter. Also apply the same optimization to
normalize_color() where division by max_value guarantees results
stay in [0,1].

.clang-tidy.hash

@@ -1 +1 @@
-37ec8d5a343c8d0a485fd2118cbdabcbccd7b9bca197e4a392be75087974dced
+74867fc82764102ce1275ea2bc43e3aeee7619679537c6db61114a33342bb4c7

docker/Dockerfile

@@ -23,7 +23,7 @@ RUN if command -v apk > /dev/null; then \
 
 ENV PIP_DISABLE_PIP_VERSION_CHECK=1
 
-RUN pip install --no-cache-dir -U pip uv==0.6.14
+RUN pip install --no-cache-dir -U pip uv==0.10.1
 
 COPY requirements.txt /
 

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
-  const char *peername = this->helper_->get_client_peername();
-  this->helper_->set_client_name(peername, strlen(peername));
+  char peername[socket::SOCKADDR_STR_LEN];
+  this->helper_->set_client_name(this->helper_->get_peername_to(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
-    this->helper_->close();
+    // requested a disconnect - don't close socket here, let APIServer::loop() do it
+    // so getpeername() still works for the disconnect trigger
     this->flags_.remove = true;
     return;
   }
@@ -293,7 +293,8 @@ bool APIConnection::send_disconnect_response_() {
   return this->send_message(resp, DisconnectResponse::MESSAGE_TYPE);
 }
 void APIConnection::on_disconnect_response() {
-  this->helper_->close();
+  // Don't close socket here, let APIServer::loop() do it
+  // so getpeername() still works for the disconnect trigger
   this->flags_.remove = true;
 }
 
@@ -1469,8 +1470,11 @@ 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
-  this->parent_->get_client_connected_trigger()->trigger(std::string(this->helper_->get_client_name()),
-                                                         std::string(this->helper_->get_client_peername()));
+  {
+    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)));
+  }
 #endif
 #ifdef USE_HOMEASSISTANT_TIME
   if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1489,8 +1493,9 @@ 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_client_peername(), this->client_api_version_major_, this->client_api_version_minor_);
+           this->helper_->get_peername_to(peername), this->client_api_version_major_, this->client_api_version_minor_);
 
   HelloResponse resp;
   resp.api_version_major = 1;
@@ -1838,7 +1843,8 @@ void APIConnection::on_no_setup_connection() {
   this->log_client_(ESPHOME_LOG_LEVEL_DEBUG, LOG_STR("no connection setup"));
 }
 void APIConnection::on_fatal_error() {
-  this->helper_->close();
+  // 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->flags_.remove = true;
 }
 
@@ -1899,6 +1905,10 @@ bool APIConnection::schedule_batch_() {
 }
 
 void APIConnection::process_batch_() {
+  // Ensure MessageInfo remains trivially destructible for our placement new approach
+  static_assert(std::is_trivially_destructible<MessageInfo>::value,
+                "MessageInfo must remain trivially destructible with this placement-new approach");
+
   if (this->deferred_batch_.empty()) {
     this->flags_.batch_scheduled = false;
     return;
@@ -1923,10 +1933,6 @@ void APIConnection::process_batch_() {
   for (size_t i = 0; i < num_items; i++) {
     total_estimated_size += this->deferred_batch_[i].estimated_size;
   }
-  // Clamp to MAX_BATCH_PACKET_SIZE — we won't send more than that per batch
-  if (total_estimated_size > MAX_BATCH_PACKET_SIZE) {
-    total_estimated_size = MAX_BATCH_PACKET_SIZE;
-  }
 
   this->prepare_first_message_buffer(shared_buf, header_padding, total_estimated_size);
 
@@ -1950,20 +1956,7 @@ void APIConnection::process_batch_() {
     return;
   }
 
-  // Multi-message path — heavy stack frame isolated in separate noinline function
-  this->process_batch_multi_(shared_buf, num_items, header_padding, footer_size);
-}
-
-// Separated from process_batch_() so the single-message fast path gets a minimal
-// stack frame without the MAX_MESSAGES_PER_BATCH * sizeof(MessageInfo) array.
-void APIConnection::process_batch_multi_(std::vector<uint8_t> &shared_buf, size_t num_items, uint8_t header_padding,
-                                         uint8_t footer_size) {
-  // Ensure MessageInfo remains trivially destructible for our placement new approach
-  static_assert(std::is_trivially_destructible<MessageInfo>::value,
-                "MessageInfo must remain trivially destructible with this placement-new approach");
-
-  const size_t messages_to_process = std::min(num_items, MAX_MESSAGES_PER_BATCH);
-  const uint8_t frame_overhead = header_padding + footer_size;
+  size_t messages_to_process = std::min(num_items, MAX_MESSAGES_PER_BATCH);
 
   // Stack-allocated array for message info
   alignas(MessageInfo) char message_info_storage[MAX_MESSAGES_PER_BATCH * sizeof(MessageInfo)];
@@ -1990,7 +1983,7 @@ void APIConnection::process_batch_multi_(std::vector<uint8_t> &shared_buf, size_
 
     // Message was encoded successfully
     // payload_size is header_padding + actual payload size + footer_size
-    uint16_t proto_payload_size = payload_size - frame_overhead;
+    uint16_t proto_payload_size = payload_size - header_padding - footer_size;
     // Use placement new to construct MessageInfo in pre-allocated stack array
     // This avoids default-constructing all MAX_MESSAGES_PER_BATCH elements
     // Explicit destruction is not needed because MessageInfo is trivially destructible,
@@ -2006,38 +1999,42 @@ void APIConnection::process_batch_multi_(std::vector<uint8_t> &shared_buf, size_
     current_offset = shared_buf.size() + footer_size;
   }
 
-  if (items_processed > 0) {
-    // Add footer space for the last message (for Noise protocol MAC)
-    if (footer_size > 0) {
-      shared_buf.resize(shared_buf.size() + footer_size);
-    }
-
-    // Send all collected messages
-    APIError err = this->helper_->write_protobuf_messages(ProtoWriteBuffer{&shared_buf},
-                                                          std::span<const MessageInfo>(message_info, items_processed));
-    if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
-      this->fatal_error_with_log_(LOG_STR("Batch write failed"), err);
-    }
-
-#ifdef HAS_PROTO_MESSAGE_DUMP
-    // Log messages after send attempt for VV debugging
-    // It's safe to use the buffer for logging at this point regardless of send result
-    for (size_t i = 0; i < items_processed; i++) {
-      const auto &item = this->deferred_batch_[i];
-      this->log_batch_item_(item);
-    }
-#endif
-
-    // Partial batch — remove processed items and reschedule
-    if (items_processed < this->deferred_batch_.size()) {
-      this->deferred_batch_.remove_front(items_processed);
-      this->schedule_batch_();
-      return;
-    }
+  if (items_processed == 0) {
+    this->deferred_batch_.clear();
+    return;
   }
 
-  // All items processed (or none could be processed)
-  this->clear_batch_();
+  // Add footer space for the last message (for Noise protocol MAC)
+  if (footer_size > 0) {
+    shared_buf.resize(shared_buf.size() + footer_size);
+  }
+
+  // Send all collected messages
+  APIError err = this->helper_->write_protobuf_messages(ProtoWriteBuffer{&shared_buf},
+                                                        std::span<const MessageInfo>(message_info, items_processed));
+  if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
+    this->fatal_error_with_log_(LOG_STR("Batch write failed"), err);
+  }
+
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  // Log messages after send attempt for VV debugging
+  // It's safe to use the buffer for logging at this point regardless of send result
+  for (size_t i = 0; i < items_processed; i++) {
+    const auto &item = this->deferred_batch_[i];
+    this->log_batch_item_(item);
+  }
+#endif
+
+  // Handle remaining items more efficiently
+  if (items_processed < this->deferred_batch_.size()) {
+    // Remove processed items from the beginning
+    this->deferred_batch_.remove_front(items_processed);
+    // Reschedule for remaining items
+    this->schedule_batch_();
+  } else {
+    // All items processed
+    this->clear_batch_();
+  }
 }
 
 // Dispatch message encoding based on message_type
@@ -2204,12 +2201,14 @@ 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_client_peername(), LOG_STR_ARG(message));
+                  this->helper_->get_peername_to(peername), LOG_STR_ARG(message));
 }
 
 void APIConnection::log_warning_(const LogString *message, APIError err) {
-  ESP_LOGW(TAG, "%s (%s): %s %s errno=%d", this->helper_->get_client_name(), this->helper_->get_client_peername(),
+  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),
            LOG_STR_ARG(message), LOG_STR_ARG(api_error_to_logstr(err)), errno);
 }
 

esphome/components/api/api_connection.h

@@ -276,8 +276,10 @@ 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) - cached at connection init time
-  const char *get_peername() const { return this->helper_->get_client_peername(); }
+  /// 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);
+  }
 
  protected:
   // Helper function to handle authentication completion
@@ -549,8 +551,8 @@ class APIConnection final : public APIServerConnectionBase {
       batch_start_time = 0;
     }
 
-    // Remove processed items from the front — noinline to keep memmove out of warm callers
-    void remove_front(size_t count) __attribute__((noinline)) { items.erase(items.begin(), items.begin() + count); }
+    // Remove processed items from the front
+    void remove_front(size_t count) { items.erase(items.begin(), items.begin() + count); }
 
     bool empty() const { return items.empty(); }
     size_t size() const { return items.size(); }
@@ -622,8 +624,6 @@ class APIConnection final : public APIServerConnectionBase {
 
   bool schedule_batch_();
   void process_batch_();
-  void process_batch_multi_(std::vector<uint8_t> &shared_buf, size_t num_items, uint8_t header_padding,
-                            uint8_t footer_size) __attribute__((noinline));
   void clear_batch_() {
     this->deferred_batch_.clear();
     this->flags_.batch_scheduled = false;

esphome/components/api/api_frame_helper.cpp

@@ -16,7 +16,12 @@ 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, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
+#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)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif
@@ -240,13 +245,20 @@ 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,8 +90,9 @@ class APIFrameHelper {
 
   // Get client name (null-terminated)
   const char *get_client_name() const { return this->client_name_; }
-  // 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_; }
+  // 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;
   // 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);
@@ -105,6 +106,8 @@ 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)
@@ -231,8 +234,6 @@ 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,7 +29,12 @@ 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, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
+#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)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -21,7 +21,12 @@ 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, ...) ESP_LOGVV(TAG, "%s (%s): " msg, this->client_name_, this->client_peername_, ##__VA_ARGS__)
+#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)
 #else
 #define HELPER_LOG(msg, ...) ((void) 0)
 #endif

esphome/components/api/api_server.cpp

@@ -192,11 +192,15 @@ void APIServer::loop() {
     ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Save client info before removal for the trigger
+    // Save client info before closing socket and removal for the trigger
+    char peername_buf[socket::SOCKADDR_STR_LEN];
     std::string client_name(client->get_name());
-    std::string client_peername(client->get_peername());
+    std::string client_peername(client->get_peername_to(peername_buf));
 #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/bk72xx/boards.py

@@ -159,6 +159,10 @@ 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,
@@ -227,6 +231,10 @@ 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,
@@ -295,6 +303,10 @@ 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,
@@ -485,8 +497,7 @@ BK72XX_BOARD_PINS = {
     },
     "cb3s": {
         "WIRE1_SCL": 20,
-        "WIRE1_SDA_0": 21,
-        "WIRE1_SDA_1": 21,
+        "WIRE1_SDA": 21,
         "SERIAL1_RX": 10,
         "SERIAL1_TX": 11,
         "SERIAL2_TX": 0,
@@ -647,6 +658,10 @@ 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,
@@ -1096,6 +1111,10 @@ 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,8 +6,9 @@
 */
 
 #include "bmp3xx_base.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include <cinttypes>
 
 namespace esphome {
@@ -26,46 +27,18 @@ 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) {
-  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("");
-  }
+  return OversamplingStrings::get_log_str(static_cast<uint8_t>(oversampling), OversamplingStrings::LAST_INDEX);
 }
 
+// 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) {
-  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("");
-  }
+  return IIRFilterStrings::get_log_str(static_cast<uint8_t>(filter), IIRFilterStrings::LAST_INDEX);
 }
 
 void BMP3XXComponent::setup() {

esphome/components/bmp581_base/bmp581_base.cpp

@@ -11,57 +11,26 @@
  */
 
 #include "bmp581_base.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include "esphome/core/progmem.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) {
-  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("");
-  }
+  return OversamplingStrings::get_log_str(static_cast<uint8_t>(oversampling), OversamplingStrings::LAST_INDEX);
 }
 
+// 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) {
-  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("");
-  }
+  return IIRFilterStrings::get_log_str(static_cast<uint8_t>(filter), IIRFilterStrings::LAST_INDEX);
 }
 
 void BMP581Component::dump_config() {

esphome/components/debug/debug_esp8266.cpp

@@ -1,6 +1,7 @@
 #include "debug_component.h"
 #ifdef USE_ESP8266
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include <Esp.h>
 
 extern "C" {
@@ -19,27 +20,38 @@ 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_WDT_RST == 1, "Reset reason enum values must match table indices");
+static_assert(REASON_EXCEPTION_RST == 2, "Reset reason enum values must match table indices");
+static_assert(REASON_SOFT_WDT_RST == 3, "Reset reason enum values must match table indices");
+static_assert(REASON_SOFT_RESTART == 4, "Reset reason enum values must match table indices");
+static_assert(REASON_DEEP_SLEEP_AWAKE == 5, "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_QOUT == 1, "Flash mode enum values must match table indices");
+static_assert(FM_DIO == 2, "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) {
-  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");
-  }
+  return ResetReasonStrings::get_log_str(static_cast<uint8_t>(reason), ResetReasonStrings::LAST_INDEX);
 }
 
 // Size for core version hex buffer
@@ -92,23 +104,9 @@ 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();
 
-  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");
-  }
+  const LogString *flash_mode = FlashModeStrings::get_log_str(
+      static_cast<uint8_t>(ESP.getFlashChipMode()),  // NOLINT(readability-static-accessed-through-instance)
+      FlashModeStrings::LAST_INDEX);
   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/esp32/__init__.py

@@ -135,6 +135,7 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
     "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
     "esp_driver_mcpwm",  # MCPWM driver - ESPHome doesn't use motor control PWM
+    "esp_driver_pcnt",  # PCNT driver - only needed by pulse_counter, hlw8012 components
     "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
     "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
     "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
@@ -1435,10 +1436,6 @@ async def to_code(config):
         CORE.relative_internal_path(".espressif")
     )
 
-    # Set the uv cache inside the data dir so "Clean All" clears it.
-    # Avoids persistent corrupted cache from mid-stream download failures.
-    os.environ["UV_CACHE_DIR"] = str(CORE.relative_internal_path(".uv_cache"))
-
     if conf[CONF_TYPE] == FRAMEWORK_ESP_IDF:
         cg.add_build_flag("-DUSE_ESP_IDF")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ESP_IDF")

esphome/components/esp32_hosted/__init__.py

@@ -95,9 +95,9 @@ async def to_code(config):
     framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
     os.environ["ESP_IDF_VERSION"] = f"{framework_ver.major}.{framework_ver.minor}"
     if framework_ver >= cv.Version(5, 5, 0):
-        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.2.4")
+        esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="1.3.2")
         esp32.add_idf_component(name="espressif/eppp_link", ref="1.1.4")
-        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.9.3")
+        esp32.add_idf_component(name="espressif/esp_hosted", ref="2.11.5")
     else:
         esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.13.0")
         esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")

esphome/components/esp32_rmt_led_strip/led_strip.cpp

@@ -7,22 +7,25 @@
 #include "esphome/core/log.h"
 
 #include <esp_attr.h>
+#include <esp_clk_tree.h>
 
 namespace esphome {
 namespace esp32_rmt_led_strip {
 
 static const char *const TAG = "esp32_rmt_led_strip";
 
-#ifdef USE_ESP32_VARIANT_ESP32H2
-static const uint32_t RMT_CLK_FREQ = 32000000;
-static const uint8_t RMT_CLK_DIV = 1;
-#else
-static const uint32_t RMT_CLK_FREQ = 80000000;
-static const uint8_t RMT_CLK_DIV = 2;
-#endif
-
 static const size_t RMT_SYMBOLS_PER_BYTE = 8;
 
+// Query the RMT default clock source frequency. This varies by variant:
+// APB (80MHz) on ESP32/S2/S3/C3, PLL_F80M (80MHz) on C6/P4, XTAL (32MHz) on H2.
+// Worst-case reset time is WS2811 at 300µs = 24000 ticks at 80MHz, well within
+// the 15-bit rmt_symbol_word_t duration field max of 32767.
+static uint32_t rmt_resolution_hz() {
+  uint32_t freq;
+  esp_clk_tree_src_get_freq_hz((soc_module_clk_t) RMT_CLK_SRC_DEFAULT, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &freq);
+  return freq;
+}
+
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
 static size_t IRAM_ATTR HOT encoder_callback(const void *data, size_t size, size_t symbols_written, size_t symbols_free,
                                              rmt_symbol_word_t *symbols, bool *done, void *arg) {
@@ -92,7 +95,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
   rmt_tx_channel_config_t channel;
   memset(&channel, 0, sizeof(channel));
   channel.clk_src = RMT_CLK_SRC_DEFAULT;
-  channel.resolution_hz = RMT_CLK_FREQ / RMT_CLK_DIV;
+  channel.resolution_hz = rmt_resolution_hz();
   channel.gpio_num = gpio_num_t(this->pin_);
   channel.mem_block_symbols = this->rmt_symbols_;
   channel.trans_queue_depth = 1;
@@ -137,7 +140,7 @@ void ESP32RMTLEDStripLightOutput::setup() {
 
 void ESP32RMTLEDStripLightOutput::set_led_params(uint32_t bit0_high, uint32_t bit0_low, uint32_t bit1_high,
                                                  uint32_t bit1_low, uint32_t reset_time_high, uint32_t reset_time_low) {
-  float ratio = (float) RMT_CLK_FREQ / RMT_CLK_DIV / 1e09f;
+  float ratio = (float) rmt_resolution_hz() / 1e09f;
 
   // 0-bit
   this->params_.bit0.duration0 = (uint32_t) (ratio * bit0_high);

esphome/components/hlw8012/sensor.py

@@ -94,10 +94,7 @@ CONFIG_SCHEMA = cv.Schema(
 
 async def to_code(config):
     if CORE.is_esp32:
-        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
-        # HLW8012 uses pulse_counter's PCNT storage which requires driver/pcnt.h
-        # TODO: Remove this once pulse_counter migrates to new PCNT API (driver/pulse_cnt.h)
-        include_builtin_idf_component("driver")
+        include_builtin_idf_component("esp_driver_pcnt")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)

esphome/components/http_request/http_request.h

@@ -103,6 +103,42 @@ inline bool is_success(int const status) { return status >= HTTP_STATUS_OK && st
  *   - ESP-IDF: blocking reads, 0 only returned when all content read
  *   - Arduino: non-blocking, 0 means "no data yet" or "all content read"
  *
+ * Chunked responses that complete in a reasonable time work correctly on both
+ * platforms. The limitation below applies only to *streaming* chunked
+ * responses where data arrives slowly over a long period.
+ *
+ * Streaming chunked responses are NOT supported (all platforms):
+ *   The read helpers (http_read_loop_result, http_read_fully) block the main
+ *   event loop until all response data is received. For streaming responses
+ *   where data trickles in slowly (e.g., TTS streaming via ffmpeg proxy),
+ *   this starves the event loop on both ESP-IDF and Arduino. If data arrives
+ *   just often enough to avoid the caller's timeout, the loop runs
+ *   indefinitely. If data stops entirely, ESP-IDF fails with
+ *   -ESP_ERR_HTTP_EAGAIN (transport timeout) while Arduino spins with
+ *   delay(1) until the caller's timeout fires. Supporting streaming requires
+ *   a non-blocking incremental read pattern that yields back to the event
+ *   loop between chunks. Components that need streaming should use
+ *   esp_http_client directly on a separate FreeRTOS task with
+ *   esp_http_client_is_complete_data_received() for completion detection
+ *   (see audio_reader.cpp for an example).
+ *
+ * Chunked transfer encoding - platform differences:
+ *   - ESP-IDF HttpContainer:
+ *       HttpContainerIDF overrides is_read_complete() to call
+ *       esp_http_client_is_complete_data_received(), which is the
+ *       authoritative completion check for both chunked and non-chunked
+ *       transfers. When esp_http_client_read() returns 0 for a completed
+ *       chunked response, read() returns 0 and is_read_complete() returns
+ *       true, so callers get COMPLETE from http_read_loop_result().
+ *
+ *   - Arduino HttpContainer:
+ *       Chunked responses are decoded internally (see
+ *       HttpContainerArduino::read_chunked_()). When the final chunk arrives,
+ *       is_chunked_ is cleared and content_length is set to bytes_read_.
+ *       Completion is then detected via is_read_complete(), and a subsequent
+ *       read() returns 0 to indicate "all content read" (not
+ *       HTTP_ERROR_CONNECTION_CLOSED).
+ *
  * Use the helper functions below instead of checking return values directly:
  *   - http_read_loop_result(): for manual loops with per-chunk processing
  *   - http_read_fully(): for simple "read N bytes into buffer" operations
@@ -204,9 +240,13 @@ class HttpContainer : public Parented<HttpRequestComponent> {
 
   size_t get_bytes_read() const { return this->bytes_read_; }
 
-  /// Check if all expected content has been read
-  /// For chunked responses, returns false (completion detected via read() returning error/EOF)
-  bool is_read_complete() const {
+  /// Check if all expected content has been read.
+  /// Base implementation handles non-chunked responses and status-code-based no-body checks.
+  /// Platform implementations may override for chunked completion detection:
+  ///   - ESP-IDF: overrides to call esp_http_client_is_complete_data_received() for chunked.
+  ///   - Arduino: read_chunked_() clears is_chunked_ and sets content_length on the final
+  ///     chunk, after which the base implementation detects completion.
+  virtual bool is_read_complete() const {
     // Per RFC 9112, these responses have no body:
     // - 1xx (Informational), 204 No Content, 205 Reset Content, 304 Not Modified
     if ((this->status_code >= 100 && this->status_code < 200) || this->status_code == HTTP_STATUS_NO_CONTENT ||

esphome/components/http_request/http_request_idf.cpp

@@ -218,32 +218,50 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   return container;
 }
 
+bool HttpContainerIDF::is_read_complete() const {
+  // Base class handles no-body status codes and non-chunked content_length completion
+  if (HttpContainer::is_read_complete()) {
+    return true;
+  }
+  // For chunked responses, use the authoritative ESP-IDF completion check
+  return this->is_chunked_ && esp_http_client_is_complete_data_received(this->client_);
+}
+
 // ESP-IDF HTTP read implementation (blocking mode)
 //
 // WARNING: Return values differ from BSD sockets! See http_request.h for full documentation.
 //
 // esp_http_client_read() in blocking mode returns:
 //   > 0: bytes read
-//   0: connection closed (end of stream)
+//   0: all chunked data received (is_chunk_complete true) or connection closed
+//   -ESP_ERR_HTTP_EAGAIN: transport timeout, no data available yet
 //   < 0: error
 //
 // We normalize to HttpContainer::read() contract:
 //   > 0: bytes read
-//   0: all content read (only returned when content_length is known and fully read)
+//   0: all content read (for both content_length-based and chunked completion)
 //   < 0: error/connection closed
 //
 // Note on chunked transfer encoding:
 //   esp_http_client_fetch_headers() returns 0 for chunked responses (no Content-Length header).
-//   We handle this by skipping the content_length check when content_length is 0,
-//   allowing esp_http_client_read() to handle chunked decoding internally and signal EOF
-//   by returning 0.
+//   When esp_http_client_read() returns 0 for a chunked response, is_read_complete() calls
+//   esp_http_client_is_complete_data_received() to distinguish successful completion from
+//   connection errors. Callers use http_read_loop_result() which checks is_read_complete()
+//   to return COMPLETE for successful chunked EOF.
+//
+// Streaming chunked responses are not supported (see http_request.h for details).
+// When data stops arriving, esp_http_client_read() returns -ESP_ERR_HTTP_EAGAIN
+// after its internal transport timeout (configured via timeout_ms) expires.
+// This is passed through as a negative return value, which callers treat as an error.
 int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
-  // Check if we've already read all expected content (non-chunked only)
-  // For chunked responses (content_length == 0), esp_http_client_read() handles EOF
-  if (this->is_read_complete()) {
+  // Check if we've already read all expected content (non-chunked and no-body only).
+  // Use the base class check here, NOT the override: esp_http_client_is_complete_data_received()
+  // returns true as soon as all data arrives from the network, but data may still be in
+  // the client's internal buffer waiting to be consumed by esp_http_client_read().
+  if (HttpContainer::is_read_complete()) {
     return 0;  // All content read successfully
   }
 
@@ -258,15 +276,18 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
     return read_len_or_error;
   }
 
-  // esp_http_client_read() returns 0 in two cases:
-  // 1. Known content_length: connection closed before all data received (error)
-  // 2. Chunked encoding (content_length == 0): end of stream reached (EOF)
-  // For case 1, returning HTTP_ERROR_CONNECTION_CLOSED is correct.
-  // For case 2, 0 indicates that all chunked data has already been delivered
-  // in previous successful read() calls, so treating this as a closed
-  // connection does not cause any loss of response data.
+  // esp_http_client_read() returns 0 when:
+  // - Known content_length: connection closed before all data received (error)
+  // - Chunked encoding: all chunks received (is_chunk_complete true, genuine EOF)
+  //
+  // Return 0 in both cases. Callers use http_read_loop_result() which calls
+  // is_read_complete() to distinguish these:
+  // - Chunked complete: is_read_complete() returns true (via
+  //   esp_http_client_is_complete_data_received()), caller gets COMPLETE
+  // - Non-chunked incomplete: is_read_complete() returns false, caller
+  //   eventually gets TIMEOUT (since no more data arrives)
   if (read_len_or_error == 0) {
-    return HTTP_ERROR_CONNECTION_CLOSED;
+    return 0;
   }
 
   // Negative value - error, return the actual error code for debugging

esphome/components/http_request/http_request_idf.h

@@ -16,6 +16,7 @@ class HttpContainerIDF : public HttpContainer {
   HttpContainerIDF(esp_http_client_handle_t client) : client_(client) {}
   int read(uint8_t *buf, size_t max_len) override;
   void end() override;
+  bool is_read_complete() const override;
 
   /// @brief Feeds the watchdog timer if the executing task has one attached
   void feed_wdt();

esphome/components/http_request/update/http_request_update.cpp

@@ -90,16 +90,14 @@ 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;
-  {  // 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 {
+  {  // Scope to ensure JsonDocument is destroyed before deallocating buffer
+    valid = json::parse_json(data, read_index, [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");
@@ -137,6 +135,7 @@ 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());
@@ -157,17 +156,12 @@ 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
-    current_version = ESPHOME_PROJECT_VERSION;
+  this_update->update_info_.current_version = ESPHOME_PROJECT_VERSION;
 #else
-    current_version = ESPHOME_VERSION;
+  this_update->update_info_.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/json/json_util.cpp

@@ -25,8 +25,13 @@ std::string 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(reinterpret_cast<const uint8_t *>(data.c_str()), data.size());
+  JsonDocument doc = parse_json(data, len);
   if (doc.overflowed() || doc.isNull())
     return false;
   return f(doc.as<JsonObject>());

esphome/components/json/json_util.h

@@ -50,6 +50,8 @@ 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);

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, 11, 0), "https://github.com/libretiny-eu/libretiny.git"),
+    "dev": (cv.Version(1, 12, 1), "https://github.com/libretiny-eu/libretiny.git"),
     "latest": (
-        cv.Version(1, 11, 0),
-        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
+        cv.Version(1, 12, 1),
+        "https://github.com/libretiny-eu/libretiny.git#v1.12.1",
     ),
     "recommended": (
-        cv.Version(1, 11, 0),
-        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
+        cv.Version(1, 12, 1),
+        "https://github.com/libretiny-eu/libretiny.git#v1.12.1",
     ),
 }
 

esphome/components/light/light_call.cpp

@@ -270,22 +270,23 @@ LightColorValues LightCall::validate_() {
   if (this->has_state())
     v.set_state(this->state_);
 
-#define VALIDATE_AND_APPLY(field, setter, name_str, ...) \
+    // clamp_and_log_if_invalid already clamps in-place, so assign directly
+    // to avoid redundant clamp code from the setter being inlined.
+#define VALIDATE_AND_APPLY(field, name_str, ...) \
   if (this->has_##field()) { \
     clamp_and_log_if_invalid(name, this->field##_, LOG_STR(name_str), ##__VA_ARGS__); \
-    v.setter(this->field##_); \
+    v.field##_ = this->field##_; \
   }
 
-  VALIDATE_AND_APPLY(brightness, set_brightness, "Brightness")
-  VALIDATE_AND_APPLY(color_brightness, set_color_brightness, "Color brightness")
-  VALIDATE_AND_APPLY(red, set_red, "Red")
-  VALIDATE_AND_APPLY(green, set_green, "Green")
-  VALIDATE_AND_APPLY(blue, set_blue, "Blue")
-  VALIDATE_AND_APPLY(white, set_white, "White")
-  VALIDATE_AND_APPLY(cold_white, set_cold_white, "Cold white")
-  VALIDATE_AND_APPLY(warm_white, set_warm_white, "Warm white")
-  VALIDATE_AND_APPLY(color_temperature, set_color_temperature, "Color temperature", traits.get_min_mireds(),
-                     traits.get_max_mireds())
+  VALIDATE_AND_APPLY(brightness, "Brightness")
+  VALIDATE_AND_APPLY(color_brightness, "Color brightness")
+  VALIDATE_AND_APPLY(red, "Red")
+  VALIDATE_AND_APPLY(green, "Green")
+  VALIDATE_AND_APPLY(blue, "Blue")
+  VALIDATE_AND_APPLY(white, "White")
+  VALIDATE_AND_APPLY(cold_white, "Cold white")
+  VALIDATE_AND_APPLY(warm_white, "Warm white")
+  VALIDATE_AND_APPLY(color_temperature, "Color temperature", traits.get_min_mireds(), traits.get_max_mireds())
 
 #undef VALIDATE_AND_APPLY
 

esphome/components/light/light_color_values.h

@@ -95,15 +95,18 @@ class LightColorValues {
    */
   void normalize_color() {
     if (this->color_mode_ & ColorCapability::RGB) {
-      float max_value = fmaxf(this->get_red(), fmaxf(this->get_green(), this->get_blue()));
+      float max_value = fmaxf(this->red_, fmaxf(this->green_, this->blue_));
+      // Assign directly to avoid redundant clamp in set_red/green/blue.
+      // Values are guaranteed in [0,1]: inputs are already clamped to [0,1],
+      // and dividing by max_value (the largest) keeps results in [0,1].
       if (max_value == 0.0f) {
-        this->set_red(1.0f);
-        this->set_green(1.0f);
-        this->set_blue(1.0f);
+        this->red_ = 1.0f;
+        this->green_ = 1.0f;
+        this->blue_ = 1.0f;
       } else {
-        this->set_red(this->get_red() / max_value);
-        this->set_green(this->get_green() / max_value);
-        this->set_blue(this->get_blue() / max_value);
+        this->red_ /= max_value;
+        this->green_ /= max_value;
+        this->blue_ /= max_value;
       }
     }
   }
@@ -276,6 +279,8 @@ class LightColorValues {
   /// Set the warm white property of these light color values. In range 0.0 to 1.0.
   void set_warm_white(float warm_white) { this->warm_white_ = clamp(warm_white, 0.0f, 1.0f); }
 
+  friend class LightCall;
+
  protected:
   float state_;  ///< ON / OFF, float for transition
   float brightness_;

esphome/components/ln882x/boards.py

@@ -154,28 +154,26 @@ LN882X_BOARD_PINS = {
         "A7": 21,
     },
     "wb02a": {
-        "WIRE0_SCL_0": 7,
-        "WIRE0_SCL_1": 5,
+        "WIRE0_SCL_0": 1,
+        "WIRE0_SCL_1": 2,
         "WIRE0_SCL_2": 3,
-        "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_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_SDA_2": 3,
-        "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,
+        "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,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,
@@ -221,32 +219,32 @@ LN882X_BOARD_PINS = {
         "A1": 4,
     },
     "wl2s": {
-        "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,
+        "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,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,
@@ -301,24 +299,24 @@ LN882X_BOARD_PINS = {
         "A2": 1,
     },
     "ln-02": {
-        "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,
+        "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,
         "SERIAL0_RX": 3,
         "SERIAL0_TX": 2,
         "SERIAL1_RX": 24,

esphome/components/mdns/mdns_component.h

@@ -45,9 +45,28 @@ class MDNSComponent : public Component {
   void setup() override;
   void dump_config() override;
 
-#if (defined(USE_ESP8266) || defined(USE_RP2040)) && defined(USE_ARDUINO)
-  void loop() override;
-#endif
+  // Polling interval for MDNS.update() on platforms that require it (ESP8266, RP2040).
+  //
+  // On these platforms, MDNS.update() calls _process(true) which only manages timer-driven
+  // state machines (probe/announce timeouts and service query cache TTLs). Incoming mDNS
+  // packets are handled independently via the lwIP onRx UDP callback and are NOT affected
+  // by how often update() is called.
+  //
+  // The shortest internal timer is the 250ms probe interval (RFC 6762 Section 8.1).
+  // Announcement intervals are 1000ms and cache TTL checks are on the order of seconds
+  // to minutes. A 50ms polling interval provides sufficient resolution for all timers
+  // while completely removing mDNS from the per-iteration loop list.
+  //
+  // In steady state (after the ~8 second boot probe/announce phase completes), update()
+  // checks timers that are set to never expire, making every call pure overhead.
+  //
+  // Tasmota uses a 50ms main loop cycle with mDNS working correctly, confirming this
+  // interval is safe in production.
+  //
+  // By using set_interval() instead of overriding loop(), the component is excluded from
+  // the main loop list via has_overridden_loop(), eliminating all per-iteration overhead
+  // including virtual dispatch.
+  static constexpr uint32_t MDNS_UPDATE_INTERVAL_MS = 50;
   float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
 #ifdef USE_MDNS_EXTRA_SERVICES

esphome/components/mdns/mdns_esp8266.cpp

@@ -36,9 +36,14 @@ static void register_esp8266(MDNSComponent *, StaticVector<MDNSService, MDNS_SER
   }
 }
 
-void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp8266); }
-
-void MDNSComponent::loop() { MDNS.update(); }
+void MDNSComponent::setup() {
+  this->setup_buffers_and_register_(register_esp8266);
+  // Schedule MDNS.update() via set_interval() instead of overriding loop().
+  // This removes the component from the per-iteration loop list entirely,
+  // eliminating virtual dispatch overhead on every main loop cycle.
+  // See MDNS_UPDATE_INTERVAL_MS comment in mdns_component.h for safety analysis.
+  this->set_interval(MDNS_UPDATE_INTERVAL_MS, []() { MDNS.update(); });
+}
 
 void MDNSComponent::on_shutdown() {
   MDNS.close();

esphome/components/mdns/mdns_rp2040.cpp

@@ -35,9 +35,14 @@ static void register_rp2040(MDNSComponent *, StaticVector<MDNSService, MDNS_SERV
   }
 }
 
-void MDNSComponent::setup() { this->setup_buffers_and_register_(register_rp2040); }
-
-void MDNSComponent::loop() { MDNS.update(); }
+void MDNSComponent::setup() {
+  this->setup_buffers_and_register_(register_rp2040);
+  // Schedule MDNS.update() via set_interval() instead of overriding loop().
+  // This removes the component from the per-iteration loop list entirely,
+  // eliminating virtual dispatch overhead on every main loop cycle.
+  // See MDNS_UPDATE_INTERVAL_MS comment in mdns_component.h for safety analysis.
+  this->set_interval(MDNS_UPDATE_INTERVAL_MS, []() { MDNS.update(); });
+}
 
 void MDNSComponent::on_shutdown() {
   MDNS.close();

esphome/components/mqtt/mqtt_client.cpp

@@ -170,10 +170,8 @@ 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({.topic = this->log_message_.topic,
-                   .payload = std::string(message, message_len),
-                   .qos = this->log_message_.qos,
-                   .retain = this->log_message_.retain});
+    this->publish(this->log_message_.topic.c_str(), message, message_len, this->log_message_.qos,
+                  this->log_message_.retain);
   }
 }
 #endif

esphome/components/mqtt/mqtt_climate.cpp

@@ -300,9 +300,11 @@ 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(), climate_mode_to_mqtt_str(this->device_->mode)))
+  if (!this->publish(this->get_mode_state_topic_to(topic_buf), 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();
@@ -311,68 +313,70 @@ 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(), payload, len))
+    if (!this->publish(this->get_current_temperature_state_topic_to(topic_buf), 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(), payload, len))
+    if (!this->publish(this->get_target_temperature_low_state_topic_to(topic_buf), 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(), payload, len))
+    if (!this->publish(this->get_target_temperature_high_state_topic_to(topic_buf), 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(), payload, len))
+    if (!this->publish(this->get_target_temperature_state_topic_to(topic_buf), 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(), payload, len))
+    if (!this->publish(this->get_current_humidity_state_topic_to(topic_buf), 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(), payload, len))
+    if (!this->publish(this->get_target_humidity_state_topic_to(topic_buf), 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(), this->device_->get_custom_preset()))
+      if (!this->publish(this->get_preset_state_topic_to(topic_buf), this->device_->get_custom_preset().c_str()))
         success = false;
     } else if (this->device_->preset.has_value()) {
-      if (!this->publish(this->get_preset_state_topic(), climate_preset_to_mqtt_str(this->device_->preset.value())))
+      if (!this->publish(this->get_preset_state_topic_to(topic_buf),
+                         climate_preset_to_mqtt_str(this->device_->preset.value())))
         success = false;
-    } else if (!this->publish(this->get_preset_state_topic(), "")) {
+    } else if (!this->publish(this->get_preset_state_topic_to(topic_buf), "")) {
       success = false;
     }
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    if (!this->publish(this->get_action_state_topic(), climate_action_to_mqtt_str(this->device_->action)))
+    if (!this->publish(this->get_action_state_topic_to(topic_buf), 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(), this->device_->get_custom_fan_mode()))
+      if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf), this->device_->get_custom_fan_mode().c_str()))
         success = false;
     } else if (this->device_->fan_mode.has_value()) {
-      if (!this->publish(this->get_fan_mode_state_topic(),
+      if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf),
                          climate_fan_mode_to_mqtt_str(this->device_->fan_mode.value())))
         success = false;
-    } else if (!this->publish(this->get_fan_mode_state_topic(), "")) {
+    } else if (!this->publish(this->get_fan_mode_state_topic_to(topic_buf), "")) {
       success = false;
     }
   }
 
   if (traits.get_supports_swing_modes()) {
-    if (!this->publish(this->get_swing_mode_state_topic(), climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
+    if (!this->publish(this->get_swing_mode_state_topic_to(topic_buf),
+                       climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
       success = false;
   }
 

esphome/components/mqtt/mqtt_component.h

@@ -59,6 +59,11 @@ 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(), pos, len))
+    if (!this->publish(this->get_position_state_topic_to(topic_buf), 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(), pos, len))
+    if (!this->publish(this->get_tilt_state_topic_to(topic_buf), 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,19 +173,20 @@ 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(), fan_direction_to_mqtt_str(this->state_->direction));
+    bool success = this->publish(this->get_direction_state_topic_to(topic_buf),
+                                 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(), fan_oscillation_to_mqtt_str(this->state_->oscillating));
+    bool success = this->publish(this->get_oscillation_state_topic_to(topic_buf),
+                                 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(), buf, len);
+    bool success = this->publish(this->get_speed_level_state_topic_to(topic_buf), 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(), pos, len))
+    if (!this->publish(this->get_position_state_topic_to(topic_buf), 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/pulse_counter/pulse_counter_sensor.cpp

@@ -1,6 +1,11 @@
 #include "pulse_counter_sensor.h"
 #include "esphome/core/log.h"
 
+#ifdef HAS_PCNT
+#include <esp_clk_tree.h>
+#include <hal/pcnt_ll.h>
+#endif
+
 namespace esphome {
 namespace pulse_counter {
 
@@ -56,103 +61,109 @@ pulse_counter_t BasicPulseCounterStorage::read_raw_value() {
 
 #ifdef HAS_PCNT
 bool HwPulseCounterStorage::pulse_counter_setup(InternalGPIOPin *pin) {
-  static pcnt_unit_t next_pcnt_unit = PCNT_UNIT_0;
-  static pcnt_channel_t next_pcnt_channel = PCNT_CHANNEL_0;
   this->pin = pin;
   this->pin->setup();
-  this->pcnt_unit = next_pcnt_unit;
-  this->pcnt_channel = next_pcnt_channel;
-  next_pcnt_unit = pcnt_unit_t(int(next_pcnt_unit) + 1);
-  if (int(next_pcnt_unit) >= PCNT_UNIT_0 + PCNT_UNIT_MAX) {
-    next_pcnt_unit = PCNT_UNIT_0;
-    next_pcnt_channel = pcnt_channel_t(int(next_pcnt_channel) + 1);
+
+  pcnt_unit_config_t unit_config = {
+      .low_limit = INT16_MIN,
+      .high_limit = INT16_MAX,
+      .flags = {.accum_count = true},
+  };
+  esp_err_t error = pcnt_new_unit(&unit_config, &this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Creating PCNT unit failed: %s", esp_err_to_name(error));
+    return false;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "    PCNT Unit Number: %u\n"
-                "    PCNT Channel Number: %u",
-                this->pcnt_unit, this->pcnt_channel);
+  pcnt_chan_config_t chan_config = {
+      .edge_gpio_num = this->pin->get_pin(),
+      .level_gpio_num = -1,
+  };
+  error = pcnt_new_channel(this->pcnt_unit, &chan_config, &this->pcnt_channel);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Creating PCNT channel failed: %s", esp_err_to_name(error));
+    return false;
+  }
 
-  pcnt_count_mode_t rising = PCNT_COUNT_DIS, falling = PCNT_COUNT_DIS;
+  pcnt_channel_edge_action_t rising = PCNT_CHANNEL_EDGE_ACTION_HOLD;
+  pcnt_channel_edge_action_t falling = PCNT_CHANNEL_EDGE_ACTION_HOLD;
   switch (this->rising_edge_mode) {
     case PULSE_COUNTER_DISABLE:
-      rising = PCNT_COUNT_DIS;
+      rising = PCNT_CHANNEL_EDGE_ACTION_HOLD;
       break;
     case PULSE_COUNTER_INCREMENT:
-      rising = PCNT_COUNT_INC;
+      rising = PCNT_CHANNEL_EDGE_ACTION_INCREASE;
       break;
     case PULSE_COUNTER_DECREMENT:
-      rising = PCNT_COUNT_DEC;
+      rising = PCNT_CHANNEL_EDGE_ACTION_DECREASE;
       break;
   }
   switch (this->falling_edge_mode) {
     case PULSE_COUNTER_DISABLE:
-      falling = PCNT_COUNT_DIS;
+      falling = PCNT_CHANNEL_EDGE_ACTION_HOLD;
       break;
     case PULSE_COUNTER_INCREMENT:
-      falling = PCNT_COUNT_INC;
+      falling = PCNT_CHANNEL_EDGE_ACTION_INCREASE;
       break;
     case PULSE_COUNTER_DECREMENT:
-      falling = PCNT_COUNT_DEC;
+      falling = PCNT_CHANNEL_EDGE_ACTION_DECREASE;
       break;
   }
 
-  pcnt_config_t pcnt_config = {
-      .pulse_gpio_num = this->pin->get_pin(),
-      .ctrl_gpio_num = PCNT_PIN_NOT_USED,
-      .lctrl_mode = PCNT_MODE_KEEP,
-      .hctrl_mode = PCNT_MODE_KEEP,
-      .pos_mode = rising,
-      .neg_mode = falling,
-      .counter_h_lim = 0,
-      .counter_l_lim = 0,
-      .unit = this->pcnt_unit,
-      .channel = this->pcnt_channel,
-  };
-  esp_err_t error = pcnt_unit_config(&pcnt_config);
+  error = pcnt_channel_set_edge_action(this->pcnt_channel, rising, falling);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Configuring Pulse Counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Setting PCNT edge action failed: %s", esp_err_to_name(error));
     return false;
   }
 
   if (this->filter_us != 0) {
-    uint16_t filter_val = std::min(static_cast<unsigned int>(this->filter_us * 80u), 1023u);
-    ESP_LOGCONFIG(TAG, "    Filter Value: %" PRIu32 "us (val=%u)", this->filter_us, filter_val);
-    error = pcnt_set_filter_value(this->pcnt_unit, filter_val);
+    uint32_t apb_freq;
+    esp_clk_tree_src_get_freq_hz(SOC_MOD_CLK_APB, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &apb_freq);
+    uint32_t max_glitch_ns = PCNT_LL_MAX_GLITCH_WIDTH * 1000000u / apb_freq;
+    pcnt_glitch_filter_config_t filter_config = {
+        .max_glitch_ns = std::min(this->filter_us * 1000u, max_glitch_ns),
+    };
+    error = pcnt_unit_set_glitch_filter(this->pcnt_unit, &filter_config);
     if (error != ESP_OK) {
-      ESP_LOGE(TAG, "Setting filter value failed: %s", esp_err_to_name(error));
-      return false;
-    }
-    error = pcnt_filter_enable(this->pcnt_unit);
-    if (error != ESP_OK) {
-      ESP_LOGE(TAG, "Enabling filter failed: %s", esp_err_to_name(error));
+      ESP_LOGE(TAG, "Setting PCNT glitch filter failed: %s", esp_err_to_name(error));
       return false;
     }
   }
 
-  error = pcnt_counter_pause(this->pcnt_unit);
+  error = pcnt_unit_add_watch_point(this->pcnt_unit, INT16_MIN);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Pausing pulse counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Adding PCNT low limit watch point failed: %s", esp_err_to_name(error));
     return false;
   }
-  error = pcnt_counter_clear(this->pcnt_unit);
+  error = pcnt_unit_add_watch_point(this->pcnt_unit, INT16_MAX);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Clearing pulse counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Adding PCNT high limit watch point failed: %s", esp_err_to_name(error));
     return false;
   }
-  error = pcnt_counter_resume(this->pcnt_unit);
+
+  error = pcnt_unit_enable(this->pcnt_unit);
   if (error != ESP_OK) {
-    ESP_LOGE(TAG, "Resuming pulse counter failed: %s", esp_err_to_name(error));
+    ESP_LOGE(TAG, "Enabling PCNT unit failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  error = pcnt_unit_clear_count(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Clearing PCNT unit failed: %s", esp_err_to_name(error));
+    return false;
+  }
+  error = pcnt_unit_start(this->pcnt_unit);
+  if (error != ESP_OK) {
+    ESP_LOGE(TAG, "Starting PCNT unit failed: %s", esp_err_to_name(error));
     return false;
   }
   return true;
 }
 
 pulse_counter_t HwPulseCounterStorage::read_raw_value() {
-  pulse_counter_t counter;
-  pcnt_get_counter_value(this->pcnt_unit, &counter);
-  pulse_counter_t ret = counter - this->last_value;
-  this->last_value = counter;
+  int count;
+  pcnt_unit_get_count(this->pcnt_unit, &count);
+  pulse_counter_t ret = count - this->last_value;
+  this->last_value = count;
   return ret;
 }
 #endif  // HAS_PCNT

esphome/components/pulse_counter/pulse_counter_sensor.h

@@ -6,14 +6,13 @@
 
 #include <cinttypes>
 
-// TODO: Migrate from legacy PCNT API (driver/pcnt.h) to new PCNT API (driver/pulse_cnt.h)
-// The legacy PCNT API is deprecated in ESP-IDF 5.x. Migration would allow removing the
-// "driver" IDF component dependency. See:
-// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/peripherals.html#id6
-#if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
-#include <driver/pcnt.h>
+#if defined(USE_ESP32)
+#include <soc/soc_caps.h>
+#ifdef SOC_PCNT_SUPPORTED
+#include <driver/pulse_cnt.h>
 #define HAS_PCNT
-#endif  // defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
+#endif  // SOC_PCNT_SUPPORTED
+#endif  // USE_ESP32
 
 namespace esphome {
 namespace pulse_counter {
@@ -24,11 +23,7 @@ enum PulseCounterCountMode {
   PULSE_COUNTER_DECREMENT,
 };
 
-#ifdef HAS_PCNT
-using pulse_counter_t = int16_t;
-#else   // HAS_PCNT
 using pulse_counter_t = int32_t;
-#endif  // HAS_PCNT
 
 struct PulseCounterStorageBase {
   virtual bool pulse_counter_setup(InternalGPIOPin *pin) = 0;
@@ -58,8 +53,8 @@ struct HwPulseCounterStorage : public PulseCounterStorageBase {
   bool pulse_counter_setup(InternalGPIOPin *pin) override;
   pulse_counter_t read_raw_value() override;
 
-  pcnt_unit_t pcnt_unit;
-  pcnt_channel_t pcnt_channel;
+  pcnt_unit_handle_t pcnt_unit{nullptr};
+  pcnt_channel_handle_t pcnt_channel{nullptr};
 };
 #endif  // HAS_PCNT
 

esphome/components/pulse_counter/sensor.py

@@ -129,10 +129,7 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     use_pcnt = config.get(CONF_USE_PCNT)
     if CORE.is_esp32 and use_pcnt:
-        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
-        # Provides driver/pcnt.h header for hardware pulse counter API
-        # TODO: Remove this once pulse_counter migrates to new PCNT API (driver/pulse_cnt.h)
-        include_builtin_idf_component("driver")
+        include_builtin_idf_component("esp_driver_pcnt")
 
     var = await sensor.new_sensor(config, use_pcnt)
     await cg.register_component(var, config)

esphome/components/remote_receiver/remote_receiver_esp32.cpp

@@ -3,15 +3,11 @@
 
 #ifdef USE_ESP32
 #include <driver/gpio.h>
+#include <esp_clk_tree.h>
 
 namespace esphome::remote_receiver {
 
 static const char *const TAG = "remote_receiver.esp32";
-#ifdef USE_ESP32_VARIANT_ESP32H2
-static const uint32_t RMT_CLK_FREQ = 32000000;
-#else
-static const uint32_t RMT_CLK_FREQ = 80000000;
-#endif
 
 static bool IRAM_ATTR HOT rmt_callback(rmt_channel_handle_t channel, const rmt_rx_done_event_data_t *event, void *arg) {
   RemoteReceiverComponentStore *store = (RemoteReceiverComponentStore *) arg;
@@ -98,7 +94,10 @@ void RemoteReceiverComponent::setup() {
   }
 
   uint32_t event_size = sizeof(rmt_rx_done_event_data_t);
-  uint32_t max_filter_ns = 255u * 1000 / (RMT_CLK_FREQ / 1000000);
+  uint32_t rmt_freq;
+  esp_clk_tree_src_get_freq_hz((soc_module_clk_t) RMT_CLK_SRC_DEFAULT, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED,
+                               &rmt_freq);
+  uint32_t max_filter_ns = UINT8_MAX * 1000u / (rmt_freq / 1000000);
   memset(&this->store_.config, 0, sizeof(this->store_.config));
   this->store_.config.signal_range_min_ns = std::min(this->filter_us_ * 1000, max_filter_ns);
   this->store_.config.signal_range_max_ns = this->idle_us_ * 1000;

esphome/components/resampler/speaker/__init__.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import audio, esp32, speaker
+from esphome.components import audio, esp32, socket, speaker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BITS_PER_SAMPLE,
@@ -34,7 +34,7 @@ def _set_stream_limits(config):
     return config
 
 
-def _validate_audio_compatability(config):
+def _validate_audio_compatibility(config):
     inherit_property_from(CONF_BITS_PER_SAMPLE, CONF_OUTPUT_SPEAKER)(config)
     inherit_property_from(CONF_NUM_CHANNELS, CONF_OUTPUT_SPEAKER)(config)
     inherit_property_from(CONF_SAMPLE_RATE, CONF_OUTPUT_SPEAKER)(config)
@@ -73,10 +73,13 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-FINAL_VALIDATE_SCHEMA = _validate_audio_compatability
+FINAL_VALIDATE_SCHEMA = _validate_audio_compatibility
 
 
 async def to_code(config):
+    # Enable wake_loop_threadsafe for immediate command processing from other tasks
+    socket.require_wake_loop_threadsafe()
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await speaker.register_speaker(var, config)
@@ -86,12 +89,11 @@ async def to_code(config):
 
     cg.add(var.set_buffer_duration(config[CONF_BUFFER_DURATION]))
 
-    if task_stack_in_psram := config.get(CONF_TASK_STACK_IN_PSRAM):
-        cg.add(var.set_task_stack_in_psram(task_stack_in_psram))
-        if task_stack_in_psram and config[CONF_TASK_STACK_IN_PSRAM]:
-            esp32.add_idf_sdkconfig_option(
-                "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
-            )
+    if config.get(CONF_TASK_STACK_IN_PSRAM):
+        cg.add(var.set_task_stack_in_psram(True))
+        esp32.add_idf_sdkconfig_option(
+            "CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY", True
+        )
 
     cg.add(var.set_target_bits_per_sample(config[CONF_BITS_PER_SAMPLE]))
     cg.add(var.set_target_sample_rate(config[CONF_SAMPLE_RATE]))

esphome/components/resampler/speaker/resampler_speaker.cpp

@@ -4,6 +4,8 @@
 
 #include "esphome/components/audio/audio_resampler.h"
 
+#include "esphome/core/application.h"
+#include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
@@ -17,13 +19,17 @@ static const UBaseType_t RESAMPLER_TASK_PRIORITY = 1;
 
 static const uint32_t TRANSFER_BUFFER_DURATION_MS = 50;
 
-static const uint32_t TASK_DELAY_MS = 20;
 static const uint32_t TASK_STACK_SIZE = 3072;
 
+static const uint32_t STATE_TRANSITION_TIMEOUT_MS = 5000;
+
 static const char *const TAG = "resampler_speaker";
 
 enum ResamplingEventGroupBits : uint32_t {
-  COMMAND_STOP = (1 << 0),  // stops the resampler task
+  COMMAND_STOP = (1 << 0),       // signals stop request
+  COMMAND_START = (1 << 1),      // signals start request
+  COMMAND_FINISH = (1 << 2),     // signals finish request (graceful stop)
+  TASK_COMMAND_STOP = (1 << 5),  // signals the task to stop
   STATE_STARTING = (1 << 10),
   STATE_RUNNING = (1 << 11),
   STATE_STOPPING = (1 << 12),
@@ -34,9 +40,16 @@ enum ResamplingEventGroupBits : uint32_t {
   ALL_BITS = 0x00FFFFFF,  // All valid FreeRTOS event group bits
 };
 
+void ResamplerSpeaker::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Resampler Speaker:\n"
+                "  Target Bits Per Sample: %u\n"
+                "  Target Sample Rate: %" PRIu32 " Hz",
+                this->target_bits_per_sample_, this->target_sample_rate_);
+}
+
 void ResamplerSpeaker::setup() {
   this->event_group_ = xEventGroupCreate();
-
   if (this->event_group_ == nullptr) {
     ESP_LOGE(TAG, "Failed to create event group");
     this->mark_failed();
@@ -55,81 +68,155 @@ void ResamplerSpeaker::setup() {
       this->audio_output_callback_(new_frames, write_timestamp);
     }
   });
+
+  // Start with loop disabled since no task is running and no commands are pending
+  this->disable_loop();
 }
 
 void ResamplerSpeaker::loop() {
   uint32_t event_group_bits = xEventGroupGetBits(this->event_group_);
 
+  // Process commands with priority: STOP > FINISH > START
+  // This ensures stop commands take precedence over conflicting start commands
+  if (event_group_bits & ResamplingEventGroupBits::COMMAND_STOP) {
+    if (this->state_ == speaker::STATE_RUNNING || this->state_ == speaker::STATE_STARTING) {
+      // Clear STOP, START, and FINISH bits - stop takes precedence
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_STOP |
+                                                   ResamplingEventGroupBits::COMMAND_START |
+                                                   ResamplingEventGroupBits::COMMAND_FINISH);
+      this->waiting_for_output_ = false;
+      this->enter_stopping_state_();
+    } else if (this->state_ == speaker::STATE_STOPPED) {
+      // Already stopped, just clear the command bits
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_STOP |
+                                                   ResamplingEventGroupBits::COMMAND_START |
+                                                   ResamplingEventGroupBits::COMMAND_FINISH);
+    }
+    // Leave bits set if STATE_STOPPING - will be processed once stopped
+  } else if (event_group_bits & ResamplingEventGroupBits::COMMAND_FINISH) {
+    if (this->state_ == speaker::STATE_RUNNING) {
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_FINISH);
+      this->output_speaker_->finish();
+    } else if (this->state_ == speaker::STATE_STOPPED) {
+      // Already stopped, just clear the command bit
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_FINISH);
+    }
+    // Leave bit set if transitioning states - will be processed once state allows
+  } else if (event_group_bits & ResamplingEventGroupBits::COMMAND_START) {
+    if (this->state_ == speaker::STATE_STOPPED) {
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_START);
+      this->state_ = speaker::STATE_STARTING;
+    } else if (this->state_ == speaker::STATE_RUNNING) {
+      // Already running, just clear the command bit
+      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::COMMAND_START);
+    }
+    // Leave bit set if transitioning states - will be processed once state allows
+  }
+
+  // Re-read bits after command processing (enter_stopping_state_ may have set task bits)
+  event_group_bits = xEventGroupGetBits(this->event_group_);
+
   if (event_group_bits & ResamplingEventGroupBits::STATE_STARTING) {
-    ESP_LOGD(TAG, "Starting resampler task");
+    ESP_LOGD(TAG, "Starting");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STARTING);
   }
 
   if (event_group_bits & ResamplingEventGroupBits::ERR_ESP_NO_MEM) {
-    this->status_set_error(LOG_STR("Resampler task failed to allocate the internal buffers"));
+    this->status_set_error(LOG_STR("Not enough memory"));
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ERR_ESP_NO_MEM);
-    this->state_ = speaker::STATE_STOPPING;
+    this->enter_stopping_state_();
   }
   if (event_group_bits & ResamplingEventGroupBits::ERR_ESP_NOT_SUPPORTED) {
-    this->status_set_error(LOG_STR("Cannot resample due to an unsupported audio stream"));
+    this->status_set_error(LOG_STR("Unsupported stream"));
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ERR_ESP_NOT_SUPPORTED);
-    this->state_ = speaker::STATE_STOPPING;
+    this->enter_stopping_state_();
   }
   if (event_group_bits & ResamplingEventGroupBits::ERR_ESP_FAIL) {
-    this->status_set_error(LOG_STR("Resampler task failed"));
+    this->status_set_error(LOG_STR("Resampler failure"));
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ERR_ESP_FAIL);
-    this->state_ = speaker::STATE_STOPPING;
+    this->enter_stopping_state_();
   }
 
   if (event_group_bits & ResamplingEventGroupBits::STATE_RUNNING) {
-    ESP_LOGD(TAG, "Started resampler task");
+    ESP_LOGV(TAG, "Started");
     this->status_clear_error();
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_RUNNING);
   }
   if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPING) {
-    ESP_LOGD(TAG, "Stopping resampler task");
+    ESP_LOGV(TAG, "Stopping");
     xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
   }
   if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
-    if (this->delete_task_() == ESP_OK) {
-      ESP_LOGD(TAG, "Stopped resampler task");
-      xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
-    }
+    this->delete_task_();
+    ESP_LOGD(TAG, "Stopped");
+    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
   }
 
   switch (this->state_) {
     case speaker::STATE_STARTING: {
-      esp_err_t err = this->start_();
-      if (err == ESP_OK) {
-        this->status_clear_error();
-        this->state_ = speaker::STATE_RUNNING;
-      } else {
-        switch (err) {
-          case ESP_ERR_INVALID_STATE:
-            this->status_set_error(LOG_STR("Failed to start resampler: resampler task failed to start"));
-            break;
-          case ESP_ERR_NO_MEM:
-            this->status_set_error(LOG_STR("Failed to start resampler: not enough memory for task stack"));
-          default:
-            this->status_set_error(LOG_STR("Failed to start resampler"));
-            break;
+      if (!this->waiting_for_output_) {
+        esp_err_t err = this->start_();
+        if (err == ESP_OK) {
+          this->callback_remainder_ = 0;  // reset callback remainder
+          this->status_clear_error();
+          this->waiting_for_output_ = true;
+          this->state_start_ms_ = App.get_loop_component_start_time();
+        } else {
+          this->set_start_error_(err);
+          this->waiting_for_output_ = false;
+          this->enter_stopping_state_();
+        }
+      } else {
+        if (this->output_speaker_->is_running()) {
+          this->state_ = speaker::STATE_RUNNING;
+          this->waiting_for_output_ = false;
+        } else if ((App.get_loop_component_start_time() - this->state_start_ms_) > STATE_TRANSITION_TIMEOUT_MS) {
+          // Timed out waiting for the output speaker to start
+          this->waiting_for_output_ = false;
+          this->enter_stopping_state_();
         }
-
-        this->state_ = speaker::STATE_STOPPING;
       }
       break;
     }
     case speaker::STATE_RUNNING:
       if (this->output_speaker_->is_stopped()) {
-        this->state_ = speaker::STATE_STOPPING;
+        this->enter_stopping_state_();
+      }
+      break;
+    case speaker::STATE_STOPPING: {
+      if ((this->output_speaker_->get_pause_state()) ||
+          ((App.get_loop_component_start_time() - this->state_start_ms_) > STATE_TRANSITION_TIMEOUT_MS)) {
+        // If output speaker is paused or stopping timeout exceeded, force stop
+        this->output_speaker_->stop();
       }
 
+      if (this->output_speaker_->is_stopped() && (this->task_handle_ == nullptr)) {
+        // Only transition to stopped state once the output speaker and resampler task are fully stopped
+        this->waiting_for_output_ = false;
+        this->state_ = speaker::STATE_STOPPED;
+      }
       break;
-    case speaker::STATE_STOPPING:
-      this->stop_();
-      this->state_ = speaker::STATE_STOPPED;
-      break;
+    }
     case speaker::STATE_STOPPED:
+      event_group_bits = xEventGroupGetBits(this->event_group_);
+      if (event_group_bits == 0) {
+        // No pending events, disable loop to save CPU cycles
+        this->disable_loop();
+      }
+      break;
+  }
+}
+
+void ResamplerSpeaker::set_start_error_(esp_err_t err) {
+  switch (err) {
+    case ESP_ERR_INVALID_STATE:
+      this->status_set_error(LOG_STR("Task failed to start"));
+      break;
+    case ESP_ERR_NO_MEM:
+      this->status_set_error(LOG_STR("Not enough memory"));
+      break;
+    default:
+      this->status_set_error(LOG_STR("Failed to start"));
       break;
   }
 }
@@ -143,16 +230,33 @@ size_t ResamplerSpeaker::play(const uint8_t *data, size_t length, TickType_t tic
   if ((this->output_speaker_->is_running()) && (!this->requires_resampling_())) {
     bytes_written = this->output_speaker_->play(data, length, ticks_to_wait);
   } else {
-    if (this->ring_buffer_.use_count() == 1) {
-      std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    if (temp_ring_buffer) {
+      // Only write to the ring buffer if the reference is valid
       bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
+    } else {
+      // Delay to avoid repeatedly hammering while waiting for the speaker to start
+      vTaskDelay(ticks_to_wait);
     }
   }
 
   return bytes_written;
 }
 
-void ResamplerSpeaker::start() { this->state_ = speaker::STATE_STARTING; }
+void ResamplerSpeaker::send_command_(uint32_t command_bit, bool wake_loop) {
+  this->enable_loop_soon_any_context();
+  uint32_t event_bits = xEventGroupGetBits(this->event_group_);
+  if (!(event_bits & command_bit)) {
+    xEventGroupSetBits(this->event_group_, command_bit);
+#if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
+    if (wake_loop) {
+      App.wake_loop_threadsafe();
+    }
+#endif
+  }
+}
+
+void ResamplerSpeaker::start() { this->send_command_(ResamplingEventGroupBits::COMMAND_START, true); }
 
 esp_err_t ResamplerSpeaker::start_() {
   this->target_stream_info_ = audio::AudioStreamInfo(
@@ -185,7 +289,7 @@ esp_err_t ResamplerSpeaker::start_task_() {
   }
 
   if (this->task_handle_ == nullptr) {
-    this->task_handle_ = xTaskCreateStatic(resample_task, "sample", TASK_STACK_SIZE, (void *) this,
+    this->task_handle_ = xTaskCreateStatic(resample_task, "resampler", TASK_STACK_SIZE, (void *) this,
                                            RESAMPLER_TASK_PRIORITY, this->task_stack_buffer_, &this->task_stack_);
   }
 
@@ -196,43 +300,47 @@ esp_err_t ResamplerSpeaker::start_task_() {
   return ESP_OK;
 }
 
-void ResamplerSpeaker::stop() { this->state_ = speaker::STATE_STOPPING; }
+void ResamplerSpeaker::stop() { this->send_command_(ResamplingEventGroupBits::COMMAND_STOP); }
 
-void ResamplerSpeaker::stop_() {
+void ResamplerSpeaker::enter_stopping_state_() {
+  this->state_ = speaker::STATE_STOPPING;
+  this->state_start_ms_ = App.get_loop_component_start_time();
   if (this->task_handle_ != nullptr) {
-    xEventGroupSetBits(this->event_group_, ResamplingEventGroupBits::COMMAND_STOP);
+    xEventGroupSetBits(this->event_group_, ResamplingEventGroupBits::TASK_COMMAND_STOP);
   }
   this->output_speaker_->stop();
 }
 
-esp_err_t ResamplerSpeaker::delete_task_() {
-  if (!this->task_created_) {
+void ResamplerSpeaker::delete_task_() {
+  if (this->task_handle_ != nullptr) {
+    // Delete the suspended task
+    vTaskDelete(this->task_handle_);
     this->task_handle_ = nullptr;
-
-    if (this->task_stack_buffer_ != nullptr) {
-      if (this->task_stack_in_psram_) {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
-        stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-      } else {
-        RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
-        stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
-      }
-
-      this->task_stack_buffer_ = nullptr;
-    }
-
-    return ESP_OK;
   }
 
-  return ESP_ERR_INVALID_STATE;
+  if (this->task_stack_buffer_ != nullptr) {
+    // Deallocate the task stack buffer
+    if (this->task_stack_in_psram_) {
+      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_EXTERNAL);
+      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
+    } else {
+      RAMAllocator<StackType_t> stack_allocator(RAMAllocator<StackType_t>::ALLOC_INTERNAL);
+      stack_allocator.deallocate(this->task_stack_buffer_, TASK_STACK_SIZE);
+    }
+
+    this->task_stack_buffer_ = nullptr;
+  }
 }
 
-void ResamplerSpeaker::finish() { this->output_speaker_->finish(); }
+void ResamplerSpeaker::finish() { this->send_command_(ResamplingEventGroupBits::COMMAND_FINISH); }
 
 bool ResamplerSpeaker::has_buffered_data() const {
   bool has_ring_buffer_data = false;
-  if (this->requires_resampling_() && (this->ring_buffer_.use_count() > 0)) {
-    has_ring_buffer_data = (this->ring_buffer_.lock()->available() > 0);
+  if (this->requires_resampling_()) {
+    std::shared_ptr<RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
+    if (temp_ring_buffer) {
+      has_ring_buffer_data = (temp_ring_buffer->available() > 0);
+    }
   }
   return (has_ring_buffer_data || this->output_speaker_->has_buffered_data());
 }
@@ -253,9 +361,8 @@ bool ResamplerSpeaker::requires_resampling_() const {
 }
 
 void ResamplerSpeaker::resample_task(void *params) {
-  ResamplerSpeaker *this_resampler = (ResamplerSpeaker *) params;
+  ResamplerSpeaker *this_resampler = static_cast<ResamplerSpeaker *>(params);
 
-  this_resampler->task_created_ = true;
   xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::STATE_STARTING);
 
   std::unique_ptr<audio::AudioResampler> resampler =
@@ -269,7 +376,7 @@ void ResamplerSpeaker::resample_task(void *params) {
     std::shared_ptr<RingBuffer> temp_ring_buffer =
         RingBuffer::create(this_resampler->audio_stream_info_.ms_to_bytes(this_resampler->buffer_duration_ms_));
 
-    if (temp_ring_buffer.use_count() == 0) {
+    if (!temp_ring_buffer) {
       err = ESP_ERR_NO_MEM;
     } else {
       this_resampler->ring_buffer_ = temp_ring_buffer;
@@ -291,7 +398,7 @@ void ResamplerSpeaker::resample_task(void *params) {
   while (err == ESP_OK) {
     uint32_t event_bits = xEventGroupGetBits(this_resampler->event_group_);
 
-    if (event_bits & ResamplingEventGroupBits::COMMAND_STOP) {
+    if (event_bits & ResamplingEventGroupBits::TASK_COMMAND_STOP) {
       break;
     }
 
@@ -310,8 +417,8 @@ void ResamplerSpeaker::resample_task(void *params) {
   xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
   resampler.reset();
   xEventGroupSetBits(this_resampler->event_group_, ResamplingEventGroupBits::STATE_STOPPED);
-  this_resampler->task_created_ = false;
-  vTaskDelete(nullptr);
+
+  vTaskSuspend(nullptr);  // Suspend this task indefinitely until the loop method deletes it
 }
 
 }  // namespace resampler

esphome/components/resampler/speaker/resampler_speaker.h

@@ -8,14 +8,16 @@
 
 #include "esphome/core/component.h"
 
-#include <freertos/event_groups.h>
 #include <freertos/FreeRTOS.h>
+#include <freertos/event_groups.h>
 
 namespace esphome {
 namespace resampler {
 
 class ResamplerSpeaker : public Component, public speaker::Speaker {
  public:
+  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
+  void dump_config() override;
   void setup() override;
   void loop() override;
 
@@ -65,13 +67,18 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   ///         ESP_ERR_INVALID_STATE if the task wasn't created
   esp_err_t start_task_();
 
-  /// @brief Stops the output speaker. If the resampling task is running, it sends the stop command.
-  void stop_();
+  /// @brief Transitions to STATE_STOPPING, records the stopping timestamp, sends the task stop command if the task is
+  /// running, and stops the output speaker.
+  void enter_stopping_state_();
 
-  /// @brief Deallocates the task stack and resets the pointers.
-  /// @return ESP_OK if successful
-  ///         ESP_ERR_INVALID_STATE if the task hasn't stopped itself
-  esp_err_t delete_task_();
+  /// @brief Sets the appropriate status error based on the start failure reason.
+  void set_start_error_(esp_err_t err);
+
+  /// @brief Deletes the resampler task if suspended, deallocates the task stack, and resets the related pointers.
+  void delete_task_();
+
+  /// @brief Sends a command via event group bits, enables the loop, and optionally wakes the main loop.
+  void send_command_(uint32_t command_bit, bool wake_loop = false);
 
   inline bool requires_resampling_() const;
   static void resample_task(void *params);
@@ -83,7 +90,7 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   speaker::Speaker *output_speaker_{nullptr};
 
   bool task_stack_in_psram_{false};
-  bool task_created_{false};
+  bool waiting_for_output_{false};
 
   TaskHandle_t task_handle_{nullptr};
   StaticTask_t task_stack_;
@@ -98,6 +105,7 @@ class ResamplerSpeaker : public Component, public speaker::Speaker {
   uint32_t target_sample_rate_;
 
   uint32_t buffer_duration_ms_;
+  uint32_t state_start_ms_{0};
 
   uint64_t callback_remainder_{0};
 };

esphome/components/rtl87xx/boards.py

@@ -71,6 +71,10 @@ 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,
@@ -83,6 +87,14 @@ 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,
@@ -103,6 +115,10 @@ 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,
@@ -119,10 +135,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 29,
-        "WIRE0_SCL_1": 22,
-        "WIRE0_SDA_0": 30,
-        "WIRE0_SDA_1": 19,
+        "WIRE0_SCL_0": 22,
+        "WIRE0_SCL_1": 29,
+        "WIRE0_SDA_0": 19,
+        "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,
@@ -230,10 +246,10 @@ RTL87XX_BOARD_PINS = {
         "A1": 41,
     },
     "wbr3": {
-        "WIRE0_SCL_0": 11,
-        "WIRE0_SCL_1": 2,
-        "WIRE0_SCL_2": 19,
-        "WIRE0_SCL_3": 15,
+        "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,
@@ -242,10 +258,10 @@ RTL87XX_BOARD_PINS = {
         "SERIAL0_TX_0": 11,
         "SERIAL0_TX_1": 14,
         "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 2,
-        "SERIAL1_RX_1": 0,
-        "SERIAL1_TX_0": 3,
-        "SERIAL1_TX_1": 1,
+        "SERIAL1_RX_0": 0,
+        "SERIAL1_RX_1": 2,
+        "SERIAL1_TX_0": 1,
+        "SERIAL1_TX_1": 3,
         "SERIAL2_CTS": 19,
         "SERIAL2_RX": 15,
         "SERIAL2_TX": 16,
@@ -296,6 +312,12 @@ 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,
@@ -396,10 +418,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 29,
-        "WIRE0_SCL_1": 22,
-        "WIRE0_SDA_0": 30,
-        "WIRE0_SDA_1": 19,
+        "WIRE0_SCL_0": 22,
+        "WIRE0_SCL_1": 29,
+        "WIRE0_SDA_0": 19,
+        "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,
@@ -463,10 +485,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 29,
-        "WIRE0_SCL_1": 22,
-        "WIRE0_SDA_0": 30,
-        "WIRE0_SDA_1": 19,
+        "WIRE0_SCL_0": 22,
+        "WIRE0_SCL_1": 29,
+        "WIRE0_SDA_0": 19,
+        "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,
@@ -714,6 +736,12 @@ 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,
@@ -807,6 +835,12 @@ 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,
@@ -957,8 +991,8 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 29,
-        "WIRE0_SCL_1": 22,
+        "WIRE0_SCL_0": 22,
+        "WIRE0_SCL_1": 29,
         "WIRE0_SDA_0": 19,
         "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
@@ -1088,6 +1122,99 @@ 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,
@@ -1116,21 +1243,21 @@ RTL87XX_BOARD_PINS = {
         "SPI0_MISO": 20,
         "SPI0_MOSI_0": 4,
         "SPI0_MOSI_1": 19,
-        "SPI0_SCK_0": 16,
-        "SPI0_SCK_1": 3,
+        "SPI0_SCK_0": 3,
+        "SPI0_SCK_1": 16,
         "WIRE0_SCL_0": 2,
         "WIRE0_SCL_1": 15,
         "WIRE0_SCL_2": 19,
-        "WIRE0_SDA_0": 20,
+        "WIRE0_SDA_0": 3,
         "WIRE0_SDA_1": 16,
-        "WIRE0_SDA_2": 3,
+        "WIRE0_SDA_2": 20,
         "SERIAL0_RX": 13,
         "SERIAL0_TX": 14,
         "SERIAL1_CTS": 4,
-        "SERIAL1_RX_0": 2,
-        "SERIAL1_RX_1": 0,
-        "SERIAL1_TX_0": 3,
-        "SERIAL1_TX_1": 1,
+        "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,
@@ -1251,6 +1378,168 @@ 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,
@@ -1456,8 +1745,8 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 29,
-        "WIRE0_SCL_1": 22,
+        "WIRE0_SCL_0": 22,
+        "WIRE0_SCL_1": 29,
         "WIRE0_SDA_0": 19,
         "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
@@ -1585,6 +1874,65 @@ 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,
@@ -1594,10 +1942,10 @@ RTL87XX_BOARD_PINS = {
         "SPI1_MISO": 22,
         "SPI1_MOSI": 23,
         "SPI1_SCK": 18,
-        "WIRE0_SCL_0": 29,
-        "WIRE0_SCL_1": 22,
-        "WIRE0_SDA_0": 30,
-        "WIRE0_SDA_1": 19,
+        "WIRE0_SCL_0": 22,
+        "WIRE0_SCL_1": 29,
+        "WIRE0_SDA_0": 19,
+        "WIRE0_SDA_1": 30,
         "WIRE1_SCL": 18,
         "WIRE1_SDA": 23,
         "SERIAL0_CTS": 19,

esphome/components/rtttl/rtttl.cpp

@@ -2,6 +2,7 @@
 #include <cmath>
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 namespace esphome {
 namespace rtttl {
@@ -375,22 +376,13 @@ 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, plus UNKNOWN fallback
+PROGMEM_STRING_TABLE(RtttlStateStrings, "STATE_STOPPED", "STATE_INIT", "STATE_STARTING", "STATE_RUNNING",
+                     "STATE_STOPPING", "UNKNOWN");
+
 static const LogString *state_to_string(State state) {
-  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");
-  }
-};
+  return RtttlStateStrings::get_log_str(static_cast<uint8_t>(state), RtttlStateStrings::LAST_INDEX);
+}
 #endif
 
 void Rtttl::set_state_(State state) {

esphome/components/sprinkler/sprinkler.cpp

@@ -4,6 +4,7 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include <cinttypes>
 #include <utility>
 
@@ -1544,42 +1545,19 @@ 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) {
-  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");
-  }
+  return SprinklerRequestOriginStrings::get_log_str(static_cast<uint8_t>(origin),
+                                                    SprinklerRequestOriginStrings::LAST_INDEX);
 }
 
+// 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) {
-  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");
-  }
+  return SprinklerStateStrings::get_log_str(static_cast<uint8_t>(state), SprinklerStateStrings::LAST_INDEX);
 }
 
 void Sprinkler::start_timer_(const SprinklerTimerIndex timer_index) {

esphome/components/ssd1306_base/ssd1306_base.cpp

@@ -1,6 +1,7 @@
 #include "ssd1306_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 namespace esphome {
 namespace ssd1306_base {
@@ -40,6 +41,55 @@ 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_());
 
@@ -146,6 +196,7 @@ void SSD1306::setup() {
         break;
       case SH1107_MODEL_128_64:
       case SH1107_MODEL_128_128:
+      case SSD1306_MODEL_COUNT:
         // Not used, but prevents build warning
         break;
     }
@@ -274,54 +325,14 @@ void SSD1306::turn_off() {
   this->is_on_ = false;
 }
 int SSD1306::get_height_internal() {
-  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;
-  }
+  if (this->model_ >= SSD1306_MODEL_COUNT)
+    return 0;
+  return progmem_read_byte(&MODEL_DIMS[this->model_].height);
 }
 int SSD1306::get_width_internal() {
-  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;
-  }
+  if (this->model_ >= SSD1306_MODEL_COUNT)
+    return 0;
+  return progmem_read_byte(&MODEL_DIMS[this->model_].width);
 }
 size_t SSD1306::get_buffer_length_() {
   return size_t(this->get_width_internal()) * size_t(this->get_height_internal()) / 8u;
@@ -361,37 +372,8 @@ void SSD1306::init_reset_() {
     this->reset_pin_->digital_write(true);
   }
 }
-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";
-  }
+const LogString *SSD1306::model_str_() {
+  return ModelStrings::get_log_str(static_cast<uint8_t>(this->model_), ModelStrings::LAST_INDEX);
 }
 
 }  // namespace ssd1306_base

esphome/components/ssd1306_base/ssd1306_base.h

@@ -22,6 +22,9 @@ 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 {
@@ -70,7 +73,7 @@ class SSD1306 : public display::DisplayBuffer {
   int get_height_internal() override;
   int get_width_internal() override;
   size_t get_buffer_length_();
-  const char *model_str_();
+  const LogString *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",
-                this->model_str_(), YESNO(this->external_vcc_), YESNO(this->flip_x_), YESNO(this->flip_y_),
+                LOG_STR_ARG(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",
-                this->model_str_(), YESNO(this->external_vcc_), YESNO(this->flip_x_), YESNO(this->flip_y_),
+                LOG_STR_ARG(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/voice_assistant/voice_assistant.cpp

@@ -430,12 +430,14 @@ void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscr
   }
 
   if (this->api_client_ != nullptr) {
+    char current_peername[socket::SOCKADDR_STR_LEN];
+    char new_peername[socket::SOCKADDR_STR_LEN];
     ESP_LOGE(TAG,
              "Multiple API Clients attempting to connect to Voice Assistant\n"
              "Current client: %s (%s)\n"
              "New client: %s (%s)",
-             this->api_client_->get_name(), this->api_client_->get_peername(), client->get_name(),
-             client->get_peername());
+             this->api_client_->get_name(), this->api_client_->get_peername_to(current_peername), client->get_name(),
+             client->get_peername_to(new_peername));
     return;
   }
 

esphome/components/web_server_idf/web_server_idf.cpp

@@ -344,14 +344,15 @@ bool AsyncWebServerRequest::authenticate(const char *username, const char *passw
   memcpy(user_info + user_len + 1, password, pass_len);
   user_info[user_info_len] = '\0';
 
-  size_t n = 0, out;
-  esp_crypto_base64_encode(nullptr, 0, &n, reinterpret_cast<const uint8_t *>(user_info), user_info_len);
-
-  auto digest = std::unique_ptr<char[]>(new char[n + 1]);
-  esp_crypto_base64_encode(reinterpret_cast<uint8_t *>(digest.get()), n, &out,
+  // Base64 output size is ceil(input_len * 4/3) + 1, with input bounded to 256 bytes
+  // max output is ceil(256 * 4/3) + 1 = 343 bytes, use 350 for safety
+  constexpr size_t max_digest_len = 350;
+  char digest[max_digest_len];
+  size_t out;
+  esp_crypto_base64_encode(reinterpret_cast<uint8_t *>(digest), max_digest_len, &out,
                            reinterpret_cast<const uint8_t *>(user_info), user_info_len);
 
-  return strcmp(digest.get(), auth_str + auth_prefix_len) == 0;
+  return strcmp(digest, auth_str + auth_prefix_len) == 0;
 }
 
 void AsyncWebServerRequest::requestAuthentication(const char *realm) const {
@@ -861,12 +862,12 @@ esp_err_t AsyncWebServer::handle_multipart_upload_(httpd_req_t *r, const char *c
     }
   });
 
-  // Process data
-  std::unique_ptr<char[]> buffer(new char[MULTIPART_CHUNK_SIZE]);
+  // Process data - use stack buffer to avoid heap allocation
+  char buffer[MULTIPART_CHUNK_SIZE];
   size_t bytes_since_yield = 0;
 
   for (size_t remaining = r->content_len; remaining > 0;) {
-    int recv_len = httpd_req_recv(r, buffer.get(), std::min(remaining, MULTIPART_CHUNK_SIZE));
+    int recv_len = httpd_req_recv(r, buffer, std::min(remaining, MULTIPART_CHUNK_SIZE));
 
     if (recv_len <= 0) {
       httpd_resp_send_err(r, recv_len == HTTPD_SOCK_ERR_TIMEOUT ? HTTPD_408_REQ_TIMEOUT : HTTPD_400_BAD_REQUEST,
@@ -874,7 +875,7 @@ esp_err_t AsyncWebServer::handle_multipart_upload_(httpd_req_t *r, const char *c
       return recv_len == HTTPD_SOCK_ERR_TIMEOUT ? ESP_ERR_TIMEOUT : ESP_FAIL;
     }
 
-    if (reader->parse(buffer.get(), recv_len) != static_cast<size_t>(recv_len)) {
+    if (reader->parse(buffer, recv_len) != static_cast<size_t>(recv_len)) {
       ESP_LOGW(TAG, "Multipart parser error");
       httpd_resp_send_err(r, HTTPD_400_BAD_REQUEST, nullptr);
       return ESP_FAIL;

esphome/idf_component.yml

@@ -10,7 +10,7 @@ dependencies:
   espressif/mdns:
     version: 1.9.1
   espressif/esp_wifi_remote:
-    version: 1.2.4
+    version: 1.3.2
     rules:
       - if: "target in [esp32h2, esp32p4]"
   espressif/eppp_link:
@@ -18,7 +18,7 @@ dependencies:
     rules:
       - if: "target in [esp32h2, esp32p4]"
   espressif/esp_hosted:
-    version: 2.9.3
+    version: 2.11.5
     rules:
       - if: "target in [esp32h2, esp32p4]"
   zorxx/multipart-parser:

esphome/platformio_api.py

@@ -133,6 +133,8 @@ def run_platformio_cli(*args, **kwargs) -> str | int:
     )
     # Suppress Python syntax warnings from third-party scripts during compilation
     os.environ.setdefault("PYTHONWARNINGS", "ignore::SyntaxWarning")
+    # Increase uv retry count to handle transient network errors (default is 3)
+    os.environ.setdefault("UV_HTTP_RETRIES", "10")
     cmd = ["platformio"] + list(args)
 
     if not CORE.verbose:

platformio.ini

@@ -136,6 +136,7 @@ extends = common:arduino
 platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip
 platform_packages =
     pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/3.3.6/esp32-core-3.3.6.tar.xz
+    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.2/esp-idf-v5.5.2.tar.xz
 
 framework = arduino, espidf  ; Arduino as an ESP-IDF component
 lib_deps =
@@ -213,7 +214,7 @@ build_unflags =
 ; This are common settings for the LibreTiny (all variants) using Arduino.
 [common:libretiny-arduino]
 extends = common:arduino
-platform = https://github.com/libretiny-eu/libretiny.git#v1.11.0
+platform = https://github.com/libretiny-eu/libretiny.git#v1.12.1
 framework = arduino
 lib_compat_mode = soft
 lib_deps =

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

@@ -6,8 +6,8 @@ esp32:
     type: esp-idf
     components:
       - espressif/mdns^1.8.2
-      - name: espressif/esp_hosted
-        ref: 2.7.0
+      - name: espressif/button
+        ref: 4.1.5
     advanced:
       enable_idf_experimental_features: yes
       disable_debug_stubs: true