diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 965b186c31..72013e411e 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -25,7 +25,7 @@
 - [ ] ESP32
 - [ ] ESP32 IDF
 - [ ] ESP8266
-- [ ] RP2040
+- [ ] RP2040/RP2350
 - [ ] BK72xx
 - [ ] RTL87xx
 - [ ] LN882x
diff --git a/esphome/components/esp32_ble/ble.cpp b/esphome/components/esp32_ble/ble.cpp
index d2fb24b694..a202afb2d2 100644
--- a/esphome/components/esp32_ble/ble.cpp
+++ b/esphome/components/esp32_ble/ble.cpp
@@ -455,7 +455,7 @@ void ESP32BLE::loop() {
             ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
 #ifdef ESPHOME_ESP32_BLE_GAP_EVENT_HANDLER_COUNT
             {
-              esp_ble_gap_cb_param_t *param;
+              esp_ble_gap_cb_param_t *param = NULL;
               // clang-format off
               switch (gap_event) {
                 // All three scan complete events have the same structure with just status
diff --git a/esphome/components/ethernet/esp_eth_phy_jl1101.c b/esphome/components/ethernet/esp_eth_phy_jl1101.c
index 5e73e99101..a19f7aa6b0 100644
--- a/esphome/components/ethernet/esp_eth_phy_jl1101.c
+++ b/esphome/components/ethernet/esp_eth_phy_jl1101.c
@@ -27,7 +27,7 @@
 #include "esp_rom_sys.h"
 #include "esp_idf_version.h"
 
-#if defined(USE_ARDUINO) || ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2)
+#if defined(USE_ETHERNET_JL1101) && (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2) || !defined(PLATFORMIO))
 
 static const char *TAG = "jl1101";
 #define PHY_CHECK(a, str, goto_tag, ...) \
diff --git a/esphome/components/ethernet/ethernet_component.cpp b/esphome/components/ethernet/ethernet_component.cpp
index 0bc67c8b03..d6b0d40cd9 100644
--- a/esphome/components/ethernet/ethernet_component.cpp
+++ b/esphome/components/ethernet/ethernet_component.cpp
@@ -209,7 +209,7 @@ void EthernetComponent::setup() {
       break;
     }
 #endif
-#ifdef USE_ETHERNET_JL1101
+#if defined(USE_ETHERNET_JL1101) && (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2) || !defined(PLATFORMIO))
     case ETHERNET_TYPE_JL1101: {
       this->phy_ = esp_eth_phy_new_jl1101(&phy_config);
       break;
@@ -374,7 +374,7 @@ void EthernetComponent::dump_config() {
       eth_type = "IP101";
       break;
 #endif
-#ifdef USE_ETHERNET_JL1101
+#if defined(USE_ETHERNET_JL1101) && (ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2) || !defined(PLATFORMIO))
     case ETHERNET_TYPE_JL1101:
       eth_type = "JL1101";
       break;
diff --git a/esphome/components/heatpumpir/climate.py b/esphome/components/heatpumpir/climate.py
index 0d760938d0..7743da77ab 100644
--- a/esphome/components/heatpumpir/climate.py
+++ b/esphome/components/heatpumpir/climate.py
@@ -125,6 +125,7 @@ async def to_code(config):
     cg.add(var.set_vertical_default(config[CONF_VERTICAL_DEFAULT]))
     cg.add(var.set_max_temperature(config[CONF_MAX_TEMPERATURE]))
     cg.add(var.set_min_temperature(config[CONF_MIN_TEMPERATURE]))
+    cg.add_build_flag("-Wno-error=overloaded-virtual")
 
     cg.add_library("tonia/HeatpumpIR", "1.0.40")
     if CORE.is_libretiny or CORE.is_esp32:
diff --git a/esphome/components/http_request/update/http_request_update.cpp b/esphome/components/http_request/update/http_request_update.cpp
index 1900f69a69..c40590af95 100644
--- a/esphome/components/http_request/update/http_request_update.cpp
+++ b/esphome/components/http_request/update/http_request_update.cpp
@@ -128,7 +128,8 @@ void HttpRequestUpdate::update_task(void *params) {
       this_update->update_info_.title = root[ESPHOME_F("name")].as<std::string>();
       this_update->update_info_.latest_version = root[ESPHOME_F("version")].as<std::string>();
 
-      for (auto build : root[ESPHOME_F("builds")].as<JsonArray>()) {
+      auto builds_array = root[ESPHOME_F("builds")].as<JsonArray>();
+      for (auto build : builds_array) {
         if (!build[ESPHOME_F("chipFamily")].is<const char *>()) {
           ESP_LOGE(TAG, "Manifest does not contain required fields");
           return false;
diff --git a/esphome/components/mlx90393/sensor_mlx90393.cpp b/esphome/components/mlx90393/sensor_mlx90393.cpp
index ee52f9b9ab..01084e50df 100644
--- a/esphome/components/mlx90393/sensor_mlx90393.cpp
+++ b/esphome/components/mlx90393/sensor_mlx90393.cpp
@@ -160,7 +160,7 @@ bool MLX90393Cls::verify_setting_(MLX90393Setting which) {
   uint8_t read_value = 0xFF;
   uint8_t expected_value = 0xFF;
   uint8_t read_status = -1;
-  char read_back_str[25] = {0};
+  char read_back_str[33] = {0};
 
   switch (which) {
     case MLX90393_GAIN_SEL: {
diff --git a/esphome/components/uart/__init__.py b/esphome/components/uart/__init__.py
index 3bc4263b31..1b976b73a9 100644
--- a/esphome/components/uart/__init__.py
+++ b/esphome/components/uart/__init__.py
@@ -203,8 +203,10 @@ UART_DIRECTIONS = {
 # round numbers.
 AFTER_DEFAULTS = {CONF_BYTES: 150, CONF_TIMEOUT: "100ms"}
 
+CONF_DEBUG_PREFIX = "debug_prefix"
+
 # By default, log in hex format when no specific sequence is provided.
-DEFAULT_DEBUG_OUTPUT = "UARTDebug::log_hex(direction, bytes, ':');"
+DEFAULT_DEBUG_OUTPUT = "UARTDebug::log_hex(direction, bytes, ':', debug_prefix);"
 DEFAULT_SEQUENCE = [{CONF_LAMBDA: make_data_base(DEFAULT_DEBUG_OUTPUT)}]
 
 
@@ -242,6 +244,7 @@ DEBUG_SCHEMA = cv.Schema(
         ): automation.validate_automation(),
         cv.Optional(CONF_DUMMY_RECEIVER, default=False): cv.boolean,
         cv.GenerateID(CONF_DUMMY_RECEIVER_ID): cv.declare_id(UARTDummyReceiver),
+        cv.Optional(CONF_DEBUG_PREFIX, default=""): cv.string,
     }
 )
 
@@ -283,7 +286,11 @@ async def debug_to_code(config, parent):
     for action in config[CONF_SEQUENCE]:
         await automation.build_automation(
             trigger,
-            [(UARTDirection, "direction"), (cg.std_vector.template(cg.uint8), "bytes")],
+            [
+                (UARTDirection, "direction"),
+                (cg.std_vector.template(cg.uint8), "bytes"),
+                (cg.StringRef, "debug_prefix"),
+            ],
             action,
         )
     cg.add(trigger.set_direction(config[CONF_DIRECTION]))
@@ -299,6 +306,8 @@ async def debug_to_code(config, parent):
     if config[CONF_DUMMY_RECEIVER]:
         dummy = cg.new_Pvariable(config[CONF_DUMMY_RECEIVER_ID], parent)
         await cg.register_component(dummy, {})
+    if debug_prefix := config[CONF_DEBUG_PREFIX]:
+        cg.add(trigger.set_debug_prefix(debug_prefix))
     cg.add_define("USE_UART_DEBUGGER")
 
 
diff --git a/esphome/components/uart/uart_debugger.cpp b/esphome/components/uart/uart_debugger.cpp
index 5490154d01..e0be599d8d 100644
--- a/esphome/components/uart/uart_debugger.cpp
+++ b/esphome/components/uart/uart_debugger.cpp
@@ -74,7 +74,7 @@ bool UARTDebugger::has_buffered_bytes_() { return !this->bytes_.empty(); }
 
 void UARTDebugger::fire_trigger_() {
   this->is_triggering_ = true;
-  trigger(this->last_direction_, this->bytes_);
+  trigger(this->last_direction_, this->bytes_, this->debug_prefix_);
   this->bytes_.clear();
   this->is_triggering_ = false;
 }
@@ -94,7 +94,7 @@ void UARTDummyReceiver::loop() {
 // TCP connection(s). Without these delays, debug log lines could go
 // missing when UART devices block the main loop for too long.
 
-void UARTDebug::log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator) {
+void UARTDebug::log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator, StringRef prefix) {
   std::string res;
   if (direction == UART_DIRECTION_RX) {
     res += "<<< ";
@@ -110,11 +110,11 @@ void UARTDebug::log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uin
     buf_append_printf(buf, sizeof(buf), 0, "%02X", bytes[i]);
     res += buf;
   }
-  ESP_LOGD(TAG, "%s", res.c_str());
+  ESP_LOGD(TAG, "%s%s", prefix.c_str(), res.c_str());
   delay(10);
 }
 
-void UARTDebug::log_string(UARTDirection direction, std::vector<uint8_t> bytes) {
+void UARTDebug::log_string(UARTDirection direction, std::vector<uint8_t> bytes, StringRef prefix) {
   std::string res;
   if (direction == UART_DIRECTION_RX) {
     res += "<<< \"";
@@ -154,11 +154,11 @@ void UARTDebug::log_string(UARTDirection direction, std::vector<uint8_t> bytes)
     }
   }
   res += '"';
-  ESP_LOGD(TAG, "%s", res.c_str());
+  ESP_LOGD(TAG, "%s%s", prefix.c_str(), res.c_str());
   delay(10);
 }
 
-void UARTDebug::log_int(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator) {
+void UARTDebug::log_int(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator, StringRef prefix) {
   std::string res;
   size_t len = bytes.size();
   if (direction == UART_DIRECTION_RX) {
@@ -174,11 +174,11 @@ void UARTDebug::log_int(UARTDirection direction, std::vector<uint8_t> bytes, uin
     buf_append_printf(buf, sizeof(buf), 0, "%u", bytes[i]);
     res += buf;
   }
-  ESP_LOGD(TAG, "%s", res.c_str());
+  ESP_LOGD(TAG, "%s%s", prefix.c_str(), res.c_str());
   delay(10);
 }
 
-void UARTDebug::log_binary(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator) {
+void UARTDebug::log_binary(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator, StringRef prefix) {
   std::string res;
   size_t len = bytes.size();
   if (direction == UART_DIRECTION_RX) {
@@ -194,7 +194,7 @@ void UARTDebug::log_binary(UARTDirection direction, std::vector<uint8_t> bytes,
     buf_append_printf(buf, sizeof(buf), 0, "0b" BYTE_TO_BINARY_PATTERN " (0x%02X)", BYTE_TO_BINARY(bytes[i]), bytes[i]);
     res += buf;
   }
-  ESP_LOGD(TAG, "%s", res.c_str());
+  ESP_LOGD(TAG, "%s%s", prefix.c_str(), res.c_str());
   delay(10);
 }
 
diff --git a/esphome/components/uart/uart_debugger.h b/esphome/components/uart/uart_debugger.h
index df87655962..da33bea70c 100644
--- a/esphome/components/uart/uart_debugger.h
+++ b/esphome/components/uart/uart_debugger.h
@@ -5,6 +5,7 @@
 #include <vector>
 #include "esphome/core/component.h"
 #include "esphome/core/automation.h"
+#include "esphome/core/string_ref.h"
 #include "uart.h"
 #include "uart_component.h"
 
@@ -17,7 +18,7 @@ namespace esphome::uart {
 /// 'appropriate time' means exactly, is determined by a number of
 /// configurable constraints. E.g. when a given number of bytes is gathered
 /// and/or when no more data has been seen for a given time interval.
-class UARTDebugger : public Component, public Trigger<UARTDirection, std::vector<uint8_t>> {
+class UARTDebugger : public Component, public Trigger<UARTDirection, std::vector<uint8_t>, StringRef> {
  public:
   explicit UARTDebugger(UARTComponent *parent);
   void loop() override;
@@ -41,6 +42,8 @@ class UARTDebugger : public Component, public Trigger<UARTDirection, std::vector
   /// logging will be triggered.
   void add_delimiter_byte(uint8_t byte) { this->after_delimiter_.push_back(byte); }
 
+  void set_debug_prefix(const char *prefix) { this->debug_prefix_ = StringRef(prefix); }
+
  protected:
   UARTDirection for_direction_;
   UARTDirection last_direction_{};
@@ -51,6 +54,7 @@ class UARTDebugger : public Component, public Trigger<UARTDirection, std::vector
   std::vector<uint8_t> after_delimiter_{};
   size_t after_delimiter_pos_{};
   bool is_triggering_{false};
+  StringRef debug_prefix_{};
 
   bool is_my_direction_(UARTDirection direction);
   bool is_recursive_();
@@ -81,18 +85,21 @@ class UARTDebug {
  public:
   /// Log the bytes as hex values, separated by the provided separator
   /// character.
-  static void log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator);
+  static void log_hex(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator,
+                      StringRef prefix = StringRef());
 
   /// Log the bytes as string values, escaping unprintable characters.
-  static void log_string(UARTDirection direction, std::vector<uint8_t> bytes);
+  static void log_string(UARTDirection direction, std::vector<uint8_t> bytes, StringRef prefix = StringRef());
 
   /// Log the bytes as integer values, separated by the provided separator
   /// character.
-  static void log_int(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator);
+  static void log_int(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator,
+                      StringRef prefix = StringRef());
 
   /// Log the bytes as '<binary> (<hex>)' values, separated by the provided
   /// separator.
-  static void log_binary(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator);
+  static void log_binary(UARTDirection direction, std::vector<uint8_t> bytes, uint8_t separator,
+                         StringRef prefix = StringRef());
 };
 
 }  // namespace esphome::uart
diff --git a/esphome/components/usb_uart/__init__.py b/esphome/components/usb_uart/__init__.py
index f0ee53d028..eedf590eca 100644
--- a/esphome/components/usb_uart/__init__.py
+++ b/esphome/components/usb_uart/__init__.py
@@ -1,7 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import socket
 from esphome.components.const import CONF_DATA_BITS, CONF_PARITY, CONF_STOP_BITS
-from esphome.components.uart import UARTComponent
+from esphome.components.uart import CONF_DEBUG_PREFIX, UARTComponent
 from esphome.components.usb_host import register_usb_client, usb_device_schema
 import esphome.config_validation as cv
 from esphome.const import (
@@ -90,6 +90,7 @@ def channel_schema(channels, baud_rate_required):
                             ),
                             cv.Optional(CONF_DUMMY_RECEIVER, default=False): cv.boolean,
                             cv.Optional(CONF_DEBUG, default=False): cv.boolean,
+                            cv.Optional(CONF_DEBUG_PREFIX, default=""): cv.string,
                         }
                     )
                 ),
@@ -129,6 +130,8 @@ async def to_code(config):
             cg.add(chvar.set_baud_rate(channel[CONF_BAUD_RATE]))
             cg.add(chvar.set_dummy_receiver(channel[CONF_DUMMY_RECEIVER]))
             cg.add(chvar.set_debug(channel[CONF_DEBUG]))
+            if channel[CONF_DEBUG_PREFIX]:
+                cg.add(chvar.set_debug_prefix(channel[CONF_DEBUG_PREFIX]))
             cg.add(var.add_channel(chvar))
             if channel[CONF_DEBUG]:
                 cg.add_define("USE_UART_DEBUGGER")
diff --git a/esphome/components/usb_uart/usb_uart.cpp b/esphome/components/usb_uart/usb_uart.cpp
index e20bbd02db..a1f8738491 100644
--- a/esphome/components/usb_uart/usb_uart.cpp
+++ b/esphome/components/usb_uart/usb_uart.cpp
@@ -142,7 +142,7 @@ void USBUartChannel::write_array(const uint8_t *data, size_t len) {
       size_t n = std::min(len - off, BATCH);
       memcpy(buf, ">>> ", 4);
       format_hex_pretty_to(buf + 4, sizeof(buf) - 4, data + off, n, ',');
-      ESP_LOGD(TAG, "%s", buf);
+      ESP_LOGD(TAG, "%s%s", this->debug_prefix_.c_str(), buf);
     }
   }
 #endif
@@ -219,7 +219,7 @@ void USBUartComponent::loop() {
       char buf[4 + format_hex_pretty_size(UsbDataChunk::MAX_CHUNK_SIZE)];  // "<<< " + hex
       memcpy(buf, "<<< ", 4);
       format_hex_pretty_to(buf + 4, sizeof(buf) - 4, chunk->data, chunk->length, ',');
-      ESP_LOGD(TAG, "%s", buf);
+      ESP_LOGD(TAG, "%s%s", channel->debug_prefix_.c_str(), buf);
     }
 #endif
 
diff --git a/esphome/components/usb_uart/usb_uart.h b/esphome/components/usb_uart/usb_uart.h
index 0d471e46f6..7290f8a958 100644
--- a/esphome/components/usb_uart/usb_uart.h
+++ b/esphome/components/usb_uart/usb_uart.h
@@ -3,6 +3,7 @@
 #if defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || defined(USE_ESP32_VARIANT_ESP32S3)
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/string_ref.h"
 #include "esphome/components/uart/uart_component.h"
 #include "esphome/components/usb_host/usb_host.h"
 #include "esphome/core/lock_free_queue.h"
@@ -114,6 +115,7 @@ class USBUartChannel : public uart::UARTComponent, public Parented<USBUartCompon
   void set_parity(UARTParityOptions parity) { this->parity_ = parity; }
   void set_debug(bool debug) { this->debug_ = debug; }
   void set_dummy_receiver(bool dummy_receiver) { this->dummy_receiver_ = dummy_receiver; }
+  void set_debug_prefix(const char *prefix) { this->debug_prefix_ = StringRef(prefix); }
 
   /// Register a callback invoked immediately after data is pushed to the input ring buffer.
   /// Called from USBUartComponent::loop() in the main loop context.
@@ -138,6 +140,7 @@ class USBUartChannel : public uart::UARTComponent, public Parented<USBUartCompon
   const uint8_t index_;
   bool debug_{};
   bool dummy_receiver_{};
+  StringRef debug_prefix_{};
 };
 
 class USBUartComponent : public usb_host::USBClient {
diff --git a/esphome/components/whirlpool/whirlpool.cpp b/esphome/components/whirlpool/whirlpool.cpp
index e9f602e97f..86209cb7a6 100644
--- a/esphome/components/whirlpool/whirlpool.cpp
+++ b/esphome/components/whirlpool/whirlpool.cpp
@@ -32,6 +32,13 @@ const uint8_t WHIRLPOOL_SWING_MASK = 128;
 
 const uint8_t WHIRLPOOL_POWER = 0x04;
 
+WhirlpoolClimate::WhirlpoolClimate()
+    : climate_ir::ClimateIR(
+          WHIRLPOOL_DG11J1_3A_TEMP_MIN, WHIRLPOOL_DG11J1_3A_TEMP_MAX, 1.0f, true, true,
+          {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM, climate::CLIMATE_FAN_HIGH},
+          {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL}),
+      model_(MODEL_DG11J1_3A) {}
+
 void WhirlpoolClimate::transmit_state() {
   this->last_transmit_time_ = millis();  // setting the time of the last transmission.
   uint8_t remote_state[WHIRLPOOL_STATE_LENGTH] = {0};
diff --git a/esphome/components/whirlpool/whirlpool.h b/esphome/components/whirlpool/whirlpool.h
index 992b2a7adf..ada5a36de9 100644
--- a/esphome/components/whirlpool/whirlpool.h
+++ b/esphome/components/whirlpool/whirlpool.h
@@ -19,11 +19,7 @@ const float WHIRLPOOL_DG11J1_91_TEMP_MIN = 16.0;
 
 class WhirlpoolClimate : public climate_ir::ClimateIR {
  public:
-  WhirlpoolClimate()
-      : climate_ir::ClimateIR(temperature_min_(), temperature_max_(), 1.0f, true, true,
-                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
-                               climate::CLIMATE_FAN_HIGH},
-                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL}) {}
+  WhirlpoolClimate();
 
   void setup() override {
     climate_ir::ClimateIR::setup();
@@ -37,7 +33,11 @@ class WhirlpoolClimate : public climate_ir::ClimateIR {
     climate_ir::ClimateIR::control(call);
   }
 
-  void set_model(Model model) { this->model_ = model; }
+  void set_model(Model model) {
+    this->model_ = model;
+    this->minimum_temperature_ = temperature_min_();
+    this->maximum_temperature_ = temperature_max_();
+  }
 
   // used to track when to send the power toggle command
   bool powered_on_assumed;
diff --git a/tests/components/uart/test.esp32-c3-idf.yaml b/tests/components/uart/test.esp32-c3-idf.yaml
index b053290a8b..2eae37e824 100644
--- a/tests/components/uart/test.esp32-c3-idf.yaml
+++ b/tests/components/uart/test.esp32-c3-idf.yaml
@@ -1,11 +1,15 @@
 esphome:
   on_boot:
     then:
-      - uart.write: 'Hello World'
-      - uart.write: [0x00, 0x20, 0x42]
+      - uart.write:
+          id: uart_id
+          data: 'Hello World'
+      - uart.write:
+          id: uart_id
+          data: [0x00, 0x20, 0x42]
 
 uart:
-  - id: uart_uart
+  - id: uart_id
     tx_pin: 4
     rx_pin: 5
     flow_control_pin: 6
@@ -16,3 +20,9 @@ uart:
     rx_timeout: 1
     parity: EVEN
     stop_bits: 2
+  - id: uart_debug
+    tx_pin: 18
+    rx_pin: 19
+    baud_rate: 115200
+    debug:
+      debug_prefix: "[UART1] "
diff --git a/tests/components/uart/test.esp32-idf.yaml b/tests/components/uart/test.esp32-idf.yaml
index 2a97f9a5de..fa76316b9c 100644
--- a/tests/components/uart/test.esp32-idf.yaml
+++ b/tests/components/uart/test.esp32-idf.yaml
@@ -1,13 +1,19 @@
 esphome:
   on_boot:
     then:
-      - uart.write: 'Hello World'
-      - uart.write: [0x00, 0x20, 0x42]
-      - uart.write: !lambda |-
-          return {0xAA, 0xBB, 0xCC};
+      - uart.write:
+          id: uart_id
+          data: 'Hello World'
+      - uart.write:
+          id: uart_id
+          data: [0x00, 0x20, 0x42]
+      - uart.write:
+          id: uart_id
+          data: !lambda |-
+            return {0xAA, 0xBB, 0xCC};
 
 uart:
-  - id: uart_uart
+  - id: uart_id
     tx_pin: 17
     rx_pin: 16
     flow_control_pin: 4
@@ -18,32 +24,54 @@ uart:
     rx_timeout: 1
     parity: EVEN
     stop_bits: 2
+  - id: uart_debug
+    tx_pin: 21
+    rx_pin: 22
+    baud_rate: 115200
+    debug:
+      debug_prefix: "[UART1] "
+  - id: uart_debug_custom
+    tx_pin: 25
+    rx_pin: 26
+    baud_rate: 9600
+    debug:
+      debug_prefix: "[UART2] "
+      after:
+        delimiter: "\n"
+      sequence:
+        - lambda: UARTDebug::log_string(direction, bytes, debug_prefix);
+  - id: uart_debug_no_prefix
+    tx_pin: 32
+    rx_pin: 33
+    baud_rate: 9600
+    debug:
 
 packet_transport:
   - platform: uart
+    uart_id: uart_id
 
 switch:
   # Test uart switch with single state (array)
   - platform: uart
     name: "UART Switch Single Array"
-    uart_id: uart_uart
+    uart_id: uart_id
     data: [0x01, 0x02, 0x03]
   # Test uart switch with single state (string)
   - platform: uart
     name: "UART Switch Single String"
-    uart_id: uart_uart
+    uart_id: uart_id
     data: "ON"
   # Test uart switch with turn_on/turn_off (arrays)
   - platform: uart
     name: "UART Switch Dual Array"
-    uart_id: uart_uart
+    uart_id: uart_id
     data:
       turn_on: [0xA0, 0xA1, 0xA2]
       turn_off: [0xB0, 0xB1, 0xB2]
   # Test uart switch with turn_on/turn_off (strings)
   - platform: uart
     name: "UART Switch Dual String"
-    uart_id: uart_uart
+    uart_id: uart_id
     data:
       turn_on: "TURN_ON"
       turn_off: "TURN_OFF"
@@ -61,24 +89,26 @@ button:
   # Test uart button with array data
   - platform: uart
     name: "UART Button Array"
-    uart_id: uart_uart
+    uart_id: uart_id
     data: [0xFF, 0xEE, 0xDD]
   # Test uart button with string data
   - platform: uart
     name: "UART Button String"
-    uart_id: uart_uart
+    uart_id: uart_id
     data: "BUTTON_PRESS"
   # Test uart button with lambda (function pointer)
   - platform: template
     name: "UART Lambda Test"
     on_press:
-      - uart.write: !lambda |-
-          std::string cmd = "VALUE=" + str_sprintf("%.0f", id(test_number).state) + "\r\n";
-          return std::vector<uint8_t>(cmd.begin(), cmd.end());
+      - uart.write:
+          id: uart_id
+          data: !lambda |-
+            std::string cmd = "VALUE=" + str_sprintf("%.0f", id(test_number).state) + "\r\n";
+            return std::vector<uint8_t>(cmd.begin(), cmd.end());
 
 event:
   - platform: uart
-    uart_id: uart_uart
+    uart_id: uart_id
     name: "UART Event"
     event_types:
       - "string_event_A": "*A#"
diff --git a/tests/components/uart/test.esp8266-ard.yaml b/tests/components/uart/test.esp8266-ard.yaml
index c2670b289a..4c9d6fd736 100644
--- a/tests/components/uart/test.esp8266-ard.yaml
+++ b/tests/components/uart/test.esp8266-ard.yaml
@@ -1,11 +1,15 @@
 esphome:
   on_boot:
     then:
-      - uart.write: 'Hello World'
-      - uart.write: [0x00, 0x20, 0x42]
+      - uart.write:
+          id: uart_id
+          data: 'Hello World'
+      - uart.write:
+          id: uart_id
+          data: [0x00, 0x20, 0x42]
 
 uart:
-  - id: uart_uart
+  - id: uart_id
     tx_pin: 4
     rx_pin: 5
     baud_rate: 9600
@@ -13,15 +17,21 @@ uart:
     rx_buffer_size: 512
     parity: EVEN
     stop_bits: 2
+  - id: uart_debug
+    tx_pin: 14
+    rx_pin: 12
+    baud_rate: 115200
+    debug:
+      debug_prefix: "[UART1] "
 
 switch:
   - platform: uart
     name: "UART Switch Array"
-    uart_id: uart_uart
+    uart_id: uart_id
     data: [0x01, 0x02, 0x03]
   - platform: uart
     name: "UART Switch Dual"
-    uart_id: uart_uart
+    uart_id: uart_id
     data:
       turn_on: [0xA0, 0xA1]
       turn_off: [0xB0, 0xB1]
@@ -29,12 +39,12 @@ switch:
 button:
   - platform: uart
     name: "UART Button"
-    uart_id: uart_uart
+    uart_id: uart_id
     data: [0xFF, 0xEE]
 
 event:
   - platform: uart
-    uart_id: uart_uart
+    uart_id: uart_id
     name: "UART Event"
     event_types:
       - "string_event_A": "*A#"
diff --git a/tests/components/uart/test.host.yaml b/tests/components/uart/test.host.yaml
index 63f0ade084..bc64245c7b 100644
--- a/tests/components/uart/test.host.yaml
+++ b/tests/components/uart/test.host.yaml
@@ -5,7 +5,7 @@ esphome:
       - uart.write: [0x00, 0x20, 0x42]
 
 uart:
-  - id: uart_uart
+  - id: uart_id
     port: "/dev/ttyS0"
     baud_rate: 9600
     data_bits: 8
diff --git a/tests/components/uart/test.rp2040-ard.yaml b/tests/components/uart/test.rp2040-ard.yaml
index 09178f1663..5eb2b533ea 100644
--- a/tests/components/uart/test.rp2040-ard.yaml
+++ b/tests/components/uart/test.rp2040-ard.yaml
@@ -1,11 +1,15 @@
 esphome:
   on_boot:
     then:
-      - uart.write: 'Hello World'
-      - uart.write: [0x00, 0x20, 0x42]
+      - uart.write:
+          id: uart_id
+          data: 'Hello World'
+      - uart.write:
+          id: uart_id
+          data: [0x00, 0x20, 0x42]
 
 uart:
-  - id: uart_uart
+  - id: uart_id
     tx_pin: 4
     rx_pin: 5
     baud_rate: 9600
@@ -13,3 +17,9 @@ uart:
     rx_buffer_size: 512
     parity: EVEN
     stop_bits: 2
+  - id: uart_debug
+    tx_pin: 8
+    rx_pin: 9
+    baud_rate: 115200
+    debug:
+      debug_prefix: "[UART1] "
diff --git a/tests/components/usb_uart/common.yaml b/tests/components/usb_uart/common.yaml
index 474c3f5c8d..5869b9468b 100644
--- a/tests/components/usb_uart/common.yaml
+++ b/tests/components/usb_uart/common.yaml
@@ -34,3 +34,11 @@ usb_uart:
       - id: channel_4_1
         debug: true
         dummy_receiver: true
+        debug_prefix: "[ESP_JTAG] "
+  - id: uart_5
+    type: cp210x
+    channels:
+      - id: channel_5_1
+        baud_rate: 9600
+        debug: true
+        debug_prefix: "[CP210X] "
diff --git a/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp b/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
index affcc8d908..e8c07d632d 100644
--- a/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
+++ b/tests/integration/fixtures/external_components/uart_mock/uart_mock.cpp
@@ -104,12 +104,12 @@ void MockUartComponent::write_array(const uint8_t *data, size_t len) {
   }
 #endif
 
-  if (this->scenario_active_) {
-    this->try_match_response_();
-  }
+  // Responses are always active - they are request-response pairs triggered by
+  // component TX, not timed injections. No race condition with test subscription.
+  this->try_match_response_();
 
   // This directly calls a tx_hook (lambda) as an alternative to the simpler match_response mechanism.
-  if (this->tx_hook_ && this->scenario_active_) {
+  if (this->tx_hook_) {
     std::vector<uint8_t> buf(data, data + len);
     this->tx_hook_(buf);
   }
diff --git a/tests/integration/fixtures/uart_mock_ld2420.yaml b/tests/integration/fixtures/uart_mock_ld2420.yaml
new file mode 100644
index 0000000000..5380b81071
--- /dev/null
+++ b/tests/integration/fixtures/uart_mock_ld2420.yaml
@@ -0,0 +1,187 @@
+esphome:
+  name: uart-mock-ld2420-test
+
+host:
+api:
+logger:
+  level: VERBOSE
+
+external_components:
+  - source:
+      type: local
+      path: EXTERNAL_COMPONENT_PATH
+
+# Dummy uart entry to satisfy ld2420's DEPENDENCIES = ["uart"]
+# The actual UART bus used is the uart_mock component below
+uart:
+  baud_rate: 115200
+  port: /dev/null
+
+uart_mock:
+  id: mock_uart
+  baud_rate: 115200
+  auto_start: false
+  responses:
+    # Version-specific response: match the complete firmware version command TX.
+    # CMD_READ_VERSION (0x0000) TX = FD FC FB FA 02 00 00 00 04 03 02 01
+    # Returns "v2.0.0" → get_firmware_int = 200 >= 154 → energy mode
+    #
+    # Response layout:
+    #   [0-3]   FD FC FB FA = header
+    #   [4-5]   0C 00       = length 12
+    #   [6]     00          = cmd (CMD_READ_VERSION)
+    #   [7]     01          = status (ACK)
+    #   [8-9]   00 00       = error = 0
+    #   [10]    06          = ver_len = 6
+    #   [11]    00          = padding
+    #   [12-17] "v2.0.0"   = version string
+    #   [18-21] 04 03 02 01 = footer
+    - expect_tx:
+        [0xFD, 0xFC, 0xFB, 0xFA, 0x02, 0x00, 0x00, 0x00, 0x04, 0x03, 0x02, 0x01]
+      inject_rx:
+        [
+          0xFD, 0xFC, 0xFB, 0xFA,
+          0x0C, 0x00,
+          0x00, 0x01,
+          0x00, 0x00,
+          0x06, 0x00,
+          0x76, 0x32, 0x2E, 0x30, 0x2E, 0x30,
+          0x04, 0x03, 0x02, 0x01,
+        ]
+
+    # Catch-all response: match any command footer (04 03 02 01).
+    # Returns a generic ACK with cmd=0xFF (CMD_ENABLE_CONF case in switch).
+    # All commands get unblocked via cmd_reply_.ack = true.
+    # Data fields stay zeroed (min_gate=0, max_gate=0, timeout=0, thresholds=0).
+    #
+    # Response layout:
+    #   [0-3]  FD FC FB FA = header
+    #   [4-5]  04 00       = length 4
+    #   [6]    FF          = cmd (handled as CMD_ENABLE_CONF)
+    #   [7]    01          = status (ACK)
+    #   [8-9]  00 00       = error = 0
+    #   [10-13] 04 03 02 01 = footer
+    - expect_tx: [0x04, 0x03, 0x02, 0x01]
+      inject_rx:
+        [
+          0xFD, 0xFC, 0xFB, 0xFA,
+          0x04, 0x00,
+          0xFF, 0x01,
+          0x00, 0x00,
+          0x04, 0x03, 0x02, 0x01,
+        ]
+
+  injections:
+    # Phase 1 (t=100ms): Valid LD2420 energy mode data frame - happy path
+    # Buffer is clean (buffer_pos_=0). This frame should parse correctly.
+    # Presence: 1 (target detected), Distance: 100cm, Gate energies: all 0
+    #
+    # Energy frame layout (45 bytes):
+    #   [0-3]   F4 F3 F2 F1 = energy frame header
+    #   [4-5]   23 00       = length 35 (1+2+32)
+    #   [6]     01          = presence (1 = target)
+    #   [7-8]   64 00       = distance 100 (uint16_t LE)
+    #   [9-40]  00 00 x16   = 16 gate energies (uint16_t LE each)
+    #   [41-44] F8 F7 F6 F5 = energy frame footer
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x23, 0x00,
+          0x01,
+          0x64, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+    # Phase 2 (t=300ms): Garbage bytes
+    # LD2420's readline_ does NOT check frame headers at position 0 (unlike LD2412),
+    # so these bytes accumulate in the buffer. buffer_pos_ goes from 0 to 7.
+    - delay: 200ms
+      inject_rx: [0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11, 0x22]
+
+    # Phase 3 (t=400ms): Truncated energy frame WITH footer (13 bytes)
+    # This tests PR #14458 bug #3: missing length validation in handle_energy_mode_.
+    # The 7 garbage bytes from Phase 2 are still in the buffer (buffer_pos_=7).
+    # These 13 bytes are appended at positions 7-19 (buffer_pos_=20).
+    # Energy footer at positions 16-19 triggers handle_energy_mode_(buffer, 20).
+    #
+    # Pre-fix: handle_energy_mode_ reads 32 bytes of gate energy from buffer[9:40],
+    #          which is past the 20 actual bytes. Reads uninitialized data.
+    #          No "Energy frame too short" warning exists.
+    # Post-fix: len=20 < 41 → logs "Energy frame too short: 20 bytes", returns early.
+    #
+    # Frame: header + length + presence + distance + footer (no gate data)
+    - delay: 100ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x23, 0x00,
+          0x01,
+          0x64, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+    # Phase 4 (t=600ms): Overflow - inject 50 bytes of 0xFF (MAX_LINE_LENGTH=50)
+    # After Phase 3, buffer_pos_=0 (reset after energy footer detection).
+    # 49 bytes fill positions 0-48 (buffer_pos_=49), 50th byte triggers overflow.
+    # Logs "Max command length exceeded; ignoring", buffer_pos_=0.
+    - delay: 200ms
+      inject_rx:
+        [
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        ]
+
+    # Phase 5 (t=1500ms): Valid frame after overflow - recovery test
+    # Buffer was reset by overflow. This valid frame should parse correctly.
+    # Presence: 1 (target), Distance: 50cm
+    # Delay=900ms ensures >1000ms gap from Phase 1 for REFRESH_RATE_MS throttle.
+    - delay: 900ms
+      inject_rx:
+        [
+          0xF4, 0xF3, 0xF2, 0xF1,
+          0x23, 0x00,
+          0x01,
+          0x32, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0xF8, 0xF7, 0xF6, 0xF5,
+        ]
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    on_press:
+      - lambda: 'id(mock_uart).start_scenario();'
+
+ld2420:
+  id: ld2420_dev
+  uart_id: mock_uart
+
+sensor:
+  - platform: ld2420
+    ld2420_id: ld2420_dev
+    moving_distance:
+      name: "Moving Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+
+binary_sensor:
+  - platform: ld2420
+    ld2420_id: ld2420_dev
+    has_target:
+      name: "Has Target"
+      filters:
+        - settle: 50ms
diff --git a/tests/integration/fixtures/uart_mock_ld2420_simple.yaml b/tests/integration/fixtures/uart_mock_ld2420_simple.yaml
new file mode 100644
index 0000000000..2ceca5d35d
--- /dev/null
+++ b/tests/integration/fixtures/uart_mock_ld2420_simple.yaml
@@ -0,0 +1,141 @@
+esphome:
+  name: uart-mock-ld2420-simple-test
+
+host:
+api:
+logger:
+  level: VERBOSE
+
+external_components:
+  - source:
+      type: local
+      path: EXTERNAL_COMPONENT_PATH
+
+# Dummy uart entry to satisfy ld2420's DEPENDENCIES = ["uart"]
+uart:
+  baud_rate: 115200
+  port: /dev/null
+
+uart_mock:
+  id: mock_uart
+  baud_rate: 115200
+  auto_start: false
+  responses:
+    # Catch-all response only (no version-specific response).
+    # Without a version response, firmware_ver_ stays at default "v0.0.0".
+    # get_firmware_int("v0.0.0") = 0 < 154 → simple mode (CMD_SYSTEM_MODE_SIMPLE).
+    - expect_tx: [0x04, 0x03, 0x02, 0x01]
+      inject_rx:
+        [
+          0xFD, 0xFC, 0xFB, 0xFA,
+          0x04, 0x00,
+          0xFF, 0x01,
+          0x00, 0x00,
+          0x04, 0x03, 0x02, 0x01,
+        ]
+
+  injections:
+    # Phase 1 (t=100ms): Valid simple mode text frame - happy path
+    # "ON Range 0100\r\n" → presence=true, distance=100
+    # Simple mode frames end with \r\n (0x0D 0x0A), triggering handle_simple_mode_.
+    - delay: 100ms
+      inject_rx:
+        [
+          0x4F, 0x4E, 0x20, 0x52, 0x61, 0x6E, 0x67, 0x65, 0x20,
+          0x30, 0x31, 0x30, 0x30,
+          0x0D, 0x0A,
+        ]
+
+    # Phase 2 (t=300ms): Garbage bytes
+    # LD2420's readline_ stores all bytes regardless of header. buffer_pos_ = 7.
+    - delay: 200ms
+      inject_rx: [0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x11, 0x22]
+
+    # Phase 3 (t=500ms): Overflow - inject 50 bytes of 0xFF (MAX_LINE_LENGTH=50)
+    # buffer_pos_ starts at 7 (from Phase 2 garbage).
+    # Positions 7-48 fill (42 bytes), byte 43 triggers overflow (buffer_pos_=49).
+    # After overflow: buffer_pos_=0, remaining 7 bytes fill positions 0-6.
+    # Final buffer_pos_ = 7.
+    - delay: 200ms
+      inject_rx:
+        [
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+          0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+        ]
+
+    # Phase 4 (t=1400ms): Recovery after overflow
+    # buffer_pos_ = 7 (from overflow remainder). These 15 bytes fill positions 7-21.
+    # At position 21 (0x0A), \r\n detected → handle_simple_mode_(buffer, 22).
+    # Parser skips 0xFF bytes at positions 0-6, finds "ON" at positions 7-8,
+    # parses digits "0050" → distance=50.
+    # Delay=900ms ensures >1000ms gap from Phase 1 for REFRESH_RATE_MS throttle.
+    - delay: 900ms
+      inject_rx:
+        [
+          0x4F, 0x4E, 0x20, 0x52, 0x61, 0x6E, 0x67, 0x65, 0x20,
+          0x30, 0x30, 0x35, 0x30,
+          0x0D, 0x0A,
+        ]
+
+    # Phase 5 (t=2500ms): 16-digit distance - tests PR #14458 bug #1
+    # "ON Range 0000000000000000\r\n" has 16 digit characters.
+    # handle_simple_mode_ outbuf is 16 bytes, can hold 15 digits (index 0-14).
+    #
+    # Pre-fix: At the 16th digit, index=15, (index < bufsize-1) is false.
+    #          The digit branch doesn't increment pos. The else branch is skipped.
+    #          pos stays at the 16th digit FOREVER → INFINITE LOOP.
+    #          The binary hangs, no more state updates, test times out.
+    # Post-fix: pos always increments (moved outside digit branch).
+    #          16th digit skipped, loop continues to \r\n. distance=0.
+    - delay: 1100ms
+      inject_rx:
+        [
+          0x4F, 0x4E, 0x20, 0x52, 0x61, 0x6E, 0x67, 0x65, 0x20,
+          0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+          0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+          0x0D, 0x0A,
+        ]
+
+    # Phase 6 (t=3700ms): Post-bug-trigger recovery
+    # If Phase 5 didn't hang, this frame should parse correctly.
+    # "ON Range 0025\r\n" → distance=25
+    # Delay=1200ms ensures >1000ms gap from Phase 5 for throttle.
+    - delay: 1200ms
+      inject_rx:
+        [
+          0x4F, 0x4E, 0x20, 0x52, 0x61, 0x6E, 0x67, 0x65, 0x20,
+          0x30, 0x30, 0x32, 0x35,
+          0x0D, 0x0A,
+        ]
+
+button:
+  - platform: template
+    name: "Start Scenario"
+    on_press:
+      - lambda: 'id(mock_uart).start_scenario();'
+
+ld2420:
+  id: ld2420_dev
+  uart_id: mock_uart
+
+sensor:
+  - platform: ld2420
+    ld2420_id: ld2420_dev
+    moving_distance:
+      name: "Moving Distance"
+      filters:
+        - timeout:
+            timeout: 50ms
+            value: last
+        - throttle_with_priority: 50ms
+
+binary_sensor:
+  - platform: ld2420
+    ld2420_id: ld2420_dev
+    has_target:
+      name: "Has Target"
+      filters:
+        - settle: 50ms
diff --git a/tests/integration/test_uart_mock_ld2420.py b/tests/integration/test_uart_mock_ld2420.py
new file mode 100644
index 0000000000..ae28da4d3e
--- /dev/null
+++ b/tests/integration/test_uart_mock_ld2420.py
@@ -0,0 +1,273 @@
+"""Integration test for LD2420 component with mock UART.
+
+Tests:
+test_uart_mock_ld2420 (energy mode):
+  1. Happy path - valid energy frame publishes correct sensor values
+  2. Garbage resilience - random bytes don't crash the component
+  3. Truncated energy frame - triggers "Energy frame too short" warning (PR #14458 bug #3)
+  4. Buffer overflow recovery - overflow resets the parser
+  5. Post-overflow parsing - next valid frame after overflow is parsed correctly
+  6. TX logging - verifies LD2420 sends expected setup commands
+
+test_uart_mock_ld2420_simple (simple mode):
+  1. Happy path - valid simple mode text frame publishes correct values
+  2. Garbage resilience
+  3. Buffer overflow recovery
+  4. 16-digit distance triggers infinite loop pre-fix (PR #14458 bug #1)
+  5. Post-bug-trigger recovery proves the parser survived
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from aioesphomeapi import ButtonInfo
+import pytest
+
+from .state_utils import InitialStateHelper, SensorStateCollector, find_entity
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_uart_mock_ld2420(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test LD2420 energy mode: happy path, truncated frame, overflow, and recovery."""
+    # Replace external component path placeholder
+    external_components_path = str(
+        Path(__file__).parent / "fixtures" / "external_components"
+    )
+    yaml_config = yaml_config.replace(
+        "EXTERNAL_COMPONENT_PATH", external_components_path
+    )
+
+    loop = asyncio.get_running_loop()
+
+    # Track overflow warning in logs
+    overflow_seen = loop.create_future()
+
+    # Track "Energy frame too short" warning (PR #14458 bug #3 fix)
+    # This message ONLY exists after the fix. Pre-fix, handle_energy_mode_
+    # silently reads past the buffer without any warning.
+    truncated_frame_warning_seen = loop.create_future()
+
+    # Track TX data logged by the mock for assertions
+    tx_log_lines: list[str] = []
+
+    def line_callback(line: str) -> None:
+        if "Max command length exceeded" in line and not overflow_seen.done():
+            overflow_seen.set_result(True)
+        if "Energy frame too short" in line and not truncated_frame_warning_seen.done():
+            truncated_frame_warning_seen.set_result(True)
+        # Capture all TX log lines from uart_mock
+        if "uart_mock" in line and "TX " in line:
+            tx_log_lines.append(line)
+
+    collector = SensorStateCollector(
+        sensor_names=["moving_distance"],
+        binary_sensor_names=["has_target"],
+    )
+
+    # Signal when we see recovery frame values
+    recovery_received = collector.add_waiter(
+        lambda: pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+    )
+
+    async with (
+        run_compiled(yaml_config, line_callback=line_callback),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+        collector.build_key_mapping(entities)
+
+        # Set up initial state helper
+        initial_state_helper = InitialStateHelper(entities)
+        client.subscribe_states(
+            initial_state_helper.on_state_wrapper(collector.on_state)
+        )
+
+        try:
+            await initial_state_helper.wait_for_initial_states()
+        except TimeoutError:
+            pytest.fail("Timeout waiting for initial states")
+
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
+        # Wait for Phase 1 - all sensors and binary sensors have at least one value
+        try:
+            await collector.wait_for_all(timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 1 frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}\n"
+                f"  binary_states: {collector.binary_states}"
+            )
+
+        # Phase 1 values: moving=100, has_target=true
+        assert collector.sensor_states["moving_distance"][0] == pytest.approx(100.0)
+        assert collector.binary_states["has_target"][0] is True
+
+        # Wait for the recovery frame (Phase 5) to be parsed
+        # This proves the component survived garbage + truncated + overflow
+        try:
+            await asyncio.wait_for(recovery_received, timeout=5.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for recovery frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}"
+            )
+
+        # Verify overflow warning was logged
+        assert overflow_seen.done(), (
+            "Expected 'Max command length exceeded' warning in logs"
+        )
+
+        # Verify truncated frame warning was logged (PR #14458 bug #3)
+        # This assertion FAILS before PR #14458 because the length check
+        # and warning message did not exist.
+        assert truncated_frame_warning_seen.done(), (
+            "Expected 'Energy frame too short' warning in logs. "
+            "This indicates PR #14458 fix for handle_energy_mode_ length "
+            "validation is missing."
+        )
+
+        # Verify LD2420 sent setup commands (TX logging)
+        assert len(tx_log_lines) > 0, "Expected TX log lines from uart_mock"
+        tx_data = " ".join(tx_log_lines)
+        # Verify command frame header appears (FD:FC:FB:FA)
+        assert "FD.FC.FB.FA" in tx_data or "FD:FC:FB:FA" in tx_data, (
+            "Expected LD2420 command frame header FD:FC:FB:FA in TX log"
+        )
+        # Verify command frame footer appears (04:03:02:01)
+        assert "04.03.02.01" in tx_data or "04:03:02:01" in tx_data, (
+            "Expected LD2420 command frame footer 04:03:02:01 in TX log"
+        )
+
+        # Recovery frame values (Phase 5, after overflow)
+        recovery_values = [
+            v
+            for v in collector.sensor_states["moving_distance"]
+            if v == pytest.approx(50.0)
+        ]
+        assert len(recovery_values) >= 1, (
+            f"Expected moving_distance=50 in recovery, got: {collector.sensor_states['moving_distance']}"
+        )
+
+
+@pytest.mark.asyncio
+async def test_uart_mock_ld2420_simple(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test LD2420 simple mode: happy path, overflow, and 16-digit bug trigger."""
+    external_components_path = str(
+        Path(__file__).parent / "fixtures" / "external_components"
+    )
+    yaml_config = yaml_config.replace(
+        "EXTERNAL_COMPONENT_PATH", external_components_path
+    )
+
+    loop = asyncio.get_running_loop()
+
+    # Track overflow warning in logs
+    overflow_seen = loop.create_future()
+
+    def line_callback(line: str) -> None:
+        if "Max command length exceeded" in line and not overflow_seen.done():
+            overflow_seen.set_result(True)
+
+    collector = SensorStateCollector(
+        sensor_names=["moving_distance"],
+        binary_sensor_names=["has_target"],
+    )
+
+    # Signal for recovery frames
+    recovery_received = collector.add_waiter(
+        lambda: pytest.approx(50.0) in collector.sensor_states["moving_distance"]
+    )
+    post_bug_received = collector.add_waiter(
+        lambda: pytest.approx(25.0) in collector.sensor_states["moving_distance"]
+    )
+
+    async with (
+        run_compiled(yaml_config, line_callback=line_callback),
+        api_client_connected() as client,
+    ):
+        entities, _ = await client.list_entities_services()
+        collector.build_key_mapping(entities)
+
+        initial_state_helper = InitialStateHelper(entities)
+        client.subscribe_states(
+            initial_state_helper.on_state_wrapper(collector.on_state)
+        )
+
+        try:
+            await initial_state_helper.wait_for_initial_states()
+        except TimeoutError:
+            pytest.fail("Timeout waiting for initial states")
+
+        # Start the UART mock scenario now that we're subscribed
+        start_btn = find_entity(entities, "start_scenario", ButtonInfo)
+        assert start_btn is not None, "Start Scenario button not found"
+        client.button_command(start_btn.key)
+
+        # Wait for Phase 1 - all sensors and binary sensors have at least one value
+        try:
+            await collector.wait_for_all(timeout=3.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for Phase 1 frame. Received:\n"
+                f"  sensor_states: {collector.sensor_states}\n"
+                f"  binary_states: {collector.binary_states}"
+            )
+
+        # Phase 1: simple mode "ON Range 0100\r\n" → distance=100, presence=true
+        assert collector.sensor_states["moving_distance"][0] == pytest.approx(100.0)
+        assert collector.binary_states["has_target"][0] is True
+
+        # Wait for Phase 4 recovery (distance=50) after overflow
+        try:
+            await asyncio.wait_for(recovery_received, timeout=5.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for recovery frame. Received:\n"
+                f"  moving_distance: {collector.sensor_states['moving_distance']}"
+            )
+
+        # Verify overflow warning was logged
+        assert overflow_seen.done(), (
+            "Expected 'Max command length exceeded' warning in logs"
+        )
+
+        # Wait for Phase 6: distance=25 (post-16-digit-bug recovery)
+        # This assertion FAILS before PR #14458 because the 16-digit frame
+        # in Phase 5 causes an infinite loop in handle_simple_mode_ pre-fix.
+        # The binary hangs, Phase 6 never fires, and this wait times out.
+        try:
+            await asyncio.wait_for(post_bug_received, timeout=8.0)
+        except TimeoutError:
+            pytest.fail(
+                f"Timeout waiting for post-bug recovery (distance=25). "
+                f"This likely means Phase 5 (16-digit frame) caused an infinite "
+                f"loop in handle_simple_mode_, indicating PR #14458 bug #1 fix "
+                f"is missing.\n"
+                f"  moving_distance values: {collector.sensor_states['moving_distance']}"
+            )
+
+        # Verify post-bug value
+        post_bug_values = [
+            v
+            for v in collector.sensor_states["moving_distance"]
+            if v == pytest.approx(25.0)
+        ]
+        assert len(post_bug_values) >= 1, (
+            f"Expected moving_distance=25 after 16-digit test, "
+            f"got: {collector.sensor_states['moving_distance']}"
+        )