Merge pull request #14151 from esphome/bump-2026.2.1

2026.2.1
Bump version to 2026.2.1
2026-07-08 16:05:34 +00:00 · 2026-02-20 11:24:11 -05:00 · 2026-02-20 10:17:12 -05:00 · 2026-02-20 10:17:12 -05:00 · 2026-02-20 10:17:12 -05:00 · 2026-02-20 10:17:12 -05:00
72 changed files with 1100 additions and 428 deletions
@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = 2026.2.0b1
+PROJECT_NUMBER         = 2026.2.1

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -9,7 +9,8 @@ FROM ghcr.io/esphome/docker-base:${BUILD_OS}-ha-addon-${BUILD_BASE_VERSION} AS b
 ARG BUILD_TYPE
 FROM base-source-${BUILD_TYPE} AS base

-RUN git config --system --add safe.directory "*"
+RUN git config --system --add safe.directory "*" \
+    && git config --system advice.detachedHead false

 # Install build tools for Python packages that require compilation
 # (e.g., ruamel.yaml.clibz used by ESP-IDF's idf-component-manager)
@@ -138,10 +138,12 @@ APIError APINoiseFrameHelper::handle_noise_error_(int err, const LogString *func

 /// Run through handshake messages (if in that phase)
 APIError APINoiseFrameHelper::loop() {
-  // During handshake phase, process as many actions as possible until we can't progress
-  // socket_->ready() stays true until next main loop, but state_action() will return
-  // WOULD_BLOCK when no more data is available to read
-  while (state_ != State::DATA && this->socket_->ready()) {
+  // Cache ready() outside the loop. On ESP8266 LWIP raw TCP, ready() returns false once
+  // the rx buffer is consumed. Re-checking each iteration would block handshake writes
+  // that must follow reads, deadlocking the handshake. state_action() will return
+  // WOULD_BLOCK when no more data is available to read.
+  bool socket_ready = this->socket_->ready();
+  while (state_ != State::DATA && socket_ready) {
    APIError err = state_action_();
    if (err == APIError::WOULD_BLOCK) {
      break;
@@ -117,37 +117,7 @@ void APIServer::setup() {
 void APIServer::loop() {
  // Accept new clients only if the socket exists and has incoming connections
  if (this->socket_ && this->socket_->ready()) {
-    while (true) {
-      struct sockaddr_storage source_addr;
-      socklen_t addr_len = sizeof(source_addr);
-
-      auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
-      if (!sock)
-        break;
-
-      char peername[socket::SOCKADDR_STR_LEN];
-      sock->getpeername_to(peername);
-
-      // Check if we're at the connection limit
-      if (this->clients_.size() >= this->max_connections_) {
-        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
-        // Immediately close - socket destructor will handle cleanup
-        sock.reset();
-        continue;
-      }
-
-      ESP_LOGD(TAG, "Accept %s", peername);
-
-      auto *conn = new APIConnection(std::move(sock), this);
-      this->clients_.emplace_back(conn);
-      conn->start();
-
-      // First client connected - clear warning and update timestamp
-      if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
-        this->status_clear_warning();
-        this->last_connected_ = App.get_loop_component_start_time();
-      }
-    }
+    this->accept_new_connections_();
  }

  if (this->clients_.empty()) {
@@ -178,46 +148,88 @@ void APIServer::loop() {
  while (client_index < this->clients_.size()) {
    auto &client = this->clients_[client_index];

+    // Common case: process active client
    if (!client->flags_.remove) {
-      // Common case: process active client
      client->loop();
+    }
+    // Handle disconnection promptly - close socket to free LWIP PCB
+    // resources and prevent retransmit crashes on ESP8266.
+    if (client->flags_.remove) {
+      // Rare case: handle disconnection (don't increment - swapped element needs processing)
+      this->remove_client_(client_index);
+    } else {
      client_index++;
+    }
+  }
+}
+
+void APIServer::remove_client_(size_t client_index) {
+  auto &client = this->clients_[client_index];
+
+#ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
+  this->unregister_active_action_calls_for_connection(client.get());
+#endif
+  ESP_LOGV(TAG, "Remove connection %s", client->get_name());
+
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+  // Save client info before closing socket and removal for the trigger
+  char peername_buf[socket::SOCKADDR_STR_LEN];
+  std::string client_name(client->get_name());
+  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());
+  }
+  this->clients_.pop_back();
+
+  // Last client disconnected - set warning and start tracking for reboot timeout
+  if (this->clients_.empty() && this->reboot_timeout_ != 0) {
+    this->status_set_warning();
+    this->last_connected_ = App.get_loop_component_start_time();
+  }
+
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+  // Fire trigger after client is removed so api.connected reflects the true state
+  this->client_disconnected_trigger_.trigger(client_name, client_peername);
+#endif
+}
+
+void APIServer::accept_new_connections_() {
+  while (true) {
+    struct sockaddr_storage source_addr;
+    socklen_t addr_len = sizeof(source_addr);
+
+    auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
+    if (!sock)
+      break;
+
+    char peername[socket::SOCKADDR_STR_LEN];
+    sock->getpeername_to(peername);
+
+    // Check if we're at the connection limit
+    if (this->clients_.size() >= this->max_connections_) {
+      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
+      // Immediately close - socket destructor will handle cleanup
+      sock.reset();
      continue;
    }

-    // Rare case: handle disconnection
-#ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-    this->unregister_active_action_calls_for_connection(client.get());
-#endif
-    ESP_LOGV(TAG, "Remove connection %s", client->get_name());
+    ESP_LOGD(TAG, "Accept %s", peername);

-#ifdef USE_API_CLIENT_DISCONNECTED_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_to(peername_buf));
-#endif
+    auto *conn = new APIConnection(std::move(sock), this);
+    this->clients_.emplace_back(conn);
+    conn->start();

-    // 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());
-    }
-    this->clients_.pop_back();
-
-    // Last client disconnected - set warning and start tracking for reboot timeout
-    if (this->clients_.empty() && this->reboot_timeout_ != 0) {
-      this->status_set_warning();
+    // First client connected - clear warning and update timestamp
+    if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
+      this->status_clear_warning();
      this->last_connected_ = App.get_loop_component_start_time();
    }
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-    // Fire trigger after client is removed so api.connected reflects the true state
-    this->client_disconnected_trigger_.trigger(client_name, client_peername);
-#endif
-    // Don't increment client_index since we need to process the swapped element
  }
 }

@@ -234,6 +234,11 @@ class APIServer : public Component,
 #endif

 protected:
+  // Accept incoming socket connections. Only called when socket has pending connections.
+  void __attribute__((noinline)) accept_new_connections_();
+  // Remove a disconnected client by index. Swaps with last element and pops.
+  void __attribute__((noinline)) remove_client_(size_t client_index);
+
 #ifdef USE_API_NOISE
  bool update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg, const LogString *fail_log_msg,
                         const psk_t &active_psk, bool make_active);
@@ -126,7 +126,7 @@ void LinearCombinationComponent::setup() {
 }

 void LinearCombinationComponent::handle_new_value(float value) {
-  // Multiplies each sensor state by a configured coeffecient and then sums
+  // Multiplies each sensor state by a configured coefficient and then sums

  if (!std::isfinite(value))
    return;
@@ -1,3 +1,5 @@
+import logging
+
 import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
@@ -15,6 +17,8 @@ from esphome.const import (
 )
 from esphome.core.entity_helpers import inherit_property_from

+_LOGGER = logging.getLogger(__name__)
+
 CODEOWNERS = ["@Cat-Ion", "@kahrendt"]

 combination_ns = cg.esphome_ns.namespace("combination")
@@ -47,7 +51,8 @@ SumCombinationComponent = combination_ns.class_(
    "SumCombinationComponent", cg.Component, sensor.Sensor
 )

-CONF_COEFFECIENT = "coeffecient"
+CONF_COEFFICIENT = "coefficient"
+CONF_COEFFECIENT = "coeffecient"  # Deprecated, remove before 2026.12.0
 CONF_ERROR = "error"
 CONF_KALMAN = "kalman"
 CONF_LINEAR = "linear"
@@ -68,11 +73,34 @@ KALMAN_SOURCE_SCHEMA = cv.Schema(
    }
 )

-LINEAR_SOURCE_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
-        cv.Required(CONF_COEFFECIENT): cv.templatable(cv.float_),
-    }
+
+def _migrate_coeffecient(config):
+    """Migrate deprecated 'coeffecient' spelling to 'coefficient'."""
+    if CONF_COEFFECIENT in config:
+        if CONF_COEFFICIENT in config:
+            raise cv.Invalid(
+                f"Cannot specify both '{CONF_COEFFICIENT}' and '{CONF_COEFFECIENT}'"
+            )
+        _LOGGER.warning(
+            "'%s' is deprecated, use '%s' instead. Will be removed in 2026.12.0",
+            CONF_COEFFECIENT,
+            CONF_COEFFICIENT,
+        )
+        config[CONF_COEFFICIENT] = config.pop(CONF_COEFFECIENT)
+    elif CONF_COEFFICIENT not in config:
+        raise cv.Invalid(f"'{CONF_COEFFICIENT}' is a required option")
+    return config
+
+
+LINEAR_SOURCE_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Required(CONF_SOURCE): cv.use_id(sensor.Sensor),
+            cv.Optional(CONF_COEFFICIENT): cv.templatable(cv.float_),
+            cv.Optional(CONF_COEFFECIENT): cv.templatable(cv.float_),
+        }
+    ),
+    _migrate_coeffecient,
 )

 SENSOR_ONLY_SOURCE_SCHEMA = cv.Schema(
@@ -162,12 +190,12 @@ async def to_code(config):
            )
            cg.add(var.add_source(source, error))
        elif config[CONF_TYPE] == CONF_LINEAR:
