From dff1422e3697cc558c76af1d11fc865d1e18c21c Mon Sep 17 00:00:00 2001
From: Keith Burzinski <kbx81x@gmail.com>
Date: Tue, 13 Oct 2026 17:55:22 -0500
Subject: [PATCH 01/21] [mdns] Advertise the connected interface in the network
 TXT record (#20673)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/mdns/mdns_component.cpp    | 53 ++++++++++++++++++-
 esphome/components/mdns/mdns_component.h      | 22 ++++++++
 esphome/components/mdns/mdns_esp32.cpp        | 19 ++++++-
 esphome/components/mdns/mdns_rp2.cpp          | 19 +++++++
 .../mdns/common-dual-interface.yaml           |  9 ++++
 .../mdns/test-dual-interface.esp32-idf.yaml   | 17 ++++++
 .../mdns/test-dual-interface.rp2040-ard.yaml  | 17 ++++++
 7 files changed, 154 insertions(+), 2 deletions(-)
 create mode 100644 tests/components/mdns/common-dual-interface.yaml
 create mode 100644 tests/components/mdns/test-dual-interface.esp32-idf.yaml
 create mode 100644 tests/components/mdns/test-dual-interface.rp2040-ard.yaml

diff --git a/esphome/components/mdns/mdns_component.cpp b/esphome/components/mdns/mdns_component.cpp
index 4f236153c2c..a5e1efeb08a 100644
--- a/esphome/components/mdns/mdns_component.cpp
+++ b/esphome/components/mdns/mdns_component.cpp
@@ -20,6 +20,10 @@
 #ifdef USE_DASHBOARD_IMPORT
 #include "esphome/components/dashboard_import/dashboard_import.h"
 #endif
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+#include "esphome/components/ethernet/ethernet_component.h"
+#include "esphome/components/wifi/wifi_component.h"
+#endif
 
 namespace esphome::mdns {
 
@@ -39,6 +43,45 @@ MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
 // Wrap build-time defines into flash storage
 MDNS_STATIC_CONST_CHAR(VALUE_VERSION, ESPHOME_VERSION);
 
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
+MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
+
+// Same order as the default route in NetworkComponent::loop()
+const char *MDNSComponent::connected_network_() const {
+  const bool ethernet = ethernet::global_eth_component->is_connected();
+  const bool wifi = wifi::global_wifi_component->is_connected();
+#ifdef USE_NETWORK_PRIMARY_INTERFACE_WIFI
+  if (wifi)
+    return NETWORK_WIFI;
+#endif
+  if (ethernet)
+    return NETWORK_ETHERNET;
+  if (wifi)
+    return NETWORK_WIFI;
+  return nullptr;
+}
+
+void MDNSComponent::update_network_txt_() {
+  if (this->network_txt_ == nullptr)
+    return;
+  // With no interface connected, keep the last value instead of flapping to wifi
+  const char *network = this->connected_network_();
+  if (network == nullptr || network == this->network_txt_)
+    return;
+  if (!this->publish_network_txt_(network)) {
+    // The _esphomelib service is missing, so a retry would fail too
+    this->network_txt_ = nullptr;
+    return;
+  }
+  ESP_LOGD(TAG, "Network TXT: %s", network);
+  this->network_txt_ = network;
+#ifdef USE_MDNS_STORE_SERVICES
+  this->network_record_->value = MDNS_STR(network);
+#endif
+}
+#endif
+
 void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {
 #ifdef USE_MDNS_STORE_SERVICES
   auto &services = this->services_;
@@ -160,7 +203,15 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
 
     txt_records.push_back({MDNS_STR(TXT_BOARD), MDNS_STR(VALUE_BOARD)});
 
-#if defined(USE_WIFI)
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+    const char *network = this->connected_network_();
+    this->network_txt_ = network != nullptr ? network : NETWORK_WIFI;
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(this->network_txt_)});
+#ifdef USE_MDNS_STORE_SERVICES
+    // services is services_ here, which never reallocates
+    this->network_record_ = &txt_records.back();
+#endif
+#elif defined(USE_WIFI)
     MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
     txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)
diff --git a/esphome/components/mdns/mdns_component.h b/esphome/components/mdns/mdns_component.h
index 93d9eb1e385..f2ea7c19149 100644
--- a/esphome/components/mdns/mdns_component.h
+++ b/esphome/components/mdns/mdns_component.h
@@ -32,6 +32,12 @@
 #define USE_MDNS_DEVICE_INFO_TXT
 #endif
 
