Merge remote-tracking branch 'puddly/20260218-zigbee-proxy' into 20260218-zigbee-proxy

Merge branch 'dev' into 20260218-zigbee-proxy
[serial_proxy] Implement a no-op hardware flow control
2026-09-11 07:17:33 +00:00 · 2026-09-10 18:48:02 -05:00 · 2026-09-10 22:57:49 +00:00 · 2026-09-10 20:32:31 +00:00 · 2026-09-10 18:54:51 +00:00 · 2026-09-10 18:48:05 +00:00
108 changed files with 2485 additions and 549 deletions
@@ -76,6 +76,7 @@ service APIConnection {
  rpc serial_proxy_write(SerialProxyWriteRequest) returns (void) {}
  rpc serial_proxy_set_modem_pins(SerialProxySetModemPinsRequest) returns (void) {}
  rpc serial_proxy_get_modem_pins(SerialProxyGetModemPinsRequest) returns (void) {}
+  rpc serial_proxy_get_usb_info(SerialProxyGetUsbInfoRequest) returns (void) {}
  rpc serial_proxy_request(SerialProxyRequest) returns (void) {}
  rpc serial_proxy_set_mode(SerialProxySetModeRequest) returns (void) {}
 }
@@ -228,6 +229,11 @@ enum SerialProxyPortType {
  SERIAL_PROXY_PORT_TYPE_TTL = 0;
  SERIAL_PROXY_PORT_TYPE_RS232 = 1;
  SERIAL_PROXY_PORT_TYPE_RS485 = 2;
+  // A serial device attached through a USB bridge. Set by the device configuration, never
+  // by the user; identifies ports whose USB identity can be read with
+  // SerialProxyGetUsbInfoRequest. Deliberately not a USB endpoint type: serial_proxy
+  // carries serial devices only, whatever bridge chip connects them.
+  SERIAL_PROXY_PORT_TYPE_USB_SERIAL = 3;
 }

 message SerialProxyInfo {
@@ -2867,6 +2873,44 @@ message SerialProxySetModeRequest {
  SerialProxyMode mode = 2;
 }

+// Ask for the USB identity of the device behind a USB_SERIAL port. Read-only, so no
+// subscription is required -- a client typically uses this to decide which port to
+// subscribe to. Answered with NOT_SUPPORTED on ports that are not USB_SERIAL.
+message SerialProxyGetUsbInfoRequest {
+  option (id) = 153;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;
+}
+
+// The USB identity of the device currently behind a port, read live from the cached
+// USB descriptors. Fields are zero/empty while no device is connected.
+//
+// Sent in reply to SerialProxyGetUsbInfoRequest, and also unsolicited to every connected
+// client whenever a USB device is attached to or removed from a USB_SERIAL port. A client
+// therefore subscribes to this message before querying the current state, so the
+// connect-time query and later hotplug events are handled by one path. The port's
+// subscription is untouched by a hotplug: the session belongs to the client, which decides
+// whether to keep it.
+message SerialProxyUsbInfo {
+  option (id) = 154;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;
+  SerialProxyStatus status = 2;   // NOT_SUPPORTED when the port is not USB_SERIAL
+  bool connected = 3;             // True when a USB device is currently attached
+  uint32 vendor_id = 4;
+  uint32 product_id = 5;
+  uint32 bcd_device = 6;
+  uint32 interface_number = 7;    // bInterfaceNumber a host driver binds to, as Linux reports it
+  string manufacturer = 8;
+  string product = 9;
+  string serial_number = 10;
+  string interface_description = 11;  // iInterface string of that interface; empty when the device has none
+}
+
 // ==================== BLUETOOTH CONNECTION PARAMS ====================
 message BluetoothSetConnectionParamsRequest {
  option (id) = 145;
@@ -48,6 +48,9 @@
 #ifdef USE_ZWAVE_PROXY
 #include "esphome/components/zwave_proxy/zwave_proxy.h"
 #endif
+#ifdef USE_SERIAL_PROXY_USB_INFO
+#include "esphome/components/usb_host/usb_host.h"
+#endif
 #ifdef USE_WATER_HEATER
 #include "esphome/components/water_heater/water_heater.h"
 #endif
@@ -1642,6 +1645,27 @@ void APIConnection::on_serial_proxy_get_modem_pins_request(const SerialProxyGetM
  }
 }

+void APIConnection::on_serial_proxy_get_usb_info_request(const SerialProxyGetUsbInfoRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  SerialProxyUsbInfo resp{};
+  resp.instance = msg.instance;
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %" PRIu32 " out of range", msg.instance);
+    resp.status = enums::SERIAL_PROXY_STATUS_INVALID_ARGUMENT;
+  } else {
+#ifdef USE_SERIAL_PROXY_USB_INFO
+    // The message's strings are views into this buffer, which outlives the send below
+    usb_host::UsbDeviceInfo info;
+    proxies[msg.instance]->get_usb_info(info, resp);
+#else
+    resp.status = enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED;
+#endif
+  }
+  if (!this->send_message(resp)) {
+    API_LOG_MSG_DROPPED(TAG, "Serial proxy response");
+  }
+}
+
 void APIConnection::on_serial_proxy_request(const SerialProxyRequest &msg) {
  auto &proxies = App.get_serial_proxies();
  if (msg.instance >= proxies.size()) {
@@ -243,6 +243,7 @@ class APIConnection final : public APIServerConnectionBase {
  void on_serial_proxy_write_request(const SerialProxyWriteRequest &msg);
  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg);
  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg);
+  void on_serial_proxy_get_usb_info_request(const SerialProxyGetUsbInfoRequest &msg);
  void on_serial_proxy_request(const SerialProxyRequest &msg);
  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &msg);
  void send_serial_proxy_data(const SerialProxyDataReceived &msg);
@@ -4266,6 +4266,46 @@ bool SerialProxySetModeRequest::decode_varint(uint32_t field_id, proto_varint_va
  }
  return true;
 }
+bool SerialProxyGetUsbInfoRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value;
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+uint8_t *SerialProxyUsbInfo::encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
+  uint8_t *__restrict__ pos = buffer.get_pos();
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 1, this->instance);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(this->status));
+  ProtoEncode::encode_bool(pos PROTO_ENCODE_DEBUG_ARG, 3, this->connected);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, this->vendor_id);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 5, this->product_id);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 6, this->bcd_device);
+  ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 7, this->interface_number);
+  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 8, this->manufacturer);
+  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 9, this->product);
+  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 10, this->serial_number);
+  ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 11, this->interface_description);
+  return pos;
+}
+uint32_t SerialProxyUsbInfo::calculate_size() const {
+  uint32_t size = 0;
+  size += ProtoSize::calc_uint32(1, this->instance);
+  size += this->status ? 2 : 0;
+  size += ProtoSize::calc_bool(1, this->connected);
+  size += ProtoSize::calc_uint32(1, this->vendor_id);
+  size += ProtoSize::calc_uint32(1, this->product_id);
+  size += ProtoSize::calc_uint32(1, this->bcd_device);
+  size += ProtoSize::calc_uint32(1, this->interface_number);
+  size += ProtoSize::calc_length(1, this->manufacturer.size());
+  size += ProtoSize::calc_length(1, this->product.size());
+  size += ProtoSize::calc_length(1, this->serial_number.size());
+  size += ProtoSize::calc_length(1, this->interface_description.size());
+  return size;
+}
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 bool BluetoothSetConnectionParamsRequest::decode_varint(uint32_t field_id, proto_varint_value_t value) {
@@ -23,6 +23,7 @@ enum SerialProxyPortType : uint32_t {
  SERIAL_PROXY_PORT_TYPE_TTL = 0,
  SERIAL_PROXY_PORT_TYPE_RS232 = 1,
  SERIAL_PROXY_PORT_TYPE_RS485 = 2,
+  SERIAL_PROXY_PORT_TYPE_USB_SERIAL = 3,
 };
 enum EntityCategory : uint32_t {
  ENTITY_CATEGORY_NONE = 0,
@@ -3424,6 +3425,47 @@ class SerialProxySetModeRequest final : public ProtoDecodableMessage {
 protected:
  bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;
 };
+class SerialProxyGetUsbInfoRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint16_t MESSAGE_TYPE = 153;
+  static constexpr uint8_t ESTIMATED_SIZE = 4;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_get_usb_info_request"); }
+#endif
+  uint32_t instance{0};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, proto_varint_value_t value) override;
+};
+class SerialProxyUsbInfo final : public ProtoMessage {
+ public:
+  static constexpr uint16_t MESSAGE_TYPE = 154;
+  static constexpr uint8_t ESTIMATED_SIZE = 60;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const LogString *message_name() const override { return LOG_STR("serial_proxy_usb_info"); }
+#endif
+  uint32_t instance{0};
+  enums::SerialProxyStatus status{};
+  bool connected{false};
+  uint32_t vendor_id{0};
+  uint32_t product_id{0};
+  uint32_t bcd_device{0};
+  uint32_t interface_number{0};
+  StringRef manufacturer{};
+  StringRef product{};
+  StringRef serial_number{};
+  StringRef interface_description{};
+  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const;
+  uint32_t calculate_size() const;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 class BluetoothSetConnectionParamsRequest final : public ProtoDecodableMessage {
@@ -143,6 +143,8 @@ template<> const char *proto_enum_to_string<enums::SerialProxyPortType>(enums::S
      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_RS232");
    case enums::SERIAL_PROXY_PORT_TYPE_RS485:
      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_RS485");
+    case enums::SERIAL_PROXY_PORT_TYPE_USB_SERIAL:
+      return ESPHOME_PSTR("SERIAL_PROXY_PORT_TYPE_USB_SERIAL");
    default:
      return ESPHOME_PSTR("UNKNOWN");
  }
@@ -2823,6 +2825,26 @@ const char *SerialProxySetModeRequest::dump_to(DumpBuffer &out) const {
  dump_field(out, ESPHOME_PSTR("mode"), static_cast<enums::SerialProxyMode>(this->mode));
  return out.c_str();
 }
+const char *SerialProxyGetUsbInfoRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyGetUsbInfoRequest"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  return out.c_str();
+}
+const char *SerialProxyUsbInfo::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, ESPHOME_PSTR("SerialProxyUsbInfo"));
+  dump_field(out, ESPHOME_PSTR("instance"), this->instance);
+  dump_field(out, ESPHOME_PSTR("status"), static_cast<enums::SerialProxyStatus>(this->status));
+  dump_field(out, ESPHOME_PSTR("connected"), this->connected);
+  dump_field(out, ESPHOME_PSTR("vendor_id"), this->vendor_id);
+  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("manufacturer"), this->manufacturer);
+  dump_field(out, ESPHOME_PSTR("product"), this->product);
+  dump_field(out, ESPHOME_PSTR("serial_number"), this->serial_number);
+  dump_field(out, ESPHOME_PSTR("interface_description"), this->interface_description);
+  return out.c_str();
+}
 #endif
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
 const char *BluetoothSetConnectionParamsRequest::dump_to(DumpBuffer &out) const {
@@ -722,6 +722,17 @@ void APIConnection::read_message_(uint32_t msg_size, uint32_t msg_type, const ui
      this->on_serial_proxy_set_mode_request(msg);
      break;
    }
+#endif
+#ifdef USE_SERIAL_PROXY
+    case SerialProxyGetUsbInfoRequest::MESSAGE_TYPE: {
+      SerialProxyGetUsbInfoRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_get_usb_info_request"), msg);
+#endif
+      this->on_serial_proxy_get_usb_info_request(msg);
+      break;
+    }
 #endif
    default:
      break;
@@ -238,6 +238,10 @@ class APIServerConnectionBase {
 #ifdef USE_SERIAL_PROXY
  void on_serial_proxy_set_mode_request(const SerialProxySetModeRequest &value){};
 #endif
+#ifdef USE_SERIAL_PROXY
+  void on_serial_proxy_get_usb_info_request(const SerialProxyGetUsbInfoRequest &value){};
+#endif
+
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
  void on_bluetooth_set_connection_params_request(const BluetoothSetConnectionParamsRequest &value){};
 #endif
@@ -404,6 +404,18 @@ void APIServer::on_zwave_proxy_request(const ZWaveProxyRequest &msg) {
 }
 #endif

+#ifdef USE_SERIAL_PROXY_USB_INFO
+void APIServer::send_serial_proxy_usb_info(const SerialProxyUsbInfo &msg) {
+  // Unsolicited: a hotplug is rare and the message small, so every client hears of it
+  // rather than maintaining a subscription for the one client there normally is
+  for (auto &c : this->active_clients()) {
+    if (!c->send_message(msg)) {
+      API_LOG_MSG_DROPPED(TAG, "USB info notification");
+    }
+  }
+}
+#endif
+
 #if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
 void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_id, uint32_t key,
                                               const std::vector<int32_t> *timings) {
@@ -194,6 +194,10 @@ class APIServer final : public Component,
 #ifdef USE_ZWAVE_PROXY
  void on_zwave_proxy_request(const ZWaveProxyRequest &msg);
 #endif
+#ifdef USE_SERIAL_PROXY_USB_INFO
+  /// Tell every client that the USB device behind a serial proxy port changed
+  void send_serial_proxy_usb_info(const SerialProxyUsbInfo &msg);
+#endif
 #if defined(USE_IR_RF) || defined(USE_RADIO_FREQUENCY)
  void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
 #endif
@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import climate_ir, remote_base
+from esphome.components import climate_ir
 from esphome.types import ConfigType

 AUTO_LOAD = ["climate_ir"]
@@ -12,5 +12,4 @@ CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(CoolixClimate)


 async def to_code(config: ConfigType) -> None:
-    remote_base.request_protocol("coolix")  # used from C++
    await climate_ir.new_climate_ir(config)
@@ -59,6 +59,11 @@ void Infrared::setup() {
  // Set up traits based on configuration
  this->traits_.set_supports_transmitter(this->has_transmitter());
  this->traits_.set_supports_receiver(this->has_receiver());
+
+  // Register as listener for received IR data
+  if (this->receiver_ != nullptr) {
+    this->receiver_->register_listener(this);
+  }
 }

 void Infrared::dump_config() {
@@ -1,9 +1,6 @@
 """IR/RF Proxy component - provides remote_base backend for infrared platform."""

 import esphome.codegen as cg
-from esphome.components import remote_base
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType

 CODEOWNERS = ["@kbx81"]

@@ -12,10 +9,3 @@ ir_rf_proxy_ns = cg.esphome_ns.namespace("ir_rf_proxy")

 CONF_REMOTE_RECEIVER_ID = "remote_receiver_id"
 CONF_REMOTE_TRANSMITTER_ID = "remote_transmitter_id"
-
-
-async def attach_receiver(var: MockObj, config: ConfigType) -> None:
-    """Wire the configured remote_receiver to a proxy entity and register it as a listener."""
-    receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
-    cg.add(var.set_receiver(receiver))
-    remote_base.add_listener(receiver, var)
@@ -9,12 +9,7 @@ import esphome.config_validation as cv
 from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_FREQUENCY
 import esphome.final_validate as fv

-from . import (
-    CONF_REMOTE_RECEIVER_ID,
-    CONF_REMOTE_TRANSMITTER_ID,
-    attach_receiver,
-    ir_rf_proxy_ns,
-)
+from . import CONF_REMOTE_RECEIVER_ID, CONF_REMOTE_TRANSMITTER_ID, ir_rf_proxy_ns

 CODEOWNERS = ["@kbx81"]
 DEPENDENCIES = ["infrared"]
@@ -87,7 +82,8 @@ async def to_code(config: dict[str, Any]) -> None:

    # Link receiver if specified
    if CONF_REMOTE_RECEIVER_ID in config:
-        await attach_receiver(var, config)
+        receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
+        cg.add(var.set_receiver(receiver))

    # Set receiver demodulation frequency if specified (metadata only, no hardware effect)
    if CONF_RECEIVER_FREQUENCY in config:
@@ -97,6 +97,10 @@ void RfProxy::setup() {

  // remote_transmitter/receiver always uses OOK (on-off keying)
  this->traits_.add_supported_modulation(radio_frequency::RadioFrequencyModulation::RADIO_FREQUENCY_MODULATION_OOK);
+
+  if (this->receiver_ != nullptr) {
+    this->receiver_->register_listener(this);
+  }
 }

 void RfProxy::dump_config() {
@@ -7,12 +7,7 @@ from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_FREQUENCY
 import esphome.final_validate as fv
 from esphome.types import ConfigType

-from . import (
-    CONF_REMOTE_RECEIVER_ID,
-    CONF_REMOTE_TRANSMITTER_ID,
-    attach_receiver,
-    ir_rf_proxy_ns,
-)
+from . import CONF_REMOTE_RECEIVER_ID, CONF_REMOTE_TRANSMITTER_ID, ir_rf_proxy_ns

 CODEOWNERS = ["@kbx81"]
 DEPENDENCIES = ["radio_frequency"]
@@ -71,4 +66,5 @@ async def to_code(config: ConfigType) -> None:
        cg.add(var.set_transmitter(transmitter))

    if CONF_REMOTE_RECEIVER_ID in config:
-        await attach_receiver(var, config)
+        receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
+        cg.add(var.set_receiver(receiver))
@@ -1,6 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components import climate, remote_base, remote_transmitter, sensor, uart
+from esphome.components import climate, remote_transmitter, sensor, uart
 from esphome.components.climate import ClimateMode, ClimatePreset, ClimateSwingMode
 from esphome.components.remote_base import CONF_TRANSMITTER_ID
 import esphome.config_validation as cv
@@ -280,7 +280,6 @@ async def to_code(config):
    cg.add(var.set_response_timeout(config[CONF_TIMEOUT].total_milliseconds))
    cg.add(var.set_request_attempts(config[CONF_NUM_ATTEMPTS]))
    if CONF_TRANSMITTER_ID in config:
-        remote_base.request_protocol("midea")  # ir_transmitter.h uses it from C++
        cg.add_define("USE_REMOTE_TRANSMITTER")
        transmitter_ = await cg.get_variable(config[CONF_TRANSMITTER_ID])
        cg.add(var.set_transmitter(transmitter_))
@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import climate_ir, remote_base
+from esphome.components import climate_ir
 import esphome.config_validation as cv
 from esphome.const import CONF_USE_FAHRENHEIT
 from esphome.types import ConfigType
@@ -19,9 +19,5 @@ CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(MideaIR).extend(


 async def to_code(config: ConfigType) -> None:
-    # midea_ir uses MideaProtocol from C++ and auto-loads coolix, whose coolix.cpp uses
-    # CoolixProtocol even when no coolix climate is configured
-    remote_base.request_protocol("midea")
-    remote_base.request_protocol("coolix")
    var = await climate_ir.new_climate_ir(config)
    cg.add(var.set_fahrenheit(config[CONF_USE_FAHRENHEIT]))
@@ -1,11 +1,6 @@
-from collections.abc import Callable
-from pathlib import Path
-from typing import Any
-
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import binary_sensor
-from esphome.config_helpers import filter_source_files_from_defines
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ADDRESS,
@@ -45,9 +40,7 @@ from esphome.const import (
    CONF_ZERO,
 )
 from esphome.core import ID, coroutine
-from esphome.cpp_generator import MockObj
 from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
-from esphome.types import ConfigType
 from esphome.util import Registry, SimpleRegistry

 AUTO_LOAD = ["binary_sensor"]
@@ -97,25 +90,9 @@ REMOTE_TRANSMITTABLE_SCHEMA = cv.Schema(
 )


-# Listener and dumper lists are StaticVectors sized from these counts, so every
-# registration must go through add_listener / add_dumper
-_request_listener_slot = cg.slot_counter("REMOTE_BASE_LISTENER_COUNT")
-_request_dumper_slot = cg.slot_counter("REMOTE_BASE_DUMPER_COUNT")
-
-
-def add_listener(receiver: MockObj, listener: MockObj) -> None:
-    _request_listener_slot()
-    cg.add(receiver.register_listener(listener))
-
-
-def add_dumper(receiver: MockObj, dumper: MockObj) -> None:
-    _request_dumper_slot()
-    cg.add(receiver.register_dumper(dumper))
-
-
-async def register_listener(var: MockObj, config: ConfigType) -> None:
+async def register_listener(var, config):
    receiver = await cg.get_variable(config[CONF_RECEIVER_ID])
-    add_listener(receiver, var)
+    cg.add(receiver.register_listener(var))


 async def register_transmittable(var, config):
@@ -123,47 +100,8 @@ async def register_transmittable(var, config):
    cg.add(var.set_transmitter(transmitter_))


-# Registry names that share a protocol source file
-def _protocol_stem(name: str) -> str:
-    if name.startswith("rc_switch"):
-        return "rc_switch"
-    if name == "canalsatld":
-        return "canalsat"
-    return name
-
-
-def protocol_define(name: str) -> str:
-    return f"USE_REMOTE_PROTOCOL_{_protocol_stem(name).upper()}"
-
-
-def request_protocol(name: str) -> None:
-    """Keep a protocol's source file in the build; components using it from C++ must call this."""
-    cg.add_define(protocol_define(name))
-
-
-_PROTOCOL_STEMS = sorted(
-    path.name.removesuffix("_protocol.cpp")
-    for path in Path(__file__).parent.glob("*_protocol.cpp")
-)
-# Only the protocol sources a configuration uses are compiled
-FILTER_SOURCE_FILES = filter_source_files_from_defines(
-    {f"{stem}_protocol.cpp": protocol_define(stem) for stem in _PROTOCOL_STEMS}
-)
-
-
-def register_binary_sensor(
-    name: str, type: MockObj, schema: cv.Schema | dict
-) -> Callable[[Callable[[MockObj, ConfigType], Any]], Callable]:
-    registerer = BINARY_SENSOR_REGISTRY.register(name, type, schema)
-
-    def decorator(func: Callable[[MockObj, ConfigType], Any]) -> Callable:
-        async def new_func(var: MockObj, config: ConfigType) -> None:
-            request_protocol(name)
-            await coroutine(func)(var, config)
-
-        return registerer(new_func)
-
-    return decorator
+def register_binary_sensor(name, type, schema):
+    return BINARY_SENSOR_REGISTRY.register(name, type, schema)


 def register_trigger(name, type, data_type):
@@ -176,7 +114,6 @@ def register_trigger(name, type, data_type):

    def decorator(func):
        async def new_func(config):
-            request_protocol(name)
            var = cg.new_Pvariable(config[CONF_TRIGGER_ID])
            await coroutine(func)(var, config)
            await automation.build_automation(var, [(data_type, "x")], config)
@@ -194,7 +131,6 @@ def register_dumper(name, type, schema=None):

    def decorator(func):
        async def new_func(config, dumper_id):
-            request_protocol(name)
            var = cg.new_Pvariable(dumper_id)
            await coroutine(func)(var, config)
            return var
@@ -235,7 +171,6 @@ def register_action(name, type_, schema):

    def decorator(func):
        async def new_func(config, action_id, template_arg, args):
-            request_protocol(name)
            var = cg.new_Pvariable(action_id, template_arg)
            await register_transmittable(var, config)
            if CONF_REPEAT in config:
@@ -275,21 +210,9 @@ TRIGGER_REGISTRY = SimpleRegistry()
 DUMPER_REGISTRY = Registry()


-def _dumper_key(item: Any) -> Any:
-    """Registry key of a dump entry in either its string or its mapping form."""
-    if isinstance(item, dict) and len(item) == 1:
-        return next(iter(item))
-    return item
-
-
 def validate_dumpers(value):
    if isinstance(value, str) and value.lower() == "all":
        return validate_dumpers(list(DUMPER_REGISTRY.keys()))
-    if isinstance(value, list):
-        # a dumper listed twice would register twice; the receiver holds one secondary dumper
-        keys = [_dumper_key(item) for item in value]
-        if all(isinstance(key, str) for key in keys):
-            value = list(dict(zip(keys, value, strict=True)).values())
    return cv.validate_registry("dumper", DUMPER_REGISTRY)(value)


@@ -191,9 +191,9 @@ class ABBWelcomeData {

 class ABBWelcomeProtocol : public RemoteProtocol<ABBWelcomeData> {
 public:
-  void encode(RemoteTransmitData *dst, const ABBWelcomeData &src);
-  optional<ABBWelcomeData> decode(RemoteReceiveData src);
-  void dump(const ABBWelcomeData &data);
+  void encode(RemoteTransmitData *dst, const ABBWelcomeData &src) override;
+  optional<ABBWelcomeData> decode(RemoteReceiveData src) override;
+  void dump(const ABBWelcomeData &data) override;

 protected:
  void encode_byte_(RemoteTransmitData *dst, uint8_t data) const;
@@ -15,9 +15,9 @@ struct AEHAData {

 class AEHAProtocol : public RemoteProtocol<AEHAData> {
 public:
-  void encode(RemoteTransmitData *dst, const AEHAData &data);
-  optional<AEHAData> decode(RemoteReceiveData src);
-  void dump(const AEHAData &data);
+  void encode(RemoteTransmitData *dst, const AEHAData &data) override;
+  optional<AEHAData> decode(RemoteReceiveData src) override;
+  void dump(const AEHAData &data) override;

 private:
  std::string format_data_(const std::vector<uint8_t> &data);
@@ -16,9 +16,9 @@ struct Beo4Data {

 class Beo4Protocol : public RemoteProtocol<Beo4Data> {
 public:
-  void encode(RemoteTransmitData *dst, const Beo4Data &data);
-  optional<Beo4Data> decode(RemoteReceiveData src);
-  void dump(const Beo4Data &data);
+  void encode(RemoteTransmitData *dst, const Beo4Data &data) override;
+  optional<Beo4Data> decode(RemoteReceiveData src) override;
+  void dump(const Beo4Data &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Beo4)
@@ -13,9 +13,9 @@ struct BrennenstuhlData {

 class BrennenstuhlProtocol : public RemoteProtocol<BrennenstuhlData> {
 public:
-  void encode(RemoteTransmitData *dst, const BrennenstuhlData &data);
-  optional<BrennenstuhlData> decode(RemoteReceiveData src);
-  void dump(const BrennenstuhlData &data);
+  void encode(RemoteTransmitData *dst, const BrennenstuhlData &data) override;
+  optional<BrennenstuhlData> decode(RemoteReceiveData src) override;
+  void dump(const BrennenstuhlData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Brennenstuhl)
@@ -21,9 +21,9 @@ struct ByronSXData {

 class ByronSXProtocol : public RemoteProtocol<ByronSXData> {
 public:
-  void encode(RemoteTransmitData *dst, const ByronSXData &data);
-  optional<ByronSXData> decode(RemoteReceiveData src);
-  void dump(const ByronSXData &data);
+  void encode(RemoteTransmitData *dst, const ByronSXData &data) override;
+  optional<ByronSXData> decode(RemoteReceiveData src) override;
+  void dump(const ByronSXData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(ByronSX)
@@ -19,9 +19,9 @@ struct CanalSatLDData : public CanalSatData {};

 class CanalSatBaseProtocol : public RemoteProtocol<CanalSatData> {
 public:
-  void encode(RemoteTransmitData *dst, const CanalSatData &data);
-  optional<CanalSatData> decode(RemoteReceiveData src);
-  void dump(const CanalSatData &data);
+  void encode(RemoteTransmitData *dst, const CanalSatData &data) override;
+  optional<CanalSatData> decode(RemoteReceiveData src) override;
+  void dump(const CanalSatData &data) override;

 protected:
  uint16_t frequency_;
@@ -21,9 +21,9 @@ struct CoolixData {

 class CoolixProtocol : public RemoteProtocol<CoolixData> {
 public:
-  void encode(RemoteTransmitData *dst, const CoolixData &data);
-  optional<CoolixData> decode(RemoteReceiveData data);
-  void dump(const CoolixData &data);
+  void encode(RemoteTransmitData *dst, const CoolixData &data) override;
+  optional<CoolixData> decode(RemoteReceiveData data) override;
+  void dump(const CoolixData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Coolix)
@@ -13,9 +13,9 @@ struct DishData {

 class DishProtocol : public RemoteProtocol<DishData> {
 public:
-  void encode(RemoteTransmitData *dst, const DishData &data);
-  optional<DishData> decode(RemoteReceiveData src);
-  void dump(const DishData &data);
+  void encode(RemoteTransmitData *dst, const DishData &data) override;
+  optional<DishData> decode(RemoteReceiveData src) override;
+  void dump(const DishData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Dish)
@@ -20,9 +20,9 @@ struct DooyaData {

 class DooyaProtocol : public RemoteProtocol<DooyaData> {
 public:
-  void encode(RemoteTransmitData *dst, const DooyaData &data);
-  optional<DooyaData> decode(RemoteReceiveData src);
-  void dump(const DooyaData &data);
+  void encode(RemoteTransmitData *dst, const DooyaData &data) override;
+  optional<DooyaData> decode(RemoteReceiveData src) override;
+  void dump(const DooyaData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Dooya)
@@ -19,9 +19,9 @@ struct DraytonData {

 class DraytonProtocol : public RemoteProtocol<DraytonData> {
 public:
-  void encode(RemoteTransmitData *dst, const DraytonData &data);
-  optional<DraytonData> decode(RemoteReceiveData src);
-  void dump(const DraytonData &data);
+  void encode(RemoteTransmitData *dst, const DraytonData &data) override;
+  optional<DraytonData> decode(RemoteReceiveData src) override;
+  void dump(const DraytonData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Drayton)
@@ -21,9 +21,9 @@ struct DysonData {

 class DysonProtocol : public RemoteProtocol<DysonData> {
 public:
-  void encode(RemoteTransmitData *dst, const DysonData &data);
-  optional<DysonData> decode(RemoteReceiveData src);
-  void dump(const DysonData &data);
+  void encode(RemoteTransmitData *dst, const DysonData &data) override;
+  optional<DysonData> decode(RemoteReceiveData src) override;
+  void dump(const DysonData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Dyson)
@@ -31,9 +31,9 @@ class GoboxProtocol : public RemoteProtocol<GoboxData> {
  void dump_timings_(const RawTimings &timings) const;

 public:
-  void encode(RemoteTransmitData *dst, const GoboxData &data);
-  optional<GoboxData> decode(RemoteReceiveData src);
-  void dump(const GoboxData &data);
+  void encode(RemoteTransmitData *dst, const GoboxData &data) override;
+  optional<GoboxData> decode(RemoteReceiveData src) override;
+  void dump(const GoboxData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Gobox)
@@ -13,9 +13,9 @@ struct HaierData {

 class HaierProtocol : public RemoteProtocol<HaierData> {
 public:
-  void encode(RemoteTransmitData *dst, const HaierData &data);
-  optional<HaierData> decode(RemoteReceiveData src);
-  void dump(const HaierData &data);
+  void encode(RemoteTransmitData *dst, const HaierData &data) override;
+  optional<HaierData> decode(RemoteReceiveData src) override;
+  void dump(const HaierData &data) override;

 protected:
  void encode_byte_(RemoteTransmitData *dst, uint8_t item);
@@ -14,9 +14,9 @@ struct JVCData {

 class JVCProtocol : public RemoteProtocol<JVCData> {
 public:
-  void encode(RemoteTransmitData *dst, const JVCData &data);
-  optional<JVCData> decode(RemoteReceiveData src);
-  void dump(const JVCData &data);
+  void encode(RemoteTransmitData *dst, const JVCData &data) override;
+  optional<JVCData> decode(RemoteReceiveData src) override;
+  void dump(const JVCData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(JVC)
@@ -24,9 +24,9 @@ struct KeeloqData {

 class KeeloqProtocol : public RemoteProtocol<KeeloqData> {
 public:
-  void encode(RemoteTransmitData *dst, const KeeloqData &data);
-  optional<KeeloqData> decode(RemoteReceiveData src);
-  void dump(const KeeloqData &data);
+  void encode(RemoteTransmitData *dst, const KeeloqData &data) override;
+  optional<KeeloqData> decode(RemoteReceiveData src) override;
+  void dump(const KeeloqData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Keeloq)
@@ -16,9 +16,9 @@ struct LGData {

 class LGProtocol : public RemoteProtocol<LGData> {
 public:
-  void encode(RemoteTransmitData *dst, const LGData &data);
-  optional<LGData> decode(RemoteReceiveData src);
-  void dump(const LGData &data);
+  void encode(RemoteTransmitData *dst, const LGData &data) override;
+  optional<LGData> decode(RemoteReceiveData src) override;
+  void dump(const LGData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(LG)
@@ -27,9 +27,9 @@ struct MagiQuestData {

 class MagiQuestProtocol : public RemoteProtocol<MagiQuestData> {
 public:
-  void encode(RemoteTransmitData *dst, const MagiQuestData &data);
-  optional<MagiQuestData> decode(RemoteReceiveData src);
-  void dump(const MagiQuestData &data);
+  void encode(RemoteTransmitData *dst, const MagiQuestData &data) override;
+  optional<MagiQuestData> decode(RemoteReceiveData src) override;
+  void dump(const MagiQuestData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(MagiQuest)
@@ -67,9 +67,9 @@ class MideaData {

 class MideaProtocol : public RemoteProtocol<MideaData> {
 public:
-  void encode(RemoteTransmitData *dst, const MideaData &src);
-  optional<MideaData> decode(RemoteReceiveData src);
-  void dump(const MideaData &data);
+  void encode(RemoteTransmitData *dst, const MideaData &src) override;
+  optional<MideaData> decode(RemoteReceiveData src) override;
+  void dump(const MideaData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Midea)
@@ -13,9 +13,9 @@ struct MirageData {

 class MirageProtocol : public RemoteProtocol<MirageData> {
 public:
-  void encode(RemoteTransmitData *dst, const MirageData &data);
-  optional<MirageData> decode(RemoteReceiveData src);
-  void dump(const MirageData &data);
+  void encode(RemoteTransmitData *dst, const MirageData &data) override;
+  optional<MirageData> decode(RemoteReceiveData src) override;
+  void dump(const MirageData &data) override;

 protected:
  void encode_byte_(RemoteTransmitData *dst, uint8_t item);
@@ -14,9 +14,9 @@ struct NECData {

 class NECProtocol : public RemoteProtocol<NECData> {
 public:
-  void encode(RemoteTransmitData *dst, const NECData &data);
-  optional<NECData> decode(RemoteReceiveData src);
-  void dump(const NECData &data);
+  void encode(RemoteTransmitData *dst, const NECData &data) override;
+  optional<NECData> decode(RemoteReceiveData src) override;
+  void dump(const NECData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(NEC)
@@ -24,9 +24,9 @@ class NexaProtocol : public RemoteProtocol<NexaData> {
  void zero(RemoteTransmitData *dst) const;
  void sync(RemoteTransmitData *dst) const;

-  void encode(RemoteTransmitData *dst, const NexaData &data);
-  optional<NexaData> decode(RemoteReceiveData src);
-  void dump(const NexaData &data);
+  void encode(RemoteTransmitData *dst, const NexaData &data) override;
+  optional<NexaData> decode(RemoteReceiveData src) override;
+  void dump(const NexaData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Nexa)
@@ -16,9 +16,9 @@ struct PanasonicData {

 class PanasonicProtocol : public RemoteProtocol<PanasonicData> {
 public:
-  void encode(RemoteTransmitData *dst, const PanasonicData &data);
-  optional<PanasonicData> decode(RemoteReceiveData src);
-  void dump(const PanasonicData &data);
+  void encode(RemoteTransmitData *dst, const PanasonicData &data) override;
+  optional<PanasonicData> decode(RemoteReceiveData src) override;
+  void dump(const PanasonicData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Panasonic)
@@ -13,9 +13,9 @@ struct PioneerData {

 class PioneerProtocol : public RemoteProtocol<PioneerData> {
 public:
-  void encode(RemoteTransmitData *dst, const PioneerData &data);
-  optional<PioneerData> decode(RemoteReceiveData src);
-  void dump(const PioneerData &data);
+  void encode(RemoteTransmitData *dst, const PioneerData &data) override;
+  optional<PioneerData> decode(RemoteReceiveData src) override;
+  void dump(const PioneerData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Pioneer)
@@ -30,9 +30,9 @@ class ProntoProtocol : public RemoteProtocol<ProntoData> {
  std::string compensate_and_dump_sequence_(const RawTimings &data, uint16_t timebase);

 public:
-  void encode(RemoteTransmitData *dst, const ProntoData &data);
-  optional<ProntoData> decode(RemoteReceiveData src);
-  void dump(const ProntoData &data);
+  void encode(RemoteTransmitData *dst, const ProntoData &data) override;
+  optional<ProntoData> decode(RemoteReceiveData src) override;
+  void dump(const ProntoData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Pronto)
@@ -14,9 +14,9 @@ struct RC5Data {

 class RC5Protocol : public RemoteProtocol<RC5Data> {
 public:
-  void encode(RemoteTransmitData *dst, const RC5Data &data);
-  optional<RC5Data> decode(RemoteReceiveData src);
-  void dump(const RC5Data &data);
+  void encode(RemoteTransmitData *dst, const RC5Data &data) override;
+  optional<RC5Data> decode(RemoteReceiveData src) override;
+  void dump(const RC5Data &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(RC5)
@@ -15,9 +15,9 @@ struct RC6Data {

 class RC6Protocol : public RemoteProtocol<RC6Data> {
 public:
-  void encode(RemoteTransmitData *dst, const RC6Data &data);
-  optional<RC6Data> decode(RemoteReceiveData src);
-  void dump(const RC6Data &data);
+  void encode(RemoteTransmitData *dst, const RC6Data &data) override;
+  optional<RC6Data> decode(RemoteReceiveData src) override;
+  void dump(const RC6Data &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(RC6)
@@ -1,12 +1,30 @@
 #include "rc_switch_protocol.h"
-
-#include <iterator>
 #include "esphome/core/log.h"

 namespace esphome::remote_base {

 static const char *const TAG = "remote.rc_switch";

+const RCSwitchBase RC_SWITCH_PROTOCOLS[9] = {RCSwitchBase(0, 0, 0, 0, 0, 0, false),
+                                             RCSwitchBase(350, 10850, 350, 1050, 1050, 350, false),
+                                             RCSwitchBase(650, 6500, 650, 1300, 1300, 650, false),
+                                             RCSwitchBase(3000, 7100, 400, 1100, 900, 600, false),
+                                             RCSwitchBase(380, 2280, 380, 1140, 1140, 380, false),
+                                             RCSwitchBase(3000, 7000, 500, 1000, 1000, 500, false),
+                                             RCSwitchBase(10350, 450, 450, 900, 900, 450, true),
+                                             RCSwitchBase(300, 9300, 150, 900, 900, 150, false),
+                                             RCSwitchBase(250, 2500, 250, 1250, 250, 250, false)};
+
+RCSwitchBase::RCSwitchBase(uint32_t sync_high, uint32_t sync_low, uint32_t zero_high, uint32_t zero_low,
+                           uint32_t one_high, uint32_t one_low, bool inverted)
+    : sync_high_(sync_high),
+      sync_low_(sync_low),
+      zero_high_(zero_high),
+      zero_low_(zero_low),
+      one_high_(one_high),
+      one_low_(one_low),
+      inverted_(inverted) {}
+
 void RCSwitchBase::one(RemoteTransmitData *dst) const {
  if (!this->inverted_) {
    dst->mark(this->one_high_);
@@ -115,11 +133,11 @@ bool RCSwitchBase::decode(RemoteReceiveData &src, uint64_t *out_data, uint8_t *o
 optional<RCSwitchData> RCSwitchBase::decode(RemoteReceiveData &src) const {
  RCSwitchData out;
  uint8_t out_nbits;
-  for (size_t i = 1; i < std::size(RC_SWITCH_PROTOCOLS); i++) {
+  for (uint8_t i = 1; i <= 8; i++) {
    src.reset();
    const RCSwitchBase *protocol = &RC_SWITCH_PROTOCOLS[i];
    if (protocol->decode(src, &out.code, &out_nbits) && out_nbits >= 3) {
-      out.protocol = static_cast<uint8_t>(i);
+      out.protocol = i;
      return out;
    }
  }
@@ -228,7 +246,7 @@ bool RCSwitchRawReceiver::matches(RemoteReceiveData src) {
  return decoded_nbits == this->nbits_ && (decoded_code & this->mask_) == (this->code_ & this->mask_);
 }
 bool RCSwitchDumper::dump(RemoteReceiveData src) {
-  for (size_t i = 1; i < std::size(RC_SWITCH_PROTOCOLS); i++) {
+  for (uint8_t i = 1; i <= 8; i++) {
    src.reset();
    uint64_t out_data;
    uint8_t out_nbits;
@@ -239,7 +257,7 @@ bool RCSwitchDumper::dump(RemoteReceiveData src) {
        buffer[j] = (out_data & ((uint64_t) 1 << (out_nbits - j - 1))) ? '1' : '0';

      buffer[out_nbits] = '\0';
-      ESP_LOGI(TAG, "Received RCSwitch Raw: protocol=%u data='%s'", static_cast<unsigned>(i), buffer);
+      ESP_LOGI(TAG, "Received RCSwitch Raw: protocol=%u data='%s'", i, buffer);

      // only send first decoded protocol
      return true;
@@ -16,16 +16,9 @@ class RCSwitchBase {
 public:
  using ProtocolData = RCSwitchData;

-  constexpr RCSwitchBase() = default;
-  constexpr RCSwitchBase(uint32_t sync_high, uint32_t sync_low, uint32_t zero_high, uint32_t zero_low,
-                         uint32_t one_high, uint32_t one_low, bool inverted)
-      : sync_high_(sync_high),
-        sync_low_(sync_low),
-        zero_high_(zero_high),
-        zero_low_(zero_low),
-        one_high_(one_high),
-        one_low_(one_low),
-        inverted_(inverted) {}
+  RCSwitchBase() = default;
+  RCSwitchBase(uint32_t sync_high, uint32_t sync_low, uint32_t zero_high, uint32_t zero_low, uint32_t one_high,
+               uint32_t one_low, bool inverted);

  void one(RemoteTransmitData *dst) const;

@@ -65,21 +58,10 @@ class RCSwitchBase {
  uint32_t zero_low_{};
  uint32_t one_high_{};
  uint32_t one_low_{};
-  uint32_t inverted_{};  // bool widened so every field is a word: the table is read from flash
+  bool inverted_{};
 };

-// Constant-initialized and kept in flash on every platform; all fields are 32-bit so ESP8266 can read it in place
-inline constexpr RCSwitchBase RC_SWITCH_PROTOCOLS[] PROGMEM = {
-    {0, 0, 0, 0, 0, 0, false},
-    {350, 10850, 350, 1050, 1050, 350, false},
-    {650, 6500, 650, 1300, 1300, 650, false},
-    {3000, 7100, 400, 1100, 900, 600, false},
-    {380, 2280, 380, 1140, 1140, 380, false},
-    {3000, 7000, 500, 1000, 1000, 500, false},
-    {10350, 450, 450, 900, 900, 450, true},
-    {300, 9300, 150, 900, 900, 150, false},
-    {250, 2500, 250, 1250, 250, 250, false},
-};
+extern const RCSwitchBase RC_SWITCH_PROTOCOLS[9];

 uint64_t decode_binary_string(const std::string &data);

@@ -99,47 +99,29 @@ bool RemoteReceiverBinarySensorBase::on_receive(RemoteReceiveData src) {

 /* RemoteReceiverBase */

-// Slots are counted at code generation; a registration from C++ setup() has none
-#ifdef REMOTE_BASE_LISTENER_COUNT
-void RemoteReceiverBase::register_listener(RemoteReceiverListener *listener) {
-  if (this->listeners_.size() == REMOTE_BASE_LISTENER_COUNT) {
-    ESP_LOGE(TAG, "No %s slot: register it from to_code() with remote_base.add_%s", LOG_STR_LITERAL("listener"),
-             LOG_STR_LITERAL("listener"));
-    return;
-  }
-  this->listeners_.push_back(listener);
-}
-#endif
-
-#ifdef REMOTE_BASE_DUMPER_COUNT
 void RemoteReceiverBase::register_dumper(RemoteReceiverDumperBase *dumper) {
  if (dumper->is_secondary()) {
-    this->secondary_dumper_ = dumper;
-    return;
+    this->secondary_dumpers_.push_back(dumper);
+  } else {
+    this->dumpers_.push_back(dumper);
  }
-  if (this->dumpers_.size() == REMOTE_BASE_DUMPER_COUNT) {
-    ESP_LOGE(TAG, "No %s slot: register it from to_code() with remote_base.add_%s", LOG_STR_LITERAL("dumper"),
-             LOG_STR_LITERAL("dumper"));
-    return;
-  }
-  this->dumpers_.push_back(dumper);
 }
-#endif

-void RemoteReceiverBase::call_listeners_dumpers_() {
-#ifdef REMOTE_BASE_LISTENER_COUNT
+void RemoteReceiverBase::call_listeners_() {
  for (auto *listener : this->listeners_)
    listener->on_receive(RemoteReceiveData(this->temp_, this->tolerance_, this->tolerance_mode_));
-#endif
-#ifdef REMOTE_BASE_DUMPER_COUNT
+}
+
+void RemoteReceiverBase::call_dumpers_() {
  bool success = false;
  for (auto *dumper : this->dumpers_) {
    if (dumper->dump(RemoteReceiveData(this->temp_, this->tolerance_, this->tolerance_mode_)))
      success = true;
  }
-  if (!success && this->secondary_dumper_ != nullptr)
-    this->secondary_dumper_->dump(RemoteReceiveData(this->temp_, this->tolerance_, this->tolerance_mode_));
-#endif
+  if (!success) {
+    for (auto *dumper : this->secondary_dumpers_)
+      dumper->dump(RemoteReceiveData(this->temp_, this->tolerance_, this->tolerance_mode_));
+  }
 }

 void RemoteReceiverBinarySensorBase::dump_config() { LOG_BINARY_SENSOR("", "Remote Receiver Binary Sensor", this); }
@@ -1,14 +1,12 @@
-#pragma once
-
-#include <concepts>
 #include <utility>
 #include <vector>

+#pragma once
+
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"

 namespace esphome::remote_base {

@@ -143,22 +141,6 @@ class RemoteRMTChannel {
 #endif  // SOC_RMT_SUPPORTED
 #endif  // USE_ESP32

-// Protocol shapes, checked where a protocol is used so a missing method fails at the use site
-// instead of deep inside a template body. Receive-only protocols such as RCSwitchBase decode
-// without encoding.
-template<typename T>
-concept RemoteProtocolDecoder = requires(T proto, RemoteReceiveData src) {
-  { proto.decode(src) } -> std::same_as<optional<typename T::ProtocolData>>;
-};
-template<typename T>
-concept RemoteProtocolDumper = RemoteProtocolDecoder<T> && requires(T proto, const typename T::ProtocolData &data) {
-  proto.dump(data);
-};
-template<typename T>
-concept RemoteProtocolEncoder = requires(T proto, RemoteTransmitData *dst, const typename T::ProtocolData &data) {
-  proto.encode(dst, data);
-};
-
 class RemoteTransmitterBase : public RemoteComponentBase {
 public:
  RemoteTransmitterBase(InternalGPIOPin *pin) : RemoteComponentBase(pin) {}
@@ -180,7 +162,7 @@ class RemoteTransmitterBase : public RemoteComponentBase {
    this->temp_.reset();
    return TransmitCall(this);
  }
-  template<RemoteProtocolEncoder Protocol>
+  template<typename Protocol>
  void transmit(const Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
    auto call = this->transmit();
    Protocol().encode(call.get_data(), data);
@@ -212,37 +194,24 @@ class RemoteReceiverDumperBase {
 class RemoteReceiverBase : public RemoteComponentBase {
 public:
  RemoteReceiverBase(InternalGPIOPin *pin) : RemoteComponentBase(pin) {}
-  // Slots are counted at code generation; without one the call fails at compile time with the same message
-  // the runtime check logs
-#ifdef REMOTE_BASE_LISTENER_COUNT
-  void register_listener(RemoteReceiverListener *listener);
-#else
-  template<typename T> void register_listener(T *) {
-    static_assert(sizeof(T) == 0, "No listener slot: register it from to_code() with remote_base.add_listener");
-  }
-#endif
-#ifdef REMOTE_BASE_DUMPER_COUNT
+  void register_listener(RemoteReceiverListener *listener) { this->listeners_.push_back(listener); }
  void register_dumper(RemoteReceiverDumperBase *dumper);
-#else
-  template<typename T> void register_dumper(T *) {
-    static_assert(sizeof(T) == 0, "No dumper slot: register it from to_code() with remote_base.add_dumper");
-  }
-#endif
  void set_tolerance(uint32_t tolerance, ToleranceMode tolerance_mode) {
    this->tolerance_ = tolerance;
    this->tolerance_mode_ = tolerance_mode;
  }

 protected:
-  void call_listeners_dumpers_();
+  void call_listeners_();
+  void call_dumpers_();
+  void call_listeners_dumpers_() {
+    this->call_listeners_();
+    this->call_dumpers_();
+  }

-#ifdef REMOTE_BASE_LISTENER_COUNT
-  StaticVector<RemoteReceiverListener *, REMOTE_BASE_LISTENER_COUNT> listeners_;
-#endif
-#ifdef REMOTE_BASE_DUMPER_COUNT
-  StaticVector<RemoteReceiverDumperBase *, REMOTE_BASE_DUMPER_COUNT> dumpers_;
-  RemoteReceiverDumperBase *secondary_dumper_{nullptr};  // runs only when no primary dumper matched
-#endif
+  std::vector<RemoteReceiverListener *> listeners_;
+  std::vector<RemoteReceiverDumperBase *> dumpers_;
+  std::vector<RemoteReceiverDumperBase *> secondary_dumpers_;
  RawTimings temp_;
  uint32_t tolerance_{25};
  ToleranceMode tolerance_mode_{TOLERANCE_MODE_PERCENTAGE};
@@ -260,14 +229,15 @@ class RemoteReceiverBinarySensorBase : public binary_sensor::BinarySensorInitial

 /* TEMPLATES */

-// Protocols are used only through their concrete type (see the RemoteProtocol* concepts); encode/decode/dump
-// stay non-virtual so unused ones link out
 template<typename T> class RemoteProtocol {
 public:
  using ProtocolData = T;
+  virtual void encode(RemoteTransmitData *dst, const ProtocolData &data) = 0;
+  virtual optional<ProtocolData> decode(RemoteReceiveData src) = 0;
+  virtual void dump(const ProtocolData &data) = 0;
 };

-template<RemoteProtocolDecoder T> class RemoteReceiverBinarySensor : public RemoteReceiverBinarySensorBase {
+template<typename T> class RemoteReceiverBinarySensor : public RemoteReceiverBinarySensorBase {
 public:
  RemoteReceiverBinarySensor() : RemoteReceiverBinarySensorBase() {}

@@ -285,7 +255,7 @@ template<RemoteProtocolDecoder T> class RemoteReceiverBinarySensor : public Remo
  T::ProtocolData data_;
 };

-template<RemoteProtocolDecoder T>
+template<typename T>
 class RemoteReceiverTrigger final : public Trigger<typename T::ProtocolData>, public RemoteReceiverListener {
 protected:
  bool on_receive(RemoteReceiveData src) override {
@@ -306,7 +276,7 @@ class RemoteTransmittable {
  void set_transmitter(RemoteTransmitterBase *transmitter) { this->transmitter_ = transmitter; }

 protected:
-  template<RemoteProtocolEncoder Protocol>
+  template<typename Protocol>
  void transmit_(const Protocol::ProtocolData &data, uint32_t send_times = 1, uint32_t send_wait = 0) {
    this->transmitter_->transmit<Protocol>(data, send_times, send_wait);
  }
@@ -328,7 +298,7 @@ template<typename... Ts> class RemoteTransmitterActionBase : public RemoteTransm
  virtual void encode(RemoteTransmitData *dst, Ts... x) = 0;
 };

-template<RemoteProtocolDumper T> class RemoteReceiverDumper : public RemoteReceiverDumperBase {
+template<typename T> class RemoteReceiverDumper : public RemoteReceiverDumperBase {
 public:
  bool dump(RemoteReceiveData src) override {
    auto proto = T();
@@ -12,9 +12,9 @@ struct RoombaData {

 class RoombaProtocol : public RemoteProtocol<RoombaData> {
 public:
-  void encode(RemoteTransmitData *dst, const RoombaData &data);
-  optional<RoombaData> decode(RemoteReceiveData src);
-  void dump(const RoombaData &data);
+  void encode(RemoteTransmitData *dst, const RoombaData &data) override;
+  optional<RoombaData> decode(RemoteReceiveData src) override;
+  void dump(const RoombaData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Roomba)
@@ -16,9 +16,9 @@ struct Samsung36Data {

 class Samsung36Protocol : public RemoteProtocol<Samsung36Data> {
 public:
-  void encode(RemoteTransmitData *dst, const Samsung36Data &data);
-  optional<Samsung36Data> decode(RemoteReceiveData src);
-  void dump(const Samsung36Data &data);
+  void encode(RemoteTransmitData *dst, const Samsung36Data &data) override;
+  optional<Samsung36Data> decode(RemoteReceiveData src) override;
+  void dump(const Samsung36Data &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Samsung36)
@@ -14,9 +14,9 @@ struct SamsungData {

 class SamsungProtocol : public RemoteProtocol<SamsungData> {
 public:
-  void encode(RemoteTransmitData *dst, const SamsungData &data);
-  optional<SamsungData> decode(RemoteReceiveData src);
-  void dump(const SamsungData &data);
+  void encode(RemoteTransmitData *dst, const SamsungData &data) override;
+  optional<SamsungData> decode(RemoteReceiveData src) override;
+  void dump(const SamsungData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Samsung)
@@ -16,9 +16,9 @@ struct SonyData {

 class SonyProtocol : public RemoteProtocol<SonyData> {
 public:
-  void encode(RemoteTransmitData *dst, const SonyData &data);
-  optional<SonyData> decode(RemoteReceiveData src);
-  void dump(const SonyData &data);
+  void encode(RemoteTransmitData *dst, const SonyData &data) override;
+  optional<SonyData> decode(RemoteReceiveData src) override;
+  void dump(const SonyData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Sony)
@@ -17,9 +17,9 @@ struct SymphonyData {

 class SymphonyProtocol : public RemoteProtocol<SymphonyData> {
 public:
-  void encode(RemoteTransmitData *dst, const SymphonyData &data);
-  optional<SymphonyData> decode(RemoteReceiveData src);
-  void dump(const SymphonyData &data);
+  void encode(RemoteTransmitData *dst, const SymphonyData &data) override;
+  optional<SymphonyData> decode(RemoteReceiveData src) override;
+  void dump(const SymphonyData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Symphony)
@@ -14,9 +14,9 @@ struct ToshibaAcData {

 class ToshibaAcProtocol : public RemoteProtocol<ToshibaAcData> {
 public:
-  void encode(RemoteTransmitData *dst, const ToshibaAcData &data);
-  optional<ToshibaAcData> decode(RemoteReceiveData src);
-  void dump(const ToshibaAcData &data);
+  void encode(RemoteTransmitData *dst, const ToshibaAcData &data) override;
+  optional<ToshibaAcData> decode(RemoteReceiveData src) override;
+  void dump(const ToshibaAcData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(ToshibaAc)
@@ -16,9 +16,9 @@ struct TotoData {

 class TotoProtocol : public RemoteProtocol<TotoData> {
 public:
-  void encode(RemoteTransmitData *dst, const TotoData &data);
-  optional<TotoData> decode(RemoteReceiveData src);
-  void dump(const TotoData &data);
+  void encode(RemoteTransmitData *dst, const TotoData &data) override;
+  optional<TotoData> decode(RemoteReceiveData src) override;
+  void dump(const TotoData &data) override;
 };

 DECLARE_REMOTE_PROTOCOL(Toto)
@@ -221,11 +221,11 @@ async def to_code(config: ConfigType) -> None:

    dumpers = await remote_base.build_dumpers(config[CONF_DUMP])
    for dumper in dumpers:
-        remote_base.add_dumper(var, dumper)
+        cg.add(var.register_dumper(dumper))

    triggers = await remote_base.build_triggers(config)
    for trigger in triggers:
-        remote_base.add_listener(var, trigger)
+        cg.add(var.register_listener(trigger))
    await cg.register_component(var, config)

    cg.add(
@@ -18,9 +18,10 @@ from esphome import pins
 import esphome.codegen as cg
 from esphome.components import uart
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_NAME
+from esphome.const import CONF_ID, CONF_NAME, CONF_UART_ID
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
+import esphome.final_validate as fv
 from esphome.types import ConfigType

 CODEOWNERS = ["@kbx81"]
@@ -34,11 +35,14 @@ SerialProxyTap = serial_proxy_ns.class_("SerialProxyTap")

 api_enums_ns = cg.esphome_ns.namespace("api").namespace("enums")
 SerialProxyPortType = api_enums_ns.enum("SerialProxyPortType")
+# User-selectable electrical types. USB_SERIAL is deliberately absent: it is derived
+# from the uart_id pointing at a usb_uart channel, never set by the user.
 SERIAL_PROXY_PORT_TYPES = {
    "TTL": SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_TTL,
    "RS232": SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_RS232,
    "RS485": SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_RS485,
 }
+PORT_TYPE_USB_SERIAL = SerialProxyPortType.SERIAL_PROXY_PORT_TYPE_USB_SERIAL

 CONF_DTR_PIN = "dtr_pin"
 CONF_PORT_TYPE = "port_type"
@@ -63,7 +67,7 @@ CONFIG_SCHEMA = (
        {
            cv.GenerateID(): cv.declare_id(SerialProxy),
            cv.Required(CONF_NAME): cv.string_strict,
-            cv.Required(CONF_PORT_TYPE): cv.enum(SERIAL_PROXY_PORT_TYPES, upper=True),
+            cv.Optional(CONF_PORT_TYPE): cv.enum(SERIAL_PROXY_PORT_TYPES, upper=True),
            cv.Optional(CONF_RTS_PIN): pins.gpio_output_pin_schema,
            cv.Optional(CONF_DTR_PIN): pins.gpio_output_pin_schema,
        }
@@ -73,6 +77,26 @@ CONFIG_SCHEMA = (
 )


+def _uses_usb_uart(config: ConfigType, full_config: ConfigType) -> bool:
+    from esphome.components.usb_uart import is_usb_uart_channel
+
+    return is_usb_uart_channel(config[CONF_UART_ID], full_config)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    if _uses_usb_uart(config, fv.full_config.get()):
+        if CONF_PORT_TYPE in config:
+            raise cv.Invalid(
+                f"{CONF_PORT_TYPE} is set automatically for USB serial ports"
+            )
+    elif CONF_PORT_TYPE not in config:
+        raise cv.Invalid(f"{CONF_PORT_TYPE} is required")
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
@coroutine_with_priority(CoroPriority.FINAL)
 async def _add_serial_proxy_count_define() -> None:
    """Emit the SERIAL_PROXY_COUNT define once with the final instance count."""
@@ -87,7 +111,13 @@ async def to_code(config: ConfigType) -> None:
    await uart.register_uart_device(var, config)
    cg.add(cg.App.register_serial_proxy(var))
    cg.add(var.set_name(config[CONF_NAME]))
-    cg.add(var.set_port_type(config[CONF_PORT_TYPE]))
+    if _uses_usb_uart(config, CORE.config):
+        cg.add(var.set_port_type(PORT_TYPE_USB_SERIAL))
+        channel = await cg.get_variable(config[CONF_UART_ID])
+        cg.add(var.set_usb_channel(channel))
+        cg.add_define("USE_SERIAL_PROXY_USB_INFO")
+    else:
+        cg.add(var.set_port_type(config[CONF_PORT_TYPE]))
    cg.add_define("USE_SERIAL_PROXY")

    # Track instance count for the FINAL priority define
@@ -12,6 +12,10 @@
 #include "esphome/components/api/api_server.h"
 #endif

+#ifdef USE_SERIAL_PROXY_USB_INFO
+#include "esphome/components/usb_uart/usb_uart.h"
+#endif
+
 namespace esphome::serial_proxy {

 static const char *const TAG = "serial_proxy";
@@ -30,6 +34,13 @@ void SerialProxy::setup() {
  // instance_index_ is fixed at registration time; pre-set it so loop() only needs to update data
  this->outgoing_msg_.instance = this->instance_index_;
 #endif
+#ifdef USE_SERIAL_PROXY_USB_INFO
+  // The define is global, so a hardware UART port in the same config also gets here
+  if (this->usb_channel_ != nullptr) {
+    this->usb_channel_->get_parent()->add_on_connection_callback(
+        [this](bool connected) { this->on_usb_connection_changed_(connected); });
+  }
+#endif
 #ifdef USE_SERIAL_PROXY_TAP
  // A tap sets itself up before this runs (its setup priority is higher), so it may
  // already be waiting on the port -- a boot-time handshake with the device, say. Leaving
@@ -156,9 +167,10 @@ void SerialProxy::dump_config() {
                "  RTS Pin: %s\n"
                "  DTR Pin: %s",
                this->instance_index_, this->name_ != nullptr ? this->name_ : "",
-                this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS485   ? LOG_STR_LITERAL("RS485")
-                : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS232 ? LOG_STR_LITERAL("RS232")
-                                                                               : LOG_STR_LITERAL("TTL"),
+                this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS485        ? LOG_STR_LITERAL("RS485")
+                : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_RS232      ? LOG_STR_LITERAL("RS232")
+                : this->port_type_ == api::enums::SERIAL_PROXY_PORT_TYPE_USB_SERIAL ? LOG_STR_LITERAL("USB_SERIAL")
+                                                                                    : LOG_STR_LITERAL("TTL"),
                this->rts_pin_ != nullptr ? LOG_STR_LITERAL("configured") : LOG_STR_LITERAL("not configured"),
                this->dtr_pin_ != nullptr ? LOG_STR_LITERAL("configured") : LOG_STR_LITERAL("not configured"));
 }
@@ -200,11 +212,6 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
    ESP_LOGW(TAG, "Invalid parity: %u (must be 0-2)", parity);
    return SerialProxyResult::SERIAL_PROXY_RESULT_INVALID_ARGUMENT;
  }
-  if (flow_control) {
-    ESP_LOGW(TAG, "Hardware flow control requested but is not yet supported");
-    return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
-  }
-
  // Skip a no-op reconfigure. Clients routinely re-send identical settings on every
  // port open, and on a USB UART each apply is a CDC SET_LINE_CODING control transfer.
  // Some bridges watch line-coding changes as a signalling channel (a magic baud
@@ -215,7 +222,8 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
      uart::UART_CONFIG_PARITY_ODD,
  };
  if (uart_comp->get_baud_rate() == baudrate && uart_comp->get_stop_bits() == stop_bits &&
-      uart_comp->get_data_bits() == data_size && uart_comp->get_parity() == PARITY_MAP[parity]) {
+      uart_comp->get_data_bits() == data_size && uart_comp->get_parity() == PARITY_MAP[parity] &&
+      uart_comp->get_flow_control() == flow_control) {
    ESP_LOGV(TAG, "Settings unchanged, skipping reconfigure [%" PRIu32 "]", this->instance_index_);
    return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
  }
@@ -224,6 +232,7 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
  uart_comp->set_baud_rate(baudrate);
  uart_comp->set_stop_bits(stop_bits);
  uart_comp->set_data_bits(data_size);
+  uart_comp->set_flow_control(flow_control);

  uart_comp->set_parity(PARITY_MAP[parity]);

@@ -333,6 +342,55 @@ SerialProxyResult SerialProxy::set_modem_pins(api::APIConnection *api_connection
  return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
 }

+#ifdef USE_SERIAL_PROXY_USB_INFO
+void SerialProxy::on_usb_connection_changed_(bool connected) {
+  ESP_LOGD(TAG, "USB device %s serial proxy [%" PRIu32 "]",
+           connected ? LOG_STR_LITERAL("attached to") : LOG_STR_LITERAL("removed from"), this->instance_index_);
+#ifdef USE_SERIAL_PROXY_TAP
+  // Before telling clients, so a tap never acknowledges a frame from the old device after
+  // a client has been told it is gone. The subscriber and the mode stay: both belong to
+  // the client's session, and only the client knows whether that session is over.
+  if (!connected && this->tap_ != nullptr) {
+    this->tap_->on_device_disconnected();
+  }
+#endif
+#ifdef USE_API
+  if (api::global_api_server == nullptr) {
+    return;
+  }
+  // The message's strings are views into this buffer, which outlives the send below
+  usb_host::UsbDeviceInfo info;
+  api::SerialProxyUsbInfo msg{};
+  msg.instance = this->instance_index_;
+  this->get_usb_info(info, msg);
+  api::global_api_server->send_serial_proxy_usb_info(msg);
+#endif
+}
+
+#ifdef USE_API
+void SerialProxy::get_usb_info(usb_host::UsbDeviceInfo &info, api::SerialProxyUsbInfo &msg) const {
+  if (this->usb_channel_ == nullptr) {
+    msg.status = api::enums::SERIAL_PROXY_STATUS_NOT_SUPPORTED;
+    return;
+  }
+  if (!this->usb_channel_->get_parent()->get_device_info(info)) {
+    // No device attached right now; not an error
+    return;
+  }
+  msg.connected = true;
+  msg.vendor_id = info.vendor_id;
+  msg.product_id = info.product_id;
+  msg.bcd_device = info.bcd_device;
+  msg.interface_number = this->usb_channel_->get_interface_number();
+  msg.manufacturer = StringRef(info.manufacturer);
+  msg.product = StringRef(info.product);
+  msg.serial_number = StringRef(info.serial_number);
+  // Lives in the channel for as long as the device is attached
+  msg.interface_description = StringRef(this->usb_channel_->get_interface_string());
+}
+#endif
+#endif
+
 uint32_t SerialProxy::get_modem_pins() const {
  return (this->rts_state_ ? static_cast<uint32_t>(SERIAL_PROXY_LINE_STATE_FLAG_RTS) : 0u) |
         (this->dtr_state_ ? static_cast<uint32_t>(SERIAL_PROXY_LINE_STATE_FLAG_DTR) : 0u);
@@ -20,6 +20,15 @@
 #include "esphome/components/api/api_pb2.h"
 #endif

+#ifdef USE_SERIAL_PROXY_USB_INFO
+namespace esphome::usb_uart {
+class USBUartChannel;
+}  // namespace esphome::usb_uart
+namespace esphome::usb_host {
+struct UsbDeviceInfo;
+}  // namespace esphome::usb_host
+#endif
+
 // Forward-declare types needed outside the USE_API guard.
 namespace esphome::api {
 class APIConnection;
@@ -80,6 +89,11 @@ class SerialProxyTap {
  /// else with the device -- reflash it, most likely -- so anything the tap believes about
  /// it should be treated as suspect.
  virtual void on_protocol_disabled() = 0;
+
+  /// The device behind the port went away -- unplugged, or its power was cut. Whatever
+  /// session the tap had observed ended with it; the device that appears next starts from
+  /// scratch and may not even be the same one. Only a USB UART can report this.
+  virtual void on_device_disconnected() = 0;
 };
 #endif

@@ -114,7 +128,7 @@ class SerialProxy final : public uart::UARTDevice, public Component {
  /// Configure UART parameters and apply them
  /// @param api_connection The API connection requesting the change
  /// @param baudrate Baud rate in bits per second
-  /// @param flow_control True to enable hardware flow control
+  /// @param flow_control True to request hardware flow control
  /// @param parity Parity setting (0=none, 1=even, 2=odd)
  /// @param stop_bits Number of stop bits (1 or 2)
  /// @param data_size Number of data bits (5-8)
@@ -155,6 +169,17 @@ class SerialProxy final : public uart::UARTDevice, public Component {
  /// Set the DTR GPIO pin (from YAML configuration)
  void set_dtr_pin(GPIOPin *pin) { this->dtr_pin_ = pin; }

+#ifdef USE_SERIAL_PROXY_USB_INFO
+  /// Attach the USB UART channel behind this port (from code generation)
+  void set_usb_channel(usb_uart::USBUartChannel *channel) { this->usb_channel_ = channel; }
+
+#ifdef USE_API
+  /// Fill a USB info message for this port. The message's strings are views into info,
+  /// so info must outlive the send.
+  void get_usb_info(usb_host::UsbDeviceInfo &info, api::SerialProxyUsbInfo &msg) const;
+#endif
+#endif
+
 #ifdef USE_SERIAL_PROXY_TAP
  /// Attach a traffic observer. At most one, set once at setup time.
  void set_tap(SerialProxyTap *tap) { this->tap_ = tap; }
@@ -218,6 +243,12 @@ class SerialProxy final : public uart::UARTDevice, public Component {
  bool tap_observing_() const;
 #endif

+#ifdef USE_SERIAL_PROXY_USB_INFO
+  /// The USB device behind this port was attached or removed. Reports the port's new USB
+  /// identity to every API client, and ends the tap's view of the old device.
+  void on_usb_connection_changed_(bool connected);
+#endif
+
  /// Instance index for identifying this proxy in API messages
  uint32_t instance_index_{0};

@@ -251,6 +282,11 @@ class SerialProxy final : public uart::UARTDevice, public Component {
 #ifdef USE_SERIAL_PROXY_TAP
  SerialProxyTap *tap_{nullptr};
 #endif
+
+#ifdef USE_SERIAL_PROXY_USB_INFO
+  /// The USB UART channel behind this port; nullptr on non-USB ports
+  usb_uart::USBUartChannel *usb_channel_{nullptr};
+#endif
 };

 }  // namespace esphome::serial_proxy
@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import climate_ir, remote_base
+from esphome.components import climate_ir
 import esphome.config_validation as cv
 from esphome.const import CONF_MODEL
 from esphome.types import ConfigType
@@ -26,6 +26,5 @@ CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(ToshibaClimate).exten


 async def to_code(config: ConfigType) -> None:
-    remote_base.request_protocol("toshiba_ac")  # used from C++
    var = await climate_ir.new_climate_ir(config)
    cg.add(var.set_model(config[CONF_MODEL]))
@@ -166,6 +166,14 @@ class UARTComponent {
  // @return Baud rate in bits per second.
  uint32_t get_baud_rate() const { return baud_rate_; }

+  // Requests hardware (RTS/CTS) flow control.
+  // @param flow_control True to request hardware flow control.
+  void set_flow_control(bool flow_control) { this->flow_control_ = flow_control; }
+
+  // Gets whether hardware flow control was requested.
+  // @return True when hardware flow control was requested.
+  bool get_flow_control() const { return this->flow_control_; }
+
 #if defined(USE_ESP8266) || defined(USE_ESP32)
  /**
   * Load the UART settings.
@@ -213,6 +221,7 @@ class UARTComponent {
  uint8_t stop_bits_{0};
  uint8_t data_bits_{0};
  UARTParityOptions parity_{UART_CONFIG_PARITY_NONE};
+  bool flow_control_{false};
 #ifdef USE_UART_DEBUGGER
  CallbackManager<void(UARTDirection, uint8_t)> debug_callback_{};
 #endif
@@ -26,6 +26,8 @@ USBClient = usb_host_ns.class_("USBClient", Component)
 DOMAIN = "usb_host"
 CONF_VID = "vid"
 CONF_PID = "pid"
+CONF_MANUFACTURER = "manufacturer"
+CONF_PRODUCT = "product"
 CONF_ENABLE_HUBS = "enable_hubs"
 CONF_MAX_TRANSFER_REQUESTS = "max_transfer_requests"
 CONF_MAX_PACKET_SIZE = "max_packet_size"
@@ -47,7 +49,46 @@ def usb_device_schema(
        schema = schema.extend({cv.Optional(CONF_PID, default=pid): cv.hex_uint16_t})
    else:
        schema = schema.extend({cv.Required(CONF_PID): cv.hex_uint16_t})
-    return schema
+
+    return schema.extend(
+        {
+            cv.Optional(CONF_MANUFACTURER): cv.string_strict,
+            cv.Optional(CONF_PRODUCT): cv.string_strict,
+        }
+    )
+
+
+_validate_filters_complete = cv.has_none_or_all_keys(CONF_MANUFACTURER, CONF_PRODUCT)
+
+
+def validate_usb_clients(configs: list[ConfigType]) -> list[ConfigType]:
+    """Reject invalid USB configuration."""
+    for config in configs:
+        _validate_filters_complete(config)
+    for index, first in enumerate(configs):
+        # Ensure matching logic does not overlap between entries
+        for second in configs[index + 1 :]:
+            # A zero VID or PID is a wildcard for that field, so only a differing non-zero
+            # value separates two entries
+            if not all(
+                first[key] == 0 or second[key] == 0 or first[key] == second[key]
+                for key in (CONF_VID, CONF_PID)
+            ):
+                continue
+
+            # An unset filter constrains nothing, so only a differing value separates them
+            if not all(
+                (a := first.get(key)) is None
+                or (b := second.get(key)) is None
+                or a == b
+                for key in (CONF_MANUFACTURER, CONF_PRODUCT)
+            ):
+                continue
+
+            raise cv.Invalid(
+                f"USB configs overlap: {first[CONF_ID]!r}, {second[CONF_ID]!r}"
+            )
+    return configs


 def _set_max_packet_size(config: dict) -> dict:
@@ -72,7 +113,9 @@ CONFIG_SCHEMA = cv.All(
            cv.Optional(CONF_MAX_PACKET_SIZE, default=64): cv.one_of(
                64, 128, 256, 512, 1024, int=True
            ),
-            cv.Optional(CONF_DEVICES): cv.ensure_list(usb_device_schema()),
+            cv.Optional(CONF_DEVICES): cv.All(
+                cv.ensure_list(usb_device_schema()), validate_usb_clients
+            ),
        }
    ),
    only_on_variant(
@@ -91,6 +134,10 @@ CONFIG_SCHEMA = cv.All(
 async def register_usb_client(config: ConfigType) -> MockObj:
    var = cg.new_Pvariable(config[CONF_ID], config[CONF_VID], config[CONF_PID])
    await cg.register_component(var, config)
+    if (manufacturer := config.get(CONF_MANUFACTURER)) is not None:
+        cg.add(var.set_manufacturer_filter(manufacturer))
+    if (product := config.get(CONF_PRODUCT)) is not None:
+        cg.add(var.set_product_filter(product))
    return var


@@ -5,6 +5,7 @@
    defined(USE_ESP32_VARIANT_ESP32S31) || defined(USE_ESP32_VARIANT_ESP32H4)
 #include "esphome/core/defines.h"
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
 #include <vector>
 #include "usb/usb_host.h"
 #include <freertos/FreeRTOS.h>
@@ -12,6 +13,7 @@
 #include "esphome/core/lock_free_queue.h"
 #include "esphome/core/event_pool.h"
 #include <atomic>
+#include <span>

 namespace esphome::usb_host {

@@ -117,6 +119,24 @@ struct UsbEvent {

 // callback function type.

+// USB string descriptors hold at most 126 characters; one more for the terminator
+static constexpr size_t DESC_STRING_BUF_SIZE = 128;
+
+/// Identity of a connected USB device, copied out of the descriptors the USB host
+/// stack caches for the lifetime of the connection
+struct UsbDeviceInfo {
+  uint16_t vendor_id;
+  uint16_t product_id;
+  uint16_t bcd_device;
+  char manufacturer[DESC_STRING_BUF_SIZE];
+  char product[DESC_STRING_BUF_SIZE];
+  char serial_number[DESC_STRING_BUF_SIZE];
+};
+
+/// Copy a USB string descriptor into a NUL-terminated buffer, dropping characters outside
+/// Latin-1. A missing descriptor copies as an empty string.
+void copy_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer);
+
 enum ClientState {
  USB_CLIENT_INIT = 0,
  USB_CLIENT_OPEN,
@@ -144,6 +164,32 @@ class USBClient : public Component {
  bool control_transfer(uint8_t type, uint8_t request, uint16_t value, uint16_t index, const transfer_cb_t &callback,
                        const std::vector<uint8_t> &data = {});

+  /// Copy the connected device's identity out of the cached USB descriptors.
+  /// Returns false when no device is connected.
+  bool get_device_info(UsbDeviceInfo &info) const;
+
+  /// Read a string descriptor the host stack does not cache, an interface string say, into
+  /// buffer. Uses a transfer of its own: the pooled ones hold one packet, and a string
+  /// descriptor can be four times that. The callback runs on the USB task once buffer holds
+  /// the string (empty on failure). Returns false when nothing was started. One read at a
+  /// time; main loop only.
+  bool read_string_descriptor(uint8_t index, std::span<char, DESC_STRING_BUF_SIZE> buffer,
+                              const transfer_cb_t &callback);
+
+  /// Narrow which device this client claims, beyond the VID/PID it was constructed
+  /// with, by requiring a descriptor string to match exactly.
+  void set_manufacturer_filter(const char *manufacturer) { this->manufacturer_filter_ = manufacturer; }
+  void set_product_filter(const char *product) { this->product_filter_ = product; }
+
+  /// Register a callback for the device this client claims being connected (true) or
+  /// removed (false). Fires only for a device that passed every filter and was fully
+  /// opened, so a device another client claims is never reported. Called from the main
+  /// loop: connected once the device is ready to use (a subclass may hold this back until
+  /// its own setup of the device has finished), removed after on_disconnected() has run.
+  template<typename F> void add_on_connection_callback(F &&callback) {
+    this->connection_callback_.add(std::forward<F>(callback));
+  }
+
  // Lock-free event queue and pool for USB task to main loop communication
  // Must be public for access from static callbacks
  LockFreeQueue<UsbEvent, USB_EVENT_QUEUE_SIZE> event_queue;
@@ -161,11 +207,23 @@ class USBClient : public Component {
  TransferRequest *get_trq_();  // Lock-free allocation using atomic bitmask (multi-consumer safe)
  virtual void disconnect();
  virtual void on_connected() {}
+
+  /// Whether the device's descriptor strings satisfy every filter that is set.
+  bool descriptor_strings_match_(const usb_device_info_t &dev_info) const;
+
+  /// Whether the subclass reports the device as connected itself, once its own setup of
+  /// the device has finished, rather than as soon as the device has been opened
+  virtual bool reports_connection_itself() const { return false; }
+  /// Report the claimed device to the connection callbacks. Idempotent; a subclass that
+  /// reports itself calls this once the device is ready to use.
+  void report_connected_();
  virtual void on_disconnected() {
    // Reset all requests to available (all bits to 0)
    this->trq_in_use_.store(0);
  }

+  static void string_descriptor_callback(usb_transfer_t *xfer);
+
  // USB task management
  static void usb_task_fn(void *arg);
  [[noreturn]] void usb_task_loop_() const;
@@ -173,6 +231,11 @@ class USBClient : public Component {
  // Members ordered to minimize struct padding on 32-bit platforms
  TransferRequest requests_[MAX_REQUESTS]{};
  TaskHandle_t usb_task_handle_{nullptr};
+  // Dedicated transfer for read_string_descriptor(), allocated on first use and kept
+  usb_transfer_t *string_transfer_{nullptr};
+  transfer_cb_t string_callback_;
+  char *string_buffer_{nullptr};
+  std::atomic<bool> string_read_busy_{false};
  usb_host_client_handle_t handle_{};
  usb_device_handle_t device_handle_{};
  int device_addr_{-1};
@@ -181,8 +244,15 @@ class USBClient : public Component {
  // Bit i = 1: requests_[i] is in use, Bit i = 0: requests_[i] is available
  // Supports multiple concurrent consumers and producers (both threads can allocate/deallocate)
  std::atomic<trq_bitmask_t> trq_in_use_;
+  LazyCallbackManager<void(bool)> connection_callback_;
+  // Descriptor strings a device must report to be claimed; nullptr means no constraint
+  const char *manufacturer_filter_{nullptr};
+  const char *product_filter_{nullptr};
  uint16_t vid_{};
  uint16_t pid_{};
+  // Whether the connection callbacks were told about the current device, so a removal is
+  // only ever reported for a device that was reported connected
+  bool connection_reported_{false};
 };
 class USBHost final : public Component {
 public:
@@ -143,10 +143,8 @@ static void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc
  } while (next_desc != NULL);
 }
 #endif
-// USB string descriptors: bLength (uint8_t, max 255) includes the 2-byte header (bLength and bDescriptorType).
-// Character count = (bLength - 2) / 2, max 126 chars + null terminator.
-static constexpr size_t DESC_STRING_BUF_SIZE = 128;
-
+// bLength (uint8_t, max 255) includes the 2-byte header (bLength and bDescriptorType),
+// so character count = (bLength - 2) / 2.
 static const char *get_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer) {
  if (desc == nullptr || desc->bLength < 2)
    return "(unspecified)";
@@ -162,6 +160,127 @@ static const char *get_descriptor_string(const usb_str_desc_t *desc, std::span<c
  return buffer.data();
 }

+// A missing descriptor copies as an empty string, unlike the "(unspecified)"
+// placeholder the logging helper above uses
+void copy_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer) {
+  buffer[0] = '\0';
+  if (desc == nullptr || desc->bLength < 2)
+    return;
+  int char_count = (desc->bLength - 2) / 2;
+  char *p = buffer.data();
+  char *end = p + buffer.size() - 1;
+  for (int i = 0; i != char_count && p < end; i++) {
+    auto c = desc->wData[i];
+    if (c < 0x100)
+      *p++ = static_cast<char>(c);
+  }
+  *p = '\0';
+}
+
+// Descriptor strings are UTF-16, so a character above Latin-1 can never match.
+static bool descriptor_string_equals(const usb_str_desc_t *desc, const char *expected) {
+  const int char_count = (desc == nullptr || desc->bLength < 2) ? 0 : (desc->bLength - 2) / 2;
+  for (int i = 0; i != char_count; i++) {
+    const uint16_t c = desc->wData[i];
+    if (c >= 0x100 || expected[i] == '\0' || static_cast<char>(c) != expected[i])
+      return false;
+  }
+  return expected[char_count] == '\0';
+}
+
+bool USBClient::descriptor_strings_match_(const usb_device_info_t &dev_info) const {
+  if (this->manufacturer_filter_ != nullptr &&
+      !descriptor_string_equals(dev_info.str_desc_manufacturer, this->manufacturer_filter_))
+    return false;
+  if (this->product_filter_ != nullptr && !descriptor_string_equals(dev_info.str_desc_product, this->product_filter_))
+    return false;
+  return true;
+}
+
+bool USBClient::get_device_info(UsbDeviceInfo &info) const {
+  if (this->state_ != USB_CLIENT_CONNECTED)
+    return false;
+  const usb_device_desc_t *desc;
+  if (usb_host_get_device_descriptor(this->device_handle_, &desc) != ESP_OK)
+    return false;
+  info.vendor_id = desc->idVendor;
+  info.product_id = desc->idProduct;
+  info.bcd_device = desc->bcdDevice;
+  usb_device_info_t dev_info;
+  if (usb_host_device_info(this->device_handle_, &dev_info) != ESP_OK)
+    return false;
+  copy_descriptor_string(dev_info.str_desc_manufacturer, info.manufacturer);
+  copy_descriptor_string(dev_info.str_desc_product, info.product);
+  copy_descriptor_string(dev_info.str_desc_serial_num, info.serial_number);
+  return true;
+}
+
+static constexpr size_t MAX_STRING_DESC_SIZE = 255;  // bLength is one byte
+static constexpr uint16_t LANGID_EN_US = 0x0409;
+
+// CALLBACK CONTEXT: USB task
+void USBClient::string_descriptor_callback(usb_transfer_t *xfer) {
+  auto *client = static_cast<USBClient *>(xfer->context);
+  TransferStatus status{};
+  status.error_code = xfer->status;
+  status.success = xfer->status == USB_TRANSFER_STATUS_COMPLETED;
+  status.endpoint = xfer->bEndpointAddress;
+  // The buffer starts with the setup packet; the descriptor follows it
+  status.data = xfer->data_buffer + SETUP_PACKET_SIZE;
+  status.data_len =
+      xfer->actual_num_bytes > static_cast<int>(SETUP_PACKET_SIZE) ? xfer->actual_num_bytes - SETUP_PACKET_SIZE : 0;
+  const auto *desc = reinterpret_cast<const usb_str_desc_t *>(status.data);
+  // A short read leaves bLength claiming bytes that never arrived; treat it as missing
+  const bool complete = status.success && status.data_len >= 2 && desc->bLength <= status.data_len;
+  copy_descriptor_string(complete ? desc : nullptr,
+                         std::span<char, DESC_STRING_BUF_SIZE>(client->string_buffer_, DESC_STRING_BUF_SIZE));
+  client->string_read_busy_.store(false);
+  if (client->string_callback_ != nullptr) {
+    client->string_callback_(status);
+  }
+}
+
+bool USBClient::read_string_descriptor(uint8_t index, std::span<char, DESC_STRING_BUF_SIZE> buffer,
+                                       const transfer_cb_t &callback) {
+  buffer[0] = '\0';
+  if (this->state_ != USB_CLIENT_CONNECTED || index == 0) {
+    return false;
+  }
+  if (this->string_transfer_ == nullptr) {
+    if (usb_host_transfer_alloc(SETUP_PACKET_SIZE + MAX_STRING_DESC_SIZE, 0, &this->string_transfer_) != ESP_OK) {
+      ESP_LOGE(TAG, "String descriptor transfer alloc failed");
+      return false;
+    }
+    this->string_transfer_->context = this;
+    this->string_transfer_->callback = string_descriptor_callback;
+  }
+  bool idle = false;
+  if (!this->string_read_busy_.compare_exchange_strong(idle, true)) {
+    ESP_LOGW(TAG, "String descriptor read already in progress");
+    return false;
+  }
+  auto *setup = reinterpret_cast<usb_setup_packet_t *>(this->string_transfer_->data_buffer);
+  setup->bmRequestType = USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
+  setup->bRequest = USB_B_REQUEST_GET_DESCRIPTOR;
+  setup->wValue = (USB_B_DESCRIPTOR_TYPE_STRING << 8) | index;
+  // The host stack read the device strings in US English; Linux asks for it first as well,
+  // so all three report the same text
+  setup->wIndex = LANGID_EN_US;
+  setup->wLength = MAX_STRING_DESC_SIZE;
+  this->string_transfer_->num_bytes = SETUP_PACKET_SIZE + MAX_STRING_DESC_SIZE;
+  this->string_transfer_->bEndpointAddress = USB_DIR_IN;
+  this->string_transfer_->device_handle = this->device_handle_;
+  this->string_buffer_ = buffer.data();
+  this->string_callback_ = callback;
+  auto err = usb_host_transfer_submit_control(this->handle_, this->string_transfer_);
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "Failed to submit string descriptor read, err=%s", esp_err_to_name(err));
+    this->string_read_busy_.store(false);
+    return false;
+  }
+  return true;
+}
+
 // CALLBACK CONTEXT: USB task (called from usb_host_client_handle_events in USB task)
 static void client_event_cb(const usb_host_client_event_msg_t *event_msg, void *ptr) {
  auto *client = static_cast<USBClient *>(ptr);
@@ -302,12 +421,10 @@ void USBClient::handle_open_state_() {
    return;
  }
  ESP_LOGD(TAG, "Device descriptor: vid %X pid %X", desc->idVendor, desc->idProduct);
-  if (desc->idVendor != this->vid_ || desc->idProduct != this->pid_) {
-    if (this->vid_ != 0 || this->pid_ != 0) {
-      ESP_LOGD(TAG, "Not our device, closing");
-      this->disconnect();
-      return;
-    }
+  if ((this->vid_ != 0 && desc->idVendor != this->vid_) || (this->pid_ != 0 && desc->idProduct != this->pid_)) {
+    ESP_LOGD(TAG, "Not our device, closing");
+    this->disconnect();
+    return;
  }
  usb_device_info_t dev_info;
  err = usb_host_device_info(this->device_handle_, &dev_info);
@@ -316,6 +433,16 @@ void USBClient::handle_open_state_() {
    this->disconnect();
    return;
  }
+  // Scoped so the buffers do not outlive this cold branch
+  if (!this->descriptor_strings_match_(dev_info)) {
+    char buf_manuf[DESC_STRING_BUF_SIZE];
+    char buf_product[DESC_STRING_BUF_SIZE];
+    ESP_LOGD(TAG, "Device does not match filter, closing. Manuf: %s; Prod: %s",
+             get_descriptor_string(dev_info.str_desc_manufacturer, buf_manuf),
+             get_descriptor_string(dev_info.str_desc_product, buf_product));
+    this->disconnect();
+    return;
+  }
  this->state_ = USB_CLIENT_CONNECTED;
  char buf_manuf[DESC_STRING_BUF_SIZE];
  char buf_product[DESC_STRING_BUF_SIZE];
@@ -336,6 +463,18 @@ void USBClient::handle_open_state_() {
    usb_client_print_config_descriptor(config_desc, nullptr);
 #endif
  this->on_connected();
+  // on_connected() may have rejected the device (no usable interface, say) and closed it
+  if (this->state_ == USB_CLIENT_CONNECTED && !this->reports_connection_itself()) {
+    this->report_connected_();
+  }
+}
+
+void USBClient::report_connected_() {
+  if (this->state_ != USB_CLIENT_CONNECTED || this->connection_reported_) {
+    return;
+  }
+  this->connection_reported_ = true;
+  this->connection_callback_.call(true);
 }

 void USBClient::on_opened(uint8_t addr) {
@@ -406,6 +545,10 @@ TransferRequest *USBClient::get_trq_() {
 }

 void USBClient::disconnect() {
+  // Also reached for a device this client opened and then declined, or lost before it was
+  // ready; neither was reported as connected, so neither is reported as removed
+  const bool was_reported = this->connection_reported_;
+  this->connection_reported_ = false;
  this->on_disconnected();
  auto err = usb_host_device_close(this->handle_, this->device_handle_);
  if (err != ESP_OK) {
@@ -414,6 +557,9 @@ void USBClient::disconnect() {
  this->state_ = USB_CLIENT_INIT;
  this->device_handle_ = nullptr;
  this->device_addr_ = -1;
+  if (was_reported) {
+    this->connection_callback_.call(false);
+  }
 }

 // THREAD CONTEXT: Called from main loop thread only
@@ -557,6 +703,12 @@ void USBClient::dump_config() {
                "  Vendor id %04X\n"
                "  Product id %04X",
                this->vid_, this->pid_);
+  if (this->manufacturer_filter_ != nullptr) {
+    ESP_LOGCONFIG(TAG, "  Manufacturer %s", this->manufacturer_filter_);
+  }
+  if (this->product_filter_ != nullptr) {
+    ESP_LOGCONFIG(TAG, "  Product %s", this->product_filter_);
+  }
 }
 // THREAD CONTEXT: Called from both USB task and main loop threads
 // - USB task: Immediately after transfer callback completes
@@ -6,6 +6,7 @@ from esphome.components.usb_host import (
    get_max_packet_size,
    register_usb_client,
    usb_device_schema,
+    validate_usb_clients,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -16,7 +17,7 @@ from esphome.const import (
    CONF_DUMMY_RECEIVER,
    CONF_ID,
 )
-from esphome.core import CORE
+from esphome.core import CORE, ID
 from esphome.cpp_types import Component
 from esphome.types import ConfigType

@@ -27,6 +28,16 @@ usb_uart_ns = cg.esphome_ns.namespace("usb_uart")
 USBUartComponent = usb_uart_ns.class_("USBUartComponent", Component)
 USBUartChannel = usb_uart_ns.class_("USBUartChannel", UARTComponent)

+
+def is_usb_uart_channel(uart_id: ID, full_config: ConfigType) -> bool:
+    """Return True if the given ID refers to a channel of a configured usb_uart device."""
+    return any(
+        channel[CONF_ID] == uart_id
+        for device in full_config.get("usb_uart") or []
+        for channel in device[CONF_CHANNELS]
+    )
+
+
 UARTParityOptions = usb_uart_ns.enum("UARTParityOptions")
 UART_PARITY_OPTIONS = {
    "NONE": UARTParityOptions.UART_CONFIG_PARITY_NONE,
@@ -144,16 +155,19 @@ def channel_schema(type_: "Type") -> cv.Schema:
    )


-CONFIG_SCHEMA = cv.ensure_list(
-    cv.typed_schema(
-        {
-            it.name: usb_device_schema(it.cls, it.vid, it.pid).extend(
-                channel_schema(it)
-            )
-            for it in uart_types
-        },
-        upper=True,
-    )
+CONFIG_SCHEMA = cv.All(
+    cv.ensure_list(
+        cv.typed_schema(
+            {
+                it.name: usb_device_schema(it.cls, it.vid, it.pid).extend(
+                    channel_schema(it)
+                )
+                for it in uart_types
+            },
+            upper=True,
+        )
+    ),
+    validate_usb_clients,
 )


@@ -88,10 +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;
    }
+    // No communication interface: the data interface is the one a host binds to
    if (in_ep->bEndpointAddress & usb_host::USB_DIR_IN) {
-      cdc_devs.push_back({CdcEps{nullptr, in_ep, out_ep, data_desc->bInterfaceNumber}});
+      cdc_devs.push_back({CdcEps{nullptr, in_ep, out_ep, data_desc->bInterfaceNumber, 0xFF, 0, data_desc->iInterface}});
    } else {
-      cdc_devs.push_back({CdcEps{nullptr, out_ep, in_ep, data_desc->bInterfaceNumber}});
+      cdc_devs.push_back({CdcEps{nullptr, out_ep, in_ep, data_desc->bInterfaceNumber, 0xFF, 0, data_desc->iInterface}});
    }
  }
  return cdc_devs;
@@ -217,6 +217,9 @@ 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_string_index = intf_desc->iInterface;
+  // No communication interface: the data interface is the one a host binds to
+  eps.interrupt_interface_number = 0xFF;
  return eps;
 }

@@ -189,7 +189,8 @@ 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});
+      cdc_devs.push_back(CdcEps{notify_ep, in_ep, out_ep, intf->bInterfaceNumber, intf->bInterfaceNumber,
+                                intf->iInterface, intf->iInterface});
      break;  // PL2303 is single-port
    }
  }
@@ -43,14 +43,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_string_index = intf_desc->iInterface;
      } 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_string_index = intf_desc->iInterface;
      } 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_string_index = intf_desc->iInterface;
      } else {
        ESP_LOGE(TAG, "Unexpected endpoint attributes: %02X", ep->bmAttributes);
        continue;
@@ -242,7 +245,7 @@ void USBUartComponent::loop() {
    this->chunk_pool_.release(chunk);

    // Invoke the RX callback (if registered) immediately after data lands in the
-    // ring buffer.  This lets consumers such as ZigbeeProxy process incoming bytes
+    // ring buffer.  This lets consumers such as ZigbeeProxyTap process incoming bytes
    // in the same loop iteration they are delivered, avoiding an extra wakeup cycle.
    if (channel->rx_callback_) {
      channel->rx_callback_();
@@ -481,6 +484,7 @@ void USBUartTypeCdcAcm::on_disconnected() {
    channel->input_started_.store(true);
    channel->output_started_.store(true);
    channel->input_buffer_.clear();
+    channel->interface_string_[0] = '\0';
    // Drain any pending output chunks and return them to the pool
    {
      UsbOutputChunk *chunk;
@@ -559,11 +563,38 @@ void USBUartComponent::start_config_(bool reload) {
  this->cfg_step_ = 0;
  this->cfg_ok_ = true;
  this->cfg_in_flight_ = false;
+  this->cfg_string_done_ = false;
+  this->cfg_string_in_flight_ = false;
  this->cfg_done_.store(false);
  this->cfg_active_ = true;
  this->enable_loop();
 }

+bool USBUartComponent::fetch_interface_string_(USBUartChannelBase *channel) {
+  const CdcEps &eps = channel->cdc_dev_;
+  const uint8_t index =
+      eps.interrupt_interface_number != 0xFF ? eps.interrupt_interface_string_index : eps.bulk_interface_string_index;
+  channel->interface_string_[0] = '\0';
+  if (index == 0) {
+    return false;
+  }
+  this->cfg_done_.store(false);
+  const bool submitted =
+      this->read_string_descriptor(index, channel->interface_string_, [this](const usb_host::TransferStatus &status) {
+        if (!status.success) {
+          ESP_LOGW(TAG, "Interface string read failed: %s", esp_err_to_name(status.error_code));
+        }
+        // Release: publishes the string before the loop observes cfg_done_.
+        this->cfg_done_.store(true, std::memory_order_release);
+        this->enable_loop_soon_any_context();
+        App.wake_loop_threadsafe();
+      });
+  if (!submitted) {
+    ESP_LOGW(TAG, "Interface string read submit failed");
+  }
+  return submitted;
+}
+
 void USBUartComponent::config_transfer_(uint8_t type, uint8_t request, uint16_t value, uint16_t index,
                                        const std::vector<uint8_t> &data) {
  this->cfg_done_.store(false);
@@ -597,6 +628,14 @@ bool USBUartComponent::run_config_machine_() {
  if (!this->cfg_active_)
    return false;

+  if (this->cfg_string_in_flight_) {
+    // Acquire: pairs with the release in fetch_interface_string_'s callback.
+    if (!this->cfg_done_.load(std::memory_order_acquire))
+      return false;
+    this->cfg_string_in_flight_ = false;
+    this->cfg_done_.store(false);
+  }
+
  if (this->cfg_in_flight_) {
    // Acquire: pairs with the release in config_transfer_'s callback.
    if (!this->cfg_done_.load(std::memory_order_acquire))
@@ -627,6 +666,16 @@ bool USBUartComponent::run_config_machine_() {
          ? this->cfg_single_
          : (this->cfg_channel_idx_ < this->channels_.size() ? this->channels_[this->cfg_channel_idx_] : nullptr);

+  // Once per channel on init, before its settings: the interface string is part of the
+  // identity reported to clients, and the connected report waits for this machine.
+  if (channel != nullptr && !this->cfg_reload_ && !this->cfg_string_done_) {
+    this->cfg_string_done_ = true;
+    if (this->fetch_interface_string_(channel)) {
+      this->cfg_string_in_flight_ = true;
+      return true;
+    }
+  }
+
  if (channel != nullptr && channel->initialised_.load()) {
    if (!this->cfg_ok_) {
      // A previous step in this channel's sequence failed. Abort the rest. On a full init,
@@ -650,11 +699,14 @@ bool USBUartComponent::run_config_machine_() {
  // Advance to the next channel (or finish).
  this->cfg_step_ = 0;
  this->cfg_ok_ = true;
+  this->cfg_string_done_ = false;
  if (this->cfg_single_ != nullptr) {
    this->cfg_active_ = false;
    this->cfg_single_ = nullptr;
  } else if (++this->cfg_channel_idx_ >= this->channels_.size()) {
    this->cfg_active_ = false;
+    // Init is done and the line settings are on the wire: now the device is ready to use
+    this->report_connected_();
  }

  // If the machine just went idle and a reload was requested while it was busy, start it now.
@@ -37,6 +37,9 @@ struct CdcEps {
  // Also the wIndex target for CDC class requests (SET_LINE_CODING etc.), so it
  // must remain valid even when the interface itself is not claimed.
  uint8_t interrupt_interface_number;
+  // iInterface of each interface; 0 when the device provides no string for it
+  uint8_t interrupt_interface_string_index;
+  uint8_t bulk_interface_string_index;
  bool interrupt_interface_claimed{false};
 };

@@ -163,15 +166,30 @@ class USBUartChannelBase : public uart::UARTComponent, public Parented<USBUartCo

  /// Register a callback invoked immediately after data is pushed to the input ring buffer.
  /// Called from USBUartComponent::loop() in the main loop context.
-  /// Allows consumers (e.g. ZigbeeProxy) to process bytes in the same loop iteration
+  /// Allows consumers (e.g. ZigbeeProxyTap) to process bytes in the same loop iteration
  /// they arrive, eliminating one full main-loop-wakeup cycle of latency.
  void set_rx_callback(std::function<void()> cb) { this->rx_callback_ = std::move(cb); }

+  /// Channel index on the bridge
+  uint8_t get_index() const { return this->index_; }
+
+  /// USB interface number a host driver binds to for this channel: the communication
+  /// interface of a CDC ACM function, otherwise the data interface.
+  uint8_t get_interface_number() const {
+    return this->cdc_dev_.interrupt_interface_number != 0xFF ? this->cdc_dev_.interrupt_interface_number
+                                                             : this->cdc_dev_.bulk_interface_number;
+  }
+
+  /// iInterface string of that interface; empty when the device has none, or until it has
+  /// been read after the device connected
+  const char *get_interface_string() const { return this->interface_string_; }
+
 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) {}
  void check_logger_conflict() override {}
  // Larger structures first (8+ bytes)
+  char interface_string_[usb_host::DESC_STRING_BUF_SIZE]{};
  RingBuffer input_buffer_;
  LockFreeQueue<UsbOutputChunk, USB_OUTPUT_CHUNK_COUNT> output_queue_;
  // Pool sized to queue capacity (SIZE-1) because LockFreeQueue<T,N> is a ring
@@ -241,6 +259,9 @@ class USBUartComponent : public usb_host::USBClient {
  void start_config_(bool reload);
  // Advance the config state machine; called from loop(). Returns true if it did work.
  bool run_config_machine_();
+  // Ask the device for the channel's interface string. Returns true when a transfer was
+  // submitted; its completion is signalled through cfg_done_ like a config step's.
+  bool fetch_interface_string_(USBUartChannelBase *channel);

  // Per-subclass per-channel settings sequence. For the given zero-based step, issue the
  // next control transfer via config_transfer_() and return true, or return false when the
@@ -252,6 +273,10 @@ class USBUartComponent : public usb_host::USBClient {
  // (e.g. CH34x chip detection). Same contract as config_step_(). Default: no steps.
  virtual bool config_device_step(uint8_t step, bool ok, const uint8_t *response) { return false; }

+  // The device is only usable once the config machine has applied every channel's line
+  // settings, so the connected report waits for run_config_machine_() to finish the init
+  bool reports_connection_itself() const override { return true; }
+
  std::vector<USBUartChannelBase *> channels_{};

  // Config state machine
@@ -266,6 +291,8 @@ class USBUartComponent : public usb_host::USBClient {
  bool cfg_device_phase_{false};
  bool cfg_in_flight_{false};
  bool cfg_ok_{true};
+  bool cfg_string_done_{false};
+  bool cfg_string_in_flight_{false};
 };

 class USBUartTypeCdcAcm : public USBUartComponent {
@@ -0,0 +1,47 @@
+import esphome.codegen as cg
+from esphome.components import serial_proxy
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_POWER_SAVE_MODE, CONF_WIFI
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@kbx81"]
+DEPENDENCIES = ["serial_proxy"]
+
+CONF_SERIAL_PROXY_ID = "serial_proxy_id"
+
+zigbee_proxy_tap_ns = cg.esphome_ns.namespace("zigbee_proxy_tap")
+ZigbeeProxyTap = zigbee_proxy_tap_ns.class_(
+    "ZigbeeProxyTap", cg.Component, serial_proxy.SerialProxyTap
+)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    full_config = fv.full_config.get()
+    if (wifi_conf := full_config.get(CONF_WIFI)) and (
+        wifi_conf.get(CONF_POWER_SAVE_MODE, "").lower() != "none"
+    ):
+        raise cv.Invalid(
+            f"{CONF_WIFI} {CONF_POWER_SAVE_MODE} must be set to 'none' when using Zigbee proxy"
+        )
+    return config
+
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(ZigbeeProxyTap),
+        cv.Required(CONF_SERIAL_PROXY_ID): cv.use_id(serial_proxy.SerialProxy),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    sp = await cg.get_variable(config[CONF_SERIAL_PROXY_ID])
+    var = cg.new_Pvariable(config[CONF_ID], sp)
+    await cg.register_component(var, config)
+
+    cg.add_define("USE_ZIGBEE_PROXY_TAP")
+    # Compiles the tap interface into serial_proxy; without it the port is a plain byte pipe
+    cg.add_define("USE_SERIAL_PROXY_TAP")
@@ -0,0 +1,250 @@
+#include "ash_detector.h"
+
+#ifdef USE_ZIGBEE_PROXY_TAP
+
+namespace esphome::zigbee_proxy_tap {
+
+// Control byte of an RSTACK, and the only ASH version byte that can follow it
+static constexpr uint8_t ASH_RSTACK_CONTROL = 0xC1;
+static constexpr uint8_t ASH_PROTOCOL_VERSION = 0x02;
+static constexpr size_t ASH_RSTACK_BODY_SIZE = 3;  // control, version, reset code
+static constexpr size_t ASH_CRC_SIZE = 2;
+// Smallest legal frame on the wire: a bare control byte plus its CRC
+static constexpr size_t ASH_MIN_FRAME_SIZE = 1 + ASH_CRC_SIZE;
+
+// The opening EZSP version command is a constant: control 0x00 (frmNum 0, ackNum 0)
+// followed by [seq=0][frameControl=0][frameId=0] randomized by 0x42 0x21 0xA8. Only the
+// trailing requested-version byte varies, so the first four bytes pin the frame exactly.
+static constexpr uint8_t EZSP_VERSION_CMD_PREFIX[] = {0x00, 0x42, 0x21, 0xA8};
+static constexpr size_t EZSP_VERSION_CMD_SIZE = 5;
+
+// Consecutive frames we could not accept, with neither a good frame nor a retransmission
+// in between, before concluding the peer is no longer speaking ASH. A real ASH peer must
+// retransmit an unacknowledged frame, so the absence of one is the positive evidence
+// here -- garbage on the line is not, since noise proves nothing either way.
+static constexpr uint8_t MAX_UNCONFIRMED_REJECTS = 4;
+
+static bool ash_reset_code_is_known(uint8_t code) {
+  switch (code) {
+    case 0x00:  // RESET_UNKNOWN
+    case 0x01:  // RESET_EXTERNAL
+    case 0x02:  // RESET_POWER_ON
+    case 0x03:  // RESET_WATCHDOG
+    case 0x06:  // RESET_ASSERT
+    case 0x09:  // RESET_BOOTLOADER
+    case 0x0B:  // RESET_SOFTWARE
+    case 0x51:  // ERROR_EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT
+    case 0x80:  // ERROR_CHIP_SPECIFIC
+    case 0x81:  // RESET_CHIP_SPECIFIC
+      return true;
+    default:
+      return false;
+  }
+}
+
+void AshFrameScanner::begin_frame_() {
+  this->index_ = 0;
+  this->crc_ = ASH_CRC_INIT;
+  this->escaped_ = false;
+  this->poisoned_ = false;
+}
+
+void AshFrameScanner::reset() {
+  this->begin_frame_();
+  this->frame_length_ = 0;
+  this->discarding_ = false;
+}
+
+ScanResult AshFrameScanner::feed(uint8_t byte) {
+  if (byte == ASH_FLAG_BYTE) {
+    // Snapshot everything the verdict depends on: begin_frame_() clears all of it.
+    const bool discarding = this->discarding_;
+    const bool poisoned = this->poisoned_;
+    const bool escaped = this->escaped_;
+    const size_t index = this->index_;
+    const uint16_t crc = this->crc_;
+    // A FLAG always starts the next frame afresh, whatever preceded it
+    this->begin_frame_();
+    this->discarding_ = false;
+
+    if (discarding || index == 0) {
+      // Consecutive delimiters carry no frame at all, so there is nothing to judge
+      this->frame_length_ = 0;
+      return ScanResult::NONE;
+    }
+    // Running the CRC over the body *and* its trailing CRC bytes leaves zero when
+    // correct, so validity needs no second pass over the frame.
+    if (poisoned || escaped || index < ASH_MIN_FRAME_SIZE || crc != 0) {
+      this->frame_length_ = 0;
+      return ScanResult::INVALID;
+    }
+    this->frame_length_ = index - ASH_CRC_SIZE;
+    return ScanResult::FRAME;
+  }
+
+  if (this->discarding_) {
+    return ScanResult::NONE;
+  }
+
+  switch (byte) {
+    case ASH_CANCEL_BYTE:
+      // Everything received since the last FLAG is to be ignored
+      this->begin_frame_();
+      return ScanResult::NONE;
+
+    case ASH_SUBSTITUTE_BYTE:
+      // A low-level error was flagged; ignore everything up to the next FLAG
+      this->discarding_ = true;
+      return ScanResult::NONE;
+
+    case ASH_XON_BYTE:
+    case ASH_XOFF_BYTE:
+      // Transport flow control, not frame content: skip it without disturbing the frame
+      return ScanResult::NONE;
+
+    case ASH_ESCAPE_BYTE:
+      this->escaped_ = true;
+      return ScanResult::NONE;
+
+    default:
+      break;
+  }
+
+  uint8_t value = byte;
+  if (this->escaped_) {
+    this->escaped_ = false;
+    value = byte ^ ASH_XOR_BYTE;
+    // An escape must decode to a reserved byte; anything else is not ASH framing at all
+    if (!ash_is_reserved(value)) {
+      this->poisoned_ = true;
+      return ScanResult::NONE;
+    }
+  }
+
+  if (this->index_ >= sizeof(this->buffer_)) {
+    this->poisoned_ = true;
+    return ScanResult::NONE;
+  }
+
+  this->buffer_[this->index_++] = value;
+  this->crc_ = ash_crc16(&value, 1, this->crc_);
+  return ScanResult::NONE;
+}
+
+void AshDetector::reset() {
+  this->ncp_scanner_.reset();
+  this->host_scanner_.reset();
+  this->state_ = AshDetectState::IDLE;
+  this->rx_sequence_ = 0;
+  this->ack_owed_ = false;
+  this->unconfirmed_rejects_ = 0;
+}
+
+void AshDetector::from_ncp(uint8_t byte) {
+  switch (this->ncp_scanner_.feed(byte)) {
+    case ScanResult::FRAME:
+      this->handle_ncp_frame_();
+      break;
+    case ScanResult::INVALID:
+      // A delimited chunk that is not a frame. While armed this may be a corrupted ASH
+      // frame, which the peer will retransmit, or a sign the peer stopped speaking ASH.
+      // reject_() distinguishes the two by whether a retransmission ever arrives.
+      this->reject_();
+      break;
+    case ScanResult::NONE:
+      break;
+  }
+}
+
+void AshDetector::handle_ncp_frame_() {
+  const uint8_t *body = this->ncp_scanner_.frame();
+  const size_t length = this->ncp_scanner_.length();
+  const uint8_t control = body[0];
+
+  // RSTACK is the only way into the handshake, and the only way back after a firmware
+  // swap: a Spinel or bootloader NCP never emits one, so those stay unarmed forever.
+  if (control == ASH_RSTACK_CONTROL) {
+    if (length == ASH_RSTACK_BODY_SIZE && body[1] == ASH_PROTOCOL_VERSION && ash_reset_code_is_known(body[2])) {
+      this->state_ = AshDetectState::SAW_RSTACK;
+      this->rx_sequence_ = 0;
+      this->ack_owed_ = false;
+      this->unconfirmed_rejects_ = 0;
+    }
+    return;
+  }
+
+  if (this->state_ != AshDetectState::ARMED) {
+    return;
+  }
+
+  if ((control & 0x80) != 0) {
+    return;  // ACK/NAK/RST/ERROR: nothing is owed for these
+  }
+
+  const uint8_t frame_num = (control >> 4) & ASH_MAX_SEQUENCE;
+  const bool re_tx = (control & 0x08) != 0;
+
+  if (frame_num != this->rx_sequence_) {
+    // A retransmission still proves the peer is speaking ASH even though we cannot use
+    // this copy, so it clears the suspicion without being acknowledged.
+    if (re_tx) {
+      this->unconfirmed_rejects_ = 0;
+    } else {
+      this->reject_();
+    }
+    return;
+  }
+
+  this->rx_sequence_ = (this->rx_sequence_ + 1) & ASH_MAX_SEQUENCE;
+  this->pending_ack_ = this->rx_sequence_;
+  this->ack_owed_ = true;
+  this->unconfirmed_rejects_ = 0;
+}
+
+void AshDetector::reject_() {
+  if (this->state_ != AshDetectState::ARMED) {
+    return;
+  }
+  if (++this->unconfirmed_rejects_ >= MAX_UNCONFIRMED_REJECTS) {
+    this->state_ = AshDetectState::IDLE;
+    this->unconfirmed_rejects_ = 0;
+  }
+}
+
+void AshDetector::from_host(uint8_t byte) {
+  if (this->host_scanner_.feed(byte) != ScanResult::FRAME) {
+    return;
+  }
+
+  if (this->state_ != AshDetectState::SAW_RSTACK) {
+    return;
+  }
+
+  const uint8_t *body = this->host_scanner_.frame();
+  if (this->host_scanner_.length() != EZSP_VERSION_CMD_SIZE) {
+    return;
+  }
+  for (size_t i = 0; i < sizeof(EZSP_VERSION_CMD_PREFIX); i++) {
+    if (body[i] != EZSP_VERSION_CMD_PREFIX[i]) {
+      return;
+    }
+  }
+
+  this->state_ = AshDetectState::ARMED;
+  this->rx_sequence_ = 0;
+  this->ack_owed_ = false;
+  this->unconfirmed_rejects_ = 0;
+}
+
+bool AshDetector::take_pending_ack(uint8_t &ack_num) {
+  if (!this->ack_owed_) {
+    return false;
+  }
+  this->ack_owed_ = false;
+  ack_num = this->pending_ack_;
+  return true;
+}
+
+}  // namespace esphome::zigbee_proxy_tap
+
+#endif  // USE_ZIGBEE_PROXY_TAP
@@ -0,0 +1,104 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_ZIGBEE_PROXY_TAP
+
+#include "ash_protocol.h"
+
+#include <cstddef>
+#include <cstdint>
+
+namespace esphome::zigbee_proxy_tap {
+
+// Decides when it is safe to acknowledge NCP frames on a client's behalf.
+//
+// The client suppresses its own ACKs, so nobody else will send them, and injecting ASH
+// bytes into a stream that is not ASH would corrupt it. Detection is therefore one-sided:
+// arm only on the session handshake, which is a fixed byte string, and never on frame
+// validity, which non-ASH traffic can satisfy by luck.
+//
+//   RSTACK  (NCP -> host)   c1 02 <reset_code> <crc> 7e
+//   version (host -> NCP)   00 42 21 a8 <version^0x54> <crc> 7e
+//
+// Requiring both, in that order, in opposite directions cannot be satisfied by a
+// unidirectional byte stream whatever it contains -- which is exactly the situation
+// during a firmware upload. Verified against real .gbl images and real Spinel traffic:
+// zero false arms, and neither pattern occurs even as a substring.
+//
+// Getting it wrong in the other direction is cheap: a frame we decline to acknowledge is
+// retransmitted by the NCP, so we see a clean copy and lose only the ack timeout. That
+// asymmetry is why this errs towards silence everywhere.
+
+enum class AshDetectState : uint8_t {
+  IDLE,        // Not ASH, or not yet proven to be
+  SAW_RSTACK,  // Handshake half-complete; watching for the version command
+  ARMED,       // Session confirmed; acknowledging on the client's behalf
+};
+
+enum class ScanResult : uint8_t {
+  NONE,     // Mid-frame, or a delimiter that carried nothing
+  FRAME,    // frame()/length() hold a complete body with a verified CRC
+  INVALID,  // A delimited chunk arrived but was not a well-formed ASH frame
+};
+
+// Reassembles one direction of the byte stream into unstuffed, CRC-checked frames.
+// Mirrors bellows' AshProtocol.data_received: FLAG ends a frame, CANCEL discards what
+// precedes it, SUBSTITUTE poisons everything up to the next FLAG, and XON/XOFF are
+// transport flow control removed without disturbing the frame around them.
+class AshFrameScanner {
+ public:
+  ScanResult feed(uint8_t byte);
+  void reset();
+
+  // Valid only until the next feed() call, which begins overwriting the buffer.
+  const uint8_t *frame() const { return this->buffer_; }
+  size_t length() const { return this->frame_length_; }
+
+ private:
+  void begin_frame_();
+
+  // Frames are bounded by the ASH maximum, so a stream carrying no delimiters cannot
+  // grow the buffer without limit; it just keeps failing.
+  uint8_t buffer_[MAX_ASH_FRAME_SIZE];
+  size_t index_{0};         // accumulation position for the frame being read
+  size_t frame_length_{0};  // body length of the last completed frame
+  uint16_t crc_{ASH_CRC_INIT};
+  bool escaped_{false};
+  bool discarding_{false};
+  bool poisoned_{false};
+};
+
+class AshDetector {
+ public:
+  void reset();
+
+  // Feed observed traffic. Neither call gates forwarding: the detector only watches.
+  void from_ncp(uint8_t byte);
+  void from_host(uint8_t byte);
+
+  bool armed() const { return this->state_ == AshDetectState::ARMED; }
+
+  // True only while the host direction can affect the state machine, i.e. while waiting
+  // for the version command. Lets the caller skip scanning that direction entirely the
+  // rest of the time -- it is the one carrying firmware uploads.
+  bool needs_host_scan() const { return this->state_ == AshDetectState::SAW_RSTACK; }
+
+  // An acknowledgement became owed after the last from_ncp() call. Clears the flag.
+  bool take_pending_ack(uint8_t &ack_num);
+
+ protected:
+  void handle_ncp_frame_();
+  void reject_();
+
+  AshFrameScanner ncp_scanner_;
+  AshFrameScanner host_scanner_;
+  AshDetectState state_{AshDetectState::IDLE};
+  uint8_t rx_sequence_{0};
+  uint8_t pending_ack_{0};
+  uint8_t unconfirmed_rejects_{0};
+  bool ack_owed_{false};
+};
+
+}  // namespace esphome::zigbee_proxy_tap
+
+#endif  // USE_ZIGBEE_PROXY_TAP
@@ -0,0 +1,41 @@
+#include "ash_protocol.h"
+
+namespace esphome::zigbee_proxy_tap {
+
+static const uint16_t CRC_NIBBLE_TABLE[16] = {0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+                                              0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF};
+
+uint16_t ash_crc16(const uint8_t *data, size_t length, uint16_t init) {
+  uint16_t crc = init;
+  for (size_t i = 0; i < length; i++) {
+    crc = static_cast<uint16_t>(crc << 4) ^ CRC_NIBBLE_TABLE[(crc >> 12) ^ (data[i] >> 4)];
+    crc = static_cast<uint16_t>(crc << 4) ^ CRC_NIBBLE_TABLE[(crc >> 12) ^ (data[i] & 0x0F)];
+  }
+  return crc;
+}
+
+// Appends a byte with ASH stuffing; the caller sized `output` for the worst case.
+static void append_byte_stuffed(uint8_t *output, size_t &pos, uint8_t byte) {
+  if (ash_is_reserved(byte)) {
+    output[pos++] = ASH_ESCAPE_BYTE;
+    output[pos++] = byte ^ ASH_XOR_BYTE;
+  } else {
+    output[pos++] = byte;
+  }
+}
+
+size_t ash_build_ack_frame(uint8_t *output, uint8_t ack_num) {
+  // ACK control byte: 100nrPPP, where PPP is the next frame number expected
+  const uint8_t control = 0x80 | (ack_num & ASH_MAX_SEQUENCE);
+  const uint16_t crc = ash_crc16(&control, 1);
+
+  size_t pos = 0;
+  output[pos++] = ASH_FLAG_BYTE;
+  append_byte_stuffed(output, pos, control);
+  append_byte_stuffed(output, pos, (crc >> 8) & 0xFF);
+  append_byte_stuffed(output, pos, crc & 0xFF);
+  output[pos++] = ASH_FLAG_BYTE;
+  return pos;
+}
+
+}  // namespace esphome::zigbee_proxy_tap
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace esphome::zigbee_proxy_tap {
+
+// ASH Protocol Constants
+static constexpr uint8_t ASH_FLAG_BYTE = 0x7E;        // Frame delimiter
+static constexpr uint8_t ASH_ESCAPE_BYTE = 0x7D;      // Escape/substitution byte
+static constexpr uint8_t ASH_XOR_BYTE = 0x20;         // XOR mask for escaped bytes
+static constexpr uint8_t ASH_SUBSTITUTE_BYTE = 0x18;  // Substitution for invalid bytes
+
+static constexpr uint8_t ASH_XON_BYTE = 0x11;     // Resume transmission
+static constexpr uint8_t ASH_XOFF_BYTE = 0x13;    // Pause transmission
+static constexpr uint8_t ASH_CANCEL_BYTE = 0x1A;  // Discards the partial frame before it
+
+// A reserved byte can never appear literally inside a frame; it is escaped as
+// ESCAPE followed by the byte XOR 0x20. Rejecting frames that contain one is what
+// eliminates most non-ASH traffic before its CRC is ever computed: real firmware
+// images and Spinel payloads are dense in 0x11/0x13/0x18/0x1A.
+inline bool ash_is_reserved(uint8_t byte) {
+  return byte == ASH_FLAG_BYTE || byte == ASH_ESCAPE_BYTE || byte == ASH_XON_BYTE || byte == ASH_XOFF_BYTE ||
+         byte == ASH_SUBSTITUTE_BYTE || byte == ASH_CANCEL_BYTE;
+}
+
+// CRC-CCITT (init 0xFFFF, polynomial 0x1021, transmitted big-endian). Note this is a
+// different variant from the Kermit FCS that Spinel/HDLC-lite uses over the same
+// 0x7E framing, so Spinel frames systematically fail this check.
+uint16_t ash_crc16(const uint8_t *data, size_t length, uint16_t init = 0xFFFF);
+
+// ASH bounds a frame's Data Field at 128 bytes, so the largest body a scanner has to
+// hold is that field plus the control byte and the two CRC bytes ahead of the closing
+// delimiter. Byte stuffing happens on the wire only and is undone as bytes arrive, so it
+// does not enlarge this.
+static constexpr size_t ASH_MAX_DATA_FIELD_SIZE = 128;
+static constexpr size_t MAX_ASH_FRAME_SIZE = 1 + ASH_MAX_DATA_FIELD_SIZE + 2;
+
+// Protocol limits
+static constexpr uint8_t ASH_MAX_SEQUENCE = 7;    // 3-bit sequence number (0-7)
+static constexpr uint16_t ASH_CRC_INIT = 0xFFFF;  // CRC-CCITT initial value
+
+// An ACK is FLAG, control byte, two CRC bytes, FLAG. Every byte but the delimiters may
+// need escaping, so the worst case is 2 + 3 * 2 = 8.
+static constexpr size_t ASH_ACK_FRAME_MAX_SIZE = 8;
+
+// Writes an ACK frame for `ack_num` into `output`, which must hold at least
+// ASH_ACK_FRAME_MAX_SIZE bytes, and returns its length.
+size_t ash_build_ack_frame(uint8_t *output, uint8_t ack_num);
+
+}  // namespace esphome::zigbee_proxy_tap
@@ -0,0 +1,71 @@
+#include "zigbee_proxy_tap.h"
+
+#ifdef USE_ZIGBEE_PROXY_TAP
+
+#include "esphome/core/log.h"
+
+namespace esphome::zigbee_proxy_tap {
+
+static const char *const TAG = "zigbee_proxy_tap";
+
+void ZigbeeProxyTap::setup() { this->parent_->set_tap(this); }
+
+void ZigbeeProxyTap::dump_config() { ESP_LOGCONFIG(TAG, "Zigbee Proxy Tap:\n  Port: %s", this->parent_->get_name()); }
+
+void ZigbeeProxyTap::on_device_rx(const uint8_t *data, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    // Observation only: the detector never gates forwarding, so it adds no latency and a
+    // frame it cannot parse still reaches the client, which judges it for itself.
+    this->detector_.from_ncp(data[i]);
+
+    uint8_t ack_num;
+    if (this->detector_.take_pending_ack(ack_num)) {
+      // The client suppresses its own ACKs, so this is the only acknowledgement the NCP
+      // will see. Only ever sent for a frame that passed CRC and arrived in sequence.
+      uint8_t frame[ASH_ACK_FRAME_MAX_SIZE];
+      this->parent_->write_from_tap(frame, ash_build_ack_frame(frame, ack_num));
+      ESP_LOGV(TAG, "Sent ACK for frame %u", ack_num);
+    }
+  }
+
+  const bool armed = this->detector_.armed();
+  if (armed != this->was_armed_) {
+    this->was_armed_ = armed;
+    ESP_LOGD(TAG, "ASH session %s",
+             armed ? LOG_STR_LITERAL("detected, acknowledging frames")
+                   : LOG_STR_LITERAL("lost, no longer acknowledging frames"));
+  }
+}
+
+void ZigbeeProxyTap::on_client_tx(const uint8_t *data, size_t len) {
+  // Scanning this direction only matters while waiting for the version command that
+  // completes the handshake. Outside that window it is skipped entirely -- which is what
+  // makes a firmware upload, all of which flows this way, essentially free.
+  if (!this->detector_.needs_host_scan()) {
+    return;
+  }
+  for (size_t i = 0; i < len; i++) {
+    this->detector_.from_host(data[i]);
+  }
+}
+
+void ZigbeeProxyTap::on_protocol_disabled() {
+  // A client turning protocol handling off is usually about to reflash the radio, so the
+  // handshake we saw says nothing about what will be on the wire next. Forget it: a real
+  // ASH session announces itself again with an RSTACK.
+  this->detector_.reset();
+}
+
+void ZigbeeProxyTap::on_device_disconnected() {
+  // The ASH session died with the NCP's power. Staying armed would acknowledge frames from
+  // whatever boots next, before its own RSTACK has proven it speaks ASH at all.
+  if (this->was_armed_) {
+    ESP_LOGD(TAG, "Device removed, no longer acknowledging frames");
+    this->was_armed_ = false;
+  }
+  this->detector_.reset();
+}
+
+}  // namespace esphome::zigbee_proxy_tap
+
+#endif  // USE_ZIGBEE_PROXY_TAP
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_ZIGBEE_PROXY_TAP
+
+#include "esphome/components/serial_proxy/serial_proxy.h"
+#include "esphome/core/component.h"
+#include "ash_detector.h"
+
+namespace esphome::zigbee_proxy_tap {
+
+// Acknowledges the ASH frames of an EZSP NCP on behalf of a remote client, so the NCP's
+// ack timeout is measured against this device rather than against the network round trip
+// to the client. The client suppresses its own acknowledgements, making these the only
+// ones the NCP sees.
+//
+// It never carries client traffic: the serial proxy owns the port and the bytes, and this
+// component only observes them. The sole exception is the acknowledgement itself, and it
+// is sent only once the handshake has proven the port really is carrying ASH.
+class ZigbeeProxyTap : public serial_proxy::SerialProxyTap, public Component {
+ public:
+  explicit ZigbeeProxyTap(serial_proxy::SerialProxy *parent) : parent_(parent) {}
+
+  void setup() override;
+  void dump_config() override;
+
+  // SerialProxyTap
+  void on_device_rx(const uint8_t *data, size_t len) override;
+  void on_client_tx(const uint8_t *data, size_t len) override;
+  // Acknowledging is only ever useful on a client's behalf, so with nobody subscribed
+  // there is nothing to do and the port need not be read.
+  bool tap_needs_port() const override { return false; }
+  void on_protocol_disabled() override;
+  void on_device_disconnected() override;
+
+ protected:
+  // The port this component observes. Owns the UART and the bytes; every write we make
+  // goes through it.
+  serial_proxy::SerialProxy *parent_;
+
+  // Decides when acknowledging on the client's behalf is safe. Armed only by the ASH
+  // session handshake, so a bootloader or Thread NCP never triggers it.
+  AshDetector detector_;
+
+  // Previous armed state, for logging the transitions
+  bool was_armed_{false};
+};
+
+}  // namespace esphome::zigbee_proxy_tap
+
+#endif  // USE_ZIGBEE_PROXY_TAP
@@ -0,0 +1,47 @@
+import esphome.codegen as cg
+from esphome.components import serial_proxy
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_POWER_SAVE_MODE, CONF_WIFI
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+CODEOWNERS = ["@kbx81"]
+DEPENDENCIES = ["serial_proxy"]
+
+CONF_SERIAL_PROXY_ID = "serial_proxy_id"
+
+zwave_proxy_tap_ns = cg.esphome_ns.namespace("zwave_proxy_tap")
+ZWaveProxyTap = zwave_proxy_tap_ns.class_(
+    "ZWaveProxyTap", cg.Component, serial_proxy.SerialProxyTap
+)
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    full_config = fv.full_config.get()
+    if (wifi_conf := full_config.get(CONF_WIFI)) and (
+        wifi_conf.get(CONF_POWER_SAVE_MODE, "").lower() != "none"
+    ):
+        raise cv.Invalid(
+            f"{CONF_WIFI} {CONF_POWER_SAVE_MODE} must be set to 'none' when using Z-Wave proxy"
+        )
+    return config
+
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(ZWaveProxyTap),
+        cv.Required(CONF_SERIAL_PROXY_ID): cv.use_id(serial_proxy.SerialProxy),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    sp = await cg.get_variable(config[CONF_SERIAL_PROXY_ID])
+    var = cg.new_Pvariable(config[CONF_ID], sp)
+    await cg.register_component(var, config)
+
+    cg.add_define("USE_ZWAVE_PROXY_TAP")
+    # Compiles the tap interface into serial_proxy; without it the port is a plain byte pipe
+    cg.add_define("USE_SERIAL_PROXY_TAP")
@@ -0,0 +1,166 @@
+#include "zwave_detector.h"
+
+#ifdef USE_ZWAVE_PROXY_TAP
+
+namespace esphome::zwave_proxy_tap {
+
+// Consecutive malformed frames, with no well-formed one in between, before concluding the
+// controller is no longer speaking the Serial API. Repeated checksum failures mean our
+// idea of where frames begin is wrong, and acknowledging frames we are misreading is
+// worse than acknowledging none, so the safe move is to stop and wait to be convinced
+// again. A well-formed frame is the evidence that clears the suspicion; garbage is not,
+// since noise proves nothing either way.
+static constexpr uint8_t MAX_UNCONFIRMED_REJECTS = 4;
+
+// Abandons a frame that stalled part-received, and time-stamps the batch about to be fed.
+static void expire_stalled_frame(ZWaveFrameScanner &scanner, uint32_t &frame_start, uint32_t now) {
+  if (scanner.in_frame()) {
+    if (now - frame_start <= ZWAVE_FRAME_TIMEOUT_MS) {
+      return;  // Still within its window; keep the start time it already has
+    }
+    scanner.reset();
+  }
+  frame_start = now;
+}
+
+ScanResult ZWaveFrameScanner::feed(uint8_t byte) {
+  switch (this->state_) {
+    case ScanState::WAIT_SOF:
+      // ACK/NAK/CAN and anything else carry no framing, so there is nothing to reassemble
+      if (byte == ZWAVE_SOF_BYTE) {
+        this->state_ = ScanState::WAIT_LENGTH;
+      }
+      return ScanResult::NONE;
+
+    case ScanState::WAIT_LENGTH:
+      if (byte < ZWAVE_MIN_LENGTH) {
+        // Not a length the protocol can produce. A 0x01 in this position is far more
+        // likely to be the real start of a frame than a length, so treat it as one.
+        this->state_ = byte == ZWAVE_SOF_BYTE ? ScanState::WAIT_LENGTH : ScanState::WAIT_SOF;
+        return ScanResult::INVALID;
+      }
+      this->remaining_ = byte;
+      this->checksum_ = ZWAVE_CHECKSUM_INIT ^ byte;
+      this->state_ = ScanState::WAIT_TYPE;
+      return ScanResult::NONE;
+
+    case ScanState::WAIT_TYPE:
+      this->type_ = byte;
+      this->checksum_ ^= byte;
+      this->remaining_--;
+      this->state_ = ScanState::WAIT_COMMAND;
+      return ScanResult::NONE;
+
+    case ScanState::WAIT_COMMAND:
+      this->command_ = byte;
+      this->checksum_ ^= byte;
+      this->remaining_--;
+      this->state_ = ScanState::WAIT_BODY;
+      return ScanResult::NONE;
+
+    case ScanState::WAIT_BODY:
+      break;
+  }
+
+  if (this->remaining_ > 1) {
+    this->checksum_ ^= byte;
+    this->remaining_--;
+    return ScanResult::NONE;
+  }
+  // The frame's last byte is its checksum, which the accumulator can be compared against
+  // directly -- everything it covers has already been folded in.
+  this->state_ = ScanState::WAIT_SOF;
+  return byte == this->checksum_ ? ScanResult::FRAME : ScanResult::INVALID;
+}
+
+void ZWaveDetector::reset() {
+  this->device_scanner_.reset();
+  this->host_scanner_.reset();
+  this->state_ = ZWaveDetectState::IDLE;
+  this->pending_command_ = 0;
+  this->ack_owed_ = false;
+  this->unconfirmed_rejects_ = 0;
+}
+
+void ZWaveDetector::begin_batch(uint32_t now) {
+  // Both directions, from either caller: a frame stalled in the quiet direction still has
+  // to expire, and the direction being fed is by definition not stalled.
+  expire_stalled_frame(this->device_scanner_, this->device_frame_start_, now);
+  expire_stalled_frame(this->host_scanner_, this->host_frame_start_, now);
+}
+
+void ZWaveDetector::from_device(uint8_t byte) {
+  switch (this->device_scanner_.feed(byte)) {
+    case ScanResult::FRAME:
+      this->handle_device_frame_();
+      break;
+    case ScanResult::INVALID:
+      // While armed this may be a corrupted frame, which the controller will retransmit,
+      // or a sign it stopped speaking the Serial API. reject_() distinguishes the two by
+      // whether a well-formed frame ever follows.
+      this->reject_();
+      break;
+    case ScanResult::NONE:
+      break;
+  }
+}
+
+void ZWaveDetector::handle_device_frame_() {
+  if (this->state_ == ZWaveDetectState::SAW_REQUEST) {
+    // An unsolicited request from the controller can arrive before the response we are
+    // waiting for; it is not the other half of the exchange, so it proves nothing.
+    if (this->device_scanner_.type() != ZWAVE_FRAME_TYPE_RESPONSE ||
+        this->device_scanner_.command() != this->pending_command_) {
+      return;
+    }
+    this->state_ = ZWaveDetectState::ARMED;
+    // The host direction stops being scanned from here, so leave nothing part-read behind
+    this->host_scanner_.reset();
+  } else if (this->state_ != ZWaveDetectState::ARMED) {
+    return;
+  }
+
+  // Every well-formed frame is acknowledged, the one that armed us included: the
+  // controller is already waiting on that one, so answering now saves a retransmit.
+  this->ack_owed_ = true;
+  this->unconfirmed_rejects_ = 0;
+}
+
+void ZWaveDetector::reject_() {
+  if (this->state_ != ZWaveDetectState::ARMED) {
+    return;
+  }
+  if (++this->unconfirmed_rejects_ >= MAX_UNCONFIRMED_REJECTS) {
+    this->state_ = ZWaveDetectState::IDLE;
+    this->unconfirmed_rejects_ = 0;
+    this->ack_owed_ = false;
+  }
+}
+
+void ZWaveDetector::from_host(uint8_t byte) {
+  if (this->host_scanner_.feed(byte) != ScanResult::FRAME) {
+    return;
+  }
+  if (this->state_ == ZWaveDetectState::ARMED) {
+    return;
+  }
+  // Only a request opens an exchange. A later request replaces the one being waited on:
+  // the host does not repeat a command it has given up on.
+  if (this->host_scanner_.type() != ZWAVE_FRAME_TYPE_REQUEST) {
+    return;
+  }
+  this->pending_command_ = this->host_scanner_.command();
+  this->state_ = ZWaveDetectState::SAW_REQUEST;
+}
+
+bool ZWaveDetector::take_pending_ack() {
+  if (!this->ack_owed_) {
+    return false;
+  }
+  this->ack_owed_ = false;
+  return true;
+}
+
+}  // namespace esphome::zwave_proxy_tap
+
+#endif  // USE_ZWAVE_PROXY_TAP
@@ -0,0 +1,121 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_ZWAVE_PROXY_TAP
+
+#include "zwave_protocol.h"
+
+#include <cstdint>
+
+namespace esphome::zwave_proxy_tap {
+
+// Decides when it is safe to acknowledge controller frames on a client's behalf.
+//
+// The client suppresses its own ACKs, so nobody else will send them, and injecting a
+// stray 0x06 into a stream that is not the Serial API would corrupt it. Detection is
+// therefore one-sided: arm only on evidence that cannot arise by accident, and never on
+// frame validity alone, which other traffic can satisfy by luck.
+//
+// The Serial API has no fixed opening handshake to key off, but every session is a
+// sequence of request/response exchanges, and one of those is evidence enough:
+//
+//   request   (host -> ctrl)   01 <len> 00 <cmd> <payload> <chk>
+//   response  (ctrl -> host)   01 <len> 01 <cmd> <payload> <chk>
+//
+// Requiring a well-formed request and then a well-formed response carrying the same
+// command, in opposite directions, cannot be satisfied by a unidirectional byte stream
+// whatever it contains -- which is exactly the situation during a firmware upload. It
+// also rules out the bootloader, which only ever emits single bytes and menu text and
+// never a 0x01-framed multi-byte reply. Keying on the exchange rather than on one
+// particular command means it does not matter which command the client opens with.
+//
+// Getting it wrong in the other direction is cheap: a frame we decline to acknowledge is
+// retransmitted by the controller once its ack timeout expires, so we see a clean copy
+// and lose only that delay. That asymmetry is why this errs towards silence everywhere,
+// including on a bad checksum -- where the zwave_proxy component answers with a NAK, this
+// says nothing and lets the timeout do the work.
+
+enum class ZWaveDetectState : uint8_t {
+  IDLE,         // Not the Serial API, or not yet proven to be
+  SAW_REQUEST,  // Exchange half-complete; watching for the matching response
+  ARMED,        // Session confirmed; acknowledging on the client's behalf
+};
+
+enum class ScanResult : uint8_t {
+  NONE,     // Mid-frame, or a byte that carried nothing
+  FRAME,    // type()/command() describe a complete frame with a verified checksum
+  INVALID,  // A frame started but was not well formed
+};
+
+// Reassembles one direction of the byte stream into checksum-verified frames.
+//
+// Because the framing is length-prefixed, the length is known before the payload
+// arrives, so the checksum can be folded in byte by byte and nothing needs to be
+// buffered. Only the two header fields the detector actually reads are kept, which is
+// what makes a scanner per direction cost a handful of bytes rather than 257 each.
+class ZWaveFrameScanner {
+ public:
+  ScanResult feed(uint8_t byte);
+  void reset() { this->state_ = ScanState::WAIT_SOF; }
+
+  /// True while a frame is part-received, so the caller can time it out.
+  bool in_frame() const { return this->state_ != ScanState::WAIT_SOF; }
+
+  // Valid only for the frame the last feed() reported.
+  uint8_t type() const { return this->type_; }
+  uint8_t command() const { return this->command_; }
+
+ private:
+  enum class ScanState : uint8_t {
+    WAIT_SOF,
+    WAIT_LENGTH,
+    WAIT_TYPE,
+    WAIT_COMMAND,
+    WAIT_BODY,  // Payload bytes, then the checksum that ends the frame
+  };
+
+  ScanState state_{ScanState::WAIT_SOF};
+  uint8_t remaining_{0};  // Bytes of the current frame still to come, checksum included
+  uint8_t checksum_{ZWAVE_CHECKSUM_INIT};
+  uint8_t type_{0};
+  uint8_t command_{0};
+};
+
+class ZWaveDetector {
+ public:
+  void reset();
+
+  /// Time-stamp a batch of observed bytes, before feeding them, so a frame left
+  /// part-received by an earlier batch is abandoned rather than swallowing this one.
+  void begin_batch(uint32_t now);
+
+  // Feed observed traffic. Neither call gates forwarding: the detector only watches.
+  void from_device(uint8_t byte);
+  void from_host(uint8_t byte);
+
+  bool armed() const { return this->state_ == ZWaveDetectState::ARMED; }
+
+  /// True only while the host direction can still affect the state machine. Lets the
+  /// caller skip scanning that direction once armed -- it is the busier of the two.
+  bool needs_host_scan() const { return this->state_ != ZWaveDetectState::ARMED; }
+
+  /// An acknowledgement became owed during the last from_device() call. Clears the flag.
+  bool take_pending_ack();
+
+ protected:
+  void handle_device_frame_();
+  void reject_();
+
+  ZWaveFrameScanner device_scanner_;
+  ZWaveFrameScanner host_scanner_;
+  uint32_t device_frame_start_{0};
+  uint32_t host_frame_start_{0};
+  ZWaveDetectState state_{ZWaveDetectState::IDLE};
+  uint8_t pending_command_{0};  // Command of the request awaiting its response
+  uint8_t unconfirmed_rejects_{0};
+  bool ack_owed_{false};
+};
+
+}  // namespace esphome::zwave_proxy_tap
+
+#endif  // USE_ZWAVE_PROXY_TAP
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::zwave_proxy_tap {
+
+// Z-Wave Serial API framing (INS12350). Unlike ASH, a data frame is length-prefixed
+// rather than delimited:
+//
+//   SOF  LEN  TYPE  CMD  payload...  CHK
+//
+// LEN counts every byte after itself, the checksum included, so a frame occupies LEN + 2
+// bytes on the wire. CHK is the XOR of LEN through the last payload byte, seeded with
+// 0xFF. ACK, NAK and CAN stand alone as single bytes and carry no framing of their own.
+
+static constexpr uint8_t ZWAVE_SOF_BYTE = 0x01;  // Start of a data frame
+static constexpr uint8_t ZWAVE_ACK_BYTE = 0x06;  // The only byte this component ever sends
+
+// TYPE field: which half of a request/response exchange the frame is
+static constexpr uint8_t ZWAVE_FRAME_TYPE_REQUEST = 0x00;
+static constexpr uint8_t ZWAVE_FRAME_TYPE_RESPONSE = 0x01;
+
+// Smallest LEN the protocol can produce: TYPE, CMD and CHK, with no payload
+static constexpr uint8_t ZWAVE_MIN_LENGTH = 3;
+
+static constexpr uint8_t ZWAVE_CHECKSUM_INIT = 0xFF;
+
+// The specification requires a receiver to abandon a data frame that has not completed
+// this long after its SOF byte. Nothing in the framing marks where a frame ends, so
+// without this a truncated frame would swallow the start of the next one.
+static constexpr uint32_t ZWAVE_FRAME_TIMEOUT_MS = 1500;
+
+}  // namespace esphome::zwave_proxy_tap
@@ -0,0 +1,72 @@
+#include "zwave_proxy_tap.h"
+
+#ifdef USE_ZWAVE_PROXY_TAP
+
+#include "esphome/core/application.h"
+#include "esphome/core/log.h"
+
+namespace esphome::zwave_proxy_tap {
+
+static const char *const TAG = "zwave_proxy_tap";
+
+void ZWaveProxyTap::setup() { this->parent_->set_tap(this); }
+
+void ZWaveProxyTap::dump_config() { ESP_LOGCONFIG(TAG, "Z-Wave Proxy Tap:\n  Port: %s", this->parent_->get_name()); }
+
+void ZWaveProxyTap::on_device_rx(const uint8_t *data, size_t len) {
+  this->detector_.begin_batch(App.get_loop_component_start_time());
+  for (size_t i = 0; i < len; i++) {
+    // Observation only: the detector never gates forwarding, so it adds no latency and a
+    // frame it cannot parse still reaches the client, which judges it for itself.
+    this->detector_.from_device(data[i]);
+
+    if (this->detector_.take_pending_ack()) {
+      // The client suppresses its own ACKs, so this is the only acknowledgement the
+      // controller will see. Only ever sent for a frame that passed its checksum.
+      this->parent_->write_from_tap(&ZWAVE_ACK_BYTE, 1);
+      ESP_LOGV(TAG, "Sent ACK");
+    }
+  }
+
+  const bool armed = this->detector_.armed();
+  if (armed != this->was_armed_) {
+    this->was_armed_ = armed;
+    ESP_LOGD(TAG, "Serial API session %s",
+             armed ? LOG_STR_LITERAL("detected, acknowledging frames")
+                   : LOG_STR_LITERAL("lost, no longer acknowledging frames"));
+  }
+}
+
+void ZWaveProxyTap::on_client_tx(const uint8_t *data, size_t len) {
+  // Scanning this direction only matters until an exchange completes. Once armed it is
+  // skipped entirely -- which is what makes a firmware upload, all of which flows this
+  // way, essentially free.
+  if (!this->detector_.needs_host_scan()) {
+    return;
+  }
+  this->detector_.begin_batch(App.get_loop_component_start_time());
+  for (size_t i = 0; i < len; i++) {
+    this->detector_.from_host(data[i]);
+  }
+}
+
+void ZWaveProxyTap::on_protocol_disabled() {
+  // A client turning protocol handling off is usually about to reflash the controller, so
+  // the exchange we saw says nothing about what will be on the wire next. Forget it: a
+  // real session proves itself again with another exchange.
+  this->detector_.reset();
+}
+
+void ZWaveProxyTap::on_device_disconnected() {
+  // The controller lost power, so the exchange we saw belongs to a session that no longer
+  // exists. Whatever appears next has to prove itself again.
+  if (this->was_armed_) {
+    ESP_LOGD(TAG, "Device removed, no longer acknowledging frames");
+    this->was_armed_ = false;
+  }
+  this->detector_.reset();
+}
+
+}  // namespace esphome::zwave_proxy_tap
+
+#endif  // USE_ZWAVE_PROXY_TAP
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_ZWAVE_PROXY_TAP
+
+#include "esphome/components/serial_proxy/serial_proxy.h"
+#include "esphome/core/component.h"
+#include "zwave_detector.h"
+
+namespace esphome::zwave_proxy_tap {
+
+// Acknowledges the frames of a Z-Wave controller on behalf of a remote client, so the
+// controller's ack timeout is measured against this device rather than against the
+// network round trip to the client. The client suppresses its own acknowledgements,
+// making these the only ones the controller sees.
+//
+// This is the serial_proxy counterpart of the zwave_proxy component. Where that one owns
+// the UART, parses the Serial API in full and carries frames over its own API messages,
+// this one only observes: the serial proxy owns the port and the bytes, and carries them
+// like those of any other serial device. The sole exception is the acknowledgement
+// itself, and it is sent only once a completed request/response exchange has proven the
+// port really is carrying the Serial API.
+class ZWaveProxyTap : public serial_proxy::SerialProxyTap, public Component {
+ public:
+  explicit ZWaveProxyTap(serial_proxy::SerialProxy *parent) : parent_(parent) {}
+
+  void setup() override;
+  void dump_config() override;
+
+  // SerialProxyTap
+  void on_device_rx(const uint8_t *data, size_t len) override;
+  void on_client_tx(const uint8_t *data, size_t len) override;
+  // Acknowledging is only ever useful on a client's behalf, so with nobody subscribed
+  // there is nothing to do and the port need not be read.
+  bool tap_needs_port() const override { return false; }
+  void on_protocol_disabled() override;
+  void on_device_disconnected() override;
+
+ protected:
+  // The port this component observes. Owns the UART and the bytes; every write we make
+  // goes through it.
+  serial_proxy::SerialProxy *parent_;
+
+  // Decides when acknowledging on the client's behalf is safe. Armed only by a completed
+  // request/response exchange, so a bootloader or a firmware upload never triggers it.
+  ZWaveDetector detector_;
+
+  // Previous armed state, for logging the transitions
+  bool was_armed_{false};
+};
+
+}  // namespace esphome::zwave_proxy_tap
+
+#endif  // USE_ZWAVE_PROXY_TAP
@@ -137,43 +137,6 @@
 #define MICRONOVA_LISTENER_COUNT 1
 #define USE_MICRONOVA_WRITER
 #define MK2PVROUTER_LISTENER_COUNT 1
-#define REMOTE_BASE_DUMPER_COUNT 1
-#define REMOTE_BASE_LISTENER_COUNT 1
-#define USE_REMOTE_PROTOCOL_ABBWELCOME
-#define USE_REMOTE_PROTOCOL_AEHA
-#define USE_REMOTE_PROTOCOL_BEO4
-#define USE_REMOTE_PROTOCOL_BRENNENSTUHL
-#define USE_REMOTE_PROTOCOL_BYRONSX
-#define USE_REMOTE_PROTOCOL_CANALSAT
-#define USE_REMOTE_PROTOCOL_COOLIX
-#define USE_REMOTE_PROTOCOL_DISH
-#define USE_REMOTE_PROTOCOL_DOOYA
-#define USE_REMOTE_PROTOCOL_DRAYTON
-#define USE_REMOTE_PROTOCOL_DYSON
-#define USE_REMOTE_PROTOCOL_GOBOX
-#define USE_REMOTE_PROTOCOL_HAIER
-#define USE_REMOTE_PROTOCOL_JVC
-#define USE_REMOTE_PROTOCOL_KEELOQ
-#define USE_REMOTE_PROTOCOL_LG
-#define USE_REMOTE_PROTOCOL_MAGIQUEST
-#define USE_REMOTE_PROTOCOL_MIDEA
-#define USE_REMOTE_PROTOCOL_MIRAGE
-#define USE_REMOTE_PROTOCOL_NEC
-#define USE_REMOTE_PROTOCOL_NEXA
-#define USE_REMOTE_PROTOCOL_PANASONIC
-#define USE_REMOTE_PROTOCOL_PIONEER
-#define USE_REMOTE_PROTOCOL_PRONTO
-#define USE_REMOTE_PROTOCOL_RAW
-#define USE_REMOTE_PROTOCOL_RC5
-#define USE_REMOTE_PROTOCOL_RC6
-#define USE_REMOTE_PROTOCOL_RC_SWITCH
-#define USE_REMOTE_PROTOCOL_ROOMBA
-#define USE_REMOTE_PROTOCOL_SAMSUNG
-#define USE_REMOTE_PROTOCOL_SAMSUNG36
-#define USE_REMOTE_PROTOCOL_SONY
-#define USE_REMOTE_PROTOCOL_SYMPHONY
-#define USE_REMOTE_PROTOCOL_TOSHIBA_AC
-#define USE_REMOTE_PROTOCOL_TOTO
 #define SERIAL_PROXY_COUNT 2
 #define SNTP_SERVER_COUNT 3
 #define USE_MEDIA_PLAYER
@@ -236,7 +199,9 @@
 #define USE_VALVE
 #define USE_WATER_HEATER
 #define USE_WATER_HEATER_VISUAL_OVERRIDES
+#define USE_ZIGBEE_PROXY_TAP
 #define USE_ZWAVE_PROXY
+#define USE_ZWAVE_PROXY_TAP

 // Feature flags which do not work for zephyr
 #ifndef USE_ZEPHYR
@@ -435,6 +400,10 @@
 #define USB_HOST_MAX_REQUESTS 16
 #define USB_HOST_MAX_PACKET_SIZE 64
 #define USB_UART_OUTPUT_CHUNK_COUNT 5
+// USB identity on serial proxy ports needs the usb_host stack
+#ifdef USE_ESP32
+#define USE_SERIAL_PROXY_USB_INFO
+#endif

 #ifdef USE_ARDUINO
 #define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 3, 7)
@@ -1,9 +0,0 @@
-esphome:
-  name: test
-
-esp32:
-  board: esp32dev
-
-remote_receiver:
-  - id: rcvr
-    pin: GPIO4
@@ -1,24 +0,0 @@
-esphome:
-  name: test
-
-esp32:
-  board: esp32dev
-
-logger:
-
-remote_receiver:
-  - id: rcvr
-    pin: GPIO4
-    dump:
-      - nec
-      - rc_switch
-    on_nec:
-      then:
-        - logger.log: nec
-
-binary_sensor:
-  - platform: remote_receiver
-    name: Remote Input
-    nec:
-      address: 0x1234
-      command: 0x5678
@@ -1,20 +0,0 @@
-esphome:
-  name: test
-
-esp32:
-  board: esp32dev
-
-remote_receiver:
-  - id: rcvr
-    pin: GPIO4
-
-infrared:
-  - platform: ir_rf_proxy
-    name: IR Receiver
-    remote_receiver_id: rcvr
-
-radio_frequency:
-  - platform: ir_rf_proxy
-    name: RF Receiver
-    frequency: 433.92MHz
-    remote_receiver_id: rcvr
@@ -1,82 +0,0 @@
-"""Listener and dumper StaticVector sizes come from codegen slot counts."""
-
-from collections.abc import Callable
-from pathlib import Path
-
-import pytest
-
-from esphome.components import remote_base
-import esphome.config_validation as cv
-
-from ..helpers import get_define_value
-
-
-def test_dumper_and_listener_counts(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    generate_main(component_config_path("receiver_with_dumpers.yaml"))
-    # nec and rc_switch dumpers
-    assert get_define_value("REMOTE_BASE_DUMPER_COUNT") == "2"
-    # on_nec trigger plus the remote_receiver binary sensor
-    assert get_define_value("REMOTE_BASE_LISTENER_COUNT") == "2"
-
-
-def test_bare_receiver_emits_no_counts(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    generate_main(component_config_path("receiver_bare.yaml"))
-    assert get_define_value("REMOTE_BASE_DUMPER_COUNT") is None
-    assert get_define_value("REMOTE_BASE_LISTENER_COUNT") is None
-
-
-def test_proxy_receivers_count_as_listeners(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    generate_main(component_config_path("receiver_with_proxies.yaml"))
-    # infrared and radio_frequency ir_rf_proxy platforms each listen
-    assert get_define_value("REMOTE_BASE_LISTENER_COUNT") == "2"
-    assert get_define_value("REMOTE_BASE_DUMPER_COUNT") is None
-
-
-def test_only_used_protocol_sources_are_compiled(
-    generate_main: Callable[[str | Path], str],
-    component_config_path: Callable[[str], Path],
-) -> None:
-    generate_main(component_config_path("receiver_with_dumpers.yaml"))
-    excluded = set(remote_base.FILTER_SOURCE_FILES())
-    assert "nec_protocol.cpp" not in excluded
-    assert "rc_switch_protocol.cpp" not in excluded
-    assert "sony_protocol.cpp" in excluded
-    assert "remote_base.cpp" not in excluded
-
-
-def test_every_registry_name_maps_to_a_protocol_source() -> None:
-    sources = {
-        path.name for path in Path(remote_base.__file__).parent.glob("*_protocol.cpp")
-    }
-    names = (
-        set(remote_base.BINARY_SENSOR_REGISTRY)
-        | set(remote_base.DUMPER_REGISTRY)
-        | {key.removeprefix("on_") for key in remote_base.TRIGGER_REGISTRY}
-    )
-    for name in names:
-        stem = (
-            remote_base.protocol_define(name)
-            .removeprefix("USE_REMOTE_PROTOCOL_")
-            .lower()
-        )
-        assert f"{stem}_protocol.cpp" in sources, name
-
-
-def test_dump_list_is_deduplicated_across_forms() -> None:
-    dumpers = remote_base.validate_dumpers(["raw", {"raw": None}, "nec", "nec"])
-    assert [name for name, _ in dumpers] == ["raw", "nec"]
-
-
-@pytest.mark.parametrize("bad", [["nec", None], [5]])
-def test_dump_list_rejects_invalid_entries_with_a_validation_error(bad: list) -> None:
-    with pytest.raises(cv.Invalid):
-        remote_base.validate_dumpers(bad)
@@ -1,6 +0,0 @@
-# A receiver with no dumpers and no listeners compiles both lists out.
-# Only built while remote_receiver is tested in isolation: the counts are global defines,
-# so this variant cannot be merged with configs that register any.
-remote_receiver:
-  - id: rcvr_bare
-    pin: ${pin}
@@ -1,5 +0,0 @@
-substitutions:
-  pin: GPIO2
-
-packages:
-  bare: !include bare-common.yaml
@@ -0,0 +1,21 @@
+wifi:
+  ssid: MySSID
+  password: password1
+
+api:
+
+usb_host:
+
+# port_type is omitted deliberately: a port on a USB UART channel derives USB_SERIAL
+usb_uart:
+  - type: CDC_ACM
+    vid: 0x303A
+    pid: 0x831A
+    channels:
+      - id: usb_serial_channel
+        baud_rate: 460800
+
+serial_proxy:
+  - id: serial_proxy_usb
+    uart_id: usb_serial_channel
+    name: USB Serial Port
@@ -4,3 +4,8 @@ usb_host:
    - id: device_1
      vid: 0x1234
      pid: 0x1234
+    - id: device_2
+      vid: 0x1234
+      pid: 0x5678
+      manufacturer: Example Corp
+      product: Example Widget
@@ -35,8 +35,10 @@ usb_uart:
        debug: true
        dummy_receiver: true
        debug_prefix: "[ESP_JTAG] "
+  # A CP2105, so it does not share 10C4:EA60 with uart_1 above
  - id: uart_5
    type: cp210x
+    pid: 0xEA70
    channels:
      - id: channel_5_1
        baud_rate: 9600
@@ -65,3 +67,20 @@ usb_uart:
        stop_bits: 2
        data_bits: 7
        parity: even
+  # A ZBT-2 and a ZWA-2 both enumerate as 303A:4001, so only iProduct separates them
+  - id: uart_9
+    type: cdc_acm
+    vid: 0x303A
+    pid: 0x4001
+    manufacturer: Nabu Casa
+    product: ZBT-2
+    channels:
+      - id: channel_9_1
+  - id: uart_10
+    type: cdc_acm
+    vid: 0x303A
+    pid: 0x4001
+    manufacturer: Nabu Casa
+    product: ZWA-2
+    channels:
+      - id: channel_10_1
@@ -0,0 +1,5 @@
+# Gitignore settings for ESPHome
+# This is an example and may include too much for your use-case.
+# You can modify this file to suit your needs.
+/.esphome/
+/secrets.yaml
@@ -0,0 +1,22 @@
+esphome:
+  name: test
+
+wifi:
+  ssid: test
+  password: password
+  power_save_mode: none
+
+api:
+
+uart:
+  - id: zigbee_uart
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 115200
+
+# The port owns the UART and carries every byte; zigbee_proxy_tap only taps it
+serial_proxy:
+  - id: zigbee_serial
+    uart_id: zigbee_uart
+    name: Zigbee
+    port_type: TTL
@@ -0,0 +1,26 @@
+wifi:
+  ssid: test
+  password: password
+  power_save_mode: none
+
+api:
+
+usb_host:
+
+usb_uart:
+  - type: CDC_ACM
+    vid: 0x303A
+    pid: 0x831A
+    channels:
+      - id: zigbee_usb_channel
+        baud_rate: 460800
+
+# The tapped port may be a USB CDC ACM channel just as well as a hardware UART:
+# zigbee_proxy_tap never touches the UART itself, so it does not care which it is.
+serial_proxy:
+  - id: zigbee_usb_serial
+    uart_id: zigbee_usb_channel
+    name: Zigbee
+
+zigbee_proxy_tap:
+  serial_proxy_id: zigbee_usb_serial
@@ -0,0 +1,11 @@
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+esp32:
+  board: esp32dev
+
+<<: !include common.yaml
+
+zigbee_proxy_tap:
+  serial_proxy_id: zigbee_serial
@@ -0,0 +1,11 @@
+substitutions:
+  tx_pin: GPIO1
+  rx_pin: GPIO3
+
+esp8266:
+  board: nodemcuv2
+
+<<: !include common.yaml
+
+zigbee_proxy_tap:
+  serial_proxy_id: zigbee_serial
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
kbx81	f504bca126	Merge remote-tracking branch 'puddly/20260218-zigbee-proxy' into 20260218-zigbee-proxy	2026-09-10 18:48:02 -05:00
puddly	1442e82bc6	Merge branch 'dev' into 20260218-zigbee-proxy	2026-09-10 22:57:49 +00:00
puddly	bc8fa31a76	[serial_proxy] Implement a no-op hardware flow control	2026-09-10 20:32:31 +00:00
puddly	a0643429c1	[usb_host] Read the interface descriptor string, for full Linux parity	2026-09-10 18:54:51 +00:00
puddly	90f428b0fb	[usb_host] Unsolicited USB info notifications [usb_host] Interface number	2026-09-10 18:48:05 +00:00
puddly	703ffbd22b	[usb_host] Allow 0x0000 VID/PID wildcards to apply to just one field [usb_host] Fix VID/PID wildcards	2026-09-10 18:48:05 +00:00
kbx81	4e22438717	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy # Conflicts: # esphome/components/api/api.proto # esphome/components/api/api_pb2.cpp # esphome/components/api/api_pb2.h # esphome/components/api/api_pb2_dump.cpp # esphome/components/api/api_pb2_service.cpp # esphome/components/api/api_pb2_service.h # esphome/components/serial_proxy/serial_proxy.h	2026-09-10 12:01:06 -05:00
puddly	ffb4ca997e	[usb_host] Validate USB configuration more strictly	2026-09-09 21:33:33 +00:00
puddly	7d85efb641	[usb_host] Allow filtering USB devices by manufacturer and product	2026-09-09 21:26:36 +00:00
puddly	8aae67b7b2	test: Rename `zigbee_proxy` to `zigbee_proxy_tap`	2026-09-09 20:07:16 +00:00
puddly	1c71adb6ca	test: Create `zwave_proxy_tap`	2026-09-09 20:05:20 +00:00
puddly	213ddf8823	test: middle ground for CRC lookup Compared to the baseline, -456 bytes of flash (90% of no lookup) but claw back 3x the performance	2026-09-09 19:07:31 +00:00
puddly	020aef214b	test: replace the CRC lookup table with direct computation Saves 500 bytes at the cost of 5x worse performance per CRC, negligible at even sustained ASH transfer rates	2026-09-09 19:07:31 +00:00
puddly	f13b4781db	Remove `buffer_size` config, the max ASH size is static	2026-09-08 19:08:39 +00:00
puddly	80254f8689	Strip out Zigbee proxy's EZSP, leaving only enough for ASH auto-ACKIng	2026-09-08 19:04:02 +00:00
kbx81	590a4a6268	[serial_proxy] Add USB identity query for USB-bridged ports Add SERIAL_PROXY_PORT_TYPE_USB_SERIAL, derived automatically when a port's uart_id resolves to a usb_uart channel (never set by the user), and a SerialProxyGetUsbInfoRequest/Response pair (IDs 153/154) that reads VID/PID/bcdDevice and the manufacturer/product/serial strings live from the descriptors the USB host stack caches, so a client can identify the attached device before subscribing. Ports that are not USB_SERIAL answer NOT_SUPPORTED; an unplugged device answers with connected=false. ZigbeeProxyRequest moves to ID 155 (expected merge order: set_mode, USB info, zigbee).	2026-09-03 22:07:52 -05:00
kbx81	6a9791609f	Merge branch '20260902-serial-proxy-tap' into 20260218-zigbee-proxy # Conflicts: # esphome/components/api/api.proto # esphome/components/api/api_connection.cpp # esphome/components/api/api_pb2.h # esphome/components/api/api_pb2_dump.cpp # esphome/components/api/api_pb2_service.cpp # esphome/components/serial_proxy/serial_proxy.cpp # esphome/components/serial_proxy/serial_proxy.h	2026-09-03 19:52:29 -05:00
kbx81	bd94a6858f	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-09-03 19:49:55 -05:00
kbx81	c432ab146f	[serial_proxy] Compile out mode state in builds without a tap PROTOCOL is refused when no tap exists, so mode_ could never leave RAW there; gate the member and reset_mode_() behind USE_SERIAL_PROXY_TAP (no-op inline otherwise), saving the member and the four reset calls in every tapless build.	2026-09-03 01:16:55 -05:00
kbx81	82675a2c78	[serial_proxy] Guard leaving_protocol_mode with the tap define Its only reader is tap-gated, so non-tap builds warned about an unused variable.	2026-09-03 00:52:17 -05:00
kbx81	29b5935a22	[serial_proxy] Split refused-write logging by cause Writes are the only high-rate, unacknowledged operation, so a legacy client streaming without a subscription would flood WARN one line per request. Contention (another client holds the port) stays WARN; the never-subscribed case logs at VERBOSE. One-shot operations keep WARN in both cases since their request/ack pattern bounds the rate.	2026-09-03 00:35:44 -05:00
kbx81	0224929624	[serial_proxy] Require an active subscription for every port operation Writes, configure, modem pins and flush previously passed for any authenticated client while nobody held the port. With a tap attached that allowed an unsubscribed writer to share the wire with the tap, with no way to select RAW to stop it (set_mode already refuses non-subscribers). All port operations now require being the live subscriber, and the proto comments state the precondition. Also fold the ifdef-inside-if in set_mode_from_client into a has_tap local for readability.	2026-09-03 00:10:19 -05:00
kbx81	4437a0bd7f	[serial_proxy] Reset the mode when a subscription is taken over A client taking over from a crashed subscriber inherited that session's mode; end the dead session with reset_mode_() before handing over the port, matching every other subscriber-change path.	2026-09-02 23:48:17 -05:00
kbx81	fa5e784cbe	[serial_proxy] Drop the YAML mode option The boot mode had no coherent job left: before any subscriber the tap is served via tap_needs_port() regardless of mode, 1.17+ clients select the mode explicitly after subscribing, and the only remaining effect was arming the tap for a first-session client that never asked for it and could not turn it off. The mode is now purely a session property of the API: ports always boot RAW. Also polish the tap contract per review: expose tap_is_observed(), return false from write_from_tap() when the bytes are dropped, and document that tap_pump() must not be called from tap callbacks.	2026-09-02 23:31:05 -05:00
kbx81	14f6d44ac2	[serial_proxy] Make set_mode acknowledgements report the real outcome - Refuse PROTOCOL with NOT_SUPPORTED when the port has no tap, so a client cannot mistake a plain pipe for an active tap - Skip tap_pump() when neither the tap nor a subscriber would receive the bytes, instead of draining the FIFO into the void - Rename the client-facing overload to set_mode_from_client, matching write_from_client - Document that PORT_IN_USE also covers callers that never subscribed, and that the YAML mode applies only until the first session ends	2026-09-02 23:04:29 -05:00
kbx81	88402743d5	[serial_proxy] Enforce session scoping and RAW inertness for the port mode Address review findings: - Only the live subscriber may set the mode, so a mode set by a client that never subscribes cannot persist past its session - With a subscriber attached, the mode alone decides whether the tap is served; tap_needs_port() bypasses it only while the port is unheld, and write_from_tap() is gated the same way, so RAW is inert by code - The explicit UNSUBSCRIBE path keeps the loop alive for a tap that still needs the port, mirroring the disconnect path in loop() - Mode values from the wire are validated; unknown values are refused with INVALID_ARGUMENT instead of stored and acknowledged OK - Add a test variant that defines USE_SERIAL_PROXY_TAP so the tap code paths compile in a real build	2026-09-02 22:27:52 -05:00
Keith Burzinski	6ae5f070c8	Merge branch 'dev' into 20260902-serial-proxy-tap	2026-09-02 22:10:12 -05:00
kbx81	89d00c6d93	[serial_proxy] Acknowledge set_mode requests Follow the acknowledgement pattern from #18312: set_mode now returns a SerialProxyResult and the handler answers with SerialProxyRequestResponse (type SET_MODE). This matters most for a client switching to RAW before flashing firmware through the port: without an ack, a refused request (another client holds the port) is silently dropped and the client cannot tell that protocol bytes may still be injected.	2026-09-02 21:31:05 -05:00
kbx81	e723d404e2	[serial_proxy] Add set_mode to the benchmark stub The benchmark harness compiles api_connection.cpp against stub component headers, so the stub needs the new client-request method.	2026-09-02 21:25:34 -05:00
Keith Burzinski	dde216d8c8	Merge branch 'dev' into 20260902-serial-proxy-tap	2026-09-02 19:57:04 -05:00
kbx81	ab8e180ff5	[serial_proxy] Move SerialProxySetModeRequest to ID 152 IDs 150 and 151 were claimed on dev (DeviceCapabilitiesResponse, ZWaveProxyRequestResponse) after this branch was cut.	2026-09-02 19:16:38 -05:00
kbx81	99a82222ab	Merge remote-tracking branch 'upstream/dev' into 20260902-serial-proxy-tap	2026-09-02 18:55:29 -05:00
kbx81andpuddly	3162a16b05	[serial_proxy] Add tap interface and port mode Add SerialProxyTap, a protocol-agnostic observer interface that lets a companion component watch the bytes flowing through a proxied port and inject bytes of its own (protocol acknowledgements, for example) without owning the port. The tap machinery is compiled in only when a tap component defines USE_SERIAL_PROXY_TAP, so ports without one pay nothing. Add a per-port mode (RAW or PROTOCOL) with a matching API message so clients control whether the tap is active. The mode belongs to the client session: it resets to RAW whenever the subscriber disconnects, and RAW is guaranteed inert so a client can flash firmware through the port without protocol bytes being injected. Bumps the API minor version to 17. Co-Authored-By: puddly <32534428+puddly@users.noreply.github.com>	2026-09-02 16:07:50 -05:00
kbx81	feeacda4ba	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-09-02 16:04:55 -05:00
kbx81	f14d69ff36	[usb_uart] Drop unused is_usb_uart_channel helper Its only caller was removed when zigbee_proxy switched to observing a serial_proxy port instead of owning the UART.	2026-09-02 14:25:13 -05:00
kbx81	5e79c617e8	[serial_proxy] Make port mode protocol-neutral Rename SERIAL_PROXY_MODE_EZSP_ASH to SERIAL_PROXY_MODE_PROTOCOL so the serial_proxy API surface carries no protocol-specific names. The mode now means "the port's tap is active"; which protocol the tap speaks is a property of the device configuration, discoverable from the tap component's own API surface. Future protocol taps need no serial_proxy or API changes.	2026-09-02 14:19:52 -05:00
kbx81	1cc48bfee2	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy # Conflicts: # esphome/components/api/api_connection.cpp # esphome/components/api/api_pb2.h # esphome/components/api/api_pb2_defines.h # esphome/components/api/api_pb2_service.cpp # esphome/components/api/api_pb2_service.h # esphome/components/serial_proxy/serial_proxy.cpp	2026-09-02 02:30:09 -05:00
kbx81	890f0408a5	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-08-06 23:27:44 -05:00
puddly	3e0f81bf1e	Improve Zigbee/WiFi collision warning	2026-08-05 14:40:38 -04:00
puddly	6111791706	Have zigbee proxying piggyback off of serial proxying?	2026-08-05 14:40:38 -04:00
puddly	7a05749231	Classify UART traffic for arbitrary protocol passthrough	2026-08-05 14:40:38 -04:00
puddly	997e218376	Reset state more reliably	2026-08-05 14:40:38 -04:00
puddly	973da47da6	Simplify startup state machine by using direct NVRAM access	2026-08-05 14:40:38 -04:00
puddly	e80aa9579b	Handle more of the EZSP protocol and try to detect the bootloader	2026-08-05 14:40:38 -04:00
puddly	a060db1251	Fix EZSP and ASH protocol parsing/forwarding	2026-08-05 14:39:01 -04:00
kbx81	9c4016a871	[zigbee_proxy] Drop usb_uart_id removal error, component is unreleased	2026-08-03 16:58:53 -05:00
kbx81	5846977cf6	[zigbee_proxy] Auto-detect USB UART channel from uart_id, drop usb_uart_id The usb_uart_id key was redundant: uart_id already points at the channel. A new usb_uart.is_usb_uart_channel() helper checks the config tree (use_id resolution does not narrow the ID type), and zigbee_proxy uses it to enable the RX callback fast path and USB timeout defaults automatically.	2026-08-03 16:55:28 -05:00
kbx81	ca42862742	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-08-03 16:32:34 -05:00
kbx81	e0a054dbcb	[zigbee_proxy] Harden ASH sessions, fix UAF/boot-stall/overflows, reduce latency - Unsubscribe on API disconnect (use-after-free) + loop() subscriber guard - Bounds-checked frame building; cap forwarded RSTACK/ERROR payloads - Explicit client ACKs, duplicate re-ACK, NAK on reject (both ASH sides) - Client->NCP TX queue with NAK overflow; retry client frames on API backpressure - Harvest EUI64 during boot; implement NETWORK_INFO request/response and push - Proceed after boot timeout instead of stalling setup; periodic NCP recovery - zwave-style inline UART fast path; process piggybacked ACKs before sequence check - Wire up bootloader detection; heap-free hex logging	2026-07-22 23:20:51 -05:00
kbx81	5e822b828e	Fix zigbee proxy handlers for new non-virtual dispatch, drop deprecated rp2040 platform key in test	2026-07-22 22:31:12 -05:00
kbx81	ef646a9303	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-07-22 22:20:25 -05:00
kbx81	f8bec0813d	fix	2026-03-13 16:48:56 -05:00
kbx81	84762e6ae0	oops	2026-03-13 16:46:13 -05:00
kbx81	2edf313ee3	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-03-13 16:45:23 -05:00
kbx81	ae9c999052	fix	2026-02-28 23:21:30 -06:00
kbx81	7d2f6fbf55	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-28 23:12:31 -06:00
kbx81	608bef86cc	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-26 23:42:43 -06:00
kbx81	6514dc2fe1	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-26 20:55:50 -06:00
kbx81	240afd23b3	...	2026-02-26 14:31:17 -06:00
kbx81	156c2a8cb0	optimize	2026-02-26 14:30:31 -06:00
kbx81	908c47bb5e	preen, tune	2026-02-25 23:28:44 -06:00
kbx81	6df3a30740	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-25 17:33:27 -06:00
kbx81	0aaf59dbed	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-24 16:51:04 -06:00
kbx81	249c5bb724	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-23 18:01:56 -06:00
kbx81	54ea8dd207	Merge remote-tracking branch 'upstream/dev' into 20260218-zigbee-proxy	2026-02-19 18:31:15 -06:00
puddly	4cfb794b62	WIP	2026-02-19 18:22:03 -05:00
kbx81	917af8ff31	[zigbee_proxy] New component	2026-02-19 14:34:29 -06:00