-            coeffecient = await cg.templatable(
-                source_conf[CONF_COEFFECIENT],
+            coefficient = await cg.templatable(
+                source_conf[CONF_COEFFICIENT],
                [(float, "x")],
                cg.float_,
            )
-            cg.add(var.add_source(source, coeffecient))
+            cg.add(var.add_source(source, coefficient))
        else:
            cg.add(var.add_source(source))

@@ -14,12 +14,17 @@ static const int PORT = 5568;
 E131Component::E131Component() {}

 E131Component::~E131Component() {
+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
  if (this->socket_) {
    this->socket_->close();
  }
+#elif defined(USE_SOCKET_IMPL_LWIP_TCP)
+  this->udp_.stop();
+#endif
 }

 void E131Component::setup() {
+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
  this->socket_ = socket::socket_ip(SOCK_DGRAM, IPPROTO_IP);

  int enable = 1;
@@ -50,6 +55,13 @@ void E131Component::setup() {
    this->mark_failed();
    return;
  }
+#elif defined(USE_SOCKET_IMPL_LWIP_TCP)
+  if (!this->udp_.begin(PORT)) {
+    ESP_LOGW(TAG, "Cannot bind E1.31 to port %d.", PORT);
+    this->mark_failed();
+    return;
+  }
+#endif

  join_igmp_groups_();
 }
@@ -59,19 +71,36 @@ void E131Component::loop() {
  int universe = 0;
  uint8_t buf[1460];

+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
  ssize_t len = this->socket_->read(buf, sizeof(buf));
  if (len == -1) {
    return;
  }

  if (!this->packet_(buf, (size_t) len, universe, packet)) {
-    ESP_LOGV(TAG, "Invalid packet received of size %zd.", len);
+    ESP_LOGV(TAG, "Invalid packet received of size %d.", (int) len);
    return;
  }

  if (!this->process_(universe, packet)) {
    ESP_LOGV(TAG, "Ignored packet for %d universe of size %d.", universe, packet.count);
  }
+#elif defined(USE_SOCKET_IMPL_LWIP_TCP)
+  while (auto packet_size = this->udp_.parsePacket()) {
+    auto len = this->udp_.read(buf, sizeof(buf));
+    if (len <= 0)
+      continue;
+
+    if (!this->packet_(buf, (size_t) len, universe, packet)) {
+      ESP_LOGV(TAG, "Invalid packet received of size %d.", (int) len);
+      continue;
+    }
+
+    if (!this->process_(universe, packet)) {
+      ESP_LOGV(TAG, "Ignored packet for %d universe of size %d.", universe, packet.count);
+    }
+  }
+#endif
 }

 void E131Component::add_effect(E131AddressableLightEffect *light_effect) {
@@ -1,7 +1,11 @@
 #pragma once
 #include "esphome/core/defines.h"
 #ifdef USE_NETWORK
+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
 #include "esphome/components/socket/socket.h"
+#elif defined(USE_SOCKET_IMPL_LWIP_TCP)
+#include <WiFiUdp.h>
+#endif
 #include "esphome/core/component.h"

 #include <cinttypes>
@@ -45,7 +49,11 @@ class E131Component : public esphome::Component {
  void leave_(int universe);

  E131ListenMethod listen_method_{E131_MULTICAST};
+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
  std::unique_ptr<socket::Socket> socket_;
+#elif defined(USE_SOCKET_IMPL_LWIP_TCP)
+  WiFiUDP udp_;
+#endif
  std::vector<E131AddressableLightEffect *> light_effects_;
  std::map<int, int> universe_consumers_;
 };
@@ -62,8 +62,10 @@ const size_t E131_MIN_PACKET_SIZE = reinterpret_cast<size_t>(&((E131RawPacket *)
 bool E131Component::join_igmp_groups_() {
  if (listen_method_ != E131_MULTICAST)
    return false;
+#if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
  if (this->socket_ == nullptr)
    return false;
+#endif

  for (auto universe : universe_consumers_) {
    if (!universe.second)
@@ -44,9 +44,9 @@ from esphome.const import (
 from esphome.core import CORE, HexInt, TimePeriod
 from esphome.coroutine import CoroPriority, coroutine_with_priority
 import esphome.final_validate as fv
-from esphome.helpers import copy_file_if_changed, write_file_if_changed
+from esphome.helpers import copy_file_if_changed, rmtree, write_file_if_changed
 from esphome.types import ConfigType
-from esphome.writer import clean_cmake_cache, rmtree
+from esphome.writer import clean_cmake_cache

 from .boards import BOARDS, STANDARD_BOARDS
 from .const import (  # noqa
@@ -9,6 +9,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import socket
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
+from esphome.components.esp32.const import VARIANT_ESP32C2
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ENABLE_ON_BOOT,
@@ -387,6 +388,15 @@ def final_validation(config):
                f"Name '{name}' is too long, maximum length is {max_length} characters"
            )

+    # ESP32-C2 has very limited RAM (~272KB). Without releasing BLE IRAM,
+    # esp_bt_controller_init fails with ESP_ERR_NO_MEM.
+    # CONFIG_BT_RELEASE_IRAM changes the memory layout so IRAM and DRAM share
+    # space more flexibly, giving the BT controller enough contiguous memory.
+    # This requires CONFIG_ESP_SYSTEM_PMP_IDRAM_SPLIT to be disabled.
+    if get_esp32_variant() == VARIANT_ESP32C2:
+        add_idf_sdkconfig_option("CONFIG_BT_RELEASE_IRAM", True)
+        add_idf_sdkconfig_option("CONFIG_ESP_SYSTEM_PMP_IDRAM_SPLIT", False)
+
    # Set GATT Client/Server sdkconfig options based on which components are loaded
    full_config = fv.full_config.get()

@@ -527,7 +527,7 @@ async def to_code_characteristic(service_var, char_conf):
                action_conf,
                char_conf[CONF_CHAR_VALUE_ACTION_ID_],
                cg.TemplateArguments(),
-                {},
+                [],
            )
            cg.add(value_action.play())
        else:
@@ -246,9 +246,27 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
      if (this->handle_ != param->write.handle)
        break;

+      esp_gatt_status_t status = ESP_GATT_OK;
+
      if (param->write.is_prep) {
-        this->value_.insert(this->value_.end(), param->write.value, param->write.value + param->write.len);
-        this->write_event_ = true;
+        const size_t offset = param->write.offset;
+        const size_t write_len = param->write.len;
+        const size_t new_size = offset + write_len;
+        // Clean the buffer on the first prepared write event
+        if (offset == 0) {
+          this->value_.clear();
+        }
+
+        if (offset != this->value_.size()) {
+          status = ESP_GATT_INVALID_OFFSET;
+        } else if (new_size > ESP_GATT_MAX_ATTR_LEN) {
+          status = ESP_GATT_INVALID_ATTR_LEN;
+        } else {
+          if (this->value_.size() < new_size) {
+            this->value_.resize(new_size);
+          }
+          memcpy(this->value_.data() + offset, param->write.value, write_len);
+        }
      } else {
        this->set_value(ByteBuffer::wrap(param->write.value, param->write.len));
      }
@@ -263,7 +281,7 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
        memcpy(response.attr_value.value, param->write.value, param->write.len);

        esp_err_t err =
-            esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, &response);
+            esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, status, &response);

        if (err != ESP_OK) {
          ESP_LOGE(TAG, "esp_ble_gatts_send_response failed: %d", err);
@@ -280,9 +298,9 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
    }

    case ESP_GATTS_EXEC_WRITE_EVT: {
-      if (!this->write_event_)
+      // BLE stack will guarantee that ESP_GATTS_EXEC_WRITE_EVT is only received after prepared writes
+      if (this->value_.empty())
        break;
-      this->write_event_ = false;
      if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
        if (this->on_write_callback_) {
          (*this->on_write_callback_)(this->value_, param->exec_write.conn_id);
@@ -77,7 +77,6 @@ class BLECharacteristic {
  }

 protected:
-  bool write_event_{false};
  BLEService *service_{};
  ESPBTUUID uuid_;
  esp_gatt_char_prop_t properties_;
@@ -1,8 +1,30 @@
 from esphome.components import esp32
 import esphome.config_validation as cv
+from esphome.core import CORE

 CODEOWNERS = ["@jesserockz"]

+VARIANTS_NO_RMT = {esp32.VARIANT_ESP32C2, esp32.VARIANT_ESP32C61}
+
+
+def validate_rmt_not_supported(rmt_only_keys):
+    """Validate that RMT-only config keys are not used on variants without RMT hardware."""
+    rmt_only_keys = set(rmt_only_keys)
+
+    def _validator(config):
+        if CORE.is_esp32:
+            variant = esp32.get_esp32_variant()
+            if variant in VARIANTS_NO_RMT:
+                unsupported = rmt_only_keys.intersection(config)
+                if unsupported:
+                    keys = ", ".join(sorted(f"'{k}'" for k in unsupported))
+                    raise cv.Invalid(
+                        f"{keys} not available on {variant} (no RMT hardware)"
+                    )
+        return config
+
+    return _validator
+

 def validate_clock_resolution():
    def _validator(value):
@@ -3,7 +3,7 @@ import logging

 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import esp32, light
+from esphome.components import esp32, esp32_rmt, light
 from esphome.components.const import CONF_USE_PSRAM
 from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
@@ -71,6 +71,10 @@ CONF_RESET_LOW = "reset_low"


 CONFIG_SCHEMA = cv.All(
+    esp32.only_on_variant(
+        unsupported=list(esp32_rmt.VARIANTS_NO_RMT),
+        msg_prefix="ESP32 RMT LED strip",
+    ),
    light.ADDRESSABLE_LIGHT_SCHEMA.extend(
        {
            cv.GenerateID(CONF_OUTPUT_ID): cv.declare_id(ESP32RMTLEDStripLightOutput),
@@ -218,12 +218,19 @@ def _validate(config):
                )
    elif config[CONF_TYPE] != "OPENETH":
        if CONF_CLK_MODE in config:
+            mode, pin = CLK_MODES_DEPRECATED[config[CONF_CLK_MODE]]
            LOGGER.warning(
-                "[ethernet] The 'clk_mode' option is deprecated and will be removed in ESPHome 2026.1. "
-                "Please update your configuration to use 'clk' instead."
+                "[ethernet] The 'clk_mode' option is deprecated. "
+                "Please replace 'clk_mode: %s' with:\n"
+                "  clk:\n"
+                "    mode: %s\n"
+                "    pin: %s\n"
+                "Removal scheduled for 2026.7.0.",
+                config[CONF_CLK_MODE],
+                mode,
+                pin,
            )
-            mode = CLK_MODES_DEPRECATED[config[CONF_CLK_MODE]]
-            config[CONF_CLK] = CLK_SCHEMA({CONF_MODE: mode[0], CONF_PIN: mode[1]})
+            config[CONF_CLK] = CLK_SCHEMA({CONF_MODE: mode, CONF_PIN: pin})
            del config[CONF_CLK_MODE]
        elif CONF_CLK not in config:
            raise cv.Invalid("'clk' is a required option for [ethernet].")
@@ -221,12 +221,17 @@ void Fan::publish_state() {
 }

 // Random 32-bit value, change this every time the layout of the FanRestoreState struct changes.
-constexpr uint32_t RESTORE_STATE_VERSION = 0x71700ABA;
+constexpr uint32_t RESTORE_STATE_VERSION = 0x71700ABB;
 optional<FanRestoreState> Fan::restore_state_() {
  FanRestoreState recovered{};
  this->rtc_ = this->make_entity_preference<FanRestoreState>(RESTORE_STATE_VERSION);
  bool restored = this->rtc_.load(&recovered);

+  if (!restored) {
+    // No valid saved data; ensure preset_mode sentinel is set
+    recovered.preset_mode = FanRestoreState::NO_PRESET;
+  }
+
  switch (this->restore_mode_) {
    case FanRestoreMode::NO_RESTORE:
      return {};
@@ -264,6 +269,7 @@ void Fan::save_state_() {
  state.oscillating = this->oscillating;
  state.speed = this->speed;
  state.direction = this->direction;
+  state.preset_mode = FanRestoreState::NO_PRESET;

  if (this->has_preset_mode()) {
    const auto &preset_modes = traits.supported_preset_modes();
@@ -91,11 +91,13 @@ class FanCall {
 };

 struct FanRestoreState {
+  static constexpr uint8_t NO_PRESET = UINT8_MAX;
+
  bool state;
  int speed;
  bool oscillating;
  FanDirection direction;
-  uint8_t preset_mode;
+  uint8_t preset_mode{NO_PRESET};

  /// Convert this struct to a fan call that can be performed.
  FanCall to_call(Fan &fan);
@@ -28,15 +28,15 @@ fan::FanCall HBridgeFan::brake() {
 }

 void HBridgeFan::setup() {
+  // Construct traits before restore so preset modes can be looked up by index
+  this->traits_ = fan::FanTraits(this->oscillating_ != nullptr, true, true, this->speed_count_);
+  this->traits_.set_supported_preset_modes(this->preset_modes_);
+
  auto restore = this->restore_state_();
  if (restore.has_value()) {
    restore->apply(*this);
    this->write_state_();
  }
-
-  // Construct traits
-  this->traits_ = fan::FanTraits(this->oscillating_ != nullptr, true, true, this->speed_count_);
-  this->traits_.set_supported_preset_modes(this->preset_modes_);
 }

 void HBridgeFan::dump_config() {
@@ -608,8 +608,9 @@ void LD2410Component::readline_(int readch) {
    // We should never get here, but just in case...
    ESP_LOGW(TAG, "Max command length exceeded; ignoring");
    this->buffer_pos_ = 0;
+    return;
  }
-  if (this->buffer_pos_ < 4) {
+  if (this->buffer_pos_ < HEADER_FOOTER_SIZE) {
    return;  // Not enough data to process yet
  }
  if (ld2410::validate_header_footer(DATA_FRAME_FOOTER, &this->buffer_data_[this->buffer_pos_ - 4])) {
@@ -33,8 +33,10 @@ namespace esphome::ld2410 {

 using namespace ld24xx;

-static constexpr uint8_t MAX_LINE_LENGTH = 46;  // Max characters for serial buffer
-static constexpr uint8_t TOTAL_GATES = 9;       // Total number of gates supported by the LD2410
+// Engineering data frame is 45 bytes; +1 for null terminator, +4 so that a frame footer always
+// lands inside the buffer during footer-based resynchronization after losing sync.
+static constexpr uint8_t MAX_LINE_LENGTH = 50;
+static constexpr uint8_t TOTAL_GATES = 9;  // Total number of gates supported by the LD2410

 class LD2410Component : public Component, public uart::UARTDevice {
 #ifdef USE_BINARY_SENSOR
@@ -63,73 +63,73 @@ namespace esphome::ld2420 {
 static const char *const TAG = "ld2420";

 // Local const's
-static const uint16_t REFRESH_RATE_MS = 1000;
+static constexpr uint16_t REFRESH_RATE_MS = 1000;

 // Command sets
-static const uint16_t CMD_DISABLE_CONF = 0x00FE;
-static const uint16_t CMD_ENABLE_CONF = 0x00FF;
-static const uint16_t CMD_PARM_HIGH_TRESH = 0x0012;
-static const uint16_t CMD_PARM_LOW_TRESH = 0x0021;
-static const uint16_t CMD_PROTOCOL_VER = 0x0002;
-static const uint16_t CMD_READ_ABD_PARAM = 0x0008;
-static const uint16_t CMD_READ_REG_ADDR = 0x0020;
-static const uint16_t CMD_READ_REGISTER = 0x0002;
-static const uint16_t CMD_READ_SERIAL_NUM = 0x0011;
-static const uint16_t CMD_READ_SYS_PARAM = 0x0013;
-static const uint16_t CMD_READ_VERSION = 0x0000;
-static const uint16_t CMD_RESTART = 0x0068;
-static const uint16_t CMD_SYSTEM_MODE = 0x0000;
-static const uint16_t CMD_SYSTEM_MODE_GR = 0x0003;
-static const uint16_t CMD_SYSTEM_MODE_MTT = 0x0001;
-static const uint16_t CMD_SYSTEM_MODE_SIMPLE = 0x0064;
-static const uint16_t CMD_SYSTEM_MODE_DEBUG = 0x0000;
-static const uint16_t CMD_SYSTEM_MODE_ENERGY = 0x0004;
-static const uint16_t CMD_SYSTEM_MODE_VS = 0x0002;
-static const uint16_t CMD_WRITE_ABD_PARAM = 0x0007;
-static const uint16_t CMD_WRITE_REGISTER = 0x0001;
-static const uint16_t CMD_WRITE_SYS_PARAM = 0x0012;
+static constexpr uint16_t CMD_DISABLE_CONF = 0x00FE;
+static constexpr uint16_t CMD_ENABLE_CONF = 0x00FF;
+static constexpr uint16_t CMD_PARM_HIGH_TRESH = 0x0012;
+static constexpr uint16_t CMD_PARM_LOW_TRESH = 0x0021;
+static constexpr uint16_t CMD_PROTOCOL_VER = 0x0002;
+static constexpr uint16_t CMD_READ_ABD_PARAM = 0x0008;
+static constexpr uint16_t CMD_READ_REG_ADDR = 0x0020;
+static constexpr uint16_t CMD_READ_REGISTER = 0x0002;
+static constexpr uint16_t CMD_READ_SERIAL_NUM = 0x0011;
+static constexpr uint16_t CMD_READ_SYS_PARAM = 0x0013;
+static constexpr uint16_t CMD_READ_VERSION = 0x0000;
+static constexpr uint16_t CMD_RESTART = 0x0068;
+static constexpr uint16_t CMD_SYSTEM_MODE = 0x0000;
+static constexpr uint16_t CMD_SYSTEM_MODE_GR = 0x0003;
+static constexpr uint16_t CMD_SYSTEM_MODE_MTT = 0x0001;
+static constexpr uint16_t CMD_SYSTEM_MODE_SIMPLE = 0x0064;
+static constexpr uint16_t CMD_SYSTEM_MODE_DEBUG = 0x0000;
+static constexpr uint16_t CMD_SYSTEM_MODE_ENERGY = 0x0004;
+static constexpr uint16_t CMD_SYSTEM_MODE_VS = 0x0002;
+static constexpr uint16_t CMD_WRITE_ABD_PARAM = 0x0007;
+static constexpr uint16_t CMD_WRITE_REGISTER = 0x0001;
+static constexpr uint16_t CMD_WRITE_SYS_PARAM = 0x0012;

-static const uint8_t CMD_ABD_DATA_REPLY_SIZE = 0x04;
-static const uint8_t CMD_ABD_DATA_REPLY_START = 0x0A;
-static const uint8_t CMD_MAX_BYTES = 0x64;
-static const uint8_t CMD_REG_DATA_REPLY_SIZE = 0x02;
+static constexpr uint8_t CMD_ABD_DATA_REPLY_SIZE = 0x04;
+static constexpr uint8_t CMD_ABD_DATA_REPLY_START = 0x0A;
+static constexpr uint8_t CMD_MAX_BYTES = 0x64;
+static constexpr uint8_t CMD_REG_DATA_REPLY_SIZE = 0x02;

-static const uint8_t LD2420_ERROR_NONE = 0x00;
-static const uint8_t LD2420_ERROR_TIMEOUT = 0x02;
-static const uint8_t LD2420_ERROR_UNKNOWN = 0x01;
+static constexpr uint8_t LD2420_ERROR_NONE = 0x00;
+static constexpr uint8_t LD2420_ERROR_TIMEOUT = 0x02;
+static constexpr uint8_t LD2420_ERROR_UNKNOWN = 0x01;

 // Register address values
-static const uint16_t CMD_MIN_GATE_REG = 0x0000;
-static const uint16_t CMD_MAX_GATE_REG = 0x0001;
-static const uint16_t CMD_TIMEOUT_REG = 0x0004;
-static const uint16_t CMD_GATE_MOVE_THRESH[TOTAL_GATES] = {0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015,
-                                                           0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B,
-                                                           0x001C, 0x001D, 0x001E, 0x001F};
-static const uint16_t CMD_GATE_STILL_THRESH[TOTAL_GATES] = {0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025,
-                                                            0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B,
-                                                            0x002C, 0x002D, 0x002E, 0x002F};
-static const uint32_t FACTORY_MOVE_THRESH[TOTAL_GATES] = {60000, 30000, 400, 250, 250, 250, 250, 250,
-                                                          250,   250,   250, 250, 250, 250, 250, 250};
-static const uint32_t FACTORY_STILL_THRESH[TOTAL_GATES] = {40000, 20000, 200, 200, 200, 200, 200, 150,
-                                                           150,   100,   100, 100, 100, 100, 100, 100};
-static const uint16_t FACTORY_TIMEOUT = 120;
-static const uint16_t FACTORY_MIN_GATE = 1;
-static const uint16_t FACTORY_MAX_GATE = 12;
+static constexpr uint16_t CMD_MIN_GATE_REG = 0x0000;
+static constexpr uint16_t CMD_MAX_GATE_REG = 0x0001;
+static constexpr uint16_t CMD_TIMEOUT_REG = 0x0004;
+static constexpr uint16_t CMD_GATE_MOVE_THRESH[TOTAL_GATES] = {0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015,
+                                                               0x0016, 0x0017, 0x0018, 0x0019, 0x001A, 0x001B,
+                                                               0x001C, 0x001D, 0x001E, 0x001F};
+static constexpr uint16_t CMD_GATE_STILL_THRESH[TOTAL_GATES] = {0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025,
+                                                                0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B,
+                                                                0x002C, 0x002D, 0x002E, 0x002F};
+static constexpr uint32_t FACTORY_MOVE_THRESH[TOTAL_GATES] = {60000, 30000, 400, 250, 250, 250, 250, 250,
+                                                              250,   250,   250, 250, 250, 250, 250, 250};
+static constexpr uint32_t FACTORY_STILL_THRESH[TOTAL_GATES] = {40000, 20000, 200, 200, 200, 200, 200, 150,
+                                                               150,   100,   100, 100, 100, 100, 100, 100};
+static constexpr uint16_t FACTORY_TIMEOUT = 120;
+static constexpr uint16_t FACTORY_MIN_GATE = 1;
+static constexpr uint16_t FACTORY_MAX_GATE = 12;

 // COMMAND_BYTE Header & Footer
-static const uint32_t CMD_FRAME_FOOTER = 0x01020304;
-static const uint32_t CMD_FRAME_HEADER = 0xFAFBFCFD;
-static const uint32_t DEBUG_FRAME_FOOTER = 0xFAFBFCFD;
-static const uint32_t DEBUG_FRAME_HEADER = 0x1410BFAA;
-static const uint32_t ENERGY_FRAME_FOOTER = 0xF5F6F7F8;
-static const uint32_t ENERGY_FRAME_HEADER = 0xF1F2F3F4;
-static const int CALIBRATE_VERSION_MIN = 154;
-static const uint8_t CMD_FRAME_COMMAND = 6;
-static const uint8_t CMD_FRAME_DATA_LENGTH = 4;
-static const uint8_t CMD_FRAME_STATUS = 7;
-static const uint8_t CMD_ERROR_WORD = 8;
-static const uint8_t ENERGY_SENSOR_START = 9;
-static const uint8_t CALIBRATE_REPORT_INTERVAL = 4;
+static constexpr uint32_t CMD_FRAME_FOOTER = 0x01020304;
+static constexpr uint32_t CMD_FRAME_HEADER = 0xFAFBFCFD;
+static constexpr uint32_t DEBUG_FRAME_FOOTER = 0xFAFBFCFD;
+static constexpr uint32_t DEBUG_FRAME_HEADER = 0x1410BFAA;
+static constexpr uint32_t ENERGY_FRAME_FOOTER = 0xF5F6F7F8;
+static constexpr uint32_t ENERGY_FRAME_HEADER = 0xF1F2F3F4;
+static constexpr int CALIBRATE_VERSION_MIN = 154;
+static constexpr uint8_t CMD_FRAME_COMMAND = 6;
+static constexpr uint8_t CMD_FRAME_DATA_LENGTH = 4;
+static constexpr uint8_t CMD_FRAME_STATUS = 7;
+static constexpr uint8_t CMD_ERROR_WORD = 8;
+static constexpr uint8_t ENERGY_SENSOR_START = 9;
+static constexpr uint8_t CALIBRATE_REPORT_INTERVAL = 4;
 static const char *const OP_NORMAL_MODE_STRING = "Normal";
 static const char *const OP_SIMPLE_MODE_STRING = "Simple";

@@ -20,9 +20,11 @@

 namespace esphome::ld2420 {

-static const uint8_t CALIBRATE_SAMPLES = 64;
-static const uint8_t MAX_LINE_LENGTH = 46;  // Max characters for serial buffer
-static const uint8_t TOTAL_GATES = 16;
+static constexpr uint8_t CALIBRATE_SAMPLES = 64;
+// Energy frame is 45 bytes; +1 for null terminator, +4 so that a frame footer always lands
+// inside the buffer during footer-based resynchronization after losing sync.
+static constexpr uint8_t MAX_LINE_LENGTH = 50;
+static constexpr uint8_t TOTAL_GATES = 16;

 enum OpMode : uint8_t {
  OP_NORMAL_MODE = 1,
@@ -776,8 +776,9 @@ void LD2450Component::readline_(int readch) {
    // We should never get here, but just in case...
    ESP_LOGW(TAG, "Max command length exceeded; ignoring");
    this->buffer_pos_ = 0;
+    return;
  }
-  if (this->buffer_pos_ < 4) {
+  if (this->buffer_pos_ < HEADER_FOOTER_SIZE) {
    return;  // Not enough data to process yet
  }
  if (this->buffer_data_[this->buffer_pos_ - 2] == DATA_FRAME_FOOTER[0] &&
@@ -1,5 +1,6 @@
 #pragma once

+#include "esphome/core/automation.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/component.h"
 #ifdef USE_SENSOR
@@ -37,9 +38,11 @@ using namespace ld24xx;

 // Constants
 static constexpr uint8_t DEFAULT_PRESENCE_TIMEOUT = 5;  // Timeout to reset presense status 5 sec.
-static constexpr uint8_t MAX_LINE_LENGTH = 41;          // Max characters for serial buffer
-static constexpr uint8_t MAX_TARGETS = 3;               // Max 3 Targets in LD2450
-static constexpr uint8_t MAX_ZONES = 3;                 // Max 3 Zones in LD2450
+// Zone query response is 40 bytes; +1 for null terminator, +4 so that a frame footer always
+// lands inside the buffer during footer-based resynchronization after losing sync.
+static constexpr uint8_t MAX_LINE_LENGTH = 45;
+static constexpr uint8_t MAX_TARGETS = 3;  // Max 3 Targets in LD2450
+static constexpr uint8_t MAX_ZONES = 3;    // Max 3 Zones in LD2450

 enum Direction : uint8_t {
  DIRECTION_APPROACHING = 0,
@@ -115,7 +115,7 @@ void OpenThreadComponent::ot_main() {
      ESP_LOGE(TAG, "Failed to set OpenThread pollperiod.");
    }
    uint32_t link_polling_period = otLinkGetPollPeriod(esp_openthread_get_instance());
-    ESP_LOGD(TAG, "Link Polling Period: %d", link_polling_period);
+    ESP_LOGD(TAG, "Link Polling Period: %" PRIu32, link_polling_period);
  }
  link_mode_config.mRxOnWhenIdle = this->poll_period == 0;
  link_mode_config.mDeviceType = false;
@@ -2,7 +2,7 @@
 #include "esphome/core/log.h"

 #ifdef HAS_PCNT
-#include <esp_clk_tree.h>
+#include <esp_private/esp_clk.h>
 #include <hal/pcnt_ll.h>
 #endif

@@ -117,9 +117,7 @@ bool HwPulseCounterStorage::pulse_counter_setup(InternalGPIOPin *pin) {
  }

  if (this->filter_us != 0) {
-    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;
+    uint32_t max_glitch_ns = PCNT_LL_MAX_GLITCH_WIDTH * 1000u / ((uint32_t) esp_clk_apb_freq() / 1000000u);
    pcnt_glitch_filter_config_t filter_config = {
        .max_glitch_ns = std::min(this->filter_us * 1000u, max_glitch_ns),
    };
@@ -8,10 +8,10 @@

 #if defined(USE_ESP32)
 #include <soc/soc_caps.h>
-#ifdef SOC_PCNT_SUPPORTED
+#if defined(SOC_PCNT_SUPPORTED) && __has_include(<driver/pulse_cnt.h>)
 #include <driver/pulse_cnt.h>
 #define HAS_PCNT
-#endif  // SOC_PCNT_SUPPORTED
+#endif  // defined(SOC_PCNT_SUPPORTED) && __has_include(<driver/pulse_cnt.h>)
 #endif  // USE_ESP32

 namespace esphome {
@@ -38,8 +38,7 @@ void PulseMeterSensor::setup() {
 }

 void PulseMeterSensor::loop() {
-  // Reset the count in get before we pass it back to the ISR as set
-  this->get_->count_ = 0;
+  State state;

  {
    // Lock the interrupt so the interrupt code doesn't interfere with itself
@@ -58,31 +57,35 @@ void PulseMeterSensor::loop() {
    }
    this->last_pin_val_ = current;

-    // Swap out set and get to get the latest state from the ISR
-    std::swap(this->set_, this->get_);
+    // Get the latest state from the ISR and reset the count in the ISR
+    state.last_detected_edge_us_ = this->state_.last_detected_edge_us_;
+    state.last_rising_edge_us_ = this->state_.last_rising_edge_us_;
+    state.count_ = this->state_.count_;
+    this->state_.count_ = 0;
  }

  const uint32_t now = micros();

  // If an edge was peeked, repay the debt
-  if (this->peeked_edge_ && this->get_->count_ > 0) {
+  if (this->peeked_edge_ && state.count_ > 0) {
    this->peeked_edge_ = false;
-    this->get_->count_--;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    state.count_--;
  }

-  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early
-  if (this->get_->last_rising_edge_us_ != this->get_->last_detected_edge_us_ &&
-      now - this->get_->last_rising_edge_us_ >= this->filter_us_) {
+  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early.
+  // Wait for the debt to be repaid before counting another unprocessed edge early.
+  if (!this->peeked_edge_ && state.last_rising_edge_us_ != state.last_detected_edge_us_ &&
+      now - state.last_rising_edge_us_ >= this->filter_us_) {
    this->peeked_edge_ = true;
-    this->get_->last_detected_edge_us_ = this->get_->last_rising_edge_us_;
-    this->get_->count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    state.last_detected_edge_us_ = state.last_rising_edge_us_;
+    state.count_++;
  }

  // Check if we detected a pulse this loop
-  if (this->get_->count_ > 0) {
+  if (state.count_ > 0) {
    // Keep a running total of pulses if a total sensor is configured
    if (this->total_sensor_ != nullptr) {
-      this->total_pulses_ += this->get_->count_;
+      this->total_pulses_ += state.count_;
      const uint32_t total = this->total_pulses_;
      this->total_sensor_->publish_state(total);
    }
@@ -94,15 +97,15 @@ void PulseMeterSensor::loop() {
        this->meter_state_ = MeterState::RUNNING;
      } break;
      case MeterState::RUNNING: {
-        uint32_t delta_us = this->get_->last_detected_edge_us_ - this->last_processed_edge_us_;
-        float pulse_width_us = delta_us / float(this->get_->count_);
-        ESP_LOGV(TAG, "New pulse, delta: %" PRIu32 " µs, count: %" PRIu32 ", width: %.5f µs", delta_us,
-                 this->get_->count_, pulse_width_us);
+        uint32_t delta_us = state.last_detected_edge_us_ - this->last_processed_edge_us_;
+        float pulse_width_us = delta_us / float(state.count_);
+        ESP_LOGV(TAG, "New pulse, delta: %" PRIu32 " µs, count: %" PRIu32 ", width: %.5f µs", delta_us, state.count_,
+                 pulse_width_us);
        this->publish_state((60.0f * 1000000.0f) / pulse_width_us);
      } break;
    }

-    this->last_processed_edge_us_ = this->get_->last_detected_edge_us_;
+    this->last_processed_edge_us_ = state.last_detected_edge_us_;
  }
  // No detected edges this loop
  else {
@@ -141,14 +144,14 @@ void IRAM_ATTR PulseMeterSensor::edge_intr(PulseMeterSensor *sensor) {
  // This is an interrupt handler - we can't call any virtual method from this method
  // Get the current time before we do anything else so the measurements are consistent
  const uint32_t now = micros();
-  auto &state = sensor->edge_state_;
-  auto &set = *sensor->set_;
+  auto &edge_state = sensor->edge_state_;
+  auto &state = sensor->state_;

-  if ((now - state.last_sent_edge_us_) >= sensor->filter_us_) {
-    state.last_sent_edge_us_ = now;
-    set.last_detected_edge_us_ = now;
-    set.last_rising_edge_us_ = now;
-    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  if ((now - edge_state.last_sent_edge_us_) >= sensor->filter_us_) {
+    edge_state.last_sent_edge_us_ = now;
+    state.last_detected_edge_us_ = now;
+    state.last_rising_edge_us_ = now;
+    state.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
  }

  // This ISR is bound to rising edges, so the pin is high
@@ -160,26 +163,26 @@ void IRAM_ATTR PulseMeterSensor::pulse_intr(PulseMeterSensor *sensor) {
  // Get the current time before we do anything else so the measurements are consistent
  const uint32_t now = micros();
  const bool pin_val = sensor->isr_pin_.digital_read();
-  auto &state = sensor->pulse_state_;
-  auto &set = *sensor->set_;
+  auto &pulse_state = sensor->pulse_state_;
+  auto &state = sensor->state_;

  // Filter length has passed since the last interrupt
-  const bool length = now - state.last_intr_ >= sensor->filter_us_;
+  const bool length = now - pulse_state.last_intr_ >= sensor->filter_us_;

-  if (length && state.latched_ && !sensor->last_pin_val_) {  // Long enough low edge
-    state.latched_ = false;
-  } else if (length && !state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
-    state.latched_ = true;
-    set.last_detected_edge_us_ = state.last_intr_;
-    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  if (length && pulse_state.latched_ && !sensor->last_pin_val_) {  // Long enough low edge
+    pulse_state.latched_ = false;
+  } else if (length && !pulse_state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
+    pulse_state.latched_ = true;
+    state.last_detected_edge_us_ = pulse_state.last_intr_;
+    state.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
  }

  // Due to order of operations this includes
  //    length && latched && rising   (just reset from a long low edge)
  //    !latched && (rising || high)  (noise on the line resetting the potential rising edge)
-  set.last_rising_edge_us_ = !state.latched_ && pin_val ? now : set.last_detected_edge_us_;
+  state.last_rising_edge_us_ = !pulse_state.latched_ && pin_val ? now : state.last_detected_edge_us_;

-  state.last_intr_ = now;
+  pulse_state.last_intr_ = now;
  sensor->last_pin_val_ = pin_val;
 }

@@ -46,17 +46,16 @@ class PulseMeterSensor : public sensor::Sensor, public Component {
  uint32_t total_pulses_ = 0;
  uint32_t last_processed_edge_us_ = 0;

-  // This struct (and the two pointers) are used to pass data between the ISR and loop.
-  // These two pointers are exchanged each loop.
-  // Use these to send data from the ISR to the loop not the other way around (except for resetting the values).
+  // This struct and variable are used to pass data between the ISR and loop.
+  // The data from state_ is read and then count_ in state_ is reset in each loop.
+  // This must be done while guarded by an InterruptLock. Use this variable to send data
+  // from the ISR to the loop not the other way around (except for resetting count_).
  struct State {
    uint32_t last_detected_edge_us_ = 0;
    uint32_t last_rising_edge_us_ = 0;
    uint32_t count_ = 0;
  };
-  State state_[2];
-  volatile State *set_ = state_;
-  volatile State *get_ = state_ + 1;
+  volatile State state_{};

  // Only use the following variables in the ISR or while guarded by an InterruptLock
  ISRInternalGPIOPin isr_pin_;
@@ -119,6 +119,8 @@ class RemoteComponentBase {
 };

 #ifdef USE_ESP32
+#include <soc/soc_caps.h>
+#if SOC_RMT_SUPPORTED
 class RemoteRMTChannel {
 public:
  void set_clock_resolution(uint32_t clock_resolution) { this->clock_resolution_ = clock_resolution; }
@@ -137,7 +139,8 @@ class RemoteRMTChannel {
  uint32_t clock_resolution_{1000000};
  uint32_t rmt_symbols_;
 };
-#endif
+#endif  // SOC_RMT_SUPPORTED
+#endif  // USE_ESP32

 class RemoteTransmitterBase : public RemoteComponentBase {
 public:
@@ -65,6 +65,8 @@ RemoteReceiverComponent = remote_receiver_ns.class_(
 def validate_config(config):
    if CORE.is_esp32:
        variant = esp32.get_esp32_variant()
+        if variant in esp32_rmt.VARIANTS_NO_RMT:
+            return config
        if variant in (esp32.VARIANT_ESP32, esp32.VARIANT_ESP32S2):
            max_idle = 65535
        else:
@@ -110,6 +112,8 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
            cv.SplitDefault(
                CONF_BUFFER_SIZE,
                esp32="10000b",
+                esp32_c2="1000b",
+                esp32_c61="1000b",
                esp8266="1000b",
                bk72xx="1000b",
                ln882x="1000b",
@@ -131,9 +135,11 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
            cv.SplitDefault(
                CONF_RMT_SYMBOLS,
                esp32=192,
+                esp32_c2=cv.UNDEFINED,
                esp32_c3=96,
                esp32_c5=96,
                esp32_c6=96,
+                esp32_c61=cv.UNDEFINED,
                esp32_h2=96,
                esp32_p4=192,
                esp32_s2=192,
@@ -145,6 +151,8 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
            cv.SplitDefault(
                CONF_RECEIVE_SYMBOLS,
                esp32=192,
+                esp32_c2=cv.UNDEFINED,
+                esp32_c61=cv.UNDEFINED,
            ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
            cv.Optional(CONF_USE_DMA): cv.All(
                esp32.only_on_variant(
@@ -152,24 +160,45 @@ CONFIG_SCHEMA = remote_base.validate_triggers(
                ),
                cv.boolean,
            ),
-            cv.SplitDefault(CONF_CARRIER_DUTY_PERCENT, esp32=100): cv.All(
+            cv.SplitDefault(
+                CONF_CARRIER_DUTY_PERCENT,
+                esp32=100,
+                esp32_c2=cv.UNDEFINED,
+                esp32_c61=cv.UNDEFINED,
+            ): cv.All(
                cv.only_on_esp32,
                cv.percentage_int,
                cv.Range(min=1, max=100),
            ),
-            cv.SplitDefault(CONF_CARRIER_FREQUENCY, esp32="0Hz"): cv.All(
-                cv.only_on_esp32, cv.frequency, cv.int_
-            ),
+            cv.SplitDefault(
+                CONF_CARRIER_FREQUENCY,
+                esp32="0Hz",
+                esp32_c2=cv.UNDEFINED,
+                esp32_c61=cv.UNDEFINED,
+            ): cv.All(cv.only_on_esp32, cv.frequency, cv.int_),
        }
    )
    .extend(cv.COMPONENT_SCHEMA)
+    .add_extra(
+        esp32_rmt.validate_rmt_not_supported(
+            [
+                CONF_CLOCK_RESOLUTION,
+                CONF_USE_DMA,
+                CONF_RMT_SYMBOLS,
+                CONF_FILTER_SYMBOLS,
+                CONF_RECEIVE_SYMBOLS,
+                CONF_CARRIER_DUTY_PERCENT,
+                CONF_CARRIER_FREQUENCY,
+            ]
+        )
+    )
    .add_extra(validate_config)
 )


 async def to_code(config):
    pin = await cg.gpio_pin_expression(config[CONF_PIN])
-    if CORE.is_esp32:
+    if CORE.is_esp32 and esp32.get_esp32_variant() not in esp32_rmt.VARIANTS_NO_RMT:
        # Re-enable ESP-IDF's RMT driver (excluded by default to save compile time)
        esp32.include_builtin_idf_component("esp_driver_rmt")

@@ -213,6 +242,8 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
            PlatformFramework.ESP32_IDF,
        },
        "remote_receiver.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
            PlatformFramework.ESP8266_ARDUINO,
            PlatformFramework.BK72XX_ARDUINO,
            PlatformFramework.RTL87XX_ARDUINO,
@@ -3,7 +3,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

-#if defined(USE_LIBRETINY) || defined(USE_ESP8266) || defined(USE_RP2040)
+#if defined(USE_LIBRETINY) || defined(USE_ESP8266) || defined(USE_RP2040) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)

 namespace esphome::remote_receiver {

@@ -6,12 +6,15 @@
 #include <cinttypes>

 #if defined(USE_ESP32)
+#include <soc/soc_caps.h>
+#if SOC_RMT_SUPPORTED
 #include <driver/rmt_rx.h>
-#endif
+#endif  // SOC_RMT_SUPPORTED
+#endif  // USE_ESP32

 namespace esphome::remote_receiver {

-#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2040)
+#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2040) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
 struct RemoteReceiverComponentStore {
  static void gpio_intr(RemoteReceiverComponentStore *arg);

@@ -35,7 +38,7 @@ struct RemoteReceiverComponentStore {
  volatile bool prev_level{false};
  volatile bool overflow{false};
 };
-#elif defined(USE_ESP32)
+#elif defined(USE_ESP32) && SOC_RMT_SUPPORTED
 struct RemoteReceiverComponentStore {
  /// Stores RMT symbols and rx done event data
  volatile uint8_t *buffer{nullptr};
@@ -54,7 +57,7 @@ struct RemoteReceiverComponentStore {

 class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
                                public Component
-#ifdef USE_ESP32
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
    ,
                                public remote_base::RemoteRMTChannel
 #endif
@@ -66,7 +69,7 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
  void dump_config() override;
  void loop() override;

-#ifdef USE_ESP32
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
  void set_filter_symbols(uint32_t filter_symbols) { this->filter_symbols_ = filter_symbols; }
  void set_receive_symbols(uint32_t receive_symbols) { this->receive_symbols_ = receive_symbols; }
  void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
@@ -78,7 +81,7 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
  void set_idle_us(uint32_t idle_us) { this->idle_us_ = idle_us; }

 protected:
-#ifdef USE_ESP32
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
  void decode_rmt_(rmt_symbol_word_t *item, size_t item_count);
  rmt_channel_handle_t channel_{NULL};
  uint32_t filter_symbols_{0};
@@ -94,7 +97,7 @@ class RemoteReceiverComponent : public remote_base::RemoteReceiverBase,
  RemoteReceiverComponentStore store_;
 #endif

-#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2040)
+#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2040) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
  HighFrequencyLoopRequester high_freq_;
 #endif

@@ -2,6 +2,8 @@
 #include "esphome/core/log.h"

 #ifdef USE_ESP32
+#include <soc/soc_caps.h>
+#if SOC_RMT_SUPPORTED
 #include <driver/gpio.h>
 #include <esp_clk_tree.h>

@@ -248,4 +250,5 @@ void RemoteReceiverComponent::decode_rmt_(rmt_symbol_word_t *item, size_t item_c

 }  // namespace esphome::remote_receiver

-#endif
+#endif  // SOC_RMT_SUPPORTED
+#endif  // USE_ESP32
@@ -40,45 +40,66 @@ DigitalWriteAction = remote_transmitter_ns.class_(
    cg.Parented.template(RemoteTransmitterComponent),
 )

+
 MULTI_CONF = True
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(RemoteTransmitterComponent),
-        cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
-        cv.Required(CONF_CARRIER_DUTY_PERCENT): cv.All(
-            cv.percentage_int, cv.Range(min=1, max=100)
-        ),
-        cv.Optional(CONF_CLOCK_RESOLUTION): cv.All(
-            cv.only_on_esp32,
-            esp32_rmt.validate_clock_resolution(),
-        ),
-        cv.Optional(CONF_EOT_LEVEL): cv.All(cv.only_on_esp32, cv.boolean),
-        cv.Optional(CONF_USE_DMA): cv.All(
-            esp32.only_on_variant(
-                supported=[esp32.VARIANT_ESP32P4, esp32.VARIANT_ESP32S3]
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(RemoteTransmitterComponent),
+            cv.Required(CONF_PIN): pins.gpio_output_pin_schema,
+            cv.Required(CONF_CARRIER_DUTY_PERCENT): cv.All(
+                cv.percentage_int, cv.Range(min=1, max=100)
            ),
-            cv.boolean,
-        ),
-        cv.SplitDefault(
-            CONF_RMT_SYMBOLS,
-            esp32=64,
-            esp32_c3=48,
-            esp32_c5=48,
-            esp32_c6=48,
-            esp32_h2=48,
-            esp32_p4=48,
-            esp32_s2=64,
-            esp32_s3=48,
-        ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
-        cv.Optional(CONF_NON_BLOCKING): cv.All(cv.only_on_esp32, cv.boolean),
-        cv.Optional(CONF_ON_TRANSMIT): automation.validate_automation(single=True),
-        cv.Optional(CONF_ON_COMPLETE): automation.validate_automation(single=True),
-    }
-).extend(cv.COMPONENT_SCHEMA)
+            cv.Optional(CONF_CLOCK_RESOLUTION): cv.All(
+                cv.only_on_esp32,
+                esp32_rmt.validate_clock_resolution(),
+            ),
+            cv.Optional(CONF_EOT_LEVEL): cv.All(cv.only_on_esp32, cv.boolean),
+            cv.Optional(CONF_USE_DMA): cv.All(
+                esp32.only_on_variant(
+                    supported=[esp32.VARIANT_ESP32P4, esp32.VARIANT_ESP32S3]
+                ),
+                cv.boolean,
+            ),
+            cv.SplitDefault(
+                CONF_RMT_SYMBOLS,
+                esp32=64,
+                esp32_c2=cv.UNDEFINED,
+                esp32_c3=48,
+                esp32_c5=48,
+                esp32_c6=48,
+                esp32_c61=cv.UNDEFINED,
+                esp32_h2=48,
+                esp32_p4=48,
+                esp32_s2=64,
+                esp32_s3=48,
+            ): cv.All(cv.only_on_esp32, cv.int_range(min=2)),
+            cv.Optional(CONF_NON_BLOCKING): cv.All(cv.only_on_esp32, cv.boolean),
+            cv.Optional(CONF_ON_TRANSMIT): automation.validate_automation(single=True),
+            cv.Optional(CONF_ON_COMPLETE): automation.validate_automation(single=True),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .add_extra(
+        esp32_rmt.validate_rmt_not_supported(
+            [
+                CONF_CLOCK_RESOLUTION,
+                CONF_EOT_LEVEL,
+                CONF_USE_DMA,
+                CONF_RMT_SYMBOLS,
+                CONF_NON_BLOCKING,
+            ]
+        )
+    )
+)


 def _validate_non_blocking(config):
-    if CORE.is_esp32 and CONF_NON_BLOCKING not in config:
+    if (
+        CORE.is_esp32
+        and esp32.get_esp32_variant() not in esp32_rmt.VARIANTS_NO_RMT
+        and CONF_NON_BLOCKING not in config
+    ):
        _LOGGER.warning(
            "'non_blocking' is not set for 'remote_transmitter' and will default to 'true'.\n"
            "The default behavior changed in 2025.11.0; previously blocking mode was used.\n"
@@ -111,7 +132,7 @@ async def digital_write_action_to_code(config, action_id, template_arg, args):

 async def to_code(config):
    pin = await cg.gpio_pin_expression(config[CONF_PIN])
-    if CORE.is_esp32:
+    if CORE.is_esp32 and esp32.get_esp32_variant() not in esp32_rmt.VARIANTS_NO_RMT:
        # Re-enable ESP-IDF's RMT driver (excluded by default to save compile time)
        esp32.include_builtin_idf_component("esp_driver_rmt")

@@ -155,6 +176,8 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
            PlatformFramework.ESP32_IDF,
        },
        "remote_transmitter.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
            PlatformFramework.ESP8266_ARDUINO,
            PlatformFramework.BK72XX_ARDUINO,
            PlatformFramework.RTL87XX_ARDUINO,
@@ -5,8 +5,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"

-namespace esphome {
-namespace remote_transmitter {
+namespace esphome::remote_transmitter {

 template<typename... Ts> class DigitalWriteAction : public Action<Ts...>, public Parented<RemoteTransmitterComponent> {
 public:
@@ -14,5 +13,4 @@ template<typename... Ts> class DigitalWriteAction : public Action<Ts...>, public
  void play(const Ts &...x) override { this->parent_->digital_write(this->value_.value(x...)); }
 };

-}  // namespace remote_transmitter
-}  // namespace esphome
+}  // namespace esphome::remote_transmitter
@@ -2,10 +2,9 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"

-#if defined(USE_LIBRETINY) || defined(USE_ESP8266) || defined(USE_RP2040)
+#if defined(USE_LIBRETINY) || defined(USE_ESP8266) || defined(USE_RP2040) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)

-namespace esphome {
-namespace remote_transmitter {
+namespace esphome::remote_transmitter {

 static const char *const TAG = "remote_transmitter";

@@ -105,7 +104,6 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
  this->complete_trigger_.trigger();
 }

-}  // namespace remote_transmitter
-}  // namespace esphome
+}  // namespace esphome::remote_transmitter

 #endif
@@ -6,13 +6,15 @@
 #include <vector>

 #if defined(USE_ESP32)
+#include <soc/soc_caps.h>
+#if SOC_RMT_SUPPORTED
 #include <driver/rmt_tx.h>
-#endif
+#endif  // SOC_RMT_SUPPORTED
+#endif  // USE_ESP32

-namespace esphome {
-namespace remote_transmitter {
+namespace esphome::remote_transmitter {

-#ifdef USE_ESP32
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
 // IDF version 5.5.1 and above is required because of a bug in
 // the RMT encoder: https://github.com/espressif/esp-idf/issues/17244
@@ -33,7 +35,7 @@ struct RemoteTransmitterComponentStore {

 class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
                                   public Component
-#ifdef USE_ESP32
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
    ,
                                   public remote_base::RemoteRMTChannel
 #endif
@@ -51,7 +53,7 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,

  void digital_write(bool value);

-#if defined(USE_ESP32)
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
  void set_with_dma(bool with_dma) { this->with_dma_ = with_dma; }
  void set_eot_level(bool eot_level) { this->eot_level_ = eot_level; }
  void set_non_blocking(bool non_blocking) { this->non_blocking_ = non_blocking; }
@@ -62,7 +64,7 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,

 protected:
  void send_internal(uint32_t send_times, uint32_t send_wait) override;
-#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2040)
+#if defined(USE_ESP8266) || defined(USE_LIBRETINY) || defined(USE_RP2040) || (defined(USE_ESP32) && !SOC_RMT_SUPPORTED)
  void calculate_on_off_time_(uint32_t carrier_frequency, uint32_t *on_time_period, uint32_t *off_time_period);

  void mark_(uint32_t on_time, uint32_t off_time, uint32_t usec);
@@ -73,7 +75,7 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
  uint32_t target_time_;
 #endif

-#ifdef USE_ESP32
+#if defined(USE_ESP32) && SOC_RMT_SUPPORTED
  void configure_rmt_();
  void wait_for_rmt_();

@@ -100,5 +102,4 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
  Trigger<> complete_trigger_;
 };

-}  // namespace remote_transmitter
-}  // namespace esphome
+}  // namespace esphome::remote_transmitter
@@ -3,10 +3,11 @@
 #include "esphome/core/application.h"

 #ifdef USE_ESP32
+#include <soc/soc_caps.h>
+#if SOC_RMT_SUPPORTED
 #include <driver/gpio.h>

-namespace esphome {
-namespace remote_transmitter {
+namespace esphome::remote_transmitter {

 static const char *const TAG = "remote_transmitter";

@@ -358,7 +359,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
 }
 #endif

-}  // namespace remote_transmitter
-}  // namespace esphome
+}  // namespace esphome::remote_transmitter

-#endif
+#endif  // SOC_RMT_SUPPORTED
+#endif  // USE_ESP32
@@ -11,6 +11,7 @@

 #if defined(USE_ESP32) && defined(USE_OTA_ROLLBACK)
 #include <esp_ota_ops.h>
+#include <esp_system.h>
 #endif

 namespace esphome::safe_mode {
@@ -54,6 +55,10 @@ void SafeModeComponent::dump_config() {
             "OTA rollback detected! Rolled back from partition '%s'\n"
             "The device reset before the boot was marked successful",
             last_invalid->label);
+    if (esp_reset_reason() == ESP_RST_BROWNOUT) {
+      ESP_LOGW(TAG, "Last reset was due to brownout - check your power supply!\n"
+                    "See https://esphome.io/guides/faq.html#brownout-detector-was-triggered");
+    }
  }
 #endif
 }
@@ -59,8 +59,14 @@ size_t format_sockaddr_to(const struct sockaddr *addr_ptr, socklen_t len, std::s
 #if USE_NETWORK_IPV6
  else if (addr_ptr->sa_family == AF_INET6 && len >= sizeof(sockaddr_in6)) {
    const auto *addr = reinterpret_cast<const struct sockaddr_in6 *>(addr_ptr);
-#ifndef USE_SOCKET_IMPL_LWIP_TCP
-    // Format IPv4-mapped IPv6 addresses as regular IPv4 (not supported on ESP8266 raw TCP)
+#ifdef USE_HOST
+    // Format IPv4-mapped IPv6 addresses as regular IPv4 (POSIX layout, no LWIP union)
+    if (IN6_IS_ADDR_V4MAPPED(&addr->sin6_addr) &&
+        esphome_inet_ntop4(&addr->sin6_addr.s6_addr[12], buf.data(), buf.size()) != nullptr) {
+      return strlen(buf.data());
+    }
+#elif !defined(USE_SOCKET_IMPL_LWIP_TCP)
+    // Format IPv4-mapped IPv6 addresses as regular IPv4 (LWIP layout)
    if (addr->sin6_addr.un.u32_addr[0] == 0 && addr->sin6_addr.un.u32_addr[1] == 0 &&
        addr->sin6_addr.un.u32_addr[2] == htonl(0xFFFF) &&
        esphome_inet_ntop4(&addr->sin6_addr.un.u32_addr[3], buf.data(), buf.size()) != nullptr) {
@@ -7,15 +7,15 @@ namespace speed {
 static const char *const TAG = "speed.fan";

 void SpeedFan::setup() {
+  // Construct traits before restore so preset modes can be looked up by index
+  this->traits_ = fan::FanTraits(this->oscillating_ != nullptr, true, this->direction_ != nullptr, this->speed_count_);
+  this->traits_.set_supported_preset_modes(this->preset_modes_);
+
  auto restore = this->restore_state_();
  if (restore.has_value()) {
    restore->apply(*this);
    this->write_state_();
  }
-
-  // Construct traits
-  this->traits_ = fan::FanTraits(this->oscillating_ != nullptr, true, this->direction_ != nullptr, this->speed_count_);
-  this->traits_.set_supported_preset_modes(this->preset_modes_);
 }

 void SpeedFan::dump_config() { LOG_FAN("", "Speed Fan", this); }
@@ -6,15 +6,15 @@ namespace esphome::template_ {
 static const char *const TAG = "template.fan";

 void TemplateFan::setup() {
+  // Construct traits before restore so preset modes can be looked up by index
+  this->traits_ =
+      fan::FanTraits(this->has_oscillating_, this->speed_count_ > 0, this->has_direction_, this->speed_count_);
+  this->traits_.set_supported_preset_modes(this->preset_modes_);
+
  auto restore = this->restore_state_();
  if (restore.has_value()) {
    restore->apply(*this);
  }
-
-  // Construct traits
-  this->traits_ =
-      fan::FanTraits(this->has_oscillating_, this->speed_count_ > 0, this->has_direction_, this->speed_count_);
-  this->traits_.set_supported_preset_modes(this->preset_modes_);
 }

 void TemplateFan::dump_config() { LOG_FAN("", "Template Fan", this); }
@@ -19,6 +19,13 @@ namespace esphome::uart {

 static const char *const TAG = "uart.idf";

+/// Check if a pin number matches one of the default UART0 GPIO pins.
+/// These pins may have residual state from the boot console that requires
+/// explicit reset before UART reconfiguration (ESP-IDF issue #17459).
+static constexpr bool is_default_uart0_pin(int8_t pin_num) {
+  return pin_num == U0TXD_GPIO_NUM || pin_num == U0RXD_GPIO_NUM;
+}
+
 uart_config_t IDFUARTComponent::get_config_() {
  uart_parity_t parity = UART_PARITY_DISABLE;
  if (this->parity_ == UART_CONFIG_PARITY_EVEN) {
@@ -90,7 +97,6 @@ void IDFUARTComponent::setup() {
    return;
  }
  this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
-  this->lock_ = xSemaphoreCreateMutex();

 #if (SOC_UART_LP_NUM >= 1)
  size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
@@ -102,11 +108,7 @@ void IDFUARTComponent::setup() {
    this->rx_buffer_size_ = fifo_len * 2;
  }

-  xSemaphoreTake(this->lock_, portMAX_DELAY);
-
  this->load_settings(false);
-
-  xSemaphoreGive(this->lock_);
 }

 void IDFUARTComponent::load_settings(bool dump_config) {
@@ -126,13 +128,20 @@ void IDFUARTComponent::load_settings(bool dump_config) {
      return;
    }
  }
+#ifdef USE_UART_WAKE_LOOP_ON_RX
+  constexpr int event_queue_size = 20;
+  QueueHandle_t *event_queue_ptr = &this->uart_event_queue_;
+#else
+  constexpr int event_queue_size = 0;
+  QueueHandle_t *event_queue_ptr = nullptr;
+#endif
  err = uart_driver_install(this->uart_num_,        // UART number
                            this->rx_buffer_size_,  // RX ring buffer size
-                            0,   // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
-                                 // block task until all data has been sent out
-                            20,  // event queue size/depth
-                            &this->uart_event_queue_,  // event queue
-                            0                          // Flags used to allocate the interrupt
+                            0,  // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
+                                // block task until all data has been sent out
+                            event_queue_size,  // event queue size/depth
+                            event_queue_ptr,   // event queue
+                            0                  // Flags used to allocate the interrupt
  );
  if (err != ESP_OK) {
    ESP_LOGW(TAG, "uart_driver_install failed: %s", esp_err_to_name(err));
@@ -148,20 +157,26 @@ void IDFUARTComponent::load_settings(bool dump_config) {
  // Commit 9ed617fb17 removed gpio_func_sel() calls from uart_set_pin(), which breaks
  // UART on default UART0 pins that may have residual state from boot console.
  // Reset these pins before configuring UART to ensure they're in a clean state.
-  if (tx == U0TXD_GPIO_NUM || tx == U0RXD_GPIO_NUM) {
+  if (is_default_uart0_pin(tx)) {
    gpio_reset_pin(static_cast<gpio_num_t>(tx));
  }
-  if (rx == U0TXD_GPIO_NUM || rx == U0RXD_GPIO_NUM) {
+  if (is_default_uart0_pin(rx)) {
    gpio_reset_pin(static_cast<gpio_num_t>(rx));
  }

-  // Setup pins after reset to preserve open drain/pullup/pulldown flags
+  // Setup pins after reset to configure GPIO direction and pull resistors.
+  // For UART0 default pins, setup() must always be called because gpio_reset_pin()
+  // above sets GPIO_MODE_DISABLE which disables the input buffer. Without setup(),
+  // uart_set_pin() on ESP-IDF 5.4.2+ does not re-enable the input buffer for
+  // IOMUX-connected pins, so the RX pin cannot receive data (see issue #10132).
+  // For other pins, only call setup() if pull or open-drain flags are set to avoid
+  // disturbing the default pin state which breaks some external components (#11823).
  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
    if (!pin) {
      return;
    }
    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
-    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
+    if (is_default_uart0_pin(pin->get_pin()) || (pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
      pin->setup();
    }
  };
@@ -282,9 +297,7 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 }

 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
-  xSemaphoreTake(this->lock_, portMAX_DELAY);
  int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
-  xSemaphoreGive(this->lock_);
  if (write_len != (int32_t) len) {
    ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
    this->mark_failed();
@@ -299,7 +312,6 @@ void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
 bool IDFUARTComponent::peek_byte(uint8_t *data) {
  if (!this->check_read_timeout_())
    return false;
-  xSemaphoreTake(this->lock_, portMAX_DELAY);
  if (this->has_peek_) {
    *data = this->peek_byte_;
  } else {
@@ -311,7 +323,6 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
      this->peek_byte_ = *data;
    }
  }
-  xSemaphoreGive(this->lock_);
  return true;
 }

@@ -320,7 +331,6 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
  int32_t read_len = 0;
  if (!this->check_read_timeout_(len))
    return false;
-  xSemaphoreTake(this->lock_, portMAX_DELAY);
  if (this->has_peek_) {
    length_to_read--;
    *data = this->peek_byte_;
@@ -329,7 +339,6 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
  }
  if (length_to_read > 0)
    read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
-  xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
  for (size_t i = 0; i < len; i++) {
    this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
@@ -342,9 +351,7 @@ size_t IDFUARTComponent::available() {
  size_t available = 0;
  esp_err_t err;

-  xSemaphoreTake(this->lock_, portMAX_DELAY);
  err = uart_get_buffered_data_len(this->uart_num_, &available);
-  xSemaphoreGive(this->lock_);

  if (err != ESP_OK) {
    ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
@@ -358,9 +365,7 @@ size_t IDFUARTComponent::available() {

 void IDFUARTComponent::flush() {
  ESP_LOGVV(TAG, "    Flushing");
-  xSemaphoreTake(this->lock_, portMAX_DELAY);
  uart_wait_tx_done(this->uart_num_, portMAX_DELAY);
-  xSemaphoreGive(this->lock_);
 }

 void IDFUARTComponent::check_logger_conflict() {}
@@ -384,6 +389,13 @@ void IDFUARTComponent::start_rx_event_task_() {
  ESP_LOGV(TAG, "RX event task started");
 }

+// FreeRTOS task that relays UART ISR events to the main loop.
+// This task exists because wake_loop_threadsafe() is not ISR-safe (it uses a
+// UDP loopback socket), so we need a task as an ISR-to-main-loop trampoline.
+// IMPORTANT: This task must NOT call any UART wrapper methods (read_array,
+// write_array, peek_byte, etc.) or touch has_peek_/peek_byte_ — all reading
+// is done by the main loop. This task only reads from the event queue and
+// calls App.wake_loop_threadsafe().
 void IDFUARTComponent::rx_event_task_func(void *param) {
  auto *self = static_cast<IDFUARTComponent *>(param);
  uart_event_t event;
@@ -405,8 +417,14 @@ void IDFUARTComponent::rx_event_task_func(void *param) {

        case UART_FIFO_OVF:
        case UART_BUFFER_FULL:
-          ESP_LOGW(TAG, "FIFO overflow or ring buffer full - clearing");
-          uart_flush_input(self->uart_num_);
+          // Don't call uart_flush_input() here — this task does not own the read side.
+          // ESP-IDF examples flush on overflow because the same task handles both events
+          // and reads, so flush and read are serialized. Here, reads happen on the main
+          // loop, so flushing from this task races with read_array() and can destroy data
+          // mid-read. The driver self-heals without an explicit flush: uart_read_bytes()
+          // calls uart_check_buf_full() after each chunk, which moves stashed FIFO bytes
+          // into the ring buffer and re-enables RX interrupts once space is freed.
+          ESP_LOGW(TAG, "FIFO overflow or ring buffer full");
 #if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
          App.wake_loop_threadsafe();
 #endif
@@ -8,6 +8,13 @@

 namespace esphome::uart {

+/// ESP-IDF UART driver wrapper.
+///
+/// Thread safety: All public methods must only be called from the main loop.
+/// The ESP-IDF UART driver API does not guarantee thread safety, and ESPHome's
+/// peek byte state (has_peek_/peek_byte_) is not synchronized. The rx_event_task
+/// (when enabled) must not call any of these methods — it communicates with the
+/// main loop exclusively via App.wake_loop_threadsafe().
 class IDFUARTComponent : public UARTComponent, public Component {
 public:
  void setup() override;
@@ -26,7 +33,9 @@ class IDFUARTComponent : public UARTComponent, public Component {
  void flush() override;

  uint8_t get_hw_serial_number() { return this->uart_num_; }
+#ifdef USE_UART_WAKE_LOOP_ON_RX
  QueueHandle_t *get_uart_event_queue() { return &this->uart_event_queue_; }
+#endif

  /**
   * Load the UART with the current settings.
@@ -46,18 +55,20 @@ class IDFUARTComponent : public UARTComponent, public Component {
 protected:
  void check_logger_conflict() override;
  uart_port_t uart_num_;
-  QueueHandle_t uart_event_queue_;
  uart_config_t get_config_();
-  SemaphoreHandle_t lock_;

  bool has_peek_{false};
  uint8_t peek_byte_;

 #ifdef USE_UART_WAKE_LOOP_ON_RX
-  // RX notification support
+  // RX notification support — runs on a separate FreeRTOS task.
+  // IMPORTANT: rx_event_task_func must NOT call any UART wrapper methods (read_array,
+  // write_array, etc.) or touch has_peek_/peek_byte_. It must only read from the
+  // event queue and call App.wake_loop_threadsafe().
  void start_rx_event_task_();
  static void rx_event_task_func(void *param);

+  QueueHandle_t uart_event_queue_;
  TaskHandle_t rx_event_task_handle_{nullptr};
 #endif  // USE_UART_WAKE_LOOP_ON_RX
 };
@@ -14,6 +14,7 @@ import esphome.config_validation as cv
 from esphome.const import CONF_DATA, CONF_ID, CONF_PORT, CONF_TRIGGER_ID
 from esphome.core import ID
 from esphome.cpp_generator import MockObj
+from esphome.types import ConfigType

 CODEOWNERS = ["@clydebarrow"]
 DEPENDENCIES = ["network"]
@@ -65,33 +66,47 @@ RELOCATED = {
    )
 }

-CONFIG_SCHEMA = cv.COMPONENT_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(UDPComponent),
-        cv.Optional(CONF_PORT, default=18511): cv.Any(
-            cv.port,
-            cv.Schema(
+
+def _consume_udp_sockets(config: ConfigType) -> ConfigType:
+    """Register socket needs for UDP component."""
+    from esphome.components import socket
+
+    # UDP uses up to 2 sockets: 1 broadcast + 1 listen
+    # Whether each is used depends on code generation, so register worst case
+    socket.consume_sockets(2, "udp")(config)
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.COMPONENT_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(UDPComponent),
+            cv.Optional(CONF_PORT, default=18511): cv.Any(
+                cv.port,
+                cv.Schema(
+                    {
+                        cv.Required(CONF_LISTEN_PORT): cv.port,
+                        cv.Required(CONF_BROADCAST_PORT): cv.port,
+                    }
+                ),
+            ),
+            cv.Optional(
+                CONF_LISTEN_ADDRESS, default="255.255.255.255"
+            ): cv.ipv4address_multi_broadcast,
+            cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
+                cv.ipv4address,
+            ),
+            cv.Optional(CONF_ON_RECEIVE): automation.validate_automation(
                {
-                    cv.Required(CONF_LISTEN_PORT): cv.port,
-                    cv.Required(CONF_BROADCAST_PORT): cv.port,
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                        Trigger.template(trigger_args)
+                    ),
                }
            ),
-        ),
-        cv.Optional(
-            CONF_LISTEN_ADDRESS, default="255.255.255.255"
-        ): cv.ipv4address_multi_broadcast,
-        cv.Optional(CONF_ADDRESSES, default=["255.255.255.255"]): cv.ensure_list(
-            cv.ipv4address,
-        ),
-        cv.Optional(CONF_ON_RECEIVE): automation.validate_automation(
-            {
-                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                    Trigger.template(trigger_args)
-                ),
-            }
-        ),
-    }
-).extend(RELOCATED)
+        }
+    ).extend(RELOCATED),
+    _consume_udp_sockets,
+)


 async def register_udp_client(var, config):
@@ -144,9 +144,10 @@ def _consume_web_server_sockets(config: ConfigType) -> ConfigType:
    """Register socket needs for web_server component."""
    from esphome.components import socket

-    # Web server needs 1 listening socket + typically 2 concurrent client connections
-    # (browser makes 2 connections for page + event stream)
-    sockets_needed = 3
+    # Web server needs 1 listening socket + typically 5 concurrent client connections
+    # (browser opens connections for page resources, SSE event stream, and POST
+    # requests for entity control which may linger before closing)
+    sockets_needed = 6
    socket.consume_sockets(sockets_needed, "web_server")(config)
    return config

@@ -1913,6 +1913,9 @@ std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDe
    JsonArray modes = root[ESPHOME_F("modes")].to<JsonArray>();
    for (auto m : traits.get_supported_modes())
      modes.add(PSTR_LOCAL(water_heater::water_heater_mode_to_string(m)));
+    root[ESPHOME_F("min_temp")] = traits.get_min_temperature();
+    root[ESPHOME_F("max_temp")] = traits.get_max_temperature();
+    root[ESPHOME_F("step")] = traits.get_target_temperature_step();
    this->add_sorting_info_(root, obj);
  }

@@ -1935,10 +1938,6 @@ std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDe
      root[ESPHOME_F("target_temperature")] = target;
  }

-  root[ESPHOME_F("min_temperature")] = traits.get_min_temperature();
-  root[ESPHOME_F("max_temperature")] = traits.get_max_temperature();
-  root[ESPHOME_F("step")] = traits.get_target_temperature_step();
-
  if (traits.get_supports_away_mode()) {
    root[ESPHOME_F("away")] = obj->is_away();
  }
@@ -1,4 +1,5 @@
 import logging
+import math

 from esphome import automation
 from esphome.automation import Condition
@@ -493,6 +494,13 @@ async def to_code(config):
        cg.add(var.set_passive_scan(True))
    if CONF_OUTPUT_POWER in config:
        cg.add(var.set_output_power(config[CONF_OUTPUT_POWER]))
+        if CORE.is_esp32:
+            # Set PHY max TX power to match output_power so calibration also uses
+            # reduced power. This prevents brownout during PHY init on marginal
+            # power supplies, which is critical for OTA updates with rollback enabled.
+            # Kconfig range is 10-20, ESPHome allows 8.5-20.5
+            phy_tx_power = max(10, min(20, math.ceil(config[CONF_OUTPUT_POWER])))
+            add_idf_sdkconfig_option("CONFIG_ESP_PHY_MAX_WIFI_TX_POWER", phy_tx_power)
    # enable_on_boot defaults to true in C++ - only set if false
    if not config[CONF_ENABLE_ON_BOOT]:
        cg.add(var.set_enable_on_boot(False))
@@ -216,23 +216,16 @@ bool WiFiComponent::wifi_apply_hostname_() {
    ESP_LOGV(TAG, "Set hostname failed");
  }

-  // inform dhcp server of hostname change using dhcp_renew()
+  // Update hostname on all lwIP interfaces so DHCP packets include it.
+  // lwIP includes the hostname in DHCP DISCOVER/REQUEST automatically
+  // via LWIP_NETIF_HOSTNAME — no dhcp_renew() needed. The hostname is
+  // fixed at compile time and never changes at runtime.
  for (netif *intf = netif_list; intf; intf = intf->next) {
-    // unconditionally update all known interfaces
 #if LWIP_VERSION_MAJOR == 1
    intf->hostname = (char *) wifi_station_get_hostname();
 #else
    intf->hostname = wifi_station_get_hostname();
 #endif
-    if (netif_dhcp_data(intf) != nullptr) {
-      // renew already started DHCP leases
-      err_t lwipret = dhcp_renew(intf);
-      if (lwipret != ERR_OK) {
-        ESP_LOGW(TAG, "wifi_apply_hostname_(%s): lwIP error %d on interface %c%c (index %d)", intf->hostname,
-                 (int) lwipret, intf->name[0], intf->name[1], intf->num);
-        ret = false;
-      }
-    }
  }

  return ret;
@@ -4,7 +4,7 @@ from enum import Enum

 from esphome.enum import StrEnum

-__version__ = "2026.2.0b1"
+__version__ = "2026.2.1"

 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (
@@ -5,12 +5,12 @@ import hashlib
 import logging
 from pathlib import Path
 import re
-import shutil
 import subprocess
 import urllib.parse

 import esphome.config_validation as cv
 from esphome.core import CORE, TimePeriodSeconds
+from esphome.helpers import rmtree

 _LOGGER = logging.getLogger(__name__)

@@ -115,24 +115,35 @@ def clone_or_update(
    if not repo_dir.is_dir():
        _LOGGER.info("Cloning %s", key)
        _LOGGER.debug("Location: %s", repo_dir)
-        cmd = ["git", "clone", "--depth=1"]
-        cmd += ["--", url, str(repo_dir)]
-        run_git_command(cmd)
+        try:
+            cmd = ["git", "clone", "--depth=1"]
+            cmd += ["--", url, str(repo_dir)]
+            run_git_command(cmd)

-        if ref is not None:
-            # We need to fetch the PR branch first, otherwise git will complain
-            # about missing objects
-            _LOGGER.info("Fetching %s", ref)
-            run_git_command(["git", "fetch", "--", "origin", ref], git_dir=repo_dir)
-            run_git_command(["git", "reset", "--hard", "FETCH_HEAD"], git_dir=repo_dir)
+            if ref is not None:
+                # We need to fetch the PR branch first, otherwise git will complain
+                # about missing objects
+                _LOGGER.info("Fetching %s", ref)
+                run_git_command(["git", "fetch", "--", "origin", ref], git_dir=repo_dir)
+                run_git_command(
+                    ["git", "reset", "--hard", "FETCH_HEAD"], git_dir=repo_dir
+                )

-        if submodules is not None:
-            _LOGGER.info(
-                "Initializing submodules (%s) for %s", ", ".join(submodules), key
-            )
-            run_git_command(
-                ["git", "submodule", "update", "--init"] + submodules, git_dir=repo_dir
-            )
+            if submodules is not None:
+                _LOGGER.info(
+                    "Initializing submodules (%s) for %s", ", ".join(submodules), key
+                )
+                run_git_command(
+                    ["git", "submodule", "update", "--init"] + submodules,
+                    git_dir=repo_dir,
+                )
+        except GitException:
+            # Remove incomplete clone to prevent stale state. Without this,
+            # a failed ref fetch leaves a clone on the default branch, and
+            # subsequent calls skip the update due to the refresh window.
+            if repo_dir.is_dir():
+                rmtree(repo_dir)
+            raise

    else:
        # Check refresh needed
@@ -193,7 +204,7 @@ def clone_or_update(
                    err,
                )
                _LOGGER.info("Removing broken repository at %s", repo_dir)
-                shutil.rmtree(repo_dir)
+                rmtree(repo_dir)
                _LOGGER.info("Successfully removed broken repository, re-cloning...")

                # Recursively call clone_or_update to re-clone
@@ -8,6 +8,7 @@ from pathlib import Path
 import platform
 import re
 import shutil
+import stat
 import tempfile
 from typing import TYPE_CHECKING
 from urllib.parse import urlparse
@@ -354,6 +355,23 @@ def is_ha_addon():
    return get_bool_env("ESPHOME_IS_HA_ADDON")


+def rmtree(path: Path | str) -> None:
+    """Remove a directory tree, handling read-only files on Windows.
+
+    On Windows, git pack files and other files may be marked read-only,
+    causing shutil.rmtree to fail. This handles that by removing the
+    read-only flag and retrying.
+    """
+
+    def _onerror(func, path, exc_info):
+        if os.access(path, os.W_OK):
+            raise exc_info[1].with_traceback(exc_info[2])
+        os.chmod(path, stat.S_IWUSR | stat.S_IRUSR)
+        func(path)
+
+    shutil.rmtree(path, onerror=_onerror)
+
+
 def walk_files(path: Path):
    for root, _, files in os.walk(path):
        for name in files:
@@ -481,8 +499,6 @@ def list_starts_with(list_, sub):

 def file_compare(path1: Path, path2: Path) -> bool:
    """Return True if the files path1 and path2 have the same contents."""
-    import stat
-
    try:
        stat1, stat2 = path1.stat(), path2.stat()
    except OSError:
@@ -1,14 +1,10 @@
-from collections.abc import Callable
 import importlib
 import json
 import logging
 import os
 from pathlib import Path
 import re
-import shutil
-import stat
 import time
-from types import TracebackType

 from esphome import loader
 from esphome.config import iter_component_configs, iter_components
@@ -25,6 +21,7 @@ from esphome.helpers import (
    get_str_env,
    is_ha_addon,
    read_file,
+    rmtree,
    walk_files,
    write_file,
    write_file_if_changed,
@@ -404,28 +401,6 @@ def clean_cmake_cache():
            pioenvs_cmake_path.unlink()


-def _rmtree_error_handler(
-    func: Callable[[str], object],
-    path: str,
-    exc_info: tuple[type[BaseException], BaseException, TracebackType | None],
-) -> None:
-    """Error handler for shutil.rmtree to handle read-only files on Windows.
-
-    On Windows, git pack files and other files may be marked read-only,
-    causing shutil.rmtree to fail with "Access is denied". This handler
-    removes the read-only flag and retries the deletion.
-    """
-    if os.access(path, os.W_OK):
-        raise exc_info[1].with_traceback(exc_info[2])
-    os.chmod(path, stat.S_IWUSR | stat.S_IRUSR)
-    func(path)
-
-
-def rmtree(path: Path | str) -> None:
-    """Remove a directory tree, handling read-only files on Windows."""
-    shutil.rmtree(path, onerror=_rmtree_error_handler)
-
-
 def clean_build(clear_pio_cache: bool = True):
    # Allow skipping cache cleaning for integration tests
    if os.environ.get("ESPHOME_SKIP_CLEAN_BUILD"):
@@ -369,7 +369,7 @@ def get_logger_tags():
        "api.service",
    ]
    for file in CORE_COMPONENTS_PATH.rglob("*.cpp"):
-        data = file.read_text()
+        data = file.read_text(encoding="utf-8")
        match = pattern.search(data)
        if match:
            tags.append(match.group(1))
@@ -27,9 +27,9 @@ sensor:
    name: Linearly combined temperatures
    sources:
      - source: template_temperature1
-        coeffecient: !lambda "return 0.4 + std::abs(x - 25) * 0.023;"
+        coefficient: !lambda "return 0.4 + std::abs(x - 25) * 0.023;"
      - source: template_temperature2
-        coeffecient: 1.5
+        coefficient: 1.5
  - platform: combination
    type: max
    name: Max of combined temperatures
@@ -0,0 +1,5 @@
+<<: !include common.yaml
+
+esp32_ble:
+  io_capability: keyboard_only
+  disable_bt_logs: false
@@ -0,0 +1,61 @@
+#pragma once
+#include <cstdint>
+#include <cstring>
+#include <vector>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include "esphome/components/ld2450/ld2450.h"
+#include "esphome/components/uart/uart_component.h"
+
+namespace esphome::ld2450::testing {
+
+// Mock UART component to satisfy UARTDevice parent requirement.
+class MockUARTComponent : public uart::UARTComponent {
+ public:
+  void write_array(const uint8_t *data, size_t len) override {}
+  MOCK_METHOD(bool, read_array, (uint8_t * data, size_t len), (override));
+  MOCK_METHOD(bool, peek_byte, (uint8_t * data), (override));
+  MOCK_METHOD(size_t, available, (), (override));
+  MOCK_METHOD(void, flush, (), (override));
+  MOCK_METHOD(void, check_logger_conflict, (), (override));
+};
+
+// Expose protected members for testing.
+class TestableLD2450 : public LD2450Component {
+ public:
+  using LD2450Component::buffer_data_;
+  using LD2450Component::buffer_pos_;
+  using LD2450Component::readline_;
+
+  void feed(const std::vector<uint8_t> &data) {
+    for (uint8_t byte : data) {
+      this->readline_(byte);
+    }
+  }
+};
+
+// LD2450 periodic data frame: header (4) + 3 targets * 8 bytes + footer (2) = 30 bytes
+// All-zero targets means no presence detected.
+inline std::vector<uint8_t> make_periodic_frame(uint8_t fill = 0x00) {
+  std::vector<uint8_t> frame = {0xAA, 0xFF, 0x03, 0x00};  // DATA_FRAME_HEADER
+  for (int i = 0; i < 24; i++) {
+    frame.push_back(fill);  // 3 targets * 8 bytes
+  }
+  frame.push_back(0x55);  // DATA_FRAME_FOOTER
+  frame.push_back(0xCC);
+  return frame;
+}
+
+// LD2450 command ACK frame for CMD_ENABLE_CONF (0xFF), successful.
+// header (4) + length (2) + command (2) + result (2) + footer (4) = 14 bytes
+inline std::vector<uint8_t> make_ack_frame() {
+  return {
+      0xFD, 0xFC, 0xFB, 0xFA,  // CMD_FRAME_HEADER
+      0x04, 0x00,              // length = 4
+      0xFF, 0x01,              // command = enable_conf, status = success
+      0x00, 0x00,              // result = ok
+      0x04, 0x03, 0x02, 0x01   // CMD_FRAME_FOOTER
+  };
+}
+
+}  // namespace esphome::ld2450::testing
@@ -0,0 +1,145 @@
+#include "common.h"
+
+namespace esphome::ld2450::testing {
+
+class LD2450ReadlineTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    this->ld2450_.set_uart_parent(&this->mock_uart_);
+    // Ensure clean state
+    ASSERT_EQ(this->ld2450_.buffer_pos_, 0);
+  }
+
+  MockUARTComponent mock_uart_;
+  TestableLD2450 ld2450_;
+};
+
+// --- Good data tests ---
+
+TEST_F(LD2450ReadlineTest, ValidPeriodicFrame) {
+  auto frame = make_periodic_frame();
+  this->ld2450_.feed(frame);
+  // After a complete valid frame, buffer should be reset
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+TEST_F(LD2450ReadlineTest, ValidCommandAckFrame) {
+  auto frame = make_ack_frame();
+  this->ld2450_.feed(frame);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+TEST_F(LD2450ReadlineTest, BackToBackPeriodicFrames) {
+  auto frame = make_periodic_frame();
+  for (int i = 0; i < 5; i++) {
+    this->ld2450_.feed(frame);
+    EXPECT_EQ(this->ld2450_.buffer_pos_, 0) << "Frame " << i << " not processed";
+  }
+}
+
+TEST_F(LD2450ReadlineTest, BackToBackMixedFrames) {
+  auto periodic = make_periodic_frame();
+  auto ack = make_ack_frame();
+  this->ld2450_.feed(periodic);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+  this->ld2450_.feed(ack);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+  this->ld2450_.feed(periodic);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+// --- Garbage then valid frame tests ---
+
+TEST_F(LD2450ReadlineTest, GarbageThenValidFrame) {
+  // Garbage bytes accumulate in the buffer but don't match any footer.
+  // A valid frame follows; its footer resets the buffer and resyncs.
+  std::vector<uint8_t> garbage = {0x01, 0x02, 0x03, 0x42, 0x99};
+  this->ld2450_.feed(garbage);
+  EXPECT_GT(this->ld2450_.buffer_pos_, 0);  // Garbage accumulated
+
+  auto frame = make_periodic_frame();
+  this->ld2450_.feed(frame);
+  // Footer from the valid frame resyncs the parser
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+// --- Footer-based resynchronization tests ---
+
+TEST_F(LD2450ReadlineTest, FooterInGarbageResyncs) {
+  // Garbage containing a periodic frame footer (0x55 0xCC) triggers
+  // a buffer reset, allowing the next frame to be parsed cleanly.
+  std::vector<uint8_t> garbage_with_footer = {0x01, 0x02, 0x03, 0x04, 0x55, 0xCC};
+  this->ld2450_.feed(garbage_with_footer);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);  // Footer reset the buffer
+
+  auto frame = make_periodic_frame();
+  this->ld2450_.feed(frame);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+TEST_F(LD2450ReadlineTest, CmdFooterInGarbageResyncs) {
+  // Garbage containing a command frame footer (04 03 02 01) also resyncs.
+  std::vector<uint8_t> garbage_with_footer = {0x10, 0x20, 0x30, 0x40, 0x04, 0x03, 0x02, 0x01};
+  this->ld2450_.feed(garbage_with_footer);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+
+  auto frame = make_periodic_frame();
+  this->ld2450_.feed(frame);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+// --- Overflow recovery tests ---
+
+TEST_F(LD2450ReadlineTest, OverflowResetsBuffer) {
+  // Fill the buffer to capacity with filler that won't match any footer.
+  // MAX_LINE_LENGTH is 45, usable is 44. The 45th byte triggers overflow.
+  std::vector<uint8_t> overflow_data(MAX_LINE_LENGTH, 0x11);
+  this->ld2450_.feed(overflow_data);
+  // After overflow, buffer_pos_ resets to 0 (via the < 4 early return path)
+  EXPECT_LT(this->ld2450_.buffer_pos_, 4);
+}
+
+TEST_F(LD2450ReadlineTest, OverflowThenValidFrame) {
+  // Overflow, then a valid frame should be processed.
+  std::vector<uint8_t> overflow_data(MAX_LINE_LENGTH, 0x11);
+  this->ld2450_.feed(overflow_data);
+
+  auto frame = make_periodic_frame();
+  this->ld2450_.feed(frame);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+TEST_F(LD2450ReadlineTest, BufferLargeEnoughForDesyncedFooter) {
+  // The key fix: the buffer (45) is large enough that a desynced periodic frame's
+  // footer (at most 30 bytes into the stream) will land inside the buffer before overflow.
+  // Simulate starting 10 bytes into a periodic frame, then a full frame follows.
+  std::vector<uint8_t> mid_frame = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39};
+  // Then a complete periodic frame whose footer will land at position 40 (10 + 30),
+  // well within the buffer size of 45.
+  auto frame = make_periodic_frame();
+  mid_frame.insert(mid_frame.end(), frame.begin(), frame.end());
+
+  this->ld2450_.feed(mid_frame);
+  // The footer from the frame should have triggered a reset
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+TEST_F(LD2450ReadlineTest, SimulatedRestartThenFrames) {
+  // Simulate LD2450 restart: burst of garbage followed by valid periodic frames.
+  // The garbage + first frame should fit in the buffer so the footer resyncs.
+  std::vector<uint8_t> restart_noise = {
+      0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,  // 8 bytes of mid-frame data
+  };
+  auto frame = make_periodic_frame();
+  // 8 garbage + 30 frame = 38 bytes, well within buffer of 45
+  restart_noise.insert(restart_noise.end(), frame.begin(), frame.end());
+
+  this->ld2450_.feed(restart_noise);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+
+  // Subsequent frames should work normally
+  this->ld2450_.feed(frame);
+  EXPECT_EQ(this->ld2450_.buffer_pos_, 0);
+}
+
+}  // namespace esphome::ld2450::testing
@@ -0,0 +1,10 @@
+sensor:
+  - platform: pulse_counter
+    name: Pulse Counter
+    pin: 4
+    use_pcnt: false
+    count_mode:
+      rising_edge: INCREMENT
+      falling_edge: DECREMENT
+    internal_filter: 13us
+    update_interval: 15s
@@ -0,0 +1,12 @@
+remote_receiver:
+  id: rcvr
+  pin: GPIO2
+  dump: all
+  <<: !include common-actions.yaml
+
+binary_sensor:
+  - platform: remote_receiver
+    name: Panasonic Remote Input
+    panasonic:
+      address: 0x4004
+      command: 0x100BCBD
@@ -0,0 +1,7 @@
+remote_transmitter:
+  id: xmitr
+  pin: GPIO2
+  carrier_duty_percent: 50%
+
+packages:
+  buttons: !include common-buttons.yaml
@@ -0,0 +1,11 @@
+substitutions:
+  network_enable_ipv6: "false"
+
+socket:
+
+wifi:
+  ssid: MySSID
+  password: password1
+
+network:
+  enable_ipv6: ${network_enable_ipv6}
@@ -0,0 +1,4 @@
+substitutions:
+  network_enable_ipv6: "true"
+
+<<: !include common.yaml
@@ -0,0 +1,4 @@
+socket:
+
+network:
+  enable_ipv6: true
@@ -0,0 +1 @@
+<<: !include common.yaml
@@ -0,0 +1,3 @@
+socket:
+
+network:
@@ -270,6 +270,14 @@ async def test_alarm_control_panel_state_transitions(
        # The chime_sensor has chime: true, so opening it while disarmed
        # should trigger on_chime callback

+        # Set up future for the on_ready from opening the chime sensor
+        # (alarm becomes "not ready" when chime sensor opens).
+        # We must wait for this BEFORE creating the close future, otherwise
+        # the open event's log can arrive late and resolve the close future,
+        # causing the test to proceed before the chime close is processed.
+        ready_after_chime_open: asyncio.Future[bool] = loop.create_future()
+        ready_futures.append(ready_after_chime_open)
+
        # We're currently DISARMED - open the chime sensor
        client.switch_command(chime_switch_info.key, True)

@@ -279,11 +287,18 @@ async def test_alarm_control_panel_state_transitions(
        except TimeoutError:
            pytest.fail(f"on_chime callback not fired. Log lines: {log_lines[-20:]}")

-        # Close the chime sensor and wait for alarm to become ready again
-        # We need to wait for this transition before testing door sensor,
-        # otherwise there's a race where the door sensor state change could
-        # arrive before the chime sensor state change, leaving the alarm in
-        # a continuous "not ready" state with no on_ready callback fired.
+        # Wait for the on_ready from the chime sensor opening
+        try:
+            await asyncio.wait_for(ready_after_chime_open, timeout=2.0)
+        except TimeoutError:
+            pytest.fail(
+                f"on_ready callback not fired when chime sensor opened. "
+                f"Log lines: {log_lines[-20:]}"
+            )
+
+        # Now create the future for the close event and close the sensor.
+        # Since we waited for the open event above, the close event's
+        # on_ready log cannot be confused with the open event's.
        ready_after_chime_close: asyncio.Future[bool] = loop.create_future()
        ready_futures.append(ready_after_chime_close)

@@ -656,7 +656,7 @@ def test_clone_or_update_recover_broken_flag_prevents_infinite_loop(
    # Should raise on the second attempt when _recover_broken=False
    # This hits the "if not _recover_broken: raise" path
    with (
-        unittest.mock.patch("esphome.git.shutil.rmtree", side_effect=mock_rmtree),
+        unittest.mock.patch("esphome.git.rmtree", side_effect=mock_rmtree),
        pytest.raises(GitCommandError, match="fatal: unable to write new index file"),
    ):
        git.clone_or_update(
@@ -671,3 +671,114 @@ def test_clone_or_update_recover_broken_flag_prevents_infinite_loop(
    stash_calls = [c for c in call_list if "stash" in c[0][0]]
    # Should have exactly two stash calls
    assert len(stash_calls) == 2
+
+
+def test_clone_or_update_cleans_up_on_failed_ref_fetch(
+    tmp_path: Path, mock_run_git_command: Mock
+) -> None:
+    """Test that a failed ref fetch removes the incomplete clone directory.
+
+    When cloning with a specific ref, if `git clone` succeeds but the
+    subsequent `git fetch <ref>` fails, the clone directory should be
+    removed so the next attempt starts fresh instead of finding a stale
+    clone on the default branch.
+    """
+    CORE.config_path = tmp_path / "test.yaml"
+
+    url = "https://github.com/test/repo"
+    ref = "pull/123/head"
+    domain = "test"
+    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    def git_command_side_effect(
+        cmd: list[str], cwd: str | None = None, **kwargs: Any
+    ) -> str:
+        cmd_type = _get_git_command_type(cmd)
+        if cmd_type == "clone":
+            # Simulate successful clone by creating the directory
+            repo_dir.mkdir(parents=True, exist_ok=True)
+            (repo_dir / ".git").mkdir(exist_ok=True)
+            return ""
+        if cmd_type == "fetch":
+            raise GitCommandError("fatal: couldn't find remote ref pull/123/head")
+        return ""
+
+    mock_run_git_command.side_effect = git_command_side_effect
+
+    refresh = TimePeriodSeconds(days=1)
+
+    with pytest.raises(GitCommandError, match="couldn't find remote ref"):
+        git.clone_or_update(
+            url=url,
+            ref=ref,
+            refresh=refresh,
+            domain=domain,
+        )
+
+    # The incomplete clone directory should have been removed
+    assert not repo_dir.exists()
+
+    # Verify clone was attempted then fetch failed
+    call_list = mock_run_git_command.call_args_list
+    clone_calls = [c for c in call_list if "clone" in c[0][0]]
+    assert len(clone_calls) == 1
+    fetch_calls = [c for c in call_list if "fetch" in c[0][0]]
+    assert len(fetch_calls) == 1
+
+
+def test_clone_or_update_stale_clone_is_retried_after_cleanup(
+    tmp_path: Path, mock_run_git_command: Mock
+) -> None:
+    """Test that after cleanup, a subsequent call does a fresh clone.
+
+    This is the full scenario: first call fails at fetch (directory cleaned up),
+    second call sees no directory and clones fresh.
+    """
+    CORE.config_path = tmp_path / "test.yaml"
+
+    url = "https://github.com/test/repo"
+    ref = "pull/123/head"
+    domain = "test"
+    repo_dir = _compute_repo_dir(url, ref, domain)
+
+    call_count = {"clone": 0, "fetch": 0}
+
+    def git_command_side_effect(
+        cmd: list[str], cwd: str | None = None, **kwargs: Any
+    ) -> str:
+        cmd_type = _get_git_command_type(cmd)
+        if cmd_type == "clone":
+            call_count["clone"] += 1
+            repo_dir.mkdir(parents=True, exist_ok=True)
+            (repo_dir / ".git").mkdir(exist_ok=True)
+            return ""
+        if cmd_type == "fetch":
+            call_count["fetch"] += 1
+            if call_count["fetch"] == 1:
+                # First fetch fails
+                raise GitCommandError("fatal: couldn't find remote ref pull/123/head")
+            # Second fetch succeeds
+            return ""
+        if cmd_type == "reset":
+            return ""
+        return ""
+
+    mock_run_git_command.side_effect = git_command_side_effect
+
+    refresh = TimePeriodSeconds(days=1)
+
+    # First call: clone succeeds, fetch fails, directory cleaned up
+    with pytest.raises(GitCommandError, match="couldn't find remote ref"):
+        git.clone_or_update(url=url, ref=ref, refresh=refresh, domain=domain)
+
+    assert not repo_dir.exists()
+
+    # Second call: fresh clone + fetch succeeds
+    result_dir, _ = git.clone_or_update(
+        url=url, ref=ref, refresh=refresh, domain=domain
+    )
+
+    assert result_dir == repo_dir
+    assert repo_dir.exists()
+    assert call_count["clone"] == 2
+    assert call_count["fetch"] == 2
Author	SHA1	Message	Date
Jonathan Swoboda	49356f4132	Merge pull request #14151 from esphome/bump-2026.2.1 2026.2.1	2026-02-20 11:24:11 -05:00
Jonathan Swoboda	8aaf0b8d85	Bump version to 2026.2.1	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	28d510191c	[ld2410/ld2450] Replace header sync with buffer size increase for frame resync (#14138 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	4c8e0575f9	[ld2420] Increase MAX_LINE_LENGTH to allow footer-based resync (#14137 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	49afe53a2c	[ld2410] Add frame header synchronization to readline_() (#14136 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	d19c1b689a	[ld2450] Add frame header synchronization to fix initialization regression (#14135 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	e7e1acc0a2	[pulse_counter] Fix PCNT glitch filter calculation off by 1000x (#14132 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
J. Nick Koston	7bdeb32a8a	[uart] Always call pin setup for UART0 default pins on ESP-IDF (#14130 )	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	f412ab4f8b	[wifi] Sync output_power with PHY max TX power to prevent brownout (#14118 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	0fc09462ff	[safe_mode] Log brownout as reset reason on OTA rollback (#14113 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
J. Nick Koston	d78496321e	[esp32_ble] Enable CONFIG_BT_RELEASE_IRAM on ESP32-C2 (#14109 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	ac76fc4409	[pulse_counter] Fix build failure when use_pcnt is false (#14111 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	a343ff1989	[ethernet] Improve clk_mode deprecation warning with actionable YAML (#14104 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:12 -05:00
Jonathan Swoboda	2d2178c90a	[socket] Fix IPv6 compilation error on host platform (#14101 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-20 10:17:11 -05:00
J. Nick Koston	25b14f9953	[e131] Fix E1.31 on ESP8266 and RP2040 by restoring WiFiUDP support (#14086 )	2026-02-20 10:17:11 -05:00
J. Nick Koston	2491b4f85c	[ld2420] Use constexpr for compile-time constants (#14079 )	2026-02-20 10:17:11 -05:00
J. Nick Koston	cb8b14e64b	[web_server] Fix water_heater JSON key names and move traits to DETAIL_ALL (#14064 )	2026-02-20 10:17:11 -05:00
J. Nick Koston	887172d663	[pulse_counter] Fix compilation on ESP32-C6/C5/H2/P4 (#14070 )	2026-02-20 10:17:11 -05:00
J. Nick Koston	e4aa23abaa	[web_server] Double socket allocation to prevent connection exhaustion (#14067 )	2026-02-20 10:17:11 -05:00
J. Nick Koston	8c0cc3a2d8	[udp] Register socket consumption for CONFIG_LWIP_MAX_SOCKETS (#14068 )	2026-02-20 10:17:11 -05:00
Rodrigo Martín	efe8a6c8eb	[esp32_ble_server] fix infinitely large characteristic value (#14011 )	2026-02-20 10:17:11 -05:00
Jesse Hills	6b61edce92	Merge pull request #14062 from esphome/bump-2026.2.0 2026.2.0	2026-02-19 11:36:00 +13:00
Jesse Hills	2c89cded4b	Bump version to 2026.2.0	2026-02-19 09:30:04 +13:00
Jesse Hills	896dc4d34d	Merge pull request #14056 from esphome/bump-2026.2.0b5 2026.2.0b5	2026-02-19 09:04:47 +13:00
Jesse Hills	ab572c2882	Bump version to 2026.2.0b5	2026-02-19 08:03:44 +13:00
Jonathan Swoboda	6b8264fcaa	[external_components] Clean up incomplete clone on failed ref fetch (#14051 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-19 08:03:43 +13:00
Jesse Hills	973656191b	Merge pull request #14038 from esphome/bump-2026.2.0b4 2026.2.0b4	2026-02-18 13:28:37 +13:00
Jesse Hills	d9f493ab7a	Bump version to 2026.2.0b4	2026-02-18 10:13:41 +13:00
schrob	a0c4fa6496	[openthread] Fix compiler format warning (#14030 )	2026-02-18 10:13:41 +13:00
Jesse Hills	fd43bd2b7e	Merge pull request #14025 from esphome/bump-2026.2.0b3 2026.2.0b3	2026-02-17 16:22:12 +13:00
Jesse Hills	5904808804	Bump version to 2026.2.0b3	2026-02-17 13:24:35 +13:00
Jonathan Swoboda	e945e9b659	[esp32_rmt] Handle ESP32 variants without RMT hardware (#14001 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-17 13:24:35 +13:00
Jonathan Swoboda	df29cdbf17	[fan] Fix preset_mode not restored on boot (#14002 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-17 13:24:35 +13:00
Jonathan Swoboda	f6362aa8da	[combination] Fix 'coeffecient' typo with backward-compatible deprecation (#14004 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-17 13:24:35 +13:00
J. Nick Koston	1517b7799a	[wifi] Fix ESP8266 DHCP state corruption from premature dhcp_renew() (#13983 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-17 13:24:35 +13:00
Jesse Hills	afa4047089	Merge pull request #13984 from esphome/bump-2026.2.0b2 2026.2.0b2	2026-02-14 16:02:49 +13:00
Jesse Hills	a8a324cbfb	Bump version to 2026.2.0b2	2026-02-14 13:53:54 +13:00
J. Nick Koston	f6aeef2e68	[api] Fix ESP8266 noise API handshake deadlock and prompt socket cleanup (#13972 )	2026-02-14 13:53:54 +13:00
Jonathan Swoboda	297dfb0db4	[docker] Suppress git detached HEAD advice (#13962 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-14 13:53:54 +13:00
Jonathan Swoboda	c08356b0c1	[alarm_control_panel] Fix flaky integration test race condition (#13964 ) Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>	2026-02-14 13:53:54 +13:00
Lukáš Maňas	e9bf9bc691	[pulse_meter] Fix early edge detection (#12360 ) Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>	2026-02-14 13:53:54 +13:00
J. Nick Koston	ead7937dbf	[api] Extract cold code from APIServer::loop() hot path (#13902 )	2026-02-14 13:53:54 +13:00
J. Nick Koston	844210519a	[uart] Remove redundant mutex, fix flush race, conditional event queue (#13955 )	2026-02-14 13:53:54 +13:00
Guillermo Ruffino	7c70b2e04e	[schema-gen] fix Windows: ensure UTF-8 encoding when reading component files (#13952 )	2026-02-14 13:53:54 +13:00