+// With both wifi and ethernet, the _esphomelib "network" TXT value follows the connected interface.
+// OpenThread hands its services to the SRP client once, so it keeps the fixed value.
+#if defined(USE_API) && defined(USE_WIFI) && defined(USE_ETHERNET) && !defined(USE_OPENTHREAD)
+#define USE_MDNS_DYNAMIC_NETWORK_TXT
+#endif
+
 namespace esphome::mdns {
 
 // Helper struct that identifies strings that may be stored in flash storage (similar to LogString)
@@ -150,6 +156,22 @@ class MDNSComponent final : public Component
 
   void setup_buffers_and_register_(PlatformRegisterFn platform_register);
 
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+  static constexpr uint32_t NETWORK_TXT_CHECK_INTERVAL_MS = 1000;
+  /// The first connected interface in network: priority order ("ethernet" or "wifi"), else nullptr.
+  const char *connected_network_() const;
+  /// Check the connected interface and publish a changed "network" TXT value.
+  void update_network_txt_();
+  /// Platform-specific: replace the "network" TXT value of the registered _esphomelib service.
+  bool publish_network_txt_(const char *network);
+  /// Advertised value; nullptr until the _esphomelib service is registered, and after a failed publish.
+  const char *network_txt_{nullptr};
+#ifdef USE_MDNS_STORE_SERVICES
+  /// The "network" record in services_, kept in step with network_txt_.
+  MDNSTXTRecord *network_record_{nullptr};
+#endif
+#endif
+
 #ifdef USE_MDNS_DYNAMIC_TXT
   /// Storage for runtime-generated TXT values from user lambdas
   /// Pre-sized at compile time via MDNS_DYNAMIC_TXT_COUNT to avoid heap allocations.
diff --git a/esphome/components/mdns/mdns_esp32.cpp b/esphome/components/mdns/mdns_esp32.cpp
index 48df61326e2..bd74dd6a948 100644
--- a/esphome/components/mdns/mdns_esp32.cpp
+++ b/esphome/components/mdns/mdns_esp32.cpp
@@ -89,7 +89,24 @@ bool MDNSComponent::set_service_enabled(const char *service_type, const char *pr
 }
 #endif  // USE_MDNS_SUPPORTS_ENABLE_DISABLE && !USE_OPENTHREAD
 
-void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+bool MDNSComponent::publish_network_txt_(const char *network) {
+  // ESP-IDF copies the value and announces the changed record
+  esp_err_t err = mdns_service_txt_item_set("_esphomelib", "_tcp", "network", network);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Failed to update network TXT: %s", esp_err_to_name(err));
+    return false;
+  }
+  return true;
+}
+#endif
+
+void MDNSComponent::setup() {
+  this->setup_buffers_and_register_(register_esp32);
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
+#endif
+}
 
 void MDNSComponent::on_shutdown() {
 #ifndef USE_OPENTHREAD
diff --git a/esphome/components/mdns/mdns_rp2.cpp b/esphome/components/mdns/mdns_rp2.cpp
index 7eaac594fb5..603f3f0417c 100644
--- a/esphome/components/mdns/mdns_rp2.cpp
+++ b/esphome/components/mdns/mdns_rp2.cpp
@@ -46,7 +46,26 @@ void MDNSComponent::start_polling_window_() {
 }
 #endif
 
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+ESPHOME_LOG_TAG(TAG, "mdns");
+
+bool MDNSComponent::publish_network_txt_(const char *network) {
+  // LEAmDNS replaces the value of an existing key; announce() sends the change
+  if (!MDNS.addServiceTxt("esphomelib", "tcp", "network", network)) {
+    ESP_LOGW(TAG, "Failed to update network TXT");
+    return false;
+  }
+  MDNS.announce();
+  this->start_polling_window_();
+  return true;
+}
+#endif
+
 void MDNSComponent::setup() {
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+  // No-op until the first IP-up event registers the services
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
+#endif
   // arduino-pico stubs out LwipIntf::stateUpCB (the netif status callback LEAmDNS uses
   // on ESP8266 for auto-restart), so we must drive begin()/notifyAPChange() from our
   // own IP state listener. Both WiFi and Ethernet have the same listener signature —
diff --git a/tests/components/mdns/common-dual-interface.yaml b/tests/components/mdns/common-dual-interface.yaml
new file mode 100644
index 00000000000..97ae545f2bc
--- /dev/null
+++ b/tests/components/mdns/common-dual-interface.yaml
@@ -0,0 +1,9 @@
+# wifi and ethernet together: the _esphomelib "network" TXT value follows
+# the connected interface, so the update path is compiled.
+wifi:
+  ssid: MySSID
+  password: password1
+
+api:
+
+mdns:
diff --git a/tests/components/mdns/test-dual-interface.esp32-idf.yaml b/tests/components/mdns/test-dual-interface.esp32-idf.yaml
new file mode 100644
index 00000000000..d480824494b
--- /dev/null
+++ b/tests/components/mdns/test-dual-interface.esp32-idf.yaml
@@ -0,0 +1,17 @@
+packages:
+  mdns: !include common-dual-interface.yaml
+
+ethernet:
+  type: W5500
+  clk_pin: GPIO19
+  mosi_pin: GPIO21
+  miso_pin: GPIO23
+  cs_pin: GPIO18
+  interrupt_pin: GPIO36
+  reset_pin: GPIO22
+  clock_speed: 10Mhz
+
+network:
+  priority:
+    - ethernet
+    - wifi
diff --git a/tests/components/mdns/test-dual-interface.rp2040-ard.yaml b/tests/components/mdns/test-dual-interface.rp2040-ard.yaml
new file mode 100644
index 00000000000..3836afb7eef
--- /dev/null
+++ b/tests/components/mdns/test-dual-interface.rp2040-ard.yaml
@@ -0,0 +1,17 @@
+packages:
+  mdns: !include common-dual-interface.yaml
+
+ethernet:
+  type: W5500
+  clk_pin: 18
+  mosi_pin: 19
+  miso_pin: 16
+  cs_pin: 17
+  interrupt_pin: 21
+  reset_pin: 20
+
+# wifi first, so the USE_NETWORK_PRIMARY_INTERFACE_WIFI order is compiled
+network:
+  priority:
+    - wifi
+    - ethernet

From 4645d34e1a85538db5de7bc75dd6df66749fb248 Mon Sep 17 00:00:00 2001
From: Anunay Kulshrestha <anunay@kul.sh>
Date: Wed, 14 Oct 2026 08:19:06 +0000
Subject: [PATCH 02/21] [web_server_idf] Keep active SSE sessions out of the
 LRU purge (#17383)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: J. Nick Koston <nick@koston.org>
Co-authored-by: J. Nick Koston <nick@home-assistant.io>
---
 .../web_server_idf/web_server_idf.cpp         | 34 +++++++++++++++++--
 .../web_server_idf/web_server_idf.h           | 12 +++++--
 2 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/esphome/components/web_server_idf/web_server_idf.cpp b/esphome/components/web_server_idf/web_server_idf.cpp
index a35ad652141..d120e826726 100644
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -955,10 +955,39 @@ void AsyncEventSourceResponse::process_close_() {
   }
 }
 
+void AsyncEventSourceResponse::refresh_lru_() {
+  // httpd only advances a session's LRU counter when a request arrives, and an event stream receives one
+  // request ever, so the purge that frees a socket for a new client would evict the live streams first.
+  // The HTTPD task owns the session table, so the refresh runs there.
+  // A stalled stream is the socket the purge should take, and a zeroed fd has no session left to refresh.
+  if (this->send_failure_started_ms_ != 0 || this->fd_.load() == 0)
+    return;
+  const uint32_t now = App.get_loop_component_start_time();
+  if (now - this->last_lru_refresh_ms_ < LRU_REFRESH_INTERVAL_MS ||
+      this->lru_work_queued_.load(std::memory_order_acquire)) {
+    return;
+  }
+  this->last_lru_refresh_ms_ = now;  // a full queue also waits for the next interval
+  this->lru_work_queued_.store(true, std::memory_order_release);
+  if (httpd_queue_work(this->hd_, &AsyncEventSourceResponse::refresh_lru_work, this) != ESP_OK) {
+    this->lru_work_queued_.store(false, std::memory_order_release);
+  }
+}
+
+void AsyncEventSourceResponse::refresh_lru_work(void *arg) {
+  auto *response = static_cast<AsyncEventSourceResponse *>(arg);
+  const int fd = response->fd_.load();
+  if (response->owns_session_(fd)) {
+    httpd_sess_update_lru_counter(response->hd_, fd);
+  }
+  // Release self only after the HTTPD-task callback has finished every access.
+  response->lru_work_queued_.store(false, std::memory_order_release);
+}
+
 void AsyncEventSourceResponse::close_session_work(void *arg) {
   auto *response = static_cast<AsyncEventSourceResponse *>(arg);
   const int fd = response->fd_.load();
-  if (fd != 0 && httpd_sess_get_ctx(response->hd_, fd) == response) {
+  if (response->owns_session_(fd)) {
     // The HTTPD task remains the session owner. Shutting the socket down makes
     // its next select/recv path delete the session and invoke destroy().
     shutdown(fd, SHUT_RDWR);
@@ -972,7 +1001,7 @@ ssize_t AsyncEventSourceResponse::send_(struct iovec *iov, int iovcnt) {
   // httpd frees a session before closing its socket, so the fd may already be a new client's.
   // Treated as would-block; the stall timer ends a session that never becomes ours again.
   const int fd = this->fd_.load();
-  if (httpd_sess_get_ctx(this->hd_, fd) != this) {
+  if (!this->owns_session_(fd)) {
     return 0;
   }
   struct msghdr msg {};
@@ -1081,6 +1110,7 @@ void AsyncEventSourceResponse::loop() {
     this->process_close_();
     return;
   }
+  this->refresh_lru_();
   drain_tail_();
   process_deferred_queue_();
   if (this->close_requested_)
diff --git a/esphome/components/web_server_idf/web_server_idf.h b/esphome/components/web_server_idf/web_server_idf.h
index 581ba8323b5..45128602e3a 100644
--- a/esphome/components/web_server_idf/web_server_idf.h
+++ b/esphome/components/web_server_idf/web_server_idf.h
@@ -329,10 +329,15 @@ class AsyncEventSourceResponse {
   };
   void process_close_();
   static void close_session_work(void *arg);
+  void refresh_lru_();
+  static void refresh_lru_work(void *arg);
+  // httpd frees a session before closing its socket, so the fd may already belong to a new client
+  bool owns_session_(int fd) const { return fd != 0 && httpd_sess_get_ctx(this->hd_, fd) == this; }
 
-  // Deletable only after destroy() zeroed fd_ and no queued HTTPD close work still references this object.
+  // Deletable only after destroy() zeroed fd_ and no queued HTTPD work still references this object.
   bool safe_to_delete_() const {
-    return this->fd_.load() == 0 && !this->close_work_queued_.load(std::memory_order_acquire);
+    return this->fd_.load() == 0 && !this->close_work_queued_.load(std::memory_order_acquire) &&
+           !this->lru_work_queued_.load(std::memory_order_acquire);
   }
 
   static void destroy(void *p);
@@ -347,11 +352,13 @@ class AsyncEventSourceResponse {
   RAMUniquePtr<uint8_t[]> tail_;
   uint32_t send_failure_started_ms_{0};  // Zero means no send stall in progress.
   uint32_t next_close_attempt_ms_{0};
+  uint32_t last_lru_refresh_ms_{0};
   uint16_t tail_cap_{0};
   uint16_t tail_len_{0};  // Zero means nothing pending
   uint16_t tail_sent_{0};
   // Set on the main loop before queueing close work, cleared by the HTTPD-task callback when done.
   std::atomic<bool> close_work_queued_{false};
+  std::atomic<bool> lru_work_queued_{false};
   // Main-loop only; the HTTPD task never reads or writes these flags.
   bool close_requested_{false};
   bool close_retry_warning_logged_{false};
@@ -373,6 +380,7 @@ class AsyncEventSourceResponse {
   static constexpr uint32_t SEND_STALL_TIMEOUT_MS = 20000;
   static constexpr uint32_t CLOSE_RETRY_INTERVAL_MS = 250;
   static constexpr uint32_t CLOSE_CONFIRM_INTERVAL_MS = 1000;
+  static constexpr uint32_t LRU_REFRESH_INTERVAL_MS = 1000;
 };
 
 using AsyncEventSourceClient = AsyncEventSourceResponse;

From cd6c0dd402bde0022f011fe7ed93ee6497ecbffc Mon Sep 17 00:00:00 2001
From: "esphome[bot]" <115708604+esphome[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 20:21:45 +0000
Subject: [PATCH 03/21] Bump aioesphomeapi from 46.10.0 to 46.11.0 (#20766)

Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index a54897ef36d..486612817c2 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ pyserial==3.5
 platformio==6.2.0
 esptool==5.4.0
 click==8.5.0
-aioesphomeapi==46.10.0
+aioesphomeapi==46.11.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
 zeroconf==0.151.5
 puremagic==2.2.0

From ba575600dc53f21f09f306a1f8c690cb2173c933 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Wed, 14 Oct 2026 11:13:32 -1000
Subject: [PATCH 04/21] [mqtt] Match subscription topics in a loop instead of
 recursing per character (#20767)

---
 esphome/components/mqtt/mqtt_client.cpp    |  58 +-----------
 esphome/components/mqtt/mqtt_topic_match.h |  28 ++++++
 tests/components/mqtt/test_topic_match.cpp | 103 +++++++++++++++++++++
 3 files changed, 132 insertions(+), 57 deletions(-)
 create mode 100644 esphome/components/mqtt/mqtt_topic_match.h
 create mode 100644 tests/components/mqtt/test_topic_match.cpp

diff --git a/esphome/components/mqtt/mqtt_client.cpp b/esphome/components/mqtt/mqtt_client.cpp
index 2ecab47904a..4143f12d127 100644
--- a/esphome/components/mqtt/mqtt_client.cpp
+++ b/esphome/components/mqtt/mqtt_client.cpp
@@ -16,6 +16,7 @@
 #include "lwip/dns.h"
 #include "lwip/err.h"
 #include "mqtt_component.h"
+#include "mqtt_topic_match.h"
 
 #ifdef USE_API
 #include "esphome/components/api/api_server.h"
@@ -581,63 +582,6 @@ void MQTTClientComponent::disable() {
   this->on_shutdown();
 }
 
-/** Check if the message topic matches the given subscription topic
- *
- * INFO: MQTT spec mandates that topics must not be empty and must be valid NULL-terminated UTF-8 strings.
- *
- * @param message The message topic that was received from the MQTT server. Note: this must not contain
- *                wildcard characters as mandated by the MQTT spec.
- * @param subscription The subscription topic we are matching against.
- * @param is_normal Is this a "normal" topic - Does the message topic not begin with a "$".
- * @param past_separator Are we past the first '/' topic separator.
- * @return true if the subscription topic matches the message topic, false otherwise.
- */
-static bool topic_match(const char *message, const char *subscription, bool is_normal, bool past_separator) {
-  // Reached end of both strings at the same time, this means we have a successful match
-  if (*message == '\0' && *subscription == '\0')
-    return true;
-
-  // Either the message or the subscribe are at the end. This means they don't match.
-  if (*message == '\0' || *subscription == '\0')
-    return false;
-
-  bool do_wildcards = is_normal || past_separator;
-
-  if (*subscription == '+' && do_wildcards) {
-    // single level wildcard
-    // consume + from subscription
-    subscription++;
-    // consume everything from message until '/' found or end of string
-    while (*message != '\0' && *message != '/') {
-      message++;
-    }
-    // after this, both pointers will point to a '/' or to the end of the string
-
-    return topic_match(message, subscription, is_normal, true);
-  }
-
-  if (*subscription == '#' && do_wildcards) {
-    // multilevel wildcard - MQTT mandates that this must be at end of subscribe topic
-    return true;
-  }
-
-  // this handles '/' and normal characters at the same time.
-  if (*message != *subscription)
-    return false;
-
-  past_separator = past_separator || *subscription == '/';
-
-  // consume characters
-  subscription++;
-  message++;
-
-  return topic_match(message, subscription, is_normal, past_separator);
-}
-
-static bool topic_match(const char *message, const char *subscription) {
-  return topic_match(message, subscription, *message != '\0' && *message != '$', false);
-}
-
 void MQTTClientComponent::on_message(const std::string &topic, const std::string &payload) {
 #ifdef USE_ESP8266
   // IMPORTANT: This defer is REQUIRED to prevent stack overflow crashes on ESP8266.
diff --git a/esphome/components/mqtt/mqtt_topic_match.h b/esphome/components/mqtt/mqtt_topic_match.h
new file mode 100644
index 00000000000..84172bc805e
--- /dev/null
+++ b/esphome/components/mqtt/mqtt_topic_match.h
@@ -0,0 +1,28 @@
+#pragma once
+
+namespace esphome::mqtt {
+
+/// True if the message topic matches the subscription, with + and # wildcards.
+/// A loop on purpose: recursing per character overflowed the ESP32 loop task's stack on long topics.
+inline bool topic_match(const char *message, const char *subscription) {
+  // First-level wildcards do not match topics that begin with '$'
+  bool wildcards = *message != '$';
+  while (*message != '\0' && *subscription != '\0') {
+    if (wildcards && *subscription == '#')
+      return true;
+    if (wildcards && *subscription == '+') {
+      subscription++;
+      while (*message != '\0' && *message != '/')
+        message++;
+      continue;
+    }
+    if (*message != *subscription)
+      return false;
+    wildcards |= *subscription == '/';
+    message++;
+    subscription++;
+  }
+  return *message == *subscription;  // a match only if both ended
+}
+
+}  // namespace esphome::mqtt
diff --git a/tests/components/mqtt/test_topic_match.cpp b/tests/components/mqtt/test_topic_match.cpp
new file mode 100644
index 00000000000..b51f45ce478
--- /dev/null
+++ b/tests/components/mqtt/test_topic_match.cpp
@@ -0,0 +1,103 @@
+#include <gtest/gtest.h>
+
+#include <random>
+#include <string>
+
+#include "esphome/components/mqtt/mqtt_topic_match.h"
+
+namespace esphome::mqtt::testing {
+
+// The previous recursive implementation, kept to check the loop matches it
+static bool reference_match(const char *message, const char *subscription, bool is_normal, bool past_separator) {
+  if (*message == '\0' && *subscription == '\0')
+    return true;
+  if (*message == '\0' || *subscription == '\0')
+    return false;
+  bool do_wildcards = is_normal || past_separator;
+  if (*subscription == '+' && do_wildcards) {
+    subscription++;
+    while (*message != '\0' && *message != '/')
+      message++;
+    return reference_match(message, subscription, is_normal, true);
+  }
+  if (*subscription == '#' && do_wildcards)
+    return true;
+  if (*message != *subscription)
+    return false;
+  past_separator = past_separator || *subscription == '/';
+  return reference_match(message + 1, subscription + 1, is_normal, past_separator);
+}
+
+static bool reference_match(const char *message, const char *subscription) {
+  return reference_match(message, subscription, *message != '\0' && *message != '$', false);
+}
+
+TEST(MQTTTopicMatch, Exact) {
+  EXPECT_TRUE(topic_match("a/b/c", "a/b/c"));
+  EXPECT_FALSE(topic_match("a/b/c", "a/b"));
+  EXPECT_FALSE(topic_match("a/b", "a/b/c"));
+  EXPECT_FALSE(topic_match("a/b/c", "a/b/d"));
+}
+
+TEST(MQTTTopicMatch, SingleLevelWildcard) {
+  EXPECT_TRUE(topic_match("a/b/c", "a/+/c"));
+  EXPECT_TRUE(topic_match("a/b/c", "+/+/+"));
+  EXPECT_TRUE(topic_match("a//c", "a/+/c"));
+  EXPECT_FALSE(topic_match("a/b/c", "a/+"));
+  EXPECT_FALSE(topic_match("a/b/c/d", "a/+/c"));
+}
+
+TEST(MQTTTopicMatch, MultiLevelWildcard) {
+  EXPECT_TRUE(topic_match("a/b/c", "a/#"));
+  EXPECT_TRUE(topic_match("a/b/c", "#"));
+  EXPECT_TRUE(topic_match("a/b/c", "a/+/#"));
+  EXPECT_FALSE(topic_match("b/c", "a/#"));
+}
+
+TEST(MQTTTopicMatch, DollarTopicsSkipFirstLevelWildcards) {
+  EXPECT_FALSE(topic_match("$SYS/broker", "#"));
+  EXPECT_FALSE(topic_match("$SYS/broker", "+/broker"));
+  EXPECT_TRUE(topic_match("$SYS/broker", "$SYS/#"));
+  EXPECT_TRUE(topic_match("$SYS/broker", "$SYS/+"));
+}
+
+TEST(MQTTTopicMatch, EdgeCases) {
+  EXPECT_TRUE(topic_match("", ""));
+  EXPECT_FALSE(topic_match("a", ""));
+  // Kept from the previous code; the MQTT spec has "#" match the parent level and "+" an empty last level
+  EXPECT_FALSE(topic_match("a/b", "a/b/#"));
+  EXPECT_FALSE(topic_match("a/", "a/+"));
+  EXPECT_TRUE(topic_match("a/$x", "a/+"));
+}
+
+// Recursion overflowed the ESP32 loop stack at about 250 characters
+TEST(MQTTTopicMatch, LongTopic) {
+  std::string topic(4096, 'x');
+  topic[100] = '/';
+  EXPECT_TRUE(topic_match(topic.c_str(), topic.c_str()));
+  std::string other = topic;
+  other.back() = 'y';
+  EXPECT_FALSE(topic_match(topic.c_str(), other.c_str()));
+}
+
+TEST(MQTTTopicMatch, MatchesPreviousImplementation) {
+  // Small alphabet so wildcards, separators and '$' meet often
+  static constexpr char MESSAGE_CHARS[] = {'a', 'b', '/', '$'};
+  static constexpr char SUBSCRIPTION_CHARS[] = {'a', 'b', '/', '$', '+', '#'};
+  std::mt19937 rng(1234);  // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed) reproducible
+  auto random_string = [&rng](const char *chars, size_t count) {
+    std::string s(rng() % 8, ' ');
+    for (char &c : s)
+      c = chars[rng() % count];
+    return s;
+  };
+  for (int i = 0; i < 20000; i++) {
+    std::string message = random_string(MESSAGE_CHARS, sizeof(MESSAGE_CHARS));
+    std::string subscription = random_string(SUBSCRIPTION_CHARS, sizeof(SUBSCRIPTION_CHARS));
+    ASSERT_EQ(topic_match(message.c_str(), subscription.c_str()),
+              reference_match(message.c_str(), subscription.c_str()))
+        << "message='" << message << "' subscription='" << subscription << "'";
+  }
+}
+
+}  // namespace esphome::mqtt::testing

From dd2582bdfd71dfad2ace33b072048232ce9ce578 Mon Sep 17 00:00:00 2001
From: puddly <32534428+puddly@users.noreply.github.com>
Date: Wed, 14 Oct 2026 17:41:12 -0400
Subject: [PATCH 05/21] [usb_uart] Expose `interface_class` and `port_number`
 (#20659)

Co-authored-by: J. Nick Koston <nick@home-assistant.io>
---
 esphome/components/api/api.proto              |  7 ++-
 esphome/components/api/api_pb2.cpp            |  4 ++
 esphome/components/api/api_pb2.h              |  2 +
 esphome/components/api/api_pb2_dump.cpp       |  2 +
 .../components/serial_proxy/serial_proxy.cpp  |  2 +
 esphome/components/usb_uart/ch34x.cpp         |  8 ---
 esphome/components/usb_uart/cp210x.cpp        | 10 ++--
 esphome/components/usb_uart/ft23xx.cpp        |  1 +
 esphome/components/usb_uart/pl2303.cpp        |  5 +-
 esphome/components/usb_uart/usb_uart.cpp      |  6 ++-
 esphome/components/usb_uart/usb_uart.h        | 21 +++++++-
 tests/components/serial_proxy/__init__.py     | 16 ++++++
 .../test_usb_device_descriptor.cpp            | 51 +++++++++++++++++++
 13 files changed, 115 insertions(+), 20 deletions(-)
 create mode 100644 tests/components/serial_proxy/__init__.py
 create mode 100644 tests/components/serial_proxy/test_usb_device_descriptor.cpp

diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index 77b5afe818e..6ba7bde9af6 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -3043,12 +3043,15 @@ enum SerialProxyIdentityFlag {
                                              // IDs below are empty
 }
 
-// The descriptor fields of a USB device as seen by the host stack
+// The descriptor fields of a USB device as seen by the host stack, and the port's index
+// among those a vendor driver exposes on the interface
 message UsbDeviceDescriptor {
   uint32 vendor_id = 1;
   uint32 product_id = 2;
   uint32 bcd_device = 3;
-  uint32 interface_number = 4;   // bInterfaceNumber the host driver binds to
+  uint32 interface_number = 4;  // bInterfaceNumber the port is bound through
+  uint32 interface_class = 5;   // bInterfaceClass of that interface
+  uint32 port_number = 6;
 }
 
 // The identity of the device behind a port. Identifies one physical device among others of
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index b59663aeb51..a3a08b78e3d 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -4175,6 +4175,8 @@ uint8_t *UsbDeviceDescriptor::encode_msg(const void *self, uint8_t *__restrict__
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.product_id);
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.bcd_device);
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.interface_number);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.interface_class);
+  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, msg.port_number);
   return pos;
 }
 uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
@@ -4184,6 +4186,8 @@ uint32_t UsbDeviceDescriptor::calc_size_msg(const void *self) {
   size += ProtoSize::calc_uint32(1, msg.product_id);
   size += ProtoSize::calc_uint32(1, msg.bcd_device);
   size += ProtoSize::calc_uint32(1, msg.interface_number);
+  size += ProtoSize::calc_uint32(1, msg.interface_class);
+  size += ProtoSize::calc_uint32(1, msg.port_number);
   return size;
 }
 uint8_t *SerialProxyIdentity::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index 421c3fccb38..ef4e713c77d 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -4083,6 +4083,8 @@ class UsbDeviceDescriptor final : public ProtoMessage {
   uint32_t product_id{0};
   uint32_t bcd_device{0};
   uint32_t interface_number{0};
+  uint32_t interface_class{0};
+  uint32_t port_number{0};
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp
index 3c6f5302b55..ec224c46e29 100644
--- a/esphome/components/api/api_pb2_dump.cpp
+++ b/esphome/components/api/api_pb2_dump.cpp
@@ -2942,6 +2942,8 @@ const char *UsbDeviceDescriptor::dump_to(DumpBuffer &out) const {
   dump_field(out, ESPHOME_PSTR("product_id"), this->product_id);
   dump_field(out, ESPHOME_PSTR("bcd_device"), this->bcd_device);
   dump_field(out, ESPHOME_PSTR("interface_number"), this->interface_number);
+  dump_field(out, ESPHOME_PSTR("interface_class"), this->interface_class);
+  dump_field(out, ESPHOME_PSTR("port_number"), this->port_number);
   return out.c_str();
 }
 const char *SerialProxyIdentity::dump_to(DumpBuffer &out) const {
diff --git a/esphome/components/serial_proxy/serial_proxy.cpp b/esphome/components/serial_proxy/serial_proxy.cpp
index 16e0f0b984c..a34b1b5b514 100644
--- a/esphome/components/serial_proxy/serial_proxy.cpp
+++ b/esphome/components/serial_proxy/serial_proxy.cpp
@@ -412,6 +412,8 @@ void SerialProxy::fill_identity_([[maybe_unused]] IdentityScratch &scratch, api:
     msg.usb.product_id = scratch.product_id;
     msg.usb.bcd_device = scratch.bcd_device;
     msg.usb.interface_number = this->usb_channel_->get_interface_number();
+    msg.usb.interface_class = this->usb_channel_->get_interface_class();
+    msg.usb.port_number = this->usb_channel_->get_port_number();
     msg.manufacturer = StringRef(scratch.manufacturer);
     msg.product = StringRef(scratch.product);
     msg.serial_number = StringRef(scratch.serial_number);
diff --git a/esphome/components/usb_uart/ch34x.cpp b/esphome/components/usb_uart/ch34x.cpp
index ed5a034b82f..dce07a64a53 100644
--- a/esphome/components/usb_uart/ch34x.cpp
+++ b/esphome/components/usb_uart/ch34x.cpp
@@ -152,14 +152,6 @@ bool USBUartTypeCH34X::config_step(USBUartChannelBase *channel, uint8_t step, bo
   }
 }
 
-std::vector<CdcEps> USBUartTypeCH34X::parse_descriptors(usb_device_handle_t dev_hdl) {
-  auto result = USBUartTypeCdcAcm::parse_descriptors(dev_hdl);
-  // ch34x doesn't use the interrupt endpoint, and we don't have endpoints to spare
-  for (auto &cdc_dev : result) {
-    cdc_dev.interrupt_interface_number = 0xFF;
-  }
-  return result;
-}
 }  // namespace esphome::usb_uart
 
 #endif  // USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S2 || USE_ESP32_VARIANT_ESP32S3 ||
diff --git a/esphome/components/usb_uart/cp210x.cpp b/esphome/components/usb_uart/cp210x.cpp
index e920da6c267..34b76f88541 100644
--- a/esphome/components/usb_uart/cp210x.cpp
+++ b/esphome/components/usb_uart/cp210x.cpp
@@ -88,11 +88,11 @@ std::vector<CdcEps> USBUartTypeCP210X::parse_descriptors(usb_device_handle_t dev
       ESP_LOGE(TAG, "in_ep: usb_parse_endpoint_descriptor_by_index failed");
       continue;
     }
-    if (in_ep->bEndpointAddress & usb_host::USB_DIR_IN) {
-      cdc_devs.push_back({CdcEps{nullptr, in_ep, out_ep, data_desc->bInterfaceNumber}});
-    } else {
-      cdc_devs.push_back({CdcEps{nullptr, out_ep, in_ep, data_desc->bInterfaceNumber}});
-    }
+    CdcEps eps = in_ep->bEndpointAddress & usb_host::USB_DIR_IN
+                     ? CdcEps{nullptr, in_ep, out_ep, data_desc->bInterfaceNumber}
+                     : CdcEps{nullptr, out_ep, in_ep, data_desc->bInterfaceNumber};
+    eps.bulk_interface_class = data_desc->bInterfaceClass;
+    cdc_devs.push_back(eps);
   }
   return cdc_devs;
 }
diff --git a/esphome/components/usb_uart/ft23xx.cpp b/esphome/components/usb_uart/ft23xx.cpp
index e10da78aaf0..805a4adfce3 100644
--- a/esphome/components/usb_uart/ft23xx.cpp
+++ b/esphome/components/usb_uart/ft23xx.cpp
@@ -217,6 +217,7 @@ static optional<CdcEps> get_uart(const usb_config_desc_t *config_desc, uint8_t i
   }
 
   eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+  eps.bulk_interface_class = intf_desc->bInterfaceClass;
   return eps;
 }
 
diff --git a/esphome/components/usb_uart/pl2303.cpp b/esphome/components/usb_uart/pl2303.cpp
index 36107c093c4..0430b1eeacb 100644
--- a/esphome/components/usb_uart/pl2303.cpp
+++ b/esphome/components/usb_uart/pl2303.cpp
@@ -189,7 +189,10 @@ std::vector<CdcEps> USBUartTypePL2303::parse_descriptors(usb_device_handle_t dev
     }
 
     if (in_ep && out_ep) {
-      cdc_devs.push_back(CdcEps{notify_ep, in_ep, out_ep, intf->bInterfaceNumber, intf->bInterfaceNumber});
+      CdcEps eps{notify_ep, in_ep, out_ep, intf->bInterfaceNumber, intf->bInterfaceNumber};
+      eps.bulk_interface_class = intf->bInterfaceClass;
+      eps.interrupt_interface_class = intf->bInterfaceClass;
+      cdc_devs.push_back(eps);
       break;  // PL2303 is single-port
     }
   }
diff --git a/esphome/components/usb_uart/usb_uart.cpp b/esphome/components/usb_uart/usb_uart.cpp
index f61642566cb..744b79f4e43 100644
--- a/esphome/components/usb_uart/usb_uart.cpp
+++ b/esphome/components/usb_uart/usb_uart.cpp
@@ -41,14 +41,17 @@ static optional<CdcEps> get_cdc(const usb_config_desc_t *config_desc, uint8_t in
       if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_INT) {
         eps.notify_ep = ep;
         eps.interrupt_interface_number = intf_desc->bInterfaceNumber;
+        eps.interrupt_interface_class = intf_desc->bInterfaceClass;
       } else if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_BULK && ep->bEndpointAddress & usb_host::USB_DIR_IN &&
                  (eps.bulk_interface_number == 0xFF || eps.bulk_interface_number == intf_desc->bInterfaceNumber)) {
         eps.in_ep = ep;
         eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+        eps.bulk_interface_class = intf_desc->bInterfaceClass;
       } else if (ep->bmAttributes == USB_BM_ATTRIBUTES_XFER_BULK && !(ep->bEndpointAddress & usb_host::USB_DIR_IN) &&
                  (eps.bulk_interface_number == 0xFF || eps.bulk_interface_number == intf_desc->bInterfaceNumber)) {
         eps.out_ep = ep;
         eps.bulk_interface_number = intf_desc->bInterfaceNumber;
+        eps.bulk_interface_class = intf_desc->bInterfaceClass;
       } else {
         ESP_LOGE(TAG, "Unexpected endpoint attributes: %02X", ep->bmAttributes);
         continue;
@@ -431,8 +434,7 @@ void USBUartTypeCdcAcm::on_connected() {
     if (channel->cdc_dev_.interrupt_interface_number != 0xFF &&
         channel->cdc_dev_.interrupt_interface_number != channel->cdc_dev_.bulk_interface_number) {
       if (!this->claim_comm_interface_) {
-        ESP_LOGD(TAG, "Skipping comm interface %d (claim_comm_interface: false)",
-                 channel->cdc_dev_.interrupt_interface_number);
+        ESP_LOGD(TAG, "Comm interface %d left unclaimed", channel->cdc_dev_.interrupt_interface_number);
       } else {
         auto err_comm = usb_host_interface_claim(this->handle_, this->device_handle_,
                                                  channel->cdc_dev_.interrupt_interface_number, 0);
diff --git a/esphome/components/usb_uart/usb_uart.h b/esphome/components/usb_uart/usb_uart.h
index 4e52fb60e20..9f527a9becd 100644
--- a/esphome/components/usb_uart/usb_uart.h
+++ b/esphome/components/usb_uart/usb_uart.h
@@ -39,6 +39,9 @@ struct CdcEps {
   // must remain valid even when the interface itself is not claimed.
   uint8_t interrupt_interface_number{0xFF};
   bool interrupt_interface_claimed{false};
+  // bInterfaceClass of each interface above, which decides how a host binds the port
+  uint8_t bulk_interface_class{0};
+  uint8_t interrupt_interface_class{0};
 };
 
 enum CH34xChipType : uint8_t {
@@ -186,6 +189,16 @@ class USBUartChannelBase : public uart::UARTComponent, public Parented<USBUartCo
                                                              : this->cdc_dev_.bulk_interface_number;
   }
 
+  /// bInterfaceClass of the interface `get_interface_number()` names
+  uint8_t get_interface_class() const {
+    return this->cdc_dev_.interrupt_interface_number != 0xFF ? this->cdc_dev_.interrupt_interface_class
+                                                             : this->cdc_dev_.bulk_interface_class;
+  }
+
+  /// Index of this port among the ports on its interface. Every driver here exposes one
+  /// port per interface; a multiplexed driver would index its channels.
+  uint8_t get_port_number() const { return 0; }
+
  protected:
   // Not directly instantiable; construct a concrete channel type instead.
   USBUartChannelBase(uint8_t index, uint16_t buffer_size) : input_buffer_(RingBuffer(buffer_size)), index_(index) {}
@@ -317,13 +330,17 @@ class USBUartTypeCP210X : public USBUartTypeCdcAcm {
 };
 class USBUartTypeCH34X : public USBUartTypeCdcAcm {
  public:
-  USBUartTypeCH34X(uint16_t vid, uint16_t pid) : USBUartTypeCdcAcm(vid, pid) {}
+  USBUartTypeCH34X(uint16_t vid, uint16_t pid) : USBUartTypeCdcAcm(vid, pid) {
+    // ch34x doesn't use the interrupt endpoint, and we don't have endpoints to spare. The
+    // comm interface is left in place unclaimed: on the CDC-style chips it is still the
+    // interface a host binds, and so the one the port is identified by.
+    this->claim_comm_interface_ = false;
+  }
   void dump_config() override;
 
  protected:
   bool config_step(USBUartChannelBase *channel, uint8_t step, bool reload, bool ok, const uint8_t *response) override;
   bool config_device_step(uint8_t step, bool ok, const uint8_t *response) override;
-  std::vector<CdcEps> parse_descriptors(usb_device_handle_t dev_hdl) override;
 
  private:
   CH34xChipType chiptype_{CHIP_UNKNOWN};
diff --git a/tests/components/serial_proxy/__init__.py b/tests/components/serial_proxy/__init__.py
new file mode 100644
index 00000000000..913e8d8b37e
--- /dev/null
+++ b/tests/components/serial_proxy/__init__.py
@@ -0,0 +1,16 @@
+import esphome.codegen as cg
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # The harness gives a multi-instance component an empty list and never calls its to_code,
+    # so take a single empty config instead and emit what the proxy messages and handlers
+    # need. No proxy is configured, so the count is 0, which keeps the capability messages as
+    # the api tests expect them; the USB identity stays out, since the USB channel exists on the ESP32 only.
+    manifest.multi_conf = False
+
+    async def to_code_testing(config):
+        cg.add_define("USE_SERIAL_PROXY")
+        cg.add_define("SERIAL_PROXY_COUNT", 0)
+
+    manifest.to_code = to_code_testing
diff --git a/tests/components/serial_proxy/test_usb_device_descriptor.cpp b/tests/components/serial_proxy/test_usb_device_descriptor.cpp
new file mode 100644
index 00000000000..c76757bbee6
--- /dev/null
+++ b/tests/components/serial_proxy/test_usb_device_descriptor.cpp
@@ -0,0 +1,51 @@
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "esphome/components/api/api_buffer.h"
+#include "esphome/components/api/api_pb2.h"
+#include "esphome/components/api/proto.h"
+
+namespace esphome::api::testing {
+
+// Encodes into a buffer of exactly the calculated size, so any overrun trips the debug bounds check.
+static std::vector<uint8_t> encode(const UsbDeviceDescriptor &msg) {
+  const uint32_t size = msg.calculate_size();
+  APIBuffer buf;
+  EXPECT_TRUE(buf.resize(size == 0 ? 1 : size));
+  uint8_t *pos = buf.data();
+#ifdef ESPHOME_DEBUG_API
+  uint8_t *proto_debug_end_ = buf.data() + buf.size();
+#endif
+  uint8_t *end = UsbDeviceDescriptor::encode_msg(&msg, pos PROTO_ENCODE_DEBUG_ARG);
+  EXPECT_EQ(static_cast<uint32_t>(end - buf.data()), size);
+  return {buf.data(), end};
+}
+
+TEST(UsbDeviceDescriptor, EncodesTheInterfaceClassAndPort) {
+  UsbDeviceDescriptor msg;
+  msg.vendor_id = 0x10C4;
+  msg.product_id = 0xEA60;
+  msg.bcd_device = 0x0100;
+  msg.interface_number = 1;
+  msg.interface_class = 0xFF;
+  msg.port_number = 2;
+
+  const std::vector<uint8_t> expected = {0x08, 0xC4, 0x21, 0x10, 0xE0, 0xD4, 0x03, 0x18, 0x80,
+                                         0x02, 0x20, 0x01, 0x28, 0xFF, 0x01, 0x30, 0x02};
+  EXPECT_EQ(encode(msg), expected);
+}
+
+TEST(UsbDeviceDescriptor, ZeroClassAndPortLeaveTheWireAsBefore) {
+  // The new fields are additive with zero defaults, so an old client sees the message it always did
+  UsbDeviceDescriptor msg;
+  msg.vendor_id = 0x303A;
+  msg.product_id = 0x1001;
+  msg.interface_number = 1;
+
+  const std::vector<uint8_t> expected = {0x08, 0xBA, 0x60, 0x10, 0x81, 0x20, 0x20, 0x01};
+  EXPECT_EQ(encode(msg), expected);
+}
+
+}  // namespace esphome::api::testing

From ad8cd0dd3ea1c29c16d8308debcddb23ef9dbcd0 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Wed, 14 Oct 2026 11:45:54 -1000
Subject: [PATCH 06/21] [noise] Initialize the protocol id's reserved field for
 ESP-IDF 6.1 (#20779)

---
 esphome/components/noise/noise_handshake.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/esphome/components/noise/noise_handshake.cpp b/esphome/components/noise/noise_handshake.cpp
index bd1afa198d3..15938f3aca1 100644
--- a/esphome/components/noise/noise_handshake.cpp
+++ b/esphome/components/noise/noise_handshake.cpp
@@ -37,6 +37,7 @@ int NoiseResponderHandshake::init(const NoiseContext &ctx, const uint8_t *prolog
       .cipher_id = NOISE_CIPHER_CHACHAPOLY,
       .hash_id = NOISE_HASH_SHA256,
       .hybrid_id = NOISE_DH_NONE,
+      .reserved = {},
   };
 
   int err = noise_handshakestate_new_by_id(&this->handshake_, &nid, NOISE_ROLE_RESPONDER);

From 4552dbad7a9e13e195657675882ff94bddbde86d Mon Sep 17 00:00:00 2001
From: "esphome[bot]" <115708604+esphome[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 12:43:07 -1000
Subject: [PATCH 07/21] Bump aioesphomeapi from 46.11.0 to 46.12.0 (#20781)

Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 486612817c2..d81770cf647 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -12,7 +12,7 @@ pyserial==3.5
 platformio==6.2.0
 esptool==5.4.0
 click==8.5.0
-aioesphomeapi==46.11.0
+aioesphomeapi==46.12.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
 zeroconf==0.151.5
 puremagic==2.2.0

From f464994f859451ba7cdb77438c53a88bc21d900f Mon Sep 17 00:00:00 2001
From: Kevin Ahrendt <kevin.ahrendt@openhomefoundation.org>
Date: Wed, 14 Oct 2026 18:56:51 -0400
Subject: [PATCH 08/21] [api][sendspin] Add the Sendspin client id to the
 capabilities message (#20775)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/api/api.proto                  | 3 +++
 esphome/components/api/api_connection.cpp         | 1 +
 esphome/components/api/api_pb2.cpp                | 2 ++
 esphome/components/api/api_pb2.h                  | 1 +
 esphome/components/api/api_pb2_dump.cpp           | 1 +
 esphome/components/sendspin/sendspin_hub.cpp      | 8 ++++++++
 esphome/components/sendspin/sendspin_hub.h        | 6 ++++++
 tests/unit_tests/components/api/test_api_proto.py | 2 +-
 8 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index 6ba7bde9af6..8e9ff00f59c 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -403,6 +403,9 @@ message WizardCapabilities {
 message SendspinCapabilities {
   // Bitmask of the Sendspin features this device supports
   uint32 feature_flags = 1;
+  // The Sendspin client_id: base64url of the client's static public key, 43 characters.
+  // Empty until the Sendspin client has started once since boot.
+  string client_id = 2 [(max_data_length) = 43];
 }
 
 message DeviceCapabilitiesResponse {
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 73ce4bd8569..efa0beb55e1 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -2128,6 +2128,7 @@ bool APIConnection::send_device_capabilities_response_() {
 #endif
 #if defined(USE_SENDSPIN) && defined(USE_ESP_IDF)
   resp.sendspin.feature_flags = sendspin_::global_sendspin_hub->get_feature_flags();
+  resp.sendspin.client_id = sendspin_::global_sendspin_hub->get_client_id();
 #endif
   return this->send_message(resp);
 }
diff --git a/esphome/components/api/api_pb2.cpp b/esphome/components/api/api_pb2.cpp
index a3a08b78e3d..a3a2e09501f 100644
--- a/esphome/components/api/api_pb2.cpp
+++ b/esphome/components/api/api_pb2.cpp
@@ -310,12 +310,14 @@ uint32_t WizardCapabilities::calc_size_msg(const void *self) {
 uint8_t *SendspinCapabilities::encode_msg(const void *self, uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
   const auto &msg = *static_cast<const SendspinCapabilities *>(self);
   pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.feature_flags);
+  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 2, msg.client_id);
   return pos;
 }
 uint32_t SendspinCapabilities::calc_size_msg(const void *self) {
   const auto &msg = *static_cast<const SendspinCapabilities *>(self);
   uint32_t size = 0;
   size += ProtoSize::calc_uint32(1, msg.feature_flags);
+  size += !msg.client_id.empty() ? 2 + msg.client_id.size() : 0;
   return size;
 }
 #endif
diff --git a/esphome/components/api/api_pb2.h b/esphome/components/api/api_pb2.h
index ef4e713c77d..cbfdb49ac9a 100644
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
@@ -750,6 +750,7 @@ class WizardCapabilities final : public ProtoMessage {
 class SendspinCapabilities final : public ProtoMessage {
  public:
   uint32_t feature_flags{0};
+  StringRef client_id{nullptr, 0};  // null until set, encode only
   static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
   uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
     return encode_msg(this, buffer.get_pos() PROTO_ENCODE_DEBUG_ARG);
diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp
index ec224c46e29..23ce6319ed1 100644
--- a/esphome/components/api/api_pb2_dump.cpp
+++ b/esphome/components/api/api_pb2_dump.cpp
@@ -1119,6 +1119,7 @@ const char *WizardCapabilities::dump_to(DumpBuffer &out) const {
 const char *SendspinCapabilities::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, ESPHOME_PSTR("SendspinCapabilities"));
   dump_field(out, ESPHOME_PSTR("feature_flags"), this->feature_flags);
+  dump_field(out, ESPHOME_PSTR("client_id"), this->client_id);
   return out.c_str();
 }
 #endif
diff --git a/esphome/components/sendspin/sendspin_hub.cpp b/esphome/components/sendspin/sendspin_hub.cpp
index df680202061..30bff186155 100644
--- a/esphome/components/sendspin/sendspin_hub.cpp
+++ b/esphome/components/sendspin/sendspin_hub.cpp
@@ -243,6 +243,14 @@ std::optional<std::string> SendspinHub::get_pairing_token() const {
   return this->client_->pairing_token();
 }
 
+// THREAD CONTEXT: Main loop
+StringRef SendspinHub::get_client_id() const {
+  if (this->client_ == nullptr) {
+    return StringRef();
+  }
+  return StringRef(this->client_->client_id());
+}
+
 // THREAD CONTEXT: Main loop (invoked from codegen before setup(), or from Sendspin components)
 void SendspinHub::set_unpaired_access_enabled(bool enabled) {
   this->unpaired_access_ = enabled;
diff --git a/esphome/components/sendspin/sendspin_hub.h b/esphome/components/sendspin/sendspin_hub.h
index cd8d0d0afaf..23c60d215b6 100644
--- a/esphome/components/sendspin/sendspin_hub.h
+++ b/esphome/components/sendspin/sendspin_hub.h
@@ -198,6 +198,12 @@ class SendspinHub final : public Component,
   /// started once; it stays available after the client stops. Main loop only.
   std::optional<std::string> get_pairing_token() const;
 
+  /// @brief Returns the Sendspin client_id: base64url of the client's static public key.
+  ///
+  /// Empty until the client has started once; it stays set after the client stops. The returned StringRef points into
+  /// the client's string, which start() may rewrite, so do not keep it past the current call. Main loop only.
+  StringRef get_client_id() const;
+
   /// @brief Sets the device information reported to the server in the `client/hello` message.
   ///
   /// Each takes a pointer to a string literal emitted by codegen, so it must stay valid for the
diff --git a/tests/unit_tests/components/api/test_api_proto.py b/tests/unit_tests/components/api/test_api_proto.py
index ca3c0ce7b58..68e3cab2a21 100644
--- a/tests/unit_tests/components/api/test_api_proto.py
+++ b/tests/unit_tests/components/api/test_api_proto.py
@@ -71,7 +71,7 @@ NEW_CAPABILITY_FIELDS: dict[str, dict[str, int]] = {
         "sendspin": 6,
     },
     "WizardCapabilities": {"configured": 1},
-    "SendspinCapabilities": {"feature_flags": 1},
+    "SendspinCapabilities": {"feature_flags": 1, "client_id": 2},
     "BluetoothProxyCapabilities": {
         "feature_flags": 1,
         "mac_address": 2,

From bd5b3fa64125d7ba4bbfd69c46b7db536156e56b Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Wed, 14 Oct 2026 15:59:56 -1000
Subject: [PATCH 09/21] [esp32_ble_client] Value-initialize the connection
 parameters for ESP-IDF 6.1 (#20776)

---
 esphome/components/esp32_ble_client/ble_client_base.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/esp32_ble_client/ble_client_base.cpp b/esphome/components/esp32_ble_client/ble_client_base.cpp
index cfd77e84f4a..547ab6748bf 100644
--- a/esphome/components/esp32_ble_client/ble_client_base.cpp
+++ b/esphome/components/esp32_ble_client/ble_client_base.cpp
@@ -300,7 +300,7 @@ void BLEClientBase::log_warning_(const char *message) {
 
 esp_err_t BLEClientBase::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
                                              uint16_t timeout, const char *param_type) {
-  esp_ble_conn_update_params_t conn_params = {{0}};
+  esp_ble_conn_update_params_t conn_params = {};
   memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
   conn_params.min_int = min_interval;
   conn_params.max_int = max_interval;

From e09cb64756d48b61db4ae20b42707211b3ca1468 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Wed, 14 Oct 2026 16:00:07 -1000
Subject: [PATCH 10/21] [bluetooth_connection] Value-initialize the connection
 parameters for ESP-IDF 6.1 (#20774)

---
 .../bluetooth_connection/bluetooth_connection_bluedroid.cpp     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp b/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp
index d3af02780fe..b7017bc105b 100644
--- a/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp
+++ b/esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp
@@ -382,7 +382,7 @@ void BluedroidGattClient::set_disconnecting_() {
 
 esp_err_t BluedroidGattClient::update_conn_params_(uint16_t min_interval, uint16_t max_interval, uint16_t latency,
                                                    uint16_t timeout, const char *param_type) {
-  esp_ble_conn_update_params_t conn_params = {{0}};
+  esp_ble_conn_update_params_t conn_params = {};
   memcpy(conn_params.bda, this->remote_bda_, sizeof(esp_bd_addr_t));
   conn_params.min_int = min_interval;
   conn_params.max_int = max_interval;

From 79823c89abb7f3c66794df286177861a48a4e867 Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Wed, 14 Oct 2026 22:05:01 -0400
Subject: [PATCH 11/21] [mipi_rgb] Rotate pure RGB panels in software (#20757)

---
 .../components/mipi_rgb/models/__init__.py    |  6 +++-
 .../mipi_rgb/test_mipi_rgb_config.py          | 35 +++++++++++++++++--
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/esphome/components/mipi_rgb/models/__init__.py b/esphome/components/mipi_rgb/models/__init__.py
index 9e3fe2a476f..62f8c7789d4 100644
--- a/esphome/components/mipi_rgb/models/__init__.py
+++ b/esphome/components/mipi_rgb/models/__init__.py
@@ -9,6 +9,10 @@ class RgbDriverChip(DriverChip):
     def transforms(self) -> set[str]:
         """
         Return the set of transformations supported by this driver chip.
-        RGB displays do not support axis swapping, so this method removes CONF_SWAP_XY
+        RGB displays do not support axis swapping, so this method removes CONF_SWAP_XY.
+        A model with an empty init sequence has no command interface at all, so it
+        cannot apply any transform in hardware.
         """
+        if self.initsequence is not None and len(self.initsequence) == 0:
+            return set()
         return super().transforms - {CONF_SWAP_XY}
diff --git a/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py b/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py
index e677577ec08..58e7ba9d959 100644
--- a/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py
+++ b/tests/component_tests/mipi_rgb/test_mipi_rgb_config.py
@@ -93,12 +93,12 @@ def test_transform_matches_model_support(
 
     from esphome.components.mipi_rgb.display import CONFIG_SCHEMA, MODELS
 
-    # ESP32-8048S070 supports both mirror axes but not swap_xy (RGB displays
+    # The full-height ST7701S supports both mirror axes but not swap_xy (RGB displays
     # never support axis swapping).
-    model = MODELS["ESP32-8048S070"]
+    model = MODELS["ST7701S"]
     assert model.transforms == {CONF_MIRROR_X, CONF_MIRROR_Y}
 
-    base = {"model": "ESP32-8048S070", "data_pins": DATA_PINS, "pclk_pin": 21}
+    base = {"model": "ST7701S", "data_pins": DATA_PINS, "pclk_pin": 21}
     CONFIG_SCHEMA({**base, "transform": {"mirror_x": True, "mirror_y": False}})
 
     # An unsupported axis may be explicitly disabled (a harmless no-op)...
@@ -139,6 +139,35 @@ def test_st7701s_only_supports_mirror_x(
         CONFIG_SCHEMA({**base, "transform": {"mirror_x": True, "mirror_y": True}})
 
 
+def test_pure_rgb_model_has_no_hardware_transform(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    """A model with no init sequence has no command interface, so no transform
+    can be applied in hardware and every rotation must be done in software.
+
+    Previously such models claimed mirror_x/mirror_y support, so a rotation of
+    180 was handed to the (nonexistent) hardware and the display was not rotated.
+    """
+    _set_s3(set_core_config)
+
+    from esphome.components.mipi_rgb.display import CONFIG_SCHEMA, MODELS
+
+    model = MODELS["ESP32-8048S070"]
+    assert model.initsequence == ()
+    assert model.transforms == set()
+
+    base = {"model": "ESP32-8048S070", "data_pins": DATA_PINS, "pclk_pin": 21}
+    for rotation in (90, 180, 270):
+        config = CONFIG_SCHEMA({**base, "id": f"rot_{rotation}", "rotation": rotation})
+        assert not model.rotation_as_transform(config)
+        metadata = get_display_metadata(config["id"])
+        assert metadata.rotation == rotation
+        assert not metadata.has_hardware_rotation
+
+    with pytest.raises(cv.Invalid, match="'mirror_x' is not supported by this model"):
+        CONFIG_SCHEMA({**base, "transform": {"mirror_x": True}})
+
+
 def test_metadata_records_rotation(
     set_core_config: SetCoreConfigCallable,
 ) -> None:

From 235c614e68eb2085d97f0afa2b1bd8ee45a4eb37 Mon Sep 17 00:00:00 2001
From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com>
Date: Thu, 15 Oct 2026 21:55:19 +1100
Subject: [PATCH 12/21] [epaper_spi] Ensure test card gets drawn (#20804)

---
 esphome/components/epaper_spi/display.py      |  1 +
 .../config/test_card_update_interval.yaml     | 22 +++++++++++++++++++
 tests/component_tests/epaper_spi/test_init.py | 12 ++++++++++
 3 files changed, 35 insertions(+)
 create mode 100644 tests/component_tests/epaper_spi/config/test_card_update_interval.yaml

diff --git a/esphome/components/epaper_spi/display.py b/esphome/components/epaper_spi/display.py
index 487e8e5ef40..32ac0b9da70 100644
--- a/esphome/components/epaper_spi/display.py
+++ b/esphome/components/epaper_spi/display.py
@@ -208,6 +208,7 @@ def _final_validate(config) -> None:
         else:
             # If no drawing methods are configured, and LVGL is not enabled, show a test card
             config[CONF_SHOW_TEST_CARD] = True
+            config[CONF_UPDATE_INTERVAL] = update_interval("1min")
     elif CONF_UPDATE_INTERVAL not in config:
         config[CONF_UPDATE_INTERVAL] = update_interval("1min")
 
diff --git a/tests/component_tests/epaper_spi/config/test_card_update_interval.yaml b/tests/component_tests/epaper_spi/config/test_card_update_interval.yaml
new file mode 100644
index 00000000000..fb6eeec8d77
--- /dev/null
+++ b/tests/component_tests/epaper_spi/config/test_card_update_interval.yaml
@@ -0,0 +1,22 @@
+esphome:
+  name: test
+
+esp32:
+  board: esp32dev
+
+spi:
+  clk_pin: GPIO18
+  mosi_pin: GPIO19
+
+display:
+  - platform: epaper_spi
+    id: epaper_display
+    model: ssd1677
+    dc_pin: GPIO21
+    busy_pin: GPIO22
+    reset_pin: GPIO23
+    cs_pin: GPIO5
+    update_interval: never
+    dimensions:
+      width: 200
+      height: 200
diff --git a/tests/component_tests/epaper_spi/test_init.py b/tests/component_tests/epaper_spi/test_init.py
index 4b8f5788925..81e197abf81 100644
--- a/tests/component_tests/epaper_spi/test_init.py
+++ b/tests/component_tests/epaper_spi/test_init.py
@@ -580,3 +580,15 @@ def test_model_with_no_default_init_sequence_generates(
     # init_sequence_length, ...); a length of 0 confirms the empty init
     # sequence array was generated instead of raising during code generation.
     assert re.search(r"epaper_spi::EPaperT133A01\([^;]*,\s*\w+,\s*0\);", main_cpp)
+
+
+def test_test_card_overrides_update_interval(
+    generate_main: Callable[[str | Path], str],
+    component_config_path: Callable[[str], Path],
+) -> None:
+    """With nothing else to draw, update_interval is not left at never for the test card."""
+    main_cpp = generate_main(component_config_path("test_card_update_interval.yaml"))
+
+    match = re.search(r"epaper_display->set_update_interval\((\d+)\);", main_cpp)
+    assert match is not None
+    assert int(match.group(1)) != 4294967295

From 0173127239a449d3952cdee2532795f1904431d3 Mon Sep 17 00:00:00 2001
From: "esphome[bot]" <115708604+esphome[bot]@users.noreply.github.com>
Date: Thu, 15 Oct 2026 23:11:26 -1000
Subject: [PATCH 13/21] Bump bundled esphome-device-builder to 1.24.0 (#20851)

Co-authored-by: esphome[bot] <115708604+esphome[bot]@users.noreply.github.com>
---
 docker/Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docker/Dockerfile b/docker/Dockerfile
index c9aa3dba62c..658b8c06302 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.23.1
+RUN uv pip install --no-cache-dir esphome-device-builder==1.24.0
 
 RUN \
     platformio settings set enable_telemetry No \

From 7ccaedfb9e14bccd320b2fa808ee4a56f90d5d1b Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Sat, 17 Oct 2026 12:49:15 -0400
Subject: [PATCH 14/21] [esp32] Bump recommended ESP-IDF to 5.5.6 (#20987)

---
 esphome/components/esp32/__init__.py | 9 +++++----
 platformio.ini                       | 4 ++--
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/esphome/components/esp32/__init__.py b/esphome/components/esp32/__init__.py
index 73078dc19fd..9164b1e1590 100644
--- a/esphome/components/esp32/__init__.py
+++ b/esphome/components/esp32/__init__.py
@@ -1099,7 +1099,7 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
 # See: https://github.com/pioarduino/esp-idf/releases
 ARDUINO_IDF_VERSION_LOOKUP = {
     cv.Version(4, 0, 0, "alpha1"): cv.Version(6, 0, 1),
-    cv.Version(3, 3, 12): cv.Version(5, 5, 5),
+    cv.Version(3, 3, 12): cv.Version(5, 5, 6),
     cv.Version(3, 3, 11): cv.Version(5, 5, 5),
     cv.Version(3, 3, 10): cv.Version(5, 5, 5),
     cv.Version(3, 3, 9): cv.Version(5, 5, 4),
@@ -1123,9 +1123,9 @@ ARDUINO_IDF_VERSION_LOOKUP = {
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(5, 5, 5),
-    "latest": cv.Version(5, 5, 5),
-    "dev": cv.Version(5, 5, 5),
+    "recommended": cv.Version(5, 5, 6),
+    "latest": cv.Version(5, 5, 6),
+    "dev": cv.Version(5, 5, 6),
 }
 
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
@@ -1135,6 +1135,7 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
     cv.Version(
         6, 0, 0
     ): "https://github.com/pioarduino/platform-espressif32.git#prep_IDF6",
+    cv.Version(5, 5, 6): cv.Version(55, 3, 312),
     cv.Version(5, 5, 5): cv.Version(55, 3, 312),
     cv.Version(5, 5, 4): cv.Version(55, 3, 39),
     cv.Version(5, 5, 3, "1"): cv.Version(55, 3, 37),
diff --git a/platformio.ini b/platformio.ini
index 56a12d8b31c..18c410c16b2 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -147,7 +147,7 @@ extends = common:arduino
 platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.312/platform-espressif32.zip
 platform_packages =
     pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/3.3.12/esp32-core-3.3.12.tar.xz
-    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.5/esp-idf-v5.5.5.tar.xz
+    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.6/esp-idf-v5.5.6.tar.xz
 
 framework = arduino, espidf  ; Arduino as an ESP-IDF component
 lib_deps =
@@ -183,7 +183,7 @@ extra_scripts =
 extends = common:idf
 platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.312/platform-espressif32.zip
 platform_packages =
-    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.5/esp-idf-v5.5.5.tar.xz
+    pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.6/esp-idf-v5.5.6.tar.xz
 
 framework = espidf
 lib_deps =

From 0fbba035221341fd23d5836fc382f3f72783184a Mon Sep 17 00:00:00 2001
From: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>
Date: Sat, 17 Oct 2026 12:50:54 -0400
Subject: [PATCH 15/21] [debug] Log uptime in dump_config (#20989)

---
 esphome/components/debug/debug_component.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/esphome/components/debug/debug_component.cpp b/esphome/components/debug/debug_component.cpp
index 97f4522c623..afd1337dca2 100644
--- a/esphome/components/debug/debug_component.cpp
+++ b/esphome/components/debug/debug_component.cpp
@@ -34,6 +34,15 @@ void DebugComponent::dump_config() {
   this->free_heap_ = get_free_heap_();
   ESP_LOGD(TAG, "Free Heap Size: %" PRIu32 " bytes", this->free_heap_);
 
+  uint32_t uptime = static_cast<uint32_t>(millis_64() / 1000);
+  uint32_t days = uptime / 86400;
+  uptime -= days * 86400;
+  uint32_t hours = uptime / 3600;
+  uptime -= hours * 3600;
+  uint32_t minutes = uptime / 60;
+  uptime -= minutes * 60;
+  ESP_LOGD(TAG, "Uptime: %" PRIu32 "d %02" PRIu32 "h %02" PRIu32 "m %02" PRIu32 "s", days, hours, minutes, uptime);
+
   pos = get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>(device_info_buffer), pos);
 
 #ifdef USE_TEXT_SENSOR

From c50ee215f225ced93a3074b5b42cd18ea4855ac5 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sat, 17 Oct 2026 15:07:42 -1000
Subject: [PATCH 16/21] [tcp_uart] Expose the connection entities as platforms
 (#21009)

---
 esphome/components/tcp_uart/__init__.py       | 30 +++---------------
 esphome/components/tcp_uart/binary_sensor.py  | 25 +++++++++++++++
 esphome/components/tcp_uart/sensor.py         | 31 +++++++++++++++++++
 esphome/components/tcp_uart/tcp_uart.cpp      |  6 ++++
 esphome/components/tcp_uart/tcp_uart.h        |  7 +++++
 tests/components/tcp_uart/benchmark.yaml      |  5 +--
 tests/components/tcp_uart/common.yaml         |  8 +++++
 .../tcp_uart/test-client.esp32-idf.yaml       |  8 +++++
 .../integration/fixtures/tcp_uart_bridge.yaml |  4 +++
 9 files changed, 97 insertions(+), 27 deletions(-)
 create mode 100644 esphome/components/tcp_uart/binary_sensor.py
 create mode 100644 esphome/components/tcp_uart/sensor.py

diff --git a/esphome/components/tcp_uart/__init__.py b/esphome/components/tcp_uart/__init__.py
index 796a9fc48db..c05b9d17a32 100644
--- a/esphome/components/tcp_uart/__init__.py
+++ b/esphome/components/tcp_uart/__init__.py
@@ -1,8 +1,7 @@
 import esphome.codegen as cg
-from esphome.components import binary_sensor, sensor, socket, uart
+from esphome.components import socket, uart
 from esphome.components.const import (
     CONF_ALLOWED_IPS,
-    CONF_CONNECTED,
     CONF_DATA_BITS,
     CONF_HOST,
     CONF_PARITY,
@@ -11,22 +10,16 @@ from esphome.components.const import (
     CONF_STOP_BITS,
 )
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BAUD_RATE,
-    CONF_ID,
-    CONF_PORT,
-    DEVICE_CLASS_CONNECTIVITY,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-    STATE_CLASS_TOTAL_INCREASING,
-)
+from esphome.const import CONF_BAUD_RATE, CONF_ID, CONF_PORT
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@Bascht74"]
 DEPENDENCIES = ["network"]
-AUTO_LOAD = ["uart", "binary_sensor", "sensor", "socket"]
+AUTO_LOAD = ["uart", "socket"]
+DOMAIN = "tcp_uart"
 MULTI_CONF = True
 
-CONF_DISCONNECTS = "disconnects"
+CONF_TCP_UART_ID = "tcp_uart_id"
 
 tcp_uart_ns = cg.esphome_ns.namespace("tcp_uart")
 TcpUart = tcp_uart_ns.class_("TcpUart", uart.UARTComponent, cg.Component)
@@ -45,15 +38,6 @@ BASE_SCHEMA = cv.Schema(
         cv.Optional(
             CONF_RECONNECT_INTERVAL, default="5s"
         ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
-            device_class=DEVICE_CLASS_CONNECTIVITY,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-        cv.Optional(CONF_DISCONNECTS): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -99,7 +83,3 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_parity(config[CONF_PARITY]))
     if (host := config.get(CONF_HOST)) is not None:
         cg.add(var.set_host(host))
-    binary_sensors = binary_sensor.sub_binary_sensors(config)
-    await binary_sensors(CONF_CONNECTED, var.set_connected_sensor)
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_DISCONNECTS, var.set_disconnects_sensor)
diff --git a/esphome/components/tcp_uart/binary_sensor.py b/esphome/components/tcp_uart/binary_sensor.py
new file mode 100644
index 00000000000..8337973c837
--- /dev/null
+++ b/esphome/components/tcp_uart/binary_sensor.py
@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+from esphome.components import binary_sensor
+from esphome.components.const import CONF_CONNECTED
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, DEVICE_CLASS_CONNECTIVITY, ENTITY_CATEGORY_DIAGNOSTIC
+from esphome.types import ConfigType
+
+from . import CONF_TCP_UART_ID, TcpUart
+
+DEPENDENCIES = ["tcp_uart"]
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
+    cv.GenerateID(CONF_TCP_UART_ID): cv.use_id(TcpUart),
+    cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
+        device_class=DEVICE_CLASS_CONNECTIVITY,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+    ),
+}
+
+
+async def to_code(config: ConfigType) -> None:
+    hub = await cg.get_variable(config[CONF_TCP_UART_ID])
+    binary_sensors = binary_sensor.sub_binary_sensors(config)
+    await binary_sensors(CONF_CONNECTED, hub.set_connected_sensor)
diff --git a/esphome/components/tcp_uart/sensor.py b/esphome/components/tcp_uart/sensor.py
new file mode 100644
index 00000000000..099ca8734e1
--- /dev/null
+++ b/esphome/components/tcp_uart/sensor.py
@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_TOTAL_INCREASING,
+)
+from esphome.types import ConfigType
+
+from . import CONF_TCP_UART_ID, TcpUart
+
+DEPENDENCIES = ["tcp_uart"]
+
+CONF_DISCONNECTS = "disconnects"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
+    cv.GenerateID(CONF_TCP_UART_ID): cv.use_id(TcpUart),
+    cv.Optional(CONF_DISCONNECTS): sensor.sensor_schema(
+        accuracy_decimals=0,
+        state_class=STATE_CLASS_TOTAL_INCREASING,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+    ),
+}
+
+
+async def to_code(config: ConfigType) -> None:
+    hub = await cg.get_variable(config[CONF_TCP_UART_ID])
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_DISCONNECTS, hub.set_disconnects_sensor)
diff --git a/esphome/components/tcp_uart/tcp_uart.cpp b/esphome/components/tcp_uart/tcp_uart.cpp
index efc85804e99..139b31a2203 100644
--- a/esphome/components/tcp_uart/tcp_uart.cpp
+++ b/esphome/components/tcp_uart/tcp_uart.cpp
@@ -17,9 +17,11 @@ void TcpUart::setup() {
 #ifdef USE_SOCKET_TCP_LISTENER
   this->listener_.begin(TAG);
 #endif
+#ifdef USE_BINARY_SENSOR
   if (this->connected_sensor_ != nullptr) {
     this->connected_sensor_->publish_state(false);
   }
+#endif
 #ifdef USE_SENSOR
   if (this->disconnects_sensor_ != nullptr) {
     this->disconnects_sensor_->publish_state(0);
@@ -38,7 +40,9 @@ void TcpUart::dump_config() {
 #ifdef USE_SOCKET_TCP_LISTENER
   this->listener_.dump_config();
 #endif
+#ifdef USE_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Connected", this->connected_sensor_);
+#endif
 #ifdef USE_SENSOR
   LOG_SENSOR("  ", "Disconnects", this->disconnects_sensor_);
 #endif
@@ -58,9 +62,11 @@ void TcpUart::sync_link_() {
     // Unread bytes of the last session stay readable while down, never into the next one.
     this->rx_start_ = this->rx_end_ = 0;
   }
+#ifdef USE_BINARY_SENSOR
   if (this->connected_sensor_ != nullptr) {
     this->connected_sensor_->publish_state(up);
   }
+#endif
 #ifdef USE_SENSOR
   // Only edges get here, so down is the falling edge.
   if (!up && this->disconnects_sensor_ != nullptr) {
diff --git a/esphome/components/tcp_uart/tcp_uart.h b/esphome/components/tcp_uart/tcp_uart.h
index 1e1d48e4c20..6ecfd1a0862 100644
--- a/esphome/components/tcp_uart/tcp_uart.h
+++ b/esphome/components/tcp_uart/tcp_uart.h
@@ -1,6 +1,9 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+#ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
@@ -23,7 +26,9 @@ class TcpUart : public uart::UARTComponent, public Component {
   void set_host(const char *host) { this->link_.set_host(host); }
   void set_port(uint16_t port) { this->link_.set_port(port); }
   void set_reconnect_interval(uint32_t ms) { this->link_.set_reconnect_interval(ms); }
+#ifdef USE_BINARY_SENSOR
   void set_connected_sensor(binary_sensor::BinarySensor *sensor) { this->connected_sensor_ = sensor; }
+#endif
 #ifdef USE_SENSOR
   void set_disconnects_sensor(sensor::Sensor *sensor) { this->disconnects_sensor_ = sensor; }
 #endif
@@ -64,7 +69,9 @@ class TcpUart : public uart::UARTComponent, public Component {
 #ifdef USE_SOCKET_TCP_LISTENER
   socket::TcpListener listener_;
 #endif
+#ifdef USE_BINARY_SENSOR
   binary_sensor::BinarySensor *connected_sensor_{nullptr};
+#endif
 #ifdef USE_SENSOR
   sensor::Sensor *disconnects_sensor_{nullptr};
   uint32_t disconnects_{0};
diff --git a/tests/components/tcp_uart/benchmark.yaml b/tests/components/tcp_uart/benchmark.yaml
index 781dc15b681..ed771f20534 100644
--- a/tests/components/tcp_uart/benchmark.yaml
+++ b/tests/components/tcp_uart/benchmark.yaml
@@ -1,3 +1,4 @@
-# The disconnects counter is compiled only with USE_SENSOR; declaring the
-# sensor domain makes the C++ unit test build define it.
+# The connection entities are compiled only with USE_BINARY_SENSOR and
+# USE_SENSOR; declaring the domains makes the C++ unit test build define them.
+binary_sensor:
 sensor:
diff --git a/tests/components/tcp_uart/common.yaml b/tests/components/tcp_uart/common.yaml
index 97ac0247da3..97bcd24f6a7 100644
--- a/tests/components/tcp_uart/common.yaml
+++ b/tests/components/tcp_uart/common.yaml
@@ -10,8 +10,16 @@ tcp_uart:
     allowed_ips:
       - 192.0.2.20
       - 192.0.2.0/24
+
+binary_sensor:
+  - platform: tcp_uart
+    tcp_uart_id: tcp_uart_server
     connected:
       name: TCP UART Server Connected
+
+sensor:
+  - platform: tcp_uart
+    tcp_uart_id: tcp_uart_server
     disconnects:
       name: TCP UART Server Disconnects
 
diff --git a/tests/components/tcp_uart/test-client.esp32-idf.yaml b/tests/components/tcp_uart/test-client.esp32-idf.yaml
index 74bd26a98bc..921ce0cbc1a 100644
--- a/tests/components/tcp_uart/test-client.esp32-idf.yaml
+++ b/tests/components/tcp_uart/test-client.esp32-idf.yaml
@@ -7,7 +7,15 @@ tcp_uart:
     host: 192.0.2.10
     port: 502
     reconnect_interval: 10s
+
+binary_sensor:
+  - platform: tcp_uart
+    tcp_uart_id: tcp_uart_1
     connected:
       name: TCP UART Connected
+
+sensor:
+  - platform: tcp_uart
+    tcp_uart_id: tcp_uart_1
     disconnects:
       name: TCP UART Disconnects
diff --git a/tests/integration/fixtures/tcp_uart_bridge.yaml b/tests/integration/fixtures/tcp_uart_bridge.yaml
index 12791e7dd46..74a8710b19e 100644
--- a/tests/integration/fixtures/tcp_uart_bridge.yaml
+++ b/tests/integration/fixtures/tcp_uart_bridge.yaml
@@ -20,6 +20,10 @@ tcp_uart:
     host: 127.0.0.1
     port: 18125
     reconnect_interval: 3s
+
+binary_sensor:
+  - platform: tcp_uart
+    tcp_uart_id: tcp_uart_1
     connected:
       name: Bridge Connected
 

From 26064f141543d92697a575dbb5e10e7b69d77036 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sat, 17 Oct 2026 15:09:32 -1000
Subject: [PATCH 17/21] [uart_tcp] Expose the connection entities as platforms
 (#21008)

---
 esphome/components/uart_tcp/__init__.py       | 23 ++------------
 esphome/components/uart_tcp/binary_sensor.py  | 25 +++++++++++++++
 esphome/components/uart_tcp/sensor.py         | 31 +++++++++++++++++++
 esphome/components/uart_tcp/uart_tcp.cpp      |  6 ++++
 esphome/components/uart_tcp/uart_tcp.h        |  7 +++++
 tests/components/uart_tcp/benchmark.yaml      |  5 +--
 tests/components/uart_tcp/common.yaml         |  8 +++++
 .../uart_tcp/test-client.esp32-idf.yaml       |  8 +++++
 tests/components/uart_tcp/test.host.yaml      |  8 +++++
 .../integration/fixtures/uart_tcp_bridge.yaml |  8 +++--
 10 files changed, 105 insertions(+), 24 deletions(-)
 create mode 100644 esphome/components/uart_tcp/binary_sensor.py
 create mode 100644 esphome/components/uart_tcp/sensor.py

diff --git a/esphome/components/uart_tcp/__init__.py b/esphome/components/uart_tcp/__init__.py
index 6e7a6fef325..b5eafa9a448 100644
--- a/esphome/components/uart_tcp/__init__.py
+++ b/esphome/components/uart_tcp/__init__.py
@@ -1,8 +1,7 @@
 import esphome.codegen as cg
-from esphome.components import binary_sensor, sensor, socket, uart
+from esphome.components import socket, uart
 from esphome.components.const import (
     CONF_ALLOWED_IPS,
-    CONF_CONNECTED,
     CONF_HOST,
     CONF_RECONNECT_INTERVAL,
     CONF_ROLE,
@@ -14,9 +13,6 @@ from esphome.const import (
     CONF_ID,
     CONF_PORT,
     CONF_UART_ID,
-    DEVICE_CLASS_CONNECTIVITY,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-    STATE_CLASS_TOTAL_INCREASING,
 )
 from esphome.core import CORE
 import esphome.final_validate as fv
@@ -25,10 +21,10 @@ from esphome.types import ConfigType
 CODEOWNERS = ["@Bascht74"]
 DOMAIN = "uart_tcp"
 DEPENDENCIES = ["network", "uart"]
-AUTO_LOAD = ["binary_sensor", "sensor", "socket"]
+AUTO_LOAD = ["socket"]
 MULTI_CONF = True
 
-CONF_DISCONNECTS = "disconnects"
+CONF_UART_TCP_ID = "uart_tcp_id"
 
 uart_tcp_ns = cg.esphome_ns.namespace("uart_tcp")
 UartTcp = uart_tcp_ns.class_("UartTcp", cg.Component, uart.UARTDevice)
@@ -42,15 +38,6 @@ BASE_SCHEMA = cv.Schema(
         cv.Optional(
             CONF_RECONNECT_INTERVAL, default="5s"
         ): cv.positive_time_period_milliseconds,
-        cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
-            device_class=DEVICE_CLASS_CONNECTIVITY,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
-        cv.Optional(CONF_DISCONNECTS): sensor.sensor_schema(
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_TOTAL_INCREASING,
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -155,7 +142,3 @@ async def to_code(config: ConfigType) -> None:
     cg.add(var.set_reconnect_interval(config[CONF_RECONNECT_INTERVAL]))
     if (host := config.get(CONF_HOST)) is not None:
         cg.add(var.set_host(host))
-    binary_sensors = binary_sensor.sub_binary_sensors(config)
-    await binary_sensors(CONF_CONNECTED, var.set_connected_sensor)
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_DISCONNECTS, var.set_disconnects_sensor)
diff --git a/esphome/components/uart_tcp/binary_sensor.py b/esphome/components/uart_tcp/binary_sensor.py
new file mode 100644
index 00000000000..c8d19319337
--- /dev/null
+++ b/esphome/components/uart_tcp/binary_sensor.py
@@ -0,0 +1,25 @@
+import esphome.codegen as cg
+from esphome.components import binary_sensor
+from esphome.components.const import CONF_CONNECTED
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, DEVICE_CLASS_CONNECTIVITY, ENTITY_CATEGORY_DIAGNOSTIC
+from esphome.types import ConfigType
+
+from . import CONF_UART_TCP_ID, UartTcp
+
+DEPENDENCIES = ["uart_tcp"]
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
+    cv.GenerateID(CONF_UART_TCP_ID): cv.use_id(UartTcp),
+    cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
+        device_class=DEVICE_CLASS_CONNECTIVITY,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+    ),
+}
+
+
+async def to_code(config: ConfigType) -> None:
+    hub = await cg.get_variable(config[CONF_UART_TCP_ID])
+    binary_sensors = binary_sensor.sub_binary_sensors(config)
+    await binary_sensors(CONF_CONNECTED, hub.set_connected_sensor)
diff --git a/esphome/components/uart_tcp/sensor.py b/esphome/components/uart_tcp/sensor.py
new file mode 100644
index 00000000000..ad44b56ad09
--- /dev/null
+++ b/esphome/components/uart_tcp/sensor.py
@@ -0,0 +1,31 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_TOTAL_INCREASING,
+)
+from esphome.types import ConfigType
+
+from . import CONF_UART_TCP_ID, UartTcp
+
+DEPENDENCIES = ["uart_tcp"]
+
+CONF_DISCONNECTS = "disconnects"
+
+CONFIG_SCHEMA = {
+    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
+    cv.GenerateID(CONF_UART_TCP_ID): cv.use_id(UartTcp),
+    cv.Optional(CONF_DISCONNECTS): sensor.sensor_schema(
+        accuracy_decimals=0,
+        state_class=STATE_CLASS_TOTAL_INCREASING,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+    ),
+}
+
+
+async def to_code(config: ConfigType) -> None:
+    hub = await cg.get_variable(config[CONF_UART_TCP_ID])
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_DISCONNECTS, hub.set_disconnects_sensor)
diff --git a/esphome/components/uart_tcp/uart_tcp.cpp b/esphome/components/uart_tcp/uart_tcp.cpp
index 4f241f85671..dcdc8ce49d5 100644
--- a/esphome/components/uart_tcp/uart_tcp.cpp
+++ b/esphome/components/uart_tcp/uart_tcp.cpp
@@ -19,9 +19,11 @@ void UartTcp::setup() {
 #ifdef USE_SOCKET_TCP_LISTENER
   this->listener_.begin(TAG);
 #endif
+#ifdef USE_BINARY_SENSOR
   if (this->connected_sensor_ != nullptr) {
     this->connected_sensor_->publish_state(false);
   }
+#endif
 #ifdef USE_SENSOR
   if (this->disconnects_sensor_ != nullptr) {
     this->disconnects_sensor_->publish_state(0);
@@ -40,7 +42,9 @@ void UartTcp::dump_config() {
 #ifdef USE_SOCKET_TCP_LISTENER
   this->listener_.dump_config();
 #endif
+#ifdef USE_BINARY_SENSOR
   LOG_BINARY_SENSOR("  ", "Connected", this->connected_sensor_);
+#endif
 #ifdef USE_SENSOR
   LOG_SENSOR("  ", "Disconnects", this->disconnects_sensor_);
 #endif
@@ -60,9 +64,11 @@ void UartTcp::sync_link_() {
     // The driver kept whatever arrived while the link was down.
     this->discard_uart_();
   }
+#ifdef USE_BINARY_SENSOR
   if (this->connected_sensor_ != nullptr) {
     this->connected_sensor_->publish_state(up);
   }
+#endif
 #ifdef USE_SENSOR
   // Only edges get here, so down is the falling edge.
   if (!up && this->disconnects_sensor_ != nullptr) {
diff --git a/esphome/components/uart_tcp/uart_tcp.h b/esphome/components/uart_tcp/uart_tcp.h
index 256e059133a..6080cc95514 100644
--- a/esphome/components/uart_tcp/uart_tcp.h
+++ b/esphome/components/uart_tcp/uart_tcp.h
@@ -1,6 +1,9 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+#ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
+#endif
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
@@ -22,7 +25,9 @@ class UartTcp final : public Component, public uart::UARTDevice {
   void set_host(const char *host) { this->link_.set_host(host); }
   void set_port(uint16_t port) { this->link_.set_port(port); }
   void set_reconnect_interval(uint32_t ms) { this->link_.set_reconnect_interval(ms); }
+#ifdef USE_BINARY_SENSOR
   void set_connected_sensor(binary_sensor::BinarySensor *sensor) { this->connected_sensor_ = sensor; }
+#endif
 #ifdef USE_SENSOR
   void set_disconnects_sensor(sensor::Sensor *sensor) { this->disconnects_sensor_ = sensor; }
 #endif
@@ -53,7 +58,9 @@ class UartTcp final : public Component, public uart::UARTDevice {
 #ifdef USE_SOCKET_TCP_LISTENER
   socket::TcpListener listener_;
 #endif
+#ifdef USE_BINARY_SENSOR
   binary_sensor::BinarySensor *connected_sensor_{nullptr};
+#endif
   // Loop start time of the last socket-to-UART write; sizes the next paced write.
   uint32_t last_write_ms_{0};
 #ifdef USE_SENSOR
diff --git a/tests/components/uart_tcp/benchmark.yaml b/tests/components/uart_tcp/benchmark.yaml
index 781dc15b681..ed771f20534 100644
--- a/tests/components/uart_tcp/benchmark.yaml
+++ b/tests/components/uart_tcp/benchmark.yaml
@@ -1,3 +1,4 @@
-# The disconnects counter is compiled only with USE_SENSOR; declaring the
-# sensor domain makes the C++ unit test build define it.
+# The connection entities are compiled only with USE_BINARY_SENSOR and
+# USE_SENSOR; declaring the domains makes the C++ unit test build define them.
+binary_sensor:
 sensor:
diff --git a/tests/components/uart_tcp/common.yaml b/tests/components/uart_tcp/common.yaml
index fd34757d0ee..cf86dc9da89 100644
--- a/tests/components/uart_tcp/common.yaml
+++ b/tests/components/uart_tcp/common.yaml
@@ -10,7 +10,15 @@ uart_tcp:
     allowed_ips:
       - 192.168.1.10
       - 192.168.1.0/24
+
+binary_sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
     connected:
       name: UART TCP Connected
+
+sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
     disconnects:
       name: UART TCP Disconnects
diff --git a/tests/components/uart_tcp/test-client.esp32-idf.yaml b/tests/components/uart_tcp/test-client.esp32-idf.yaml
index 5ba900347c4..6bce693f854 100644
--- a/tests/components/uart_tcp/test-client.esp32-idf.yaml
+++ b/tests/components/uart_tcp/test-client.esp32-idf.yaml
@@ -12,7 +12,15 @@ uart_tcp:
     host: 192.0.2.20
     port: 502
     reconnect_interval: 10s
+
+binary_sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
     connected:
       name: UART TCP Connected
+
+sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
     disconnects:
       name: UART TCP Disconnects
diff --git a/tests/components/uart_tcp/test.host.yaml b/tests/components/uart_tcp/test.host.yaml
index a0b82c568df..b793ae144c3 100644
--- a/tests/components/uart_tcp/test.host.yaml
+++ b/tests/components/uart_tcp/test.host.yaml
@@ -8,7 +8,15 @@ uart_tcp:
     uart_id: uart_bus
     host: 127.0.0.1
     port: 44502
+
+binary_sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
     connected:
       name: UART TCP Connected
+
+sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
     disconnects:
       name: UART TCP Disconnects
diff --git a/tests/integration/fixtures/uart_tcp_bridge.yaml b/tests/integration/fixtures/uart_tcp_bridge.yaml
index 7ad28316f75..cf6c8fad64b 100644
--- a/tests/integration/fixtures/uart_tcp_bridge.yaml
+++ b/tests/integration/fixtures/uart_tcp_bridge.yaml
@@ -24,11 +24,15 @@ uart_tcp:
     port: 18126
     allowed_ips:
       - 127.0.0.1
-    connected:
-      name: Bridge Connected
   - id: denied_bridge
     uart_id: denied_bus
     role: server
     port: 18127
     allowed_ips:
       - 192.0.2.1
+
+binary_sensor:
+  - platform: uart_tcp
+    uart_tcp_id: bridge
+    connected:
+      name: Bridge Connected

From f979ddcf0de00b868f7c1556bd366820ccbb4608 Mon Sep 17 00:00:00 2001
From: "J. Nick Koston" <nick@koston.org>
Date: Sun, 18 Oct 2026 02:37:48 -1000
Subject: [PATCH 18/21] [bl0906] Read stale receive bytes instead of spinning
 on flush() (#21035)

---
 esphome/components/bl0906/bl0906.cpp          |  4 +-
 .../fixtures/uart_mock_bl0906_stray_rx.yaml   | 64 +++++++++++++++++++
 .../test_uart_mock_bl0906_stray_rx.py         | 57 +++++++++++++++++
 3 files changed, 123 insertions(+), 2 deletions(-)
 create mode 100644 tests/integration/fixtures/uart_mock_bl0906_stray_rx.yaml
 create mode 100644 tests/integration/test_uart_mock_bl0906_stray_rx.py

diff --git a/esphome/components/bl0906/bl0906.cpp b/esphome/components/bl0906/bl0906.cpp
index 9a27cffd043..4e9b1f9c5fd 100644
--- a/esphome/components/bl0906/bl0906.cpp
+++ b/esphome/components/bl0906/bl0906.cpp
@@ -20,7 +20,7 @@ constexpr uint8_t bl0906_checksum(const uint8_t address, const DataPacket *data)
 
 void BL0906::loop() {
   while (this->available())
-    this->flush();
+    this->read();
 
   if (this->current_stage_ == STAGE_IDLE) {
     // Woken up between cycles to drain the action queue. Go back to sleep.
@@ -92,7 +92,7 @@ void BL0906::advance_stage_() {
 
 void BL0906::setup() {
   while (this->available())
-    this->flush();
+    this->read();
   this->write_array(USR_WRPROT_WITABLE, sizeof(USR_WRPROT_WITABLE));
   // Calibration (1: register address; 2: value before calibration; 3: value after calibration)
   this->bias_correction_(BL0906_RMSOS_1, 0.01600, 0);  // Calibration current_1
diff --git a/tests/integration/fixtures/uart_mock_bl0906_stray_rx.yaml b/tests/integration/fixtures/uart_mock_bl0906_stray_rx.yaml
new file mode 100644
index 00000000000..d5f8a7837ce
--- /dev/null
+++ b/tests/integration/fixtures/uart_mock_bl0906_stray_rx.yaml
@@ -0,0 +1,64 @@
+esphome:
+  name: uart-mock-bl0906-stray-rx
+
+host:
+api:
+  batch_delay: 0ms # Disable batching to receive all state updates
+logger:
+  level: VERBOSE
+
+external_components:
+  - source:
+      type: local
+      path: EXTERNAL_COMPONENT_PATH
+
+# Dummy uart entry to satisfy DEPENDENCIES = ["uart"]
+uart:
+  baud_rate: 9600
+  port: /dev/null
+
+# Answers register reads; the first temperature answer has one stray trailing byte
+uart_mock:
+  id: mock_uart
+  baud_rate: 19200
+  on_tx:
+    - then:
+        - lambda: |-
+            // Command and register address arrive as separate one-byte writes
+            static bool read_pending = false;
+            static bool stray_sent = false;
+            if (data.size() != 1)
+              return;
+            if (!read_pending) {
+              read_pending = data[0] == 0x35;
+              return;
+            }
+            read_pending = false;
+            const uint8_t address = data[0];
+            uint32_t raw;
+            switch (address) {
+              case 0x5E:  // temperature: (300 - 64) * 12.5 / 59 - 40 = 10 C
+                raw = 300;
+                break;
+              case 0x16:  // voltage
+                raw = 0x2A1B3C;
+                break;
+              default:
+                return;
+            }
+            const uint8_t l = raw & 0xFF, m = (raw >> 8) & 0xFF, h = (raw >> 16) & 0xFF;
+            std::vector<uint8_t> reply{l, m, h, static_cast<uint8_t>((address + l + m + h) ^ 0xFF)};
+            if (address == 0x5E && !stray_sent) {
+              stray_sent = true;
+              reply.push_back(0xAA);
+            }
+            id(mock_uart).inject_to_rx_buffer(reply);
+
+sensor:
+  - platform: bl0906
+    uart_id: mock_uart
+    update_interval: 1s
+    temperature:
+      name: Temperature
+    voltage:
+      name: Voltage
diff --git a/tests/integration/test_uart_mock_bl0906_stray_rx.py b/tests/integration/test_uart_mock_bl0906_stray_rx.py
new file mode 100644
index 00000000000..5f8a635c7f5
--- /dev/null
+++ b/tests/integration/test_uart_mock_bl0906_stray_rx.py
@@ -0,0 +1,57 @@
+"""A BL0906 that leaves a stray byte in the receive buffer keeps reading."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from aioesphomeapi import EntityState, SensorInfo
+import pytest
+
+from .state_utils import require_entity
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_uart_mock_bl0906_stray_rx(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """A stray received byte does not stop the read cycle."""
+    external_components_path = str(
+        Path(__file__).parent / "fixtures" / "external_components"
+    )
+    yaml_config = yaml_config.replace(
+        "EXTERNAL_COMPONENT_PATH", external_components_path
+    )
+
+    lines: list[str] = []
+    states: dict[int, EntityState] = {}
+
+    async with (
+        run_compiled(yaml_config, line_callback=lines.append),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+        temperature = require_entity(entities, "temperature", SensorInfo)
+        voltage = require_entity(entities, "voltage", SensorInfo)
+
+        client.subscribe_states(lambda state: states.__setitem__(state.key, state))
+
+        def state_of(entity: SensorInfo) -> float | None:
+            state = states.get(entity.key)
+            return None if state is None or state.missing_state else state.state
+
+        try:
+            async with asyncio.timeout(10.0):
+                while state_of(voltage) is None:
+                    await asyncio.sleep(0.05)
+        except TimeoutError:
+            pytest.fail(f"No voltage reading; log: {lines[-20:]}")
+
+        assert any("RX inject 5 bytes" in x for x in lines), "stray byte not sent"
+        assert state_of(temperature) == pytest.approx(10.0, abs=0.01)
+        uref = 1.097 * 100000 / (13162 * 100 * 1000)
+        assert state_of(voltage) == pytest.approx(0x2A1B3C * uref, rel=1e-5)
+        assert not any("Junk on wire" in x for x in lines)

From ffa20abe96664634bea6cdf192450767120406df Mon Sep 17 00:00:00 2001
From: Bonne Eggleston <bonne@exciton.com.au>
Date: Sun, 18 Oct 2026 14:36:35 -0500
Subject: [PATCH 19/21] [api] Poll the outgoing dial every loop on deep sleep
 builds (#21077)

---
 esphome/components/api/api_outgoing_connection.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/esphome/components/api/api_outgoing_connection.h b/esphome/components/api/api_outgoing_connection.h
index 16d50c34255..fff11522d79 100644
--- a/esphome/components/api/api_outgoing_connection.h
+++ b/esphome/components/api/api_outgoing_connection.h
@@ -59,17 +59,20 @@ class OutgoingConnectionManager {
   static constexpr uint32_t BACKOFF_MIN_MS = 5000;
   static constexpr uint32_t BACKOFF_MAX_MS = 300000;
   static constexpr uint32_t CONNECT_TIMEOUT_MS = 10000;
-  static constexpr uint32_t CONNECT_POLL_INTERVAL_MS = 250;
-  static constexpr uint32_t NETWORK_RETRY_MS = 500;
   static constexpr uint32_t PRECONDITION_RETRY_MS = 5000;
   // A deep sleep wake window is too short to spend on the delay, so those
-  // builds dial out as soon as the target is gone
+  // builds dial out as soon as the target is gone, recheck the network on
+  // every loop and notice the connect completing on the loop it does
 #ifdef USE_DEEP_SLEEP
   static constexpr uint32_t BOOT_WAIT_MS = 0;
   static constexpr uint32_t IDLE_WAIT_MS = BACKOFF_MIN_MS;
+  static constexpr uint32_t CONNECT_POLL_INTERVAL_MS = 0;
+  static constexpr uint32_t NETWORK_RETRY_MS = 0;
 #else
   static constexpr uint32_t BOOT_WAIT_MS = API_OUTGOING_CONNECTION_DELAY;
   static constexpr uint32_t IDLE_WAIT_MS = API_OUTGOING_CONNECTION_DELAY;
+  static constexpr uint32_t CONNECT_POLL_INTERVAL_MS = 250;
+  static constexpr uint32_t NETWORK_RETRY_MS = 500;
 #endif
 
   void try_dial_(APIServer *server, uint32_t now);

From 649f2c91f566cf75fe2ecc6e4466f669fe24bf32 Mon Sep 17 00:00:00 2001
From: Bonne Eggleston <bonne@exciton.com.au>
Date: Sun, 18 Oct 2026 15:47:02 -0500
Subject: [PATCH 20/21] [api] Poll the outgoing dial every loop (#21085)

Co-authored-by: J. Nick Koston <nick@koston.org>
---
 esphome/components/api/api_outgoing_connection.cpp | 10 +---------
 esphome/components/api/api_outgoing_connection.h   |  8 +-------
 2 files changed, 2 insertions(+), 16 deletions(-)

diff --git a/esphome/components/api/api_outgoing_connection.cpp b/esphome/components/api/api_outgoing_connection.cpp
index c86107cef0b..0b2b1d52dbe 100644
--- a/esphome/components/api/api_outgoing_connection.cpp
+++ b/esphome/components/api/api_outgoing_connection.cpp
@@ -152,10 +152,7 @@ void OutgoingConnectionManager::loop(APIServer *server) {
 
 void OutgoingConnectionManager::try_dial_(APIServer *server, uint32_t now) {
   if (!network::is_connected()) {
-    // Flips within seconds of boot; recheck fast so a deep sleep wake
-    // window is not spent waiting
-    this->schedule_wait_(now, NETWORK_RETRY_MS);
-    return;
+    return;  // still WAITING with the wait elapsed, so the next loop rechecks
   }
   struct sockaddr_storage addr;
   socklen_t addr_len = this->target_sockaddr_(&addr);
@@ -197,7 +194,6 @@ void OutgoingConnectionManager::try_dial_(APIServer *server, uint32_t now) {
   }
   this->state_ = DialState::DIAL_STATE_CONNECTING;
   this->state_ts_ = now;
-  this->last_poll_ = now;
 }
 
 void OutgoingConnectionManager::poll_connect_(APIServer *server, uint32_t now) {
@@ -206,10 +202,6 @@ void OutgoingConnectionManager::poll_connect_(APIServer *server, uint32_t now) {
     this->schedule_retry_(now);
     return;
   }
-  if (now - this->last_poll_ < CONNECT_POLL_INTERVAL_MS) {
-    return;
-  }
-  this->last_poll_ = now;
   int err = 0;
   switch (socket::poll_connect(*this->dial_socket_, err)) {
     case socket::ConnectPollResult::CONNECT_POLL_RESULT_PENDING:
diff --git a/esphome/components/api/api_outgoing_connection.h b/esphome/components/api/api_outgoing_connection.h
index fff11522d79..fa222e29ccf 100644
--- a/esphome/components/api/api_outgoing_connection.h
+++ b/esphome/components/api/api_outgoing_connection.h
@@ -61,18 +61,13 @@ class OutgoingConnectionManager {
   static constexpr uint32_t CONNECT_TIMEOUT_MS = 10000;
   static constexpr uint32_t PRECONDITION_RETRY_MS = 5000;
   // A deep sleep wake window is too short to spend on the delay, so those
-  // builds dial out as soon as the target is gone, recheck the network on
-  // every loop and notice the connect completing on the loop it does
+  // builds dial out as soon as the target is gone
 #ifdef USE_DEEP_SLEEP
   static constexpr uint32_t BOOT_WAIT_MS = 0;
   static constexpr uint32_t IDLE_WAIT_MS = BACKOFF_MIN_MS;
-  static constexpr uint32_t CONNECT_POLL_INTERVAL_MS = 0;
-  static constexpr uint32_t NETWORK_RETRY_MS = 0;
 #else
   static constexpr uint32_t BOOT_WAIT_MS = API_OUTGOING_CONNECTION_DELAY;
   static constexpr uint32_t IDLE_WAIT_MS = API_OUTGOING_CONNECTION_DELAY;
-  static constexpr uint32_t CONNECT_POLL_INTERVAL_MS = 250;
-  static constexpr uint32_t NETWORK_RETRY_MS = 500;
 #endif
 
   void try_dial_(APIServer *server, uint32_t now);
@@ -107,7 +102,6 @@ class OutgoingConnectionManager {
   uint32_t backoff_{BACKOFF_MIN_MS};
   uint32_t wait_{BOOT_WAIT_MS};
   uint32_t state_ts_{0};
-  uint32_t last_poll_{0};
 
   // Byte-aligned types last
 #ifndef API_OUTGOING_CONNECTION_HOST

From a6a4b49e752817d0615b2db4231f8b73efeb00b3 Mon Sep 17 00:00:00 2001
From: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Date: Mon, 19 Oct 2026 11:29:05 +1300
Subject: [PATCH 21/21] Bump version to 2026.10.0b5

---
 Doxyfile         | 2 +-
 esphome/const.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Doxyfile b/Doxyfile
index 614b9a6fc05..5261997847d 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -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.10.0b4
+PROJECT_NUMBER         = 2026.10.0b5
 
 # 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
diff --git a/esphome/const.py b/esphome/const.py
index 3888f8f95d3..785a4de64a3 100644
--- a/esphome/const.py
+++ b/esphome/const.py
@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.10.0b4"
+__version__ = "2026.10.0b5"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (