diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index be761cee3d0..817ea1d2be0 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
+        uses: github/codeql-action/init@6bc82e05fd0ea64601dd4b465378bbcf57de0314 # v4.32.1
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
+        uses: github/codeql-action/analyze@6bc82e05fd0ea64601dd4b465378bbcf57de0314 # v4.32.1
         with:
           category: "/language:${{matrix.language}}"
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index b068673ecf5..991e053d5ae 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.14
+    rev: v0.15.0
     hooks:
       # Run the linter.
       - id: ruff
diff --git a/CODEOWNERS b/CODEOWNERS
index b7675f94062..25e6dc1b296 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -134,6 +134,7 @@ esphome/components/dfplayer/* @glmnet
 esphome/components/dfrobot_sen0395/* @niklasweber
 esphome/components/dht/* @OttoWinter
 esphome/components/display_menu_base/* @numo68
+esphome/components/dlms_meter/* @SimonFischer04
 esphome/components/dps310/* @kbx81
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/ds2484/* @mrk-its
@@ -531,7 +532,7 @@ esphome/components/uart/packet_transport/* @clydebarrow
 esphome/components/udp/* @clydebarrow
 esphome/components/ufire_ec/* @pvizeli
 esphome/components/ufire_ise/* @pvizeli
-esphome/components/ultrasonic/* @OttoWinter
+esphome/components/ultrasonic/* @ssieb @swoboda1337
 esphome/components/update/* @jesserockz
 esphome/components/uponor_smatrix/* @kroimon
 esphome/components/usb_cdc_acm/* @kbx81
diff --git a/esphome/analyze_memory/cli.py b/esphome/analyze_memory/cli.py
index a77e17afce1..72a73dbdd48 100644
--- a/esphome/analyze_memory/cli.py
+++ b/esphome/analyze_memory/cli.py
@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from collections import defaultdict
 from collections.abc import Callable
+import heapq
+from operator import itemgetter
 import sys
 from typing import TYPE_CHECKING
 
@@ -29,6 +31,10 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
     )
     # Lower threshold for RAM symbols (RAM is more constrained)
     RAM_SYMBOL_SIZE_THRESHOLD: int = 24
+    # Number of top symbols to show in the largest symbols report
+    TOP_SYMBOLS_LIMIT: int = 30
+    # Width for symbol name display in top symbols report
+    COL_TOP_SYMBOL_NAME: int = 55
 
     # Column width constants
     COL_COMPONENT: int = 29
@@ -147,6 +153,37 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             section_label = f" [{section[1:]}]"  # .data -> [data], .bss -> [bss]
         return f"{demangled} ({size:,} B){section_label}"
 
+    def _add_top_symbols(self, lines: list[str]) -> None:
+        """Add a section showing the top largest symbols in the binary."""
+        # Collect all symbols from all components: (symbol, demangled, size, section, component)
+        all_symbols = [
+            (symbol, demangled, size, section, component)
+            for component, symbols in self._component_symbols.items()
+            for symbol, demangled, size, section in symbols
+        ]
+
+        # Get top N symbols by size using heapq for efficiency
+        top_symbols = heapq.nlargest(
+            self.TOP_SYMBOLS_LIMIT, all_symbols, key=itemgetter(2)
+        )
+
+        lines.append("")
+        lines.append(f"Top {self.TOP_SYMBOLS_LIMIT} Largest Symbols:")
+        # Calculate truncation limit from column width (leaving room for "...")
+        truncate_limit = self.COL_TOP_SYMBOL_NAME - 3
+        for i, (_, demangled, size, section, component) in enumerate(top_symbols):
+            # Format section label
+            section_label = f"[{section[1:]}]" if section else ""
+            # Truncate demangled name if too long
+            demangled_display = (
+                f"{demangled[:truncate_limit]}..."
+                if len(demangled) > self.COL_TOP_SYMBOL_NAME
+                else demangled
+            )
+            lines.append(
+                f"{i + 1:>2}. {size:>7,} B {section_label:<8} {demangled_display:<{self.COL_TOP_SYMBOL_NAME}} {component}"
+            )
+
     def generate_report(self, detailed: bool = False) -> str:
         """Generate a formatted memory report."""
         components = sorted(
@@ -248,6 +285,9 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
             "RAM",
         )
 
+        # Top largest symbols in the binary
+        self._add_top_symbols(lines)
+
         # Add ESPHome core detailed analysis if there are core symbols
         if self._esphome_core_symbols:
             self._add_section_header(lines, f"{_COMPONENT_CORE} Detailed Analysis")
diff --git a/esphome/components/absolute_humidity/absolute_humidity.cpp b/esphome/components/absolute_humidity/absolute_humidity.cpp
index b13fcd519aa..9c66531d053 100644
--- a/esphome/components/absolute_humidity/absolute_humidity.cpp
+++ b/esphome/components/absolute_humidity/absolute_humidity.cpp
@@ -45,8 +45,6 @@ void AbsoluteHumidityComponent::dump_config() {
                 this->temperature_sensor_->get_name().c_str(), this->humidity_sensor_->get_name().c_str());
 }
 
-float AbsoluteHumidityComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void AbsoluteHumidityComponent::loop() {
   if (!this->next_update_) {
     return;
diff --git a/esphome/components/absolute_humidity/absolute_humidity.h b/esphome/components/absolute_humidity/absolute_humidity.h
index 9f3b9eab8b6..71feee2c429 100644
--- a/esphome/components/absolute_humidity/absolute_humidity.h
+++ b/esphome/components/absolute_humidity/absolute_humidity.h
@@ -24,7 +24,6 @@ class AbsoluteHumidityComponent : public sensor::Sensor, public Component {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void loop() override;
 
  protected:
diff --git a/esphome/components/adc/adc_sensor.h b/esphome/components/adc/adc_sensor.h
index 526dd57fd50..91cf4eaafcc 100644
--- a/esphome/components/adc/adc_sensor.h
+++ b/esphome/components/adc/adc_sensor.h
@@ -68,11 +68,6 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   /// This method is called during the ESPHome setup process to log the configuration.
   void dump_config() override;
 
-  /// Return the setup priority for this component.
-  /// Components with higher priority are initialized earlier during setup.
-  /// @return A float representing the setup priority.
-  float get_setup_priority() const override;
-
 #ifdef USE_ZEPHYR
   /// Set the ADC channel to be used by the ADC sensor.
   /// @param channel Pointer to an adc_dt_spec structure representing the ADC channel.
diff --git a/esphome/components/adc/adc_sensor_common.cpp b/esphome/components/adc/adc_sensor_common.cpp
index 748c8634b73..c779fd5893b 100644
--- a/esphome/components/adc/adc_sensor_common.cpp
+++ b/esphome/components/adc/adc_sensor_common.cpp
@@ -79,7 +79,5 @@ void ADCSensor::set_sample_count(uint8_t sample_count) {
 
 void ADCSensor::set_sampling_mode(SamplingMode sampling_mode) { this->sampling_mode_ = sampling_mode; }
 
-float ADCSensor::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace adc
 }  // namespace esphome
diff --git a/esphome/components/adc/adc_sensor_esp32.cpp b/esphome/components/adc/adc_sensor_esp32.cpp
index ea1263db5f7..1d3138623ec 100644
--- a/esphome/components/adc/adc_sensor_esp32.cpp
+++ b/esphome/components/adc/adc_sensor_esp32.cpp
@@ -42,11 +42,11 @@ void ADCSensor::setup() {
     adc_oneshot_unit_init_cfg_t init_config = {};  // Zero initialize
     init_config.unit_id = this->adc_unit_;
     init_config.ulp_mode = ADC_ULP_MODE_DISABLE;
-#if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
-    USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
+#if USE_ESP32_VARIANT_ESP32C2 || USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || \
+    USE_ESP32_VARIANT_ESP32C6 || USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
     init_config.clk_src = ADC_DIGI_CLK_SRC_DEFAULT;
-#endif  // USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 ||
-        // USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
+#endif  // USE_ESP32_VARIANT_ESP32C2 || USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 ||
+        // USE_ESP32_VARIANT_ESP32C6 || USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2
     esp_err_t err = adc_oneshot_new_unit(&init_config, &ADCSensor::shared_adc_handles[this->adc_unit_]);
     if (err != ESP_OK) {
       ESP_LOGE(TAG, "Error initializing %s: %d", LOG_STR_ARG(adc_unit_to_str(this->adc_unit_)), err);
@@ -76,7 +76,7 @@ void ADCSensor::setup() {
 
 #if USE_ESP32_VARIANT_ESP32C3 || USE_ESP32_VARIANT_ESP32C5 || USE_ESP32_VARIANT_ESP32C6 || \
     USE_ESP32_VARIANT_ESP32C61 || USE_ESP32_VARIANT_ESP32H2 || USE_ESP32_VARIANT_ESP32P4 || USE_ESP32_VARIANT_ESP32S3
-    // RISC-V variants and S3 use curve fitting calibration
+    // RISC-V variants (except C2) and S3 use curve fitting calibration
     adc_cali_curve_fitting_config_t cali_config = {};  // Zero initialize first
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0)
     cali_config.chan = this->channel_;
@@ -94,14 +94,14 @@ void ADCSensor::setup() {
       ESP_LOGW(TAG, "Curve fitting calibration failed with error %d, will use uncalibrated readings", err);
       this->setup_flags_.calibration_complete = false;
     }
-#else  // Other ESP32 variants use line fitting calibration
+#else  // ESP32, ESP32-S2, and ESP32-C2 use line fitting calibration
     adc_cali_line_fitting_config_t cali_config = {
       .unit_id = this->adc_unit_,
       .atten = this->attenuation_,
       .bitwidth = ADC_BITWIDTH_DEFAULT,
-#if !defined(USE_ESP32_VARIANT_ESP32S2)
+#if !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
       .default_vref = 1100,  // Default reference voltage in mV
-#endif  // !defined(USE_ESP32_VARIANT_ESP32S2)
+#endif  // !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
     };
     err = adc_cali_create_scheme_line_fitting(&cali_config, &handle);
     if (err == ESP_OK) {
@@ -112,7 +112,7 @@ void ADCSensor::setup() {
       ESP_LOGW(TAG, "Line fitting calibration failed with error %d, will use uncalibrated readings", err);
       this->setup_flags_.calibration_complete = false;
     }
-#endif  // USE_ESP32_VARIANT_ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
+#endif  // ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
   }
 
   this->setup_flags_.init_complete = true;
@@ -189,7 +189,7 @@ float ADCSensor::sample_fixed_attenuation_() {
         adc_cali_delete_scheme_curve_fitting(this->calibration_handle_);
 #else   // Other ESP32 variants use line fitting calibration
         adc_cali_delete_scheme_line_fitting(this->calibration_handle_);
-#endif  // USE_ESP32_VARIANT_ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
+#endif  // ESP32C3 || ESP32C5 || ESP32C6 || ESP32C61 || ESP32H2 || ESP32P4 || ESP32S3
         this->calibration_handle_ = nullptr;
       }
     }
@@ -247,7 +247,7 @@ float ADCSensor::sample_autorange_() {
       .unit_id = this->adc_unit_,
       .atten = atten,
       .bitwidth = ADC_BITWIDTH_DEFAULT,
-#if !defined(USE_ESP32_VARIANT_ESP32S2)
+#if !defined(USE_ESP32_VARIANT_ESP32S2) && !defined(USE_ESP32_VARIANT_ESP32C2)
       .default_vref = 1100,
 #endif
     };
diff --git a/esphome/components/adc128s102/sensor/adc128s102_sensor.cpp b/esphome/components/adc128s102/sensor/adc128s102_sensor.cpp
index 03ce31d3cb3..800b2d52610 100644
--- a/esphome/components/adc128s102/sensor/adc128s102_sensor.cpp
+++ b/esphome/components/adc128s102/sensor/adc128s102_sensor.cpp
@@ -9,8 +9,6 @@ static const char *const TAG = "adc128s102.sensor";
 
 ADC128S102Sensor::ADC128S102Sensor(uint8_t channel) : channel_(channel) {}
 
-float ADC128S102Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void ADC128S102Sensor::dump_config() {
   LOG_SENSOR("", "ADC128S102 Sensor", this);
   ESP_LOGCONFIG(TAG, "  Pin: %u", this->channel_);
diff --git a/esphome/components/adc128s102/sensor/adc128s102_sensor.h b/esphome/components/adc128s102/sensor/adc128s102_sensor.h
index 234500c2f40..5e6fc74e9c5 100644
--- a/esphome/components/adc128s102/sensor/adc128s102_sensor.h
+++ b/esphome/components/adc128s102/sensor/adc128s102_sensor.h
@@ -19,7 +19,6 @@ class ADC128S102Sensor : public PollingComponent,
 
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   float sample() override;
 
  protected:
diff --git a/esphome/components/aht10/aht10.cpp b/esphome/components/aht10/aht10.cpp
index 03d9d9cd9ed..1b1f8335cc5 100644
--- a/esphome/components/aht10/aht10.cpp
+++ b/esphome/components/aht10/aht10.cpp
@@ -150,8 +150,6 @@ void AHT10Component::update() {
   this->restart_read_();
 }
 
-float AHT10Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void AHT10Component::dump_config() {
   ESP_LOGCONFIG(TAG, "AHT10:");
   LOG_I2C_DEVICE(this);
diff --git a/esphome/components/aht10/aht10.h b/esphome/components/aht10/aht10.h
index a3320c77e09..ce9cd963ad3 100644
--- a/esphome/components/aht10/aht10.h
+++ b/esphome/components/aht10/aht10.h
@@ -16,7 +16,6 @@ class AHT10Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void set_variant(AHT10Variant variant) { this->variant_ = variant; }
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
diff --git a/esphome/components/am2315c/am2315c.cpp b/esphome/components/am2315c/am2315c.cpp
index b20a8c6cbb5..1390b749754 100644
--- a/esphome/components/am2315c/am2315c.cpp
+++ b/esphome/components/am2315c/am2315c.cpp
@@ -176,7 +176,5 @@ void AM2315C::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
-float AM2315C::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace am2315c
 }  // namespace esphome
diff --git a/esphome/components/am2315c/am2315c.h b/esphome/components/am2315c/am2315c.h
index c8d01beeaa9..d7baf01cae1 100644
--- a/esphome/components/am2315c/am2315c.h
+++ b/esphome/components/am2315c/am2315c.h
@@ -33,7 +33,6 @@ class AM2315C : public PollingComponent, public i2c::I2CDevice {
   void dump_config() override;
   void update() override;
   void setup() override;
-  float get_setup_priority() const override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { this->temperature_sensor_ = temperature_sensor; }
   void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
diff --git a/esphome/components/am2320/am2320.cpp b/esphome/components/am2320/am2320.cpp
index 055be2aeeea..7fef3bb3a62 100644
--- a/esphome/components/am2320/am2320.cpp
+++ b/esphome/components/am2320/am2320.cpp
@@ -51,7 +51,6 @@ void AM2320Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
-float AM2320Component::get_setup_priority() const { return setup_priority::DATA; }
 
 bool AM2320Component::read_bytes_(uint8_t a_register, uint8_t *data, uint8_t len, uint32_t conversion) {
   if (!this->write_bytes(a_register, data, 2)) {
diff --git a/esphome/components/am2320/am2320.h b/esphome/components/am2320/am2320.h
index da1e87cf65c..708dbb632e8 100644
--- a/esphome/components/am2320/am2320.h
+++ b/esphome/components/am2320/am2320.h
@@ -11,7 +11,6 @@ class AM2320Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
diff --git a/esphome/components/apds9960/apds9960.cpp b/esphome/components/apds9960/apds9960.cpp
index 93038d31601..260de82d143 100644
--- a/esphome/components/apds9960/apds9960.cpp
+++ b/esphome/components/apds9960/apds9960.cpp
@@ -384,7 +384,6 @@ void APDS9960::process_dataset_(int up, int down, int left, int right) {
     }
   }
 }
-float APDS9960::get_setup_priority() const { return setup_priority::DATA; }
 bool APDS9960::is_proximity_enabled_() const {
   return
 #ifdef USE_SENSOR
diff --git a/esphome/components/apds9960/apds9960.h b/esphome/components/apds9960/apds9960.h
index 2a0fbb5c196..4574b70a42e 100644
--- a/esphome/components/apds9960/apds9960.h
+++ b/esphome/components/apds9960/apds9960.h
@@ -32,7 +32,6 @@ class APDS9960 : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void loop() override;
 
diff --git a/esphome/components/api/api.proto b/esphome/components/api/api.proto
index 597da25883a..d25934c60b4 100644
--- a/esphome/components/api/api.proto
+++ b/esphome/components/api/api.proto
@@ -45,6 +45,7 @@ service APIConnection {
   rpc time_command (TimeCommandRequest) returns (void) {}
   rpc update_command (UpdateCommandRequest) returns (void) {}
   rpc valve_command (ValveCommandRequest) returns (void) {}
+  rpc water_heater_command (WaterHeaterCommandRequest) returns (void) {}
 
   rpc subscribe_bluetooth_le_advertisements(SubscribeBluetoothLEAdvertisementsRequest) returns (void) {}
   rpc bluetooth_device_request(BluetoothDeviceRequest) returns (void) {}
diff --git a/esphome/components/api/api_connection.cpp b/esphome/components/api/api_connection.cpp
index 1626f395e65..2aa5956f24d 100644
--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -300,7 +300,7 @@ void APIConnection::on_disconnect_response(const DisconnectResponse &value) {
 // Encodes a message to the buffer and returns the total number of bytes used,
 // including header and footer overhead. Returns 0 if the message doesn't fit.
 uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint8_t message_type, APIConnection *conn,
-                                                 uint32_t remaining_size, bool is_single) {
+                                                 uint32_t remaining_size) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   // If in log-only mode, just log and return
   if (conn->flags_.log_only_mode) {
@@ -330,12 +330,9 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint8_t mess
   // Get buffer size after allocation (which includes header padding)
   std::vector<uint8_t> &shared_buf = conn->parent_->get_shared_buffer_ref();
 
-  if (is_single || conn->flags_.batch_first_message) {
-    // Single message or first batch message
-    conn->prepare_first_message_buffer(shared_buf, header_padding, total_calculated_size);
-    if (conn->flags_.batch_first_message) {
-      conn->flags_.batch_first_message = false;
-    }
+  if (conn->flags_.batch_first_message) {
+    // First message - buffer already prepared by caller, just clear flag
+    conn->flags_.batch_first_message = false;
   } else {
     // Batch message second or later
     // Add padding for previous message footer + this message header
@@ -365,24 +362,22 @@ bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary
                                    BinarySensorStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                     bool is_single) {
+uint16_t APIConnection::try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *binary_sensor = static_cast<binary_sensor::BinarySensor *>(entity);
   BinarySensorStateResponse resp;
   resp.state = binary_sensor->state;
   resp.missing_state = !binary_sensor->has_state();
   return fill_and_encode_entity_state(binary_sensor, resp, BinarySensorStateResponse::MESSAGE_TYPE, conn,
-                                      remaining_size, is_single);
+                                      remaining_size);
 }
 
-uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                    bool is_single) {
+uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *binary_sensor = static_cast<binary_sensor::BinarySensor *>(entity);
   ListEntitiesBinarySensorResponse msg;
   msg.device_class = binary_sensor->get_device_class_ref();
   msg.is_status_binary_sensor = binary_sensor->is_status_binary_sensor();
   return fill_and_encode_entity_info(binary_sensor, msg, ListEntitiesBinarySensorResponse::MESSAGE_TYPE, conn,
-                                     remaining_size, is_single);
+                                     remaining_size);
 }
 #endif
 
@@ -390,8 +385,7 @@ uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConne
 bool APIConnection::send_cover_state(cover::Cover *cover) {
   return this->send_message_smart_(cover, CoverStateResponse::MESSAGE_TYPE, CoverStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *cover = static_cast<cover::Cover *>(entity);
   CoverStateResponse msg;
   auto traits = cover->get_traits();
@@ -399,10 +393,9 @@ uint16_t APIConnection::try_send_cover_state(EntityBase *entity, APIConnection *
   if (traits.get_supports_tilt())
     msg.tilt = cover->tilt;
   msg.current_operation = static_cast<enums::CoverOperation>(cover->current_operation);
-  return fill_and_encode_entity_state(cover, msg, CoverStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(cover, msg, CoverStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *cover = static_cast<cover::Cover *>(entity);
   ListEntitiesCoverResponse msg;
   auto traits = cover->get_traits();
@@ -411,8 +404,7 @@ uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *c
   msg.supports_tilt = traits.get_supports_tilt();
   msg.supports_stop = traits.get_supports_stop();
   msg.device_class = cover->get_device_class_ref();
-  return fill_and_encode_entity_info(cover, msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(cover, msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::cover_command(const CoverCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(cover::Cover, cover, cover)
@@ -430,8 +422,7 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
 bool APIConnection::send_fan_state(fan::Fan *fan) {
   return this->send_message_smart_(fan, FanStateResponse::MESSAGE_TYPE, FanStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                           bool is_single) {
+uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *fan = static_cast<fan::Fan *>(entity);
   FanStateResponse msg;
   auto traits = fan->get_traits();
@@ -445,10 +436,9 @@ uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *co
     msg.direction = static_cast<enums::FanDirection>(fan->direction);
   if (traits.supports_preset_modes() && fan->has_preset_mode())
     msg.preset_mode = fan->get_preset_mode();
-  return fill_and_encode_entity_state(fan, msg, FanStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(fan, msg, FanStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                          bool is_single) {
+uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *fan = static_cast<fan::Fan *>(entity);
   ListEntitiesFanResponse msg;
   auto traits = fan->get_traits();
@@ -457,7 +447,7 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   msg.supports_direction = traits.supports_direction();
   msg.supported_speed_count = traits.supported_speed_count();
   msg.supported_preset_modes = &traits.supported_preset_modes();
-  return fill_and_encode_entity_info(fan, msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_info(fan, msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::fan_command(const FanCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(fan::Fan, fan, fan)
@@ -481,8 +471,7 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
 bool APIConnection::send_light_state(light::LightState *light) {
   return this->send_message_smart_(light, LightStateResponse::MESSAGE_TYPE, LightStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *light = static_cast<light::LightState *>(entity);
   LightStateResponse resp;
   auto values = light->remote_values;
@@ -501,10 +490,9 @@ uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *
   if (light->supports_effects()) {
     resp.effect = light->get_effect_name();
   }
-  return fill_and_encode_entity_state(light, resp, LightStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(light, resp, LightStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *light = static_cast<light::LightState *>(entity);
   ListEntitiesLightResponse msg;
   auto traits = light->get_traits();
@@ -527,8 +515,7 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
     }
   }
   msg.effects = &effects_list;
-  return fill_and_encode_entity_info(light, msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(light, msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::light_command(const LightCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(light::LightState, light, light)
@@ -568,17 +555,15 @@ bool APIConnection::send_sensor_state(sensor::Sensor *sensor) {
   return this->send_message_smart_(sensor, SensorStateResponse::MESSAGE_TYPE, SensorStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *sensor = static_cast<sensor::Sensor *>(entity);
   SensorStateResponse resp;
   resp.state = sensor->state;
   resp.missing_state = !sensor->has_state();
-  return fill_and_encode_entity_state(sensor, resp, SensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(sensor, resp, SensorStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *sensor = static_cast<sensor::Sensor *>(entity);
   ListEntitiesSensorResponse msg;
   msg.unit_of_measurement = sensor->get_unit_of_measurement_ref();
@@ -586,8 +571,7 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
   msg.force_update = sensor->get_force_update();
   msg.device_class = sensor->get_device_class_ref();
   msg.state_class = static_cast<enums::SensorStateClass>(sensor->get_state_class());
-  return fill_and_encode_entity_info(sensor, msg, ListEntitiesSensorResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(sensor, msg, ListEntitiesSensorResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 #endif
 
@@ -596,23 +580,19 @@ bool APIConnection::send_switch_state(switch_::Switch *a_switch) {
   return this->send_message_smart_(a_switch, SwitchStateResponse::MESSAGE_TYPE, SwitchStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *a_switch = static_cast<switch_::Switch *>(entity);
   SwitchStateResponse resp;
   resp.state = a_switch->state;
-  return fill_and_encode_entity_state(a_switch, resp, SwitchStateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                      is_single);
+  return fill_and_encode_entity_state(a_switch, resp, SwitchStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *a_switch = static_cast<switch_::Switch *>(entity);
   ListEntitiesSwitchResponse msg;
   msg.assumed_state = a_switch->assumed_state();
   msg.device_class = a_switch->get_device_class_ref();
-  return fill_and_encode_entity_info(a_switch, msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(a_switch, msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::switch_command(const SwitchCommandRequest &msg) {
   ENTITY_COMMAND_GET(switch_::Switch, a_switch, switch)
@@ -631,22 +611,19 @@ bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor)
                                    TextSensorStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                   bool is_single) {
+uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
   TextSensorStateResponse resp;
   resp.state = StringRef(text_sensor->state);
   resp.missing_state = !text_sensor->has_state();
-  return fill_and_encode_entity_state(text_sensor, resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                      is_single);
+  return fill_and_encode_entity_state(text_sensor, resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                  bool is_single) {
+uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
   ListEntitiesTextSensorResponse msg;
   msg.device_class = text_sensor->get_device_class_ref();
   return fill_and_encode_entity_info(text_sensor, msg, ListEntitiesTextSensorResponse::MESSAGE_TYPE, conn,
-                                     remaining_size, is_single);
+                                     remaining_size);
 }
 #endif
 
@@ -654,8 +631,7 @@ uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnect
 bool APIConnection::send_climate_state(climate::Climate *climate) {
   return this->send_message_smart_(climate, ClimateStateResponse::MESSAGE_TYPE, ClimateStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                               bool is_single) {
+uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *climate = static_cast<climate::Climate *>(entity);
   ClimateStateResponse resp;
   auto traits = climate->get_traits();
@@ -687,11 +663,9 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
     resp.current_humidity = climate->current_humidity;
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY))
     resp.target_humidity = climate->target_humidity;
-  return fill_and_encode_entity_state(climate, resp, ClimateStateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                      is_single);
+  return fill_and_encode_entity_state(climate, resp, ClimateStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *climate = static_cast<climate::Climate *>(entity);
   ListEntitiesClimateResponse msg;
   auto traits = climate->get_traits();
@@ -716,8 +690,7 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
   msg.supported_presets = &traits.get_supported_presets();
   msg.supported_custom_presets = &traits.get_supported_custom_presets();
   msg.supported_swing_modes = &traits.get_supported_swing_modes();
-  return fill_and_encode_entity_info(climate, msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(climate, msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::climate_command(const ClimateCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(climate::Climate, climate, climate)
@@ -750,17 +723,15 @@ bool APIConnection::send_number_state(number::Number *number) {
   return this->send_message_smart_(number, NumberStateResponse::MESSAGE_TYPE, NumberStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *number = static_cast<number::Number *>(entity);
   NumberStateResponse resp;
   resp.state = number->state;
   resp.missing_state = !number->has_state();
-  return fill_and_encode_entity_state(number, resp, NumberStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(number, resp, NumberStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *number = static_cast<number::Number *>(entity);
   ListEntitiesNumberResponse msg;
   msg.unit_of_measurement = number->traits.get_unit_of_measurement_ref();
@@ -769,8 +740,7 @@ uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *
   msg.min_value = number->traits.get_min_value();
   msg.max_value = number->traits.get_max_value();
   msg.step = number->traits.get_step();
-  return fill_and_encode_entity_info(number, msg, ListEntitiesNumberResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(number, msg, ListEntitiesNumberResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::number_command(const NumberCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(number::Number, number, number)
@@ -783,22 +753,19 @@ void APIConnection::number_command(const NumberCommandRequest &msg) {
 bool APIConnection::send_date_state(datetime::DateEntity *date) {
   return this->send_message_smart_(date, DateStateResponse::MESSAGE_TYPE, DateStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *date = static_cast<datetime::DateEntity *>(entity);
   DateStateResponse resp;
   resp.missing_state = !date->has_state();
   resp.year = date->year;
   resp.month = date->month;
   resp.day = date->day;
-  return fill_and_encode_entity_state(date, resp, DateStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(date, resp, DateStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                           bool is_single) {
+uint16_t APIConnection::try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *date = static_cast<datetime::DateEntity *>(entity);
   ListEntitiesDateResponse msg;
-  return fill_and_encode_entity_info(date, msg, ListEntitiesDateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(date, msg, ListEntitiesDateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::date_command(const DateCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(datetime::DateEntity, date, date)
@@ -811,22 +778,19 @@ void APIConnection::date_command(const DateCommandRequest &msg) {
 bool APIConnection::send_time_state(datetime::TimeEntity *time) {
   return this->send_message_smart_(time, TimeStateResponse::MESSAGE_TYPE, TimeStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *time = static_cast<datetime::TimeEntity *>(entity);
   TimeStateResponse resp;
   resp.missing_state = !time->has_state();
   resp.hour = time->hour;
   resp.minute = time->minute;
   resp.second = time->second;
-  return fill_and_encode_entity_state(time, resp, TimeStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(time, resp, TimeStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                           bool is_single) {
+uint16_t APIConnection::try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *time = static_cast<datetime::TimeEntity *>(entity);
   ListEntitiesTimeResponse msg;
-  return fill_and_encode_entity_info(time, msg, ListEntitiesTimeResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(time, msg, ListEntitiesTimeResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::time_command(const TimeCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(datetime::TimeEntity, time, time)
@@ -840,8 +804,7 @@ bool APIConnection::send_datetime_state(datetime::DateTimeEntity *datetime) {
   return this->send_message_smart_(datetime, DateTimeStateResponse::MESSAGE_TYPE,
                                    DateTimeStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                bool is_single) {
+uint16_t APIConnection::try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
   DateTimeStateResponse resp;
   resp.missing_state = !datetime->has_state();
@@ -849,15 +812,12 @@ uint16_t APIConnection::try_send_datetime_state(EntityBase *entity, APIConnectio
     ESPTime state = datetime->state_as_esptime();
     resp.epoch_seconds = state.timestamp;
   }
-  return fill_and_encode_entity_state(datetime, resp, DateTimeStateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                      is_single);
+  return fill_and_encode_entity_state(datetime, resp, DateTimeStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                               bool is_single) {
+uint16_t APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
   ListEntitiesDateTimeResponse msg;
-  return fill_and_encode_entity_info(datetime, msg, ListEntitiesDateTimeResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(datetime, msg, ListEntitiesDateTimeResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(datetime::DateTimeEntity, datetime, datetime)
@@ -871,25 +831,22 @@ bool APIConnection::send_text_state(text::Text *text) {
   return this->send_message_smart_(text, TextStateResponse::MESSAGE_TYPE, TextStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *text = static_cast<text::Text *>(entity);
   TextStateResponse resp;
   resp.state = StringRef(text->state);
   resp.missing_state = !text->has_state();
-  return fill_and_encode_entity_state(text, resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(text, resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                           bool is_single) {
+uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *text = static_cast<text::Text *>(entity);
   ListEntitiesTextResponse msg;
   msg.mode = static_cast<enums::TextMode>(text->traits.get_mode());
   msg.min_length = text->traits.get_min_length();
   msg.max_length = text->traits.get_max_length();
   msg.pattern = text->traits.get_pattern_ref();
-  return fill_and_encode_entity_info(text, msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(text, msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::text_command(const TextCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(text::Text, text, text)
@@ -903,22 +860,19 @@ bool APIConnection::send_select_state(select::Select *select) {
   return this->send_message_smart_(select, SelectStateResponse::MESSAGE_TYPE, SelectStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *select = static_cast<select::Select *>(entity);
   SelectStateResponse resp;
   resp.state = select->current_option();
   resp.missing_state = !select->has_state();
-  return fill_and_encode_entity_state(select, resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(select, resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *select = static_cast<select::Select *>(entity);
   ListEntitiesSelectResponse msg;
   msg.options = &select->traits.get_options();
-  return fill_and_encode_entity_info(select, msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(select, msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::select_command(const SelectCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(select::Select, select, select)
@@ -928,13 +882,11 @@ void APIConnection::select_command(const SelectCommandRequest &msg) {
 #endif
 
 #ifdef USE_BUTTON
-uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *button = static_cast<button::Button *>(entity);
   ListEntitiesButtonResponse msg;
   msg.device_class = button->get_device_class_ref();
-  return fill_and_encode_entity_info(button, msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(button, msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg) {
   ENTITY_COMMAND_GET(button::Button, button, button)
@@ -947,23 +899,20 @@ bool APIConnection::send_lock_state(lock::Lock *a_lock) {
   return this->send_message_smart_(a_lock, LockStateResponse::MESSAGE_TYPE, LockStateResponse::ESTIMATED_SIZE);
 }
 
-uint16_t APIConnection::try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *a_lock = static_cast<lock::Lock *>(entity);
   LockStateResponse resp;
   resp.state = static_cast<enums::LockState>(a_lock->state);
-  return fill_and_encode_entity_state(a_lock, resp, LockStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(a_lock, resp, LockStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                           bool is_single) {
+uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *a_lock = static_cast<lock::Lock *>(entity);
   ListEntitiesLockResponse msg;
   msg.assumed_state = a_lock->traits.get_assumed_state();
   msg.supports_open = a_lock->traits.get_supports_open();
   msg.requires_code = a_lock->traits.get_requires_code();
-  return fill_and_encode_entity_info(a_lock, msg, ListEntitiesLockResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(a_lock, msg, ListEntitiesLockResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::lock_command(const LockCommandRequest &msg) {
   ENTITY_COMMAND_GET(lock::Lock, a_lock, lock)
@@ -986,16 +935,14 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
 bool APIConnection::send_valve_state(valve::Valve *valve) {
   return this->send_message_smart_(valve, ValveStateResponse::MESSAGE_TYPE, ValveStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *valve = static_cast<valve::Valve *>(entity);
   ValveStateResponse resp;
   resp.position = valve->position;
   resp.current_operation = static_cast<enums::ValveOperation>(valve->current_operation);
-  return fill_and_encode_entity_state(valve, resp, ValveStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(valve, resp, ValveStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *valve = static_cast<valve::Valve *>(entity);
   ListEntitiesValveResponse msg;
   auto traits = valve->get_traits();
@@ -1003,8 +950,7 @@ uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *c
   msg.assumed_state = traits.get_is_assumed_state();
   msg.supports_position = traits.get_supports_position();
   msg.supports_stop = traits.get_supports_stop();
-  return fill_and_encode_entity_info(valve, msg, ListEntitiesValveResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(valve, msg, ListEntitiesValveResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::valve_command(const ValveCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(valve::Valve, valve, valve)
@@ -1021,8 +967,7 @@ bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_pla
   return this->send_message_smart_(media_player, MediaPlayerStateResponse::MESSAGE_TYPE,
                                    MediaPlayerStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                    bool is_single) {
+uint16_t APIConnection::try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *media_player = static_cast<media_player::MediaPlayer *>(entity);
   MediaPlayerStateResponse resp;
   media_player::MediaPlayerState report_state = media_player->state == media_player::MEDIA_PLAYER_STATE_ANNOUNCING
@@ -1031,11 +976,9 @@ uint16_t APIConnection::try_send_media_player_state(EntityBase *entity, APIConne
   resp.state = static_cast<enums::MediaPlayerState>(report_state);
   resp.volume = media_player->volume;
   resp.muted = media_player->is_muted();
-  return fill_and_encode_entity_state(media_player, resp, MediaPlayerStateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                      is_single);
+  return fill_and_encode_entity_state(media_player, resp, MediaPlayerStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                   bool is_single) {
+uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *media_player = static_cast<media_player::MediaPlayer *>(entity);
   ListEntitiesMediaPlayerResponse msg;
   auto traits = media_player->get_traits();
@@ -1051,7 +994,7 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
     media_format.sample_bytes = supported_format.sample_bytes;
   }
   return fill_and_encode_entity_info(media_player, msg, ListEntitiesMediaPlayerResponse::MESSAGE_TYPE, conn,
-                                     remaining_size, is_single);
+                                     remaining_size);
 }
 void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(media_player::MediaPlayer, media_player, media_player)
@@ -1092,7 +1035,7 @@ void APIConnection::try_send_camera_image_() {
     msg.device_id = camera::Camera::instance()->get_device_id();
 #endif
 
-    if (!this->send_message_(msg, CameraImageResponse::MESSAGE_TYPE)) {
+    if (!this->send_message_impl(msg, CameraImageResponse::MESSAGE_TYPE)) {
       return;  // Send failed, try again later
     }
     this->image_reader_->consume_data(to_send);
@@ -1115,12 +1058,10 @@ void APIConnection::set_camera_state(std::shared_ptr<camera::CameraImage> image)
     this->try_send_camera_image_();
   }
 }
-uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *camera = static_cast<camera::Camera *>(entity);
   ListEntitiesCameraResponse msg;
-  return fill_and_encode_entity_info(camera, msg, ListEntitiesCameraResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(camera, msg, ListEntitiesCameraResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::camera_image(const CameraImageRequest &msg) {
   if (camera::Camera::instance() == nullptr)
@@ -1305,22 +1246,22 @@ bool APIConnection::send_alarm_control_panel_state(alarm_control_panel::AlarmCon
                                    AlarmControlPanelStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn,
-                                                           uint32_t remaining_size, bool is_single) {
+                                                           uint32_t remaining_size) {
   auto *a_alarm_control_panel = static_cast<alarm_control_panel::AlarmControlPanel *>(entity);
   AlarmControlPanelStateResponse resp;
   resp.state = static_cast<enums::AlarmControlPanelState>(a_alarm_control_panel->get_state());
   return fill_and_encode_entity_state(a_alarm_control_panel, resp, AlarmControlPanelStateResponse::MESSAGE_TYPE, conn,
-                                      remaining_size, is_single);
+                                      remaining_size);
 }
 uint16_t APIConnection::try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn,
-                                                          uint32_t remaining_size, bool is_single) {
+                                                          uint32_t remaining_size) {
   auto *a_alarm_control_panel = static_cast<alarm_control_panel::AlarmControlPanel *>(entity);
   ListEntitiesAlarmControlPanelResponse msg;
   msg.supported_features = a_alarm_control_panel->get_supported_features();
   msg.requires_code = a_alarm_control_panel->get_requires_code();
   msg.requires_code_to_arm = a_alarm_control_panel->get_requires_code_to_arm();
   return fill_and_encode_entity_info(a_alarm_control_panel, msg, ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE,
-                                     conn, remaining_size, is_single);
+                                     conn, remaining_size);
 }
 void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(alarm_control_panel::AlarmControlPanel, a_alarm_control_panel, alarm_control_panel)
@@ -1357,8 +1298,7 @@ bool APIConnection::send_water_heater_state(water_heater::WaterHeater *water_hea
   return this->send_message_smart_(water_heater, WaterHeaterStateResponse::MESSAGE_TYPE,
                                    WaterHeaterStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                    bool is_single) {
+uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *wh = static_cast<water_heater::WaterHeater *>(entity);
   WaterHeaterStateResponse resp;
   resp.mode = static_cast<enums::WaterHeaterMode>(wh->get_mode());
@@ -1369,10 +1309,9 @@ uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConne
   resp.state = wh->get_state();
   resp.key = wh->get_object_id_hash();
 
-  return encode_message_to_buffer(resp, WaterHeaterStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return encode_message_to_buffer(resp, WaterHeaterStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                   bool is_single) {
+uint16_t APIConnection::try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *wh = static_cast<water_heater::WaterHeater *>(entity);
   ListEntitiesWaterHeaterResponse msg;
   auto traits = wh->get_traits();
@@ -1381,11 +1320,10 @@ uint16_t APIConnection::try_send_water_heater_info(EntityBase *entity, APIConnec
   msg.target_temperature_step = traits.get_target_temperature_step();
   msg.supported_modes = &traits.get_supported_modes();
   msg.supported_features = traits.get_feature_flags();
-  return fill_and_encode_entity_info(wh, msg, ListEntitiesWaterHeaterResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(wh, msg, ListEntitiesWaterHeaterResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequest &msg) {
+void APIConnection::water_heater_command(const WaterHeaterCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(water_heater::WaterHeater, water_heater, water_heater)
   if (msg.has_fields & enums::WATER_HEATER_COMMAND_HAS_MODE)
     call.set_mode(static_cast<water_heater::WaterHeaterMode>(msg.mode));
@@ -1411,20 +1349,18 @@ void APIConnection::send_event(event::Event *event) {
                             event->get_last_event_type_index());
 }
 uint16_t APIConnection::try_send_event_response(event::Event *event, StringRef event_type, APIConnection *conn,
-                                                uint32_t remaining_size, bool is_single) {
+                                                uint32_t remaining_size) {
   EventResponse resp;
   resp.event_type = event_type;
-  return fill_and_encode_entity_state(event, resp, EventResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(event, resp, EventResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single) {
+uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *event = static_cast<event::Event *>(entity);
   ListEntitiesEventResponse msg;
   msg.device_class = event->get_device_class_ref();
   msg.event_types = &event->get_event_types();
-  return fill_and_encode_entity_info(event, msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(event, msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 #endif
 
@@ -1447,13 +1383,11 @@ void APIConnection::send_infrared_rf_receive_event(const InfraredRFReceiveEvent
 #endif
 
 #ifdef USE_INFRARED
-uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                               bool is_single) {
+uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *infrared = static_cast<infrared::Infrared *>(entity);
   ListEntitiesInfraredResponse msg;
   msg.capabilities = infrared->get_capability_flags();
-  return fill_and_encode_entity_info(infrared, msg, ListEntitiesInfraredResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(infrared, msg, ListEntitiesInfraredResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 #endif
 
@@ -1461,8 +1395,7 @@ uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection
 bool APIConnection::send_update_state(update::UpdateEntity *update) {
   return this->send_message_smart_(update, UpdateStateResponse::MESSAGE_TYPE, UpdateStateResponse::ESTIMATED_SIZE);
 }
-uint16_t APIConnection::try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *update = static_cast<update::UpdateEntity *>(entity);
   UpdateStateResponse resp;
   resp.missing_state = !update->has_state();
@@ -1478,15 +1411,13 @@ uint16_t APIConnection::try_send_update_state(EntityBase *entity, APIConnection
     resp.release_summary = StringRef(update->update_info.summary);
     resp.release_url = StringRef(update->update_info.release_url);
   }
-  return fill_and_encode_entity_state(update, resp, UpdateStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return fill_and_encode_entity_state(update, resp, UpdateStateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
-uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single) {
+uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *update = static_cast<update::UpdateEntity *>(entity);
   ListEntitiesUpdateResponse msg;
   msg.device_class = update->get_device_class_ref();
-  return fill_and_encode_entity_info(update, msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size,
-                                     is_single);
+  return fill_and_encode_entity_info(update, msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 void APIConnection::update_command(const UpdateCommandRequest &msg) {
   ENTITY_COMMAND_GET(update::UpdateEntity, update, update)
@@ -1512,7 +1443,7 @@ bool APIConnection::try_send_log_message(int level, const char *tag, const char
   SubscribeLogsResponse msg;
   msg.level = static_cast<enums::LogLevel>(level);
   msg.set_message(reinterpret_cast<const uint8_t *>(line), message_len);
-  return this->send_message_(msg, SubscribeLogsResponse::MESSAGE_TYPE);
+  return this->send_message_impl(msg, SubscribeLogsResponse::MESSAGE_TYPE);
 }
 
 void APIConnection::complete_authentication_() {
@@ -1837,6 +1768,14 @@ bool APIConnection::try_to_clear_buffer(bool log_out_of_space) {
   }
   return false;
 }
+bool APIConnection::send_message_impl(const ProtoMessage &msg, uint8_t message_type) {
+  ProtoSize size;
+  msg.calculate_size(size);
+  std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
+  this->prepare_first_message_buffer(shared_buf, size.get_size());
+  msg.encode({&shared_buf});
+  return this->send_buffer({&shared_buf}, message_type);
+}
 bool APIConnection::send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) {
   const bool is_log_message = (message_type == SubscribeLogsResponse::MESSAGE_TYPE);
 
@@ -1897,6 +1836,23 @@ void APIConnection::DeferredBatch::add_item_front(EntityBase *entity, uint8_t me
   }
 }
 
+bool APIConnection::send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
+                                        uint8_t aux_data_index) {
+  if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+    auto &shared_buf = this->parent_->get_shared_buffer_ref();
+    this->prepare_first_message_buffer(shared_buf, estimated_size);
+    DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index};
+    if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) &&
+        this->send_buffer(ProtoWriteBuffer{&shared_buf}, message_type)) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_batch_item_(item);
+#endif
+      return true;
+    }
+  }
+  return this->schedule_message_(entity, message_type, estimated_size, aux_data_index);
+}
+
 bool APIConnection::schedule_batch_() {
   if (!this->flags_.batch_scheduled) {
     this->flags_.batch_scheduled = true;
@@ -1925,10 +1881,21 @@ void APIConnection::process_batch_() {
   auto &shared_buf = this->parent_->get_shared_buffer_ref();
   size_t num_items = this->deferred_batch_.size();
 
-  // Fast path for single message - allocate exact size needed
+  // Cache these values to avoid repeated virtual calls
+  const uint8_t header_padding = this->helper_->frame_header_padding();
+  const uint8_t footer_size = this->helper_->frame_footer_size();
+
+  // Pre-calculate exact buffer size needed based on message types
+  uint32_t total_estimated_size = num_items * (header_padding + footer_size);
+  for (size_t i = 0; i < num_items; i++) {
+    total_estimated_size += this->deferred_batch_[i].estimated_size;
+  }
+
+  this->prepare_first_message_buffer(shared_buf, header_padding, total_estimated_size);
+
+  // Fast path for single message - buffer already allocated above
   if (num_items == 1) {
     const auto &item = this->deferred_batch_[0];
-
     // Let dispatch_message_ calculate size and encode if it fits
     uint16_t payload_size = this->dispatch_message_(item, std::numeric_limits<uint16_t>::max(), true);
 
@@ -1951,30 +1918,8 @@ void APIConnection::process_batch_() {
   // Stack-allocated array for message info
   alignas(MessageInfo) char message_info_storage[MAX_MESSAGES_PER_BATCH * sizeof(MessageInfo)];
   MessageInfo *message_info = reinterpret_cast<MessageInfo *>(message_info_storage);
-  size_t message_count = 0;
-
-  // Cache these values to avoid repeated virtual calls
-  const uint8_t header_padding = this->helper_->frame_header_padding();
-  const uint8_t footer_size = this->helper_->frame_footer_size();
-
-  // Initialize buffer and tracking variables
-  shared_buf.clear();
-
-  // Pre-calculate exact buffer size needed based on message types
-  uint32_t total_estimated_size = num_items * (header_padding + footer_size);
-  for (size_t i = 0; i < this->deferred_batch_.size(); i++) {
-    const auto &item = this->deferred_batch_[i];
-    total_estimated_size += item.estimated_size;
-  }
-
-  // Calculate total overhead for all messages
-  // Reserve based on estimated size (much more accurate than 24-byte worst-case)
-  shared_buf.reserve(total_estimated_size);
-  this->flags_.batch_first_message = true;
-
   size_t items_processed = 0;
   uint16_t remaining_size = std::numeric_limits<uint16_t>::max();
-
   // Track where each message's header padding begins in the buffer
   // For plaintext: this is where the 6-byte header padding starts
   // For noise: this is where the 7-byte header padding starts
@@ -1986,7 +1931,7 @@ void APIConnection::process_batch_() {
     const auto &item = this->deferred_batch_[i];
     // Try to encode message via dispatch
     // The dispatch function calculates overhead to determine if the message fits
-    uint16_t payload_size = this->dispatch_message_(item, remaining_size, false);
+    uint16_t payload_size = this->dispatch_message_(item, remaining_size, i == 0);
 
     if (payload_size == 0) {
       // Message won't fit, stop processing
@@ -2000,10 +1945,7 @@ void APIConnection::process_batch_() {
     // This avoids default-constructing all MAX_MESSAGES_PER_BATCH elements
     // Explicit destruction is not needed because MessageInfo is trivially destructible,
     // as ensured by the static_assert in its definition.
-    new (&message_info[message_count++]) MessageInfo(item.message_type, current_offset, proto_payload_size);
-
-    // Update tracking variables
-    items_processed++;
+    new (&message_info[items_processed++]) MessageInfo(item.message_type, current_offset, proto_payload_size);
     // After first message, set remaining size to MAX_BATCH_PACKET_SIZE to avoid fragmentation
     if (items_processed == 1) {
       remaining_size = MAX_BATCH_PACKET_SIZE;
@@ -2026,7 +1968,7 @@ void APIConnection::process_batch_() {
 
   // Send all collected messages
   APIError err = this->helper_->write_protobuf_messages(ProtoWriteBuffer{&shared_buf},
-                                                        std::span<const MessageInfo>(message_info, message_count));
+                                                        std::span<const MessageInfo>(message_info, items_processed));
   if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
     this->fatal_error_with_log_(LOG_STR("Batch write failed"), err);
   }
@@ -2055,7 +1997,8 @@ void APIConnection::process_batch_() {
 // Dispatch message encoding based on message_type
 // Switch assigns function pointer, single call site for smaller code size
 uint16_t APIConnection::dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size,
-                                          bool is_single) {
+                                          bool batch_first) {
+  this->flags_.batch_first_message = batch_first;
 #ifdef USE_EVENT
   // Events need aux_data_index to look up event type from entity
   if (item.message_type == EventResponse::MESSAGE_TYPE) {
@@ -2064,7 +2007,7 @@ uint16_t APIConnection::dispatch_message_(const DeferredBatch::BatchItem &item,
       return 0;
     auto *event = static_cast<event::Event *>(item.entity);
     return try_send_event_response(event, StringRef::from_maybe_nullptr(event->get_event_type(item.aux_data_index)),
-                                   this, remaining_size, is_single);
+                                   this, remaining_size);
   }
 #endif
 
@@ -2174,25 +2117,22 @@ uint16_t APIConnection::dispatch_message_(const DeferredBatch::BatchItem &item,
 #undef CASE_STATE_INFO
 #undef CASE_INFO_ONLY
 
-  return func(item.entity, this, remaining_size, is_single);
+  return func(item.entity, this, remaining_size);
 }
 
-uint16_t APIConnection::try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                bool is_single) {
+uint16_t APIConnection::try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   ListEntitiesDoneResponse resp;
-  return encode_message_to_buffer(resp, ListEntitiesDoneResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return encode_message_to_buffer(resp, ListEntitiesDoneResponse::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                    bool is_single) {
+uint16_t APIConnection::try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   DisconnectRequest req;
-  return encode_message_to_buffer(req, DisconnectRequest::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return encode_message_to_buffer(req, DisconnectRequest::MESSAGE_TYPE, conn, remaining_size);
 }
 
-uint16_t APIConnection::try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single) {
+uint16_t APIConnection::try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   PingRequest req;
-  return encode_message_to_buffer(req, PingRequest::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return encode_message_to_buffer(req, PingRequest::MESSAGE_TYPE, conn, remaining_size);
 }
 
 #ifdef USE_API_HOMEASSISTANT_STATES
diff --git a/esphome/components/api/api_connection.h b/esphome/components/api/api_connection.h
index 21bf4c4073b..40e4fd61c15 100644
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -170,7 +170,7 @@ class APIConnection final : public APIServerConnection {
 
 #ifdef USE_WATER_HEATER
   bool send_water_heater_state(water_heater::WaterHeater *water_heater);
-  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+  void water_heater_command(const WaterHeaterCommandRequest &msg) override;
 #endif
 
 #ifdef USE_IR_RF
@@ -255,17 +255,7 @@ class APIConnection final : public APIServerConnection {
 
   void on_fatal_error() override;
   void on_no_setup_connection() override;
-  ProtoWriteBuffer create_buffer(uint32_t reserve_size) override {
-    // FIXME: ensure no recursive writes can happen
-
-    // Get header padding size - used for both reserve and insert
-    uint8_t header_padding = this->helper_->frame_header_padding();
-    // Get shared buffer from parent server
-    std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
-    this->prepare_first_message_buffer(shared_buf, header_padding,
-                                       reserve_size + header_padding + this->helper_->frame_footer_size());
-    return {&shared_buf};
-  }
+  bool send_message_impl(const ProtoMessage &msg, uint8_t message_type) override;
 
   void prepare_first_message_buffer(std::vector<uint8_t> &shared_buf, size_t header_padding, size_t total_size) {
     shared_buf.clear();
@@ -277,6 +267,13 @@ class APIConnection final : public APIServerConnection {
     shared_buf.resize(header_padding);
   }
 
+  // Convenience overload - computes frame overhead internally
+  void prepare_first_message_buffer(std::vector<uint8_t> &shared_buf, size_t payload_size) {
+    const uint8_t header_padding = this->helper_->frame_header_padding();
+    const uint8_t footer_size = this->helper_->frame_footer_size();
+    this->prepare_first_message_buffer(shared_buf, header_padding, payload_size + header_padding + footer_size);
+  }
+
   bool try_to_clear_buffer(bool log_out_of_space);
   bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) override;
 
@@ -298,21 +295,21 @@ class APIConnection final : public APIServerConnection {
 
   // Non-template helper to encode any ProtoMessage
   static uint16_t encode_message_to_buffer(ProtoMessage &msg, uint8_t message_type, APIConnection *conn,
-                                           uint32_t remaining_size, bool is_single);
+                                           uint32_t remaining_size);
 
   // Helper to fill entity state base and encode message
   static uint16_t fill_and_encode_entity_state(EntityBase *entity, StateResponseProtoMessage &msg, uint8_t message_type,
-                                               APIConnection *conn, uint32_t remaining_size, bool is_single) {
+                                               APIConnection *conn, uint32_t remaining_size) {
     msg.key = entity->get_object_id_hash();
 #ifdef USE_DEVICES
     msg.device_id = entity->get_device_id();
 #endif
-    return encode_message_to_buffer(msg, message_type, conn, remaining_size, is_single);
+    return encode_message_to_buffer(msg, message_type, conn, remaining_size);
   }
 
   // Helper to fill entity info base and encode message
   static uint16_t fill_and_encode_entity_info(EntityBase *entity, InfoResponseProtoMessage &msg, uint8_t message_type,
-                                              APIConnection *conn, uint32_t remaining_size, bool is_single) {
+                                              APIConnection *conn, uint32_t remaining_size) {
     // Set common fields that are shared by all entity types
     msg.key = entity->get_object_id_hash();
 
@@ -339,7 +336,7 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_DEVICES
     msg.device_id = entity->get_device_id();
 #endif
-    return encode_message_to_buffer(msg, message_type, conn, remaining_size, is_single);
+    return encode_message_to_buffer(msg, message_type, conn, remaining_size);
   }
 
 #ifdef USE_VOICE_ASSISTANT
@@ -370,141 +367,108 @@ class APIConnection final : public APIServerConnection {
   }
 
 #ifdef USE_BINARY_SENSOR
-  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                               bool is_single);
-  static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single);
+  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_COVER
-  static uint16_t try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
-  static uint16_t try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_FAN
-  static uint16_t try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_LIGHT
-  static uint16_t try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
-  static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_SENSOR
-  static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
-  static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_SWITCH
-  static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
-  static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_TEXT_SENSOR
-  static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single);
-  static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                            bool is_single);
+  static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_CLIMATE
-  static uint16_t try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                         bool is_single);
-  static uint16_t try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
+  static uint16_t try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_NUMBER
-  static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
-  static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_DATETIME_DATE
-  static uint16_t try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_DATETIME_TIME
-  static uint16_t try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_DATETIME_DATETIME
-  static uint16_t try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                          bool is_single);
-  static uint16_t try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                         bool is_single);
+  static uint16_t try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_TEXT
-  static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_SELECT
-  static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
-  static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_BUTTON
-  static uint16_t try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_LOCK
-  static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_VALVE
-  static uint16_t try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
-  static uint16_t try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_MEDIA_PLAYER
-  static uint16_t try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single);
-  static uint16_t try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single);
+  static uint16_t try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-  static uint16_t try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                     bool is_single);
-  static uint16_t try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                    bool is_single);
+  static uint16_t try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_WATER_HEATER
-  static uint16_t try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single);
-  static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                             bool is_single);
+  static uint16_t try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_water_heater_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_INFRARED
-  static uint16_t try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                         bool is_single);
+  static uint16_t try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_EVENT
   static uint16_t try_send_event_response(event::Event *event, StringRef event_type, APIConnection *conn,
-                                          uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+                                          uint32_t remaining_size);
+  static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_UPDATE
-  static uint16_t try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
-  static uint16_t try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
+  static uint16_t try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 #ifdef USE_CAMERA
-  static uint16_t try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                       bool is_single);
+  static uint16_t try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 #endif
 
   // Method for ListEntitiesDone batching
-  static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                          bool is_single);
+  static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 
   // Method for DisconnectRequest batching
-  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single);
+  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 
   // Batch message method for ping requests
-  static uint16_t try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                        bool is_single);
+  static uint16_t try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size);
 
   // === Optimal member ordering for 32-bit systems ===
 
@@ -539,7 +503,7 @@ class APIConnection final : public APIServerConnection {
 #endif
 
   // Function pointer type for message encoding
-  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size, bool is_single);
+  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size);
 
   // Generic batching mechanism for both state updates and entity info
   struct DeferredBatch {
@@ -652,7 +616,7 @@ class APIConnection final : public APIServerConnection {
 
   // Dispatch message encoding based on message_type - replaces function pointer storage
   // Switch assigns pointer, single call site for smaller code size
-  uint16_t dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size, bool is_single);
+  uint16_t dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size, bool batch_first);
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void log_batch_item_(const DeferredBatch::BatchItem &item) {
@@ -684,19 +648,7 @@ class APIConnection final : public APIServerConnection {
   // Tries immediate send if should_send_immediately_() returns true and buffer has space
   // Falls back to batching if immediate send fails or isn't applicable
   bool send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-      DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index};
-      if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) &&
-          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-        this->log_batch_item_(item);
-#endif
-        return true;
-      }
-    }
-    return this->schedule_message_(entity, message_type, estimated_size, aux_data_index);
-  }
+                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED);
 
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
diff --git a/esphome/components/api/api_pb2_dump.cpp b/esphome/components/api/api_pb2_dump.cpp
index 29121f05e07..e9db36ae216 100644
--- a/esphome/components/api/api_pb2_dump.cpp
+++ b/esphome/components/api/api_pb2_dump.cpp
@@ -23,15 +23,8 @@ static inline void append_field_prefix(DumpBuffer &out, const char *field_name,
   out.append(indent, ' ').append(field_name).append(": ");
 }
 
-static inline void append_with_newline(DumpBuffer &out, const char *str) {
-  out.append(str);
-  out.append("\n");
-}
-
 static inline void append_uint(DumpBuffer &out, uint32_t value) {
-  char buf[16];
-  snprintf(buf, sizeof(buf), "%" PRIu32, value);
-  out.append(buf);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu32, value));
 }
 
 // RAII helper for message dump formatting
@@ -49,31 +42,23 @@ class MessageDumpHelper {
 
 // Helper functions to reduce code duplication in dump methods
 static void dump_field(DumpBuffer &out, const char *field_name, int32_t value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%" PRId32, value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRId32 "\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, uint32_t value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%" PRIu32, value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu32 "\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, float value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%g", value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%g\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, uint64_t value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%" PRIu64, value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu64 "\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, bool value, int indent = 2) {
@@ -112,7 +97,7 @@ static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint
   char hex_buf[format_hex_pretty_size(160)];
   append_field_prefix(out, field_name, indent);
   format_hex_pretty_to(hex_buf, data, len);
-  append_with_newline(out, hex_buf);
+  out.append(hex_buf).append("\n");
 }
 
 template<> const char *proto_enum_to_string<enums::EntityCategory>(enums::EntityCategory value) {
diff --git a/esphome/components/api/api_pb2_service.cpp b/esphome/components/api/api_pb2_service.cpp
index 4b7148e6c05..af0a2d0ca27 100644
--- a/esphome/components/api/api_pb2_service.cpp
+++ b/esphome/components/api/api_pb2_service.cpp
@@ -746,6 +746,11 @@ void APIServerConnection::on_update_command_request(const UpdateCommandRequest &
 #ifdef USE_VALVE
 void APIServerConnection::on_valve_command_request(const ValveCommandRequest &msg) { this->valve_command(msg); }
 #endif
+#ifdef USE_WATER_HEATER
+void APIServerConnection::on_water_heater_command_request(const WaterHeaterCommandRequest &msg) {
+  this->water_heater_command(msg);
+}
+#endif
 #ifdef USE_BLUETOOTH_PROXY
 void APIServerConnection::on_subscribe_bluetooth_le_advertisements_request(
     const SubscribeBluetoothLEAdvertisementsRequest &msg) {
diff --git a/esphome/components/api/api_pb2_service.h b/esphome/components/api/api_pb2_service.h
index 200991c2826..e2bc1609ed7 100644
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -23,7 +23,7 @@ class APIServerConnectionBase : public ProtoService {
     DumpBuffer dump_buf;
     this->log_send_message_(msg.message_name(), msg.dump_to(dump_buf));
 #endif
-    return this->send_message_(msg, message_type);
+    return this->send_message_impl(msg, message_type);
   }
 
   virtual void on_hello_request(const HelloRequest &value){};
@@ -303,6 +303,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_VALVE
   virtual void valve_command(const ValveCommandRequest &msg) = 0;
 #endif
+#ifdef USE_WATER_HEATER
+  virtual void water_heater_command(const WaterHeaterCommandRequest &msg) = 0;
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   virtual void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) = 0;
 #endif
@@ -432,6 +435,9 @@ class APIServerConnection : public APIServerConnectionBase {
 #ifdef USE_VALVE
   void on_valve_command_request(const ValveCommandRequest &msg) override;
 #endif
+#ifdef USE_WATER_HEATER
+  void on_water_heater_command_request(const WaterHeaterCommandRequest &msg) override;
+#endif
 #ifdef USE_BLUETOOTH_PROXY
   void on_subscribe_bluetooth_le_advertisements_request(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
 #endif
diff --git a/esphome/components/api/api_server.cpp b/esphome/components/api/api_server.cpp
index ed97c3b9a26..c56449455d2 100644
--- a/esphome/components/api/api_server.cpp
+++ b/esphome/components/api/api_server.cpp
@@ -211,7 +211,7 @@ void APIServer::loop() {
 
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
     // Fire trigger after client is removed so api.connected reflects the true state
-    this->client_disconnected_trigger_->trigger(client_name, client_peername);
+    this->client_disconnected_trigger_.trigger(client_name, client_peername);
 #endif
     // Don't increment client_index since we need to process the swapped element
   }
diff --git a/esphome/components/api/api_server.h b/esphome/components/api/api_server.h
index 93421ef801f..6ab3cdc5764 100644
--- a/esphome/components/api/api_server.h
+++ b/esphome/components/api/api_server.h
@@ -227,12 +227,10 @@ class APIServer : public Component,
 #endif
 
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  Trigger<std::string, std::string> *get_client_connected_trigger() const { return this->client_connected_trigger_; }
+  Trigger<std::string, std::string> *get_client_connected_trigger() { return &this->client_connected_trigger_; }
 #endif
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  Trigger<std::string, std::string> *get_client_disconnected_trigger() const {
-    return this->client_disconnected_trigger_;
-  }
+  Trigger<std::string, std::string> *get_client_disconnected_trigger() { return &this->client_disconnected_trigger_; }
 #endif
 
  protected:
@@ -253,10 +251,10 @@ class APIServer : public Component,
   // Pointers and pointer-like types first (4 bytes each)
   std::unique_ptr<socket::Socket> socket_ = nullptr;
 #ifdef USE_API_CLIENT_CONNECTED_TRIGGER
-  Trigger<std::string, std::string> *client_connected_trigger_ = new Trigger<std::string, std::string>();
+  Trigger<std::string, std::string> client_connected_trigger_;
 #endif
 #ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  Trigger<std::string, std::string> *client_disconnected_trigger_ = new Trigger<std::string, std::string>();
+  Trigger<std::string, std::string> client_disconnected_trigger_;
 #endif
 
   // 4-byte aligned types
diff --git a/esphome/components/api/homeassistant_service.h b/esphome/components/api/homeassistant_service.h
index 9bffe18764b..8ee23c75fee 100644
--- a/esphome/components/api/homeassistant_service.h
+++ b/esphome/components/api/homeassistant_service.h
@@ -136,12 +136,10 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
   void set_wants_response() { this->flags_.wants_response = true; }
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  Trigger<JsonObjectConst, Ts...> *get_success_trigger_with_response() const {
-    return this->success_trigger_with_response_;
-  }
+  Trigger<JsonObjectConst, Ts...> *get_success_trigger_with_response() { return &this->success_trigger_with_response_; }
 #endif
-  Trigger<Ts...> *get_success_trigger() const { return this->success_trigger_; }
-  Trigger<std::string, Ts...> *get_error_trigger() const { return this->error_trigger_; }
+  Trigger<Ts...> *get_success_trigger() { return &this->success_trigger_; }
+  Trigger<std::string, Ts...> *get_error_trigger() { return &this->error_trigger_; }
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 
   void play(const Ts &...x) override {
@@ -187,14 +185,14 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
               if (response.is_success()) {
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
                 if (this->flags_.wants_response) {
-                  this->success_trigger_with_response_->trigger(response.get_json(), args...);
+                  this->success_trigger_with_response_.trigger(response.get_json(), args...);
                 } else
 #endif
                 {
-                  this->success_trigger_->trigger(args...);
+                  this->success_trigger_.trigger(args...);
                 }
               } else {
-                this->error_trigger_->trigger(response.get_error_message(), args...);
+                this->error_trigger_.trigger(response.get_error_message(), args...);
               }
             },
             captured_args);
@@ -251,10 +249,10 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   TemplatableStringValue<Ts...> response_template_{""};
-  Trigger<JsonObjectConst, Ts...> *success_trigger_with_response_ = new Trigger<JsonObjectConst, Ts...>();
+  Trigger<JsonObjectConst, Ts...> success_trigger_with_response_;
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  Trigger<Ts...> *success_trigger_ = new Trigger<Ts...>();
-  Trigger<std::string, Ts...> *error_trigger_ = new Trigger<std::string, Ts...>();
+  Trigger<Ts...> success_trigger_;
+  Trigger<std::string, Ts...> error_trigger_;
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 
   struct Flags {
diff --git a/esphome/components/api/proto.h b/esphome/components/api/proto.h
index 2e0df297c35..92978f765f0 100644
--- a/esphome/components/api/proto.h
+++ b/esphome/components/api/proto.h
@@ -402,6 +402,20 @@ class DumpBuffer {
   const char *c_str() const { return buf_; }
   size_t size() const { return pos_; }
 
+  /// Get writable buffer pointer for use with buf_append_printf
+  char *data() { return buf_; }
+  /// Get current position for use with buf_append_printf
+  size_t pos() const { return pos_; }
+  /// Update position after buf_append_printf call
+  void set_pos(size_t pos) {
+    if (pos >= CAPACITY) {
+      pos_ = CAPACITY - 1;
+    } else {
+      pos_ = pos;
+    }
+    buf_[pos_] = '\0';
+  }
+
  private:
   void append_impl_(const char *str, size_t len) {
     size_t space = CAPACITY - 1 - pos_;
@@ -943,32 +957,16 @@ class ProtoService {
   virtual bool is_connection_setup() = 0;
   virtual void on_fatal_error() = 0;
   virtual void on_no_setup_connection() = 0;
-  /**
-   * Create a buffer with a reserved size.
-   * @param reserve_size The number of bytes to pre-allocate in the buffer. This is a hint
-   *                     to optimize memory usage and avoid reallocations during encoding.
-   *                     Implementations should aim to allocate at least this size.
-   * @return A ProtoWriteBuffer object with the reserved size.
-   */
-  virtual ProtoWriteBuffer create_buffer(uint32_t reserve_size) = 0;
   virtual bool send_buffer(ProtoWriteBuffer buffer, uint8_t message_type) = 0;
   virtual void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) = 0;
-
-  // Optimized method that pre-allocates buffer based on message size
-  bool send_message_(const ProtoMessage &msg, uint8_t message_type) {
-    ProtoSize size;
-    msg.calculate_size(size);
-    uint32_t msg_size = size.get_size();
-
-    // Create a pre-sized buffer
-    auto buffer = this->create_buffer(msg_size);
-
-    // Encode message into the buffer
-    msg.encode(buffer);
-
-    // Send the buffer
-    return this->send_buffer(buffer, message_type);
-  }
+  /**
+   * Send a protobuf message by calculating its size, allocating a buffer, encoding, and sending.
+   * This is the implementation method - callers should use send_message() which adds logging.
+   * @param msg The protobuf message to send.
+   * @param message_type The message type identifier.
+   * @return True if the message was sent successfully, false otherwise.
+   */
+  virtual bool send_message_impl(const ProtoMessage &msg, uint8_t message_type) = 0;
 
   // Authentication helper methods
   inline bool check_connection_setup_() {
diff --git a/esphome/components/aqi/aqi_sensor.h b/esphome/components/aqi/aqi_sensor.h
index a990f815fec..2e526ca8252 100644
--- a/esphome/components/aqi/aqi_sensor.h
+++ b/esphome/components/aqi/aqi_sensor.h
@@ -10,7 +10,6 @@ class AQISensor : public sensor::Sensor, public Component {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void set_pm_2_5_sensor(sensor::Sensor *sensor) { this->pm_2_5_sensor_ = sensor; }
   void set_pm_10_0_sensor(sensor::Sensor *sensor) { this->pm_10_0_sensor_ = sensor; }
diff --git a/esphome/components/as3935/as3935.cpp b/esphome/components/as3935/as3935.cpp
index 93a0bff5b31..dd0ab714f7c 100644
--- a/esphome/components/as3935/as3935.cpp
+++ b/esphome/components/as3935/as3935.cpp
@@ -41,8 +41,6 @@ void AS3935Component::dump_config() {
 #endif
 }
 
-float AS3935Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void AS3935Component::loop() {
   if (!this->irq_pin_->digital_read())
     return;
diff --git a/esphome/components/as3935/as3935.h b/esphome/components/as3935/as3935.h
index dc590c268ec..5dff1cb0aef 100644
--- a/esphome/components/as3935/as3935.h
+++ b/esphome/components/as3935/as3935.h
@@ -74,7 +74,6 @@ class AS3935Component : public Component {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void loop() override;
 
   void set_irq_pin(GPIOPin *irq_pin) { irq_pin_ = irq_pin; }
diff --git a/esphome/components/as5600/sensor/as5600_sensor.cpp b/esphome/components/as5600/sensor/as5600_sensor.cpp
index feb8f6cebf3..1c0f4bad2c3 100644
--- a/esphome/components/as5600/sensor/as5600_sensor.cpp
+++ b/esphome/components/as5600/sensor/as5600_sensor.cpp
@@ -22,8 +22,6 @@ static const uint8_t REGISTER_STATUS = 0x0B;     // 8 bytes  / R
 static const uint8_t REGISTER_AGC = 0x1A;        // 8 bytes  / R
 static const uint8_t REGISTER_MAGNITUDE = 0x1B;  // 16 bytes / R
 
-float AS5600Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void AS5600Sensor::dump_config() {
   LOG_SENSOR("", "AS5600 Sensor", this);
   ESP_LOGCONFIG(TAG, "  Out of Range Mode: %u", this->out_of_range_mode_);
diff --git a/esphome/components/as5600/sensor/as5600_sensor.h b/esphome/components/as5600/sensor/as5600_sensor.h
index 0af9b01ae5c..d471be49b58 100644
--- a/esphome/components/as5600/sensor/as5600_sensor.h
+++ b/esphome/components/as5600/sensor/as5600_sensor.h
@@ -14,7 +14,6 @@ class AS5600Sensor : public PollingComponent, public Parented<AS5600Component>,
  public:
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void set_angle_sensor(sensor::Sensor *angle_sensor) { this->angle_sensor_ = angle_sensor; }
   void set_raw_angle_sensor(sensor::Sensor *raw_angle_sensor) { this->raw_angle_sensor_ = raw_angle_sensor; }
diff --git a/esphome/components/as7341/as7341.cpp b/esphome/components/as7341/as7341.cpp
index 893eaa850f6..1e78d814c8c 100644
--- a/esphome/components/as7341/as7341.cpp
+++ b/esphome/components/as7341/as7341.cpp
@@ -58,8 +58,6 @@ void AS7341Component::dump_config() {
   LOG_SENSOR("  ", "NIR", this->nir_);
 }
 
-float AS7341Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void AS7341Component::update() {
   this->read_channels(this->channel_readings_);
 
diff --git a/esphome/components/as7341/as7341.h b/esphome/components/as7341/as7341.h
index aed7996cef5..3ede9d4aa4b 100644
--- a/esphome/components/as7341/as7341.h
+++ b/esphome/components/as7341/as7341.h
@@ -78,7 +78,6 @@ class AS7341Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_f1_sensor(sensor::Sensor *f1_sensor) { this->f1_ = f1_sensor; }
diff --git a/esphome/components/atm90e26/atm90e26.cpp b/esphome/components/atm90e26/atm90e26.cpp
index cadc06ac6b4..2203dd0d713 100644
--- a/esphome/components/atm90e26/atm90e26.cpp
+++ b/esphome/components/atm90e26/atm90e26.cpp
@@ -146,7 +146,6 @@ void ATM90E26Component::dump_config() {
   LOG_SENSOR("  ", "Active Reverse Energy A", this->reverse_active_energy_sensor_);
   LOG_SENSOR("  ", "Frequency", this->freq_sensor_);
 }
-float ATM90E26Component::get_setup_priority() const { return setup_priority::DATA; }
 
 uint16_t ATM90E26Component::read16_(uint8_t a_register) {
   uint8_t data[2];
diff --git a/esphome/components/atm90e26/atm90e26.h b/esphome/components/atm90e26/atm90e26.h
index 3c098d7e91b..d15a53ea433 100644
--- a/esphome/components/atm90e26/atm90e26.h
+++ b/esphome/components/atm90e26/atm90e26.h
@@ -13,7 +13,6 @@ class ATM90E26Component : public PollingComponent,
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_voltage_sensor(sensor::Sensor *obj) { this->voltage_sensor_ = obj; }
diff --git a/esphome/components/bang_bang/bang_bang_climate.cpp b/esphome/components/bang_bang/bang_bang_climate.cpp
index f26377a38a9..6871e9df5dc 100644
--- a/esphome/components/bang_bang/bang_bang_climate.cpp
+++ b/esphome/components/bang_bang/bang_bang_climate.cpp
@@ -6,8 +6,7 @@ namespace bang_bang {
 
 static const char *const TAG = "bang_bang.climate";
 
-BangBangClimate::BangBangClimate()
-    : idle_trigger_(new Trigger<>()), cool_trigger_(new Trigger<>()), heat_trigger_(new Trigger<>()) {}
+BangBangClimate::BangBangClimate() = default;
 
 void BangBangClimate::setup() {
   this->sensor_->add_on_state_callback([this](float state) {
@@ -160,13 +159,13 @@ void BangBangClimate::switch_to_action_(climate::ClimateAction action) {
   switch (action) {
     case climate::CLIMATE_ACTION_OFF:
     case climate::CLIMATE_ACTION_IDLE:
-      trig = this->idle_trigger_;
+      trig = &this->idle_trigger_;
       break;
     case climate::CLIMATE_ACTION_COOLING:
-      trig = this->cool_trigger_;
+      trig = &this->cool_trigger_;
       break;
     case climate::CLIMATE_ACTION_HEATING:
-      trig = this->heat_trigger_;
+      trig = &this->heat_trigger_;
       break;
     default:
       trig = nullptr;
@@ -204,9 +203,9 @@ void BangBangClimate::set_away_config(const BangBangClimateTargetTempConfig &awa
 void BangBangClimate::set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
 void BangBangClimate::set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
 
-Trigger<> *BangBangClimate::get_idle_trigger() const { return this->idle_trigger_; }
-Trigger<> *BangBangClimate::get_cool_trigger() const { return this->cool_trigger_; }
-Trigger<> *BangBangClimate::get_heat_trigger() const { return this->heat_trigger_; }
+Trigger<> *BangBangClimate::get_idle_trigger() { return &this->idle_trigger_; }
+Trigger<> *BangBangClimate::get_cool_trigger() { return &this->cool_trigger_; }
+Trigger<> *BangBangClimate::get_heat_trigger() { return &this->heat_trigger_; }
 
 void BangBangClimate::set_supports_cool(bool supports_cool) { this->supports_cool_ = supports_cool; }
 void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
diff --git a/esphome/components/bang_bang/bang_bang_climate.h b/esphome/components/bang_bang/bang_bang_climate.h
index 2e7da93a070..d0ddef2848e 100644
--- a/esphome/components/bang_bang/bang_bang_climate.h
+++ b/esphome/components/bang_bang/bang_bang_climate.h
@@ -30,9 +30,9 @@ class BangBangClimate : public climate::Climate, public Component {
   void set_normal_config(const BangBangClimateTargetTempConfig &normal_config);
   void set_away_config(const BangBangClimateTargetTempConfig &away_config);
 
-  Trigger<> *get_idle_trigger() const;
-  Trigger<> *get_cool_trigger() const;
-  Trigger<> *get_heat_trigger() const;
+  Trigger<> *get_idle_trigger();
+  Trigger<> *get_cool_trigger();
+  Trigger<> *get_heat_trigger();
 
  protected:
   /// Override control to change settings of the climate device.
@@ -57,17 +57,13 @@ class BangBangClimate : public climate::Climate, public Component {
    *
    * In idle mode, the controller is assumed to have both heating and cooling disabled.
    */
-  Trigger<> *idle_trigger_{nullptr};
+  Trigger<> idle_trigger_;
   /** The trigger to call when the controller should switch to cooling mode.
    */
-  Trigger<> *cool_trigger_{nullptr};
+  Trigger<> cool_trigger_;
   /** The trigger to call when the controller should switch to heating mode.
-   *
-   * A null value for this attribute means that the controller has no heating action
-   * For example window blinds, where only cooling (blinds closed) and not-cooling
-   * (blinds open) is possible.
    */
-  Trigger<> *heat_trigger_{nullptr};
+  Trigger<> heat_trigger_;
   /** A reference to the trigger that was previously active.
    *
    * This is so that the previous trigger can be stopped before enabling a new one.
diff --git a/esphome/components/bh1750/bh1750.cpp b/esphome/components/bh1750/bh1750.cpp
index bd7c667c25c..045fb7cf454 100644
--- a/esphome/components/bh1750/bh1750.cpp
+++ b/esphome/components/bh1750/bh1750.cpp
@@ -265,6 +265,4 @@ void BH1750Sensor::fail_and_reset_() {
   this->state_ = IDLE;
 }
 
-float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace esphome::bh1750
diff --git a/esphome/components/bh1750/bh1750.h b/esphome/components/bh1750/bh1750.h
index 04604279548..39dbd1d6a99 100644
--- a/esphome/components/bh1750/bh1750.h
+++ b/esphome/components/bh1750/bh1750.h
@@ -21,7 +21,6 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void dump_config() override;
   void update() override;
   void loop() override;
-  float get_setup_priority() const override;
 
  protected:
   // State machine states
diff --git a/esphome/components/bme280_base/bme280_base.cpp b/esphome/components/bme280_base/bme280_base.cpp
index c5d4c9c0a5b..f396888fd19 100644
--- a/esphome/components/bme280_base/bme280_base.cpp
+++ b/esphome/components/bme280_base/bme280_base.cpp
@@ -199,7 +199,6 @@ void BME280Component::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
   ESP_LOGCONFIG(TAG, "    Oversampling: %s", oversampling_to_str(this->humidity_oversampling_));
 }
-float BME280Component::get_setup_priority() const { return setup_priority::DATA; }
 
 inline uint8_t oversampling_to_time(BME280Oversampling over_sampling) { return (1 << uint8_t(over_sampling)) >> 1; }
 
diff --git a/esphome/components/bme280_base/bme280_base.h b/esphome/components/bme280_base/bme280_base.h
index 0f55ad01012..00781d05b20 100644
--- a/esphome/components/bme280_base/bme280_base.h
+++ b/esphome/components/bme280_base/bme280_base.h
@@ -76,7 +76,6 @@ class BME280Component : public PollingComponent {
   // (In most use cases you won't need these)
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/bme680/bme680.cpp b/esphome/components/bme680/bme680.cpp
index 16435ccfee8..5e52c84b3db 100644
--- a/esphome/components/bme680/bme680.cpp
+++ b/esphome/components/bme680/bme680.cpp
@@ -233,8 +233,6 @@ void BME680Component::dump_config() {
   }
 }
 
-float BME680Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void BME680Component::update() {
   uint8_t meas_control = 0;  // No need to fetch, we're setting all fields
   meas_control |= (this->temperature_oversampling_ & 0b111) << 5;
diff --git a/esphome/components/bme680/bme680.h b/esphome/components/bme680/bme680.h
index cfa7aaca20e..d48a42823b2 100644
--- a/esphome/components/bme680/bme680.h
+++ b/esphome/components/bme680/bme680.h
@@ -99,7 +99,6 @@ class BME680Component : public PollingComponent, public i2c::I2CDevice {
   // (In most use cases you won't need these)
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/bme680_bsec/__init__.py b/esphome/components/bme680_bsec/__init__.py
index 06e641d34da..a86e061cd4e 100644
--- a/esphome/components/bme680_bsec/__init__.py
+++ b/esphome/components/bme680_bsec/__init__.py
@@ -89,8 +89,9 @@ async def to_code(config):
         var.set_state_save_interval(config[CONF_STATE_SAVE_INTERVAL].total_milliseconds)
     )
 
-    # Although this component does not use SPI, the BSEC library requires the SPI library
+    # Although this component does not use SPI/Wire directly, the BSEC library requires them
     cg.add_library("SPI", None)
+    cg.add_library("Wire", None)
 
     cg.add_define("USE_BSEC")
     cg.add_library("boschsensortec/BSEC Software Library", "1.6.1480")
diff --git a/esphome/components/bme680_bsec/bme680_bsec.cpp b/esphome/components/bme680_bsec/bme680_bsec.cpp
index d969c8fd980..392d071b317 100644
--- a/esphome/components/bme680_bsec/bme680_bsec.cpp
+++ b/esphome/components/bme680_bsec/bme680_bsec.cpp
@@ -181,8 +181,6 @@ void BME680BSECComponent::dump_config() {
   LOG_SENSOR("  ", "Breath VOC Equivalent", this->breath_voc_equivalent_sensor_);
 }
 
-float BME680BSECComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void BME680BSECComponent::loop() {
   this->run_();
 
diff --git a/esphome/components/bme680_bsec/bme680_bsec.h b/esphome/components/bme680_bsec/bme680_bsec.h
index e52dbe964b7..ec919f31df2 100644
--- a/esphome/components/bme680_bsec/bme680_bsec.h
+++ b/esphome/components/bme680_bsec/bme680_bsec.h
@@ -64,7 +64,6 @@ class BME680BSECComponent : public Component, public i2c::I2CDevice {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void loop() override;
 
  protected:
diff --git a/esphome/components/bme68x_bsec2/bme68x_bsec2.cpp b/esphome/components/bme68x_bsec2/bme68x_bsec2.cpp
index 91383c8d45e..1a42c9d54b6 100644
--- a/esphome/components/bme68x_bsec2/bme68x_bsec2.cpp
+++ b/esphome/components/bme68x_bsec2/bme68x_bsec2.cpp
@@ -106,8 +106,6 @@ void BME68xBSEC2Component::dump_config() {
 #endif
 }
 
-float BME68xBSEC2Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void BME68xBSEC2Component::loop() {
   this->run_();
 
diff --git a/esphome/components/bme68x_bsec2/bme68x_bsec2.h b/esphome/components/bme68x_bsec2/bme68x_bsec2.h
index 86d3e5dfbf4..8f4d8f61c25 100644
--- a/esphome/components/bme68x_bsec2/bme68x_bsec2.h
+++ b/esphome/components/bme68x_bsec2/bme68x_bsec2.h
@@ -48,7 +48,6 @@ class BME68xBSEC2Component : public Component {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void loop() override;
 
   void set_algorithm_output(AlgorithmOutput algorithm_output) { this->algorithm_output_ = algorithm_output; }
diff --git a/esphome/components/bmi160/bmi160.cpp b/esphome/components/bmi160/bmi160.cpp
index 4fcc3edb82a..1e8c91d7b79 100644
--- a/esphome/components/bmi160/bmi160.cpp
+++ b/esphome/components/bmi160/bmi160.cpp
@@ -263,7 +263,6 @@ void BMI160Component::update() {
 
   this->status_clear_warning();
 }
-float BMI160Component::get_setup_priority() const { return setup_priority::DATA; }
 
 }  // namespace bmi160
 }  // namespace esphome
diff --git a/esphome/components/bmi160/bmi160.h b/esphome/components/bmi160/bmi160.h
index 47691a4de99..16cab697330 100644
--- a/esphome/components/bmi160/bmi160.h
+++ b/esphome/components/bmi160/bmi160.h
@@ -14,8 +14,6 @@ class BMI160Component : public PollingComponent, public i2c::I2CDevice {
 
   void update() override;
 
-  float get_setup_priority() const override;
-
   void set_accel_x_sensor(sensor::Sensor *accel_x_sensor) { accel_x_sensor_ = accel_x_sensor; }
   void set_accel_y_sensor(sensor::Sensor *accel_y_sensor) { accel_y_sensor_ = accel_y_sensor; }
   void set_accel_z_sensor(sensor::Sensor *accel_z_sensor) { accel_z_sensor_ = accel_z_sensor; }
diff --git a/esphome/components/bmp085/bmp085.cpp b/esphome/components/bmp085/bmp085.cpp
index 657da34f9b0..9a383b26546 100644
--- a/esphome/components/bmp085/bmp085.cpp
+++ b/esphome/components/bmp085/bmp085.cpp
@@ -131,7 +131,6 @@ bool BMP085Component::set_mode_(uint8_t mode) {
   ESP_LOGV(TAG, "Setting mode to 0x%02X", mode);
   return this->write_byte(BMP085_REGISTER_CONTROL, mode);
 }
-float BMP085Component::get_setup_priority() const { return setup_priority::DATA; }
 
 }  // namespace bmp085
 }  // namespace esphome
diff --git a/esphome/components/bmp085/bmp085.h b/esphome/components/bmp085/bmp085.h
index d84b4d43ef5..c7315827e0e 100644
--- a/esphome/components/bmp085/bmp085.h
+++ b/esphome/components/bmp085/bmp085.h
@@ -18,8 +18,6 @@ class BMP085Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
 
-  float get_setup_priority() const override;
-
  protected:
   struct CalibrationData {
     int16_t ac1, ac2, ac3;
diff --git a/esphome/components/bmp280_base/bmp280_base.cpp b/esphome/components/bmp280_base/bmp280_base.cpp
index 728eead521a..de685e7c278 100644
--- a/esphome/components/bmp280_base/bmp280_base.cpp
+++ b/esphome/components/bmp280_base/bmp280_base.cpp
@@ -148,7 +148,6 @@ void BMP280Component::dump_config() {
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
   ESP_LOGCONFIG(TAG, "    Oversampling: %s", oversampling_to_str(this->pressure_oversampling_));
 }
-float BMP280Component::get_setup_priority() const { return setup_priority::DATA; }
 
 inline uint8_t oversampling_to_time(BMP280Oversampling over_sampling) { return (1 << uint8_t(over_sampling)) >> 1; }
 
diff --git a/esphome/components/bmp280_base/bmp280_base.h b/esphome/components/bmp280_base/bmp280_base.h
index a47a794e967..836eafaf8b6 100644
--- a/esphome/components/bmp280_base/bmp280_base.h
+++ b/esphome/components/bmp280_base/bmp280_base.h
@@ -64,7 +64,6 @@ class BMP280Component : public PollingComponent {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/bmp3xx_base/bmp3xx_base.cpp b/esphome/components/bmp3xx_base/bmp3xx_base.cpp
index acc28d4e853..d7d99721709 100644
--- a/esphome/components/bmp3xx_base/bmp3xx_base.cpp
+++ b/esphome/components/bmp3xx_base/bmp3xx_base.cpp
@@ -179,7 +179,6 @@ void BMP3XXComponent::dump_config() {
     ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
   }
 }
-float BMP3XXComponent::get_setup_priority() const { return setup_priority::DATA; }
 
 inline uint8_t oversampling_to_time(Oversampling over_sampling) { return (1 << uint8_t(over_sampling)); }
 
diff --git a/esphome/components/bmp3xx_base/bmp3xx_base.h b/esphome/components/bmp3xx_base/bmp3xx_base.h
index 50f92e04c14..8d2312231b9 100644
--- a/esphome/components/bmp3xx_base/bmp3xx_base.h
+++ b/esphome/components/bmp3xx_base/bmp3xx_base.h
@@ -73,7 +73,6 @@ class BMP3XXComponent : public PollingComponent {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
diff --git a/esphome/components/cc1101/cc1101.cpp b/esphome/components/cc1101/cc1101.cpp
index 46cd89e0e8d..b6973da78d1 100644
--- a/esphome/components/cc1101/cc1101.cpp
+++ b/esphome/components/cc1101/cc1101.cpp
@@ -156,7 +156,7 @@ void CC1101Component::call_listeners_(const std::vector<uint8_t> &packet, float
   for (auto &listener : this->listeners_) {
     listener->on_packet(packet, freq_offset, rssi, lqi);
   }
-  this->packet_trigger_->trigger(packet, freq_offset, rssi, lqi);
+  this->packet_trigger_.trigger(packet, freq_offset, rssi, lqi);
 }
 
 void CC1101Component::loop() {
diff --git a/esphome/components/cc1101/cc1101.h b/esphome/components/cc1101/cc1101.h
index 6e3f01af90b..e55071e7e36 100644
--- a/esphome/components/cc1101/cc1101.h
+++ b/esphome/components/cc1101/cc1101.h
@@ -79,7 +79,7 @@ class CC1101Component : public Component,
   // Packet mode operations
   CC1101Error transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(CC1101Listener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() const { return this->packet_trigger_; }
+  Trigger<std::vector<uint8_t>, float, float, uint8_t> *get_packet_trigger() { return &this->packet_trigger_; }
 
  protected:
   uint16_t chip_id_{0};
@@ -96,8 +96,7 @@ class CC1101Component : public Component,
 
   // Packet handling
   void call_listeners_(const std::vector<uint8_t> &packet, float freq_offset, float rssi, uint8_t lqi);
-  Trigger<std::vector<uint8_t>, float, float, uint8_t> *packet_trigger_{
-      new Trigger<std::vector<uint8_t>, float, float, uint8_t>()};
+  Trigger<std::vector<uint8_t>, float, float, uint8_t> packet_trigger_;
   std::vector<uint8_t> packet_;
   std::vector<CC1101Listener *> listeners_;
 
diff --git a/esphome/components/cd74hc4067/cd74hc4067.cpp b/esphome/components/cd74hc4067/cd74hc4067.cpp
index 4293d7af074..302c83d7d3a 100644
--- a/esphome/components/cd74hc4067/cd74hc4067.cpp
+++ b/esphome/components/cd74hc4067/cd74hc4067.cpp
@@ -7,8 +7,6 @@ namespace cd74hc4067 {
 
 static const char *const TAG = "cd74hc4067";
 
-float CD74HC4067Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void CD74HC4067Component::setup() {
   this->pin_s0_->setup();
   this->pin_s1_->setup();
diff --git a/esphome/components/cd74hc4067/cd74hc4067.h b/esphome/components/cd74hc4067/cd74hc4067.h
index 61935135757..76ebc1ebbe1 100644
--- a/esphome/components/cd74hc4067/cd74hc4067.h
+++ b/esphome/components/cd74hc4067/cd74hc4067.h
@@ -13,7 +13,6 @@ class CD74HC4067Component : public Component {
   /// Set up the internal sensor array.
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   /// setting pin active by setting the right combination of the four multiplexer input pins
   void activate_pin(uint8_t pin);
diff --git a/esphome/components/cm1106/cm1106.h b/esphome/components/cm1106/cm1106.h
index ad089bbe7d7..8c33e564578 100644
--- a/esphome/components/cm1106/cm1106.h
+++ b/esphome/components/cm1106/cm1106.h
@@ -10,8 +10,6 @@ namespace cm1106 {
 
 class CM1106Component : public PollingComponent, public uart::UARTDevice {
  public:
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
-
   void setup() override;
   void update() override;
   void dump_config() override;
diff --git a/esphome/components/combination/combination.h b/esphome/components/combination/combination.h
index 901aeaf2590..fb5e156da9a 100644
--- a/esphome/components/combination/combination.h
+++ b/esphome/components/combination/combination.h
@@ -10,8 +10,6 @@ namespace combination {
 
 class CombinationComponent : public Component, public sensor::Sensor {
  public:
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
-
   /// @brief Logs all source sensor's names
   virtual void log_source_sensors() = 0;
 
diff --git a/esphome/components/cover/__init__.py b/esphome/components/cover/__init__.py
index 383daee083a..41774f3d71a 100644
--- a/esphome/components/cover/__init__.py
+++ b/esphome/components/cover/__init__.py
@@ -1,3 +1,5 @@
+import logging
+
 from esphome import automation
 from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
@@ -9,6 +11,7 @@ from esphome.const import (
     CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
+    CONF_ON_IDLE,
     CONF_ON_OPEN,
     CONF_POSITION,
     CONF_POSITION_COMMAND_TOPIC,
@@ -32,9 +35,10 @@ from esphome.const import (
     DEVICE_CLASS_SHUTTER,
     DEVICE_CLASS_WINDOW,
 )
-from esphome.core import CORE, CoroPriority, coroutine_with_priority
+from esphome.core import CORE, ID, CoroPriority, coroutine_with_priority
 from esphome.core.entity_helpers import entity_duplicate_validator, setup_entity
-from esphome.cpp_generator import MockObjClass
+from esphome.cpp_generator import MockObj, MockObjClass
+from esphome.types import ConfigType, TemplateArgsType
 
 IS_PLATFORM_COMPONENT = True
 
@@ -53,6 +57,8 @@ DEVICE_CLASSES = [
     DEVICE_CLASS_WINDOW,
 ]
 
+_LOGGER = logging.getLogger(__name__)
+
 cover_ns = cg.esphome_ns.namespace("cover")
 
 Cover = cover_ns.class_("Cover", cg.EntityBase)
@@ -83,14 +89,29 @@ ControlAction = cover_ns.class_("ControlAction", automation.Action)
 CoverPublishAction = cover_ns.class_("CoverPublishAction", automation.Action)
 CoverIsOpenCondition = cover_ns.class_("CoverIsOpenCondition", Condition)
 CoverIsClosedCondition = cover_ns.class_("CoverIsClosedCondition", Condition)
-
-# Triggers
-CoverOpenTrigger = cover_ns.class_("CoverOpenTrigger", automation.Trigger.template())
+CoverOpenedTrigger = cover_ns.class_(
+    "CoverOpenedTrigger", automation.Trigger.template()
+)
 CoverClosedTrigger = cover_ns.class_(
     "CoverClosedTrigger", automation.Trigger.template()
 )
+CoverTrigger = cover_ns.class_("CoverTrigger", automation.Trigger.template())
 
+# Cover-specific constants
 CONF_ON_CLOSED = "on_closed"
+CONF_ON_OPENED = "on_opened"
+CONF_ON_OPENING = "on_opening"
+CONF_ON_CLOSING = "on_closing"
+
+TRIGGERS = {
+    CONF_ON_OPEN: CoverOpenedTrigger,  # Deprecated, use on_opened
+    CONF_ON_OPENED: CoverOpenedTrigger,
+    CONF_ON_CLOSED: CoverClosedTrigger,
+    CONF_ON_CLOSING: CoverTrigger.template(CoverOperation.COVER_OPERATION_CLOSING),
+    CONF_ON_OPENING: CoverTrigger.template(CoverOperation.COVER_OPERATION_OPENING),
+    CONF_ON_IDLE: CoverTrigger.template(CoverOperation.COVER_OPERATION_IDLE),
+}
+
 
 _COVER_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
@@ -111,16 +132,14 @@ _COVER_SCHEMA = (
             cv.Optional(CONF_TILT_STATE_TOPIC): cv.All(
                 cv.requires_component("mqtt"), cv.subscribe_topic
             ),
-            cv.Optional(CONF_ON_OPEN): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CoverOpenTrigger),
-                }
-            ),
-            cv.Optional(CONF_ON_CLOSED): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(CoverClosedTrigger),
-                }
-            ),
+            **{
+                cv.Optional(conf): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(trigger_class),
+                    }
+                )
+                for conf, trigger_class in TRIGGERS.items()
+            },
         }
     )
 )
@@ -157,12 +176,14 @@ async def setup_cover_core_(var, config):
     if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
         cg.add(var.set_device_class(device_class))
 
-    for conf in config.get(CONF_ON_OPEN, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
-    for conf in config.get(CONF_ON_CLOSED, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
+    if CONF_ON_OPEN in config:
+        _LOGGER.warning(
+            "'on_open' is deprecated, use 'on_opened'. Will be removed in 2026.8.0"
+        )
+    for trigger_conf in TRIGGERS:
+        for conf in config.get(trigger_conf, []):
+            trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+            await automation.build_automation(trigger, [], conf)
 
     if (mqtt_id := config.get(CONF_MQTT_ID)) is not None:
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
@@ -258,6 +279,26 @@ async def cover_control_to_code(config, action_id, template_arg, args):
     return var
 
 
+COVER_CONDITION_SCHEMA = cv.maybe_simple_value(
+    {cv.Required(CONF_ID): cv.use_id(Cover)}, key=CONF_ID
+)
+
+
+async def cover_condition_to_code(
+    config: ConfigType, condition_id: ID, template_arg: MockObj, args: TemplateArgsType
+) -> MockObj:
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(condition_id, template_arg, paren)
+
+
+automation.register_condition(
+    "cover.is_open", CoverIsOpenCondition, COVER_CONDITION_SCHEMA
+)(cover_condition_to_code)
+automation.register_condition(
+    "cover.is_closed", CoverIsClosedCondition, COVER_CONDITION_SCHEMA
+)(cover_condition_to_code)
+
+
 @coroutine_with_priority(CoroPriority.CORE)
 async def to_code(config):
     cg.add_global(cover_ns.using)
diff --git a/esphome/components/cover/automation.h b/esphome/components/cover/automation.h
index c0345a7cc61..12ec46725d6 100644
--- a/esphome/components/cover/automation.h
+++ b/esphome/components/cover/automation.h
@@ -90,44 +90,53 @@ template<typename... Ts> class CoverPublishAction : public Action<Ts...> {
   Cover *cover_;
 };
 
-template<typename... Ts> class CoverIsOpenCondition : public Condition<Ts...> {
+template<bool OPEN, typename... Ts> class CoverPositionCondition : public Condition<Ts...> {
  public:
-  CoverIsOpenCondition(Cover *cover) : cover_(cover) {}
-  bool check(const Ts &...x) override { return this->cover_->is_fully_open(); }
+  CoverPositionCondition(Cover *cover) : cover_(cover) {}
+
+  bool check(const Ts &...x) override { return this->cover_->position == (OPEN ? COVER_OPEN : COVER_CLOSED); }
 
  protected:
   Cover *cover_;
 };
 
-template<typename... Ts> class CoverIsClosedCondition : public Condition<Ts...> {
+template<typename... Ts> using CoverIsOpenCondition = CoverPositionCondition<true, Ts...>;
+template<typename... Ts> using CoverIsClosedCondition = CoverPositionCondition<false, Ts...>;
+
+template<bool OPEN> class CoverPositionTrigger : public Trigger<> {
  public:
-  CoverIsClosedCondition(Cover *cover) : cover_(cover) {}
-  bool check(const Ts &...x) override { return this->cover_->is_fully_closed(); }
+  CoverPositionTrigger(Cover *a_cover) {
+    a_cover->add_on_state_callback([this, a_cover]() {
+      if (a_cover->position != this->last_position_) {
+        this->last_position_ = a_cover->position;
+        if (a_cover->position == (OPEN ? COVER_OPEN : COVER_CLOSED))
+          this->trigger();
+      }
+    });
+  }
 
  protected:
-  Cover *cover_;
+  float last_position_{NAN};
 };
 
-class CoverOpenTrigger : public Trigger<> {
+using CoverOpenedTrigger = CoverPositionTrigger<true>;
+using CoverClosedTrigger = CoverPositionTrigger<false>;
+
+template<CoverOperation OP> class CoverTrigger : public Trigger<> {
  public:
-  CoverOpenTrigger(Cover *a_cover) {
+  CoverTrigger(Cover *a_cover) {
     a_cover->add_on_state_callback([this, a_cover]() {
-      if (a_cover->is_fully_open()) {
-        this->trigger();
+      auto current_op = a_cover->current_operation;
+      if (current_op == OP) {
+        if (!this->last_operation_.has_value() || this->last_operation_.value() != OP) {
+          this->trigger();
+        }
       }
+      this->last_operation_ = current_op;
     });
   }
-};
 
-class CoverClosedTrigger : public Trigger<> {
- public:
-  CoverClosedTrigger(Cover *a_cover) {
-    a_cover->add_on_state_callback([this, a_cover]() {
-      if (a_cover->is_fully_closed()) {
-        this->trigger();
-      }
-    });
-  }
+ protected:
+  optional<CoverOperation> last_operation_{};
 };
-
 }  // namespace esphome::cover
diff --git a/esphome/components/cover/cover.cpp b/esphome/components/cover/cover.cpp
index 0d9e7e8ffb0..37cb908d9f3 100644
--- a/esphome/components/cover/cover.cpp
+++ b/esphome/components/cover/cover.cpp
@@ -10,9 +10,6 @@ namespace esphome::cover {
 
 static const char *const TAG = "cover";
 
-const float COVER_OPEN = 1.0f;
-const float COVER_CLOSED = 0.0f;
-
 const LogString *cover_command_to_str(float pos) {
   if (pos == COVER_OPEN) {
     return LOG_STR("OPEN");
diff --git a/esphome/components/cover/cover.h b/esphome/components/cover/cover.h
index e5427ceaa86..0af48f75de8 100644
--- a/esphome/components/cover/cover.h
+++ b/esphome/components/cover/cover.h
@@ -10,8 +10,8 @@
 
 namespace esphome::cover {
 
-const extern float COVER_OPEN;
-const extern float COVER_CLOSED;
+static constexpr float COVER_OPEN = 1.0f;
+static constexpr float COVER_CLOSED = 0.0f;
 
 #define LOG_COVER(prefix, type, obj) \
   if ((obj) != nullptr) { \
diff --git a/esphome/components/cse7761/cse7761.cpp b/esphome/components/cse7761/cse7761.cpp
index 482636dd81d..7c5ee833a44 100644
--- a/esphome/components/cse7761/cse7761.cpp
+++ b/esphome/components/cse7761/cse7761.cpp
@@ -62,8 +62,6 @@ void CSE7761Component::dump_config() {
   this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }
 
-float CSE7761Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void CSE7761Component::update() {
   if (this->data_.ready) {
     this->get_data_();
diff --git a/esphome/components/cse7761/cse7761.h b/esphome/components/cse7761/cse7761.h
index 71846cdcab3..289c5e7e197 100644
--- a/esphome/components/cse7761/cse7761.h
+++ b/esphome/components/cse7761/cse7761.h
@@ -28,7 +28,6 @@ class CSE7761Component : public PollingComponent, public uart::UARTDevice {
   void set_current_2_sensor(sensor::Sensor *current_sensor_2) { current_sensor_2_ = current_sensor_2; }
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/cse7766/cse7766.cpp b/esphome/components/cse7766/cse7766.cpp
index 4432195365d..df4872deacf 100644
--- a/esphome/components/cse7766/cse7766.cpp
+++ b/esphome/components/cse7766/cse7766.cpp
@@ -37,7 +37,6 @@ void CSE7766Component::loop() {
     this->raw_data_index_ = (this->raw_data_index_ + 1) % 24;
   }
 }
-float CSE7766Component::get_setup_priority() const { return setup_priority::DATA; }
 
 bool CSE7766Component::check_byte_() {
   uint8_t index = this->raw_data_index_;
@@ -152,6 +151,10 @@ void CSE7766Component::parse_data_() {
     if (this->power_sensor_ != nullptr) {
       this->power_sensor_->publish_state(power);
     }
+  } else if (this->power_sensor_ != nullptr) {
+    // No valid power measurement from chip - publish 0W to avoid stale readings
+    // This typically happens when current is below the measurable threshold (~50mA)
+    this->power_sensor_->publish_state(0.0f);
   }
 
   float current = 0.0f;
diff --git a/esphome/components/cse7766/cse7766.h b/esphome/components/cse7766/cse7766.h
index 8902eafe3cf..efddccd3c5d 100644
--- a/esphome/components/cse7766/cse7766.h
+++ b/esphome/components/cse7766/cse7766.h
@@ -23,7 +23,6 @@ class CSE7766Component : public Component, public uart::UARTDevice {
   void set_power_factor_sensor(sensor::Sensor *power_factor_sensor) { power_factor_sensor_ = power_factor_sensor; }
 
   void loop() override;
-  float get_setup_priority() const override;
   void dump_config() override;
 
  protected:
diff --git a/esphome/components/current_based/current_based_cover.cpp b/esphome/components/current_based/current_based_cover.cpp
index cb3f65c9cd5..5dfaeeff390 100644
--- a/esphome/components/current_based/current_based_cover.cpp
+++ b/esphome/components/current_based/current_based_cover.cpp
@@ -66,7 +66,7 @@ void CurrentBasedCover::loop() {
   if (this->current_operation == COVER_OPERATION_OPENING) {
     if (this->malfunction_detection_ && this->is_closing_()) {  // Malfunction
       this->direction_idle_();
-      this->malfunction_trigger_->trigger();
+      this->malfunction_trigger_.trigger();
       ESP_LOGI(TAG, "'%s' - Malfunction detected during opening. Current flow detected in close circuit",
                this->name_.c_str());
     } else if (this->is_opening_blocked_()) {  // Blocked
@@ -87,7 +87,7 @@ void CurrentBasedCover::loop() {
   } else if (this->current_operation == COVER_OPERATION_CLOSING) {
     if (this->malfunction_detection_ && this->is_opening_()) {  // Malfunction
       this->direction_idle_();
-      this->malfunction_trigger_->trigger();
+      this->malfunction_trigger_.trigger();
       ESP_LOGI(TAG, "'%s' - Malfunction detected during closing. Current flow detected in open circuit",
                this->name_.c_str());
     } else if (this->is_closing_blocked_()) {  // Blocked
@@ -159,7 +159,6 @@ void CurrentBasedCover::dump_config() {
                 this->start_sensing_delay_ / 1e3f, YESNO(this->malfunction_detection_));
 }
 
-float CurrentBasedCover::get_setup_priority() const { return setup_priority::DATA; }
 void CurrentBasedCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
@@ -221,15 +220,15 @@ void CurrentBasedCover::start_direction_(CoverOperation dir) {
   Trigger<> *trig;
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = this->stop_trigger_;
+      trig = &this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = this->open_trigger_;
+      trig = &this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = this->close_trigger_;
+      trig = &this->close_trigger_;
       break;
     default:
       return;
diff --git a/esphome/components/current_based/current_based_cover.h b/esphome/components/current_based/current_based_cover.h
index b172e762b06..76bd85cdf77 100644
--- a/esphome/components/current_based/current_based_cover.h
+++ b/esphome/components/current_based/current_based_cover.h
@@ -14,11 +14,10 @@ class CurrentBasedCover : public cover::Cover, public Component {
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
-  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
+  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
 
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
+  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
   void set_open_sensor(sensor::Sensor *open_sensor) { this->open_sensor_ = open_sensor; }
   void set_open_moving_current_threshold(float open_moving_current_threshold) {
     this->open_moving_current_threshold_ = open_moving_current_threshold;
@@ -28,7 +27,7 @@ class CurrentBasedCover : public cover::Cover, public Component {
   }
   void set_open_duration(uint32_t open_duration) { this->open_duration_ = open_duration; }
 
-  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
+  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
   void set_close_sensor(sensor::Sensor *close_sensor) { this->close_sensor_ = close_sensor; }
   void set_close_moving_current_threshold(float close_moving_current_threshold) {
     this->close_moving_current_threshold_ = close_moving_current_threshold;
@@ -44,7 +43,7 @@ class CurrentBasedCover : public cover::Cover, public Component {
   void set_malfunction_detection(bool malfunction_detection) { this->malfunction_detection_ = malfunction_detection; }
   void set_start_sensing_delay(uint32_t start_sensing_delay) { this->start_sensing_delay_ = start_sensing_delay; }
 
-  Trigger<> *get_malfunction_trigger() const { return this->malfunction_trigger_; }
+  Trigger<> *get_malfunction_trigger() { return &this->malfunction_trigger_; }
 
   cover::CoverTraits get_traits() override;
 
@@ -64,23 +63,23 @@ class CurrentBasedCover : public cover::Cover, public Component {
 
   void recompute_position_();
 
-  Trigger<> *stop_trigger_{new Trigger<>()};
+  Trigger<> stop_trigger_;
 
   sensor::Sensor *open_sensor_{nullptr};
-  Trigger<> *open_trigger_{new Trigger<>()};
+  Trigger<> open_trigger_;
   float open_moving_current_threshold_;
   float open_obstacle_current_threshold_{FLT_MAX};
   uint32_t open_duration_;
 
   sensor::Sensor *close_sensor_{nullptr};
-  Trigger<> *close_trigger_{new Trigger<>()};
+  Trigger<> close_trigger_;
   float close_moving_current_threshold_;
   float close_obstacle_current_threshold_{FLT_MAX};
   uint32_t close_duration_;
 
   uint32_t max_duration_{UINT32_MAX};
   bool malfunction_detection_{true};
-  Trigger<> *malfunction_trigger_{new Trigger<>()};
+  Trigger<> malfunction_trigger_;
   uint32_t start_sensing_delay_;
   float obstacle_rollback_;
 
diff --git a/esphome/components/daly_bms/daly_bms.cpp b/esphome/components/daly_bms/daly_bms.cpp
index 2d270cc56ea..90ccee78f8a 100644
--- a/esphome/components/daly_bms/daly_bms.cpp
+++ b/esphome/components/daly_bms/daly_bms.cpp
@@ -104,8 +104,6 @@ void DalyBmsComponent::loop() {
   }
 }
 
-float DalyBmsComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void DalyBmsComponent::request_data_(uint8_t data_id) {
   uint8_t request_message[DALY_FRAME_SIZE];
 
diff --git a/esphome/components/daly_bms/daly_bms.h b/esphome/components/daly_bms/daly_bms.h
index e6d476bcdd2..1983ba0ef19 100644
--- a/esphome/components/daly_bms/daly_bms.h
+++ b/esphome/components/daly_bms/daly_bms.h
@@ -72,7 +72,6 @@ class DalyBmsComponent : public PollingComponent, public uart::UARTDevice {
   void update() override;
   void loop() override;
 
-  float get_setup_priority() const override;
   void set_address(uint8_t address) { this->addr_ = address; }
 
  protected:
diff --git a/esphome/components/dht/dht.cpp b/esphome/components/dht/dht.cpp
index 276ea247171..fef247f1681 100644
--- a/esphome/components/dht/dht.cpp
+++ b/esphome/components/dht/dht.cpp
@@ -63,8 +63,6 @@ void DHT::update() {
   }
 }
 
-float DHT::get_setup_priority() const { return setup_priority::DATA; }
-
 void DHT::set_dht_model(DHTModel model) {
   this->model_ = model;
   this->is_auto_detect_ = model == DHT_MODEL_AUTO_DETECT;
diff --git a/esphome/components/dht/dht.h b/esphome/components/dht/dht.h
index 9047dd2c964..4671ee6f272 100644
--- a/esphome/components/dht/dht.h
+++ b/esphome/components/dht/dht.h
@@ -51,8 +51,6 @@ class DHT : public PollingComponent {
   void dump_config() override;
   /// Update sensor values and push them to the frontend.
   void update() override;
-  /// HARDWARE_LATE setup priority.
-  float get_setup_priority() const override;
 
  protected:
   bool read_sensor_(float *temperature, float *humidity, bool report_errors);
diff --git a/esphome/components/dht12/dht12.cpp b/esphome/components/dht12/dht12.cpp
index 445d150be0e..1d884daad68 100644
--- a/esphome/components/dht12/dht12.cpp
+++ b/esphome/components/dht12/dht12.cpp
@@ -49,7 +49,7 @@ void DHT12Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
-float DHT12Component::get_setup_priority() const { return setup_priority::DATA; }
+
 bool DHT12Component::read_data_(uint8_t *data) {
   if (!this->read_bytes(0, data, 5)) {
     ESP_LOGW(TAG, "Updating DHT12 failed!");
diff --git a/esphome/components/dht12/dht12.h b/esphome/components/dht12/dht12.h
index 2a706039ba4..ab19d7c7230 100644
--- a/esphome/components/dht12/dht12.h
+++ b/esphome/components/dht12/dht12.h
@@ -11,7 +11,6 @@ class DHT12Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
diff --git a/esphome/components/dlms_meter/__init__.py b/esphome/components/dlms_meter/__init__.py
new file mode 100644
index 00000000000..c22ab7b5521
--- /dev/null
+++ b/esphome/components/dlms_meter/__init__.py
@@ -0,0 +1,57 @@
+import esphome.codegen as cg
+from esphome.components import uart
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, PLATFORM_ESP32, PLATFORM_ESP8266
+
+CODEOWNERS = ["@SimonFischer04"]
+DEPENDENCIES = ["uart"]
+
+CONF_DLMS_METER_ID = "dlms_meter_id"
+CONF_DECRYPTION_KEY = "decryption_key"
+CONF_PROVIDER = "provider"
+
+PROVIDERS = {"generic": 0, "netznoe": 1}
+
+dlms_meter_component_ns = cg.esphome_ns.namespace("dlms_meter")
+DlmsMeterComponent = dlms_meter_component_ns.class_(
+    "DlmsMeterComponent", cg.Component, uart.UARTDevice
+)
+
+
+def validate_key(value):
+    value = cv.string_strict(value)
+    if len(value) != 32:
+        raise cv.Invalid("Decryption key must be 32 hex characters (16 bytes)")
+    try:
+        return [int(value[i : i + 2], 16) for i in range(0, 32, 2)]
+    except ValueError as exc:
+        raise cv.Invalid("Decryption key must be hex values from 00 to FF") from exc
+
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(DlmsMeterComponent),
+            cv.Required(CONF_DECRYPTION_KEY): validate_key,
+            cv.Optional(CONF_PROVIDER, default="generic"): cv.enum(
+                PROVIDERS, lower=True
+            ),
+        }
+    )
+    .extend(uart.UART_DEVICE_SCHEMA)
+    .extend(cv.COMPONENT_SCHEMA),
+    cv.only_on([PLATFORM_ESP8266, PLATFORM_ESP32]),
+)
+
+FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
+    "dlms_meter", baud_rate=2400, require_rx=True
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
+    key = ", ".join(str(b) for b in config[CONF_DECRYPTION_KEY])
+    cg.add(var.set_decryption_key(cg.RawExpression(f"{{{key}}}")))
+    cg.add(var.set_provider(PROVIDERS[config[CONF_PROVIDER]]))
diff --git a/esphome/components/dlms_meter/dlms.h b/esphome/components/dlms_meter/dlms.h
new file mode 100644
index 00000000000..a3d8f62ce63
--- /dev/null
+++ b/esphome/components/dlms_meter/dlms.h
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::dlms_meter {
+
+/*
++-------------------------------+
+|       Ciphering Service       |
++-------------------------------+
+|      System Title Length      |
++-------------------------------+
+|                               |
+|                               |
+|                               |
+|            System             |
+|            Title              |
+|                               |
+|                               |
+|                               |
++-------------------------------+
+|            Length             | (1 or 3 Bytes)
++-------------------------------+
+|     Security Control Byte     |
++-------------------------------+
+|                               |
+|             Frame             |
+|            Counter            |
+|                               |
++-------------------------------+
+|                               |
+~                               ~
+        Encrypted Payload
+~                               ~
+|                               |
++-------------------------------+
+
+Ciphering Service: 0xDB (General-Glo-Ciphering)
+System Title Length: 0x08
+System Title: Unique ID of meter
+Length: 1 Byte=Length <= 127, 3 Bytes=Length > 127 (0x82 & 2 Bytes length)
+Security Control Byte:
+- Bit 3…0: Security_Suite_Id
+- Bit 4: "A" subfield: indicates that authentication is applied
+- Bit 5: "E" subfield: indicates that encryption is applied
+- Bit 6: Key_Set subfield: 0 = Unicast, 1 = Broadcast
+- Bit 7: Indicates the use of compression.
+ */
+
+static constexpr uint8_t DLMS_HEADER_LENGTH = 16;
+static constexpr uint8_t DLMS_HEADER_EXT_OFFSET = 2;  // Extra offset for extended length header
+static constexpr uint8_t DLMS_CIPHER_OFFSET = 0;
+static constexpr uint8_t DLMS_SYST_OFFSET = 1;
+static constexpr uint8_t DLMS_LENGTH_OFFSET = 10;
+static constexpr uint8_t TWO_BYTE_LENGTH = 0x82;
+static constexpr uint8_t DLMS_LENGTH_CORRECTION = 5;  // Header bytes included in length field
+static constexpr uint8_t DLMS_SECBYTE_OFFSET = 11;
+static constexpr uint8_t DLMS_FRAMECOUNTER_OFFSET = 12;
+static constexpr uint8_t DLMS_FRAMECOUNTER_LENGTH = 4;
+static constexpr uint8_t DLMS_PAYLOAD_OFFSET = 16;
+static constexpr uint8_t GLO_CIPHERING = 0xDB;
+static constexpr uint8_t DATA_NOTIFICATION = 0x0F;
+static constexpr uint8_t TIMESTAMP_DATETIME = 0x0C;
+static constexpr uint16_t MAX_MESSAGE_LENGTH = 512;  // Maximum size of message (when having 2 bytes length in header).
+
+// Provider specific quirks
+static constexpr uint8_t NETZ_NOE_MAGIC_BYTE = 0x81;  // Magic length byte used by Netz NOE
+static constexpr uint8_t NETZ_NOE_EXPECTED_MESSAGE_LENGTH = 0xF8;
+static constexpr uint8_t NETZ_NOE_EXPECTED_SECURITY_CONTROL_BYTE = 0x20;
+
+}  // namespace esphome::dlms_meter
diff --git a/esphome/components/dlms_meter/dlms_meter.cpp b/esphome/components/dlms_meter/dlms_meter.cpp
new file mode 100644
index 00000000000..6aa465143e5
--- /dev/null
+++ b/esphome/components/dlms_meter/dlms_meter.cpp
@@ -0,0 +1,468 @@
+#include "dlms_meter.h"
+
+#include <cmath>
+
+#if defined(USE_ESP8266_FRAMEWORK_ARDUINO)
+#include <bearssl/bearssl.h>
+#elif defined(USE_ESP32)
+#include "mbedtls/esp_config.h"
+#include "mbedtls/gcm.h"
+#endif
+
+namespace esphome::dlms_meter {
+
+static constexpr const char *TAG = "dlms_meter";
+
+void DlmsMeterComponent::dump_config() {
+  const char *provider_name = this->provider_ == PROVIDER_NETZNOE ? "Netz NOE" : "Generic";
+  ESP_LOGCONFIG(TAG,
+                "DLMS Meter:\n"
+                "  Provider: %s\n"
+                "  Read Timeout: %u ms",
+                provider_name, this->read_timeout_);
+#define DLMS_METER_LOG_SENSOR(s) LOG_SENSOR("  ", #s, this->s##_sensor_);
+  DLMS_METER_SENSOR_LIST(DLMS_METER_LOG_SENSOR, )
+#define DLMS_METER_LOG_TEXT_SENSOR(s) LOG_TEXT_SENSOR("  ", #s, this->s##_text_sensor_);
+  DLMS_METER_TEXT_SENSOR_LIST(DLMS_METER_LOG_TEXT_SENSOR, )
+}
+
+void DlmsMeterComponent::loop() {
+  // Read while data is available, netznoe uses two frames so allow 2x max frame length
+  while (this->available()) {
+    if (this->receive_buffer_.size() >= MBUS_MAX_FRAME_LENGTH * 2) {
+      ESP_LOGW(TAG, "Receive buffer full, dropping remaining bytes");
+      break;
+    }
+    uint8_t c;
+    this->read_byte(&c);
+    this->receive_buffer_.push_back(c);
+    this->last_read_ = millis();
+  }
+
+  if (!this->receive_buffer_.empty() && millis() - this->last_read_ > this->read_timeout_) {
+    this->mbus_payload_.clear();
+    if (!this->parse_mbus_(this->mbus_payload_))
+      return;
+
+    uint16_t message_length;
+    uint8_t systitle_length;
+    uint16_t header_offset;
+    if (!this->parse_dlms_(this->mbus_payload_, message_length, systitle_length, header_offset))
+      return;
+
+    if (message_length < DECODER_START_OFFSET || message_length > MAX_MESSAGE_LENGTH) {
+      ESP_LOGE(TAG, "DLMS: Message length invalid: %u", message_length);
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    // Decrypt in place and then decode the OBIS codes
+    if (!this->decrypt_(this->mbus_payload_, message_length, systitle_length, header_offset))
+      return;
+    this->decode_obis_(&this->mbus_payload_[header_offset + DLMS_PAYLOAD_OFFSET], message_length);
+  }
+}
+
+bool DlmsMeterComponent::parse_mbus_(std::vector<uint8_t> &mbus_payload) {
+  ESP_LOGV(TAG, "Parsing M-Bus frames");
+  uint16_t frame_offset = 0;  // Offset is used if the M-Bus message is split into multiple frames
+
+  while (frame_offset < this->receive_buffer_.size()) {
+    // Ensure enough bytes remain for the minimal intro header before accessing indices
+    if (this->receive_buffer_.size() - frame_offset < MBUS_HEADER_INTRO_LENGTH) {
+      ESP_LOGE(TAG, "MBUS: Not enough data for frame header (need %d, have %d)", MBUS_HEADER_INTRO_LENGTH,
+               (this->receive_buffer_.size() - frame_offset));
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Check start bytes
+    if (this->receive_buffer_[frame_offset + MBUS_START1_OFFSET] != START_BYTE_LONG_FRAME ||
+        this->receive_buffer_[frame_offset + MBUS_START2_OFFSET] != START_BYTE_LONG_FRAME) {
+      ESP_LOGE(TAG, "MBUS: Start bytes do not match");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Both length bytes must be identical
+    if (this->receive_buffer_[frame_offset + MBUS_LENGTH1_OFFSET] !=
+        this->receive_buffer_[frame_offset + MBUS_LENGTH2_OFFSET]) {
+      ESP_LOGE(TAG, "MBUS: Length bytes do not match");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    uint8_t frame_length = this->receive_buffer_[frame_offset + MBUS_LENGTH1_OFFSET];  // Get length of this frame
+
+    // Check if received data is enough for the given frame length
+    if (this->receive_buffer_.size() - frame_offset <
+        frame_length + 3) {  // length field inside packet does not account for second start- + checksum- + stop- byte
+      ESP_LOGE(TAG, "MBUS: Frame too big for received data");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Ensure we have full frame (header + payload + checksum + stop byte) before accessing stop byte
+    size_t required_total =
+        frame_length + MBUS_HEADER_INTRO_LENGTH + MBUS_FOOTER_LENGTH;  // payload + header + 2 footer bytes
+    if (this->receive_buffer_.size() - frame_offset < required_total) {
+      ESP_LOGE(TAG, "MBUS: Incomplete frame (need %d, have %d)", (unsigned int) required_total,
+               this->receive_buffer_.size() - frame_offset);
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    if (this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH + MBUS_FOOTER_LENGTH - 1] !=
+        STOP_BYTE) {
+      ESP_LOGE(TAG, "MBUS: Invalid stop byte");
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    // Verify checksum: sum of all bytes starting at MBUS_HEADER_INTRO_LENGTH, take last byte
+    uint8_t checksum = 0;  // use uint8_t so only the 8 least significant bits are stored
+    for (uint16_t i = 0; i < frame_length; i++) {
+      checksum += this->receive_buffer_[frame_offset + MBUS_HEADER_INTRO_LENGTH + i];
+    }
+    if (checksum != this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH]) {
+      ESP_LOGE(TAG, "MBUS: Invalid checksum: %x != %x", checksum,
+               this->receive_buffer_[frame_offset + frame_length + MBUS_HEADER_INTRO_LENGTH]);
+      this->receive_buffer_.clear();
+      return false;
+    }
+
+    mbus_payload.insert(mbus_payload.end(), &this->receive_buffer_[frame_offset + MBUS_FULL_HEADER_LENGTH],
+                        &this->receive_buffer_[frame_offset + MBUS_HEADER_INTRO_LENGTH + frame_length]);
+
+    frame_offset += MBUS_HEADER_INTRO_LENGTH + frame_length + MBUS_FOOTER_LENGTH;
+  }
+  return true;
+}
+
+bool DlmsMeterComponent::parse_dlms_(const std::vector<uint8_t> &mbus_payload, uint16_t &message_length,
+                                     uint8_t &systitle_length, uint16_t &header_offset) {
+  ESP_LOGV(TAG, "Parsing DLMS header");
+  if (mbus_payload.size() < DLMS_HEADER_LENGTH + DLMS_HEADER_EXT_OFFSET) {
+    ESP_LOGE(TAG, "DLMS: Payload too short");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  if (mbus_payload[DLMS_CIPHER_OFFSET] != GLO_CIPHERING) {  // Only general-glo-ciphering is supported (0xDB)
+    ESP_LOGE(TAG, "DLMS: Unsupported cipher");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  systitle_length = mbus_payload[DLMS_SYST_OFFSET];
+
+  if (systitle_length != 0x08) {  // Only system titles with length of 8 are supported
+    ESP_LOGE(TAG, "DLMS: Unsupported system title length");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  message_length = mbus_payload[DLMS_LENGTH_OFFSET];
+  header_offset = 0;
+
+  if (this->provider_ == PROVIDER_NETZNOE) {
+    // for some reason EVN seems to set the standard "length" field to 0x81 and then the actual length is in the next
+    // byte. Check some bytes to see if received data still matches expectation
+    if (message_length == NETZ_NOE_MAGIC_BYTE &&
+        mbus_payload[DLMS_LENGTH_OFFSET + 1] == NETZ_NOE_EXPECTED_MESSAGE_LENGTH &&
+        mbus_payload[DLMS_LENGTH_OFFSET + 2] == NETZ_NOE_EXPECTED_SECURITY_CONTROL_BYTE) {
+      message_length = mbus_payload[DLMS_LENGTH_OFFSET + 1];
+      header_offset = 1;
+    } else {
+      ESP_LOGE(TAG, "Wrong Length - Security Control Byte sequence detected for provider EVN");
+    }
+  } else {
+    if (message_length == TWO_BYTE_LENGTH) {
+      message_length = encode_uint16(mbus_payload[DLMS_LENGTH_OFFSET + 1], mbus_payload[DLMS_LENGTH_OFFSET + 2]);
+      header_offset = DLMS_HEADER_EXT_OFFSET;
+    }
+  }
+  if (message_length < DLMS_LENGTH_CORRECTION) {
+    ESP_LOGE(TAG, "DLMS: Message length too short: %u", message_length);
+    this->receive_buffer_.clear();
+    return false;
+  }
+  message_length -= DLMS_LENGTH_CORRECTION;  // Correct message length due to part of header being included in length
+
+  if (mbus_payload.size() - DLMS_HEADER_LENGTH - header_offset != message_length) {
+    ESP_LOGV(TAG, "DLMS: Length mismatch - payload=%d, header=%d, offset=%d, message=%d", mbus_payload.size(),
+             DLMS_HEADER_LENGTH, header_offset, message_length);
+    ESP_LOGE(TAG, "DLMS: Message has invalid length");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  if (mbus_payload[header_offset + DLMS_SECBYTE_OFFSET] != 0x21 &&
+      mbus_payload[header_offset + DLMS_SECBYTE_OFFSET] !=
+          0x20) {  // Only certain security suite is supported (0x21 || 0x20)
+    ESP_LOGE(TAG, "DLMS: Unsupported security control byte");
+    this->receive_buffer_.clear();
+    return false;
+  }
+
+  return true;
+}
+
+bool DlmsMeterComponent::decrypt_(std::vector<uint8_t> &mbus_payload, uint16_t message_length, uint8_t systitle_length,
+                                  uint16_t header_offset) {
+  ESP_LOGV(TAG, "Decrypting payload");
+  uint8_t iv[12];  // Reserve space for the IV, always 12 bytes
+  // Copy system title to IV (System title is before length; no header offset needed!)
+  // Add 1 to the offset in order to skip the system title length byte
+  memcpy(&iv[0], &mbus_payload[DLMS_SYST_OFFSET + 1], systitle_length);
+  memcpy(&iv[8], &mbus_payload[header_offset + DLMS_FRAMECOUNTER_OFFSET],
+         DLMS_FRAMECOUNTER_LENGTH);  // Copy frame counter to IV
+
+  uint8_t *payload_ptr = &mbus_payload[header_offset + DLMS_PAYLOAD_OFFSET];
+
+#if defined(USE_ESP8266_FRAMEWORK_ARDUINO)
+  br_gcm_context gcm_ctx;
+  br_aes_ct_ctr_keys bc;
+  br_aes_ct_ctr_init(&bc, this->decryption_key_.data(), this->decryption_key_.size());
+  br_gcm_init(&gcm_ctx, &bc.vtable, br_ghash_ctmul32);
+  br_gcm_reset(&gcm_ctx, iv, sizeof(iv));
+  br_gcm_flip(&gcm_ctx);
+  br_gcm_run(&gcm_ctx, 0, payload_ptr, message_length);
+#elif defined(USE_ESP32)
+  size_t outlen = 0;
+  mbedtls_gcm_context gcm_ctx;
+  mbedtls_gcm_init(&gcm_ctx);
+  mbedtls_gcm_setkey(&gcm_ctx, MBEDTLS_CIPHER_ID_AES, this->decryption_key_.data(), this->decryption_key_.size() * 8);
+  mbedtls_gcm_starts(&gcm_ctx, MBEDTLS_GCM_DECRYPT, iv, sizeof(iv));
+  auto ret = mbedtls_gcm_update(&gcm_ctx, payload_ptr, message_length, payload_ptr, message_length, &outlen);
+  mbedtls_gcm_free(&gcm_ctx);
+  if (ret != 0) {
+    ESP_LOGE(TAG, "Decryption failed with error: %d", ret);
+    this->receive_buffer_.clear();
+    return false;
+  }
+#else
+#error "Invalid Platform"
+#endif
+
+  if (payload_ptr[0] != DATA_NOTIFICATION || payload_ptr[5] != TIMESTAMP_DATETIME) {
+    ESP_LOGE(TAG, "OBIS: Packet was decrypted but data is invalid");
+    this->receive_buffer_.clear();
+    return false;
+  }
+  ESP_LOGV(TAG, "Decrypted payload: %d bytes", message_length);
+  return true;
+}
+
+void DlmsMeterComponent::decode_obis_(uint8_t *plaintext, uint16_t message_length) {
+  ESP_LOGV(TAG, "Decoding payload");
+  MeterData data{};
+  uint16_t current_position = DECODER_START_OFFSET;
+  bool power_factor_found = false;
+
+  while (current_position + OBIS_CODE_OFFSET <= message_length) {
+    if (plaintext[current_position + OBIS_TYPE_OFFSET] != DataType::OCTET_STRING) {
+      ESP_LOGE(TAG, "OBIS: Unsupported OBIS header type: %x", plaintext[current_position + OBIS_TYPE_OFFSET]);
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    uint8_t obis_code_length = plaintext[current_position + OBIS_LENGTH_OFFSET];
+    if (obis_code_length != OBIS_CODE_LENGTH_STANDARD && obis_code_length != OBIS_CODE_LENGTH_EXTENDED) {
+      ESP_LOGE(TAG, "OBIS: Unsupported OBIS header length: %x", obis_code_length);
+      this->receive_buffer_.clear();
+      return;
+    }
+    if (current_position + OBIS_CODE_OFFSET + obis_code_length > message_length) {
+      ESP_LOGE(TAG, "OBIS: Buffer too short for OBIS code");
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    uint8_t *obis_code = &plaintext[current_position + OBIS_CODE_OFFSET];
+    uint8_t obis_medium = obis_code[OBIS_A];
+    uint16_t obis_cd = encode_uint16(obis_code[OBIS_C], obis_code[OBIS_D]);
+
+    bool timestamp_found = false;
+    bool meter_number_found = false;
+    if (this->provider_ == PROVIDER_NETZNOE) {
+      // Do not advance Position when reading the Timestamp at DECODER_START_OFFSET
+      if ((obis_code_length == OBIS_CODE_LENGTH_EXTENDED) && (current_position == DECODER_START_OFFSET)) {
+        timestamp_found = true;
+      } else if (power_factor_found) {
+        meter_number_found = true;
+        power_factor_found = false;
+      } else {
+        current_position += obis_code_length + OBIS_CODE_OFFSET;  // Advance past code and position
+      }
+    } else {
+      current_position += obis_code_length + OBIS_CODE_OFFSET;  // Advance past code, position and type
+    }
+    if (!timestamp_found && !meter_number_found && obis_medium != Medium::ELECTRICITY &&
+        obis_medium != Medium::ABSTRACT) {
+      ESP_LOGE(TAG, "OBIS: Unsupported OBIS medium: %x", obis_medium);
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    if (current_position >= message_length) {
+      ESP_LOGE(TAG, "OBIS: Buffer too short for data type");
+      this->receive_buffer_.clear();
+      return;
+    }
+
+    float value = 0.0f;
+    uint8_t value_size = 0;
+    uint8_t data_type = plaintext[current_position];
+    current_position++;
+
+    switch (data_type) {
+      case DataType::DOUBLE_LONG_UNSIGNED: {
+        value_size = 4;
+        if (current_position + value_size > message_length) {
+          ESP_LOGE(TAG, "OBIS: Buffer too short for DOUBLE_LONG_UNSIGNED");
+          this->receive_buffer_.clear();
+          return;
+        }
+        value = encode_uint32(plaintext[current_position + 0], plaintext[current_position + 1],
+                              plaintext[current_position + 2], plaintext[current_position + 3]);
+        current_position += value_size;
+        break;
+      }
+      case DataType::LONG_UNSIGNED: {
+        value_size = 2;
+        if (current_position + value_size > message_length) {
+          ESP_LOGE(TAG, "OBIS: Buffer too short for LONG_UNSIGNED");
+          this->receive_buffer_.clear();
+          return;
+        }
+        value = encode_uint16(plaintext[current_position + 0], plaintext[current_position + 1]);
+        current_position += value_size;
+        break;
+      }
+      case DataType::OCTET_STRING: {
+        uint8_t data_length = plaintext[current_position];
+        current_position++;  // Advance past string length
+        if (current_position + data_length > message_length) {
+          ESP_LOGE(TAG, "OBIS: Buffer too short for OCTET_STRING");
+          this->receive_buffer_.clear();
+          return;
+        }
+        // Handle timestamp (normal OBIS code or NETZNOE special case)
+        if (obis_cd == OBIS_TIMESTAMP || timestamp_found) {
+          if (data_length < 8) {
+            ESP_LOGE(TAG, "OBIS: Timestamp data too short: %u", data_length);
+            this->receive_buffer_.clear();
+            return;
+          }
+          uint16_t year = encode_uint16(plaintext[current_position + 0], plaintext[current_position + 1]);
+          uint8_t month = plaintext[current_position + 2];
+          uint8_t day = plaintext[current_position + 3];
+          uint8_t hour = plaintext[current_position + 5];
+          uint8_t minute = plaintext[current_position + 6];
+          uint8_t second = plaintext[current_position + 7];
+          if (year > 9999 || month > 12 || day > 31 || hour > 23 || minute > 59 || second > 59) {
+            ESP_LOGE(TAG, "Invalid timestamp values: %04u-%02u-%02uT%02u:%02u:%02uZ", year, month, day, hour, minute,
+                     second);
+            this->receive_buffer_.clear();
+            return;
+          }
+          snprintf(data.timestamp, sizeof(data.timestamp), "%04u-%02u-%02uT%02u:%02u:%02uZ", year, month, day, hour,
+                   minute, second);
+        } else if (meter_number_found) {
+          snprintf(data.meternumber, sizeof(data.meternumber), "%.*s", data_length, &plaintext[current_position]);
+        }
+        current_position += data_length;
+        break;
+      }
+      default:
+        ESP_LOGE(TAG, "OBIS: Unsupported OBIS data type: %x", data_type);
+        this->receive_buffer_.clear();
+        return;
+    }
+
+    // Skip break after data
+    if (this->provider_ == PROVIDER_NETZNOE) {
+      // Don't skip the break on the first timestamp, as there's none
+      if (!timestamp_found) {
+        current_position += 2;
+      }
+    } else {
+      current_position += 2;
+    }
+
+    // Check for additional data (scaler-unit structure)
+    if (current_position < message_length && plaintext[current_position] == DataType::INTEGER) {
+      // Apply scaler: real_value = raw_value × 10^scaler
+      if (current_position + 1 < message_length) {
+        int8_t scaler = static_cast<int8_t>(plaintext[current_position + 1]);
+        if (scaler != 0) {
+          value *= powf(10.0f, scaler);
+        }
+      }
+
+      // on EVN Meters there is no additional break
+      if (this->provider_ == PROVIDER_NETZNOE) {
+        current_position += 4;
+      } else {
+        current_position += 6;
+      }
+    }
+
+    // Handle numeric values (LONG_UNSIGNED and DOUBLE_LONG_UNSIGNED)
+    if (value_size > 0) {
+      switch (obis_cd) {
+        case OBIS_VOLTAGE_L1:
+          data.voltage_l1 = value;
+          break;
+        case OBIS_VOLTAGE_L2:
+          data.voltage_l2 = value;
+          break;
+        case OBIS_VOLTAGE_L3:
+          data.voltage_l3 = value;
+          break;
+        case OBIS_CURRENT_L1:
+          data.current_l1 = value;
+          break;
+        case OBIS_CURRENT_L2:
+          data.current_l2 = value;
+          break;
+        case OBIS_CURRENT_L3:
+          data.current_l3 = value;
+          break;
+        case OBIS_ACTIVE_POWER_PLUS:
+          data.active_power_plus = value;
+          break;
+        case OBIS_ACTIVE_POWER_MINUS:
+          data.active_power_minus = value;
+          break;
+        case OBIS_ACTIVE_ENERGY_PLUS:
+          data.active_energy_plus = value;
+          break;
+        case OBIS_ACTIVE_ENERGY_MINUS:
+          data.active_energy_minus = value;
+          break;
+        case OBIS_REACTIVE_ENERGY_PLUS:
+          data.reactive_energy_plus = value;
+          break;
+        case OBIS_REACTIVE_ENERGY_MINUS:
+          data.reactive_energy_minus = value;
+          break;
+        case OBIS_POWER_FACTOR:
+          data.power_factor = value;
+          power_factor_found = true;
+          break;
+        default:
+          ESP_LOGW(TAG, "Unsupported OBIS code 0x%04X", obis_cd);
+      }
+    }
+  }
+
+  this->receive_buffer_.clear();
+
+  ESP_LOGI(TAG, "Received valid data");
+  this->publish_sensors(data);
+  this->status_clear_warning();
+}
+
+}  // namespace esphome::dlms_meter
diff --git a/esphome/components/dlms_meter/dlms_meter.h b/esphome/components/dlms_meter/dlms_meter.h
new file mode 100644
index 00000000000..c50e6f6b4da
--- /dev/null
+++ b/esphome/components/dlms_meter/dlms_meter.h
@@ -0,0 +1,96 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/log.h"
+#ifdef USE_SENSOR
+#include "esphome/components/sensor/sensor.h"
+#endif
+#ifdef USE_TEXT_SENSOR
+#include "esphome/components/text_sensor/text_sensor.h"
+#endif
+#include "esphome/components/uart/uart.h"
+
+#include "mbus.h"
+#include "dlms.h"
+#include "obis.h"
+
+#include <array>
+#include <vector>
+
+namespace esphome::dlms_meter {
+
+#ifndef DLMS_METER_SENSOR_LIST
+#define DLMS_METER_SENSOR_LIST(F, SEP)
+#endif
+
+#ifndef DLMS_METER_TEXT_SENSOR_LIST
+#define DLMS_METER_TEXT_SENSOR_LIST(F, SEP)
+#endif
+
+struct MeterData {
+  float voltage_l1 = 0.0f;             // Voltage L1
+  float voltage_l2 = 0.0f;             // Voltage L2
+  float voltage_l3 = 0.0f;             // Voltage L3
+  float current_l1 = 0.0f;             // Current L1
+  float current_l2 = 0.0f;             // Current L2
+  float current_l3 = 0.0f;             // Current L3
+  float active_power_plus = 0.0f;      // Active power taken from grid
+  float active_power_minus = 0.0f;     // Active power put into grid
+  float active_energy_plus = 0.0f;     // Active energy taken from grid
+  float active_energy_minus = 0.0f;    // Active energy put into grid
+  float reactive_energy_plus = 0.0f;   // Reactive energy taken from grid
+  float reactive_energy_minus = 0.0f;  // Reactive energy put into grid
+  char timestamp[27]{};                // Text sensor for the timestamp value
+
+  // Netz NOE
+  float power_factor = 0.0f;  // Power Factor
+  char meternumber[13]{};     // Text sensor for the meterNumber value
+};
+
+// Provider constants
+enum Providers : uint32_t { PROVIDER_GENERIC = 0x00, PROVIDER_NETZNOE = 0x01 };
+
+class DlmsMeterComponent : public Component, public uart::UARTDevice {
+ public:
+  DlmsMeterComponent() = default;
+
+  void dump_config() override;
+  void loop() override;
+
+  void set_decryption_key(const std::array<uint8_t, 16> &key) { this->decryption_key_ = key; }
+  void set_provider(uint32_t provider) { this->provider_ = provider; }
+
+  void publish_sensors(MeterData &data) {
+#define DLMS_METER_PUBLISH_SENSOR(s) \
+  if (this->s##_sensor_ != nullptr) \
+    s##_sensor_->publish_state(data.s);
+    DLMS_METER_SENSOR_LIST(DLMS_METER_PUBLISH_SENSOR, )
+
+#define DLMS_METER_PUBLISH_TEXT_SENSOR(s) \
+  if (this->s##_text_sensor_ != nullptr) \
+    s##_text_sensor_->publish_state(data.s);
+    DLMS_METER_TEXT_SENSOR_LIST(DLMS_METER_PUBLISH_TEXT_SENSOR, )
+  }
+
+  DLMS_METER_SENSOR_LIST(SUB_SENSOR, )
+  DLMS_METER_TEXT_SENSOR_LIST(SUB_TEXT_SENSOR, )
+
+ protected:
+  bool parse_mbus_(std::vector<uint8_t> &mbus_payload);
+  bool parse_dlms_(const std::vector<uint8_t> &mbus_payload, uint16_t &message_length, uint8_t &systitle_length,
+                   uint16_t &header_offset);
+  bool decrypt_(std::vector<uint8_t> &mbus_payload, uint16_t message_length, uint8_t systitle_length,
+                uint16_t header_offset);
+  void decode_obis_(uint8_t *plaintext, uint16_t message_length);
+
+  std::vector<uint8_t> receive_buffer_;  // Stores the packet currently being received
+  std::vector<uint8_t> mbus_payload_;    // Parsed M-Bus payload, reused to avoid heap churn
+  uint32_t last_read_ = 0;               // Timestamp when data was last read
+  uint32_t read_timeout_ = 1000;         // Time to wait after last byte before considering data complete
+
+  uint32_t provider_ = PROVIDER_GENERIC;  // Provider of the meter / your grid operator
+  std::array<uint8_t, 16> decryption_key_;
+};
+
+}  // namespace esphome::dlms_meter
diff --git a/esphome/components/dlms_meter/mbus.h b/esphome/components/dlms_meter/mbus.h
new file mode 100644
index 00000000000..293d43a55b6
--- /dev/null
+++ b/esphome/components/dlms_meter/mbus.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::dlms_meter {
+
+/*
++----------------------------------------------------+ -
+|               Start Character [0x68]               |  \
++----------------------------------------------------+   |
+|                   Data Length (L)                  |   |
++----------------------------------------------------+   |
+|               Data Length Repeat (L)               |   |
++----------------------------------------------------+    > M-Bus Data link layer
+|            Start Character Repeat [0x68]           |   |
++----------------------------------------------------+   |
+|             Control/Function Field (C)             |   |
++----------------------------------------------------+   |
+|                  Address Field (A)                 |  /
++----------------------------------------------------+ -
+|           Control Information Field (CI)           |  \
++----------------------------------------------------+   |
+|    Source Transport Service Access Point (STSAP)   |    > DLMS/COSEM M-Bus transport layer
++----------------------------------------------------+   |
+| Destination Transport Service Access Point (DTSAP) |  /
++----------------------------------------------------+ -
+|                                                    |  \
+~                                                    ~   |
+                         Data                             > DLMS/COSEM Application Layer
+~                                                    ~   |
+|                                                    |  /
++----------------------------------------------------+ -
+|                      Checksum                      |  \
++----------------------------------------------------+    > M-Bus Data link layer
+|                Stop Character [0x16]               |  /
++----------------------------------------------------+ -
+
+Data_Length = L - C - A - CI
+Each line (except Data) is one Byte
+
+Possible Values found in publicly available docs:
+- C: 0x53/0x73 (SND_UD)
+- A: FF (Broadcast)
+- CI: 0x00-0x1F/0x60/0x61/0x7C/0x7D
+- STSAP: 0x01 (Management Logical Device ID 1 of the meter)
+- DTSAP: 0x67 (Consumer Information Push Client ID 103)
+ */
+
+// MBUS start bytes for different telegram formats:
+// - Single Character: 0xE5 (length=1)
+// - Short Frame: 0x10 (length=5)
+// - Control Frame: 0x68 (length=9)
+// - Long Frame: 0x68 (length=9+data_length)
+// This component currently only uses Long Frame.
+static constexpr uint8_t START_BYTE_SINGLE_CHARACTER = 0xE5;
+static constexpr uint8_t START_BYTE_SHORT_FRAME = 0x10;
+static constexpr uint8_t START_BYTE_CONTROL_FRAME = 0x68;
+static constexpr uint8_t START_BYTE_LONG_FRAME = 0x68;
+static constexpr uint8_t MBUS_HEADER_INTRO_LENGTH = 4;  // Header length for the intro (0x68, length, length, 0x68)
+static constexpr uint8_t MBUS_FULL_HEADER_LENGTH = 9;   // Total header length
+static constexpr uint8_t MBUS_FOOTER_LENGTH = 2;        // Footer after frame
+static constexpr uint8_t MBUS_MAX_FRAME_LENGTH = 250;   // Maximum size of frame
+static constexpr uint8_t MBUS_START1_OFFSET = 0;        // Offset of first start byte
+static constexpr uint8_t MBUS_LENGTH1_OFFSET = 1;       // Offset of first length byte
+static constexpr uint8_t MBUS_LENGTH2_OFFSET = 2;       // Offset of (duplicated) second length byte
+static constexpr uint8_t MBUS_START2_OFFSET = 3;        // Offset of (duplicated) second start byte
+static constexpr uint8_t STOP_BYTE = 0x16;
+
+}  // namespace esphome::dlms_meter
diff --git a/esphome/components/dlms_meter/obis.h b/esphome/components/dlms_meter/obis.h
new file mode 100644
index 00000000000..1bb960e61e9
--- /dev/null
+++ b/esphome/components/dlms_meter/obis.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <cstdint>
+
+namespace esphome::dlms_meter {
+
+// Data types as per specification
+enum DataType {
+  NULL_DATA = 0x00,
+  BOOLEAN = 0x03,
+  BIT_STRING = 0x04,
+  DOUBLE_LONG = 0x05,
+  DOUBLE_LONG_UNSIGNED = 0x06,
+  OCTET_STRING = 0x09,
+  VISIBLE_STRING = 0x0A,
+  UTF8_STRING = 0x0C,
+  BINARY_CODED_DECIMAL = 0x0D,
+  INTEGER = 0x0F,
+  LONG = 0x10,
+  UNSIGNED = 0x11,
+  LONG_UNSIGNED = 0x12,
+  LONG64 = 0x14,
+  LONG64_UNSIGNED = 0x15,
+  ENUM = 0x16,
+  FLOAT32 = 0x17,
+  FLOAT64 = 0x18,
+  DATE_TIME = 0x19,
+  DATE = 0x1A,
+  TIME = 0x1B,
+
+  ARRAY = 0x01,
+  STRUCTURE = 0x02,
+  COMPACT_ARRAY = 0x13
+};
+
+enum Medium {
+  ABSTRACT = 0x00,
+  ELECTRICITY = 0x01,
+  HEAT_COST_ALLOCATOR = 0x04,
+  COOLING = 0x05,
+  HEAT = 0x06,
+  GAS = 0x07,
+  COLD_WATER = 0x08,
+  HOT_WATER = 0x09,
+  OIL = 0x10,
+  COMPRESSED_AIR = 0x11,
+  NITROGEN = 0x12
+};
+
+// Data structure
+static constexpr uint8_t DECODER_START_OFFSET = 20;  // Skip header, timestamp and break block
+static constexpr uint8_t OBIS_TYPE_OFFSET = 0;
+static constexpr uint8_t OBIS_LENGTH_OFFSET = 1;
+static constexpr uint8_t OBIS_CODE_OFFSET = 2;
+static constexpr uint8_t OBIS_CODE_LENGTH_STANDARD = 0x06;  // 6-byte OBIS code (A.B.C.D.E.F)
+static constexpr uint8_t OBIS_CODE_LENGTH_EXTENDED = 0x0C;  // 12-byte extended OBIS code
+static constexpr uint8_t OBIS_A = 0;
+static constexpr uint8_t OBIS_B = 1;
+static constexpr uint8_t OBIS_C = 2;
+static constexpr uint8_t OBIS_D = 3;
+static constexpr uint8_t OBIS_E = 4;
+static constexpr uint8_t OBIS_F = 5;
+
+// Metadata
+static constexpr uint16_t OBIS_TIMESTAMP = 0x0100;
+static constexpr uint16_t OBIS_SERIAL_NUMBER = 0x6001;
+static constexpr uint16_t OBIS_DEVICE_NAME = 0x2A00;
+
+// Voltage
+static constexpr uint16_t OBIS_VOLTAGE_L1 = 0x2007;
+static constexpr uint16_t OBIS_VOLTAGE_L2 = 0x3407;
+static constexpr uint16_t OBIS_VOLTAGE_L3 = 0x4807;
+
+// Current
+static constexpr uint16_t OBIS_CURRENT_L1 = 0x1F07;
+static constexpr uint16_t OBIS_CURRENT_L2 = 0x3307;
+static constexpr uint16_t OBIS_CURRENT_L3 = 0x4707;
+
+// Power
+static constexpr uint16_t OBIS_ACTIVE_POWER_PLUS = 0x0107;
+static constexpr uint16_t OBIS_ACTIVE_POWER_MINUS = 0x0207;
+
+// Active energy
+static constexpr uint16_t OBIS_ACTIVE_ENERGY_PLUS = 0x0108;
+static constexpr uint16_t OBIS_ACTIVE_ENERGY_MINUS = 0x0208;
+
+// Reactive energy
+static constexpr uint16_t OBIS_REACTIVE_ENERGY_PLUS = 0x0308;
+static constexpr uint16_t OBIS_REACTIVE_ENERGY_MINUS = 0x0408;
+
+// Netz NOE specific
+static constexpr uint16_t OBIS_POWER_FACTOR = 0x0D07;
+
+}  // namespace esphome::dlms_meter
diff --git a/esphome/components/dlms_meter/sensor/__init__.py b/esphome/components/dlms_meter/sensor/__init__.py
new file mode 100644
index 00000000000..27fd44f0086
--- /dev/null
+++ b/esphome/components/dlms_meter/sensor/__init__.py
@@ -0,0 +1,124 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    DEVICE_CLASS_CURRENT,
+    DEVICE_CLASS_ENERGY,
+    DEVICE_CLASS_POWER,
+    DEVICE_CLASS_POWER_FACTOR,
+    DEVICE_CLASS_VOLTAGE,
+    STATE_CLASS_MEASUREMENT,
+    STATE_CLASS_TOTAL_INCREASING,
+    UNIT_AMPERE,
+    UNIT_VOLT,
+    UNIT_WATT,
+    UNIT_WATT_HOURS,
+)
+
+from .. import CONF_DLMS_METER_ID, DlmsMeterComponent
+
+AUTO_LOAD = ["dlms_meter"]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_DLMS_METER_ID): cv.use_id(DlmsMeterComponent),
+        cv.Optional("voltage_l1"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("voltage_l2"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("voltage_l3"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=1,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("current_l1"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("current_l2"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("current_l3"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("active_power_plus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_POWER,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("active_power_minus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_POWER,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional("active_energy_plus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        cv.Optional("active_energy_minus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        cv.Optional("reactive_energy_plus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        cv.Optional("reactive_energy_minus"): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT_HOURS,
+            accuracy_decimals=0,
+            device_class=DEVICE_CLASS_ENERGY,
+            state_class=STATE_CLASS_TOTAL_INCREASING,
+        ),
+        # Netz NOE
+        cv.Optional("power_factor"): sensor.sensor_schema(
+            accuracy_decimals=3,
+            device_class=DEVICE_CLASS_POWER_FACTOR,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_DLMS_METER_ID])
+
+    sensors = []
+    for key, conf in config.items():
+        if not isinstance(conf, dict):
+            continue
+        id = conf[CONF_ID]
+        if id and id.type == sensor.Sensor:
+            sens = await sensor.new_sensor(conf)
+            cg.add(getattr(hub, f"set_{key}_sensor")(sens))
+            sensors.append(f"F({key})")
+
+    if sensors:
+        cg.add_define(
+            "DLMS_METER_SENSOR_LIST(F, sep)", cg.RawExpression(" sep ".join(sensors))
+        )
diff --git a/esphome/components/dlms_meter/text_sensor/__init__.py b/esphome/components/dlms_meter/text_sensor/__init__.py
new file mode 100644
index 00000000000..4d2373f4f94
--- /dev/null
+++ b/esphome/components/dlms_meter/text_sensor/__init__.py
@@ -0,0 +1,37 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+from .. import CONF_DLMS_METER_ID, DlmsMeterComponent
+
+AUTO_LOAD = ["dlms_meter"]
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_DLMS_METER_ID): cv.use_id(DlmsMeterComponent),
+        cv.Optional("timestamp"): text_sensor.text_sensor_schema(),
+        # Netz NOE
+        cv.Optional("meternumber"): text_sensor.text_sensor_schema(),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+async def to_code(config):
+    hub = await cg.get_variable(config[CONF_DLMS_METER_ID])
+
+    text_sensors = []
+    for key, conf in config.items():
+        if not isinstance(conf, dict):
+            continue
+        id = conf[CONF_ID]
+        if id and id.type == text_sensor.TextSensor:
+            sens = await text_sensor.new_text_sensor(conf)
+            cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))
+            text_sensors.append(f"F({key})")
+
+    if text_sensors:
+        cg.add_define(
+            "DLMS_METER_TEXT_SENSOR_LIST(F, sep)",
+            cg.RawExpression(" sep ".join(text_sensors)),
+        )
diff --git a/esphome/components/dps310/dps310.cpp b/esphome/components/dps310/dps310.cpp
index 6b6f9622fae..aa0a77cdd86 100644
--- a/esphome/components/dps310/dps310.cpp
+++ b/esphome/components/dps310/dps310.cpp
@@ -98,8 +98,6 @@ void DPS310Component::dump_config() {
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
 }
 
-float DPS310Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void DPS310Component::update() {
   if (!this->update_in_progress_) {
     this->update_in_progress_ = true;
diff --git a/esphome/components/dps310/dps310.h b/esphome/components/dps310/dps310.h
index 50e7d93c8ac..dce220d44b5 100644
--- a/esphome/components/dps310/dps310.h
+++ b/esphome/components/dps310/dps310.h
@@ -40,7 +40,6 @@ class DPS310Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
diff --git a/esphome/components/ds1307/ds1307.cpp b/esphome/components/ds1307/ds1307.cpp
index adbd7b5487a..5c0e98290b7 100644
--- a/esphome/components/ds1307/ds1307.cpp
+++ b/esphome/components/ds1307/ds1307.cpp
@@ -26,8 +26,6 @@ void DS1307Component::dump_config() {
   RealTimeClock::dump_config();
 }
 
-float DS1307Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void DS1307Component::read_time() {
   if (!this->read_rtc_()) {
     return;
diff --git a/esphome/components/ds1307/ds1307.h b/esphome/components/ds1307/ds1307.h
index f7f06253b79..1712056006d 100644
--- a/esphome/components/ds1307/ds1307.h
+++ b/esphome/components/ds1307/ds1307.h
@@ -12,7 +12,6 @@ class DS1307Component : public time::RealTimeClock, public i2c::I2CDevice {
   void setup() override;
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void read_time();
   void write_time();
 
diff --git a/esphome/components/duty_cycle/duty_cycle_sensor.cpp b/esphome/components/duty_cycle/duty_cycle_sensor.cpp
index 40a728d0259..f801769d272 100644
--- a/esphome/components/duty_cycle/duty_cycle_sensor.cpp
+++ b/esphome/components/duty_cycle/duty_cycle_sensor.cpp
@@ -43,8 +43,6 @@ void DutyCycleSensor::update() {
   this->last_update_ = now;
 }
 
-float DutyCycleSensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void IRAM_ATTR DutyCycleSensorStore::gpio_intr(DutyCycleSensorStore *arg) {
   const bool new_level = arg->pin.digital_read();
   if (new_level == arg->last_level)
diff --git a/esphome/components/duty_cycle/duty_cycle_sensor.h b/esphome/components/duty_cycle/duty_cycle_sensor.h
index ffb1802e14b..ffb8e3b6221 100644
--- a/esphome/components/duty_cycle/duty_cycle_sensor.h
+++ b/esphome/components/duty_cycle/duty_cycle_sensor.h
@@ -22,7 +22,6 @@ class DutyCycleSensor : public sensor::Sensor, public PollingComponent {
   void set_pin(InternalGPIOPin *pin) { pin_ = pin; }
 
   void setup() override;
-  float get_setup_priority() const override;
   void dump_config() override;
   void update() override;
 
diff --git a/esphome/components/ee895/ee895.cpp b/esphome/components/ee895/ee895.cpp
index 602e31db145..22f28be9bc3 100644
--- a/esphome/components/ee895/ee895.cpp
+++ b/esphome/components/ee895/ee895.cpp
@@ -55,8 +55,6 @@ void EE895Component::dump_config() {
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
 }
 
-float EE895Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void EE895Component::update() {
   write_command_(TEMPERATURE_ADDRESS, 2);
   this->set_timeout(50, [this]() {
diff --git a/esphome/components/ee895/ee895.h b/esphome/components/ee895/ee895.h
index 83bd7c6e82d..259b7c524b5 100644
--- a/esphome/components/ee895/ee895.h
+++ b/esphome/components/ee895/ee895.h
@@ -14,7 +14,6 @@ class EE895Component : public PollingComponent, public i2c::I2CDevice {
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_pressure_sensor(sensor::Sensor *pressure_sensor) { pressure_sensor_ = pressure_sensor; }
 
-  float get_setup_priority() const override;
   void setup() override;
   void dump_config() override;
   void update() override;
diff --git a/esphome/components/emc2101/sensor/emc2101_sensor.cpp b/esphome/components/emc2101/sensor/emc2101_sensor.cpp
index 2a199f48e97..3014c7da07c 100644
--- a/esphome/components/emc2101/sensor/emc2101_sensor.cpp
+++ b/esphome/components/emc2101/sensor/emc2101_sensor.cpp
@@ -7,8 +7,6 @@ namespace emc2101 {
 
 static const char *const TAG = "EMC2101.sensor";
 
-float EMC2101Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void EMC2101Sensor::dump_config() {
   ESP_LOGCONFIG(TAG, "Emc2101 sensor:");
   LOG_SENSOR("  ", "Internal temperature", this->internal_temperature_sensor_);
diff --git a/esphome/components/emc2101/sensor/emc2101_sensor.h b/esphome/components/emc2101/sensor/emc2101_sensor.h
index 3e8dcebc8ee..3e033f58a73 100644
--- a/esphome/components/emc2101/sensor/emc2101_sensor.h
+++ b/esphome/components/emc2101/sensor/emc2101_sensor.h
@@ -15,8 +15,6 @@ class EMC2101Sensor : public PollingComponent {
   void dump_config() override;
   /** Used by ESPHome framework. */
   void update() override;
-  /** Used by ESPHome framework. */
-  float get_setup_priority() const override;
 
   /** Used by ESPHome framework. */
   void set_internal_temperature_sensor(sensor::Sensor *sensor) { this->internal_temperature_sensor_ = sensor; }
diff --git a/esphome/components/endstop/endstop_cover.cpp b/esphome/components/endstop/endstop_cover.cpp
index 2c281ea2e61..ea8a5ec1869 100644
--- a/esphome/components/endstop/endstop_cover.cpp
+++ b/esphome/components/endstop/endstop_cover.cpp
@@ -111,7 +111,7 @@ void EndstopCover::dump_config() {
   LOG_BINARY_SENSOR("  ", "Open Endstop", this->open_endstop_);
   LOG_BINARY_SENSOR("  ", "Close Endstop", this->close_endstop_);
 }
-float EndstopCover::get_setup_priority() const { return setup_priority::DATA; }
+
 void EndstopCover::stop_prev_trigger_() {
   if (this->prev_command_trigger_ != nullptr) {
     this->prev_command_trigger_->stop_action();
@@ -141,15 +141,15 @@ void EndstopCover::start_direction_(CoverOperation dir) {
   Trigger<> *trig;
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = this->stop_trigger_;
+      trig = &this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = this->open_trigger_;
+      trig = &this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = this->close_trigger_;
+      trig = &this->close_trigger_;
       break;
     default:
       return;
diff --git a/esphome/components/endstop/endstop_cover.h b/esphome/components/endstop/endstop_cover.h
index 6ae15de8c14..32ede123356 100644
--- a/esphome/components/endstop/endstop_cover.h
+++ b/esphome/components/endstop/endstop_cover.h
@@ -13,11 +13,10 @@ class EndstopCover : public cover::Cover, public Component {
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
-  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
-  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
+  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
+  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
+  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
   void set_open_endstop(binary_sensor::BinarySensor *open_endstop) { this->open_endstop_ = open_endstop; }
   void set_close_endstop(binary_sensor::BinarySensor *close_endstop) { this->close_endstop_ = close_endstop; }
   void set_open_duration(uint32_t open_duration) { this->open_duration_ = open_duration; }
@@ -39,11 +38,11 @@ class EndstopCover : public cover::Cover, public Component {
 
   binary_sensor::BinarySensor *open_endstop_;
   binary_sensor::BinarySensor *close_endstop_;
-  Trigger<> *open_trigger_{new Trigger<>()};
+  Trigger<> open_trigger_;
   uint32_t open_duration_;
-  Trigger<> *close_trigger_{new Trigger<>()};
+  Trigger<> close_trigger_;
   uint32_t close_duration_;
-  Trigger<> *stop_trigger_{new Trigger<>()};
+  Trigger<> stop_trigger_;
   uint32_t max_duration_{UINT32_MAX};
 
   Trigger<> *prev_command_trigger_{nullptr};
diff --git a/esphome/components/ens210/ens210.cpp b/esphome/components/ens210/ens210.cpp
index 98a300f5d79..8bee9bfb18c 100644
--- a/esphome/components/ens210/ens210.cpp
+++ b/esphome/components/ens210/ens210.cpp
@@ -136,8 +136,6 @@ void ENS210Component::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
-float ENS210Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void ENS210Component::update() {
   // Execute a single measurement
   if (!this->write_byte(ENS210_REGISTER_SENS_RUN, 0x00)) {
diff --git a/esphome/components/ens210/ens210.h b/esphome/components/ens210/ens210.h
index 0fb6ff634d3..ae2bf81b5fb 100644
--- a/esphome/components/ens210/ens210.h
+++ b/esphome/components/ens210/ens210.h
@@ -10,7 +10,6 @@ namespace ens210 {
 /// This class implements support for the ENS210 relative humidity and temperature i2c sensor.
 class ENS210Component : public PollingComponent, public i2c::I2CDevice {
  public:
-  float get_setup_priority() const override;
   void dump_config() override;
   void setup() override;
   void update() override;
diff --git a/esphome/components/epaper_spi/display.py b/esphome/components/epaper_spi/display.py
index 8cc7b2663c6..13f66691b22 100644
--- a/esphome/components/epaper_spi/display.py
+++ b/esphome/components/epaper_spi/display.py
@@ -76,50 +76,42 @@ def model_schema(config):
         model.get_default(CONF_MINIMUM_UPDATE_INTERVAL, "1s")
     )
     cv_dimensions = cv.Optional if model.get_default(CONF_WIDTH) else cv.Required
-    return (
-        display.FULL_DISPLAY_SCHEMA.extend(
-            spi.spi_device_schema(
-                cs_pin_required=False,
-                default_mode="MODE0",
-                default_data_rate=model.get_default(CONF_DATA_RATE, 10_000_000),
-            )
-        )
-        .extend(
-            {
-                model.option(pin): pins.gpio_output_pin_schema
-                for pin in (CONF_RESET_PIN, CONF_CS_PIN, CONF_BUSY_PIN)
-            }
-        )
-        .extend(
-            {
-                cv.Optional(CONF_ROTATION, default=0): validate_rotation,
-                cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
-                cv.Optional(CONF_UPDATE_INTERVAL, default=cv.UNDEFINED): cv.All(
-                    update_interval, cv.Range(min=minimum_update_interval)
-                ),
-                cv.Optional(CONF_TRANSFORM): cv.Schema(
-                    {
-                        cv.Required(CONF_MIRROR_X): cv.boolean,
-                        cv.Required(CONF_MIRROR_Y): cv.boolean,
-                    }
-                ),
-                cv.Optional(CONF_FULL_UPDATE_EVERY, default=1): cv.int_range(1, 255),
-                model.option(CONF_DC_PIN, fallback=None): pins.gpio_output_pin_schema,
-                cv.GenerateID(): cv.declare_id(class_name),
-                cv.GenerateID(CONF_INIT_SEQUENCE_ID): cv.declare_id(cg.uint8),
-                cv_dimensions(CONF_DIMENSIONS): DIMENSION_SCHEMA,
-                model.option(CONF_ENABLE_PIN): cv.ensure_list(
-                    pins.gpio_output_pin_schema
-                ),
-                model.option(CONF_INIT_SEQUENCE, cv.UNDEFINED): cv.ensure_list(
-                    map_sequence
-                ),
-                model.option(CONF_RESET_DURATION, cv.UNDEFINED): cv.All(
-                    cv.positive_time_period_milliseconds,
-                    cv.Range(max=core.TimePeriod(milliseconds=500)),
-                ),
-            }
+    return display.FULL_DISPLAY_SCHEMA.extend(
+        spi.spi_device_schema(
+            cs_pin_required=False,
+            default_mode="MODE0",
+            default_data_rate=model.get_default(CONF_DATA_RATE, 10_000_000),
         )
+    ).extend(
+        {
+            cv.Optional(CONF_ROTATION, default=0): validate_rotation,
+            cv.Required(CONF_MODEL): cv.one_of(model.name, upper=True),
+            cv.Optional(CONF_UPDATE_INTERVAL, default=cv.UNDEFINED): cv.All(
+                update_interval, cv.Range(min=minimum_update_interval)
+            ),
+            cv.Optional(CONF_TRANSFORM): cv.Schema(
+                {
+                    cv.Required(CONF_MIRROR_X): cv.boolean,
+                    cv.Required(CONF_MIRROR_Y): cv.boolean,
+                }
+            ),
+            cv.Optional(CONF_FULL_UPDATE_EVERY, default=1): cv.int_range(1, 255),
+            model.option(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
+            model.option(CONF_CS_PIN): pins.gpio_output_pin_schema,
+            model.option(CONF_DC_PIN, fallback=None): pins.gpio_output_pin_schema,
+            model.option(CONF_RESET_PIN): pins.gpio_output_pin_schema,
+            cv.GenerateID(): cv.declare_id(class_name),
+            cv.GenerateID(CONF_INIT_SEQUENCE_ID): cv.declare_id(cg.uint8),
+            cv_dimensions(CONF_DIMENSIONS): DIMENSION_SCHEMA,
+            model.option(CONF_ENABLE_PIN): cv.ensure_list(pins.gpio_output_pin_schema),
+            model.option(CONF_INIT_SEQUENCE, cv.UNDEFINED): cv.ensure_list(
+                map_sequence
+            ),
+            model.option(CONF_RESET_DURATION, cv.UNDEFINED): cv.All(
+                cv.positive_time_period_milliseconds,
+                cv.Range(max=core.TimePeriod(milliseconds=500)),
+            ),
+        }
     )
 
 
diff --git a/esphome/components/epaper_spi/epaper_spi.cpp b/esphome/components/epaper_spi/epaper_spi.cpp
index db803305a5a..ae1923a9162 100644
--- a/esphome/components/epaper_spi/epaper_spi.cpp
+++ b/esphome/components/epaper_spi/epaper_spi.cpp
@@ -182,7 +182,9 @@ void EPaperBase::process_state_() {
       this->set_state_(EPaperState::RESET);
       break;
     case EPaperState::INITIALISE:
-      this->initialise(this->update_count_ != 0);
+      if (!this->initialise(this->update_count_ != 0)) {
+        return;  // Not done yet, come back next loop
+      }
       this->set_state_(EPaperState::TRANSFER_DATA);
       break;
     case EPaperState::TRANSFER_DATA:
@@ -239,11 +241,9 @@ void EPaperBase::start_data_() {
 
 void EPaperBase::on_safe_shutdown() { this->deep_sleep(); }
 
-void EPaperBase::initialise(bool partial) {
+void EPaperBase::send_init_sequence_(const uint8_t *sequence, size_t length) {
   size_t index = 0;
 
-  auto *sequence = this->init_sequence_;
-  auto length = this->init_sequence_length_;
   while (index != length) {
     if (length - index < 2) {
       this->mark_failed(LOG_STR("Malformed init sequence"));
@@ -266,6 +266,11 @@ void EPaperBase::initialise(bool partial) {
   }
 }
 
+bool EPaperBase::initialise(bool partial) {
+  this->send_init_sequence_(this->init_sequence_, this->init_sequence_length_);
+  return true;
+}
+
 /**
  * Check and rotate coordinates based on the transform flags.
  * @param x
diff --git a/esphome/components/epaper_spi/epaper_spi.h b/esphome/components/epaper_spi/epaper_spi.h
index 521543f0266..a8c2fe9b561 100644
--- a/esphome/components/epaper_spi/epaper_spi.h
+++ b/esphome/components/epaper_spi/epaper_spi.h
@@ -115,7 +115,8 @@ class EPaperBase : public Display,
   bool is_idle_() const;
   void setup_pins_() const;
   virtual bool reset();
-  virtual void initialise(bool partial);
+  virtual bool initialise(bool partial);
+  void send_init_sequence_(const uint8_t *sequence, size_t length);
   void wait_for_idle_(bool should_wait);
   bool init_buffer_(size_t buffer_length);
   bool rotate_coordinates_(int &x, int &y);
diff --git a/esphome/components/epaper_spi/epaper_waveshare.cpp b/esphome/components/epaper_spi/epaper_waveshare.cpp
index 8d382d86e71..7a7b4e22d3a 100644
--- a/esphome/components/epaper_spi/epaper_waveshare.cpp
+++ b/esphome/components/epaper_spi/epaper_waveshare.cpp
@@ -4,7 +4,7 @@ namespace esphome::epaper_spi {
 
 static const char *const TAG = "epaper_spi.waveshare";
 
-void EpaperWaveshare::initialise(bool partial) {
+bool EpaperWaveshare::initialise(bool partial) {
   EPaperBase::initialise(partial);
   if (partial) {
     this->cmd_data(0x32, this->partial_lut_, this->partial_lut_length_);
@@ -17,6 +17,7 @@ void EpaperWaveshare::initialise(bool partial) {
     this->cmd_data(0x3C, {0x05});
   }
   this->send_red_ = true;
+  return true;
 }
 
 void EpaperWaveshare::set_window() {
diff --git a/esphome/components/epaper_spi/epaper_waveshare.h b/esphome/components/epaper_spi/epaper_waveshare.h
index 6b894cfd09f..15fb575ca01 100644
--- a/esphome/components/epaper_spi/epaper_waveshare.h
+++ b/esphome/components/epaper_spi/epaper_waveshare.h
@@ -18,7 +18,7 @@ class EpaperWaveshare : public EPaperMono {
         partial_lut_length_(partial_lut_length) {}
 
  protected:
-  void initialise(bool partial) override;
+  bool initialise(bool partial) override;
   void set_window() override;
   void refresh_screen(bool partial) override;
   void deep_sleep() override;
diff --git a/esphome/components/esp32/__init__.py b/esphome/components/esp32/__init__.py
index aed4ecad909..0c02f6fbee2 100644
--- a/esphome/components/esp32/__init__.py
+++ b/esphome/components/esp32/__init__.py
@@ -46,10 +46,11 @@ from esphome.coroutine import CoroPriority, coroutine_with_priority
 import esphome.final_validate as fv
 from esphome.helpers import copy_file_if_changed, write_file_if_changed
 from esphome.types import ConfigType
-from esphome.writer import clean_cmake_cache
+from esphome.writer import clean_cmake_cache, rmtree
 
 from .boards import BOARDS, STANDARD_BOARDS
 from .const import (  # noqa
+    KEY_ARDUINO_LIBRARIES,
     KEY_BOARD,
     KEY_COMPONENTS,
     KEY_ESP32,
@@ -94,6 +95,11 @@ CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
 CONF_MINIMUM_CHIP_REVISION = "minimum_chip_revision"
 CONF_RELEASE = "release"
 
+ARDUINO_FRAMEWORK_NAME = "framework-arduinoespressif32"
+ARDUINO_FRAMEWORK_PKG = f"pioarduino/{ARDUINO_FRAMEWORK_NAME}"
+ARDUINO_LIBS_NAME = f"{ARDUINO_FRAMEWORK_NAME}-libs"
+ARDUINO_LIBS_PKG = f"pioarduino/{ARDUINO_LIBS_NAME}"
+
 LOG_LEVELS_IDF = [
     "NONE",
     "ERROR",
@@ -124,10 +130,14 @@ COMPILER_OPTIMIZATIONS = {
 # - "sdmmc": driver -> esp_driver_sdmmc -> sdmmc dependency chain
 DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "cmock",  # Unit testing mock framework - ESPHome doesn't use IDF's testing
+    "driver",  # Legacy driver shim - only needed by esp32_touch, esp32_can for legacy headers
     "esp_adc",  # ADC driver - only needed by adc component
+    "esp_driver_dac",  # DAC driver - only needed by esp32_dac component
     "esp_driver_i2s",  # I2S driver - only needed by i2s_audio component
+    "esp_driver_mcpwm",  # MCPWM driver - ESPHome doesn't use motor control PWM
     "esp_driver_rmt",  # RMT driver - only needed by remote_transmitter/receiver, neopixelbus
     "esp_driver_touch_sens",  # Touch sensor driver - only needed by esp32_touch
+    "esp_driver_twai",  # TWAI/CAN driver - only needed by esp32_can component
     "esp_eth",  # Ethernet driver - only needed by ethernet component
     "esp_hid",  # HID host/device support - ESPHome doesn't implement HID functionality
     "esp_http_client",  # HTTP client - only needed by http_request component
@@ -138,14 +148,178 @@ DEFAULT_EXCLUDED_IDF_COMPONENTS = (
     "espcoredump",  # Core dump support - ESPHome has its own debug component
     "fatfs",  # FAT filesystem - ESPHome doesn't use filesystem storage
     "mqtt",  # ESP-IDF MQTT library - ESPHome has its own MQTT implementation
+    "openthread",  # Thread protocol - only needed by openthread component
     "perfmon",  # Xtensa performance monitor - ESPHome has its own debug component
     "protocomm",  # Protocol communication for provisioning - unused by ESPHome
     "spiffs",  # SPIFFS filesystem - ESPHome doesn't use filesystem storage (IDF only)
+    "ulp",  # ULP coprocessor - not currently used by any ESPHome component
     "unity",  # Unit testing framework - ESPHome doesn't use IDF's testing
     "wear_levelling",  # Flash wear levelling for fatfs - unused since fatfs unused
     "wifi_provisioning",  # WiFi provisioning - ESPHome uses its own improv implementation
 )
 
+# Additional IDF managed components to exclude for Arduino framework builds
+# These are pulled in by the Arduino framework's idf_component.yml but not used by ESPHome
+# Note: Component names include the namespace prefix (e.g., "espressif__cbor") because
+# that's how managed components are registered in the IDF build system
+# List includes direct dependencies from arduino-esp32/idf_component.yml
+# plus transitive dependencies from RainMaker/Insights (except espressif/mdns which we need)
+ARDUINO_EXCLUDED_IDF_COMPONENTS = (
+    "chmorgan__esp-libhelix-mp3",  # MP3 decoder - not used
+    "espressif__cbor",  # CBOR library - only used by RainMaker/Insights
+    "espressif__esp-dsp",  # DSP library - not used
+    "espressif__esp-modbus",  # Modbus - ESPHome has its own
+    "espressif__esp-sr",  # Speech recognition - not used
+    "espressif__esp-zboss-lib",  # Zigbee ZBOSS library - not used
+    "espressif__esp-zigbee-lib",  # Zigbee library - not used
+    "espressif__esp_diag_data_store",  # Diagnostics - not used
+    "espressif__esp_diagnostics",  # Diagnostics - not used
+    "espressif__esp_hosted",  # ESP hosted - only for ESP32-P4
+    "espressif__esp_insights",  # ESP Insights - not used
+    "espressif__esp_modem",  # Modem library - not used
+    "espressif__esp_rainmaker",  # RainMaker - not used
+    "espressif__esp_rcp_update",  # RCP update - RainMaker transitive dep
+    "espressif__esp_schedule",  # Schedule - RainMaker transitive dep
+    "espressif__esp_secure_cert_mgr",  # Secure cert - RainMaker transitive dep
+    "espressif__esp_wifi_remote",  # WiFi remote - only for ESP32-P4
+    "espressif__json_generator",  # JSON generator - RainMaker transitive dep
+    "espressif__json_parser",  # JSON parser - RainMaker transitive dep
+    "espressif__lan867x",  # Ethernet PHY - ESPHome uses ESP-IDF ethernet directly
+    "espressif__libsodium",  # Crypto - ESPHome uses its own noise-c library
+    "espressif__network_provisioning",  # Network provisioning - not used
+    "espressif__qrcode",  # QR code - not used
+    "espressif__rmaker_common",  # RainMaker common - not used
+    "joltwallet__littlefs",  # LittleFS - ESPHome doesn't use filesystem
+)
+
+# Mapping of Arduino libraries to IDF managed components they require
+# When an Arduino library is enabled via cg.add_library(), these components
+# are automatically un-stubbed from ARDUINO_EXCLUDED_IDF_COMPONENTS.
+#
+# Note: Some libraries (Matter, LittleFS, ESP_SR, WiFiProv, ArduinoOTA) already have
+# conditional maybe_add_component() calls in arduino-esp32/CMakeLists.txt that handle
+# their managed component dependencies. Our mapping is primarily needed for libraries
+# that don't have such conditionals (Ethernet, PPP, Zigbee, RainMaker, Insights, etc.)
+# and to ensure the stubs are removed from our idf_component.yml overrides.
+ARDUINO_LIBRARY_IDF_COMPONENTS: dict[str, tuple[str, ...]] = {
+    "BLE": ("esp_driver_gptimer",),
+    "BluetoothSerial": ("esp_driver_gptimer",),
+    "ESP_HostedOTA": ("espressif__esp_hosted", "espressif__esp_wifi_remote"),
+    "ESP_SR": ("espressif__esp-sr",),
+    "Ethernet": ("espressif__lan867x",),
+    "FFat": ("fatfs",),
+    "Insights": (
+        "espressif__cbor",
+        "espressif__esp_insights",
+        "espressif__esp_diagnostics",
+        "espressif__esp_diag_data_store",
+        "espressif__rmaker_common",  # Transitive dep from esp_insights
+    ),
+    "LittleFS": ("joltwallet__littlefs",),
+    "Matter": ("espressif__esp_matter",),
+    "PPP": ("espressif__esp_modem",),
+    "RainMaker": (
+        # Direct deps from idf_component.yml
+        "espressif__cbor",
+        "espressif__esp_rainmaker",
+        "espressif__esp_insights",
+        "espressif__esp_diagnostics",
+        "espressif__esp_diag_data_store",
+        "espressif__rmaker_common",
+        "espressif__qrcode",
+        # Transitive deps from esp_rainmaker
+        "espressif__esp_rcp_update",
+        "espressif__esp_schedule",
+        "espressif__esp_secure_cert_mgr",
+        "espressif__json_generator",
+        "espressif__json_parser",
+        "espressif__network_provisioning",
+    ),
+    "SD": ("fatfs",),
+    "SD_MMC": ("fatfs",),
+    "SPIFFS": ("spiffs",),
+    "WiFiProv": ("espressif__network_provisioning", "espressif__qrcode"),
+    "Zigbee": ("espressif__esp-zigbee-lib", "espressif__esp-zboss-lib"),
+}
+
+# Arduino library to Arduino library dependencies
+# When enabling one library, also enable its dependencies
+# Kconfig "select" statements don't work with CONFIG_ARDUINO_SELECTIVE_COMPILATION
+ARDUINO_LIBRARY_DEPENDENCIES: dict[str, tuple[str, ...]] = {
+    "Ethernet": ("Network",),
+    "WiFi": ("Network",),
+}
+
+
+def _idf_component_stub_name(component: str) -> str:
+    """Get stub directory name from IDF component name.
+
+    Component names are typically namespace__name (e.g., espressif__cbor).
+    Returns just the name part (e.g., cbor). If no namespace is present,
+    returns the original component name.
+    """
+    _prefix, sep, suffix = component.partition("__")
+    return suffix if sep else component
+
+
+def _idf_component_dep_name(component: str) -> str:
+    """Convert IDF component name to dependency format.
+
+    Converts espressif__cbor to espressif/cbor.
+    """
+    return component.replace("__", "/")
+
+
+# Arduino libraries to disable by default when using Arduino framework
+# ESPHome uses ESP-IDF APIs directly; we only need the Arduino core
+# (HardwareSerial, Print, Stream, GPIO functions which are always compiled)
+# Components use cg.add_library() which auto-enables any they need
+# This list must match ARDUINO_ALL_LIBRARIES from arduino-esp32/CMakeLists.txt
+ARDUINO_DISABLED_LIBRARIES: frozenset[str] = frozenset(
+    {
+        "ArduinoOTA",
+        "AsyncUDP",
+        "BLE",
+        "BluetoothSerial",
+        "DNSServer",
+        "EEPROM",
+        "ESP_HostedOTA",
+        "ESP_I2S",
+        "ESP_NOW",
+        "ESP_SR",
+        "ESPmDNS",
+        "Ethernet",
+        "FFat",
+        "FS",
+        "Hash",
+        "HTTPClient",
+        "HTTPUpdate",
+        "Insights",
+        "LittleFS",
+        "Matter",
+        "NetBIOS",
+        "Network",
+        "NetworkClientSecure",
+        "OpenThread",
+        "PPP",
+        "Preferences",
+        "RainMaker",
+        "SD",
+        "SD_MMC",
+        "SimpleBLE",
+        "SPI",
+        "SPIFFS",
+        "Ticker",
+        "Update",
+        "USB",
+        "WebServer",
+        "WiFi",
+        "WiFiProv",
+        "Wire",
+        "Zigbee",
+    }
+)
+
 # ESP32 (original) chip revision options
 # Setting minimum revision to 3.0 or higher:
 # - Reduces flash size by excluding workaround code for older chip bugs
@@ -237,7 +411,13 @@ def set_core_data(config):
     CORE.data[KEY_ESP32][KEY_COMPONENTS] = {}
     # Initialize with default exclusions - components can call include_builtin_idf_component()
     # to re-enable any they need
-    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] = set(DEFAULT_EXCLUDED_IDF_COMPONENTS)
+    excluded = set(DEFAULT_EXCLUDED_IDF_COMPONENTS)
+    # Add Arduino-specific managed component exclusions when using Arduino framework
+    if conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
+        excluded.update(ARDUINO_EXCLUDED_IDF_COMPONENTS)
+    CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS] = excluded
+    # Initialize Arduino library tracking - cg.add_library() auto-enables libraries
+    CORE.data[KEY_ESP32][KEY_ARDUINO_LIBRARIES] = set()
     CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] = cv.Version.parse(
         config[CONF_FRAMEWORK][CONF_VERSION]
     )
@@ -385,6 +565,26 @@ def include_builtin_idf_component(name: str) -> None:
     CORE.data[KEY_ESP32][KEY_EXCLUDE_COMPONENTS].discard(name)
 
 
+def _enable_arduino_library(name: str) -> None:
+    """Enable an Arduino library that is disabled by default.
+
+    This is called automatically by CORE.add_library() when a component adds
+    an Arduino library via cg.add_library(). Components should not call this
+    directly - just use cg.add_library("LibName", None).
+
+    Args:
+        name: The library name (e.g., "Wire", "SPI", "WiFi")
+    """
+    enabled_libs: set[str] = CORE.data[KEY_ESP32][KEY_ARDUINO_LIBRARIES]
+    enabled_libs.add(name)
+    # Also enable any required Arduino library dependencies
+    for dep_lib in ARDUINO_LIBRARY_DEPENDENCIES.get(name, ()):
+        enabled_libs.add(dep_lib)
+    # Also enable any required IDF components
+    for idf_component in ARDUINO_LIBRARY_IDF_COMPONENTS.get(name, ()):
+        include_builtin_idf_component(idf_component)
+
+
 def add_extra_script(stage: str, filename: str, path: Path):
     """Add an extra script to the project."""
     key = f"{stage}:{filename}"
@@ -404,14 +604,12 @@ def add_extra_build_file(filename: str, path: Path) -> bool:
 
 
 def _format_framework_arduino_version(ver: cv.Version) -> str:
-    # format the given arduino (https://github.com/espressif/arduino-esp32/releases) version to
-    # a PIO pioarduino/framework-arduinoespressif32 value
     # 3.3.6+ changed filename from esp32-{ver}.zip to esp32-core-{ver}.tar.xz
     if ver >= cv.Version(3, 3, 6):
         filename = f"esp32-core-{ver}.tar.xz"
     else:
         filename = f"esp32-{ver}.zip"
-    return f"pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/{ver}/{filename}"
+    return f"{ARDUINO_FRAMEWORK_PKG}@https://github.com/espressif/arduino-esp32/releases/download/{ver}/{filename}"
 
 
 def _format_framework_espidf_version(ver: cv.Version, release: str) -> str:
@@ -511,7 +709,7 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 PLATFORM_VERSION_LOOKUP = {
     "recommended": cv.Version(55, 3, 36),
     "latest": cv.Version(55, 3, 36),
-    "dev": cv.Version(55, 3, 36),
+    "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }
 
 
@@ -546,9 +744,7 @@ def _check_versions(config):
             CONF_SOURCE, _format_framework_arduino_version(version)
         )
         if _is_framework_url(value[CONF_SOURCE]):
-            value[CONF_SOURCE] = (
-                f"pioarduino/framework-arduinoespressif32@{value[CONF_SOURCE]}"
-            )
+            value[CONF_SOURCE] = f"{ARDUINO_FRAMEWORK_PKG}@{value[CONF_SOURCE]}"
     else:
         if version < cv.Version(5, 0, 0):
             raise cv.Invalid("Only ESP-IDF 5.0+ is supported.")
@@ -973,8 +1169,8 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
         + "(We've been warning about this change since ESPHome 2025.8.0)\n"
         + "\n"
         + "Why we made this change:\n"
-        + color(AnsiFore.GREEN, "  ✨ Up to 40% smaller firmware binaries\n")
-        + color(AnsiFore.GREEN, "  ⚡ 2-3x faster compile times\n")
+        + color(AnsiFore.GREEN, "  ✨ Smaller firmware binaries\n")
+        + color(AnsiFore.GREEN, "  ⚡ Faster compile times\n")
         + color(AnsiFore.GREEN, "  🚀 Better performance and newer features\n")
         + color(AnsiFore.GREEN, "  🔧 More actively maintained by ESPHome\n")
         + "\n"
@@ -1126,6 +1322,41 @@ async def _write_exclude_components() -> None:
         )
 
 
+@coroutine_with_priority(CoroPriority.FINAL)
+async def _write_arduino_libs_stub(stubs_dir: Path, idf_ver: cv.Version) -> None:
+    """Write stub package to skip downloading precompiled Arduino libs."""
+    stubs_dir.mkdir(parents=True, exist_ok=True)
+    write_file_if_changed(
+        stubs_dir / "package.json",
+        f'{{"name":"{ARDUINO_LIBS_NAME}","version":"{idf_ver.major}.{idf_ver.minor}.{idf_ver.patch}"}}',
+    )
+    write_file_if_changed(
+        stubs_dir / "tools.json",
+        '{"packages":[{"platforms":[{"toolsDependencies":[]}],"tools":[]}]}',
+    )
+
+
+@coroutine_with_priority(CoroPriority.FINAL)
+async def _write_arduino_libraries_sdkconfig() -> None:
+    """Write Arduino selective compilation sdkconfig after all components have added libraries.
+
+    This must run at FINAL priority so that all components have had a chance to call
+    cg.add_library() which auto-enables Arduino libraries via _enable_arduino_library().
+    """
+    if KEY_ESP32 not in CORE.data:
+        return
+    # Enable Arduino selective compilation to disable unused Arduino libraries
+    # ESPHome uses ESP-IDF APIs directly; we only need the Arduino core
+    # (HardwareSerial, Print, Stream, GPIO functions which are always compiled)
+    # cg.add_library() auto-enables needed libraries; users can also add
+    # libraries via esphome: libraries: config which calls cg.add_library()
+    add_idf_sdkconfig_option("CONFIG_ARDUINO_SELECTIVE_COMPILATION", True)
+    enabled_libs = CORE.data[KEY_ESP32].get(KEY_ARDUINO_LIBRARIES, set())
+    for lib in ARDUINO_DISABLED_LIBRARIES:
+        # Enable if explicitly requested, disable otherwise
+        add_idf_sdkconfig_option(f"CONFIG_ARDUINO_SELECTIVE_{lib}", lib in enabled_libs)
+
+
 @coroutine_with_priority(CoroPriority.FINAL)
 async def _add_yaml_idf_components(components: list[ConfigType]):
     """Add IDF components from YAML config with final priority to override code-added components."""
@@ -1235,6 +1466,12 @@ async def to_code(config):
                     "platform_packages",
                     [_format_framework_espidf_version(idf_ver, None)],
                 )
+                # Use stub package to skip downloading precompiled libs
+                stubs_dir = CORE.relative_build_path("arduino-libs-stub")
+                cg.add_platformio_option(
+                    "platform_packages", [f"{ARDUINO_LIBS_PKG}@file://{stubs_dir}"]
+                )
+                CORE.add_job(_write_arduino_libs_stub, stubs_dir, idf_ver)
 
             # ESP32-S2 Arduino: Disable USB Serial on boot to avoid TinyUSB dependency
             if get_esp32_variant() == VARIANT_ESP32S2:
@@ -1544,6 +1781,11 @@ async def to_code(config):
     # Default exclusions are added in set_core_data() during config validation.
     CORE.add_job(_write_exclude_components)
 
+    # Write Arduino selective compilation sdkconfig at FINAL priority after all
+    # components have had a chance to call cg.add_library() to enable libraries they need.
+    if conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
+        CORE.add_job(_write_arduino_libraries_sdkconfig)
+
 
 APP_PARTITION_SIZES = {
     "2MB": 0x0C0000,  # 768 KB
@@ -1624,11 +1866,49 @@ def _write_sdkconfig():
 
 def _write_idf_component_yml():
     yml_path = CORE.relative_build_path("src/idf_component.yml")
+    dependencies: dict[str, dict] = {}
+
+    # For Arduino builds, override unused managed components from the Arduino framework
+    # by pointing them to empty stub directories using override_path
+    # This prevents the IDF component manager from downloading the real components
+    if CORE.using_arduino:
+        # Determine which IDF components are needed by enabled Arduino libraries
+        enabled_libs = CORE.data[KEY_ESP32].get(KEY_ARDUINO_LIBRARIES, set())
+        required_idf_components = {
+            comp
+            for lib in enabled_libs
+            for comp in ARDUINO_LIBRARY_IDF_COMPONENTS.get(lib, ())
+        }
+
+        # Only stub components that are not required by any enabled Arduino library
+        components_to_stub = (
+            set(ARDUINO_EXCLUDED_IDF_COMPONENTS) - required_idf_components
+        )
+
+        stubs_dir = CORE.relative_build_path("component_stubs")
+        stubs_dir.mkdir(exist_ok=True)
+        for component_name in components_to_stub:
+            # Create stub directory with minimal CMakeLists.txt
+            stub_path = stubs_dir / _idf_component_stub_name(component_name)
+            stub_path.mkdir(exist_ok=True)
+            stub_cmake = stub_path / "CMakeLists.txt"
+            if not stub_cmake.exists():
+                stub_cmake.write_text("idf_component_register()\n")
+            dependencies[_idf_component_dep_name(component_name)] = {
+                "version": "*",
+                "override_path": str(stub_path),
+            }
+
+        # Remove stubs for components that are now required by enabled libraries
+        for component_name in required_idf_components:
+            stub_path = stubs_dir / _idf_component_stub_name(component_name)
+            if stub_path.exists():
+                rmtree(stub_path)
+
     if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
         components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
-        dependencies = {}
         for name, component in components.items():
-            dependency = {}
+            dependency: dict[str, str] = {}
             if component[KEY_REF]:
                 dependency["version"] = component[KEY_REF]
             if component[KEY_REPO]:
@@ -1636,9 +1916,8 @@ def _write_idf_component_yml():
             if component[KEY_PATH]:
                 dependency["path"] = component[KEY_PATH]
             dependencies[name] = dependency
-        contents = yaml_util.dump({"dependencies": dependencies})
-    else:
-        contents = ""
+
+    contents = yaml_util.dump({"dependencies": dependencies}) if dependencies else ""
     if write_file_if_changed(yml_path, contents):
         dependencies_lock = CORE.relative_build_path("dependencies.lock")
         if dependencies_lock.is_file():
diff --git a/esphome/components/esp32/const.py b/esphome/components/esp32/const.py
index db3eddebd58..7874c1c759c 100644
--- a/esphome/components/esp32/const.py
+++ b/esphome/components/esp32/const.py
@@ -7,6 +7,7 @@ KEY_VARIANT = "variant"
 KEY_SDKCONFIG_OPTIONS = "sdkconfig_options"
 KEY_COMPONENTS = "components"
 KEY_EXCLUDE_COMPONENTS = "exclude_components"
+KEY_ARDUINO_LIBRARIES = "arduino_libraries"
 KEY_REPO = "repo"
 KEY_REF = "ref"
 KEY_REFRESH = "refresh"
diff --git a/esphome/components/esp32/preferences.cpp b/esphome/components/esp32/preferences.cpp
index 4e0bb68133f..7d5af023b48 100644
--- a/esphome/components/esp32/preferences.cpp
+++ b/esphome/components/esp32/preferences.cpp
@@ -203,10 +203,11 @@ class ESP32Preferences : public ESPPreferences {
   }
 };
 
+static ESP32Preferences s_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 void setup_preferences() {
-  auto *prefs = new ESP32Preferences();  // NOLINT(cppcoreguidelines-owning-memory)
-  prefs->open();
-  global_preferences = prefs;
+  s_preferences.open();
+  global_preferences = &s_preferences;
 }
 
 }  // namespace esp32
diff --git a/esphome/components/esp32_camera/esp32_camera.cpp b/esphome/components/esp32_camera/esp32_camera.cpp
index 5466d2e7efa..cfe06b16732 100644
--- a/esphome/components/esp32_camera/esp32_camera.cpp
+++ b/esphome/components/esp32_camera/esp32_camera.cpp
@@ -235,8 +235,6 @@ void ESP32Camera::loop() {
   this->single_requesters_ = 0;
 }
 
-float ESP32Camera::get_setup_priority() const { return setup_priority::DATA; }
-
 /* ---------------- constructors ---------------- */
 ESP32Camera::ESP32Camera() {
   this->config_.pin_pwdn = -1;
diff --git a/esphome/components/esp32_camera/esp32_camera.h b/esphome/components/esp32_camera/esp32_camera.h
index e97eb27c705..eea93b7e015 100644
--- a/esphome/components/esp32_camera/esp32_camera.h
+++ b/esphome/components/esp32_camera/esp32_camera.h
@@ -159,7 +159,6 @@ class ESP32Camera : public camera::Camera {
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   /* public API (specific) */
   void start_stream(camera::CameraRequester requester) override;
   void stop_stream(camera::CameraRequester requester) override;
diff --git a/esphome/components/esp32_can/canbus.py b/esphome/components/esp32_can/canbus.py
index 0768b355071..7245ba75133 100644
--- a/esphome/components/esp32_can/canbus.py
+++ b/esphome/components/esp32_can/canbus.py
@@ -15,6 +15,7 @@ from esphome.components.esp32 import (
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
     get_esp32_variant,
+    include_builtin_idf_component,
 )
 import esphome.config_validation as cv
 from esphome.const import (
@@ -121,6 +122,10 @@ def get_default_tx_enqueue_timeout(bit_rate):
 
 
 async def to_code(config):
+    # Legacy driver component provides driver/twai.h header
+    include_builtin_idf_component("driver")
+    # Also enable esp_driver_twai for future migration to new API
+    include_builtin_idf_component("esp_driver_twai")
     var = cg.new_Pvariable(config[CONF_ID])
     await canbus.register_canbus(var, config)
 
diff --git a/esphome/components/esp32_dac/output.py b/esphome/components/esp32_dac/output.py
index daace596d31..7c63d7bd11c 100644
--- a/esphome/components/esp32_dac/output.py
+++ b/esphome/components/esp32_dac/output.py
@@ -1,7 +1,12 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import output
-from esphome.components.esp32 import VARIANT_ESP32, VARIANT_ESP32S2, get_esp32_variant
+from esphome.components.esp32 import (
+    VARIANT_ESP32,
+    VARIANT_ESP32S2,
+    get_esp32_variant,
+    include_builtin_idf_component,
+)
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_NUMBER, CONF_PIN
 
@@ -38,6 +43,7 @@ CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
 
 
 async def to_code(config):
+    include_builtin_idf_component("esp_driver_dac")
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await output.register_output(var, config)
diff --git a/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp b/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp
index ebcdd5f36ee..a7d5f7e3d51 100644
--- a/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp
+++ b/esphome/components/esp32_hosted/update/esp32_hosted_update.cpp
@@ -34,14 +34,29 @@ static const char *const ESP_HOSTED_VERSION_STR = STRINGIFY(ESP_HOSTED_VERSION_M
     ESP_HOSTED_VERSION_MINOR_1) "." STRINGIFY(ESP_HOSTED_VERSION_PATCH_1);
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
+// Parse an integer from str, advancing ptr past the number
+// Returns false if no digits were parsed
+static bool parse_int(const char *&ptr, int &value) {
+  char *end;
+  value = static_cast<int>(strtol(ptr, &end, 10));
+  if (end == ptr)
+    return false;
+  ptr = end;
+  return true;
+}
+
 // Parse version string "major.minor.patch" into components
-// Returns true if parsing succeeded
+// Returns true if at least major.minor was parsed
 static bool parse_version(const std::string &version_str, int &major, int &minor, int &patch) {
   major = minor = patch = 0;
-  if (sscanf(version_str.c_str(), "%d.%d.%d", &major, &minor, &patch) >= 2) {
-    return true;
-  }
-  return false;
+  const char *ptr = version_str.c_str();
+
+  if (!parse_int(ptr, major) || *ptr++ != '.' || !parse_int(ptr, minor))
+    return false;
+  if (*ptr == '.')
+    parse_int(++ptr, patch);
+
+  return true;
 }
 
 // Compare two versions, returns:
@@ -196,11 +211,14 @@ bool Esp32HostedUpdate::fetch_manifest_() {
     int read_or_error = container->read(buf, sizeof(buf));
     App.feed_wdt();
     yield();
-    auto result = http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout);
+    auto result =
+        http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout, container->is_read_complete());
     if (result == http_request::HttpReadLoopResult::RETRY)
       continue;
+    // Note: COMPLETE is currently unreachable since the loop condition checks bytes_read < content_length,
+    // but this is defensive code in case chunked transfer encoding support is added in the future.
     if (result != http_request::HttpReadLoopResult::DATA)
-      break;  // ERROR or TIMEOUT
+      break;  // COMPLETE, ERROR, or TIMEOUT
     json_str.append(reinterpret_cast<char *>(buf), read_or_error);
   }
   container->end();
@@ -321,9 +339,14 @@ bool Esp32HostedUpdate::stream_firmware_to_coprocessor_() {
     App.feed_wdt();
     yield();
 
-    auto result = http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout);
+    auto result =
+        http_request::http_read_loop_result(read_or_error, last_data_time, read_timeout, container->is_read_complete());
     if (result == http_request::HttpReadLoopResult::RETRY)
       continue;
+    // Note: COMPLETE is currently unreachable since the loop condition checks bytes_read < content_length,
+    // but this is defensive code in case chunked transfer encoding support is added in the future.
+    if (result == http_request::HttpReadLoopResult::COMPLETE)
+      break;
     if (result != http_request::HttpReadLoopResult::DATA) {
       if (result == http_request::HttpReadLoopResult::TIMEOUT) {
         ESP_LOGE(TAG, "Timeout reading firmware data");
diff --git a/esphome/components/esp32_touch/__init__.py b/esphome/components/esp32_touch/__init__.py
index 6accb89c357..a02370a3434 100644
--- a/esphome/components/esp32_touch/__init__.py
+++ b/esphome/components/esp32_touch/__init__.py
@@ -269,6 +269,8 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     # Re-enable ESP-IDF's touch sensor driver (excluded by default to save compile time)
     include_builtin_idf_component("esp_driver_touch_sens")
+    # Legacy driver component provides driver/touch_sensor.h header
+    include_builtin_idf_component("driver")
 
     touch = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(touch, config)
diff --git a/esphome/components/esp32_touch/esp32_touch.h b/esphome/components/esp32_touch/esp32_touch.h
index 812c746301d..7f45f2ccb45 100644
--- a/esphome/components/esp32_touch/esp32_touch.h
+++ b/esphome/components/esp32_touch/esp32_touch.h
@@ -51,7 +51,6 @@ class ESP32TouchComponent : public Component {
   void setup() override;
   void dump_config() override;
   void loop() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   void on_shutdown() override;
 
diff --git a/esphome/components/esp8266/preferences.cpp b/esphome/components/esp8266/preferences.cpp
index 35d1cd07f76..f037b881a8f 100644
--- a/esphome/components/esp8266/preferences.cpp
+++ b/esphome/components/esp8266/preferences.cpp
@@ -17,10 +17,6 @@ namespace esphome::esp8266 {
 
 static const char *const TAG = "esp8266.preferences";
 
-static uint32_t *s_flash_storage = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static bool s_prevent_write = false;         // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static bool s_flash_dirty = false;           // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
 static constexpr uint32_t ESP_RTC_USER_MEM_START = 0x60001200;
 static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_WORDS = 128;
 static constexpr uint32_t ESP_RTC_USER_MEM_SIZE_BYTES = ESP_RTC_USER_MEM_SIZE_WORDS * 4;
@@ -43,6 +39,11 @@ static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 128;
 static constexpr uint32_t ESP8266_FLASH_STORAGE_SIZE = 64;
 #endif
 
+static uint32_t
+    s_flash_storage[ESP8266_FLASH_STORAGE_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static bool s_prevent_write = false;              // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static bool s_flash_dirty = false;                // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 static inline bool esp_rtc_user_mem_read(uint32_t index, uint32_t *dest) {
   if (index >= ESP_RTC_USER_MEM_SIZE_WORDS) {
     return false;
@@ -180,7 +181,6 @@ class ESP8266Preferences : public ESPPreferences {
   uint32_t current_flash_offset = 0;  // in words
 
   void setup() {
-    s_flash_storage = new uint32_t[ESP8266_FLASH_STORAGE_SIZE];  // NOLINT
     ESP_LOGVV(TAG, "Loading preferences from flash");
 
     {
@@ -283,10 +283,11 @@ class ESP8266Preferences : public ESPPreferences {
   }
 };
 
+static ESP8266Preferences s_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 void setup_preferences() {
-  auto *pref = new ESP8266Preferences();  // NOLINT(cppcoreguidelines-owning-memory)
-  pref->setup();
-  global_preferences = pref;
+  s_preferences.setup();
+  global_preferences = &s_preferences;
 }
 void preferences_prevent_write(bool prevent) { s_prevent_write = prevent; }
 
diff --git a/esphome/components/espnow/__init__.py b/esphome/components/espnow/__init__.py
index 1f5ca1104ad..faeccd910e0 100644
--- a/esphome/components/espnow/__init__.py
+++ b/esphome/components/espnow/__init__.py
@@ -13,7 +13,7 @@ from esphome.const import (
     CONF_TRIGGER_ID,
     CONF_WIFI,
 )
-from esphome.core import CORE, HexInt
+from esphome.core import HexInt
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@jesserockz"]
@@ -124,9 +124,6 @@ async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    if CORE.using_arduino:
-        cg.add_library("WiFi", None)
-
     # ESP-NOW uses wake_loop_threadsafe() to wake the main loop from ESP-NOW callbacks
     # This enables low-latency event processing instead of waiting for select() timeout
     socket.require_wake_loop_threadsafe()
diff --git a/esphome/components/ethernet/__init__.py b/esphome/components/ethernet/__init__.py
index 8d4a1aaf8e1..38489ceb2bd 100644
--- a/esphome/components/ethernet/__init__.py
+++ b/esphome/components/ethernet/__init__.py
@@ -1,6 +1,6 @@
 import logging
 
-from esphome import pins
+from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components.esp32 import (
     VARIANT_ESP32,
@@ -35,6 +35,8 @@ from esphome.const import (
     CONF_MODE,
     CONF_MOSI_PIN,
     CONF_NUMBER,
+    CONF_ON_CONNECT,
+    CONF_ON_DISCONNECT,
     CONF_PAGE_ID,
     CONF_PIN,
     CONF_POLLING_INTERVAL,
@@ -237,6 +239,8 @@ BASE_SCHEMA = cv.Schema(
         cv.Optional(CONF_DOMAIN, default=".local"): cv.domain_name,
         cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
         cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
+        cv.Optional(CONF_ON_CONNECT): automation.validate_automation(single=True),
+        cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(single=True),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -427,8 +431,17 @@ async def to_code(config):
         # Add LAN867x 10BASE-T1S PHY support component
         add_idf_component(name="espressif/lan867x", ref="2.0.0")
 
-    if CORE.using_arduino:
-        cg.add_library("WiFi", None)
+    if on_connect_config := config.get(CONF_ON_CONNECT):
+        cg.add_define("USE_ETHERNET_CONNECT_TRIGGER")
+        await automation.build_automation(
+            var.get_connect_trigger(), [], on_connect_config
+        )
+
+    if on_disconnect_config := config.get(CONF_ON_DISCONNECT):
+        cg.add_define("USE_ETHERNET_DISCONNECT_TRIGGER")
+        await automation.build_automation(
+            var.get_disconnect_trigger(), [], on_disconnect_config
+        )
 
     CORE.add_job(final_step)
 
diff --git a/esphome/components/ethernet/ethernet_component.cpp b/esphome/components/ethernet/ethernet_component.cpp
index 70f8ce12049..af7fed608b6 100644
--- a/esphome/components/ethernet/ethernet_component.cpp
+++ b/esphome/components/ethernet/ethernet_component.cpp
@@ -309,6 +309,9 @@ void EthernetComponent::loop() {
 
         this->dump_connect_params_();
         this->status_clear_warning();
+#ifdef USE_ETHERNET_CONNECT_TRIGGER
+        this->connect_trigger_.trigger();
+#endif
       } else if (now - this->connect_begin_ > 15000) {
         ESP_LOGW(TAG, "Connecting failed; reconnecting");
         this->start_connect_();
@@ -318,10 +321,16 @@ void EthernetComponent::loop() {
       if (!this->started_) {
         ESP_LOGI(TAG, "Stopped connection");
         this->state_ = EthernetComponentState::STOPPED;
+#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
+        this->disconnect_trigger_.trigger();
+#endif
       } else if (!this->connected_) {
         ESP_LOGW(TAG, "Connection lost; reconnecting");
         this->state_ = EthernetComponentState::CONNECTING;
         this->start_connect_();
+#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
+        this->disconnect_trigger_.trigger();
+#endif
       } else {
         this->finish_connect_();
         // When connected and stable, disable the loop to save CPU cycles
diff --git a/esphome/components/ethernet/ethernet_component.h b/esphome/components/ethernet/ethernet_component.h
index 34380047d17..5a2869c5a7d 100644
--- a/esphome/components/ethernet/ethernet_component.h
+++ b/esphome/components/ethernet/ethernet_component.h
@@ -4,6 +4,7 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/automation.h"
 #include "esphome/components/network/ip_address.h"
 
 #ifdef USE_ESP32
@@ -119,6 +120,12 @@ class EthernetComponent : public Component {
   void add_ip_state_listener(EthernetIPStateListener *listener) { this->ip_state_listeners_.push_back(listener); }
 #endif
 
+#ifdef USE_ETHERNET_CONNECT_TRIGGER
+  Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
+#endif
+#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
+  Trigger<> *get_disconnect_trigger() { return &this->disconnect_trigger_; }
+#endif
  protected:
   static void eth_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data);
   static void got_ip_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data);
@@ -190,6 +197,12 @@ class EthernetComponent : public Component {
   StaticVector<EthernetIPStateListener *, ESPHOME_ETHERNET_IP_STATE_LISTENERS> ip_state_listeners_;
 #endif
 
+#ifdef USE_ETHERNET_CONNECT_TRIGGER
+  Trigger<> connect_trigger_;
+#endif
+#ifdef USE_ETHERNET_DISCONNECT_TRIGGER
+  Trigger<> disconnect_trigger_;
+#endif
  private:
   // Stores a pointer to a string literal (static storage duration).
   // ONLY set from Python-generated code with string literals - never dynamic strings.
diff --git a/esphome/components/feedback/feedback_cover.cpp b/esphome/components/feedback/feedback_cover.cpp
index e419ee6229b..ffb19fa091b 100644
--- a/esphome/components/feedback/feedback_cover.cpp
+++ b/esphome/components/feedback/feedback_cover.cpp
@@ -335,18 +335,18 @@ void FeedbackCover::start_direction_(CoverOperation dir) {
 
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = this->stop_trigger_;
+      trig = &this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = this->open_trigger_;
+      trig = &this->open_trigger_;
 #ifdef USE_BINARY_SENSOR
       obstacle = this->open_obstacle_;
 #endif
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = this->close_trigger_;
+      trig = &this->close_trigger_;
 #ifdef USE_BINARY_SENSOR
       obstacle = this->close_obstacle_;
 #endif
diff --git a/esphome/components/feedback/feedback_cover.h b/esphome/components/feedback/feedback_cover.h
index 199d3b520ac..6be8939413d 100644
--- a/esphome/components/feedback/feedback_cover.h
+++ b/esphome/components/feedback/feedback_cover.h
@@ -17,9 +17,9 @@ class FeedbackCover : public cover::Cover, public Component {
   void loop() override;
   void dump_config() override;
 
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
-  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
-  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
+  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
+  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
+  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
 
 #ifdef USE_BINARY_SENSOR
   void set_open_endstop(binary_sensor::BinarySensor *open_endstop);
@@ -61,9 +61,9 @@ class FeedbackCover : public cover::Cover, public Component {
   binary_sensor::BinarySensor *close_obstacle_{nullptr};
 
 #endif
-  Trigger<> *open_trigger_{new Trigger<>()};
-  Trigger<> *close_trigger_{new Trigger<>()};
-  Trigger<> *stop_trigger_{new Trigger<>()};
+  Trigger<> open_trigger_;
+  Trigger<> close_trigger_;
+  Trigger<> stop_trigger_;
 
   uint32_t open_duration_{0};
   uint32_t close_duration_{0};
diff --git a/esphome/components/gdk101/gdk101.cpp b/esphome/components/gdk101/gdk101.cpp
index ddf38f2f55f..8b381564b2b 100644
--- a/esphome/components/gdk101/gdk101.cpp
+++ b/esphome/components/gdk101/gdk101.cpp
@@ -77,8 +77,6 @@ void GDK101Component::dump_config() {
 #endif  // USE_TEXT_SENSOR
 }
 
-float GDK101Component::get_setup_priority() const { return setup_priority::DATA; }
-
 bool GDK101Component::read_bytes_with_retry_(uint8_t a_register, uint8_t *data, uint8_t len) {
   uint8_t retry = NUMBER_OF_READ_RETRIES;
   bool status = false;
diff --git a/esphome/components/gdk101/gdk101.h b/esphome/components/gdk101/gdk101.h
index f250a42a540..abe417e0f93 100644
--- a/esphome/components/gdk101/gdk101.h
+++ b/esphome/components/gdk101/gdk101.h
@@ -40,7 +40,6 @@ class GDK101Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/gp8403/gp8403.h b/esphome/components/gp8403/gp8403.h
index 6613187b206..972f2ce60c3 100644
--- a/esphome/components/gp8403/gp8403.h
+++ b/esphome/components/gp8403/gp8403.h
@@ -20,7 +20,6 @@ class GP8403Component : public Component, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
   void set_model(GP8403Model model) { this->model_ = model; }
   void set_voltage(gp8403::GP8403Voltage voltage) { this->voltage_ = voltage; }
 
diff --git a/esphome/components/hc8/hc8.cpp b/esphome/components/hc8/hc8.cpp
index 4d0f77df1bd..4c2d367b244 100644
--- a/esphome/components/hc8/hc8.cpp
+++ b/esphome/components/hc8/hc8.cpp
@@ -86,8 +86,6 @@ void HC8Component::calibrate(uint16_t baseline) {
   this->flush();
 }
 
-float HC8Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void HC8Component::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "HC8:\n"
diff --git a/esphome/components/hc8/hc8.h b/esphome/components/hc8/hc8.h
index 7711fb8c972..74257fab148 100644
--- a/esphome/components/hc8/hc8.h
+++ b/esphome/components/hc8/hc8.h
@@ -11,8 +11,6 @@ namespace esphome::hc8 {
 
 class HC8Component : public PollingComponent, public uart::UARTDevice {
  public:
-  float get_setup_priority() const override;
-
   void setup() override;
   void update() override;
   void dump_config() override;
diff --git a/esphome/components/hdc1080/hdc1080.h b/esphome/components/hdc1080/hdc1080.h
index 7ad0764f1f6..a5bece82c49 100644
--- a/esphome/components/hdc1080/hdc1080.h
+++ b/esphome/components/hdc1080/hdc1080.h
@@ -16,8 +16,6 @@ class HDC1080Component : public PollingComponent, public i2c::I2CDevice {
   void dump_config() override;
   void update() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
  protected:
   sensor::Sensor *temperature_{nullptr};
   sensor::Sensor *humidity_{nullptr};
diff --git a/esphome/components/hlw8012/hlw8012.cpp b/esphome/components/hlw8012/hlw8012.cpp
index f037ee9d8b9..d0fd697d8ff 100644
--- a/esphome/components/hlw8012/hlw8012.cpp
+++ b/esphome/components/hlw8012/hlw8012.cpp
@@ -48,7 +48,6 @@ void HLW8012Component::dump_config() {
   LOG_SENSOR("  ", "Power", this->power_sensor_);
   LOG_SENSOR("  ", "Energy", this->energy_sensor_);
 }
-float HLW8012Component::get_setup_priority() const { return setup_priority::DATA; }
 void HLW8012Component::update() {
   // HLW8012 has 50% duty cycle
   pulse_counter::pulse_counter_t raw_cf = this->cf_store_.read_raw_value();
diff --git a/esphome/components/hlw8012/hlw8012.h b/esphome/components/hlw8012/hlw8012.h
index 312391f533a..8a13ec07d8e 100644
--- a/esphome/components/hlw8012/hlw8012.h
+++ b/esphome/components/hlw8012/hlw8012.h
@@ -31,7 +31,6 @@ class HLW8012Component : public PollingComponent {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_initial_mode(HLW8012InitialMode initial_mode) {
diff --git a/esphome/components/hlw8012/sensor.py b/esphome/components/hlw8012/sensor.py
index 201ea4451f3..4727877633c 100644
--- a/esphome/components/hlw8012/sensor.py
+++ b/esphome/components/hlw8012/sensor.py
@@ -1,6 +1,7 @@
 from esphome import pins
 import esphome.codegen as cg
 from esphome.components import sensor
+from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHANGE_MODE_EVERY,
@@ -25,6 +26,7 @@ from esphome.const import (
     UNIT_WATT,
     UNIT_WATT_HOURS,
 )
+from esphome.core import CORE
 
 AUTO_LOAD = ["pulse_counter"]
 
@@ -91,6 +93,12 @@ CONFIG_SCHEMA = cv.Schema(
 
 
 async def to_code(config):
+    if CORE.is_esp32:
+        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
+        # HLW8012 uses pulse_counter's PCNT storage which requires driver/pcnt.h
+        # TODO: Remove this once pulse_counter migrates to new PCNT API (driver/pulse_cnt.h)
+        include_builtin_idf_component("driver")
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
diff --git a/esphome/components/hm3301/hm3301.cpp b/esphome/components/hm3301/hm3301.cpp
index 00fb85397c6..9343b47823f 100644
--- a/esphome/components/hm3301/hm3301.cpp
+++ b/esphome/components/hm3301/hm3301.cpp
@@ -31,8 +31,6 @@ void HM3301Component::dump_config() {
   LOG_SENSOR("  ", "AQI", this->aqi_sensor_);
 }
 
-float HM3301Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void HM3301Component::update() {
   if (this->read(data_buffer_, 29) != i2c::ERROR_OK) {
     ESP_LOGW(TAG, "Read result failed");
diff --git a/esphome/components/hm3301/hm3301.h b/esphome/components/hm3301/hm3301.h
index e155ed6b4b5..6b10a5e2373 100644
--- a/esphome/components/hm3301/hm3301.h
+++ b/esphome/components/hm3301/hm3301.h
@@ -23,7 +23,6 @@ class HM3301Component : public PollingComponent, public i2c::I2CDevice {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/hmc5883l/hmc5883l.cpp b/esphome/components/hmc5883l/hmc5883l.cpp
index 101493ad913..b62381a287f 100644
--- a/esphome/components/hmc5883l/hmc5883l.cpp
+++ b/esphome/components/hmc5883l/hmc5883l.cpp
@@ -83,7 +83,6 @@ void HMC5883LComponent::dump_config() {
   LOG_SENSOR("  ", "Z Axis", this->z_sensor_);
   LOG_SENSOR("  ", "Heading", this->heading_sensor_);
 }
-float HMC5883LComponent::get_setup_priority() const { return setup_priority::DATA; }
 void HMC5883LComponent::update() {
   uint16_t raw_x, raw_y, raw_z;
   if (!this->read_byte_16(HMC5883L_REGISTER_DATA_X_MSB, &raw_x) ||
diff --git a/esphome/components/hmc5883l/hmc5883l.h b/esphome/components/hmc5883l/hmc5883l.h
index 06fba2af9dc..8eae0f7a50c 100644
--- a/esphome/components/hmc5883l/hmc5883l.h
+++ b/esphome/components/hmc5883l/hmc5883l.h
@@ -39,7 +39,6 @@ class HMC5883LComponent : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_oversampling(HMC5883LOversampling oversampling) { oversampling_ = oversampling; }
diff --git a/esphome/components/homeassistant/time/homeassistant_time.cpp b/esphome/components/homeassistant/time/homeassistant_time.cpp
index e72c5a21f5b..d0398920736 100644
--- a/esphome/components/homeassistant/time/homeassistant_time.cpp
+++ b/esphome/components/homeassistant/time/homeassistant_time.cpp
@@ -11,8 +11,6 @@ void HomeassistantTime::dump_config() {
   RealTimeClock::dump_config();
 }
 
-float HomeassistantTime::get_setup_priority() const { return setup_priority::DATA; }
-
 void HomeassistantTime::setup() { global_homeassistant_time = this; }
 
 void HomeassistantTime::update() { api::global_api_server->request_time(); }
diff --git a/esphome/components/homeassistant/time/homeassistant_time.h b/esphome/components/homeassistant/time/homeassistant_time.h
index 36e28ea16b6..7b5842fefdb 100644
--- a/esphome/components/homeassistant/time/homeassistant_time.h
+++ b/esphome/components/homeassistant/time/homeassistant_time.h
@@ -13,7 +13,6 @@ class HomeassistantTime : public time::RealTimeClock {
   void update() override;
   void dump_config() override;
   void set_epoch_time(uint32_t epoch) { this->synchronize_epoch_(epoch); }
-  float get_setup_priority() const override;
 };
 
 extern HomeassistantTime *global_homeassistant_time;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
diff --git a/esphome/components/honeywell_hih_i2c/honeywell_hih.cpp b/esphome/components/honeywell_hih_i2c/honeywell_hih.cpp
index 5f2b0099722..904672d1369 100644
--- a/esphome/components/honeywell_hih_i2c/honeywell_hih.cpp
+++ b/esphome/components/honeywell_hih_i2c/honeywell_hih.cpp
@@ -91,7 +91,5 @@ void HoneywellHIComponent::dump_config() {
   LOG_UPDATE_INTERVAL(this);
 }
 
-float HoneywellHIComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace honeywell_hih_i2c
 }  // namespace esphome
diff --git a/esphome/components/honeywell_hih_i2c/honeywell_hih.h b/esphome/components/honeywell_hih_i2c/honeywell_hih.h
index 4457eab1da1..79140f7399e 100644
--- a/esphome/components/honeywell_hih_i2c/honeywell_hih.h
+++ b/esphome/components/honeywell_hih_i2c/honeywell_hih.h
@@ -11,7 +11,6 @@ namespace honeywell_hih_i2c {
 class HoneywellHIComponent : public PollingComponent, public i2c::I2CDevice {
  public:
   void dump_config() override;
-  float get_setup_priority() const override;
   void loop() override;
   void update() override;
 
diff --git a/esphome/components/host/preferences.cpp b/esphome/components/host/preferences.cpp
index 7b939cdebb3..5ad87c1f2a0 100644
--- a/esphome/components/host/preferences.cpp
+++ b/esphome/components/host/preferences.cpp
@@ -66,10 +66,11 @@ ESPPreferenceObject HostPreferences::make_preference(size_t length, uint32_t typ
   return ESPPreferenceObject(backend);
 };
 
+static HostPreferences s_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 void setup_preferences() {
-  auto *pref = new HostPreferences();  // NOLINT(cppcoreguidelines-owning-memory)
-  host_preferences = pref;
-  global_preferences = pref;
+  host_preferences = &s_preferences;
+  global_preferences = &s_preferences;
 }
 
 bool HostPreferenceBackend::save(const uint8_t *data, size_t len) {
diff --git a/esphome/components/hte501/hte501.cpp b/esphome/components/hte501/hte501.cpp
index cde68861098..972e72c170a 100644
--- a/esphome/components/hte501/hte501.cpp
+++ b/esphome/components/hte501/hte501.cpp
@@ -43,7 +43,6 @@ void HTE501Component::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
-float HTE501Component::get_setup_priority() const { return setup_priority::DATA; }
 void HTE501Component::update() {
   uint8_t address_1[] = {0x2C, 0x1B};
   this->write(address_1, 2);
diff --git a/esphome/components/hte501/hte501.h b/esphome/components/hte501/hte501.h
index a7072d5bdbd..b47daf9157c 100644
--- a/esphome/components/hte501/hte501.h
+++ b/esphome/components/hte501/hte501.h
@@ -13,7 +13,6 @@ class HTE501Component : public PollingComponent, public i2c::I2CDevice {
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_humidity_sensor(sensor::Sensor *humidity_sensor) { humidity_sensor_ = humidity_sensor; }
 
-  float get_setup_priority() const override;
   void setup() override;
   void dump_config() override;
   void update() override;
diff --git a/esphome/components/http_request/http_request.h b/esphome/components/http_request/http_request.h
index fb39ca504cd..c88360ca786 100644
--- a/esphome/components/http_request/http_request.h
+++ b/esphome/components/http_request/http_request.h
@@ -26,6 +26,7 @@ struct Header {
 enum HttpStatus {
   HTTP_STATUS_OK = 200,
   HTTP_STATUS_NO_CONTENT = 204,
+  HTTP_STATUS_RESET_CONTENT = 205,
   HTTP_STATUS_PARTIAL_CONTENT = 206,
 
   /* 3xx - Redirection */
@@ -126,19 +127,21 @@ struct HttpReadResult {
 
 /// Result of processing a non-blocking read with timeout (for manual loops)
 enum class HttpReadLoopResult : uint8_t {
-  DATA,     ///< Data was read, process it
-  RETRY,    ///< No data yet, already delayed, caller should continue loop
-  ERROR,    ///< Read error, caller should exit loop
-  TIMEOUT,  ///< Timeout waiting for data, caller should exit loop
+  DATA,      ///< Data was read, process it
+  COMPLETE,  ///< All content has been read, caller should exit loop
+  RETRY,     ///< No data yet, already delayed, caller should continue loop
+  ERROR,     ///< Read error, caller should exit loop
+  TIMEOUT,   ///< Timeout waiting for data, caller should exit loop
 };
 
 /// Process a read result with timeout tracking and delay handling
 /// @param bytes_read_or_error Return value from read() - positive for bytes read, negative for error
 /// @param last_data_time Time of last successful read, updated when data received
 /// @param timeout_ms Maximum time to wait for data
-/// @return DATA if data received, RETRY if should continue loop, ERROR/TIMEOUT if should exit
-inline HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_t &last_data_time,
-                                                uint32_t timeout_ms) {
+/// @param is_read_complete Whether all expected content has been read (from HttpContainer::is_read_complete())
+/// @return How the caller should proceed - see HttpReadLoopResult enum
+inline HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_t &last_data_time, uint32_t timeout_ms,
+                                                bool is_read_complete) {
   if (bytes_read_or_error > 0) {
     last_data_time = millis();
     return HttpReadLoopResult::DATA;
@@ -146,7 +149,10 @@ inline HttpReadLoopResult http_read_loop_result(int bytes_read_or_error, uint32_
   if (bytes_read_or_error < 0) {
     return HttpReadLoopResult::ERROR;
   }
-  // bytes_read_or_error == 0: no data available yet
+  // bytes_read_or_error == 0: either "no data yet" or "all content read"
+  if (is_read_complete) {
+    return HttpReadLoopResult::COMPLETE;
+  }
   if (millis() - last_data_time >= timeout_ms) {
     return HttpReadLoopResult::TIMEOUT;
   }
@@ -159,9 +165,9 @@ class HttpRequestComponent;
 class HttpContainer : public Parented<HttpRequestComponent> {
  public:
   virtual ~HttpContainer() = default;
-  size_t content_length;
-  int status_code;
-  uint32_t duration_ms;
+  size_t content_length{0};
+  int status_code{-1};  ///< -1 indicates no response received yet
+  uint32_t duration_ms{0};
 
   /**
    * @brief Read data from the HTTP response body.
@@ -194,9 +200,24 @@ class HttpContainer : public Parented<HttpRequestComponent> {
   virtual void end() = 0;
 
   void set_secure(bool secure) { this->secure_ = secure; }
+  void set_chunked(bool chunked) { this->is_chunked_ = chunked; }
 
   size_t get_bytes_read() const { return this->bytes_read_; }
 
+  /// Check if all expected content has been read
+  /// For chunked responses, returns false (completion detected via read() returning error/EOF)
+  bool is_read_complete() const {
+    // Per RFC 9112, these responses have no body:
+    // - 1xx (Informational), 204 No Content, 205 Reset Content, 304 Not Modified
+    if ((this->status_code >= 100 && this->status_code < 200) || this->status_code == HTTP_STATUS_NO_CONTENT ||
+        this->status_code == HTTP_STATUS_RESET_CONTENT || this->status_code == HTTP_STATUS_NOT_MODIFIED) {
+      return true;
+    }
+    // For non-chunked responses, complete when bytes_read >= content_length
+    // This handles both Content-Length: 0 and Content-Length: N cases
+    return !this->is_chunked_ && this->bytes_read_ >= this->content_length;
+  }
+
   /**
    * @brief Get response headers.
    *
@@ -209,6 +230,7 @@ class HttpContainer : public Parented<HttpRequestComponent> {
  protected:
   size_t bytes_read_{0};
   bool secure_{false};
+  bool is_chunked_{false};  ///< True if response uses chunked transfer encoding
   std::map<std::string, std::list<std::string>> response_headers_{};
 };
 
@@ -219,7 +241,7 @@ class HttpContainer : public Parented<HttpRequestComponent> {
 /// @param total_size Total bytes to read
 /// @param chunk_size Maximum bytes per read call
 /// @param timeout_ms Read timeout in milliseconds
-/// @return HttpReadResult with status and error_code on failure
+/// @return HttpReadResult with status and error_code on failure; use container->get_bytes_read() for total bytes read
 inline HttpReadResult http_read_fully(HttpContainer *container, uint8_t *buffer, size_t total_size, size_t chunk_size,
                                       uint32_t timeout_ms) {
   size_t read_index = 0;
@@ -231,9 +253,11 @@ inline HttpReadResult http_read_fully(HttpContainer *container, uint8_t *buffer,
     App.feed_wdt();
     yield();
 
-    auto result = http_read_loop_result(read_bytes_or_error, last_data_time, timeout_ms);
+    auto result = http_read_loop_result(read_bytes_or_error, last_data_time, timeout_ms, container->is_read_complete());
     if (result == HttpReadLoopResult::RETRY)
       continue;
+    if (result == HttpReadLoopResult::COMPLETE)
+      break;  // Server sent less data than requested, but transfer is complete
     if (result == HttpReadLoopResult::ERROR)
       return {HttpReadStatus::ERROR, read_bytes_or_error};
     if (result == HttpReadLoopResult::TIMEOUT)
@@ -332,13 +356,13 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   void set_json(std::function<void(Ts..., JsonObject)> json_func) { this->json_func_ = json_func; }
 
 #ifdef USE_HTTP_REQUEST_RESPONSE
-  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *get_success_trigger_with_response() const {
-    return this->success_trigger_with_response_;
+  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *get_success_trigger_with_response() {
+    return &this->success_trigger_with_response_;
   }
 #endif
-  Trigger<std::shared_ptr<HttpContainer>, Ts...> *get_success_trigger() const { return this->success_trigger_; }
+  Trigger<std::shared_ptr<HttpContainer>, Ts...> *get_success_trigger() { return &this->success_trigger_; }
 
-  Trigger<Ts...> *get_error_trigger() const { return this->error_trigger_; }
+  Trigger<Ts...> *get_error_trigger() { return &this->error_trigger_; }
 
   void set_max_response_buffer_size(size_t max_response_buffer_size) {
     this->max_response_buffer_size_ = max_response_buffer_size;
@@ -372,7 +396,7 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
     auto captured_args = std::make_tuple(x...);
 
     if (container == nullptr) {
-      std::apply([this](Ts... captured_args_inner) { this->error_trigger_->trigger(captured_args_inner...); },
+      std::apply([this](Ts... captured_args_inner) { this->error_trigger_.trigger(captured_args_inner...); },
                  captured_args);
       return;
     }
@@ -393,11 +417,12 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
           int read_or_error = container->read(buf + read_index, std::min<size_t>(max_length - read_index, 512));
           App.feed_wdt();
           yield();
-          auto result = http_read_loop_result(read_or_error, last_data_time, read_timeout);
+          auto result =
+              http_read_loop_result(read_or_error, last_data_time, read_timeout, container->is_read_complete());
           if (result == HttpReadLoopResult::RETRY)
             continue;
           if (result != HttpReadLoopResult::DATA)
-            break;  // ERROR or TIMEOUT
+            break;  // COMPLETE, ERROR, or TIMEOUT
           read_index += read_or_error;
         }
         response_body.reserve(read_index);
@@ -406,14 +431,14 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
       }
       std::apply(
           [this, &container, &response_body](Ts... captured_args_inner) {
-            this->success_trigger_with_response_->trigger(container, response_body, captured_args_inner...);
+            this->success_trigger_with_response_.trigger(container, response_body, captured_args_inner...);
           },
           captured_args);
     } else
 #endif
     {
       std::apply([this, &container](
-                     Ts... captured_args_inner) { this->success_trigger_->trigger(container, captured_args_inner...); },
+                     Ts... captured_args_inner) { this->success_trigger_.trigger(container, captured_args_inner...); },
                  captured_args);
     }
     container->end();
@@ -433,12 +458,10 @@ template<typename... Ts> class HttpRequestSendAction : public Action<Ts...> {
   std::map<const char *, TemplatableValue<std::string, Ts...>> json_{};
   std::function<void(Ts..., JsonObject)> json_func_{nullptr};
 #ifdef USE_HTTP_REQUEST_RESPONSE
-  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> *success_trigger_with_response_ =
-      new Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...>();
+  Trigger<std::shared_ptr<HttpContainer>, std::string &, Ts...> success_trigger_with_response_;
 #endif
-  Trigger<std::shared_ptr<HttpContainer>, Ts...> *success_trigger_ =
-      new Trigger<std::shared_ptr<HttpContainer>, Ts...>();
-  Trigger<Ts...> *error_trigger_ = new Trigger<Ts...>();
+  Trigger<std::shared_ptr<HttpContainer>, Ts...> success_trigger_;
+  Trigger<Ts...> error_trigger_;
 
   size_t max_response_buffer_size_{SIZE_MAX};
 };
diff --git a/esphome/components/http_request/http_request_arduino.cpp b/esphome/components/http_request/http_request_arduino.cpp
index 82538b2cb39..2f12b58766b 100644
--- a/esphome/components/http_request/http_request_arduino.cpp
+++ b/esphome/components/http_request/http_request_arduino.cpp
@@ -135,9 +135,23 @@ std::shared_ptr<HttpContainer> HttpRequestArduino::perform(const std::string &ur
   // When cast to size_t, -1 becomes SIZE_MAX (4294967295 on 32-bit).
   // The read() method handles this: bytes_read_ can never reach SIZE_MAX, so the
   // early return check (bytes_read_ >= content_length) will never trigger.
+  //
+  // TODO: Chunked transfer encoding is NOT properly supported on Arduino.
+  // The implementation in #7884 was incomplete - it only works correctly on ESP-IDF where
+  // esp_http_client_read() decodes chunks internally. On Arduino, using getStreamPtr()
+  // returns raw TCP data with chunk framing (e.g., "12a\r\n{json}\r\n0\r\n\r\n") instead
+  // of decoded content. This wasn't noticed because requests would complete and payloads
+  // were only examined on IDF. The long transfer times were also masked by the misleading
+  // "HTTP on Arduino version >= 3.1 is **very** slow" warning above. This causes two issues:
+  // 1. Response body is corrupted - contains chunk size headers mixed with data
+  // 2. Cannot detect end of transfer - connection stays open (keep-alive), causing timeout
+  // The proper fix would be to use getString() for chunked responses, which decodes chunks
+  // internally, but this buffers the entire response in memory.
   int content_length = container->client_.getSize();
   ESP_LOGD(TAG, "Content-Length: %d", content_length);
   container->content_length = (size_t) content_length;
+  // -1 (SIZE_MAX when cast to size_t) means chunked transfer encoding
+  container->set_chunked(content_length == -1);
   container->duration_ms = millis() - start;
 
   return container;
@@ -178,9 +192,9 @@ int HttpContainerArduino::read(uint8_t *buf, size_t max_len) {
 
   if (bufsize == 0) {
     this->duration_ms += (millis() - start);
-    // Check if we've read all expected content (only valid when content_length is known and not SIZE_MAX)
-    // For chunked encoding (content_length == SIZE_MAX), we can't use this check
-    if (this->content_length > 0 && this->bytes_read_ >= this->content_length) {
+    // Check if we've read all expected content (non-chunked only)
+    // For chunked encoding (content_length == SIZE_MAX), is_read_complete() returns false
+    if (this->is_read_complete()) {
       return 0;  // All content read successfully
     }
     // No data available - check if connection is still open
diff --git a/esphome/components/http_request/http_request_idf.cpp b/esphome/components/http_request/http_request_idf.cpp
index 2b4dee953a3..bd12b7d1231 100644
--- a/esphome/components/http_request/http_request_idf.cpp
+++ b/esphome/components/http_request/http_request_idf.cpp
@@ -160,6 +160,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   // esp_http_client_fetch_headers() returns 0 for chunked transfer encoding (no Content-Length header).
   // The read() method handles content_length == 0 specially to support chunked responses.
   container->content_length = esp_http_client_fetch_headers(client);
+  container->set_chunked(esp_http_client_is_chunked_response(client));
   container->feed_wdt();
   container->status_code = esp_http_client_get_status_code(client);
   container->feed_wdt();
@@ -195,6 +196,7 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
 
       container->feed_wdt();
       container->content_length = esp_http_client_fetch_headers(client);
+      container->set_chunked(esp_http_client_is_chunked_response(client));
       container->feed_wdt();
       container->status_code = esp_http_client_get_status_code(client);
       container->feed_wdt();
@@ -239,10 +241,9 @@ int HttpContainerIDF::read(uint8_t *buf, size_t max_len) {
   const uint32_t start = millis();
   watchdog::WatchdogManager wdm(this->parent_->get_watchdog_timeout());
 
-  // Check if we've already read all expected content
-  // Skip this check when content_length is 0 (chunked transfer encoding or unknown length)
-  // For chunked responses, esp_http_client_read() will return 0 when all data is received
-  if (this->content_length > 0 && this->bytes_read_ >= this->content_length) {
+  // Check if we've already read all expected content (non-chunked only)
+  // For chunked responses (content_length == 0), esp_http_client_read() handles EOF
+  if (this->is_read_complete()) {
     return 0;  // All content read successfully
   }
 
diff --git a/esphome/components/http_request/ota/ota_http_request.cpp b/esphome/components/http_request/ota/ota_http_request.cpp
index 8a4b3684cf9..8f4ecfab2db 100644
--- a/esphome/components/http_request/ota/ota_http_request.cpp
+++ b/esphome/components/http_request/ota/ota_http_request.cpp
@@ -130,9 +130,13 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
     App.feed_wdt();
     yield();
 
-    auto result = http_read_loop_result(bufsize_or_error, last_data_time, read_timeout);
+    auto result = http_read_loop_result(bufsize_or_error, last_data_time, read_timeout, container->is_read_complete());
     if (result == HttpReadLoopResult::RETRY)
       continue;
+    // Note: COMPLETE is currently unreachable since the loop condition checks bytes_read < content_length,
+    // but this is defensive code in case chunked transfer encoding support is added for OTA in the future.
+    if (result == HttpReadLoopResult::COMPLETE)
+      break;
     if (result != HttpReadLoopResult::DATA) {
       if (result == HttpReadLoopResult::TIMEOUT) {
         ESP_LOGE(TAG, "Timeout reading data");
diff --git a/esphome/components/htu21d/htu21d.cpp b/esphome/components/htu21d/htu21d.cpp
index c5d91d3dd0d..58a28b213f7 100644
--- a/esphome/components/htu21d/htu21d.cpp
+++ b/esphome/components/htu21d/htu21d.cpp
@@ -143,7 +143,5 @@ uint8_t HTU21DComponent::get_heater_level() {
   return raw_heater & 0xF;
 }
 
-float HTU21DComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace htu21d
 }  // namespace esphome
diff --git a/esphome/components/htu21d/htu21d.h b/esphome/components/htu21d/htu21d.h
index 277c6ca3e5f..594be783261 100644
--- a/esphome/components/htu21d/htu21d.h
+++ b/esphome/components/htu21d/htu21d.h
@@ -28,8 +28,6 @@ class HTU21DComponent : public PollingComponent, public i2c::I2CDevice {
   void set_heater_level(uint8_t level);
   uint8_t get_heater_level();
 
-  float get_setup_priority() const override;
-
  protected:
   sensor::Sensor *temperature_{nullptr};
   sensor::Sensor *humidity_{nullptr};
diff --git a/esphome/components/htu31d/htu31d.cpp b/esphome/components/htu31d/htu31d.cpp
index 562078aacb5..4bb38a11a20 100644
--- a/esphome/components/htu31d/htu31d.cpp
+++ b/esphome/components/htu31d/htu31d.cpp
@@ -259,11 +259,5 @@ void HTU31DComponent::set_heater_state(bool desired) {
   }
 }
 
-/**
- * Sets the startup priority for this component.
- *
- * @returns The startup priority
- */
-float HTU31DComponent::get_setup_priority() const { return setup_priority::DATA; }
 }  // namespace htu31d
 }  // namespace esphome
diff --git a/esphome/components/htu31d/htu31d.h b/esphome/components/htu31d/htu31d.h
index 9462133ced9..24d85243cc1 100644
--- a/esphome/components/htu31d/htu31d.h
+++ b/esphome/components/htu31d/htu31d.h
@@ -20,8 +20,6 @@ class HTU31DComponent : public PollingComponent, public i2c::I2CDevice {
   void set_heater_state(bool desired);
   bool is_heater_enabled();
 
-  float get_setup_priority() const override;
-
  protected:
   bool reset_();
   uint32_t read_serial_num_();
diff --git a/esphome/components/hx711/hx711.cpp b/esphome/components/hx711/hx711.cpp
index 67ec4549df0..f2e3234127d 100644
--- a/esphome/components/hx711/hx711.cpp
+++ b/esphome/components/hx711/hx711.cpp
@@ -22,7 +22,6 @@ void HX711Sensor::dump_config() {
   LOG_PIN("  SCK Pin: ", this->sck_pin_);
   LOG_UPDATE_INTERVAL(this);
 }
-float HX711Sensor::get_setup_priority() const { return setup_priority::DATA; }
 void HX711Sensor::update() {
   uint32_t result;
   if (this->read_sensor_(&result)) {
diff --git a/esphome/components/hx711/hx711.h b/esphome/components/hx711/hx711.h
index a92bb9945d2..37723ee81fc 100644
--- a/esphome/components/hx711/hx711.h
+++ b/esphome/components/hx711/hx711.h
@@ -23,7 +23,6 @@ class HX711Sensor : public sensor::Sensor, public PollingComponent {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp b/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
index 4872d686105..983a0a66493 100644
--- a/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
+++ b/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
@@ -284,7 +284,5 @@ void HydreonRGxxComponent::process_line_() {
   }
 }
 
-float HydreonRGxxComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace hydreon_rgxx
 }  // namespace esphome
diff --git a/esphome/components/hydreon_rgxx/hydreon_rgxx.h b/esphome/components/hydreon_rgxx/hydreon_rgxx.h
index 76b0985a245..e3f9798a937 100644
--- a/esphome/components/hydreon_rgxx/hydreon_rgxx.h
+++ b/esphome/components/hydreon_rgxx/hydreon_rgxx.h
@@ -53,8 +53,6 @@ class HydreonRGxxComponent : public PollingComponent, public uart::UARTDevice {
   void setup() override;
   void dump_config() override;
 
-  float get_setup_priority() const override;
-
   void set_disable_led(bool disable_led) { this->disable_led_ = disable_led; }
 
  protected:
diff --git a/esphome/components/hyt271/hyt271.cpp b/esphome/components/hyt271/hyt271.cpp
index f187e054a85..4c0e3cd96e0 100644
--- a/esphome/components/hyt271/hyt271.cpp
+++ b/esphome/components/hyt271/hyt271.cpp
@@ -46,7 +46,5 @@ void HYT271Component::update() {
     this->status_clear_warning();
   });
 }
-float HYT271Component::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace hyt271
 }  // namespace esphome
diff --git a/esphome/components/hyt271/hyt271.h b/esphome/components/hyt271/hyt271.h
index 64f32a651c1..19409d830cb 100644
--- a/esphome/components/hyt271/hyt271.h
+++ b/esphome/components/hyt271/hyt271.h
@@ -16,8 +16,6 @@ class HYT271Component : public PollingComponent, public i2c::I2CDevice {
   /// Update the sensor values (temperature+humidity).
   void update() override;
 
-  float get_setup_priority() const override;
-
  protected:
   sensor::Sensor *temperature_{nullptr};
   sensor::Sensor *humidity_{nullptr};
diff --git a/esphome/components/i2c/__init__.py b/esphome/components/i2c/__init__.py
index 19efda0b492..de3f2be6740 100644
--- a/esphome/components/i2c/__init__.py
+++ b/esphome/components/i2c/__init__.py
@@ -183,7 +183,7 @@ async def to_code(config):
     if CORE.using_zephyr:
         zephyr_add_prj_conf("I2C", True)
         i2c = "i2c0"
-        if zephyr_data()[KEY_BOARD] in ["xiao_ble"]:
+        if zephyr_data()[KEY_BOARD] == "xiao_ble":
             i2c = "i2c1"
         zephyr_add_overlay(
             f"""
diff --git a/esphome/components/i2s_audio/media_player/__init__.py b/esphome/components/i2s_audio/media_player/__init__.py
index 35c42e1b06e..426b211f475 100644
--- a/esphome/components/i2s_audio/media_player/__init__.py
+++ b/esphome/components/i2s_audio/media_player/__init__.py
@@ -114,6 +114,7 @@ async def to_code(config):
         cg.add(var.set_external_dac_channels(2 if config[CONF_MODE] == "stereo" else 1))
         cg.add(var.set_i2s_comm_fmt_lsb(config[CONF_I2S_COMM_FMT] == "lsb"))
 
+    cg.add_library("WiFi", None)
     cg.add_library("NetworkClientSecure", None)
     cg.add_library("HTTPClient", None)
     cg.add_library("esphome/ESP32-audioI2S", "2.3.0")
diff --git a/esphome/components/ina219/ina219.cpp b/esphome/components/ina219/ina219.cpp
index ea8c5cea9d9..278017651bb 100644
--- a/esphome/components/ina219/ina219.cpp
+++ b/esphome/components/ina219/ina219.cpp
@@ -151,8 +151,6 @@ void INA219Component::dump_config() {
   LOG_SENSOR("  ", "Power", this->power_sensor_);
 }
 
-float INA219Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void INA219Component::update() {
   if (this->bus_voltage_sensor_ != nullptr) {
     uint16_t raw_bus_voltage;
diff --git a/esphome/components/ina219/ina219.h b/esphome/components/ina219/ina219.h
index 115fa886e07..bcadb65e36b 100644
--- a/esphome/components/ina219/ina219.h
+++ b/esphome/components/ina219/ina219.h
@@ -13,7 +13,6 @@ class INA219Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void on_powerdown() override;
 
diff --git a/esphome/components/ina226/ina226.cpp b/esphome/components/ina226/ina226.cpp
index c4d4fb896e7..cbc44c9a1aa 100644
--- a/esphome/components/ina226/ina226.cpp
+++ b/esphome/components/ina226/ina226.cpp
@@ -104,8 +104,6 @@ void INA226Component::dump_config() {
   LOG_SENSOR("  ", "Power", this->power_sensor_);
 }
 
-float INA226Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void INA226Component::update() {
   if (this->bus_voltage_sensor_ != nullptr) {
     uint16_t raw_bus_voltage;
diff --git a/esphome/components/ina226/ina226.h b/esphome/components/ina226/ina226.h
index 61214fea0e4..0aa66ff765f 100644
--- a/esphome/components/ina226/ina226.h
+++ b/esphome/components/ina226/ina226.h
@@ -45,7 +45,6 @@ class INA226Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_shunt_resistance_ohm(float shunt_resistance_ohm) { shunt_resistance_ohm_ = shunt_resistance_ohm; }
diff --git a/esphome/components/ina2xx_base/ina2xx_base.cpp b/esphome/components/ina2xx_base/ina2xx_base.cpp
index 7185d218104..de01c99a191 100644
--- a/esphome/components/ina2xx_base/ina2xx_base.cpp
+++ b/esphome/components/ina2xx_base/ina2xx_base.cpp
@@ -79,8 +79,6 @@ void INA2XX::setup() {
   this->state_ = State::IDLE;
 }
 
-float INA2XX::get_setup_priority() const { return setup_priority::DATA; }
-
 void INA2XX::update() {
   ESP_LOGD(TAG, "Updating");
   if (this->is_ready() && this->state_ == State::IDLE) {
diff --git a/esphome/components/ina2xx_base/ina2xx_base.h b/esphome/components/ina2xx_base/ina2xx_base.h
index ba0999b28e2..104c384a0d2 100644
--- a/esphome/components/ina2xx_base/ina2xx_base.h
+++ b/esphome/components/ina2xx_base/ina2xx_base.h
@@ -114,7 +114,6 @@ enum INAModel : uint8_t { INA_UNKNOWN = 0, INA_228, INA_229, INA_238, INA_239, I
 class INA2XX : public PollingComponent {
  public:
   void setup() override;
-  float get_setup_priority() const override;
   void update() override;
   void loop() override;
   void dump_config() override;
diff --git a/esphome/components/ina3221/ina3221.cpp b/esphome/components/ina3221/ina3221.cpp
index 8243764147d..d03183e002e 100644
--- a/esphome/components/ina3221/ina3221.cpp
+++ b/esphome/components/ina3221/ina3221.cpp
@@ -113,7 +113,6 @@ void INA3221Component::update() {
   }
 }
 
-float INA3221Component::get_setup_priority() const { return setup_priority::DATA; }
 void INA3221Component::set_shunt_resistance(int channel, float resistance_ohm) {
   this->channels_[channel].shunt_resistance_ = resistance_ohm;
 }
diff --git a/esphome/components/ina3221/ina3221.h b/esphome/components/ina3221/ina3221.h
index f593badc09c..3769df77aa8 100644
--- a/esphome/components/ina3221/ina3221.h
+++ b/esphome/components/ina3221/ina3221.h
@@ -12,7 +12,6 @@ class INA3221Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
   void update() override;
-  float get_setup_priority() const override;
 
   void set_bus_voltage_sensor(int channel, sensor::Sensor *obj) { this->channels_[channel].bus_voltage_sensor_ = obj; }
   void set_shunt_voltage_sensor(int channel, sensor::Sensor *obj) {
diff --git a/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp b/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp
index e5fa035682b..534939f9af5 100644
--- a/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp
+++ b/esphome/components/kamstrup_kmp/kamstrup_kmp.cpp
@@ -30,8 +30,6 @@ void KamstrupKMPComponent::dump_config() {
   this->check_uart_settings(1200, 2, uart::UART_CONFIG_PARITY_NONE, 8);
 }
 
-float KamstrupKMPComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void KamstrupKMPComponent::update() {
   if (this->heat_energy_sensor_ != nullptr) {
     this->command_queue_.push(CMD_HEAT_ENERGY);
diff --git a/esphome/components/kamstrup_kmp/kamstrup_kmp.h b/esphome/components/kamstrup_kmp/kamstrup_kmp.h
index c9cc9c5a394..f84e3601323 100644
--- a/esphome/components/kamstrup_kmp/kamstrup_kmp.h
+++ b/esphome/components/kamstrup_kmp/kamstrup_kmp.h
@@ -83,7 +83,6 @@ class KamstrupKMPComponent : public PollingComponent, public uart::UARTDevice {
   void set_flow_sensor(sensor::Sensor *sensor) { this->flow_sensor_ = sensor; }
   void set_volume_sensor(sensor::Sensor *sensor) { this->volume_sensor_ = sensor; }
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void loop() override;
   void add_custom_sensor(sensor::Sensor *sensor, uint16_t command) {
diff --git a/esphome/components/key_collector/__init__.py b/esphome/components/key_collector/__init__.py
index 17af40da1a1..badb28c32ca 100644
--- a/esphome/components/key_collector/__init__.py
+++ b/esphome/components/key_collector/__init__.py
@@ -1,4 +1,7 @@
+from dataclasses import dataclass
+
 from esphome import automation
+from esphome.automation import Trigger
 import esphome.codegen as cg
 from esphome.components import key_provider
 import esphome.config_validation as cv
@@ -10,7 +13,10 @@ from esphome.const import (
     CONF_ON_TIMEOUT,
     CONF_SOURCE_ID,
     CONF_TIMEOUT,
+    CONF_TRIGGER_ID,
 )
+from esphome.cpp_generator import MockObj, literal
+from esphome.types import TemplateArgsType
 
 CODEOWNERS = ["@ssieb"]
 
@@ -32,22 +38,50 @@ KeyCollector = key_collector_ns.class_("KeyCollector", cg.Component)
 EnableAction = key_collector_ns.class_("EnableAction", automation.Action)
 DisableAction = key_collector_ns.class_("DisableAction", automation.Action)
 
+X_TYPE = cg.std_string_ref.operator("const")
+
+
+@dataclass
+class Argument:
+    type: MockObj
+    name: str
+
+
+TRIGGER_TYPES = {
+    CONF_ON_PROGRESS: [Argument(X_TYPE, "x"), Argument(cg.uint8, "start")],
+    CONF_ON_RESULT: [
+        Argument(X_TYPE, "x"),
+        Argument(cg.uint8, "start"),
+        Argument(cg.uint8, "end"),
+    ],
+    CONF_ON_TIMEOUT: [Argument(X_TYPE, "x"), Argument(cg.uint8, "start")],
+}
+
 CONFIG_SCHEMA = cv.All(
     cv.COMPONENT_SCHEMA.extend(
         {
             cv.GenerateID(): cv.declare_id(KeyCollector),
-            cv.Optional(CONF_SOURCE_ID): cv.use_id(key_provider.KeyProvider),
-            cv.Optional(CONF_MIN_LENGTH): cv.int_,
-            cv.Optional(CONF_MAX_LENGTH): cv.int_,
+            cv.Optional(CONF_SOURCE_ID): cv.ensure_list(
+                cv.use_id(key_provider.KeyProvider)
+            ),
+            cv.Optional(CONF_MIN_LENGTH): cv.uint16_t,
+            cv.Optional(CONF_MAX_LENGTH): cv.uint16_t,
             cv.Optional(CONF_START_KEYS): cv.string,
             cv.Optional(CONF_END_KEYS): cv.string,
             cv.Optional(CONF_END_KEY_REQUIRED): cv.boolean,
             cv.Optional(CONF_BACK_KEYS): cv.string,
             cv.Optional(CONF_CLEAR_KEYS): cv.string,
             cv.Optional(CONF_ALLOWED_KEYS): cv.string,
-            cv.Optional(CONF_ON_PROGRESS): automation.validate_automation(single=True),
-            cv.Optional(CONF_ON_RESULT): automation.validate_automation(single=True),
-            cv.Optional(CONF_ON_TIMEOUT): automation.validate_automation(single=True),
+            **{
+                cv.Optional(trigger_type): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            Trigger.template(*[arg.type for arg in args])
+                        ),
+                    }
+                )
+                for trigger_type, args in TRIGGER_TYPES.items()
+            },
             cv.Optional(CONF_TIMEOUT): cv.positive_time_period_milliseconds,
             cv.Optional(CONF_ENABLE_ON_BOOT, default=True): cv.boolean,
         }
@@ -59,9 +93,9 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-    if CONF_SOURCE_ID in config:
-        source = await cg.get_variable(config[CONF_SOURCE_ID])
-        cg.add(var.set_provider(source))
+    for source_conf in config.get(CONF_SOURCE_ID, ()):
+        source = await cg.get_variable(source_conf)
+        cg.add(var.add_provider(source))
     if CONF_MIN_LENGTH in config:
         cg.add(var.set_min_length(config[CONF_MIN_LENGTH]))
     if CONF_MAX_LENGTH in config:
@@ -78,26 +112,25 @@ async def to_code(config):
         cg.add(var.set_clear_keys(config[CONF_CLEAR_KEYS]))
     if CONF_ALLOWED_KEYS in config:
         cg.add(var.set_allowed_keys(config[CONF_ALLOWED_KEYS]))
-    if CONF_ON_PROGRESS in config:
-        await automation.build_automation(
-            var.get_progress_trigger(),
-            [(cg.std_string, "x"), (cg.uint8, "start")],
-            config[CONF_ON_PROGRESS],
-        )
-    if CONF_ON_RESULT in config:
-        await automation.build_automation(
-            var.get_result_trigger(),
-            [(cg.std_string, "x"), (cg.uint8, "start"), (cg.uint8, "end")],
-            config[CONF_ON_RESULT],
-        )
-    if CONF_ON_TIMEOUT in config:
-        await automation.build_automation(
-            var.get_timeout_trigger(),
-            [(cg.std_string, "x"), (cg.uint8, "start")],
-            config[CONF_ON_TIMEOUT],
-        )
-    if CONF_TIMEOUT in config:
-        cg.add(var.set_timeout(config[CONF_TIMEOUT]))
+
+    for trigger_name, args in TRIGGER_TYPES.items():
+        arglist: TemplateArgsType = [(arg.type, arg.name) for arg in args]
+        for conf in config.get(trigger_name, ()):
+            trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID])
+            add_trig = getattr(
+                var,
+                f"add_on_{trigger_name.rsplit('_', maxsplit=1)[-1].lower()}_callback",
+            )
+            await automation.build_automation(
+                trigger,
+                arglist,
+                conf,
+            )
+            lamb = trigger.trigger(*[literal(arg.name) for arg in args])
+            cg.add(add_trig(await cg.process_lambda(lamb, arglist)))
+
+    if timeout := config.get(CONF_TIMEOUT):
+        cg.add(var.set_timeout(timeout))
     cg.add(var.set_enabled(config[CONF_ENABLE_ON_BOOT]))
 
 
diff --git a/esphome/components/key_collector/key_collector.cpp b/esphome/components/key_collector/key_collector.cpp
index 9cfc74f50ed..68d1c60bf94 100644
--- a/esphome/components/key_collector/key_collector.cpp
+++ b/esphome/components/key_collector/key_collector.cpp
@@ -7,15 +7,10 @@ namespace key_collector {
 
 static const char *const TAG = "key_collector";
 
-KeyCollector::KeyCollector()
-    : progress_trigger_(new Trigger<std::string, uint8_t>()),
-      result_trigger_(new Trigger<std::string, uint8_t, uint8_t>()),
-      timeout_trigger_(new Trigger<std::string, uint8_t>()) {}
-
 void KeyCollector::loop() {
   if ((this->timeout_ == 0) || this->result_.empty() || (millis() - this->last_key_time_ < this->timeout_))
     return;
-  this->timeout_trigger_->trigger(this->result_, this->start_key_);
+  this->timeout_callbacks_.call(this->result_, this->start_key_);
   this->clear();
 }
 
@@ -43,64 +38,68 @@ void KeyCollector::dump_config() {
     ESP_LOGCONFIG(TAG, "  entry timeout: %0.1f", this->timeout_ / 1000.0);
 }
 
-void KeyCollector::set_provider(key_provider::KeyProvider *provider) {
-  provider->add_on_key_callback([this](uint8_t key) { this->key_pressed_(key); });
+void KeyCollector::add_provider(key_provider::KeyProvider *provider) {
+  provider->add_on_key_callback([this](uint8_t key) { this->send_key(key); });
 }
 
 void KeyCollector::set_enabled(bool enabled) {
   this->enabled_ = enabled;
-  if (!enabled)
+  if (!enabled) {
     this->clear(false);
+  }
 }
 
 void KeyCollector::clear(bool progress_update) {
+  auto had_state = !this->result_.empty() || this->start_key_ != 0;
   this->result_.clear();
   this->start_key_ = 0;
-  if (progress_update)
-    this->progress_trigger_->trigger(this->result_, 0);
+  if (progress_update && had_state) {
+    this->progress_callbacks_.call(this->result_, 0);
+  }
+  this->disable_loop();
 }
 
-void KeyCollector::send_key(uint8_t key) { this->key_pressed_(key); }
-
-void KeyCollector::key_pressed_(uint8_t key) {
+void KeyCollector::send_key(uint8_t key) {
   if (!this->enabled_)
     return;
   this->last_key_time_ = millis();
   if (!this->start_keys_.empty() && !this->start_key_) {
     if (this->start_keys_.find(key) != std::string::npos) {
       this->start_key_ = key;
-      this->progress_trigger_->trigger(this->result_, this->start_key_);
+      this->progress_callbacks_.call(this->result_, this->start_key_);
     }
     return;
   }
   if (this->back_keys_.find(key) != std::string::npos) {
     if (!this->result_.empty()) {
       this->result_.pop_back();
-      this->progress_trigger_->trigger(this->result_, this->start_key_);
+      this->progress_callbacks_.call(this->result_, this->start_key_);
     }
     return;
   }
   if (this->clear_keys_.find(key) != std::string::npos) {
-    if (!this->result_.empty())
-      this->clear();
+    this->clear();
     return;
   }
   if (this->end_keys_.find(key) != std::string::npos) {
     if ((this->min_length_ == 0) || (this->result_.size() >= this->min_length_)) {
-      this->result_trigger_->trigger(this->result_, this->start_key_, key);
+      this->result_callbacks_.call(this->result_, this->start_key_, key);
       this->clear();
     }
     return;
   }
-  if (!this->allowed_keys_.empty() && (this->allowed_keys_.find(key) == std::string::npos))
+  if (!this->allowed_keys_.empty() && this->allowed_keys_.find(key) == std::string::npos)
     return;
-  if ((this->max_length_ == 0) || (this->result_.size() < this->max_length_))
+  if ((this->max_length_ == 0) || (this->result_.size() < this->max_length_)) {
+    if (this->result_.empty())
+      this->enable_loop();
     this->result_.push_back(key);
+  }
   if ((this->max_length_ > 0) && (this->result_.size() == this->max_length_) && (!this->end_key_required_)) {
-    this->result_trigger_->trigger(this->result_, this->start_key_, 0);
+    this->result_callbacks_.call(this->result_, this->start_key_, 0);
     this->clear(false);
   }
-  this->progress_trigger_->trigger(this->result_, this->start_key_);
+  this->progress_callbacks_.call(this->result_, this->start_key_);
 }
 
 }  // namespace key_collector
diff --git a/esphome/components/key_collector/key_collector.h b/esphome/components/key_collector/key_collector.h
index 735f3968097..8e30c333df7 100644
--- a/esphome/components/key_collector/key_collector.h
+++ b/esphome/components/key_collector/key_collector.h
@@ -3,27 +3,33 @@
 #include <utility>
 #include "esphome/components/key_provider/key_provider.h"
 #include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace key_collector {
 
 class KeyCollector : public Component {
  public:
-  KeyCollector();
   void loop() override;
   void dump_config() override;
-  void set_provider(key_provider::KeyProvider *provider);
-  void set_min_length(uint32_t min_length) { this->min_length_ = min_length; };
-  void set_max_length(uint32_t max_length) { this->max_length_ = max_length; };
+  void add_provider(key_provider::KeyProvider *provider);
+  void set_min_length(uint16_t min_length) { this->min_length_ = min_length; };
+  void set_max_length(uint16_t max_length) { this->max_length_ = max_length; };
   void set_start_keys(std::string start_keys) { this->start_keys_ = std::move(start_keys); };
   void set_end_keys(std::string end_keys) { this->end_keys_ = std::move(end_keys); };
   void set_end_key_required(bool end_key_required) { this->end_key_required_ = end_key_required; };
   void set_back_keys(std::string back_keys) { this->back_keys_ = std::move(back_keys); };
   void set_clear_keys(std::string clear_keys) { this->clear_keys_ = std::move(clear_keys); };
   void set_allowed_keys(std::string allowed_keys) { this->allowed_keys_ = std::move(allowed_keys); };
-  Trigger<std::string, uint8_t> *get_progress_trigger() const { return this->progress_trigger_; };
-  Trigger<std::string, uint8_t, uint8_t> *get_result_trigger() const { return this->result_trigger_; };
-  Trigger<std::string, uint8_t> *get_timeout_trigger() const { return this->timeout_trigger_; };
+  void add_on_progress_callback(std::function<void(const std::string &, uint8_t)> &&callback) {
+    this->progress_callbacks_.add(std::move(callback));
+  }
+  void add_on_result_callback(std::function<void(const std::string &, uint8_t, uint8_t)> &&callback) {
+    this->result_callbacks_.add(std::move(callback));
+  }
+  void add_on_timeout_callback(std::function<void(const std::string &, uint8_t)> &&callback) {
+    this->timeout_callbacks_.add(std::move(callback));
+  }
   void set_timeout(int timeout) { this->timeout_ = timeout; };
   void set_enabled(bool enabled);
 
@@ -31,10 +37,8 @@ class KeyCollector : public Component {
   void send_key(uint8_t key);
 
  protected:
-  void key_pressed_(uint8_t key);
-
-  uint32_t min_length_{0};
-  uint32_t max_length_{0};
+  uint16_t min_length_{0};
+  uint16_t max_length_{0};
   std::string start_keys_;
   std::string end_keys_;
   bool end_key_required_{false};
@@ -43,12 +47,12 @@ class KeyCollector : public Component {
   std::string allowed_keys_;
   std::string result_;
   uint8_t start_key_{0};
-  Trigger<std::string, uint8_t> *progress_trigger_;
-  Trigger<std::string, uint8_t, uint8_t> *result_trigger_;
-  Trigger<std::string, uint8_t> *timeout_trigger_;
-  uint32_t last_key_time_;
+  LazyCallbackManager<void(const std::string &, uint8_t)> progress_callbacks_;
+  LazyCallbackManager<void(const std::string &, uint8_t, uint8_t)> result_callbacks_;
+  LazyCallbackManager<void(const std::string &, uint8_t)> timeout_callbacks_;
+  uint32_t last_key_time_{};
   uint32_t timeout_{0};
-  bool enabled_;
+  bool enabled_{};
 };
 
 template<typename... Ts> class EnableAction : public Action<Ts...>, public Parented<KeyCollector> {
diff --git a/esphome/components/key_collector/text_sensor/__init__.py b/esphome/components/key_collector/text_sensor/__init__.py
new file mode 100644
index 00000000000..1676cf7bdf8
--- /dev/null
+++ b/esphome/components/key_collector/text_sensor/__init__.py
@@ -0,0 +1,28 @@
+import esphome.codegen as cg
+from esphome.components import text_sensor
+from esphome.components.text_sensor import TextSensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+from esphome.cpp_generator import literal
+from esphome.types import TemplateArgsType
+
+from .. import CONF_ON_RESULT, CONF_SOURCE_ID, TRIGGER_TYPES, KeyCollector
+
+CONFIG_SCHEMA = text_sensor.text_sensor_schema(TextSensor).extend(
+    {
+        cv.GenerateID(CONF_SOURCE_ID): cv.use_id(KeyCollector),
+    }
+)
+
+
+async def to_code(config):
+    parent = await cg.get_variable(config[CONF_SOURCE_ID])
+    var = cg.new_Pvariable(config[CONF_ID])
+    await text_sensor.register_text_sensor(var, config)
+    args = TRIGGER_TYPES[CONF_ON_RESULT]
+    arglist: TemplateArgsType = [(arg.type, arg.name) for arg in args]
+    cg.add(
+        parent.add_on_result_callback(
+            await cg.process_lambda(var.publish_state(literal(args[0].name)), arglist)
+        )
+    )
diff --git a/esphome/components/kmeteriso/kmeteriso.cpp b/esphome/components/kmeteriso/kmeteriso.cpp
index 36f6d74ba0d..186686e472a 100644
--- a/esphome/components/kmeteriso/kmeteriso.cpp
+++ b/esphome/components/kmeteriso/kmeteriso.cpp
@@ -47,8 +47,6 @@ void KMeterISOComponent::setup() {
   }
 }
 
-float KMeterISOComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void KMeterISOComponent::update() {
   uint8_t read_buf[4];
 
diff --git a/esphome/components/kmeteriso/kmeteriso.h b/esphome/components/kmeteriso/kmeteriso.h
index c8bed662b0b..6f1978105fb 100644
--- a/esphome/components/kmeteriso/kmeteriso.h
+++ b/esphome/components/kmeteriso/kmeteriso.h
@@ -17,7 +17,6 @@ class KMeterISOComponent : public PollingComponent, public i2c::I2CDevice {
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
   void setup() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/libretiny/preferences.cpp b/esphome/components/libretiny/preferences.cpp
index 978dcce3fa9..5a60b535da3 100644
--- a/esphome/components/libretiny/preferences.cpp
+++ b/esphome/components/libretiny/preferences.cpp
@@ -189,10 +189,11 @@ class LibreTinyPreferences : public ESPPreferences {
   }
 };
 
+static LibreTinyPreferences s_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 void setup_preferences() {
-  auto *prefs = new LibreTinyPreferences();  // NOLINT(cppcoreguidelines-owning-memory)
-  prefs->open();
-  global_preferences = prefs;
+  s_preferences.open();
+  global_preferences = &s_preferences;
 }
 
 }  // namespace libretiny
diff --git a/esphome/components/light/base_light_effects.h b/esphome/components/light/base_light_effects.h
index 2eeae574e75..cdb9f1f6665 100644
--- a/esphome/components/light/base_light_effects.h
+++ b/esphome/components/light/base_light_effects.h
@@ -138,20 +138,20 @@ class LambdaLightEffect : public LightEffect {
 class AutomationLightEffect : public LightEffect {
  public:
   AutomationLightEffect(const char *name) : LightEffect(name) {}
-  void stop() override { this->trig_->stop_action(); }
+  void stop() override { this->trig_.stop_action(); }
   void apply() override {
-    if (!this->trig_->is_action_running()) {
-      this->trig_->trigger();
+    if (!this->trig_.is_action_running()) {
+      this->trig_.trigger();
     }
   }
-  Trigger<> *get_trig() const { return trig_; }
+  Trigger<> *get_trig() { return &this->trig_; }
 
   /// Get the current effect index for use in automations.
   /// Useful for automations that need to know which effect is running.
   uint32_t get_current_index() const { return this->get_index(); }
 
  protected:
-  Trigger<> *trig_{new Trigger<>};
+  Trigger<> trig_;
 };
 
 struct StrobeLightEffectColor {
diff --git a/esphome/components/lock/lock.cpp b/esphome/components/lock/lock.cpp
index 9fa1ba36000..4c61418256f 100644
--- a/esphome/components/lock/lock.cpp
+++ b/esphome/components/lock/lock.cpp
@@ -2,6 +2,7 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 namespace esphome::lock {
 
@@ -84,21 +85,21 @@ LockCall &LockCall::set_state(optional<LockState> state) {
   this->state_ = state;
   return *this;
 }
-LockCall &LockCall::set_state(const std::string &state) {
-  if (str_equals_case_insensitive(state, "LOCKED")) {
+LockCall &LockCall::set_state(const char *state) {
+  if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("LOCKED")) == 0) {
     this->set_state(LOCK_STATE_LOCKED);
-  } else if (str_equals_case_insensitive(state, "UNLOCKED")) {
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("UNLOCKED")) == 0) {
     this->set_state(LOCK_STATE_UNLOCKED);
-  } else if (str_equals_case_insensitive(state, "JAMMED")) {
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("JAMMED")) == 0) {
     this->set_state(LOCK_STATE_JAMMED);
-  } else if (str_equals_case_insensitive(state, "LOCKING")) {
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("LOCKING")) == 0) {
     this->set_state(LOCK_STATE_LOCKING);
-  } else if (str_equals_case_insensitive(state, "UNLOCKING")) {
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("UNLOCKING")) == 0) {
     this->set_state(LOCK_STATE_UNLOCKING);
-  } else if (str_equals_case_insensitive(state, "NONE")) {
+  } else if (ESPHOME_strcasecmp_P(state, ESPHOME_PSTR("NONE")) == 0) {
     this->set_state(LOCK_STATE_NONE);
   } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized state %s", this->parent_->get_name().c_str(), state.c_str());
+    ESP_LOGW(TAG, "'%s' - Unrecognized state %s", this->parent_->get_name().c_str(), state);
   }
   return *this;
 }
diff --git a/esphome/components/lock/lock.h b/esphome/components/lock/lock.h
index 69fc4057133..bebd296eacb 100644
--- a/esphome/components/lock/lock.h
+++ b/esphome/components/lock/lock.h
@@ -83,7 +83,8 @@ class LockCall {
   /// Set the state of the lock device.
   LockCall &set_state(optional<LockState> state);
   /// Set the state of the lock device based on a string.
-  LockCall &set_state(const std::string &state);
+  LockCall &set_state(const char *state);
+  LockCall &set_state(const std::string &state) { return this->set_state(state.c_str()); }
 
   void perform();
 
diff --git a/esphome/components/logger/logger.cpp b/esphome/components/logger/logger.cpp
index 3a726d40461..54b5670016e 100644
--- a/esphome/components/logger/logger.cpp
+++ b/esphome/components/logger/logger.cpp
@@ -36,9 +36,7 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
 
   // Fast path: main thread, no recursion (99.9% of all logs)
   if (is_main_task && !this->main_task_recursion_guard_) [[likely]] {
-    RecursionGuard guard(this->main_task_recursion_guard_);
-    // Format and send to both console and callbacks
-    this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+    this->log_message_to_buffer_and_send_(this->main_task_recursion_guard_, level, tag, line, format, args);
     return;
   }
 
@@ -101,12 +99,9 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
     static const size_t MAX_CONSOLE_LOG_MSG_SIZE = 144;
 #endif
     char console_buffer[MAX_CONSOLE_LOG_MSG_SIZE];  // MUST be stack allocated for thread safety
-    uint16_t buffer_at = 0;                         // Initialize buffer position
-    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, console_buffer, &buffer_at,
-                                                MAX_CONSOLE_LOG_MSG_SIZE);
-    // Add newline before writing to console
-    this->add_newline_to_buffer_(console_buffer, &buffer_at, MAX_CONSOLE_LOG_MSG_SIZE);
-    this->write_msg_(console_buffer, buffer_at);
+    LogBuffer buf{console_buffer, MAX_CONSOLE_LOG_MSG_SIZE};
+    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
+    this->write_to_console_(buf);
   }
 
   // RAII guard automatically resets on return
@@ -117,9 +112,7 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  RecursionGuard guard(global_recursion_guard_);
-  // Format and send to both console and callbacks
-  this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_ESP32 / USE_HOST / USE_LIBRETINY
 
@@ -128,60 +121,14 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
 // Note: USE_STORE_LOG_STR_IN_FLASH is only defined for ESP8266.
 //
 // This function handles format strings stored in flash memory (PROGMEM) to save RAM.
-// The buffer is used in a special way to avoid allocating extra memory:
-//
-// Memory layout during execution:
-// Step 1: Copy format string from flash to buffer
-//         tx_buffer_: [format_string][null][.....................]
-//         tx_buffer_at_: ------------------^
-//         msg_start: saved here -----------^
-//
-// Step 2: format_log_to_buffer_with_terminator_ reads format string from beginning
-//         and writes formatted output starting at msg_start position
-//         tx_buffer_: [format_string][null][formatted_message][null]
-//         tx_buffer_at_: -------------------------------------^
-//
-// Step 3: Output the formatted message (starting at msg_start)
-//         write_msg_ and callbacks receive: this->tx_buffer_ + msg_start
-//         which points to: [formatted_message][null]
+// Uses vsnprintf_P to read the format string directly from flash without copying to RAM.
 //
 void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __FlashStringHelper *format,
                           va_list args) {  // NOLINT
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  RecursionGuard guard(global_recursion_guard_);
-  this->tx_buffer_at_ = 0;
-
-  // Copy format string from progmem
-  auto *format_pgm_p = reinterpret_cast<const uint8_t *>(format);
-  char ch = '.';
-  while (this->tx_buffer_at_ < this->tx_buffer_size_ && ch != '\0') {
-    this->tx_buffer_[this->tx_buffer_at_++] = ch = (char) progmem_read_byte(format_pgm_p++);
-  }
-
-  // Buffer full from copying format - RAII guard handles cleanup on return
-  if (this->tx_buffer_at_ >= this->tx_buffer_size_) {
-    return;
-  }
-
-  // Save the offset before calling format_log_to_buffer_with_terminator_
-  // since it will increment tx_buffer_at_ to the end of the formatted string
-  uint16_t msg_start = this->tx_buffer_at_;
-  this->format_log_to_buffer_with_terminator_(level, tag, line, this->tx_buffer_, args, this->tx_buffer_,
-                                              &this->tx_buffer_at_, this->tx_buffer_size_);
-
-  uint16_t msg_length =
-      this->tx_buffer_at_ - msg_start;  // Don't subtract 1 - tx_buffer_at_ is already at the null terminator position
-
-  // Listeners get message first (before console write)
-#ifdef USE_LOG_LISTENERS
-  for (auto *listener : this->log_listeners_)
-    listener->on_log(level, tag, this->tx_buffer_ + msg_start, msg_length);
-#endif
-
-  // Write to console starting at the msg_start
-  this->write_tx_buffer_to_console_(msg_start, &msg_length);
+  this->log_message_to_buffer_and_send_(global_recursion_guard_, level, tag, line, format, args);
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 
@@ -240,10 +187,11 @@ void Logger::process_messages_() {
     logger::TaskLogBufferHost::LogMessage *message;
     while (this->log_buffer_->get_message_main_loop(&message)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
       this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, message->text,
-                                                message->text_length);
+                                                message->text_length, buf);
       this->log_buffer_->release_message_main_loop();
-      this->write_tx_buffer_to_console_();
+      this->write_log_buffer_to_console_(buf);
     }
 #elif defined(USE_ESP32)
     logger::TaskLogBuffer::LogMessage *message;
@@ -251,22 +199,24 @@ void Logger::process_messages_() {
     void *received_token;
     while (this->log_buffer_->borrow_message_main_loop(&message, &text, &received_token)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
       this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, text,
-                                                message->text_length);
+                                                message->text_length, buf);
       // Release the message to allow other tasks to use it as soon as possible
       this->log_buffer_->release_message_main_loop(received_token);
-      this->write_tx_buffer_to_console_();
+      this->write_log_buffer_to_console_(buf);
     }
 #elif defined(USE_LIBRETINY)
     logger::TaskLogBufferLibreTiny::LogMessage *message;
     const char *text;
     while (this->log_buffer_->borrow_message_main_loop(&message, &text)) {
       const char *thread_name = message->thread_name[0] != '\0' ? message->thread_name : nullptr;
+      LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
       this->format_buffered_message_and_notify_(message->level, message->tag, message->line, thread_name, text,
-                                                message->text_length);
+                                                message->text_length, buf);
       // Release the message to allow other tasks to use it as soon as possible
       this->log_buffer_->release_message_main_loop();
-      this->write_tx_buffer_to_console_();
+      this->write_log_buffer_to_console_(buf);
     }
 #endif
   }
diff --git a/esphome/components/logger/logger.h b/esphome/components/logger/logger.h
index fe9cab4993f..1678fed5f5e 100644
--- a/esphome/components/logger/logger.h
+++ b/esphome/components/logger/logger.h
@@ -2,6 +2,7 @@
 
 #include <cstdarg>
 #include <map>
+#include <type_traits>
 #if defined(USE_ESP32) || defined(USE_HOST)
 #include <pthread.h>
 #endif
@@ -123,6 +124,163 @@ static constexpr uint16_t MAX_HEADER_SIZE = 128;
 // "0x" + 2 hex digits per byte + '\0'
 static constexpr size_t MAX_POINTER_REPRESENTATION = 2 + sizeof(void *) * 2 + 1;
 
+// Buffer wrapper for log formatting functions
+struct LogBuffer {
+  char *data;
+  uint16_t size;
+  uint16_t pos{0};
+  // Replaces the null terminator with a newline for console output.
+  // Must be called after notify_listeners_() since listeners need null-terminated strings.
+  // Console output uses length-based writes (buf.pos), so null terminator is not needed.
+  void terminate_with_newline() {
+    if (this->pos < this->size) {
+      this->data[this->pos++] = '\n';
+    } else if (this->size > 0) {
+      // Buffer was full - replace last char with newline to ensure it's visible
+      this->data[this->size - 1] = '\n';
+      this->pos = this->size;
+    }
+  }
+  void HOT write_header(uint8_t level, const char *tag, int line, const char *thread_name) {
+    // Early return if insufficient space - intentionally don't update pos to prevent partial writes
+    if (this->pos + MAX_HEADER_SIZE > this->size)
+      return;
+
+    char *p = this->current_();
+
+    // Write ANSI color
+    this->write_ansi_color_(p, level);
+
+    // Construct: [LEVEL][tag:line]
+    *p++ = '[';
+    if (level != 0) {
+      if (level >= 7) {
+        *p++ = 'V';  // VERY_VERBOSE = "VV"
+        *p++ = 'V';
+      } else {
+        *p++ = LOG_LEVEL_LETTER_CHARS[level];
+      }
+    }
+    *p++ = ']';
+    *p++ = '[';
+
+    // Copy tag
+    this->copy_string_(p, tag);
+
+    *p++ = ':';
+
+    // Format line number without modulo operations
+    if (line > 999) [[unlikely]] {
+      int thousands = line / 1000;
+      *p++ = '0' + thousands;
+      line -= thousands * 1000;
+    }
+    int hundreds = line / 100;
+    int remainder = line - hundreds * 100;
+    int tens = remainder / 10;
+    *p++ = '0' + hundreds;
+    *p++ = '0' + tens;
+    *p++ = '0' + (remainder - tens * 10);
+    *p++ = ']';
+
+#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR) || defined(USE_HOST)
+    // Write thread name with bold red color
+    if (thread_name != nullptr) {
+      this->write_ansi_color_(p, 1);  // Bold red for thread name
+      *p++ = '[';
+      this->copy_string_(p, thread_name);
+      *p++ = ']';
+      this->write_ansi_color_(p, level);  // Restore original color
+    }
+#endif
+
+    *p++ = ':';
+    *p++ = ' ';
+
+    this->pos = p - this->data;
+  }
+  void HOT format_body(const char *format, va_list args) {
+    this->format_vsnprintf_(format, args);
+    this->finalize_();
+  }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void HOT format_body_P(PGM_P format, va_list args) {
+    this->format_vsnprintf_P_(format, args);
+    this->finalize_();
+  }
+#endif
+  void write_body(const char *text, uint16_t text_length) {
+    this->write_(text, text_length);
+    this->finalize_();
+  }
+
+ private:
+  bool full_() const { return this->pos >= this->size; }
+  uint16_t remaining_() const { return this->size - this->pos; }
+  char *current_() { return this->data + this->pos; }
+  void write_(const char *value, uint16_t length) {
+    const uint16_t available = this->remaining_();
+    const uint16_t copy_len = (length < available) ? length : available;
+    if (copy_len > 0) {
+      memcpy(this->current_(), value, copy_len);
+      this->pos += copy_len;
+    }
+  }
+  void finalize_() {
+    // Write color reset sequence
+    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
+    this->write_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN);
+    // Null terminate
+    this->data[this->full_() ? this->size - 1 : this->pos] = '\0';
+  }
+  void strip_trailing_newlines_() {
+    while (this->pos > 0 && this->data[this->pos - 1] == '\n')
+      this->pos--;
+  }
+  void process_vsnprintf_result_(int ret) {
+    if (ret < 0)
+      return;
+    const uint16_t rem = this->remaining_();
+    this->pos += (ret >= rem) ? (rem - 1) : static_cast<uint16_t>(ret);
+    this->strip_trailing_newlines_();
+  }
+  void format_vsnprintf_(const char *format, va_list args) {
+    if (this->full_())
+      return;
+    this->process_vsnprintf_result_(vsnprintf(this->current_(), this->remaining_(), format, args));
+  }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  void format_vsnprintf_P_(PGM_P format, va_list args) {
+    if (this->full_())
+      return;
+    this->process_vsnprintf_result_(vsnprintf_P(this->current_(), this->remaining_(), format, args));
+  }
+#endif
+  // Write ANSI color escape sequence to buffer, updates pointer in place
+  // Caller is responsible for ensuring buffer has sufficient space
+  void write_ansi_color_(char *&p, uint8_t level) {
+    if (level == 0)
+      return;
+    // Direct buffer fill: "\033[{bold};3{color}m" (7 bytes)
+    *p++ = '\033';
+    *p++ = '[';
+    *p++ = (level == 1) ? '1' : '0';  // Only ERROR is bold
+    *p++ = ';';
+    *p++ = '3';
+    *p++ = LOG_LEVEL_COLOR_DIGIT[level];
+    *p++ = 'm';
+  }
+  // Copy string without null terminator, updates pointer in place
+  // Caller is responsible for ensuring buffer has sufficient space
+  void copy_string_(char *&p, const char *str) {
+    const size_t len = strlen(str);
+    // NOLINTNEXTLINE(bugprone-not-null-terminated-result) - intentionally no null terminator, building string piece by
+    // piece
+    memcpy(p, str, len);
+    p += len;
+  }
+};
+
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
 /** Enum for logging UART selection
  *
@@ -260,114 +418,83 @@ class Logger : public Component {
 #endif
 #endif
   void process_messages_();
-  void write_msg_(const char *msg, size_t len);
+  void write_msg_(const char *msg, uint16_t len);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
-  // It's the caller's responsibility to initialize buffer_at (typically to 0)
   inline void HOT format_log_to_buffer_with_terminator_(uint8_t level, const char *tag, int line, const char *format,
-                                                        va_list args, char *buffer, uint16_t *buffer_at,
-                                                        uint16_t buffer_size) {
+                                                        va_list args, LogBuffer &buf) {
 #if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_HOST)
-    this->write_header_to_buffer_(level, tag, line, this->get_thread_name_(), buffer, buffer_at, buffer_size);
+    buf.write_header(level, tag, line, this->get_thread_name_());
 #elif defined(USE_ZEPHYR)
-    char buff[MAX_POINTER_REPRESENTATION];
-    this->write_header_to_buffer_(level, tag, line, this->get_thread_name_(buff), buffer, buffer_at, buffer_size);
+    char tmp[MAX_POINTER_REPRESENTATION];
+    buf.write_header(level, tag, line, this->get_thread_name_(tmp));
 #else
-    this->write_header_to_buffer_(level, tag, line, nullptr, buffer, buffer_at, buffer_size);
+    buf.write_header(level, tag, line, nullptr);
 #endif
-    this->format_body_to_buffer_(buffer, buffer_at, buffer_size, format, args);
-    this->write_footer_to_buffer_(buffer, buffer_at, buffer_size);
-
-    // Always ensure the buffer has a null terminator, even if we need to
-    // overwrite the last character of the actual content
-    if (*buffer_at >= buffer_size) {
-      buffer[buffer_size - 1] = '\0';  // Truncate and ensure null termination
-    } else {
-      buffer[*buffer_at] = '\0';  // Normal case, append null terminator
-    }
+    buf.format_body(format, args);
   }
 
-  // Helper to add newline to buffer before writing to console
-  // Modifies buffer_at to include the newline
-  inline void HOT add_newline_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    // Add newline - don't need to maintain null termination
-    // write_msg_ receives explicit length, so we can safely overwrite the null terminator
-    // This is safe because:
-    // 1. Callbacks already received the message (before we add newline)
-    // 2. write_msg_ receives the length explicitly (doesn't need null terminator)
-    if (*buffer_at < buffer_size) {
-      buffer[(*buffer_at)++] = '\n';
-    } else if (buffer_size > 0) {
-      // Buffer was full - replace last char with newline to ensure it's visible
-      buffer[buffer_size - 1] = '\n';
-      *buffer_at = buffer_size;
-    }
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+  // Format a log message with flash string format and write it to a buffer with header, footer, and null terminator
+  inline void HOT format_log_to_buffer_with_terminator_P_(uint8_t level, const char *tag, int line,
+                                                          const __FlashStringHelper *format, va_list args,
+                                                          LogBuffer &buf) {
+    buf.write_header(level, tag, line, nullptr);
+    buf.format_body_P(reinterpret_cast<PGM_P>(format), args);
+  }
+#endif
+
+  // Helper to notify log listeners
+  inline void HOT notify_listeners_(uint8_t level, const char *tag, const LogBuffer &buf) {
+#ifdef USE_LOG_LISTENERS
+    for (auto *listener : this->log_listeners_)
+      listener->on_log(level, tag, buf.data, buf.pos);
+#endif
   }
 
-  // Helper to write tx_buffer_ to console if logging is enabled
-  // INTERNAL USE ONLY - offset > 0 requires length parameter to be non-null
-  inline void HOT write_tx_buffer_to_console_(uint16_t offset = 0, uint16_t *length = nullptr) {
-    if (this->baud_rate_ > 0) {
-      uint16_t *len_ptr = length ? length : &this->tx_buffer_at_;
-      this->add_newline_to_buffer_(this->tx_buffer_ + offset, len_ptr, this->tx_buffer_size_ - offset);
-      this->write_msg_(this->tx_buffer_ + offset, *len_ptr);
-    }
+  // Helper to write log buffer to console (replaces null terminator with newline and writes)
+  inline void HOT write_to_console_(LogBuffer &buf) {
+    buf.terminate_with_newline();
+    this->write_msg_(buf.data, buf.pos);
+  }
+
+  // Helper to write log buffer to console if logging is enabled
+  inline void HOT write_log_buffer_to_console_(LogBuffer &buf) {
+    if (this->baud_rate_ > 0)
+      this->write_to_console_(buf);
   }
 
   // Helper to format and send a log message to both console and listeners
-  inline void HOT log_message_to_buffer_and_send_(uint8_t level, const char *tag, int line, const char *format,
-                                                  va_list args) {
-    // Format to tx_buffer and prepare for output
-    this->tx_buffer_at_ = 0;  // Initialize buffer position
-    this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, this->tx_buffer_, &this->tx_buffer_at_,
-                                                this->tx_buffer_size_);
-
-    // Listeners get message WITHOUT newline (for API/MQTT/syslog)
-#ifdef USE_LOG_LISTENERS
-    for (auto *listener : this->log_listeners_)
-      listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
+  // Template handles both const char* (RAM) and __FlashStringHelper* (flash) format strings
+  template<typename FormatType>
+  inline void HOT log_message_to_buffer_and_send_(bool &recursion_guard, uint8_t level, const char *tag, int line,
+                                                  FormatType format, va_list args) {
+    RecursionGuard guard(recursion_guard);
+    LogBuffer buf{this->tx_buffer_, this->tx_buffer_size_};
+#ifdef USE_STORE_LOG_STR_IN_FLASH
+    if constexpr (std::is_same_v<FormatType, const __FlashStringHelper *>) {
+      this->format_log_to_buffer_with_terminator_P_(level, tag, line, format, args, buf);
+    } else
 #endif
-
-    // Console gets message WITH newline (if platform needs it)
-    this->write_tx_buffer_to_console_();
+    {
+      this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, buf);
+    }
+    this->notify_listeners_(level, tag, buf);
+    this->write_log_buffer_to_console_(buf);
   }
 
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // Helper to format a pre-formatted message from the task log buffer and notify listeners
   // Used by process_messages_ to avoid code duplication between ESP32 and host platforms
   inline void HOT format_buffered_message_and_notify_(uint8_t level, const char *tag, uint16_t line,
-                                                      const char *thread_name, const char *text, size_t text_length) {
-    this->tx_buffer_at_ = 0;
-    this->write_header_to_buffer_(level, tag, line, thread_name, this->tx_buffer_, &this->tx_buffer_at_,
-                                  this->tx_buffer_size_);
-    this->write_body_to_buffer_(text, text_length, this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
-    this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
-    this->tx_buffer_[this->tx_buffer_at_] = '\0';
-#ifdef USE_LOG_LISTENERS
-    for (auto *listener : this->log_listeners_)
-      listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
-#endif
+                                                      const char *thread_name, const char *text, uint16_t text_length,
+                                                      LogBuffer &buf) {
+    buf.write_header(level, tag, line, thread_name);
+    buf.write_body(text, text_length);
+    this->notify_listeners_(level, tag, buf);
   }
 #endif
 
-  // Write the body of the log message to the buffer
-  inline void write_body_to_buffer_(const char *value, size_t length, char *buffer, uint16_t *buffer_at,
-                                    uint16_t buffer_size) {
-    // Calculate available space
-    if (*buffer_at >= buffer_size)
-      return;
-    const uint16_t available = buffer_size - *buffer_at;
-
-    // Determine copy length (minimum of remaining capacity and string length)
-    const size_t copy_len = (length < static_cast<size_t>(available)) ? length : available;
-
-    // Copy the data
-    if (copy_len > 0) {
-      memcpy(buffer + *buffer_at, value, copy_len);
-      *buffer_at += copy_len;
-    }
-  }
-
 #ifndef USE_HOST
   const LogString *get_uart_selection_();
 #endif
@@ -421,7 +548,6 @@ class Logger : public Component {
 #endif
 
   // Group smaller types together at the end
-  uint16_t tx_buffer_at_{0};
   uint16_t tx_buffer_size_{0};
   uint8_t current_level_{ESPHOME_LOG_LEVEL_VERY_VERBOSE};
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_ZEPHYR)
@@ -525,108 +651,6 @@ class Logger : public Component {
   }
 #endif
 
-  static inline void copy_string(char *buffer, uint16_t &pos, const char *str) {
-    const size_t len = strlen(str);
-    // Intentionally no null terminator, building larger string
-    memcpy(buffer + pos, str, len);  // NOLINT(bugprone-not-null-terminated-result)
-    pos += len;
-  }
-
-  static inline void write_ansi_color_for_level(char *buffer, uint16_t &pos, uint8_t level) {
-    if (level == 0)
-      return;
-    // Construct ANSI escape sequence: "\033[{bold};3{color}m"
-    // Example: "\033[1;31m" for ERROR (bold red)
-    buffer[pos++] = '\033';
-    buffer[pos++] = '[';
-    buffer[pos++] = (level == 1) ? '1' : '0';  // Only ERROR is bold
-    buffer[pos++] = ';';
-    buffer[pos++] = '3';
-    buffer[pos++] = LOG_LEVEL_COLOR_DIGIT[level];
-    buffer[pos++] = 'm';
-  }
-
-  inline void HOT write_header_to_buffer_(uint8_t level, const char *tag, int line, const char *thread_name,
-                                          char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    uint16_t pos = *buffer_at;
-    // Early return if insufficient space - intentionally don't update buffer_at to prevent partial writes
-    if (pos + MAX_HEADER_SIZE > buffer_size)
-      return;
-
-    // Construct: <color>[LEVEL][tag:line]:
-    write_ansi_color_for_level(buffer, pos, level);
-    buffer[pos++] = '[';
-    if (level != 0) {
-      if (level >= 7) {
-        buffer[pos++] = 'V';  // VERY_VERBOSE = "VV"
-        buffer[pos++] = 'V';
-      } else {
-        buffer[pos++] = LOG_LEVEL_LETTER_CHARS[level];
-      }
-    }
-    buffer[pos++] = ']';
-    buffer[pos++] = '[';
-    copy_string(buffer, pos, tag);
-    buffer[pos++] = ':';
-    // Format line number without modulo operations (passed by value, safe to mutate)
-    if (line > 999) [[unlikely]] {
-      int thousands = line / 1000;
-      buffer[pos++] = '0' + thousands;
-      line -= thousands * 1000;
-    }
-    int hundreds = line / 100;
-    int remainder = line - hundreds * 100;
-    int tens = remainder / 10;
-    buffer[pos++] = '0' + hundreds;
-    buffer[pos++] = '0' + tens;
-    buffer[pos++] = '0' + (remainder - tens * 10);
-    buffer[pos++] = ']';
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR) || defined(USE_HOST)
-    if (thread_name != nullptr) {
-      write_ansi_color_for_level(buffer, pos, 1);  // Always use bold red for thread name
-      buffer[pos++] = '[';
-      copy_string(buffer, pos, thread_name);
-      buffer[pos++] = ']';
-      write_ansi_color_for_level(buffer, pos, level);  // Restore original color
-    }
-#endif
-
-    buffer[pos++] = ':';
-    buffer[pos++] = ' ';
-    *buffer_at = pos;
-  }
-
-  inline void HOT format_body_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size, const char *format,
-                                         va_list args) {
-    // Get remaining capacity in the buffer
-    if (*buffer_at >= buffer_size)
-      return;
-    const uint16_t remaining = buffer_size - *buffer_at;
-
-    const int ret = vsnprintf(buffer + *buffer_at, remaining, format, args);
-
-    if (ret < 0) {
-      return;  // Encoding error, do not increment buffer_at
-    }
-
-    // Update buffer_at with the formatted length (handle truncation)
-    // When vsnprintf truncates (ret >= remaining), it writes (remaining - 1) chars + null terminator
-    // When it doesn't truncate (ret < remaining), it writes ret chars + null terminator
-    uint16_t formatted_len = (ret >= remaining) ? (remaining - 1) : ret;
-    *buffer_at += formatted_len;
-
-    // Remove all trailing newlines right after formatting
-    while (*buffer_at > 0 && buffer[*buffer_at - 1] == '\n') {
-      (*buffer_at)--;
-    }
-  }
-
-  inline void HOT write_footer_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    static constexpr uint16_t RESET_COLOR_LEN = sizeof(ESPHOME_LOG_RESET_COLOR) - 1;
-    this->write_body_to_buffer_(ESPHOME_LOG_RESET_COLOR, RESET_COLOR_LEN, buffer, buffer_at, buffer_size);
-  }
-
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
   // Disable loop when task buffer is empty (with USB CDC check on ESP32)
   inline void disable_loop_when_buffer_empty_() {
diff --git a/esphome/components/logger/logger_esp32.cpp b/esphome/components/logger/logger_esp32.cpp
index 9defb6c1663..dfa643d5e94 100644
--- a/esphome/components/logger/logger_esp32.cpp
+++ b/esphome/components/logger/logger_esp32.cpp
@@ -118,9 +118,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
-  // Length is now always passed explicitly - no strlen() fallback needed
-
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
 #if defined(USE_LOGGER_UART_SELECTION_USB_CDC) || defined(USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG)
   // USB CDC/JTAG - single write including newline (already in buffer)
   // Use fwrite to stdout which goes through VFS to USB console
diff --git a/esphome/components/logger/logger_esp8266.cpp b/esphome/components/logger/logger_esp8266.cpp
index 6cee1baca59..0a3433d1321 100644
--- a/esphome/components/logger/logger_esp8266.cpp
+++ b/esphome/components/logger/logger_esp8266.cpp
@@ -28,7 +28,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   // Single write with newline already in buffer (added by caller)
   this->hw_serial_->write(msg, len);
 }
diff --git a/esphome/components/logger/logger_host.cpp b/esphome/components/logger/logger_host.cpp
index 874cdabd224..be12b6df6a2 100644
--- a/esphome/components/logger/logger_host.cpp
+++ b/esphome/components/logger/logger_host.cpp
@@ -3,7 +3,7 @@
 
 namespace esphome::logger {
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   static constexpr size_t TIMESTAMP_LEN = 10;  // "[HH:MM:SS]"
   // tx_buffer_size_ defaults to 512, so 768 covers default + headroom
   char buffer[TIMESTAMP_LEN + 768];
@@ -15,7 +15,7 @@ void HOT Logger::write_msg_(const char *msg, size_t len) {
   size_t pos = strftime(buffer, TIMESTAMP_LEN + 1, "[%H:%M:%S]", &timeinfo);
 
   // Copy message (with newline already included by caller)
-  size_t copy_len = std::min(len, sizeof(buffer) - pos);
+  size_t copy_len = std::min(static_cast<size_t>(len), sizeof(buffer) - pos);
   memcpy(buffer + pos, msg, copy_len);
   pos += copy_len;
 
diff --git a/esphome/components/logger/logger_libretiny.cpp b/esphome/components/logger/logger_libretiny.cpp
index cdf55e710cb..aab8a97abff 100644
--- a/esphome/components/logger/logger_libretiny.cpp
+++ b/esphome/components/logger/logger_libretiny.cpp
@@ -49,7 +49,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) { this->hw_serial_->write(msg, len); }
+void HOT Logger::write_msg_(const char *msg, uint16_t len) { this->hw_serial_->write(msg, len); }
 
 const LogString *Logger::get_uart_selection_() {
   switch (this->uart_) {
diff --git a/esphome/components/logger/logger_rp2040.cpp b/esphome/components/logger/logger_rp2040.cpp
index be8252f56ab..1f435031f61 100644
--- a/esphome/components/logger/logger_rp2040.cpp
+++ b/esphome/components/logger/logger_rp2040.cpp
@@ -27,7 +27,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   // Single write with newline already in buffer (added by caller)
   this->hw_serial_->write(msg, len);
 }
diff --git a/esphome/components/logger/logger_zephyr.cpp b/esphome/components/logger/logger_zephyr.cpp
index 41f53beec04..ef1702c5c1c 100644
--- a/esphome/components/logger/logger_zephyr.cpp
+++ b/esphome/components/logger/logger_zephyr.cpp
@@ -63,7 +63,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
+void HOT Logger::write_msg_(const char *msg, uint16_t len) {
   // Single write with newline already in buffer (added by caller)
 #ifdef CONFIG_PRINTK
   // Requires the debug component and an active SWD connection.
@@ -73,7 +73,7 @@ void HOT Logger::write_msg_(const char *msg, size_t len) {
   if (this->uart_dev_ == nullptr) {
     return;
   }
-  for (size_t i = 0; i < len; ++i) {
+  for (uint16_t i = 0; i < len; ++i) {
     uart_poll_out(this->uart_dev_, msg[i]);
   }
 }
diff --git a/esphome/components/lvgl/automation.py b/esphome/components/lvgl/automation.py
index 9b58727f2ae..b589e42f3b7 100644
--- a/esphome/components/lvgl/automation.py
+++ b/esphome/components/lvgl/automation.py
@@ -272,9 +272,7 @@ async def obj_hide_to_code(config, action_id, template_arg, args):
     async def do_hide(widget: Widget):
         widget.add_flag("LV_OBJ_FLAG_HIDDEN")
 
-    widgets = [
-        widget.outer if widget.outer else widget for widget in await get_widgets(config)
-    ]
+    widgets = [widget.outer or widget for widget in await get_widgets(config)]
     return await action_to_code(widgets, do_hide, action_id, template_arg, args)
 
 
@@ -285,9 +283,7 @@ async def obj_show_to_code(config, action_id, template_arg, args):
         if widget.move_to_foreground:
             lv_obj.move_foreground(widget.obj)
 
-    widgets = [
-        widget.outer if widget.outer else widget for widget in await get_widgets(config)
-    ]
+    widgets = [widget.outer or widget for widget in await get_widgets(config)]
     return await action_to_code(widgets, do_show, action_id, template_arg, args)
 
 
diff --git a/esphome/components/m5stack_8angle/m5stack_8angle.cpp b/esphome/components/m5stack_8angle/m5stack_8angle.cpp
index 5a9a5e8c9d1..2de900c21dc 100644
--- a/esphome/components/m5stack_8angle/m5stack_8angle.cpp
+++ b/esphome/components/m5stack_8angle/m5stack_8angle.cpp
@@ -69,7 +69,5 @@ int8_t M5Stack8AngleComponent::read_switch() {
   }
 }
 
-float M5Stack8AngleComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace m5stack_8angle
 }  // namespace esphome
diff --git a/esphome/components/m5stack_8angle/m5stack_8angle.h b/esphome/components/m5stack_8angle/m5stack_8angle.h
index 831b1422fd4..49425180540 100644
--- a/esphome/components/m5stack_8angle/m5stack_8angle.h
+++ b/esphome/components/m5stack_8angle/m5stack_8angle.h
@@ -21,7 +21,6 @@ class M5Stack8AngleComponent : public i2c::I2CDevice, public Component {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   float read_knob_pos(uint8_t channel, AnalogBits bits = AnalogBits::BITS_8);
   int32_t read_knob_pos_raw(uint8_t channel, AnalogBits bits = AnalogBits::BITS_8);
   int8_t read_switch();
diff --git a/esphome/components/max17043/max17043.cpp b/esphome/components/max17043/max17043.cpp
index e8cf4d5ab17..dfd59f1e7df 100644
--- a/esphome/components/max17043/max17043.cpp
+++ b/esphome/components/max17043/max17043.cpp
@@ -81,8 +81,6 @@ void MAX17043Component::dump_config() {
   LOG_SENSOR("  ", "Battery Level", this->battery_remaining_sensor_);
 }
 
-float MAX17043Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void MAX17043Component::sleep_mode() {
   if (!this->is_failed()) {
     if (!this->write_byte_16(MAX17043_CONFIG, MAX17043_CONFIG_POWER_UP_DEFAULT | MAX17043_CONFIG_SLEEP_MASK)) {
diff --git a/esphome/components/max17043/max17043.h b/esphome/components/max17043/max17043.h
index 540b977789d..f477ce59487 100644
--- a/esphome/components/max17043/max17043.h
+++ b/esphome/components/max17043/max17043.h
@@ -11,7 +11,6 @@ class MAX17043Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void sleep_mode();
 
diff --git a/esphome/components/max31855/max31855.cpp b/esphome/components/max31855/max31855.cpp
index b5be3106cff..99129880f41 100644
--- a/esphome/components/max31855/max31855.cpp
+++ b/esphome/components/max31855/max31855.cpp
@@ -31,7 +31,6 @@ void MAX31855Sensor::dump_config() {
     ESP_LOGCONFIG(TAG, "  Reference temperature disabled.");
   }
 }
-float MAX31855Sensor::get_setup_priority() const { return setup_priority::DATA; }
 void MAX31855Sensor::read_data_() {
   this->enable();
   delay(1);
diff --git a/esphome/components/max31855/max31855.h b/esphome/components/max31855/max31855.h
index 822e256587d..b755d240f26 100644
--- a/esphome/components/max31855/max31855.h
+++ b/esphome/components/max31855/max31855.h
@@ -18,7 +18,6 @@ class MAX31855Sensor : public sensor::Sensor,
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void update() override;
 
diff --git a/esphome/components/max31856/max31856.cpp b/esphome/components/max31856/max31856.cpp
index cc573cbc53e..ff65c8c5c94 100644
--- a/esphome/components/max31856/max31856.cpp
+++ b/esphome/components/max31856/max31856.cpp
@@ -197,7 +197,5 @@ uint32_t MAX31856Sensor::read_register24_(uint8_t reg) {
   return value;
 }
 
-float MAX31856Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace max31856
 }  // namespace esphome
diff --git a/esphome/components/max31856/max31856.h b/esphome/components/max31856/max31856.h
index 8d64cfe8bcf..a27ababa2ea 100644
--- a/esphome/components/max31856/max31856.h
+++ b/esphome/components/max31856/max31856.h
@@ -76,7 +76,6 @@ class MAX31856Sensor : public sensor::Sensor,
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void set_filter(MAX31856ConfigFilter filter) { this->filter_ = filter; }
   void set_thermocouple_type(MAX31856ThermocoupleType thermocouple_type) {
     this->thermocouple_type_ = thermocouple_type;
diff --git a/esphome/components/max31865/max31865.cpp b/esphome/components/max31865/max31865.cpp
index a9c5204cf59..09b8368d071 100644
--- a/esphome/components/max31865/max31865.cpp
+++ b/esphome/components/max31865/max31865.cpp
@@ -90,8 +90,6 @@ void MAX31865Sensor::dump_config() {
                 (filter_ == FILTER_60HZ ? "60 Hz" : (filter_ == FILTER_50HZ ? "50 Hz" : "Unknown!")));
 }
 
-float MAX31865Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void MAX31865Sensor::read_data_() {
   // Read temperature, disable V_BIAS (save power)
   const uint16_t rtd_resistance_register = this->read_register_16_(RTD_RESISTANCE_MSB_REG);
diff --git a/esphome/components/max31865/max31865.h b/esphome/components/max31865/max31865.h
index b83753a678c..440c6523a6c 100644
--- a/esphome/components/max31865/max31865.h
+++ b/esphome/components/max31865/max31865.h
@@ -34,7 +34,6 @@ class MAX31865Sensor : public sensor::Sensor,
   void set_num_rtd_wires(uint8_t rtd_wires) { rtd_wires_ = rtd_wires; }
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void update() override;
 
diff --git a/esphome/components/max44009/max44009.cpp b/esphome/components/max44009/max44009.cpp
index 928fc476960..8b8e38c1eae 100644
--- a/esphome/components/max44009/max44009.cpp
+++ b/esphome/components/max44009/max44009.cpp
@@ -51,8 +51,6 @@ void MAX44009Sensor::dump_config() {
   }
 }
 
-float MAX44009Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void MAX44009Sensor::update() {
   // update sensor illuminance value
   float lux = this->read_illuminance_();
diff --git a/esphome/components/max44009/max44009.h b/esphome/components/max44009/max44009.h
index c85d1c1028c..59eea66ed98 100644
--- a/esphome/components/max44009/max44009.h
+++ b/esphome/components/max44009/max44009.h
@@ -16,7 +16,6 @@ class MAX44009Sensor : public sensor::Sensor, public PollingComponent, public i2
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void set_mode(MAX44009Mode mode);
   bool set_continuous_mode();
diff --git a/esphome/components/max6675/max6675.cpp b/esphome/components/max6675/max6675.cpp
index 54e0330ff79..c329cdfd426 100644
--- a/esphome/components/max6675/max6675.cpp
+++ b/esphome/components/max6675/max6675.cpp
@@ -23,7 +23,6 @@ void MAX6675Sensor::dump_config() {
   LOG_PIN("  CS Pin: ", this->cs_);
   LOG_UPDATE_INTERVAL(this);
 }
-float MAX6675Sensor::get_setup_priority() const { return setup_priority::DATA; }
 void MAX6675Sensor::read_data_() {
   this->enable();
   delay(1);
diff --git a/esphome/components/max6675/max6675.h b/esphome/components/max6675/max6675.h
index ab0f06b041b..f0db4a6c268 100644
--- a/esphome/components/max6675/max6675.h
+++ b/esphome/components/max6675/max6675.h
@@ -14,7 +14,6 @@ class MAX6675Sensor : public sensor::Sensor,
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void update() override;
 
diff --git a/esphome/components/max7219/display.py b/esphome/components/max7219/display.py
index a434125148b..abb20702bd2 100644
--- a/esphome/components/max7219/display.py
+++ b/esphome/components/max7219/display.py
@@ -28,11 +28,10 @@ CONFIG_SCHEMA = (
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = cg.new_Pvariable(config[CONF_ID], config[CONF_NUM_CHIPS])
     await spi.register_spi_device(var, config, write_only=True)
     await display.register_display(var, config)
 
-    cg.add(var.set_num_chips(config[CONF_NUM_CHIPS]))
     cg.add(var.set_intensity(config[CONF_INTENSITY]))
     cg.add(var.set_reverse(config[CONF_REVERSE_ENABLE]))
 
diff --git a/esphome/components/max7219/max7219.cpp b/esphome/components/max7219/max7219.cpp
index 157b317c025..d701e6fc867 100644
--- a/esphome/components/max7219/max7219.cpp
+++ b/esphome/components/max7219/max7219.cpp
@@ -3,8 +3,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace max7219 {
+namespace esphome::max7219 {
 
 static const char *const TAG = "max7219";
 
@@ -115,12 +114,14 @@ const uint8_t MAX7219_ASCII_TO_RAW[95] PROGMEM = {
 };
 
 float MAX7219Component::get_setup_priority() const { return setup_priority::PROCESSOR; }
+
+MAX7219Component::MAX7219Component(uint8_t num_chips) : num_chips_(num_chips) {
+  this->buffer_ = new uint8_t[this->num_chips_ * 8];  // NOLINT
+  memset(this->buffer_, 0, this->num_chips_ * 8);
+}
+
 void MAX7219Component::setup() {
   this->spi_setup();
-  this->buffer_ = new uint8_t[this->num_chips_ * 8];  // NOLINT
-  for (uint8_t i = 0; i < this->num_chips_ * 8; i++)
-    this->buffer_[i] = 0;
-
   // let's assume the user has all 8 digits connected, only important in daisy chained setups anyway
   this->send_to_all_(MAX7219_REGISTER_SCAN_LIMIT, 7);
   // let's use our own ASCII -> led pattern encoding
@@ -229,7 +230,6 @@ void MAX7219Component::set_intensity(uint8_t intensity) {
     this->intensity_ = intensity;
   }
 }
-void MAX7219Component::set_num_chips(uint8_t num_chips) { this->num_chips_ = num_chips; }
 
 uint8_t MAX7219Component::strftime(uint8_t pos, const char *format, ESPTime time) {
   char buffer[64];
@@ -240,5 +240,4 @@ uint8_t MAX7219Component::strftime(uint8_t pos, const char *format, ESPTime time
 }
 uint8_t MAX7219Component::strftime(const char *format, ESPTime time) { return this->strftime(0, format, time); }
 
-}  // namespace max7219
-}  // namespace esphome
+}  // namespace esphome::max7219
diff --git a/esphome/components/max7219/max7219.h b/esphome/components/max7219/max7219.h
index 58d871d54c7..ef38628f288 100644
--- a/esphome/components/max7219/max7219.h
+++ b/esphome/components/max7219/max7219.h
@@ -6,8 +6,7 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
 
-namespace esphome {
-namespace max7219 {
+namespace esphome::max7219 {
 
 class MAX7219Component;
 
@@ -17,6 +16,8 @@ class MAX7219Component : public PollingComponent,
                          public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
                                                spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_1MHZ> {
  public:
+  explicit MAX7219Component(uint8_t num_chips);
+
   void set_writer(max7219_writer_t &&writer);
 
   void setup() override;
@@ -30,7 +31,6 @@ class MAX7219Component : public PollingComponent,
   void display();
 
   void set_intensity(uint8_t intensity);
-  void set_num_chips(uint8_t num_chips);
   void set_reverse(bool reverse) { this->reverse_ = reverse; };
 
   /// Evaluate the printf-format and print the result at the given position.
@@ -56,10 +56,9 @@ class MAX7219Component : public PollingComponent,
   uint8_t intensity_{15};     // Intensity of the display from 0 to 15 (most)
   bool intensity_changed_{};  // True if we need to re-send the intensity
   uint8_t num_chips_{1};
-  uint8_t *buffer_;
+  uint8_t *buffer_{nullptr};
   bool reverse_{false};
   max7219_writer_t writer_{};
 };
 
-}  // namespace max7219
-}  // namespace esphome
+}  // namespace esphome::max7219
diff --git a/esphome/components/mcp3008/sensor/mcp3008_sensor.cpp b/esphome/components/mcp3008/sensor/mcp3008_sensor.cpp
index 81eb0a812fb..ee052e9fb79 100644
--- a/esphome/components/mcp3008/sensor/mcp3008_sensor.cpp
+++ b/esphome/components/mcp3008/sensor/mcp3008_sensor.cpp
@@ -7,8 +7,6 @@ namespace mcp3008 {
 
 static const char *const TAG = "mcp3008.sensor";
 
-float MCP3008Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void MCP3008Sensor::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "MCP3008Sensor:\n"
diff --git a/esphome/components/mcp3008/sensor/mcp3008_sensor.h b/esphome/components/mcp3008/sensor/mcp3008_sensor.h
index ebaeab966fc..9478d38e747 100644
--- a/esphome/components/mcp3008/sensor/mcp3008_sensor.h
+++ b/esphome/components/mcp3008/sensor/mcp3008_sensor.h
@@ -19,7 +19,6 @@ class MCP3008Sensor : public PollingComponent,
 
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   float sample() override;
 
  protected:
diff --git a/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp b/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp
index e673537be18..711448cf448 100644
--- a/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp
+++ b/esphome/components/mcp3204/sensor/mcp3204_sensor.cpp
@@ -7,8 +7,6 @@ namespace mcp3204 {
 
 static const char *const TAG = "mcp3204.sensor";
 
-float MCP3204Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void MCP3204Sensor::dump_config() {
   LOG_SENSOR("", "MCP3204 Sensor", this);
   ESP_LOGCONFIG(TAG,
diff --git a/esphome/components/mcp3204/sensor/mcp3204_sensor.h b/esphome/components/mcp3204/sensor/mcp3204_sensor.h
index 5665b80b987..2bf75a9c1e5 100644
--- a/esphome/components/mcp3204/sensor/mcp3204_sensor.h
+++ b/esphome/components/mcp3204/sensor/mcp3204_sensor.h
@@ -19,7 +19,6 @@ class MCP3204Sensor : public PollingComponent,
 
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   float sample() override;
 
  protected:
diff --git a/esphome/components/mcp9808/mcp9808.cpp b/esphome/components/mcp9808/mcp9808.cpp
index 088d33887fc..ed12e522395 100644
--- a/esphome/components/mcp9808/mcp9808.cpp
+++ b/esphome/components/mcp9808/mcp9808.cpp
@@ -73,7 +73,6 @@ void MCP9808Sensor::update() {
   this->publish_state(temp);
   this->status_clear_warning();
 }
-float MCP9808Sensor::get_setup_priority() const { return setup_priority::DATA; }
 
 }  // namespace mcp9808
 }  // namespace esphome
diff --git a/esphome/components/mcp9808/mcp9808.h b/esphome/components/mcp9808/mcp9808.h
index 19aa3117c32..894e4599d0a 100644
--- a/esphome/components/mcp9808/mcp9808.h
+++ b/esphome/components/mcp9808/mcp9808.h
@@ -11,7 +11,6 @@ class MCP9808Sensor : public sensor::Sensor, public PollingComponent, public i2c
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void update() override;
 };
diff --git a/esphome/components/media_player/media_player.cpp b/esphome/components/media_player/media_player.cpp
index b46ec39d302..17d9b054dad 100644
--- a/esphome/components/media_player/media_player.cpp
+++ b/esphome/components/media_player/media_player.cpp
@@ -2,6 +2,7 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 namespace esphome {
 namespace media_player {
@@ -107,25 +108,25 @@ MediaPlayerCall &MediaPlayerCall::set_command(optional<MediaPlayerCommand> comma
   this->command_ = command;
   return *this;
 }
-MediaPlayerCall &MediaPlayerCall::set_command(const std::string &command) {
-  if (str_equals_case_insensitive(command, "PLAY")) {
+MediaPlayerCall &MediaPlayerCall::set_command(const char *command) {
+  if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("PLAY")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_PLAY);
-  } else if (str_equals_case_insensitive(command, "PAUSE")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("PAUSE")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_PAUSE);
-  } else if (str_equals_case_insensitive(command, "STOP")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("STOP")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_STOP);
-  } else if (str_equals_case_insensitive(command, "MUTE")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("MUTE")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_MUTE);
-  } else if (str_equals_case_insensitive(command, "UNMUTE")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("UNMUTE")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_UNMUTE);
-  } else if (str_equals_case_insensitive(command, "TOGGLE")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("TOGGLE")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_TOGGLE);
-  } else if (str_equals_case_insensitive(command, "TURN_ON")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("TURN_ON")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_TURN_ON);
-  } else if (str_equals_case_insensitive(command, "TURN_OFF")) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("TURN_OFF")) == 0) {
     this->set_command(MEDIA_PLAYER_COMMAND_TURN_OFF);
   } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command.c_str());
+    ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command);
   }
   return *this;
 }
diff --git a/esphome/components/media_player/media_player.h b/esphome/components/media_player/media_player.h
index b753e2d0880..f75a68dd853 100644
--- a/esphome/components/media_player/media_player.h
+++ b/esphome/components/media_player/media_player.h
@@ -114,7 +114,8 @@ class MediaPlayerCall {
 
   MediaPlayerCall &set_command(MediaPlayerCommand command);
   MediaPlayerCall &set_command(optional<MediaPlayerCommand> command);
-  MediaPlayerCall &set_command(const std::string &command);
+  MediaPlayerCall &set_command(const char *command);
+  MediaPlayerCall &set_command(const std::string &command) { return this->set_command(command.c_str()); }
 
   MediaPlayerCall &set_media_url(const std::string &url);
 
diff --git a/esphome/components/mhz19/mhz19.cpp b/esphome/components/mhz19/mhz19.cpp
index b6b4031e169..bccea7d423a 100644
--- a/esphome/components/mhz19/mhz19.cpp
+++ b/esphome/components/mhz19/mhz19.cpp
@@ -137,8 +137,6 @@ bool MHZ19Component::mhz19_write_command_(const uint8_t *command, uint8_t *respo
   return this->read_array(response, MHZ19_RESPONSE_LENGTH);
 }
 
-float MHZ19Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void MHZ19Component::dump_config() {
   ESP_LOGCONFIG(TAG, "MH-Z19:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
diff --git a/esphome/components/mhz19/mhz19.h b/esphome/components/mhz19/mhz19.h
index a27f1c31eb0..e577b985373 100644
--- a/esphome/components/mhz19/mhz19.h
+++ b/esphome/components/mhz19/mhz19.h
@@ -22,8 +22,6 @@ enum MHZ19DetectionRange {
 
 class MHZ19Component : public PollingComponent, public uart::UARTDevice {
  public:
-  float get_setup_priority() const override;
-
   void setup() override;
   void update() override;
   void dump_config() override;
diff --git a/esphome/components/micro_wake_word/micro_wake_word.cpp b/esphome/components/micro_wake_word/micro_wake_word.cpp
index d7e80efc844..b93bf1b556c 100644
--- a/esphome/components/micro_wake_word/micro_wake_word.cpp
+++ b/esphome/components/micro_wake_word/micro_wake_word.cpp
@@ -325,7 +325,7 @@ void MicroWakeWord::loop() {
           ESP_LOGD(TAG, "Detected '%s' with sliding average probability is %.2f and max probability is %.2f",
                    detection_event.wake_word->c_str(), (detection_event.average_probability / uint8_to_float_divisor),
                    (detection_event.max_probability / uint8_to_float_divisor));
-          this->wake_word_detected_trigger_->trigger(*detection_event.wake_word);
+          this->wake_word_detected_trigger_.trigger(*detection_event.wake_word);
           if (this->stop_after_detection_) {
             this->stop();
           }
diff --git a/esphome/components/micro_wake_word/micro_wake_word.h b/esphome/components/micro_wake_word/micro_wake_word.h
index b427e4dfcbd..44d5d893728 100644
--- a/esphome/components/micro_wake_word/micro_wake_word.h
+++ b/esphome/components/micro_wake_word/micro_wake_word.h
@@ -60,7 +60,7 @@ class MicroWakeWord : public Component
 
   void set_stop_after_detection(bool stop_after_detection) { this->stop_after_detection_ = stop_after_detection; }
 
-  Trigger<std::string> *get_wake_word_detected_trigger() const { return this->wake_word_detected_trigger_; }
+  Trigger<std::string> *get_wake_word_detected_trigger() { return &this->wake_word_detected_trigger_; }
 
   void add_wake_word_model(WakeWordModel *model);
 
@@ -78,7 +78,7 @@ class MicroWakeWord : public Component
 
  protected:
   microphone::MicrophoneSource *microphone_source_{nullptr};
-  Trigger<std::string> *wake_word_detected_trigger_ = new Trigger<std::string>();
+  Trigger<std::string> wake_word_detected_trigger_;
   State state_{State::STOPPED};
 
   std::weak_ptr<RingBuffer> ring_buffer_;
diff --git a/esphome/components/mics_4514/mics_4514.cpp b/esphome/components/mics_4514/mics_4514.cpp
index 8181ece94c8..60413b32d78 100644
--- a/esphome/components/mics_4514/mics_4514.cpp
+++ b/esphome/components/mics_4514/mics_4514.cpp
@@ -37,7 +37,6 @@ void MICS4514Component::dump_config() {
   LOG_SENSOR("  ", "Hydrogen", this->hydrogen_sensor_);
   LOG_SENSOR("  ", "Ammonia", this->ammonia_sensor_);
 }
-float MICS4514Component::get_setup_priority() const { return setup_priority::DATA; }
 void MICS4514Component::update() {
   if (!this->warmed_up_) {
     return;
diff --git a/esphome/components/mics_4514/mics_4514.h b/esphome/components/mics_4514/mics_4514.h
index d2fefc36305..e7271314c82 100644
--- a/esphome/components/mics_4514/mics_4514.h
+++ b/esphome/components/mics_4514/mics_4514.h
@@ -19,7 +19,6 @@ class MICS4514Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/midea/climate.py b/esphome/components/midea/climate.py
index b08a47afa99..8a3d4f22ba5 100644
--- a/esphome/components/midea/climate.py
+++ b/esphome/components/midea/climate.py
@@ -30,7 +30,7 @@ from esphome.const import (
     UNIT_PERCENT,
     UNIT_WATT,
 )
-from esphome.core import coroutine
+from esphome.core import CORE, coroutine
 
 CODEOWNERS = ["@dudanov"]
 DEPENDENCIES = ["climate", "uart"]
@@ -290,4 +290,7 @@ async def to_code(config):
     if CONF_HUMIDITY_SETPOINT in config:
         sens = await sensor.new_sensor(config[CONF_HUMIDITY_SETPOINT])
         cg.add(var.set_humidity_setpoint_sensor(sens))
+    # MideaUART library requires WiFi (WiFi auto-enables Network via dependency mapping)
+    if CORE.is_esp32:
+        cg.add_library("WiFi", None)
     cg.add_library("dudanov/MideaUART", "1.1.9")
diff --git a/esphome/components/mipi_dsi/models/waveshare.py b/esphome/components/mipi_dsi/models/waveshare.py
index c3d080f8b20..f83cacc5a3e 100644
--- a/esphome/components/mipi_dsi/models/waveshare.py
+++ b/esphome/components/mipi_dsi/models/waveshare.py
@@ -94,3 +94,29 @@ DriverChip(
         (0x29, 0x00),
     ],
 )
+
+DriverChip(
+    "WAVESHARE-ESP32-P4-WIFI6-TOUCH-LCD-7B",
+    height=600,
+    width=1024,
+    hsync_back_porch=160,
+    hsync_pulse_width=10,
+    hsync_front_porch=160,
+    vsync_back_porch=23,
+    vsync_pulse_width=1,
+    vsync_front_porch=12,
+    pclk_frequency="52MHz",
+    lane_bit_rate="900Mbps",
+    no_transform=True,
+    color_order="RGB",
+    initsequence=[
+        (0x80, 0x8B),
+        (0x81, 0x78),
+        (0x82, 0x84),
+        (0x83, 0x88),
+        (0x84, 0xA8),
+        (0x85, 0xE3),
+        (0x86, 0x88),
+        (0xB2, 0x10),
+    ],
+)
diff --git a/esphome/components/mixer/speaker/automation.h b/esphome/components/mixer/speaker/automation.h
index 22349366289..2fb2f49373b 100644
--- a/esphome/components/mixer/speaker/automation.h
+++ b/esphome/components/mixer/speaker/automation.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "esphome/core/automation.h"
 #include "mixer_speaker.h"
 
 #ifdef USE_ESP32
diff --git a/esphome/components/mlx90393/sensor_mlx90393.cpp b/esphome/components/mlx90393/sensor_mlx90393.cpp
index 21a5b3a829b..ee52f9b9ab0 100644
--- a/esphome/components/mlx90393/sensor_mlx90393.cpp
+++ b/esphome/components/mlx90393/sensor_mlx90393.cpp
@@ -132,8 +132,6 @@ void MLX90393Cls::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->t_sensor_);
 }
 
-float MLX90393Cls::get_setup_priority() const { return setup_priority::DATA; }
-
 void MLX90393Cls::update() {
   MLX90393::txyz data;
 
diff --git a/esphome/components/mlx90393/sensor_mlx90393.h b/esphome/components/mlx90393/sensor_mlx90393.h
index 8a6f3321f98..845ae87e09f 100644
--- a/esphome/components/mlx90393/sensor_mlx90393.h
+++ b/esphome/components/mlx90393/sensor_mlx90393.h
@@ -25,7 +25,6 @@ class MLX90393Cls : public PollingComponent, public i2c::I2CDevice, public MLX90
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_drdy_gpio(GPIOPin *pin) { drdy_pin_ = pin; }
diff --git a/esphome/components/mlx90614/mlx90614.cpp b/esphome/components/mlx90614/mlx90614.cpp
index 8e53b9e3c3b..8a514cbc260 100644
--- a/esphome/components/mlx90614/mlx90614.cpp
+++ b/esphome/components/mlx90614/mlx90614.cpp
@@ -71,8 +71,6 @@ void MLX90614Component::dump_config() {
   LOG_SENSOR("  ", "Object", this->object_sensor_);
 }
 
-float MLX90614Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void MLX90614Component::update() {
   uint8_t emissivity[3];
   if (this->read_register(MLX90614_EMISSIVITY, emissivity, 3) != i2c::ERROR_OK) {
diff --git a/esphome/components/mlx90614/mlx90614.h b/esphome/components/mlx90614/mlx90614.h
index fa6fb523bb0..bf081c3e907 100644
--- a/esphome/components/mlx90614/mlx90614.h
+++ b/esphome/components/mlx90614/mlx90614.h
@@ -12,7 +12,6 @@ class MLX90614Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
   void update() override;
-  float get_setup_priority() const override;
 
   void set_ambient_sensor(sensor::Sensor *ambient_sensor) { ambient_sensor_ = ambient_sensor; }
   void set_object_sensor(sensor::Sensor *object_sensor) { object_sensor_ = object_sensor; }
diff --git a/esphome/components/mmc5603/mmc5603.cpp b/esphome/components/mmc5603/mmc5603.cpp
index d6321eae8ff..1cbc84191f1 100644
--- a/esphome/components/mmc5603/mmc5603.cpp
+++ b/esphome/components/mmc5603/mmc5603.cpp
@@ -91,8 +91,6 @@ void MMC5603Component::dump_config() {
   LOG_SENSOR("  ", "Heading", this->heading_sensor_);
 }
 
-float MMC5603Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void MMC5603Component::update() {
   uint8_t ctrl0 = (this->auto_set_reset_) ? 0x21 : 0x01;
   if (!this->write_byte(MMC56X3_CTRL0_REG, ctrl0)) {
diff --git a/esphome/components/mmc5603/mmc5603.h b/esphome/components/mmc5603/mmc5603.h
index 09718bd3b78..f827e27e042 100644
--- a/esphome/components/mmc5603/mmc5603.h
+++ b/esphome/components/mmc5603/mmc5603.h
@@ -17,7 +17,6 @@ class MMC5603Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_datarate(MMC5603Datarate datarate) { datarate_ = datarate; }
diff --git a/esphome/components/mmc5983/mmc5983.cpp b/esphome/components/mmc5983/mmc5983.cpp
index 1e0065020c7..b038084a72d 100644
--- a/esphome/components/mmc5983/mmc5983.cpp
+++ b/esphome/components/mmc5983/mmc5983.cpp
@@ -133,7 +133,5 @@ void MMC5983Component::dump_config() {
   LOG_SENSOR("  ", "Z", this->z_sensor_);
 }
 
-float MMC5983Component::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace mmc5983
 }  // namespace esphome
diff --git a/esphome/components/mmc5983/mmc5983.h b/esphome/components/mmc5983/mmc5983.h
index d4254189040..3e87e54daa6 100644
--- a/esphome/components/mmc5983/mmc5983.h
+++ b/esphome/components/mmc5983/mmc5983.h
@@ -12,7 +12,6 @@ class MMC5983Component : public PollingComponent, public i2c::I2CDevice {
   void update() override;
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void set_x_sensor(sensor::Sensor *x_sensor) { x_sensor_ = x_sensor; }
   void set_y_sensor(sensor::Sensor *y_sensor) { y_sensor_ = y_sensor; }
diff --git a/esphome/components/mpu6050/mpu6050.cpp b/esphome/components/mpu6050/mpu6050.cpp
index ecbee11c48b..91a84d061ad 100644
--- a/esphome/components/mpu6050/mpu6050.cpp
+++ b/esphome/components/mpu6050/mpu6050.cpp
@@ -140,7 +140,6 @@ void MPU6050Component::update() {
 
   this->status_clear_warning();
 }
-float MPU6050Component::get_setup_priority() const { return setup_priority::DATA; }
 
 }  // namespace mpu6050
 }  // namespace esphome
diff --git a/esphome/components/mpu6050/mpu6050.h b/esphome/components/mpu6050/mpu6050.h
index ab410105c0b..cc7c3620df7 100644
--- a/esphome/components/mpu6050/mpu6050.h
+++ b/esphome/components/mpu6050/mpu6050.h
@@ -14,8 +14,6 @@ class MPU6050Component : public PollingComponent, public i2c::I2CDevice {
 
   void update() override;
 
-  float get_setup_priority() const override;
-
   void set_accel_x_sensor(sensor::Sensor *accel_x_sensor) { accel_x_sensor_ = accel_x_sensor; }
   void set_accel_y_sensor(sensor::Sensor *accel_y_sensor) { accel_y_sensor_ = accel_y_sensor; }
   void set_accel_z_sensor(sensor::Sensor *accel_z_sensor) { accel_z_sensor_ = accel_z_sensor; }
diff --git a/esphome/components/mpu6886/mpu6886.cpp b/esphome/components/mpu6886/mpu6886.cpp
index 6fdf7b86847..68b77b59c99 100644
--- a/esphome/components/mpu6886/mpu6886.cpp
+++ b/esphome/components/mpu6886/mpu6886.cpp
@@ -146,7 +146,5 @@ void MPU6886Component::update() {
   this->status_clear_warning();
 }
 
-float MPU6886Component::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace mpu6886
 }  // namespace esphome
diff --git a/esphome/components/mpu6886/mpu6886.h b/esphome/components/mpu6886/mpu6886.h
index 04551ae56d0..96e2bf61a16 100644
--- a/esphome/components/mpu6886/mpu6886.h
+++ b/esphome/components/mpu6886/mpu6886.h
@@ -14,8 +14,6 @@ class MPU6886Component : public PollingComponent, public i2c::I2CDevice {
 
   void update() override;
 
-  float get_setup_priority() const override;
-
   void set_accel_x_sensor(sensor::Sensor *accel_x_sensor) { accel_x_sensor_ = accel_x_sensor; }
   void set_accel_y_sensor(sensor::Sensor *accel_y_sensor) { accel_y_sensor_ = accel_y_sensor; }
   void set_accel_z_sensor(sensor::Sensor *accel_z_sensor) { accel_z_sensor_ = accel_z_sensor; }
diff --git a/esphome/components/mqtt/mqtt_alarm_control_panel.cpp b/esphome/components/mqtt/mqtt_alarm_control_panel.cpp
index 263e5547787..dc8f75d8f55 100644
--- a/esphome/components/mqtt/mqtt_alarm_control_panel.cpp
+++ b/esphome/components/mqtt/mqtt_alarm_control_panel.cpp
@@ -13,6 +13,33 @@ static const char *const TAG = "mqtt.alarm_control_panel";
 
 using namespace esphome::alarm_control_panel;
 
+static ProgmemStr alarm_state_to_mqtt_str(AlarmControlPanelState state) {
+  switch (state) {
+    case ACP_STATE_DISARMED:
+      return ESPHOME_F("disarmed");
+    case ACP_STATE_ARMED_HOME:
+      return ESPHOME_F("armed_home");
+    case ACP_STATE_ARMED_AWAY:
+      return ESPHOME_F("armed_away");
+    case ACP_STATE_ARMED_NIGHT:
+      return ESPHOME_F("armed_night");
+    case ACP_STATE_ARMED_VACATION:
+      return ESPHOME_F("armed_vacation");
+    case ACP_STATE_ARMED_CUSTOM_BYPASS:
+      return ESPHOME_F("armed_custom_bypass");
+    case ACP_STATE_PENDING:
+      return ESPHOME_F("pending");
+    case ACP_STATE_ARMING:
+      return ESPHOME_F("arming");
+    case ACP_STATE_DISARMING:
+      return ESPHOME_F("disarming");
+    case ACP_STATE_TRIGGERED:
+      return ESPHOME_F("triggered");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
 MQTTAlarmControlPanelComponent::MQTTAlarmControlPanelComponent(AlarmControlPanel *alarm_control_panel)
     : alarm_control_panel_(alarm_control_panel) {}
 void MQTTAlarmControlPanelComponent::setup() {
@@ -85,43 +112,9 @@ const EntityBase *MQTTAlarmControlPanelComponent::get_entity() const { return th
 
 bool MQTTAlarmControlPanelComponent::send_initial_state() { return this->publish_state(); }
 bool MQTTAlarmControlPanelComponent::publish_state() {
-  const char *state_s;
-  switch (this->alarm_control_panel_->get_state()) {
-    case ACP_STATE_DISARMED:
-      state_s = "disarmed";
-      break;
-    case ACP_STATE_ARMED_HOME:
-      state_s = "armed_home";
-      break;
-    case ACP_STATE_ARMED_AWAY:
-      state_s = "armed_away";
-      break;
-    case ACP_STATE_ARMED_NIGHT:
-      state_s = "armed_night";
-      break;
-    case ACP_STATE_ARMED_VACATION:
-      state_s = "armed_vacation";
-      break;
-    case ACP_STATE_ARMED_CUSTOM_BYPASS:
-      state_s = "armed_custom_bypass";
-      break;
-    case ACP_STATE_PENDING:
-      state_s = "pending";
-      break;
-    case ACP_STATE_ARMING:
-      state_s = "arming";
-      break;
-    case ACP_STATE_DISARMING:
-      state_s = "disarming";
-      break;
-    case ACP_STATE_TRIGGERED:
-      state_s = "triggered";
-      break;
-    default:
-      state_s = "unknown";
-  }
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  return this->publish(this->get_state_topic_to_(topic_buf), state_s);
+  return this->publish(this->get_state_topic_to_(topic_buf),
+                       alarm_state_to_mqtt_str(this->alarm_control_panel_->get_state()));
 }
 
 }  // namespace esphome::mqtt
diff --git a/esphome/components/mqtt/mqtt_backend_esp32.h b/esphome/components/mqtt/mqtt_backend_esp32.h
index bd2d2a67b25..adba0cf0046 100644
--- a/esphome/components/mqtt/mqtt_backend_esp32.h
+++ b/esphome/components/mqtt/mqtt_backend_esp32.h
@@ -139,7 +139,8 @@ class MQTTBackendESP32 final : public MQTTBackend {
     this->lwt_retain_ = retain;
   }
   void set_server(network::IPAddress ip, uint16_t port) final {
-    this->host_ = ip.str();
+    char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
+    this->host_ = ip.str_to(ip_buf);
     this->port_ = port;
   }
   void set_server(const char *host, uint16_t port) final {
diff --git a/esphome/components/mqtt/mqtt_climate.cpp b/esphome/components/mqtt/mqtt_climate.cpp
index 37d643f9e71..673593ef842 100644
--- a/esphome/components/mqtt/mqtt_climate.cpp
+++ b/esphome/components/mqtt/mqtt_climate.cpp
@@ -1,5 +1,6 @@
 #include "mqtt_climate.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,111 @@ static const char *const TAG = "mqtt.climate";
 
 using namespace esphome::climate;
 
+static ProgmemStr climate_mode_to_mqtt_str(ClimateMode mode) {
+  switch (mode) {
+    case CLIMATE_MODE_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_MODE_HEAT_COOL:
+      return ESPHOME_F("heat_cool");
+    case CLIMATE_MODE_AUTO:
+      return ESPHOME_F("auto");
+    case CLIMATE_MODE_COOL:
+      return ESPHOME_F("cool");
+    case CLIMATE_MODE_HEAT:
+      return ESPHOME_F("heat");
+    case CLIMATE_MODE_FAN_ONLY:
+      return ESPHOME_F("fan_only");
+    case CLIMATE_MODE_DRY:
+      return ESPHOME_F("dry");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_action_to_mqtt_str(ClimateAction action) {
+  switch (action) {
+    case CLIMATE_ACTION_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_ACTION_COOLING:
+      return ESPHOME_F("cooling");
+    case CLIMATE_ACTION_HEATING:
+      return ESPHOME_F("heating");
+    case CLIMATE_ACTION_IDLE:
+      return ESPHOME_F("idle");
+    case CLIMATE_ACTION_DRYING:
+      return ESPHOME_F("drying");
+    case CLIMATE_ACTION_FAN:
+      return ESPHOME_F("fan");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_fan_mode_to_mqtt_str(ClimateFanMode fan_mode) {
+  switch (fan_mode) {
+    case CLIMATE_FAN_ON:
+      return ESPHOME_F("on");
+    case CLIMATE_FAN_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_FAN_AUTO:
+      return ESPHOME_F("auto");
+    case CLIMATE_FAN_LOW:
+      return ESPHOME_F("low");
+    case CLIMATE_FAN_MEDIUM:
+      return ESPHOME_F("medium");
+    case CLIMATE_FAN_HIGH:
+      return ESPHOME_F("high");
+    case CLIMATE_FAN_MIDDLE:
+      return ESPHOME_F("middle");
+    case CLIMATE_FAN_FOCUS:
+      return ESPHOME_F("focus");
+    case CLIMATE_FAN_DIFFUSE:
+      return ESPHOME_F("diffuse");
+    case CLIMATE_FAN_QUIET:
+      return ESPHOME_F("quiet");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_swing_mode_to_mqtt_str(ClimateSwingMode swing_mode) {
+  switch (swing_mode) {
+    case CLIMATE_SWING_OFF:
+      return ESPHOME_F("off");
+    case CLIMATE_SWING_BOTH:
+      return ESPHOME_F("both");
+    case CLIMATE_SWING_VERTICAL:
+      return ESPHOME_F("vertical");
+    case CLIMATE_SWING_HORIZONTAL:
+      return ESPHOME_F("horizontal");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
+static ProgmemStr climate_preset_to_mqtt_str(ClimatePreset preset) {
+  switch (preset) {
+    case CLIMATE_PRESET_NONE:
+      return ESPHOME_F("none");
+    case CLIMATE_PRESET_HOME:
+      return ESPHOME_F("home");
+    case CLIMATE_PRESET_ECO:
+      return ESPHOME_F("eco");
+    case CLIMATE_PRESET_AWAY:
+      return ESPHOME_F("away");
+    case CLIMATE_PRESET_BOOST:
+      return ESPHOME_F("boost");
+    case CLIMATE_PRESET_COMFORT:
+      return ESPHOME_F("comfort");
+    case CLIMATE_PRESET_SLEEP:
+      return ESPHOME_F("sleep");
+    case CLIMATE_PRESET_ACTIVITY:
+      return ESPHOME_F("activity");
+    default:
+      return ESPHOME_F("unknown");
+  }
+}
+
 void MQTTClimateComponent::send_discovery(JsonObject root, mqtt::SendDiscoveryConfig &config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   auto traits = this->device_->get_traits();
@@ -260,34 +366,8 @@ const EntityBase *MQTTClimateComponent::get_entity() const { return this->device
 bool MQTTClimateComponent::publish_state_() {
   auto traits = this->device_->get_traits();
   // mode
-  const char *mode_s;
-  switch (this->device_->mode) {
-    case CLIMATE_MODE_OFF:
-      mode_s = "off";
-      break;
-    case CLIMATE_MODE_AUTO:
-      mode_s = "auto";
-      break;
-    case CLIMATE_MODE_COOL:
-      mode_s = "cool";
-      break;
-    case CLIMATE_MODE_HEAT:
-      mode_s = "heat";
-      break;
-    case CLIMATE_MODE_FAN_ONLY:
-      mode_s = "fan_only";
-      break;
-    case CLIMATE_MODE_DRY:
-      mode_s = "dry";
-      break;
-    case CLIMATE_MODE_HEAT_COOL:
-      mode_s = "heat_cool";
-      break;
-    default:
-      mode_s = "unknown";
-  }
   bool success = true;
-  if (!this->publish(this->get_mode_state_topic(), mode_s))
+  if (!this->publish(this->get_mode_state_topic(), climate_mode_to_mqtt_str(this->device_->mode)))
     success = false;
   int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
   int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
@@ -327,134 +407,37 @@ bool MQTTClimateComponent::publish_state_() {
   }
 
   if (traits.get_supports_presets() || !traits.get_supported_custom_presets().empty()) {
-    std::string payload;
-    if (this->device_->preset.has_value()) {
-      switch (this->device_->preset.value()) {
-        case CLIMATE_PRESET_NONE:
-          payload = "none";
-          break;
-        case CLIMATE_PRESET_HOME:
-          payload = "home";
-          break;
-        case CLIMATE_PRESET_AWAY:
-          payload = "away";
-          break;
-        case CLIMATE_PRESET_BOOST:
-          payload = "boost";
-          break;
-        case CLIMATE_PRESET_COMFORT:
-          payload = "comfort";
-          break;
-        case CLIMATE_PRESET_ECO:
-          payload = "eco";
-          break;
-        case CLIMATE_PRESET_SLEEP:
-          payload = "sleep";
-          break;
-        case CLIMATE_PRESET_ACTIVITY:
-          payload = "activity";
-          break;
-        default:
-          payload = "unknown";
-      }
-    }
-    if (this->device_->has_custom_preset())
-      payload = this->device_->get_custom_preset().c_str();
-    if (!this->publish(this->get_preset_state_topic(), payload))
+    if (this->device_->has_custom_preset()) {
+      if (!this->publish(this->get_preset_state_topic(), this->device_->get_custom_preset()))
+        success = false;
+    } else if (this->device_->preset.has_value()) {
+      if (!this->publish(this->get_preset_state_topic(), climate_preset_to_mqtt_str(this->device_->preset.value())))
+        success = false;
+    } else if (!this->publish(this->get_preset_state_topic(), "")) {
       success = false;
+    }
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_ACTION)) {
-    const char *payload;
-    switch (this->device_->action) {
-      case CLIMATE_ACTION_OFF:
-        payload = "off";
-        break;
-      case CLIMATE_ACTION_COOLING:
-        payload = "cooling";
-        break;
-      case CLIMATE_ACTION_HEATING:
-        payload = "heating";
-        break;
-      case CLIMATE_ACTION_IDLE:
-        payload = "idle";
-        break;
-      case CLIMATE_ACTION_DRYING:
-        payload = "drying";
-        break;
-      case CLIMATE_ACTION_FAN:
-        payload = "fan";
-        break;
-      default:
-        payload = "unknown";
-    }
-    if (!this->publish(this->get_action_state_topic(), payload))
+    if (!this->publish(this->get_action_state_topic(), climate_action_to_mqtt_str(this->device_->action)))
       success = false;
   }
 
   if (traits.get_supports_fan_modes()) {
-    std::string payload;
-    if (this->device_->fan_mode.has_value()) {
-      switch (this->device_->fan_mode.value()) {
-        case CLIMATE_FAN_ON:
-          payload = "on";
-          break;
-        case CLIMATE_FAN_OFF:
-          payload = "off";
-          break;
-        case CLIMATE_FAN_AUTO:
-          payload = "auto";
-          break;
-        case CLIMATE_FAN_LOW:
-          payload = "low";
-          break;
-        case CLIMATE_FAN_MEDIUM:
-          payload = "medium";
-          break;
-        case CLIMATE_FAN_HIGH:
-          payload = "high";
-          break;
-        case CLIMATE_FAN_MIDDLE:
-          payload = "middle";
-          break;
-        case CLIMATE_FAN_FOCUS:
-          payload = "focus";
-          break;
-        case CLIMATE_FAN_DIFFUSE:
-          payload = "diffuse";
-          break;
-        case CLIMATE_FAN_QUIET:
-          payload = "quiet";
-          break;
-        default:
-          payload = "unknown";
-      }
-    }
-    if (this->device_->has_custom_fan_mode())
-      payload = this->device_->get_custom_fan_mode().c_str();
-    if (!this->publish(this->get_fan_mode_state_topic(), payload))
+    if (this->device_->has_custom_fan_mode()) {
+      if (!this->publish(this->get_fan_mode_state_topic(), this->device_->get_custom_fan_mode()))
+        success = false;
+    } else if (this->device_->fan_mode.has_value()) {
+      if (!this->publish(this->get_fan_mode_state_topic(),
+                         climate_fan_mode_to_mqtt_str(this->device_->fan_mode.value())))
+        success = false;
+    } else if (!this->publish(this->get_fan_mode_state_topic(), "")) {
       success = false;
+    }
   }
 
   if (traits.get_supports_swing_modes()) {
-    const char *payload;
-    switch (this->device_->swing_mode) {
-      case CLIMATE_SWING_OFF:
-        payload = "off";
-        break;
-      case CLIMATE_SWING_BOTH:
-        payload = "both";
-        break;
-      case CLIMATE_SWING_VERTICAL:
-        payload = "vertical";
-        break;
-      case CLIMATE_SWING_HORIZONTAL:
-        payload = "horizontal";
-        break;
-      default:
-        payload = "unknown";
-    }
-    if (!this->publish(this->get_swing_mode_state_topic(), payload))
+    if (!this->publish(this->get_swing_mode_state_topic(), climate_swing_mode_to_mqtt_str(this->device_->swing_mode)))
       success = false;
   }
 
diff --git a/esphome/components/mqtt/mqtt_component.cpp b/esphome/components/mqtt/mqtt_component.cpp
index aec6140e3f1..a77afd3f4ed 100644
--- a/esphome/components/mqtt/mqtt_component.cpp
+++ b/esphome/components/mqtt/mqtt_component.cpp
@@ -5,6 +5,7 @@
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/version.h"
 
 #include "mqtt_const.h"
@@ -149,6 +150,22 @@ bool MQTTComponent::publish(const char *topic, const char *payload) {
   return this->publish(topic, payload, strlen(payload));
 }
 
+#ifdef USE_ESP8266
+bool MQTTComponent::publish(const std::string &topic, ProgmemStr payload) {
+  return this->publish(topic.c_str(), payload);
+}
+
+bool MQTTComponent::publish(const char *topic, ProgmemStr payload) {
+  if (topic[0] == '\0')
+    return false;
+  // On ESP8266, ProgmemStr is __FlashStringHelper* - need to copy from flash
+  char buf[64];
+  strncpy_P(buf, reinterpret_cast<const char *>(payload), sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  return global_mqtt_client->publish(topic, buf, strlen(buf), this->qos_, this->retain_);
+}
+#endif
+
 bool MQTTComponent::publish_json(const std::string &topic, const json::json_build_t &f) {
   return this->publish_json(topic.c_str(), f);
 }
diff --git a/esphome/components/mqtt/mqtt_component.h b/esphome/components/mqtt/mqtt_component.h
index 304a2c0d0e4..2cec6fda7ed 100644
--- a/esphome/components/mqtt/mqtt_component.h
+++ b/esphome/components/mqtt/mqtt_component.h
@@ -9,6 +9,7 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"
 #include "mqtt_client.h"
 
@@ -157,6 +158,15 @@ class MQTTComponent : public Component {
    */
   bool publish(const std::string &topic, const char *payload, size_t payload_length);
 
+  /** Send a MQTT message.
+   *
+   * @param topic The topic.
+   * @param payload The null-terminated payload.
+   */
+  bool publish(const std::string &topic, const char *payload) {
+    return this->publish(topic.c_str(), payload, strlen(payload));
+  }
+
   /** Send a MQTT message (no heap allocation for topic).
    *
    * @param topic The topic as C string.
@@ -189,6 +199,29 @@ class MQTTComponent : public Component {
    */
   bool publish(StringRef topic, const char *payload) { return this->publish(topic.c_str(), payload); }
 
+#ifdef USE_ESP8266
+  /** Send a MQTT message with a PROGMEM string payload.
+   *
+   * @param topic The topic.
+   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
+   */
+  bool publish(const std::string &topic, ProgmemStr payload);
+
+  /** Send a MQTT message with a PROGMEM string payload (no heap allocation for topic).
+   *
+   * @param topic The topic as C string.
+   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
+   */
+  bool publish(const char *topic, ProgmemStr payload);
+
+  /** Send a MQTT message with a PROGMEM string payload (no heap allocation for topic).
+   *
+   * @param topic The topic as StringRef (for use with get_state_topic_to_()).
+   * @param payload The payload (ProgmemStr - stored in flash on ESP8266).
+   */
+  bool publish(StringRef topic, ProgmemStr payload) { return this->publish(topic.c_str(), payload); }
+#endif
+
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.
diff --git a/esphome/components/mqtt/mqtt_cover.cpp b/esphome/components/mqtt/mqtt_cover.cpp
index d5bd13869a6..50e68ecbcc9 100644
--- a/esphome/components/mqtt/mqtt_cover.cpp
+++ b/esphome/components/mqtt/mqtt_cover.cpp
@@ -1,5 +1,6 @@
 #include "mqtt_cover.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,20 @@ static const char *const TAG = "mqtt.cover";
 
 using namespace esphome::cover;
 
+static ProgmemStr cover_state_to_mqtt_str(CoverOperation operation, float position, bool supports_position) {
+  if (operation == COVER_OPERATION_OPENING)
+    return ESPHOME_F("opening");
+  if (operation == COVER_OPERATION_CLOSING)
+    return ESPHOME_F("closing");
+  if (position == COVER_CLOSED)
+    return ESPHOME_F("closed");
+  if (position == COVER_OPEN)
+    return ESPHOME_F("open");
+  if (supports_position)
+    return ESPHOME_F("open");
+  return ESPHOME_F("unknown");
+}
+
 MQTTCoverComponent::MQTTCoverComponent(Cover *cover) : cover_(cover) {}
 void MQTTCoverComponent::setup() {
   auto traits = this->cover_->get_traits();
@@ -109,14 +124,10 @@ bool MQTTCoverComponent::publish_state() {
     if (!this->publish(this->get_tilt_state_topic(), pos, len))
       success = false;
   }
-  const char *state_s = this->cover_->current_operation == COVER_OPERATION_OPENING   ? "opening"
-                        : this->cover_->current_operation == COVER_OPERATION_CLOSING ? "closing"
-                        : this->cover_->position == COVER_CLOSED                     ? "closed"
-                        : this->cover_->position == COVER_OPEN                       ? "open"
-                        : traits.get_supports_position()                             ? "open"
-                                                                                     : "unknown";
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_to_(topic_buf),
+                     cover_state_to_mqtt_str(this->cover_->current_operation, this->cover_->position,
+                                             traits.get_supports_position())))
     success = false;
   return success;
 }
diff --git a/esphome/components/mqtt/mqtt_fan.cpp b/esphome/components/mqtt/mqtt_fan.cpp
index c9791fb0f1e..84d51895c50 100644
--- a/esphome/components/mqtt/mqtt_fan.cpp
+++ b/esphome/components/mqtt/mqtt_fan.cpp
@@ -1,5 +1,6 @@
 #include "mqtt_fan.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,14 @@ static const char *const TAG = "mqtt.fan";
 
 using namespace esphome::fan;
 
+static ProgmemStr fan_direction_to_mqtt_str(FanDirection direction) {
+  return direction == FanDirection::FORWARD ? ESPHOME_F("forward") : ESPHOME_F("reverse");
+}
+
+static ProgmemStr fan_oscillation_to_mqtt_str(bool oscillating) {
+  return oscillating ? ESPHOME_F("oscillate_on") : ESPHOME_F("oscillate_off");
+}
+
 MQTTFanComponent::MQTTFanComponent(Fan *state) : state_(state) {}
 
 Fan *MQTTFanComponent::get_state() const { return this->state_; }
@@ -164,13 +173,12 @@ bool MQTTFanComponent::publish_state() {
   this->publish(this->get_state_topic_to_(topic_buf), state_s);
   bool failed = false;
   if (this->state_->get_traits().supports_direction()) {
-    bool success = this->publish(this->get_direction_state_topic(),
-                                 this->state_->direction == fan::FanDirection::FORWARD ? "forward" : "reverse");
+    bool success = this->publish(this->get_direction_state_topic(), fan_direction_to_mqtt_str(this->state_->direction));
     failed = failed || !success;
   }
   if (this->state_->get_traits().supports_oscillation()) {
-    bool success = this->publish(this->get_oscillation_state_topic(),
-                                 this->state_->oscillating ? "oscillate_on" : "oscillate_off");
+    bool success =
+        this->publish(this->get_oscillation_state_topic(), fan_oscillation_to_mqtt_str(this->state_->oscillating));
     failed = failed || !success;
   }
   auto traits = this->state_->get_traits();
diff --git a/esphome/components/mqtt/mqtt_light.cpp b/esphome/components/mqtt/mqtt_light.cpp
index 3e3537fa5cb..aa47bdf996a 100644
--- a/esphome/components/mqtt/mqtt_light.cpp
+++ b/esphome/components/mqtt/mqtt_light.cpp
@@ -47,7 +47,6 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
   root[ESPHOME_F("schema")] = ESPHOME_F("json");
   auto traits = this->state_->get_traits();
 
-  root[MQTT_COLOR_MODE] = true;
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   JsonArray color_modes = root[ESPHOME_F("supported_color_modes")].to<JsonArray>();
   if (traits.supports_color_mode(ColorMode::ON_OFF))
@@ -68,10 +67,6 @@ void MQTTJSONLightComponent::send_discovery(JsonObject root, mqtt::SendDiscovery
   if (traits.supports_color_mode(ColorMode::RGB_COLD_WARM_WHITE))
     color_modes.add(ESPHOME_F("rgbww"));
 
-  // legacy API
-  if (traits.supports_color_capability(ColorCapability::BRIGHTNESS))
-    root[ESPHOME_F("brightness")] = true;
-
   if (traits.supports_color_mode(ColorMode::COLOR_TEMPERATURE) ||
       traits.supports_color_mode(ColorMode::COLD_WARM_WHITE)) {
     root[MQTT_MIN_MIREDS] = traits.get_min_mireds();
diff --git a/esphome/components/mqtt/mqtt_valve.cpp b/esphome/components/mqtt/mqtt_valve.cpp
index 2e100823bfd..16e25f6a8a1 100644
--- a/esphome/components/mqtt/mqtt_valve.cpp
+++ b/esphome/components/mqtt/mqtt_valve.cpp
@@ -1,5 +1,6 @@
 #include "mqtt_valve.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include "mqtt_const.h"
 
@@ -12,6 +13,20 @@ static const char *const TAG = "mqtt.valve";
 
 using namespace esphome::valve;
 
+static ProgmemStr valve_state_to_mqtt_str(ValveOperation operation, float position, bool supports_position) {
+  if (operation == VALVE_OPERATION_OPENING)
+    return ESPHOME_F("opening");
+  if (operation == VALVE_OPERATION_CLOSING)
+    return ESPHOME_F("closing");
+  if (position == VALVE_CLOSED)
+    return ESPHOME_F("closed");
+  if (position == VALVE_OPEN)
+    return ESPHOME_F("open");
+  if (supports_position)
+    return ESPHOME_F("open");
+  return ESPHOME_F("unknown");
+}
+
 MQTTValveComponent::MQTTValveComponent(Valve *valve) : valve_(valve) {}
 void MQTTValveComponent::setup() {
   auto traits = this->valve_->get_traits();
@@ -78,14 +93,10 @@ bool MQTTValveComponent::publish_state() {
     if (!this->publish(this->get_position_state_topic(), pos, len))
       success = false;
   }
-  const char *state_s = this->valve_->current_operation == VALVE_OPERATION_OPENING   ? "opening"
-                        : this->valve_->current_operation == VALVE_OPERATION_CLOSING ? "closing"
-                        : this->valve_->position == VALVE_CLOSED                     ? "closed"
-                        : this->valve_->position == VALVE_OPEN                       ? "open"
-                        : traits.get_supports_position()                             ? "open"
-                                                                                     : "unknown";
   char topic_buf[MQTT_DEFAULT_TOPIC_MAX_LEN];
-  if (!this->publish(this->get_state_topic_to_(topic_buf), state_s))
+  if (!this->publish(this->get_state_topic_to_(topic_buf),
+                     valve_state_to_mqtt_str(this->valve_->current_operation, this->valve_->position,
+                                             traits.get_supports_position())))
     success = false;
   return success;
 }
diff --git a/esphome/components/ms5611/ms5611.cpp b/esphome/components/ms5611/ms5611.cpp
index 5a7622e783e..7ed73400c80 100644
--- a/esphome/components/ms5611/ms5611.cpp
+++ b/esphome/components/ms5611/ms5611.cpp
@@ -38,7 +38,6 @@ void MS5611Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
 }
-float MS5611Component::get_setup_priority() const { return setup_priority::DATA; }
 void MS5611Component::update() {
   // request temperature reading
   if (!this->write_bytes(MS5611_CMD_CONV_D2 + 0x08, nullptr, 0)) {
diff --git a/esphome/components/ms5611/ms5611.h b/esphome/components/ms5611/ms5611.h
index 476db79612a..7e4806f3194 100644
--- a/esphome/components/ms5611/ms5611.h
+++ b/esphome/components/ms5611/ms5611.h
@@ -11,7 +11,6 @@ class MS5611Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
diff --git a/esphome/components/msa3xx/msa3xx.cpp b/esphome/components/msa3xx/msa3xx.cpp
index 56dc919968b..e46bfed193a 100644
--- a/esphome/components/msa3xx/msa3xx.cpp
+++ b/esphome/components/msa3xx/msa3xx.cpp
@@ -287,7 +287,6 @@ void MSA3xxComponent::update() {
   this->status_.never_published = false;
   this->status_clear_warning();
 }
-float MSA3xxComponent::get_setup_priority() const { return setup_priority::DATA; }
 
 void MSA3xxComponent::set_offset(float offset_x, float offset_y, float offset_z) {
   this->offset_x_ = offset_x;
diff --git a/esphome/components/msa3xx/msa3xx.h b/esphome/components/msa3xx/msa3xx.h
index 644109dab04..439d3b5f4dc 100644
--- a/esphome/components/msa3xx/msa3xx.h
+++ b/esphome/components/msa3xx/msa3xx.h
@@ -220,8 +220,6 @@ class MSA3xxComponent : public PollingComponent, public i2c::I2CDevice {
   void loop() override;
   void update() override;
 
-  float get_setup_priority() const override;
-
   void set_model(Model model) { this->model_ = model; }
   void set_offset(float offset_x, float offset_y, float offset_z);
   void set_range(Range range) { this->range_ = range; }
diff --git a/esphome/components/nau7802/nau7802.cpp b/esphome/components/nau7802/nau7802.cpp
index 5edbc798625..937239b98d2 100644
--- a/esphome/components/nau7802/nau7802.cpp
+++ b/esphome/components/nau7802/nau7802.cpp
@@ -296,8 +296,6 @@ void NAU7802Sensor::loop() {
   }
 }
 
-float NAU7802Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void NAU7802Sensor::update() {
   if (!this->is_data_ready_()) {
     ESP_LOGW(TAG, "No measurements ready!");
diff --git a/esphome/components/nau7802/nau7802.h b/esphome/components/nau7802/nau7802.h
index 05452851caf..ae39e167a4d 100644
--- a/esphome/components/nau7802/nau7802.h
+++ b/esphome/components/nau7802/nau7802.h
@@ -62,7 +62,6 @@ class NAU7802Sensor : public sensor::Sensor, public PollingComponent, public i2c
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/network/__init__.py b/esphome/components/network/__init__.py
index 5b63bbfce93..1f75b12178a 100644
--- a/esphome/components/network/__init__.py
+++ b/esphome/components/network/__init__.py
@@ -137,8 +137,7 @@ CONFIG_SCHEMA = cv.Schema(
 @coroutine_with_priority(CoroPriority.NETWORK)
 async def to_code(config):
     cg.add_define("USE_NETWORK")
-    if CORE.using_arduino and CORE.is_esp32:
-        cg.add_library("Networking", None)
+    # ESP32 with Arduino uses ESP-IDF network APIs directly, no Arduino Network library needed
 
     # Apply high performance networking settings
     # Config can explicitly enable/disable, or default to component-driven behavior
diff --git a/esphome/components/nextion/nextion.cpp b/esphome/components/nextion/nextion.cpp
index e57a258edba..fd6ce0a24b2 100644
--- a/esphome/components/nextion/nextion.cpp
+++ b/esphome/components/nextion/nextion.cpp
@@ -193,7 +193,6 @@ void Nextion::dump_config() {
 #endif
 }
 
-float Nextion::get_setup_priority() const { return setup_priority::DATA; }
 void Nextion::update() {
   if (!this->is_setup()) {
     return;
diff --git a/esphome/components/nextion/nextion.h b/esphome/components/nextion/nextion.h
index c543e14bfee..c42ddba9b57 100644
--- a/esphome/components/nextion/nextion.h
+++ b/esphome/components/nextion/nextion.h
@@ -1048,7 +1048,6 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
 
   void setup() override;
   void set_brightness(float brightness) { this->brightness_ = brightness; }
-  float get_setup_priority() const override;
   void update() override;
   void loop() override;
   void set_writer(const nextion_writer_t &writer);
diff --git a/esphome/components/npi19/npi19.cpp b/esphome/components/npi19/npi19.cpp
index c531d2ec8f8..995abdff376 100644
--- a/esphome/components/npi19/npi19.cpp
+++ b/esphome/components/npi19/npi19.cpp
@@ -29,8 +29,6 @@ void NPI19Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
 }
 
-float NPI19Component::get_setup_priority() const { return setup_priority::DATA; }
-
 i2c::ErrorCode NPI19Component::read_(uint16_t &raw_temperature, uint16_t &raw_pressure) {
   // initiate data read from device
   i2c::ErrorCode w_err = write(&READ_COMMAND, sizeof(READ_COMMAND));
diff --git a/esphome/components/npi19/npi19.h b/esphome/components/npi19/npi19.h
index df289dffc19..8e6a8e3bfa5 100644
--- a/esphome/components/npi19/npi19.h
+++ b/esphome/components/npi19/npi19.h
@@ -15,7 +15,6 @@ class NPI19Component : public PollingComponent, public i2c::I2CDevice {
     this->raw_pressure_sensor_ = raw_pressure_sensor;
   }
 
-  float get_setup_priority() const override;
   void setup() override;
   void dump_config() override;
   void update() override;
diff --git a/esphome/components/ntc/ntc.cpp b/esphome/components/ntc/ntc.cpp
index cc500ba429f..e2097bdd770 100644
--- a/esphome/components/ntc/ntc.cpp
+++ b/esphome/components/ntc/ntc.cpp
@@ -12,7 +12,6 @@ void NTC::setup() {
     this->process_(this->sensor_->state);
 }
 void NTC::dump_config() { LOG_SENSOR("", "NTC Sensor", this); }
-float NTC::get_setup_priority() const { return setup_priority::DATA; }
 void NTC::process_(float value) {
   if (std::isnan(value)) {
     this->publish_state(NAN);
diff --git a/esphome/components/ntc/ntc.h b/esphome/components/ntc/ntc.h
index c8592e0fe81..a0c72340dee 100644
--- a/esphome/components/ntc/ntc.h
+++ b/esphome/components/ntc/ntc.h
@@ -14,7 +14,6 @@ class NTC : public Component, public sensor::Sensor {
   void set_c(double c) { c_ = c; }
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
  protected:
   void process_(float value);
diff --git a/esphome/components/opentherm/__init__.py b/esphome/components/opentherm/__init__.py
index 8cbee1eed24..dddb9dc8918 100644
--- a/esphome/components/opentherm/__init__.py
+++ b/esphome/components/opentherm/__init__.py
@@ -4,8 +4,10 @@ from typing import Any
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import sensor
+from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_TRIGGER_ID, PLATFORM_ESP32, PLATFORM_ESP8266
+from esphome.core import CORE
 
 from . import const, generate, schema, validate
 
@@ -83,6 +85,12 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config: dict[str, Any]) -> None:
+    if CORE.is_esp32:
+        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
+        # Provides driver/timer.h header for hardware timer API
+        # TODO: Remove this once opentherm migrates to GPTimer API (driver/gptimer.h)
+        include_builtin_idf_component("driver")
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
diff --git a/esphome/components/opentherm/generate.py b/esphome/components/opentherm/generate.py
index 4e6f3b0a127..0b39895798e 100644
--- a/esphome/components/opentherm/generate.py
+++ b/esphome/components/opentherm/generate.py
@@ -31,7 +31,9 @@ def define_has_settings(keys: list[str], schemas: dict[str, SettingSchema]) -> N
         cg.RawExpression(
             " sep ".join(
                 map(
-                    lambda key: f"F({schemas[key].backing_type}, {key}_setting, {schemas[key].default_value})",
+                    lambda key: (
+                        f"F({schemas[key].backing_type}, {key}_setting, {schemas[key].default_value})"
+                    ),
                     keys,
                 )
             )
diff --git a/esphome/components/opentherm/opentherm.cpp b/esphome/components/opentherm/opentherm.cpp
index 2bf438a52fb..cdf89207bcf 100644
--- a/esphome/components/opentherm/opentherm.cpp
+++ b/esphome/components/opentherm/opentherm.cpp
@@ -8,6 +8,8 @@
 #include "opentherm.h"
 #include "esphome/core/helpers.h"
 #include <cinttypes>
+// TODO: Migrate from legacy timer API (driver/timer.h) to GPTimer API (driver/gptimer.h)
+// The legacy timer API is deprecated in ESP-IDF 5.x. See opentherm.h for details.
 #ifdef USE_ESP32
 #include "driver/timer.h"
 #include "esp_err.h"
diff --git a/esphome/components/opentherm/opentherm.h b/esphome/components/opentherm/opentherm.h
index 3996481760a..a2c347d0d8e 100644
--- a/esphome/components/opentherm/opentherm.h
+++ b/esphome/components/opentherm/opentherm.h
@@ -12,6 +12,10 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+// TODO: Migrate from legacy timer API (driver/timer.h) to GPTimer API (driver/gptimer.h)
+// The legacy timer API is deprecated in ESP-IDF 5.x. Migration would allow removing the
+// "driver" IDF component dependency. See:
+// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/peripherals.html#id4
 #ifdef USE_ESP32
 #include "driver/timer.h"
 #endif
diff --git a/esphome/components/openthread/__init__.py b/esphome/components/openthread/__init__.py
index 26c05a0a862..89d335c574e 100644
--- a/esphome/components/openthread/__init__.py
+++ b/esphome/components/openthread/__init__.py
@@ -4,6 +4,7 @@ from esphome.components.esp32 import (
     VARIANT_ESP32C6,
     VARIANT_ESP32H2,
     add_idf_sdkconfig_option,
+    include_builtin_idf_component,
     only_on_variant,
     require_vfs_select,
 )
@@ -172,6 +173,9 @@ FINAL_VALIDATE_SCHEMA = _final_validate
 
 
 async def to_code(config):
+    # Re-enable openthread IDF component (excluded by default)
+    include_builtin_idf_component("openthread")
+
     cg.add_define("USE_OPENTHREAD")
 
     # OpenThread SRP needs access to mDNS services after setup
diff --git a/esphome/components/opt3001/opt3001.cpp b/esphome/components/opt3001/opt3001.cpp
index f5f7ab9412a..a942e450355 100644
--- a/esphome/components/opt3001/opt3001.cpp
+++ b/esphome/components/opt3001/opt3001.cpp
@@ -116,7 +116,5 @@ void OPT3001Sensor::update() {
   });
 }
 
-float OPT3001Sensor::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace opt3001
 }  // namespace esphome
diff --git a/esphome/components/opt3001/opt3001.h b/esphome/components/opt3001/opt3001.h
index ae3fde5c54d..3bce9f0aeb0 100644
--- a/esphome/components/opt3001/opt3001.h
+++ b/esphome/components/opt3001/opt3001.h
@@ -12,7 +12,6 @@ class OPT3001Sensor : public sensor::Sensor, public PollingComponent, public i2c
  public:
   void dump_config() override;
   void update() override;
-  float get_setup_priority() const override;
 
  protected:
   // checks if one-shot is complete before reading the result and returning it
diff --git a/esphome/components/pcf85063/pcf85063.cpp b/esphome/components/pcf85063/pcf85063.cpp
index f38b60b55d4..03ed78654fa 100644
--- a/esphome/components/pcf85063/pcf85063.cpp
+++ b/esphome/components/pcf85063/pcf85063.cpp
@@ -26,8 +26,6 @@ void PCF85063Component::dump_config() {
   RealTimeClock::dump_config();
 }
 
-float PCF85063Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void PCF85063Component::read_time() {
   if (!this->read_rtc_()) {
     return;
diff --git a/esphome/components/pcf85063/pcf85063.h b/esphome/components/pcf85063/pcf85063.h
index b7034d4f00f..697837f223b 100644
--- a/esphome/components/pcf85063/pcf85063.h
+++ b/esphome/components/pcf85063/pcf85063.h
@@ -12,7 +12,6 @@ class PCF85063Component : public time::RealTimeClock, public i2c::I2CDevice {
   void setup() override;
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void read_time();
   void write_time();
 
diff --git a/esphome/components/pcf8563/pcf8563.cpp b/esphome/components/pcf8563/pcf8563.cpp
index 2090936bb69..dc68807aefa 100644
--- a/esphome/components/pcf8563/pcf8563.cpp
+++ b/esphome/components/pcf8563/pcf8563.cpp
@@ -26,8 +26,6 @@ void PCF8563Component::dump_config() {
   RealTimeClock::dump_config();
 }
 
-float PCF8563Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void PCF8563Component::read_time() {
   if (!this->read_rtc_()) {
     return;
diff --git a/esphome/components/pcf8563/pcf8563.h b/esphome/components/pcf8563/pcf8563.h
index 81aa816b42d..cd37d05816d 100644
--- a/esphome/components/pcf8563/pcf8563.h
+++ b/esphome/components/pcf8563/pcf8563.h
@@ -12,7 +12,6 @@ class PCF8563Component : public time::RealTimeClock, public i2c::I2CDevice {
   void setup() override;
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void read_time();
   void write_time();
 
diff --git a/esphome/components/pm1006/pm1006.cpp b/esphome/components/pm1006/pm1006.cpp
index c466c4bb25d..fe8890e7774 100644
--- a/esphome/components/pm1006/pm1006.cpp
+++ b/esphome/components/pm1006/pm1006.cpp
@@ -44,8 +44,6 @@ void PM1006Component::loop() {
   }
 }
 
-float PM1006Component::get_setup_priority() const { return setup_priority::DATA; }
-
 uint8_t PM1006Component::pm1006_checksum_(const uint8_t *command_data, uint8_t length) const {
   uint8_t sum = 0;
   for (uint8_t i = 0; i < length; i++) {
diff --git a/esphome/components/pm1006/pm1006.h b/esphome/components/pm1006/pm1006.h
index 98637dad716..6b6332e1e33 100644
--- a/esphome/components/pm1006/pm1006.h
+++ b/esphome/components/pm1006/pm1006.h
@@ -18,8 +18,6 @@ class PM1006Component : public PollingComponent, public uart::UARTDevice {
   void loop() override;
   void update() override;
 
-  float get_setup_priority() const override;
-
  protected:
   optional<bool> check_byte_() const;
   void parse_data_();
diff --git a/esphome/components/pm2005/pm2005.h b/esphome/components/pm2005/pm2005.h
index 219fbae5cb9..e788569b7e0 100644
--- a/esphome/components/pm2005/pm2005.h
+++ b/esphome/components/pm2005/pm2005.h
@@ -14,8 +14,6 @@ enum SensorType {
 
 class PM2005Component : public PollingComponent, public i2c::I2CDevice {
  public:
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
-
   void set_sensor_type(SensorType sensor_type) { this->sensor_type_ = sensor_type; }
 
   void set_pm_1_0_sensor(sensor::Sensor *pm_1_0_sensor) { this->pm_1_0_sensor_ = pm_1_0_sensor; }
diff --git a/esphome/components/pmwcs3/pmwcs3.cpp b/esphome/components/pmwcs3/pmwcs3.cpp
index 95638851b50..2ed7789c53d 100644
--- a/esphome/components/pmwcs3/pmwcs3.cpp
+++ b/esphome/components/pmwcs3/pmwcs3.cpp
@@ -53,8 +53,6 @@ void PMWCS3Component::water_calibration() {
 
 void PMWCS3Component::update() { this->read_data_(); }
 
-float PMWCS3Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void PMWCS3Component::dump_config() {
   ESP_LOGCONFIG(TAG, "PMWCS3");
   LOG_I2C_DEVICE(this);
diff --git a/esphome/components/pmwcs3/pmwcs3.h b/esphome/components/pmwcs3/pmwcs3.h
index d63c5165864..b1e26eec4fd 100644
--- a/esphome/components/pmwcs3/pmwcs3.h
+++ b/esphome/components/pmwcs3/pmwcs3.h
@@ -14,7 +14,6 @@ class PMWCS3Component : public PollingComponent, public i2c::I2CDevice {
  public:
   void update() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
   void set_e25_sensor(sensor::Sensor *e25_sensor) { e25_sensor_ = e25_sensor; }
   void set_ec_sensor(sensor::Sensor *ec_sensor) { ec_sensor_ = ec_sensor; }
diff --git a/esphome/components/pn532/pn532.cpp b/esphome/components/pn532/pn532.cpp
index 733810c242b..5366aab54e4 100644
--- a/esphome/components/pn532/pn532.cpp
+++ b/esphome/components/pn532/pn532.cpp
@@ -426,8 +426,6 @@ bool PN532::write_tag_(nfc::NfcTagUid &uid, nfc::NdefMessage *message) {
   return false;
 }
 
-float PN532::get_setup_priority() const { return setup_priority::DATA; }
-
 void PN532::dump_config() {
   ESP_LOGCONFIG(TAG, "PN532:");
   switch (this->error_code_) {
diff --git a/esphome/components/pn532/pn532.h b/esphome/components/pn532/pn532.h
index 488ec4af3ba..73a6c151640 100644
--- a/esphome/components/pn532/pn532.h
+++ b/esphome/components/pn532/pn532.h
@@ -35,7 +35,6 @@ class PN532 : public PollingComponent {
   void dump_config() override;
 
   void update() override;
-  float get_setup_priority() const override;
 
   void loop() override;
   void on_powerdown() override { powerdown(); }
diff --git a/esphome/components/pulse_counter/pulse_counter_sensor.h b/esphome/components/pulse_counter/pulse_counter_sensor.h
index 5ba59cca2ad..f906e9e5cb3 100644
--- a/esphome/components/pulse_counter/pulse_counter_sensor.h
+++ b/esphome/components/pulse_counter/pulse_counter_sensor.h
@@ -6,6 +6,10 @@
 
 #include <cinttypes>
 
+// TODO: Migrate from legacy PCNT API (driver/pcnt.h) to new PCNT API (driver/pulse_cnt.h)
+// The legacy PCNT API is deprecated in ESP-IDF 5.x. Migration would allow removing the
+// "driver" IDF component dependency. See:
+// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/peripherals.html#id6
 #if defined(USE_ESP32) && !defined(USE_ESP32_VARIANT_ESP32C3)
 #include <driver/pcnt.h>
 #define HAS_PCNT
diff --git a/esphome/components/pulse_counter/sensor.py b/esphome/components/pulse_counter/sensor.py
index dbf67fd2adf..65be5ee7936 100644
--- a/esphome/components/pulse_counter/sensor.py
+++ b/esphome/components/pulse_counter/sensor.py
@@ -1,6 +1,7 @@
 from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import sensor
+from esphome.components.esp32 import include_builtin_idf_component
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_COUNT_MODE,
@@ -126,7 +127,14 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = await sensor.new_sensor(config, config.get(CONF_USE_PCNT))
+    use_pcnt = config.get(CONF_USE_PCNT)
+    if CORE.is_esp32 and use_pcnt:
+        # Re-enable ESP-IDF's legacy driver component (excluded by default to save compile time)
+        # Provides driver/pcnt.h header for hardware pulse counter API
+        # TODO: Remove this once pulse_counter migrates to new PCNT API (driver/pulse_cnt.h)
+        include_builtin_idf_component("driver")
+
+    var = await sensor.new_sensor(config, use_pcnt)
     await cg.register_component(var, config)
 
     pin = await cg.gpio_pin_expression(config[CONF_PIN])
diff --git a/esphome/components/pulse_meter/pulse_meter_sensor.cpp b/esphome/components/pulse_meter/pulse_meter_sensor.cpp
index 9a7630a7be9..007deb66e5b 100644
--- a/esphome/components/pulse_meter/pulse_meter_sensor.cpp
+++ b/esphome/components/pulse_meter/pulse_meter_sensor.cpp
@@ -125,8 +125,6 @@ void PulseMeterSensor::loop() {
   }
 }
 
-float PulseMeterSensor::get_setup_priority() const { return setup_priority::DATA; }
-
 void PulseMeterSensor::dump_config() {
   LOG_SENSOR("", "Pulse Meter", this);
   LOG_PIN("  Pin: ", this->pin_);
diff --git a/esphome/components/pulse_meter/pulse_meter_sensor.h b/esphome/components/pulse_meter/pulse_meter_sensor.h
index 748bab29ac2..5800c4ec42a 100644
--- a/esphome/components/pulse_meter/pulse_meter_sensor.h
+++ b/esphome/components/pulse_meter/pulse_meter_sensor.h
@@ -27,7 +27,6 @@ class PulseMeterSensor : public sensor::Sensor, public Component {
 
   void setup() override;
   void loop() override;
-  float get_setup_priority() const override;
   void dump_config() override;
 
  protected:
diff --git a/esphome/components/pylontech/pylontech.cpp b/esphome/components/pylontech/pylontech.cpp
index 74b7caefb29..1dc7caaf166 100644
--- a/esphome/components/pylontech/pylontech.cpp
+++ b/esphome/components/pylontech/pylontech.cpp
@@ -2,6 +2,28 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
+// Helper macros
+#define PARSE_INT(field, field_name) \
+  { \
+    get_token(token_buf); \
+    auto val = parse_number<int>(token_buf); \
+    if (val.has_value()) { \
+      (field) = val.value(); \
+    } else { \
+      ESP_LOGD(TAG, "invalid " field_name " in line %s", buffer.substr(0, buffer.size() - 2).c_str()); \
+      return; \
+    } \
+  }
+
+#define PARSE_STR(field, field_name) \
+  { \
+    get_token(field); \
+    if (strlen(field) < 2) { \
+      ESP_LOGD(TAG, "too short " field_name " in line %s", buffer.substr(0, buffer.size() - 2).c_str()); \
+      return; \
+    } \
+  }
+
 namespace esphome {
 namespace pylontech {
 
@@ -64,40 +86,114 @@ void PylontechComponent::loop() {
 void PylontechComponent::process_line_(std::string &buffer) {
   ESP_LOGV(TAG, "Read from serial: %s", buffer.substr(0, buffer.size() - 2).c_str());
   // clang-format off
-  // example line to parse:
-  // Power Volt  Curr Tempr Tlow  Thigh  Vlow Vhigh Base.St Volt.St Curr.St Temp.St Coulomb Time                B.V.St B.T.St MosTempr M.T.St
-  // 1    50548  8910 25000 24200 25000  3368 3371  Charge  Normal  Normal  Normal  97%     2021-06-30 20:49:45 Normal Normal 22700    Normal
+  // example lines to parse:
+  // Power Volt   Curr   Tempr  Tlow   Thigh  Vlow   Vhigh  Base.St  Volt.St  Curr.St  Temp.St  Coulomb  Time                 B.V.St   B.T.St   MosTempr M.T.St
+  // 1     50548  8910   25000  24200  25000  3368   3371   Charge   Normal   Normal   Normal   97%      2021-06-30 20:49:45  Normal  Normal  22700    Normal
+  // 1     46012  1255   9100   5300   5500   3047   3091   SysError Low      Normal   Normal   4%       2025-11-28 17:56:33  Low      Normal  7800     Normal
+  // newer firmware example:
+  // Power Volt Curr Tempr Tlow Tlow.Id Thigh Thigh.Id Vlow Vlow.Id Vhigh Vhigh.Id Base.St Volt.St Curr.St Temp.St Coulomb Time                B.V.St B.T.St MosTempr M.T.St SysAlarm.St
+  // 1     49405 0   17600 13700 8      14500 0        3293 2       3294   0       Idle    Normal  Normal  Normal  60%     2025-12-05 00:53:41 Normal Normal 16600    Normal Normal
   // clang-format on
 
   PylontechListener::LineContents l{};
-  char mostempr_s[6];
-  const int parsed = sscanf(                                                                                   // NOLINT
-      buffer.c_str(), "%d %d %d %d %d %d %d %d %7s %7s %7s %7s %d%% %*d-%*d-%*d %*d:%*d:%*d %*s %*s %5s %*s",  // NOLINT
-      &l.bat_num, &l.volt, &l.curr, &l.tempr, &l.tlow, &l.thigh, &l.vlow, &l.vhigh, l.base_st, l.volt_st,      // NOLINT
-      l.curr_st, l.temp_st, &l.coulomb, mostempr_s);                                                           // NOLINT
 
-  if (l.bat_num <= 0) {
-    ESP_LOGD(TAG, "invalid bat_num in line %s", buffer.substr(0, buffer.size() - 2).c_str());
-    return;
+  const char *cursor = buffer.c_str();
+  char token_buf[TEXT_SENSOR_MAX_LEN] = {0};
+
+  // Helper Lambda to extract tokens
+  auto get_token = [&](char *token_buf) -> void {
+    // Skip leading whitespace
+    while (*cursor == ' ' || *cursor == '\t') {
+      cursor++;
+    }
+
+    if (*cursor == '\0') {
+      token_buf[0] = 0;
+      return;
+    }
+
+    const char *start = cursor;
+
+    // Find end of field
+    while (*cursor != '\0' && *cursor != ' ' && *cursor != '\t' && *cursor != '\r') {
+      cursor++;
+    }
+
+    size_t token_len = std::min(static_cast<size_t>(cursor - start), static_cast<size_t>(TEXT_SENSOR_MAX_LEN - 1));
+    memcpy(token_buf, start, token_len);
+    token_buf[token_len] = 0;
+  };
+
+  {
+    get_token(token_buf);
+    auto val = parse_number<int>(token_buf);
+    if (val.has_value() && val.value() > 0) {
+      l.bat_num = val.value();
+    } else if (strcmp(token_buf, "Power") == 0) {
+      // header line i.e. "Power Volt   Curr" and so on
+      this->has_tlow_id_ = buffer.find("Tlow.Id") != std::string::npos;
+      ESP_LOGD(TAG, "header line %s Tlow.Id: %s", this->has_tlow_id_ ? "with" : "without",
+               buffer.substr(0, buffer.size() - 2).c_str());
+      return;
+    } else {
+      ESP_LOGD(TAG, "unknown line %s", buffer.substr(0, buffer.size() - 2).c_str());
+      return;
+    }
   }
-  if (parsed != 14) {
-    ESP_LOGW(TAG, "invalid line: found only %d items in %s", parsed, buffer.substr(0, buffer.size() - 2).c_str());
-    return;
+  PARSE_INT(l.volt, "Volt");
+  PARSE_INT(l.curr, "Curr");
+  PARSE_INT(l.tempr, "Tempr");
+  PARSE_INT(l.tlow, "Tlow");
+  if (this->has_tlow_id_) {
+    get_token(token_buf);  // Skip Tlow.Id
   }
-  auto mostempr_parsed = parse_number<int>(mostempr_s);
-  if (mostempr_parsed.has_value()) {
-    l.mostempr = mostempr_parsed.value();
-  } else {
-    l.mostempr = -300;
-    ESP_LOGW(TAG, "bat_num %d: received no mostempr", l.bat_num);
+  PARSE_INT(l.thigh, "Thigh");
+  if (this->has_tlow_id_) {
+    get_token(token_buf);  // Skip Thigh.Id
   }
+  PARSE_INT(l.vlow, "Vlow");
+  if (this->has_tlow_id_) {
+    get_token(token_buf);  // Skip Vlow.Id
+  }
+  PARSE_INT(l.vhigh, "Vhigh");
+  if (this->has_tlow_id_) {
+    get_token(token_buf);  // Skip Vhigh.Id
+  }
+  PARSE_STR(l.base_st, "Base.St");
+  PARSE_STR(l.volt_st, "Volt.St");
+  PARSE_STR(l.curr_st, "Curr.St");
+  PARSE_STR(l.temp_st, "Temp.St");
+  {
+    get_token(token_buf);
+    for (char &i : token_buf) {
+      if (i == '%') {
+        i = 0;
+        break;
+      }
+    }
+    auto coul_val = parse_number<int>(token_buf);
+    if (coul_val.has_value()) {
+      l.coulomb = coul_val.value();
+    } else {
+      ESP_LOGD(TAG, "invalid Coulomb in line %s", buffer.substr(0, buffer.size() - 2).c_str());
+      return;
+    }
+  }
+  get_token(token_buf);  // Skip Date
+  get_token(token_buf);  // Skip Time
+  get_token(token_buf);  // Skip B.V.St
+  get_token(token_buf);  // Skip B.T.St
+  PARSE_INT(l.mostempr, "Mostempr");
+
+  ESP_LOGD(TAG, "successful line %s", buffer.substr(0, buffer.size() - 2).c_str());
 
   for (PylontechListener *listener : this->listeners_) {
     listener->on_line_read(&l);
   }
 }
 
-float PylontechComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace pylontech
 }  // namespace esphome
+
+#undef PARSE_INT
+#undef PARSE_STR
diff --git a/esphome/components/pylontech/pylontech.h b/esphome/components/pylontech/pylontech.h
index 3282cb4d9fb..5727928a60e 100644
--- a/esphome/components/pylontech/pylontech.h
+++ b/esphome/components/pylontech/pylontech.h
@@ -8,14 +8,14 @@ namespace esphome {
 namespace pylontech {
 
 static const uint8_t NUM_BUFFERS = 20;
-static const uint8_t TEXT_SENSOR_MAX_LEN = 8;
+static const uint8_t TEXT_SENSOR_MAX_LEN = 14;
 
 class PylontechListener {
  public:
   struct LineContents {
     int bat_num = 0, volt, curr, tempr, tlow, thigh, vlow, vhigh, coulomb, mostempr;
-    char base_st[TEXT_SENSOR_MAX_LEN], volt_st[TEXT_SENSOR_MAX_LEN], curr_st[TEXT_SENSOR_MAX_LEN],
-        temp_st[TEXT_SENSOR_MAX_LEN];
+    char base_st[TEXT_SENSOR_MAX_LEN] = {0}, volt_st[TEXT_SENSOR_MAX_LEN] = {0}, curr_st[TEXT_SENSOR_MAX_LEN] = {0},
+         temp_st[TEXT_SENSOR_MAX_LEN] = {0};
   };
 
   virtual void on_line_read(LineContents *line);
@@ -34,8 +34,6 @@ class PylontechComponent : public PollingComponent, public uart::UARTDevice {
   void setup() override;
   void dump_config() override;
 
-  float get_setup_priority() const override;
-
   void register_listener(PylontechListener *listener) { this->listeners_.push_back(listener); }
 
  protected:
@@ -45,6 +43,7 @@ class PylontechComponent : public PollingComponent, public uart::UARTDevice {
   std::string buffer_[NUM_BUFFERS];
   int buffer_index_write_ = 0;
   int buffer_index_read_ = 0;
+  bool has_tlow_id_ = false;
 
   std::vector<PylontechListener *> listeners_{};
 };
diff --git a/esphome/components/qmc5883l/qmc5883l.cpp b/esphome/components/qmc5883l/qmc5883l.cpp
index 693614581c6..bc2adb5cfe5 100644
--- a/esphome/components/qmc5883l/qmc5883l.cpp
+++ b/esphome/components/qmc5883l/qmc5883l.cpp
@@ -86,8 +86,6 @@ void QMC5883LComponent::dump_config() {
   LOG_PIN("  DRDY Pin: ", this->drdy_pin_);
 }
 
-float QMC5883LComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void QMC5883LComponent::update() {
   i2c::ErrorCode err;
   uint8_t status = false;
diff --git a/esphome/components/qmc5883l/qmc5883l.h b/esphome/components/qmc5883l/qmc5883l.h
index 5ba7180e231..21ef9c2a175 100644
--- a/esphome/components/qmc5883l/qmc5883l.h
+++ b/esphome/components/qmc5883l/qmc5883l.h
@@ -31,7 +31,6 @@ class QMC5883LComponent : public PollingComponent, public i2c::I2CDevice {
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
   void set_drdy_pin(GPIOPin *pin) { drdy_pin_ = pin; }
diff --git a/esphome/components/rd03d/rd03d.cpp b/esphome/components/rd03d/rd03d.cpp
index ba05abe8e06..090e4dcf324 100644
--- a/esphome/components/rd03d/rd03d.cpp
+++ b/esphome/components/rd03d/rd03d.cpp
@@ -132,18 +132,15 @@ void RD03DComponent::process_frame_() {
     // Header is 4 bytes, each target is 8 bytes
     uint8_t offset = FRAME_HEADER_SIZE + (i * TARGET_DATA_SIZE);
 
-    // Extract raw bytes for this target
-    // Note: Despite datasheet Table 5-2 showing order as X, Y, Speed, Resolution,
-    // actual radar output has Resolution before Speed (verified empirically -
-    // stationary targets were showing non-zero speed with original field order)
+    // Extract raw bytes for this target (per datasheet Table 5-2: X, Y, Speed, Resolution)
     uint8_t x_low = this->buffer_[offset + 0];
     uint8_t x_high = this->buffer_[offset + 1];
     uint8_t y_low = this->buffer_[offset + 2];
     uint8_t y_high = this->buffer_[offset + 3];
-    uint8_t res_low = this->buffer_[offset + 4];
-    uint8_t res_high = this->buffer_[offset + 5];
-    uint8_t speed_low = this->buffer_[offset + 6];
-    uint8_t speed_high = this->buffer_[offset + 7];
+    uint8_t speed_low = this->buffer_[offset + 4];
+    uint8_t speed_high = this->buffer_[offset + 5];
+    uint8_t res_low = this->buffer_[offset + 6];
+    uint8_t res_high = this->buffer_[offset + 7];
 
     // Decode values per RD-03D format
     int16_t x = decode_value(x_low, x_high);
diff --git a/esphome/components/rd03d/rd03d.h b/esphome/components/rd03d/rd03d.h
index 7413fe38f23..8bf7b423bed 100644
--- a/esphome/components/rd03d/rd03d.h
+++ b/esphome/components/rd03d/rd03d.h
@@ -42,7 +42,6 @@ class RD03DComponent : public Component, public uart::UARTDevice {
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
 #ifdef USE_SENSOR
   void set_target_count_sensor(sensor::Sensor *sensor) { this->target_count_sensor_ = sensor; }
diff --git a/esphome/components/remote_transmitter/remote_transmitter.cpp b/esphome/components/remote_transmitter/remote_transmitter.cpp
index f20789fb9f2..d35541e2e1f 100644
--- a/esphome/components/remote_transmitter/remote_transmitter.cpp
+++ b/esphome/components/remote_transmitter/remote_transmitter.cpp
@@ -83,7 +83,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
   uint32_t on_time, off_time;
   this->calculate_on_off_time_(this->temp_.get_carrier_frequency(), &on_time, &off_time);
   this->target_time_ = 0;
-  this->transmit_trigger_->trigger();
+  this->transmit_trigger_.trigger();
   for (uint32_t i = 0; i < send_times; i++) {
     InterruptLock lock;
     for (int32_t item : this->temp_.get_data()) {
@@ -102,7 +102,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     if (i + 1 < send_times)
       this->target_time_ += send_wait;
   }
-  this->complete_trigger_->trigger();
+  this->complete_trigger_.trigger();
 }
 
 }  // namespace remote_transmitter
diff --git a/esphome/components/remote_transmitter/remote_transmitter.h b/esphome/components/remote_transmitter/remote_transmitter.h
index dd6a849e4c2..65bd2ac8b28 100644
--- a/esphome/components/remote_transmitter/remote_transmitter.h
+++ b/esphome/components/remote_transmitter/remote_transmitter.h
@@ -57,8 +57,8 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
   void set_non_blocking(bool non_blocking) { this->non_blocking_ = non_blocking; }
 #endif
 
-  Trigger<> *get_transmit_trigger() const { return this->transmit_trigger_; };
-  Trigger<> *get_complete_trigger() const { return this->complete_trigger_; };
+  Trigger<> *get_transmit_trigger() { return &this->transmit_trigger_; }
+  Trigger<> *get_complete_trigger() { return &this->complete_trigger_; }
 
  protected:
   void send_internal(uint32_t send_times, uint32_t send_wait) override;
@@ -96,8 +96,8 @@ class RemoteTransmitterComponent : public remote_base::RemoteTransmitterBase,
 #endif
   uint8_t carrier_duty_percent_;
 
-  Trigger<> *transmit_trigger_{new Trigger<>()};
-  Trigger<> *complete_trigger_{new Trigger<>()};
+  Trigger<> transmit_trigger_;
+  Trigger<> complete_trigger_;
 };
 
 }  // namespace remote_transmitter
diff --git a/esphome/components/remote_transmitter/remote_transmitter_esp32.cpp b/esphome/components/remote_transmitter/remote_transmitter_esp32.cpp
index 59c85c99a85..89d97895b26 100644
--- a/esphome/components/remote_transmitter/remote_transmitter_esp32.cpp
+++ b/esphome/components/remote_transmitter/remote_transmitter_esp32.cpp
@@ -203,7 +203,7 @@ void RemoteTransmitterComponent::wait_for_rmt_() {
     this->status_set_warning();
   }
 
-  this->complete_trigger_->trigger();
+  this->complete_trigger_.trigger();
 }
 
 #if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 5, 1)
@@ -264,7 +264,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     return;
   }
 
-  this->transmit_trigger_->trigger();
+  this->transmit_trigger_.trigger();
 
   rmt_transmit_config_t config;
   memset(&config, 0, sizeof(config));
@@ -333,7 +333,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     ESP_LOGE(TAG, "Empty data");
     return;
   }
-  this->transmit_trigger_->trigger();
+  this->transmit_trigger_.trigger();
   for (uint32_t i = 0; i < send_times; i++) {
     rmt_transmit_config_t config;
     memset(&config, 0, sizeof(config));
@@ -354,7 +354,7 @@ void RemoteTransmitterComponent::send_internal(uint32_t send_times, uint32_t sen
     if (i + 1 < send_times)
       delayMicroseconds(send_wait);
   }
-  this->complete_trigger_->trigger();
+  this->complete_trigger_.trigger();
 }
 #endif
 
diff --git a/esphome/components/resampler/speaker/resampler_speaker.h b/esphome/components/resampler/speaker/resampler_speaker.h
index 51790069d27..810087ab7f4 100644
--- a/esphome/components/resampler/speaker/resampler_speaker.h
+++ b/esphome/components/resampler/speaker/resampler_speaker.h
@@ -16,7 +16,6 @@ namespace resampler {
 
 class ResamplerSpeaker : public Component, public speaker::Speaker {
  public:
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
   void setup() override;
   void loop() override;
 
diff --git a/esphome/components/rotary_encoder/rotary_encoder.cpp b/esphome/components/rotary_encoder/rotary_encoder.cpp
index c6529441208..38fd14375d6 100644
--- a/esphome/components/rotary_encoder/rotary_encoder.cpp
+++ b/esphome/components/rotary_encoder/rotary_encoder.cpp
@@ -235,7 +235,6 @@ void RotaryEncoderSensor::loop() {
   }
 }
 
-float RotaryEncoderSensor::get_setup_priority() const { return setup_priority::DATA; }
 void RotaryEncoderSensor::set_restore_mode(RotaryEncoderRestoreMode restore_mode) {
   this->restore_mode_ = restore_mode;
 }
diff --git a/esphome/components/rotary_encoder/rotary_encoder.h b/esphome/components/rotary_encoder/rotary_encoder.h
index 14442f0565f..865554cd4d5 100644
--- a/esphome/components/rotary_encoder/rotary_encoder.h
+++ b/esphome/components/rotary_encoder/rotary_encoder.h
@@ -82,8 +82,6 @@ class RotaryEncoderSensor : public sensor::Sensor, public Component {
   void dump_config() override;
   void loop() override;
 
-  float get_setup_priority() const override;
-
   void add_on_clockwise_callback(std::function<void()> callback) {
     this->on_clockwise_callback_.add(std::move(callback));
   }
diff --git a/esphome/components/rp2040/preferences.cpp b/esphome/components/rp2040/preferences.cpp
index e84033bc522..172da32adc3 100644
--- a/esphome/components/rp2040/preferences.cpp
+++ b/esphome/components/rp2040/preferences.cpp
@@ -18,11 +18,12 @@ namespace rp2040 {
 
 static const char *const TAG = "rp2040.preferences";
 
-static bool s_prevent_write = false;        // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static uint8_t *s_flash_storage = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static bool s_flash_dirty = false;          // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static constexpr uint32_t RP2040_FLASH_STORAGE_SIZE = 512;
 
-static const uint32_t RP2040_FLASH_STORAGE_SIZE = 512;
+static bool s_prevent_write = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static uint8_t
+    s_flash_storage[RP2040_FLASH_STORAGE_SIZE];  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+static bool s_flash_dirty = false;               // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 // Stack buffer size for preferences - covers virtually all real-world preferences without heap allocation
 static constexpr size_t PREF_BUFFER_SIZE = 64;
@@ -91,7 +92,6 @@ class RP2040Preferences : public ESPPreferences {
 
   RP2040Preferences() : eeprom_sector_(&_EEPROM_start) {}
   void setup() {
-    s_flash_storage = new uint8_t[RP2040_FLASH_STORAGE_SIZE];  // NOLINT
     ESP_LOGVV(TAG, "Loading preferences from flash");
     memcpy(s_flash_storage, this->eeprom_sector_, RP2040_FLASH_STORAGE_SIZE);
   }
@@ -149,10 +149,11 @@ class RP2040Preferences : public ESPPreferences {
   uint8_t *eeprom_sector_;
 };
 
+static RP2040Preferences s_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 void setup_preferences() {
-  auto *prefs = new RP2040Preferences();  // NOLINT(cppcoreguidelines-owning-memory)
-  prefs->setup();
-  global_preferences = prefs;
+  s_preferences.setup();
+  global_preferences = &s_preferences;
 }
 void preferences_prevent_write(bool prevent) { s_prevent_write = prevent; }
 
diff --git a/esphome/components/rtttl/rtttl.cpp b/esphome/components/rtttl/rtttl.cpp
index 65fcc207d48..c179282c50d 100644
--- a/esphome/components/rtttl/rtttl.cpp
+++ b/esphome/components/rtttl/rtttl.cpp
@@ -290,25 +290,26 @@ void Rtttl::loop() {
     this->position_++;
   }
 
-  // now, get optional '.' dotted note
-  if (this->rtttl_[this->position_] == '.') {
-    this->note_duration_ += this->note_duration_ / 2;
-    this->position_++;
-  }
-
   // now, get scale
   uint8_t scale = get_integer_();
-  if (scale == 0)
+  if (scale == 0) {
     scale = this->default_octave_;
+  }
 
   if (scale < 4 || scale > 7) {
     ESP_LOGE(TAG, "Octave must be between 4 and 7 (it is %d)", scale);
     this->finish_();
     return;
   }
-  bool need_note_gap = false;
+
+  // now, get optional '.' dotted note
+  if (this->rtttl_[this->position_] == '.') {
+    this->note_duration_ += this->note_duration_ / 2;
+    this->position_++;
+  }
 
   // Now play the note
+  bool need_note_gap = false;
   if (note) {
     auto note_index = (scale - 4) * 12 + note;
     if (note_index < 0 || note_index >= (int) sizeof(NOTES)) {
diff --git a/esphome/components/rx8130/rx8130.h b/esphome/components/rx8130/rx8130.h
index 6694c763cd5..979da3e19cb 100644
--- a/esphome/components/rx8130/rx8130.h
+++ b/esphome/components/rx8130/rx8130.h
@@ -14,8 +14,6 @@ class RX8130Component : public time::RealTimeClock, public i2c::I2CDevice {
   void dump_config() override;
   void read_time();
   void write_time();
-  /// Ensure RTC is initialized at the correct time in the setup sequence
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
  protected:
   void stop_(bool stop);
diff --git a/esphome/components/sdp3x/sdp3x.cpp b/esphome/components/sdp3x/sdp3x.cpp
index d4ab04e7cd6..6f6cc1ebd8f 100644
--- a/esphome/components/sdp3x/sdp3x.cpp
+++ b/esphome/components/sdp3x/sdp3x.cpp
@@ -114,7 +114,5 @@ void SDP3XComponent::read_pressure_() {
   this->status_clear_warning();
 }
 
-float SDP3XComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace sdp3x
 }  // namespace esphome
diff --git a/esphome/components/sdp3x/sdp3x.h b/esphome/components/sdp3x/sdp3x.h
index e3d3533c744..afb58d47c8f 100644
--- a/esphome/components/sdp3x/sdp3x.h
+++ b/esphome/components/sdp3x/sdp3x.h
@@ -17,7 +17,6 @@ class SDP3XComponent : public PollingComponent, public sensirion_common::Sensiri
   void setup() override;
   void dump_config() override;
 
-  float get_setup_priority() const override;
   void set_measurement_mode(MeasurementMode mode) { measurement_mode_ = mode; }
 
  protected:
diff --git a/esphome/components/sds011/sds011.cpp b/esphome/components/sds011/sds011.cpp
index 4e12c0e3221..cdfd7544ad8 100644
--- a/esphome/components/sds011/sds011.cpp
+++ b/esphome/components/sds011/sds011.cpp
@@ -108,8 +108,6 @@ void SDS011Component::loop() {
   }
 }
 
-float SDS011Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void SDS011Component::set_rx_mode_only(bool rx_mode_only) { this->rx_mode_only_ = rx_mode_only; }
 
 void SDS011Component::sds011_write_command_(const uint8_t *command_data) {
diff --git a/esphome/components/sds011/sds011.h b/esphome/components/sds011/sds011.h
index 1f404601b1b..3be74e66d10 100644
--- a/esphome/components/sds011/sds011.h
+++ b/esphome/components/sds011/sds011.h
@@ -21,8 +21,6 @@ class SDS011Component : public Component, public uart::UARTDevice {
   void dump_config() override;
   void loop() override;
 
-  float get_setup_priority() const override;
-
   void set_update_interval(uint32_t val) { /* ignore */
   }
   void set_update_interval_min(uint8_t update_interval_min);
diff --git a/esphome/components/sht3xd/sht3xd.cpp b/esphome/components/sht3xd/sht3xd.cpp
index d473df43c73..bd3dec6fb85 100644
--- a/esphome/components/sht3xd/sht3xd.cpp
+++ b/esphome/components/sht3xd/sht3xd.cpp
@@ -72,8 +72,6 @@ void SHT3XDComponent::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
-float SHT3XDComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void SHT3XDComponent::update() {
   if (this->status_has_warning()) {
     ESP_LOGD(TAG, "Retrying to reconnect the sensor.");
diff --git a/esphome/components/sht3xd/sht3xd.h b/esphome/components/sht3xd/sht3xd.h
index 74f155121b3..43f1a4d8e24 100644
--- a/esphome/components/sht3xd/sht3xd.h
+++ b/esphome/components/sht3xd/sht3xd.h
@@ -17,7 +17,6 @@ class SHT3XDComponent : public PollingComponent, public sensirion_common::Sensir
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void set_heater_enabled(bool heater_enabled) { heater_enabled_ = heater_enabled; }
 
diff --git a/esphome/components/shtcx/shtcx.cpp b/esphome/components/shtcx/shtcx.cpp
index aca305b88db..ec12a5babdd 100644
--- a/esphome/components/shtcx/shtcx.cpp
+++ b/esphome/components/shtcx/shtcx.cpp
@@ -63,8 +63,6 @@ void SHTCXComponent::dump_config() {
   LOG_SENSOR("  ", "Humidity", this->humidity_sensor_);
 }
 
-float SHTCXComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 void SHTCXComponent::update() {
   if (this->status_has_warning()) {
     ESP_LOGW(TAG, "Retrying communication");
diff --git a/esphome/components/shtcx/shtcx.h b/esphome/components/shtcx/shtcx.h
index 084d3bfc35c..f9778dce8d7 100644
--- a/esphome/components/shtcx/shtcx.h
+++ b/esphome/components/shtcx/shtcx.h
@@ -17,7 +17,6 @@ class SHTCXComponent : public PollingComponent, public sensirion_common::Sensiri
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void soft_reset();
   void sleep();
diff --git a/esphome/components/smt100/smt100.cpp b/esphome/components/smt100/smt100.cpp
index c8dfb4c7bdf..1bcb9642649 100644
--- a/esphome/components/smt100/smt100.cpp
+++ b/esphome/components/smt100/smt100.cpp
@@ -44,8 +44,6 @@ void SMT100Component::loop() {
   }
 }
 
-float SMT100Component::get_setup_priority() const { return setup_priority::DATA; }
-
 void SMT100Component::dump_config() {
   ESP_LOGCONFIG(TAG, "SMT100:");
 
diff --git a/esphome/components/smt100/smt100.h b/esphome/components/smt100/smt100.h
index 86827607dc9..df8803e1c62 100644
--- a/esphome/components/smt100/smt100.h
+++ b/esphome/components/smt100/smt100.h
@@ -17,8 +17,6 @@ class SMT100Component : public PollingComponent, public uart::UARTDevice {
   void loop() override;
   void update() override;
 
-  float get_setup_priority() const override;
-
   void set_counts_sensor(sensor::Sensor *counts_sensor) { this->counts_sensor_ = counts_sensor; }
   void set_permittivity_sensor(sensor::Sensor *permittivity_sensor) {
     this->permittivity_sensor_ = permittivity_sensor;
diff --git a/esphome/components/sonoff_d1/sonoff_d1.h b/esphome/components/sonoff_d1/sonoff_d1.h
index 19ff83f3786..20bea23287b 100644
--- a/esphome/components/sonoff_d1/sonoff_d1.h
+++ b/esphome/components/sonoff_d1/sonoff_d1.h
@@ -53,7 +53,6 @@ class SonoffD1Output : public light::LightOutput, public uart::UARTDevice, publi
   void setup() override{};
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return esphome::setup_priority::DATA; }
 
   // Custom methods
   void set_use_rm433_remote(const bool use_rm433_remote) { this->use_rm433_remote_ = use_rm433_remote; }
diff --git a/esphome/components/speaker/media_player/__init__.py b/esphome/components/speaker/media_player/__init__.py
index 370b4576a7c..034312236c6 100644
--- a/esphome/components/speaker/media_player/__init__.py
+++ b/esphome/components/speaker/media_player/__init__.py
@@ -157,8 +157,14 @@ def _read_audio_file_and_type(file_config):
 
     import puremagic
 
-    file_type: str = puremagic.from_string(data)
-    file_type = file_type.removeprefix(".")
+    try:
+        file_type: str = puremagic.from_string(data)
+        file_type = file_type.removeprefix(".")
+    except puremagic.PureError as e:
+        raise cv.Invalid(
+            f"Unable to determine audio file type of '{path}'. "
+            f"Try re-encoding the file into a supported format. Details: {e}"
+        )
 
     media_file_type = audio.AUDIO_FILE_TYPE_ENUM["NONE"]
     if file_type in ("wav"):
diff --git a/esphome/components/speaker/media_player/speaker_media_player.cpp b/esphome/components/speaker/media_player/speaker_media_player.cpp
index 172bc980a82..94f555c26e0 100644
--- a/esphome/components/speaker/media_player/speaker_media_player.cpp
+++ b/esphome/components/speaker/media_player/speaker_media_player.cpp
@@ -519,9 +519,9 @@ void SpeakerMediaPlayer::set_mute_state_(bool mute_state) {
 
   if (old_mute_state != mute_state) {
     if (mute_state) {
-      this->defer([this]() { this->mute_trigger_->trigger(); });
+      this->defer([this]() { this->mute_trigger_.trigger(); });
     } else {
-      this->defer([this]() { this->unmute_trigger_->trigger(); });
+      this->defer([this]() { this->unmute_trigger_.trigger(); });
     }
   }
 }
@@ -550,7 +550,7 @@ void SpeakerMediaPlayer::set_volume_(float volume, bool publish) {
     this->set_mute_state_(false);
   }
 
-  this->defer([this, volume]() { this->volume_trigger_->trigger(volume); });
+  this->defer([this, volume]() { this->volume_trigger_.trigger(volume); });
 }
 
 }  // namespace speaker
diff --git a/esphome/components/speaker/media_player/speaker_media_player.h b/esphome/components/speaker/media_player/speaker_media_player.h
index 065926d0cfe..722f98ceeaa 100644
--- a/esphome/components/speaker/media_player/speaker_media_player.h
+++ b/esphome/components/speaker/media_player/speaker_media_player.h
@@ -84,9 +84,9 @@ class SpeakerMediaPlayer : public Component,
     this->media_format_ = media_format;
   }
 
-  Trigger<> *get_mute_trigger() const { return this->mute_trigger_; }
-  Trigger<> *get_unmute_trigger() const { return this->unmute_trigger_; }
-  Trigger<float> *get_volume_trigger() const { return this->volume_trigger_; }
+  Trigger<> *get_mute_trigger() { return &this->mute_trigger_; }
+  Trigger<> *get_unmute_trigger() { return &this->unmute_trigger_; }
+  Trigger<float> *get_volume_trigger() { return &this->volume_trigger_; }
 
   void play_file(audio::AudioFile *media_file, bool announcement, bool enqueue);
 
@@ -154,9 +154,9 @@ class SpeakerMediaPlayer : public Component,
   // Used to save volume/mute state for restoration on reboot
   ESPPreferenceObject pref_;
 
-  Trigger<> *mute_trigger_ = new Trigger<>();
-  Trigger<> *unmute_trigger_ = new Trigger<>();
-  Trigger<float> *volume_trigger_ = new Trigger<float>();
+  Trigger<> mute_trigger_;
+  Trigger<> unmute_trigger_;
+  Trigger<float> volume_trigger_;
 };
 
 }  // namespace speaker
diff --git a/esphome/components/spi_device/spi_device.cpp b/esphome/components/spi_device/spi_device.cpp
index 4cc7286ba98..34f83027db4 100644
--- a/esphome/components/spi_device/spi_device.cpp
+++ b/esphome/components/spi_device/spi_device.cpp
@@ -23,7 +23,5 @@ void SPIDeviceComponent::dump_config() {
   }
 }
 
-float SPIDeviceComponent::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace spi_device
 }  // namespace esphome
diff --git a/esphome/components/spi_device/spi_device.h b/esphome/components/spi_device/spi_device.h
index d8aef440a76..e3aa74aaf05 100644
--- a/esphome/components/spi_device/spi_device.h
+++ b/esphome/components/spi_device/spi_device.h
@@ -13,8 +13,6 @@ class SPIDeviceComponent : public Component,
   void setup() override;
   void dump_config() override;
 
-  float get_setup_priority() const override;
-
  protected:
 };
 
diff --git a/esphome/components/sprinkler/sprinkler.cpp b/esphome/components/sprinkler/sprinkler.cpp
index 2a60eb042b4..eae6ecbf31f 100644
--- a/esphome/components/sprinkler/sprinkler.cpp
+++ b/esphome/components/sprinkler/sprinkler.cpp
@@ -29,7 +29,7 @@ void SprinklerControllerNumber::setup() {
 }
 
 void SprinklerControllerNumber::control(float value) {
-  this->set_trigger_->trigger(value);
+  this->set_trigger_.trigger(value);
 
   this->publish_state(value);
 
@@ -39,8 +39,7 @@ void SprinklerControllerNumber::control(float value) {
 
 void SprinklerControllerNumber::dump_config() { LOG_NUMBER("", "Sprinkler Controller Number", this); }
 
-SprinklerControllerSwitch::SprinklerControllerSwitch()
-    : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
+SprinklerControllerSwitch::SprinklerControllerSwitch() = default;
 
 void SprinklerControllerSwitch::loop() {
   // Loop is only enabled when f_ has a value (see setup())
@@ -56,11 +55,11 @@ void SprinklerControllerSwitch::write_state(bool state) {
   }
 
   if (state) {
-    this->prev_trigger_ = this->turn_on_trigger_;
-    this->turn_on_trigger_->trigger();
+    this->prev_trigger_ = &this->turn_on_trigger_;
+    this->turn_on_trigger_.trigger();
   } else {
-    this->prev_trigger_ = this->turn_off_trigger_;
-    this->turn_off_trigger_->trigger();
+    this->prev_trigger_ = &this->turn_off_trigger_;
+    this->turn_off_trigger_.trigger();
   }
 
   this->publish_state(state);
@@ -69,9 +68,6 @@ void SprinklerControllerSwitch::write_state(bool state) {
 void SprinklerControllerSwitch::set_state_lambda(std::function<optional<bool>()> &&f) { this->f_ = f; }
 float SprinklerControllerSwitch::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-Trigger<> *SprinklerControllerSwitch::get_turn_on_trigger() const { return this->turn_on_trigger_; }
-Trigger<> *SprinklerControllerSwitch::get_turn_off_trigger() const { return this->turn_off_trigger_; }
-
 void SprinklerControllerSwitch::setup() {
   this->state = this->get_initial_state_with_restore_mode().value_or(false);
   // Disable loop if no state lambda is set - nothing to poll
diff --git a/esphome/components/sprinkler/sprinkler.h b/esphome/components/sprinkler/sprinkler.h
index 04efa28031f..a3cdef5b1a0 100644
--- a/esphome/components/sprinkler/sprinkler.h
+++ b/esphome/components/sprinkler/sprinkler.h
@@ -76,7 +76,7 @@ class SprinklerControllerNumber : public number::Number, public Component {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::PROCESSOR; }
 
-  Trigger<float> *get_set_trigger() const { return set_trigger_; }
+  Trigger<float> *get_set_trigger() { return &this->set_trigger_; }
   void set_initial_value(float initial_value) { initial_value_ = initial_value; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
 
@@ -84,7 +84,7 @@ class SprinklerControllerNumber : public number::Number, public Component {
   void control(float value) override;
   float initial_value_{NAN};
   bool restore_value_{true};
-  Trigger<float> *set_trigger_ = new Trigger<float>();
+  Trigger<float> set_trigger_;
 
   ESPPreferenceObject pref_;
 };
@@ -97,8 +97,8 @@ class SprinklerControllerSwitch : public switch_::Switch, public Component {
   void dump_config() override;
 
   void set_state_lambda(std::function<optional<bool>()> &&f);
-  Trigger<> *get_turn_on_trigger() const;
-  Trigger<> *get_turn_off_trigger() const;
+  Trigger<> *get_turn_on_trigger() { return &this->turn_on_trigger_; }
+  Trigger<> *get_turn_off_trigger() { return &this->turn_off_trigger_; }
   void loop() override;
 
   float get_setup_priority() const override;
@@ -107,8 +107,8 @@ class SprinklerControllerSwitch : public switch_::Switch, public Component {
   void write_state(bool state) override;
 
   optional<std::function<optional<bool>()>> f_;
-  Trigger<> *turn_on_trigger_;
-  Trigger<> *turn_off_trigger_;
+  Trigger<> turn_on_trigger_;
+  Trigger<> turn_off_trigger_;
   Trigger<> *prev_trigger_{nullptr};
 };
 
diff --git a/esphome/components/sts3x/sts3x.cpp b/esphome/components/sts3x/sts3x.cpp
index eee2aca73e2..8713b0b6b89 100644
--- a/esphome/components/sts3x/sts3x.cpp
+++ b/esphome/components/sts3x/sts3x.cpp
@@ -41,7 +41,7 @@ void STS3XComponent::dump_config() {
 
   LOG_SENSOR("  ", "STS3x", this);
 }
-float STS3XComponent::get_setup_priority() const { return setup_priority::DATA; }
+
 void STS3XComponent::update() {
   if (this->status_has_warning()) {
     ESP_LOGD(TAG, "Retrying to reconnect the sensor.");
diff --git a/esphome/components/sts3x/sts3x.h b/esphome/components/sts3x/sts3x.h
index 8f806a34717..6c1dd2b2442 100644
--- a/esphome/components/sts3x/sts3x.h
+++ b/esphome/components/sts3x/sts3x.h
@@ -14,7 +14,6 @@ class STS3XComponent : public sensor::Sensor, public PollingComponent, public se
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 };
 
diff --git a/esphome/components/sx126x/__init__.py b/esphome/components/sx126x/__init__.py
index ed878ed0d43..413eb139d65 100644
--- a/esphome/components/sx126x/__init__.py
+++ b/esphome/components/sx126x/__init__.py
@@ -213,7 +213,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_ON_PACKET): automation.validate_automation(single=True),
             cv.Optional(CONF_PA_POWER, default=17): cv.int_range(min=-3, max=22),
             cv.Optional(CONF_PA_RAMP, default="40us"): cv.enum(RAMP),
-            cv.Optional(CONF_PAYLOAD_LENGTH, default=0): cv.int_range(min=0, max=256),
+            cv.Optional(CONF_PAYLOAD_LENGTH, default=0): cv.int_range(min=0, max=255),
             cv.Optional(CONF_PREAMBLE_DETECT, default=2): cv.int_range(min=0, max=4),
             cv.Optional(CONF_PREAMBLE_SIZE, default=8): cv.int_range(min=1, max=65535),
             cv.Required(CONF_RST_PIN): pins.gpio_output_pin_schema,
diff --git a/esphome/components/sx126x/sx126x.cpp b/esphome/components/sx126x/sx126x.cpp
index 707d6f1fbf1..64cd24b1713 100644
--- a/esphome/components/sx126x/sx126x.cpp
+++ b/esphome/components/sx126x/sx126x.cpp
@@ -343,7 +343,7 @@ void SX126x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, flo
   for (auto &listener : this->listeners_) {
     listener->on_packet(packet, rssi, snr);
   }
-  this->packet_trigger_->trigger(packet, rssi, snr);
+  this->packet_trigger_.trigger(packet, rssi, snr);
 }
 
 void SX126x::loop() {
diff --git a/esphome/components/sx126x/sx126x.h b/esphome/components/sx126x/sx126x.h
index 850d7d4c77d..a758d637955 100644
--- a/esphome/components/sx126x/sx126x.h
+++ b/esphome/components/sx126x/sx126x.h
@@ -97,7 +97,7 @@ class SX126x : public Component,
   void configure();
   SX126xError transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(SX126xListener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() const { return this->packet_trigger_; };
+  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
 
  protected:
   void configure_fsk_ook_();
@@ -111,7 +111,7 @@ class SX126x : public Component,
   void read_register_(uint16_t reg, uint8_t *data, uint8_t size);
   void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
   void wait_busy_();
-  Trigger<std::vector<uint8_t>, float, float> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, float>()};
+  Trigger<std::vector<uint8_t>, float, float> packet_trigger_;
   std::vector<SX126xListener *> listeners_;
   std::vector<uint8_t> packet_;
   std::vector<uint8_t> sync_value_;
diff --git a/esphome/components/sx127x/sx127x.cpp b/esphome/components/sx127x/sx127x.cpp
index 3185574b1a4..caf68b6d513 100644
--- a/esphome/components/sx127x/sx127x.cpp
+++ b/esphome/components/sx127x/sx127x.cpp
@@ -300,7 +300,7 @@ void SX127x::call_listeners_(const std::vector<uint8_t> &packet, float rssi, flo
   for (auto &listener : this->listeners_) {
     listener->on_packet(packet, rssi, snr);
   }
-  this->packet_trigger_->trigger(packet, rssi, snr);
+  this->packet_trigger_.trigger(packet, rssi, snr);
 }
 
 void SX127x::loop() {
diff --git a/esphome/components/sx127x/sx127x.h b/esphome/components/sx127x/sx127x.h
index 0600b512019..be7b6d8d9f8 100644
--- a/esphome/components/sx127x/sx127x.h
+++ b/esphome/components/sx127x/sx127x.h
@@ -83,7 +83,7 @@ class SX127x : public Component,
   void configure();
   SX127xError transmit_packet(const std::vector<uint8_t> &packet);
   void register_listener(SX127xListener *listener) { this->listeners_.push_back(listener); }
-  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() const { return this->packet_trigger_; };
+  Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
 
  protected:
   void configure_fsk_ook_();
@@ -94,7 +94,7 @@ class SX127x : public Component,
   void write_register_(uint8_t reg, uint8_t value);
   void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
   uint8_t read_register_(uint8_t reg);
-  Trigger<std::vector<uint8_t>, float, float> *packet_trigger_{new Trigger<std::vector<uint8_t>, float, float>()};
+  Trigger<std::vector<uint8_t>, float, float> packet_trigger_;
   std::vector<SX127xListener *> listeners_;
   std::vector<uint8_t> packet_;
   std::vector<uint8_t> sync_value_;
diff --git a/esphome/components/sy6970/sy6970.h b/esphome/components/sy6970/sy6970.h
index bacc072f9b3..2225dd781b6 100644
--- a/esphome/components/sy6970/sy6970.h
+++ b/esphome/components/sy6970/sy6970.h
@@ -87,7 +87,6 @@ class SY6970Component : public PollingComponent, public i2c::I2CDevice {
   void setup() override;
   void dump_config() override;
   void update() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
   // Listener registration
   void add_listener(SY6970Listener *listener) { this->listeners_.push_back(listener); }
diff --git a/esphome/components/t6615/t6615.cpp b/esphome/components/t6615/t6615.cpp
index c2ac88ee2e0..75f9ed108e4 100644
--- a/esphome/components/t6615/t6615.cpp
+++ b/esphome/components/t6615/t6615.cpp
@@ -86,7 +86,6 @@ void T6615Component::query_ppm_() {
   this->send_ppm_command_();
 }
 
-float T6615Component::get_setup_priority() const { return setup_priority::DATA; }
 void T6615Component::dump_config() {
   ESP_LOGCONFIG(TAG, "T6615:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
diff --git a/esphome/components/t6615/t6615.h b/esphome/components/t6615/t6615.h
index fb53032e8d7..69c406a5bad 100644
--- a/esphome/components/t6615/t6615.h
+++ b/esphome/components/t6615/t6615.h
@@ -22,8 +22,6 @@ enum class T6615Command : uint8_t {
 
 class T6615Component : public PollingComponent, public uart::UARTDevice {
  public:
-  float get_setup_priority() const override;
-
   void loop() override;
   void update() override;
   void dump_config() override;
diff --git a/esphome/components/tc74/tc74.cpp b/esphome/components/tc74/tc74.cpp
index abf3839e008..969ef3671e2 100644
--- a/esphome/components/tc74/tc74.cpp
+++ b/esphome/components/tc74/tc74.cpp
@@ -61,7 +61,5 @@ void TC74Component::read_temperature_() {
   this->status_clear_warning();
 }
 
-float TC74Component::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace tc74
 }  // namespace esphome
diff --git a/esphome/components/tc74/tc74.h b/esphome/components/tc74/tc74.h
index 5d70c05420c..f3ce225ff41 100644
--- a/esphome/components/tc74/tc74.h
+++ b/esphome/components/tc74/tc74.h
@@ -15,8 +15,6 @@ class TC74Component : public PollingComponent, public i2c::I2CDevice, public sen
   /// Update the sensor value (temperature).
   void update() override;
 
-  float get_setup_priority() const override;
-
  protected:
   /// Internal method to read the temperature from the component after it has been scheduled.
   void read_temperature_();
diff --git a/esphome/components/tcs34725/tcs34725.cpp b/esphome/components/tcs34725/tcs34725.cpp
index e4e55475957..4fe87de0ca2 100644
--- a/esphome/components/tcs34725/tcs34725.cpp
+++ b/esphome/components/tcs34725/tcs34725.cpp
@@ -56,7 +56,6 @@ void TCS34725Component::dump_config() {
   LOG_SENSOR("  ", "Illuminance", this->illuminance_sensor_);
   LOG_SENSOR("  ", "Color Temperature", this->color_temperature_sensor_);
 }
-float TCS34725Component::get_setup_priority() const { return setup_priority::DATA; }
 
 /*!
  *  @brief  Converts the raw R/G/B values to color temperature in degrees
diff --git a/esphome/components/tcs34725/tcs34725.h b/esphome/components/tcs34725/tcs34725.h
index 23985e82211..85bb383e4b7 100644
--- a/esphome/components/tcs34725/tcs34725.h
+++ b/esphome/components/tcs34725/tcs34725.h
@@ -52,7 +52,6 @@ class TCS34725Component : public PollingComponent, public i2c::I2CDevice {
   }
 
   void setup() override;
-  float get_setup_priority() const override;
   void update() override;
   void dump_config() override;
 
diff --git a/esphome/components/tee501/tee501.cpp b/esphome/components/tee501/tee501.cpp
index 06481b628b2..00a62247f90 100644
--- a/esphome/components/tee501/tee501.cpp
+++ b/esphome/components/tee501/tee501.cpp
@@ -43,7 +43,6 @@ void TEE501Component::dump_config() {
   LOG_SENSOR("  ", "TEE501", this);
 }
 
-float TEE501Component::get_setup_priority() const { return setup_priority::DATA; }
 void TEE501Component::update() {
   uint8_t address_1[] = {0x2C, 0x1B};
   this->write(address_1, 2);
diff --git a/esphome/components/tee501/tee501.h b/esphome/components/tee501/tee501.h
index 2437ac92eb7..62a6f1c9440 100644
--- a/esphome/components/tee501/tee501.h
+++ b/esphome/components/tee501/tee501.h
@@ -12,7 +12,6 @@ class TEE501Component : public sensor::Sensor, public PollingComponent, public i
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
 
  protected:
diff --git a/esphome/components/tem3200/tem3200.cpp b/esphome/components/tem3200/tem3200.cpp
index b31496142cb..9c305f8f6f0 100644
--- a/esphome/components/tem3200/tem3200.cpp
+++ b/esphome/components/tem3200/tem3200.cpp
@@ -51,8 +51,6 @@ void TEM3200Component::dump_config() {
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
 }
 
-float TEM3200Component::get_setup_priority() const { return setup_priority::DATA; }
-
 i2c::ErrorCode TEM3200Component::read_(uint8_t &status, uint16_t &raw_temperature, uint16_t &raw_pressure) {
   uint8_t response[4] = {0x00, 0x00, 0x00, 0x00};
 
diff --git a/esphome/components/tem3200/tem3200.h b/esphome/components/tem3200/tem3200.h
index c84a2aba21e..37589b2a066 100644
--- a/esphome/components/tem3200/tem3200.h
+++ b/esphome/components/tem3200/tem3200.h
@@ -15,7 +15,6 @@ class TEM3200Component : public PollingComponent, public i2c::I2CDevice {
     this->raw_pressure_sensor_ = raw_pressure_sensor;
   }
 
-  float get_setup_priority() const override;
   void setup() override;
   void dump_config() override;
   void update() override;
diff --git a/esphome/components/template/cover/template_cover.cpp b/esphome/components/template/cover/template_cover.cpp
index 9c8a8fc9bc2..7f5d68623fa 100644
--- a/esphome/components/template/cover/template_cover.cpp
+++ b/esphome/components/template/cover/template_cover.cpp
@@ -7,13 +7,7 @@ using namespace esphome::cover;
 
 static const char *const TAG = "template.cover";
 
-TemplateCover::TemplateCover()
-    : open_trigger_(new Trigger<>()),
-      close_trigger_(new Trigger<>),
-      stop_trigger_(new Trigger<>()),
-      toggle_trigger_(new Trigger<>()),
-      position_trigger_(new Trigger<float>()),
-      tilt_trigger_(new Trigger<float>()) {}
+TemplateCover::TemplateCover() = default;
 void TemplateCover::setup() {
   switch (this->restore_mode_) {
     case COVER_NO_RESTORE:
@@ -62,22 +56,22 @@ void TemplateCover::loop() {
 void TemplateCover::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 void TemplateCover::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 float TemplateCover::get_setup_priority() const { return setup_priority::HARDWARE; }
-Trigger<> *TemplateCover::get_open_trigger() const { return this->open_trigger_; }
-Trigger<> *TemplateCover::get_close_trigger() const { return this->close_trigger_; }
-Trigger<> *TemplateCover::get_stop_trigger() const { return this->stop_trigger_; }
-Trigger<> *TemplateCover::get_toggle_trigger() const { return this->toggle_trigger_; }
+Trigger<> *TemplateCover::get_open_trigger() { return &this->open_trigger_; }
+Trigger<> *TemplateCover::get_close_trigger() { return &this->close_trigger_; }
+Trigger<> *TemplateCover::get_stop_trigger() { return &this->stop_trigger_; }
+Trigger<> *TemplateCover::get_toggle_trigger() { return &this->toggle_trigger_; }
 void TemplateCover::dump_config() { LOG_COVER("", "Template Cover", this); }
 void TemplateCover::control(const CoverCall &call) {
   if (call.get_stop()) {
     this->stop_prev_trigger_();
-    this->stop_trigger_->trigger();
-    this->prev_command_trigger_ = this->stop_trigger_;
+    this->stop_trigger_.trigger();
+    this->prev_command_trigger_ = &this->stop_trigger_;
     this->publish_state();
   }
   if (call.get_toggle().has_value()) {
     this->stop_prev_trigger_();
-    this->toggle_trigger_->trigger();
-    this->prev_command_trigger_ = this->toggle_trigger_;
+    this->toggle_trigger_.trigger();
+    this->prev_command_trigger_ = &this->toggle_trigger_;
     this->publish_state();
   }
   if (call.get_position().has_value()) {
@@ -85,13 +79,13 @@ void TemplateCover::control(const CoverCall &call) {
     this->stop_prev_trigger_();
 
     if (pos == COVER_OPEN) {
-      this->open_trigger_->trigger();
-      this->prev_command_trigger_ = this->open_trigger_;
+      this->open_trigger_.trigger();
+      this->prev_command_trigger_ = &this->open_trigger_;
     } else if (pos == COVER_CLOSED) {
-      this->close_trigger_->trigger();
-      this->prev_command_trigger_ = this->close_trigger_;
+      this->close_trigger_.trigger();
+      this->prev_command_trigger_ = &this->close_trigger_;
     } else {
-      this->position_trigger_->trigger(pos);
+      this->position_trigger_.trigger(pos);
     }
 
     if (this->optimistic_) {
@@ -101,7 +95,7 @@ void TemplateCover::control(const CoverCall &call) {
 
   if (call.get_tilt().has_value()) {
     auto tilt = *call.get_tilt();
-    this->tilt_trigger_->trigger(tilt);
+    this->tilt_trigger_.trigger(tilt);
 
     if (this->optimistic_) {
       this->tilt = tilt;
@@ -119,8 +113,8 @@ CoverTraits TemplateCover::get_traits() {
   traits.set_supports_tilt(this->has_tilt_);
   return traits;
 }
-Trigger<float> *TemplateCover::get_position_trigger() const { return this->position_trigger_; }
-Trigger<float> *TemplateCover::get_tilt_trigger() const { return this->tilt_trigger_; }
+Trigger<float> *TemplateCover::get_position_trigger() { return &this->position_trigger_; }
+Trigger<float> *TemplateCover::get_tilt_trigger() { return &this->tilt_trigger_; }
 void TemplateCover::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
 void TemplateCover::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
 void TemplateCover::set_has_position(bool has_position) { this->has_position_ = has_position; }
diff --git a/esphome/components/template/cover/template_cover.h b/esphome/components/template/cover/template_cover.h
index 9c4a7872839..20c092cda79 100644
--- a/esphome/components/template/cover/template_cover.h
+++ b/esphome/components/template/cover/template_cover.h
@@ -19,12 +19,12 @@ class TemplateCover final : public cover::Cover, public Component {
 
   template<typename F> void set_state_lambda(F &&f) { this->state_f_.set(std::forward<F>(f)); }
   template<typename F> void set_tilt_lambda(F &&f) { this->tilt_f_.set(std::forward<F>(f)); }
-  Trigger<> *get_open_trigger() const;
-  Trigger<> *get_close_trigger() const;
-  Trigger<> *get_stop_trigger() const;
-  Trigger<> *get_toggle_trigger() const;
-  Trigger<float> *get_position_trigger() const;
-  Trigger<float> *get_tilt_trigger() const;
+  Trigger<> *get_open_trigger();
+  Trigger<> *get_close_trigger();
+  Trigger<> *get_stop_trigger();
+  Trigger<> *get_toggle_trigger();
+  Trigger<float> *get_position_trigger();
+  Trigger<float> *get_tilt_trigger();
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void set_has_stop(bool has_stop);
@@ -49,16 +49,16 @@ class TemplateCover final : public cover::Cover, public Component {
   TemplateLambda<float> tilt_f_;
   bool assumed_state_{false};
   bool optimistic_{false};
-  Trigger<> *open_trigger_;
-  Trigger<> *close_trigger_;
+  Trigger<> open_trigger_;
+  Trigger<> close_trigger_;
   bool has_stop_{false};
   bool has_toggle_{false};
-  Trigger<> *stop_trigger_;
-  Trigger<> *toggle_trigger_;
+  Trigger<> stop_trigger_;
+  Trigger<> toggle_trigger_;
   Trigger<> *prev_command_trigger_{nullptr};
-  Trigger<float> *position_trigger_;
+  Trigger<float> position_trigger_;
   bool has_position_{false};
-  Trigger<float> *tilt_trigger_;
+  Trigger<float> tilt_trigger_;
   bool has_tilt_{false};
 };
 
diff --git a/esphome/components/template/datetime/template_date.cpp b/esphome/components/template/datetime/template_date.cpp
index be1d875a7ed..8a5f11b876d 100644
--- a/esphome/components/template/datetime/template_date.cpp
+++ b/esphome/components/template/datetime/template_date.cpp
@@ -62,7 +62,7 @@ void TemplateDate::control(const datetime::DateCall &call) {
   if (has_day)
     value.day_of_month = *call.get_day();
 
-  this->set_trigger_->trigger(value);
+  this->set_trigger_.trigger(value);
 
   if (this->optimistic_) {
     if (has_year)
diff --git a/esphome/components/template/datetime/template_date.h b/esphome/components/template/datetime/template_date.h
index 0379a9bc672..acf823a34d1 100644
--- a/esphome/components/template/datetime/template_date.h
+++ b/esphome/components/template/datetime/template_date.h
@@ -22,7 +22,7 @@ class TemplateDate final : public datetime::DateEntity, public PollingComponent
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+  Trigger<ESPTime> *get_set_trigger() { return &this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +34,7 @@ class TemplateDate final : public datetime::DateEntity, public PollingComponent
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
-  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+  Trigger<ESPTime> set_trigger_;
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;
diff --git a/esphome/components/template/datetime/template_datetime.cpp b/esphome/components/template/datetime/template_datetime.cpp
index e134f2b654c..269a1d06ca8 100644
--- a/esphome/components/template/datetime/template_datetime.cpp
+++ b/esphome/components/template/datetime/template_datetime.cpp
@@ -80,7 +80,7 @@ void TemplateDateTime::control(const datetime::DateTimeCall &call) {
   if (has_second)
     value.second = *call.get_second();
 
-  this->set_trigger_->trigger(value);
+  this->set_trigger_.trigger(value);
 
   if (this->optimistic_) {
     if (has_year)
diff --git a/esphome/components/template/datetime/template_datetime.h b/esphome/components/template/datetime/template_datetime.h
index b7eb4909339..575065a3dd7 100644
--- a/esphome/components/template/datetime/template_datetime.h
+++ b/esphome/components/template/datetime/template_datetime.h
@@ -22,7 +22,7 @@ class TemplateDateTime final : public datetime::DateTimeEntity, public PollingCo
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+  Trigger<ESPTime> *get_set_trigger() { return &this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +34,7 @@ class TemplateDateTime final : public datetime::DateTimeEntity, public PollingCo
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
-  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+  Trigger<ESPTime> set_trigger_;
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;
diff --git a/esphome/components/template/datetime/template_time.cpp b/esphome/components/template/datetime/template_time.cpp
index 586e126e3b2..9c816871168 100644
--- a/esphome/components/template/datetime/template_time.cpp
+++ b/esphome/components/template/datetime/template_time.cpp
@@ -62,7 +62,7 @@ void TemplateTime::control(const datetime::TimeCall &call) {
   if (has_second)
     value.second = *call.get_second();
 
-  this->set_trigger_->trigger(value);
+  this->set_trigger_.trigger(value);
 
   if (this->optimistic_) {
     if (has_hour)
diff --git a/esphome/components/template/datetime/template_time.h b/esphome/components/template/datetime/template_time.h
index cb83b1b3e51..924b53cc715 100644
--- a/esphome/components/template/datetime/template_time.h
+++ b/esphome/components/template/datetime/template_time.h
@@ -22,7 +22,7 @@ class TemplateTime final : public datetime::TimeEntity, public PollingComponent
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<ESPTime> *get_set_trigger() const { return this->set_trigger_; }
+  Trigger<ESPTime> *get_set_trigger() { return &this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 
   void set_initial_value(ESPTime initial_value) { this->initial_value_ = initial_value; }
@@ -34,7 +34,7 @@ class TemplateTime final : public datetime::TimeEntity, public PollingComponent
   bool optimistic_{false};
   ESPTime initial_value_{};
   bool restore_value_{false};
-  Trigger<ESPTime> *set_trigger_ = new Trigger<ESPTime>();
+  Trigger<ESPTime> set_trigger_;
   TemplateLambda<ESPTime> f_;
 
   ESPPreferenceObject pref_;
diff --git a/esphome/components/template/lock/template_lock.cpp b/esphome/components/template/lock/template_lock.cpp
index de8f9b762cb..dbc4501ce71 100644
--- a/esphome/components/template/lock/template_lock.cpp
+++ b/esphome/components/template/lock/template_lock.cpp
@@ -7,8 +7,7 @@ using namespace esphome::lock;
 
 static const char *const TAG = "template.lock";
 
-TemplateLock::TemplateLock()
-    : lock_trigger_(new Trigger<>()), unlock_trigger_(new Trigger<>()), open_trigger_(new Trigger<>()) {}
+TemplateLock::TemplateLock() = default;
 
 void TemplateLock::setup() {
   if (!this->f_.has_value())
@@ -28,11 +27,11 @@ void TemplateLock::control(const lock::LockCall &call) {
 
   auto state = *call.get_state();
   if (state == LOCK_STATE_LOCKED) {
-    this->prev_trigger_ = this->lock_trigger_;
-    this->lock_trigger_->trigger();
+    this->prev_trigger_ = &this->lock_trigger_;
+    this->lock_trigger_.trigger();
   } else if (state == LOCK_STATE_UNLOCKED) {
-    this->prev_trigger_ = this->unlock_trigger_;
-    this->unlock_trigger_->trigger();
+    this->prev_trigger_ = &this->unlock_trigger_;
+    this->unlock_trigger_.trigger();
   }
 
   if (this->optimistic_)
@@ -42,14 +41,11 @@ void TemplateLock::open_latch() {
   if (this->prev_trigger_ != nullptr) {
     this->prev_trigger_->stop_action();
   }
-  this->prev_trigger_ = this->open_trigger_;
-  this->open_trigger_->trigger();
+  this->prev_trigger_ = &this->open_trigger_;
+  this->open_trigger_.trigger();
 }
 void TemplateLock::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 float TemplateLock::get_setup_priority() const { return setup_priority::HARDWARE; }
-Trigger<> *TemplateLock::get_lock_trigger() const { return this->lock_trigger_; }
-Trigger<> *TemplateLock::get_unlock_trigger() const { return this->unlock_trigger_; }
-Trigger<> *TemplateLock::get_open_trigger() const { return this->open_trigger_; }
 void TemplateLock::dump_config() {
   LOG_LOCK("", "Template Lock", this);
   ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
diff --git a/esphome/components/template/lock/template_lock.h b/esphome/components/template/lock/template_lock.h
index f4396c2c5da..03e3e86d88e 100644
--- a/esphome/components/template/lock/template_lock.h
+++ b/esphome/components/template/lock/template_lock.h
@@ -15,9 +15,9 @@ class TemplateLock final : public lock::Lock, public Component {
   void dump_config() override;
 
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
-  Trigger<> *get_lock_trigger() const;
-  Trigger<> *get_unlock_trigger() const;
-  Trigger<> *get_open_trigger() const;
+  Trigger<> *get_lock_trigger() { return &this->lock_trigger_; }
+  Trigger<> *get_unlock_trigger() { return &this->unlock_trigger_; }
+  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
   void set_optimistic(bool optimistic);
   void loop() override;
 
@@ -29,9 +29,9 @@ class TemplateLock final : public lock::Lock, public Component {
 
   TemplateLambda<lock::LockState> f_;
   bool optimistic_{false};
-  Trigger<> *lock_trigger_;
-  Trigger<> *unlock_trigger_;
-  Trigger<> *open_trigger_;
+  Trigger<> lock_trigger_;
+  Trigger<> unlock_trigger_;
+  Trigger<> open_trigger_;
   Trigger<> *prev_trigger_{nullptr};
 };
 
diff --git a/esphome/components/template/number/template_number.cpp b/esphome/components/template/number/template_number.cpp
index 885265cf5d2..64c2deb281a 100644
--- a/esphome/components/template/number/template_number.cpp
+++ b/esphome/components/template/number/template_number.cpp
@@ -36,7 +36,7 @@ void TemplateNumber::update() {
 }
 
 void TemplateNumber::control(float value) {
-  this->set_trigger_->trigger(value);
+  this->set_trigger_.trigger(value);
 
   if (this->optimistic_)
     this->publish_state(value);
diff --git a/esphome/components/template/number/template_number.h b/esphome/components/template/number/template_number.h
index 42c27fc3cad..e51e858ccf3 100644
--- a/esphome/components/template/number/template_number.h
+++ b/esphome/components/template/number/template_number.h
@@ -17,7 +17,7 @@ class TemplateNumber final : public number::Number, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<float> *get_set_trigger() const { return set_trigger_; }
+  Trigger<float> *get_set_trigger() { return &this->set_trigger_; }
   void set_optimistic(bool optimistic) { optimistic_ = optimistic; }
   void set_initial_value(float initial_value) { initial_value_ = initial_value; }
   void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
@@ -27,7 +27,7 @@ class TemplateNumber final : public number::Number, public PollingComponent {
   bool optimistic_{false};
   float initial_value_{NAN};
   bool restore_value_{false};
-  Trigger<float> *set_trigger_ = new Trigger<float>();
+  Trigger<float> set_trigger_;
   TemplateLambda<float> f_;
 
   ESPPreferenceObject pref_;
diff --git a/esphome/components/template/output/template_output.h b/esphome/components/template/output/template_output.h
index e536660b02d..6fe8e53855d 100644
--- a/esphome/components/template/output/template_output.h
+++ b/esphome/components/template/output/template_output.h
@@ -8,22 +8,22 @@ namespace esphome::template_ {
 
 class TemplateBinaryOutput final : public output::BinaryOutput {
  public:
-  Trigger<bool> *get_trigger() const { return trigger_; }
+  Trigger<bool> *get_trigger() { return &this->trigger_; }
 
  protected:
-  void write_state(bool state) override { this->trigger_->trigger(state); }
+  void write_state(bool state) override { this->trigger_.trigger(state); }
 
-  Trigger<bool> *trigger_ = new Trigger<bool>();
+  Trigger<bool> trigger_;
 };
 
 class TemplateFloatOutput final : public output::FloatOutput {
  public:
-  Trigger<float> *get_trigger() const { return trigger_; }
+  Trigger<float> *get_trigger() { return &this->trigger_; }
 
  protected:
-  void write_state(float state) override { this->trigger_->trigger(state); }
+  void write_state(float state) override { this->trigger_.trigger(state); }
 
-  Trigger<float> *trigger_ = new Trigger<float>();
+  Trigger<float> trigger_;
 };
 
 }  // namespace esphome::template_
diff --git a/esphome/components/template/select/__init__.py b/esphome/components/template/select/__init__.py
index 574f1f5fb7c..8de0b65c2df 100644
--- a/esphome/components/template/select/__init__.py
+++ b/esphome/components/template/select/__init__.py
@@ -10,35 +10,65 @@ from esphome.const import (
     CONF_OPTIONS,
     CONF_RESTORE_VALUE,
     CONF_SET_ACTION,
+    CONF_UPDATE_INTERVAL,
+    SCHEDULER_DONT_RUN,
 )
+from esphome.core import TimePeriodMilliseconds
+from esphome.cpp_generator import TemplateArguments
 
 from .. import template_ns
 
 TemplateSelect = template_ns.class_(
     "TemplateSelect", select.Select, cg.PollingComponent
 )
+TemplateSelectWithSetAction = template_ns.class_(
+    "TemplateSelectWithSetAction", TemplateSelect
+)
 
 
 def validate(config):
+    errors = []
     if CONF_LAMBDA in config:
         if config[CONF_OPTIMISTIC]:
-            raise cv.Invalid("optimistic cannot be used with lambda")
+            errors.append(
+                cv.Invalid(
+                    "optimistic cannot be used with lambda", path=[CONF_OPTIMISTIC]
+                )
+            )
         if CONF_INITIAL_OPTION in config:
-            raise cv.Invalid("initial_value cannot be used with lambda")
+            errors.append(
+                cv.Invalid(
+                    "initial_value cannot be used with lambda",
+                    path=[CONF_INITIAL_OPTION],
+                )
+            )
         if CONF_RESTORE_VALUE in config:
-            raise cv.Invalid("restore_value cannot be used with lambda")
+            errors.append(
+                cv.Invalid(
+                    "restore_value cannot be used with lambda",
+                    path=[CONF_RESTORE_VALUE],
+                )
+            )
     elif CONF_INITIAL_OPTION in config:
         if config[CONF_INITIAL_OPTION] not in config[CONF_OPTIONS]:
-            raise cv.Invalid(
-                f"initial_option '{config[CONF_INITIAL_OPTION]}' is not a valid option [{', '.join(config[CONF_OPTIONS])}]"
+            errors.append(
+                cv.Invalid(
+                    f"initial_option '{config[CONF_INITIAL_OPTION]}' is not a valid option [{', '.join(config[CONF_OPTIONS])}]",
+                    path=[CONF_INITIAL_OPTION],
+                )
             )
     else:
         config[CONF_INITIAL_OPTION] = config[CONF_OPTIONS][0]
 
     if not config[CONF_OPTIMISTIC] and CONF_SET_ACTION not in config:
-        raise cv.Invalid(
-            "Either optimistic mode must be enabled, or set_action must be set, to handle the option being set."
+        errors.append(
+            cv.Invalid(
+                "Either optimistic mode must be enabled, or set_action must be set, to handle the option being set."
+            )
         )
+    if errors:
+        raise cv.MultipleInvalid(errors)
+
     return config
 
 
@@ -62,29 +92,34 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await select.register_select(var, config, options=config[CONF_OPTIONS])
+    var_id = config[CONF_ID]
+    if CONF_SET_ACTION in config:
+        var_id.type = TemplateSelectWithSetAction
+    has_lambda = CONF_LAMBDA in config
+    optimistic = config.get(CONF_OPTIMISTIC, False)
+    restore_value = config.get(CONF_RESTORE_VALUE, False)
+    options = config[CONF_OPTIONS]
+    initial_option = config.get(CONF_INITIAL_OPTION, 0)
+    initial_option_index = options.index(initial_option) if not has_lambda else 0
+
+    var = cg.new_Pvariable(
+        var_id,
+        TemplateArguments(has_lambda, optimistic, restore_value, initial_option_index),
+    )
+    component_config = config.copy()
+    if not has_lambda:
+        # No point in polling if not using a lambda
+        component_config[CONF_UPDATE_INTERVAL] = TimePeriodMilliseconds(
+            milliseconds=SCHEDULER_DONT_RUN
+        )
+    await cg.register_component(var, component_config)
+    await select.register_select(var, config, options=options)
 
     if CONF_LAMBDA in config:
-        template_ = await cg.process_lambda(
+        lambda_ = await cg.process_lambda(
             config[CONF_LAMBDA], [], return_type=cg.optional.template(cg.std_string)
         )
-        cg.add(var.set_template(template_))
-
-    else:
-        # Only set if non-default to avoid bloating setup() function
-        if config[CONF_OPTIMISTIC]:
-            cg.add(var.set_optimistic(True))
-        initial_option_index = config[CONF_OPTIONS].index(config[CONF_INITIAL_OPTION])
-        # Only set if non-zero to avoid bloating setup() function
-        # (initial_option_index_ is zero-initialized in the header)
-        if initial_option_index != 0:
-            cg.add(var.set_initial_option_index(initial_option_index))
-
-        # Only set if True (default is False)
-        if config.get(CONF_RESTORE_VALUE):
-            cg.add(var.set_restore_value(True))
+        cg.add(var.set_lambda(lambda_))
 
     if CONF_SET_ACTION in config:
         await automation.build_automation(
diff --git a/esphome/components/template/select/template_select.cpp b/esphome/components/template/select/template_select.cpp
index fa34aa9fa74..e68729c2d4e 100644
--- a/esphome/components/template/select/template_select.cpp
+++ b/esphome/components/template/select/template_select.cpp
@@ -5,61 +5,44 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.select";
 
-void TemplateSelect::setup() {
-  if (this->f_.has_value())
-    return;
-
-  size_t index = this->initial_option_index_;
-  if (this->restore_value_) {
-    this->pref_ = this->make_entity_preference<size_t>();
-    size_t restored_index;
-    if (this->pref_.load(&restored_index) && this->has_index(restored_index)) {
-      index = restored_index;
-      ESP_LOGD(TAG, "State from restore: %s", this->option_at(index));
-    } else {
-      ESP_LOGD(TAG, "State from initial (could not load or invalid stored index): %s", this->option_at(index));
-    }
+void dump_config_helper(BaseTemplateSelect *sel_comp, bool optimistic, bool has_lambda,
+                        const size_t initial_option_index, bool restore_value) {
+  LOG_SELECT("", "Template Select", sel_comp);
+  if (has_lambda) {
+    LOG_UPDATE_INTERVAL(sel_comp);
   } else {
-    ESP_LOGD(TAG, "State from initial: %s", this->option_at(index));
+    ESP_LOGCONFIG(TAG,
+                  "  Optimistic: %s\n"
+                  "  Initial Option: %s\n"
+                  "  Restore Value: %s",
+                  YESNO(optimistic), sel_comp->option_at(initial_option_index), YESNO(restore_value));
   }
-
-  this->publish_state(index);
 }
 
-void TemplateSelect::update() {
-  if (!this->f_.has_value())
-    return;
+void setup_initial(BaseTemplateSelect *sel_comp, size_t initial_index) {
+  ESP_LOGD(TAG, "State from initial: %s", sel_comp->option_at(initial_index));
+  sel_comp->publish_state(initial_index);
+}
 
-  auto val = this->f_();
+void setup_with_restore(BaseTemplateSelect *sel_comp, ESPPreferenceObject &pref, size_t initial_index) {
+  size_t index = initial_index;
+  if (pref.load(&index) && sel_comp->has_index(index)) {
+    ESP_LOGD(TAG, "State from restore: %s", sel_comp->option_at(index));
+  } else {
+    index = initial_index;
+    ESP_LOGD(TAG, "State from initial (no valid stored index): %s", sel_comp->option_at(initial_index));
+  }
+  sel_comp->publish_state(index);
+}
+
+void update_lambda(BaseTemplateSelect *sel_comp, const optional<std::string> &val) {
   if (val.has_value()) {
-    if (!this->has_option(*val)) {
+    if (!sel_comp->has_option(*val)) {
       ESP_LOGE(TAG, "Lambda returned an invalid option: %s", (*val).c_str());
       return;
     }
-    this->publish_state(*val);
+    sel_comp->publish_state(*val);
   }
 }
 
-void TemplateSelect::control(size_t index) {
-  this->set_trigger_->trigger(StringRef(this->option_at(index)));
-
-  if (this->optimistic_)
-    this->publish_state(index);
-
-  if (this->restore_value_)
-    this->pref_.save(&index);
-}
-
-void TemplateSelect::dump_config() {
-  LOG_SELECT("", "Template Select", this);
-  LOG_UPDATE_INTERVAL(this);
-  if (this->f_.has_value())
-    return;
-  ESP_LOGCONFIG(TAG,
-                "  Optimistic: %s\n"
-                "  Initial Option: %s\n"
-                "  Restore Value: %s",
-                YESNO(this->optimistic_), this->option_at(this->initial_option_index_), YESNO(this->restore_value_));
-}
-
 }  // namespace esphome::template_
diff --git a/esphome/components/template/select/template_select.h b/esphome/components/template/select/template_select.h
index 114d25b9ce1..5da6d732bd4 100644
--- a/esphome/components/template/select/template_select.h
+++ b/esphome/components/template/select/template_select.h
@@ -9,29 +9,71 @@
 
 namespace esphome::template_ {
 
-class TemplateSelect final : public select::Select, public PollingComponent {
- public:
-  template<typename F> void set_template(F &&f) { this->f_.set(std::forward<F>(f)); }
+struct Empty {};
+class BaseTemplateSelect : public select::Select, public PollingComponent {};
 
-  void setup() override;
-  void update() override;
-  void dump_config() override;
+void dump_config_helper(BaseTemplateSelect *sel_comp, bool optimistic, bool has_lambda, size_t initial_option_index,
+                        bool restore_value);
+void setup_initial(BaseTemplateSelect *sel_comp, size_t initial_index);
+void setup_with_restore(BaseTemplateSelect *sel_comp, ESPPreferenceObject &pref, size_t initial_index);
+void update_lambda(BaseTemplateSelect *sel_comp, const optional<std::string> &val);
+
+/// Base template select class - used when no set_action is configured
+
+template<bool HAS_LAMBDA, bool OPTIMISTIC, bool RESTORE_VALUE, size_t INITIAL_OPTION_INDEX>
+class TemplateSelect : public BaseTemplateSelect {
+ public:
+  template<typename F> void set_lambda(F &&f) {
+    if constexpr (HAS_LAMBDA) {
+      this->f_.set(std::forward<F>(f));
+    }
+  }
+
+  void setup() override {
+    if constexpr (!HAS_LAMBDA) {
+      if constexpr (RESTORE_VALUE) {
+        this->pref_ = this->template make_entity_preference<size_t>();
+        setup_with_restore(this, this->pref_, INITIAL_OPTION_INDEX);
+      } else {
+        setup_initial(this, INITIAL_OPTION_INDEX);
+      }
+    }
+  }
+
+  void update() override {
+    if constexpr (HAS_LAMBDA) {
+      update_lambda(this, this->f_());
+    }
+  }
+  void dump_config() override {
+    dump_config_helper(this, OPTIMISTIC, HAS_LAMBDA, INITIAL_OPTION_INDEX, RESTORE_VALUE);
+  };
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<StringRef> *get_set_trigger() const { return this->set_trigger_; }
-  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_initial_option_index(size_t initial_option_index) { this->initial_option_index_ = initial_option_index; }
-  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
+ protected:
+  void control(size_t index) override {
+    if constexpr (OPTIMISTIC)
+      this->publish_state(index);
+    if constexpr (RESTORE_VALUE)
+      this->pref_.save(&index);
+  }
+  [[no_unique_address]] std::conditional_t<HAS_LAMBDA, TemplateLambda<std::string>, Empty> f_{};
+  [[no_unique_address]] std::conditional_t<RESTORE_VALUE, ESPPreferenceObject, Empty> pref_{};
+};
+
+/// Template select with set_action trigger - only instantiated when set_action is configured
+template<bool HAS_LAMBDA, bool OPTIMISTIC, bool RESTORE_VALUE, size_t INITIAL_OPTION_INDEX>
+class TemplateSelectWithSetAction final
+    : public TemplateSelect<HAS_LAMBDA, OPTIMISTIC, RESTORE_VALUE, INITIAL_OPTION_INDEX> {
+ public:
+  Trigger<StringRef> *get_set_trigger() { return &this->set_trigger_; }
 
  protected:
-  void control(size_t index) override;
-  bool optimistic_ = false;
-  size_t initial_option_index_{0};
-  bool restore_value_ = false;
-  Trigger<StringRef> *set_trigger_ = new Trigger<StringRef>();
-  TemplateLambda<std::string> f_;
-
-  ESPPreferenceObject pref_;
+  void control(size_t index) override {
+    this->set_trigger_.trigger(StringRef(this->option_at(index)));
+    TemplateSelect<HAS_LAMBDA, OPTIMISTIC, RESTORE_VALUE, INITIAL_OPTION_INDEX>::control(index);
+  }
+  Trigger<StringRef> set_trigger_;
 };
 
 }  // namespace esphome::template_
diff --git a/esphome/components/template/switch/template_switch.cpp b/esphome/components/template/switch/template_switch.cpp
index cfa8798e750..05288b2d4e0 100644
--- a/esphome/components/template/switch/template_switch.cpp
+++ b/esphome/components/template/switch/template_switch.cpp
@@ -5,7 +5,7 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.switch";
 
-TemplateSwitch::TemplateSwitch() : turn_on_trigger_(new Trigger<>()), turn_off_trigger_(new Trigger<>()) {}
+TemplateSwitch::TemplateSwitch() = default;
 
 void TemplateSwitch::loop() {
   auto s = this->f_();
@@ -19,11 +19,11 @@ void TemplateSwitch::write_state(bool state) {
   }
 
   if (state) {
-    this->prev_trigger_ = this->turn_on_trigger_;
-    this->turn_on_trigger_->trigger();
+    this->prev_trigger_ = &this->turn_on_trigger_;
+    this->turn_on_trigger_.trigger();
   } else {
-    this->prev_trigger_ = this->turn_off_trigger_;
-    this->turn_off_trigger_->trigger();
+    this->prev_trigger_ = &this->turn_off_trigger_;
+    this->turn_off_trigger_.trigger();
   }
 
   if (this->optimistic_)
@@ -32,8 +32,8 @@ void TemplateSwitch::write_state(bool state) {
 void TemplateSwitch::set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
 bool TemplateSwitch::assumed_state() { return this->assumed_state_; }
 float TemplateSwitch::get_setup_priority() const { return setup_priority::HARDWARE - 2.0f; }
-Trigger<> *TemplateSwitch::get_turn_on_trigger() const { return this->turn_on_trigger_; }
-Trigger<> *TemplateSwitch::get_turn_off_trigger() const { return this->turn_off_trigger_; }
+Trigger<> *TemplateSwitch::get_turn_on_trigger() { return &this->turn_on_trigger_; }
+Trigger<> *TemplateSwitch::get_turn_off_trigger() { return &this->turn_off_trigger_; }
 void TemplateSwitch::setup() {
   if (!this->f_.has_value())
     this->disable_loop();
diff --git a/esphome/components/template/switch/template_switch.h b/esphome/components/template/switch/template_switch.h
index 91b7b396f60..1714b4f72b9 100644
--- a/esphome/components/template/switch/template_switch.h
+++ b/esphome/components/template/switch/template_switch.h
@@ -15,8 +15,8 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   void dump_config() override;
 
   template<typename F> void set_state_lambda(F &&f) { this->f_.set(std::forward<F>(f)); }
-  Trigger<> *get_turn_on_trigger() const;
-  Trigger<> *get_turn_off_trigger() const;
+  Trigger<> *get_turn_on_trigger();
+  Trigger<> *get_turn_off_trigger();
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void loop() override;
@@ -31,9 +31,9 @@ class TemplateSwitch final : public switch_::Switch, public Component {
   TemplateLambda<bool> f_;
   bool optimistic_{false};
   bool assumed_state_{false};
-  Trigger<> *turn_on_trigger_;
-  Trigger<> *turn_off_trigger_;
-  Trigger<> *prev_trigger_{nullptr};
+  Trigger<> turn_on_trigger_;
+  Trigger<> turn_off_trigger_;
+  Trigger<> *prev_trigger_{nullptr};  // Points to one of the above
 };
 
 }  // namespace esphome::template_
diff --git a/esphome/components/template/text/template_text.cpp b/esphome/components/template/text/template_text.cpp
index 70b8dce312d..af134e6ed4a 100644
--- a/esphome/components/template/text/template_text.cpp
+++ b/esphome/components/template/text/template_text.cpp
@@ -47,7 +47,7 @@ void TemplateText::update() {
 }
 
 void TemplateText::control(const std::string &value) {
-  this->set_trigger_->trigger(value);
+  this->set_trigger_.trigger(value);
 
   if (this->optimistic_)
     this->publish_state(value);
diff --git a/esphome/components/template/text/template_text.h b/esphome/components/template/text/template_text.h
index e5e5e4f4a8b..88c6afdf2c6 100644
--- a/esphome/components/template/text/template_text.h
+++ b/esphome/components/template/text/template_text.h
@@ -68,7 +68,7 @@ class TemplateText final : public text::Text, public PollingComponent {
   void dump_config() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
 
-  Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
+  Trigger<std::string> *get_set_trigger() { return &this->set_trigger_; }
   void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
   void set_initial_value(const char *initial_value) { this->initial_value_ = initial_value; }
   /// Prevent accidental use of std::string which would dangle
@@ -79,7 +79,7 @@ class TemplateText final : public text::Text, public PollingComponent {
   void control(const std::string &value) override;
   bool optimistic_ = false;
   const char *initial_value_{nullptr};
-  Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
+  Trigger<std::string> set_trigger_;
   TemplateLambda<std::string> f_{};
 
   TemplateTextSaverBase *pref_ = nullptr;
diff --git a/esphome/components/template/valve/template_valve.cpp b/esphome/components/template/valve/template_valve.cpp
index 4e772f92538..2817e1a1327 100644
--- a/esphome/components/template/valve/template_valve.cpp
+++ b/esphome/components/template/valve/template_valve.cpp
@@ -7,12 +7,7 @@ using namespace esphome::valve;
 
 static const char *const TAG = "template.valve";
 
-TemplateValve::TemplateValve()
-    : open_trigger_(new Trigger<>()),
-      close_trigger_(new Trigger<>),
-      stop_trigger_(new Trigger<>()),
-      toggle_trigger_(new Trigger<>()),
-      position_trigger_(new Trigger<float>()) {}
+TemplateValve::TemplateValve() = default;
 
 void TemplateValve::setup() {
   switch (this->restore_mode_) {
@@ -56,10 +51,10 @@ void TemplateValve::set_optimistic(bool optimistic) { this->optimistic_ = optimi
 void TemplateValve::set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 float TemplateValve::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-Trigger<> *TemplateValve::get_open_trigger() const { return this->open_trigger_; }
-Trigger<> *TemplateValve::get_close_trigger() const { return this->close_trigger_; }
-Trigger<> *TemplateValve::get_stop_trigger() const { return this->stop_trigger_; }
-Trigger<> *TemplateValve::get_toggle_trigger() const { return this->toggle_trigger_; }
+Trigger<> *TemplateValve::get_open_trigger() { return &this->open_trigger_; }
+Trigger<> *TemplateValve::get_close_trigger() { return &this->close_trigger_; }
+Trigger<> *TemplateValve::get_stop_trigger() { return &this->stop_trigger_; }
+Trigger<> *TemplateValve::get_toggle_trigger() { return &this->toggle_trigger_; }
 
 void TemplateValve::dump_config() {
   LOG_VALVE("", "Template Valve", this);
@@ -72,14 +67,14 @@ void TemplateValve::dump_config() {
 void TemplateValve::control(const ValveCall &call) {
   if (call.get_stop()) {
     this->stop_prev_trigger_();
-    this->stop_trigger_->trigger();
-    this->prev_command_trigger_ = this->stop_trigger_;
+    this->stop_trigger_.trigger();
+    this->prev_command_trigger_ = &this->stop_trigger_;
     this->publish_state();
   }
   if (call.get_toggle().has_value()) {
     this->stop_prev_trigger_();
-    this->toggle_trigger_->trigger();
-    this->prev_command_trigger_ = this->toggle_trigger_;
+    this->toggle_trigger_.trigger();
+    this->prev_command_trigger_ = &this->toggle_trigger_;
     this->publish_state();
   }
   if (call.get_position().has_value()) {
@@ -87,13 +82,13 @@ void TemplateValve::control(const ValveCall &call) {
     this->stop_prev_trigger_();
 
     if (pos == VALVE_OPEN) {
-      this->open_trigger_->trigger();
-      this->prev_command_trigger_ = this->open_trigger_;
+      this->open_trigger_.trigger();
+      this->prev_command_trigger_ = &this->open_trigger_;
     } else if (pos == VALVE_CLOSED) {
-      this->close_trigger_->trigger();
-      this->prev_command_trigger_ = this->close_trigger_;
+      this->close_trigger_.trigger();
+      this->prev_command_trigger_ = &this->close_trigger_;
     } else {
-      this->position_trigger_->trigger(pos);
+      this->position_trigger_.trigger(pos);
     }
 
     if (this->optimistic_) {
@@ -113,7 +108,7 @@ ValveTraits TemplateValve::get_traits() {
   return traits;
 }
 
-Trigger<float> *TemplateValve::get_position_trigger() const { return this->position_trigger_; }
+Trigger<float> *TemplateValve::get_position_trigger() { return &this->position_trigger_; }
 
 void TemplateValve::set_has_stop(bool has_stop) { this->has_stop_ = has_stop; }
 void TemplateValve::set_has_toggle(bool has_toggle) { this->has_toggle_ = has_toggle; }
diff --git a/esphome/components/template/valve/template_valve.h b/esphome/components/template/valve/template_valve.h
index 4205682a2aa..76c4630aa02 100644
--- a/esphome/components/template/valve/template_valve.h
+++ b/esphome/components/template/valve/template_valve.h
@@ -18,11 +18,11 @@ class TemplateValve final : public valve::Valve, public Component {
   TemplateValve();
 
   template<typename F> void set_state_lambda(F &&f) { this->state_f_.set(std::forward<F>(f)); }
-  Trigger<> *get_open_trigger() const;
-  Trigger<> *get_close_trigger() const;
-  Trigger<> *get_stop_trigger() const;
-  Trigger<> *get_toggle_trigger() const;
-  Trigger<float> *get_position_trigger() const;
+  Trigger<> *get_open_trigger();
+  Trigger<> *get_close_trigger();
+  Trigger<> *get_stop_trigger();
+  Trigger<> *get_toggle_trigger();
+  Trigger<float> *get_position_trigger();
   void set_optimistic(bool optimistic);
   void set_assumed_state(bool assumed_state);
   void set_has_stop(bool has_stop);
@@ -45,14 +45,14 @@ class TemplateValve final : public valve::Valve, public Component {
   TemplateLambda<float> state_f_;
   bool assumed_state_{false};
   bool optimistic_{false};
-  Trigger<> *open_trigger_;
-  Trigger<> *close_trigger_;
+  Trigger<> open_trigger_;
+  Trigger<> close_trigger_;
   bool has_stop_{false};
   bool has_toggle_{false};
-  Trigger<> *stop_trigger_;
-  Trigger<> *toggle_trigger_;
+  Trigger<> stop_trigger_;
+  Trigger<> toggle_trigger_;
   Trigger<> *prev_command_trigger_{nullptr};
-  Trigger<float> *position_trigger_;
+  Trigger<float> position_trigger_;
   bool has_position_{false};
 };
 
diff --git a/esphome/components/template/water_heater/template_water_heater.cpp b/esphome/components/template/water_heater/template_water_heater.cpp
index e89c96ca484..f888edb1df0 100644
--- a/esphome/components/template/water_heater/template_water_heater.cpp
+++ b/esphome/components/template/water_heater/template_water_heater.cpp
@@ -5,7 +5,7 @@ namespace esphome::template_ {
 
 static const char *const TAG = "template.water_heater";
 
-TemplateWaterHeater::TemplateWaterHeater() : set_trigger_(new Trigger<>()) {}
+TemplateWaterHeater::TemplateWaterHeater() = default;
 
 void TemplateWaterHeater::setup() {
   if (this->restore_mode_ == TemplateWaterHeaterRestoreMode::WATER_HEATER_RESTORE ||
@@ -78,7 +78,7 @@ void TemplateWaterHeater::control(const water_heater::WaterHeaterCall &call) {
     }
   }
 
-  this->set_trigger_->trigger();
+  this->set_trigger_.trigger();
 
   if (this->optimistic_) {
     this->publish_state();
diff --git a/esphome/components/template/water_heater/template_water_heater.h b/esphome/components/template/water_heater/template_water_heater.h
index c2a2dcbb236..f1cf00a1157 100644
--- a/esphome/components/template/water_heater/template_water_heater.h
+++ b/esphome/components/template/water_heater/template_water_heater.h
@@ -28,7 +28,7 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
     this->supported_modes_ = modes;
   }
 
-  Trigger<> *get_set_trigger() const { return this->set_trigger_; }
+  Trigger<> *get_set_trigger() { return &this->set_trigger_; }
 
   void setup() override;
   void loop() override;
@@ -42,7 +42,7 @@ class TemplateWaterHeater : public Component, public water_heater::WaterHeater {
   water_heater::WaterHeaterTraits traits() override;
 
   // Ordered to minimize padding on 32-bit: 4-byte members first, then smaller
-  Trigger<> *set_trigger_;
+  Trigger<> set_trigger_;
   TemplateLambda<float> current_temperature_f_;
   TemplateLambda<water_heater::WaterHeaterMode> mode_f_;
   TemplateWaterHeaterRestoreMode restore_mode_{WATER_HEATER_NO_RESTORE};
diff --git a/esphome/components/thermostat/thermostat_climate.cpp b/esphome/components/thermostat/thermostat_climate.cpp
index 44087969b5e..c6664197010 100644
--- a/esphome/components/thermostat/thermostat_climate.cpp
+++ b/esphome/components/thermostat/thermostat_climate.cpp
@@ -499,7 +499,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
   }
 
   bool action_ready = false;
-  Trigger<> *trig = this->idle_action_trigger_, *trig_fan = nullptr;
+  Trigger<> *trig = &this->idle_action_trigger_, *trig_fan = nullptr;
   switch (action) {
     case climate::CLIMATE_ACTION_OFF:
     case climate::CLIMATE_ACTION_IDLE:
@@ -529,10 +529,10 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
         this->start_timer_(thermostat::THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME);
         if (this->supports_fan_with_cooling_) {
           this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
-          trig_fan = this->fan_only_action_trigger_;
+          trig_fan = &this->fan_only_action_trigger_;
         }
         this->cooling_max_runtime_exceeded_ = false;
-        trig = this->cool_action_trigger_;
+        trig = &this->cool_action_trigger_;
         ESP_LOGVV(TAG, "Switching to COOLING action");
         action_ready = true;
       }
@@ -543,10 +543,10 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
         this->start_timer_(thermostat::THERMOSTAT_TIMER_HEATING_MAX_RUN_TIME);
         if (this->supports_fan_with_heating_) {
           this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
-          trig_fan = this->fan_only_action_trigger_;
+          trig_fan = &this->fan_only_action_trigger_;
         }
         this->heating_max_runtime_exceeded_ = false;
-        trig = this->heat_action_trigger_;
+        trig = &this->heat_action_trigger_;
         ESP_LOGVV(TAG, "Switching to HEATING action");
         action_ready = true;
       }
@@ -558,7 +558,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
         } else {
           this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
         }
-        trig = this->fan_only_action_trigger_;
+        trig = &this->fan_only_action_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_ONLY action");
         action_ready = true;
       }
@@ -567,7 +567,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
       if (this->drying_action_ready_()) {
         this->start_timer_(thermostat::THERMOSTAT_TIMER_COOLING_ON);
         this->start_timer_(thermostat::THERMOSTAT_TIMER_FANNING_ON);
-        trig = this->dry_action_trigger_;
+        trig = &this->dry_action_trigger_;
         ESP_LOGVV(TAG, "Switching to DRYING action");
         action_ready = true;
       }
@@ -586,9 +586,7 @@ void ThermostatClimate::switch_to_action_(climate::ClimateAction action, bool pu
     }
     this->action = action;
     this->prev_action_trigger_ = trig;
-    if (trig != nullptr) {
-      trig->trigger();
-    }
+    trig->trigger();
     // if enabled, call the fan_only action with cooling/heating actions
     if (trig_fan != nullptr) {
       ESP_LOGVV(TAG, "Calling FAN_ONLY action with HEATING/COOLING action");
@@ -634,14 +632,14 @@ void ThermostatClimate::trigger_supplemental_action_() {
       if (!this->timer_active_(thermostat::THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME)) {
         this->start_timer_(thermostat::THERMOSTAT_TIMER_COOLING_MAX_RUN_TIME);
       }
-      trig = this->supplemental_cool_action_trigger_;
+      trig = &this->supplemental_cool_action_trigger_;
       ESP_LOGVV(TAG, "Calling supplemental COOLING action");
       break;
     case climate::CLIMATE_ACTION_HEATING:
       if (!this->timer_active_(thermostat::THERMOSTAT_TIMER_HEATING_MAX_RUN_TIME)) {
         this->start_timer_(thermostat::THERMOSTAT_TIMER_HEATING_MAX_RUN_TIME);
       }
-      trig = this->supplemental_heat_action_trigger_;
+      trig = &this->supplemental_heat_action_trigger_;
       ESP_LOGVV(TAG, "Calling supplemental HEATING action");
       break;
     default:
@@ -660,24 +658,24 @@ void ThermostatClimate::switch_to_humidity_control_action_(HumidificationAction
     return;
   }
 
-  Trigger<> *trig = this->humidity_control_off_action_trigger_;
+  Trigger<> *trig = &this->humidity_control_off_action_trigger_;
   switch (action) {
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF:
-      // trig = this->humidity_control_off_action_trigger_;
+      // trig = &this->humidity_control_off_action_trigger_;
       ESP_LOGVV(TAG, "Switching to HUMIDIFICATION_OFF action");
       break;
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_DEHUMIDIFY:
-      trig = this->humidity_control_dehumidify_action_trigger_;
+      trig = &this->humidity_control_dehumidify_action_trigger_;
       ESP_LOGVV(TAG, "Switching to DEHUMIDIFY action");
       break;
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_HUMIDIFY:
-      trig = this->humidity_control_humidify_action_trigger_;
+      trig = &this->humidity_control_humidify_action_trigger_;
       ESP_LOGVV(TAG, "Switching to HUMIDIFY action");
       break;
     case THERMOSTAT_HUMIDITY_CONTROL_ACTION_NONE:
     default:
       action = THERMOSTAT_HUMIDITY_CONTROL_ACTION_OFF;
-      // trig = this->humidity_control_off_action_trigger_;
+      // trig = &this->humidity_control_off_action_trigger_;
   }
 
   if (this->prev_humidity_control_trigger_ != nullptr) {
@@ -686,9 +684,7 @@ void ThermostatClimate::switch_to_humidity_control_action_(HumidificationAction
   }
   this->humidification_action = action;
   this->prev_humidity_control_trigger_ = trig;
-  if (trig != nullptr) {
-    trig->trigger();
-  }
+  trig->trigger();
 }
 
 void ThermostatClimate::switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bool publish_state) {
@@ -703,62 +699,60 @@ void ThermostatClimate::switch_to_fan_mode_(climate::ClimateFanMode fan_mode, bo
     this->publish_state();
 
   if (this->fan_mode_ready_()) {
-    Trigger<> *trig = this->fan_mode_auto_trigger_;
+    Trigger<> *trig = &this->fan_mode_auto_trigger_;
     switch (fan_mode) {
       case climate::CLIMATE_FAN_ON:
-        trig = this->fan_mode_on_trigger_;
+        trig = &this->fan_mode_on_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_ON mode");
         break;
       case climate::CLIMATE_FAN_OFF:
-        trig = this->fan_mode_off_trigger_;
+        trig = &this->fan_mode_off_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_OFF mode");
         break;
       case climate::CLIMATE_FAN_AUTO:
-        // trig = this->fan_mode_auto_trigger_;
+        // trig = &this->fan_mode_auto_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_AUTO mode");
         break;
       case climate::CLIMATE_FAN_LOW:
-        trig = this->fan_mode_low_trigger_;
+        trig = &this->fan_mode_low_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_LOW mode");
         break;
       case climate::CLIMATE_FAN_MEDIUM:
-        trig = this->fan_mode_medium_trigger_;
+        trig = &this->fan_mode_medium_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_MEDIUM mode");
         break;
       case climate::CLIMATE_FAN_HIGH:
-        trig = this->fan_mode_high_trigger_;
+        trig = &this->fan_mode_high_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_HIGH mode");
         break;
       case climate::CLIMATE_FAN_MIDDLE:
-        trig = this->fan_mode_middle_trigger_;
+        trig = &this->fan_mode_middle_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_MIDDLE mode");
         break;
       case climate::CLIMATE_FAN_FOCUS:
-        trig = this->fan_mode_focus_trigger_;
+        trig = &this->fan_mode_focus_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_FOCUS mode");
         break;
       case climate::CLIMATE_FAN_DIFFUSE:
-        trig = this->fan_mode_diffuse_trigger_;
+        trig = &this->fan_mode_diffuse_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_DIFFUSE mode");
         break;
       case climate::CLIMATE_FAN_QUIET:
-        trig = this->fan_mode_quiet_trigger_;
+        trig = &this->fan_mode_quiet_trigger_;
         ESP_LOGVV(TAG, "Switching to FAN_QUIET mode");
         break;
       default:
         // we cannot report an invalid mode back to HA (even if it asked for one)
         //  and must assume some valid value
         fan_mode = climate::CLIMATE_FAN_AUTO;
-        // trig = this->fan_mode_auto_trigger_;
+        // trig = &this->fan_mode_auto_trigger_;
     }
     if (this->prev_fan_mode_trigger_ != nullptr) {
       this->prev_fan_mode_trigger_->stop_action();
       this->prev_fan_mode_trigger_ = nullptr;
     }
     this->start_timer_(thermostat::THERMOSTAT_TIMER_FAN_MODE);
-    if (trig != nullptr) {
-      trig->trigger();
-    }
+    trig->trigger();
     this->prev_fan_mode_ = fan_mode;
     this->prev_fan_mode_trigger_ = trig;
   }
@@ -775,25 +769,25 @@ void ThermostatClimate::switch_to_mode_(climate::ClimateMode mode, bool publish_
     this->prev_mode_trigger_->stop_action();
     this->prev_mode_trigger_ = nullptr;
   }
-  Trigger<> *trig = this->off_mode_trigger_;
+  Trigger<> *trig = &this->off_mode_trigger_;
   switch (mode) {
     case climate::CLIMATE_MODE_AUTO:
-      trig = this->auto_mode_trigger_;
+      trig = &this->auto_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_HEAT_COOL:
-      trig = this->heat_cool_mode_trigger_;
+      trig = &this->heat_cool_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_COOL:
-      trig = this->cool_mode_trigger_;
+      trig = &this->cool_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_HEAT:
-      trig = this->heat_mode_trigger_;
+      trig = &this->heat_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_FAN_ONLY:
-      trig = this->fan_only_mode_trigger_;
+      trig = &this->fan_only_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_DRY:
-      trig = this->dry_mode_trigger_;
+      trig = &this->dry_mode_trigger_;
       break;
     case climate::CLIMATE_MODE_OFF:
     default:
@@ -802,9 +796,7 @@ void ThermostatClimate::switch_to_mode_(climate::ClimateMode mode, bool publish_
       mode = climate::CLIMATE_MODE_OFF;
       // trig = this->off_mode_trigger_;
   }
-  if (trig != nullptr) {
-    trig->trigger();
-  }
+  trig->trigger();
   this->mode = mode;
   this->prev_mode_ = mode;
   this->prev_mode_trigger_ = trig;
@@ -824,29 +816,27 @@ void ThermostatClimate::switch_to_swing_mode_(climate::ClimateSwingMode swing_mo
     this->prev_swing_mode_trigger_->stop_action();
     this->prev_swing_mode_trigger_ = nullptr;
   }
-  Trigger<> *trig = this->swing_mode_off_trigger_;
+  Trigger<> *trig = &this->swing_mode_off_trigger_;
   switch (swing_mode) {
     case climate::CLIMATE_SWING_BOTH:
-      trig = this->swing_mode_both_trigger_;
+      trig = &this->swing_mode_both_trigger_;
       break;
     case climate::CLIMATE_SWING_HORIZONTAL:
-      trig = this->swing_mode_horizontal_trigger_;
+      trig = &this->swing_mode_horizontal_trigger_;
       break;
     case climate::CLIMATE_SWING_OFF:
-      // trig = this->swing_mode_off_trigger_;
+      // trig = &this->swing_mode_off_trigger_;
       break;
     case climate::CLIMATE_SWING_VERTICAL:
-      trig = this->swing_mode_vertical_trigger_;
+      trig = &this->swing_mode_vertical_trigger_;
       break;
     default:
       // we cannot report an invalid mode back to HA (even if it asked for one)
       //  and must assume some valid value
       swing_mode = climate::CLIMATE_SWING_OFF;
-      // trig = this->swing_mode_off_trigger_;
-  }
-  if (trig != nullptr) {
-    trig->trigger();
+      // trig = &this->swing_mode_off_trigger_;
   }
+  trig->trigger();
   this->swing_mode = swing_mode;
   this->prev_swing_mode_ = swing_mode;
   this->prev_swing_mode_trigger_ = trig;
@@ -1024,10 +1014,8 @@ void ThermostatClimate::check_humidity_change_trigger_() {
     this->prev_target_humidity_ = this->target_humidity;
   }
   // trigger the action
-  Trigger<> *trig = this->humidity_change_trigger_;
-  if (trig != nullptr) {
-    trig->trigger();
-  }
+  Trigger<> *trig = &this->humidity_change_trigger_;
+  trig->trigger();
 }
 
 void ThermostatClimate::check_temperature_change_trigger_() {
@@ -1050,10 +1038,8 @@ void ThermostatClimate::check_temperature_change_trigger_() {
     }
   }
   // trigger the action
-  Trigger<> *trig = this->temperature_change_trigger_;
-  if (trig != nullptr) {
-    trig->trigger();
-  }
+  Trigger<> *trig = &this->temperature_change_trigger_;
+  trig->trigger();
 }
 
 bool ThermostatClimate::cooling_required_() {
@@ -1202,12 +1188,10 @@ void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
   if (config != nullptr) {
     ESP_LOGV(TAG, "Preset %s requested", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
     if (this->change_preset_internal_(*config) || (!this->preset.has_value()) || this->preset.value() != preset) {
-      // Fire any preset changed trigger if defined
-      Trigger<> *trig = this->preset_change_trigger_;
+      // Fire preset changed trigger
+      Trigger<> *trig = &this->preset_change_trigger_;
       this->set_preset_(preset);
-      if (trig != nullptr) {
-        trig->trigger();
-      }
+      trig->trigger();
 
       this->refresh();
       ESP_LOGI(TAG, "Preset %s applied", LOG_STR_ARG(climate::climate_preset_to_string(preset)));
@@ -1234,13 +1218,11 @@ void ThermostatClimate::change_custom_preset_(const char *custom_preset, size_t
     ESP_LOGV(TAG, "Custom preset %s requested", custom_preset);
     if (this->change_preset_internal_(*config) || !this->has_custom_preset() ||
         this->get_custom_preset() != custom_preset) {
-      // Fire any preset changed trigger if defined
-      Trigger<> *trig = this->preset_change_trigger_;
+      // Fire preset changed trigger
+      Trigger<> *trig = &this->preset_change_trigger_;
       // Use the base class method which handles pointer lookup and preset reset internally
       this->set_custom_preset_(custom_preset);
-      if (trig != nullptr) {
-        trig->trigger();
-      }
+      trig->trigger();
 
       this->refresh();
       ESP_LOGI(TAG, "Custom preset %s applied", custom_preset);
@@ -1305,41 +1287,7 @@ void ThermostatClimate::set_custom_preset_config(std::initializer_list<CustomPre
   this->custom_preset_config_ = presets;
 }
 
-ThermostatClimate::ThermostatClimate()
-    : cool_action_trigger_(new Trigger<>()),
-      supplemental_cool_action_trigger_(new Trigger<>()),
-      cool_mode_trigger_(new Trigger<>()),
-      dry_action_trigger_(new Trigger<>()),
-      dry_mode_trigger_(new Trigger<>()),
-      heat_action_trigger_(new Trigger<>()),
-      supplemental_heat_action_trigger_(new Trigger<>()),
-      heat_mode_trigger_(new Trigger<>()),
-      heat_cool_mode_trigger_(new Trigger<>()),
-      auto_mode_trigger_(new Trigger<>()),
-      idle_action_trigger_(new Trigger<>()),
-      off_mode_trigger_(new Trigger<>()),
-      fan_only_action_trigger_(new Trigger<>()),
-      fan_only_mode_trigger_(new Trigger<>()),
-      fan_mode_on_trigger_(new Trigger<>()),
-      fan_mode_off_trigger_(new Trigger<>()),
-      fan_mode_auto_trigger_(new Trigger<>()),
-      fan_mode_low_trigger_(new Trigger<>()),
-      fan_mode_medium_trigger_(new Trigger<>()),
-      fan_mode_high_trigger_(new Trigger<>()),
-      fan_mode_middle_trigger_(new Trigger<>()),
-      fan_mode_focus_trigger_(new Trigger<>()),
-      fan_mode_diffuse_trigger_(new Trigger<>()),
-      fan_mode_quiet_trigger_(new Trigger<>()),
-      swing_mode_both_trigger_(new Trigger<>()),
-      swing_mode_off_trigger_(new Trigger<>()),
-      swing_mode_horizontal_trigger_(new Trigger<>()),
-      swing_mode_vertical_trigger_(new Trigger<>()),
-      humidity_change_trigger_(new Trigger<>()),
-      temperature_change_trigger_(new Trigger<>()),
-      preset_change_trigger_(new Trigger<>()),
-      humidity_control_dehumidify_action_trigger_(new Trigger<>()),
-      humidity_control_humidify_action_trigger_(new Trigger<>()),
-      humidity_control_off_action_trigger_(new Trigger<>()) {}
+ThermostatClimate::ThermostatClimate() = default;
 
 void ThermostatClimate::set_default_preset(const char *custom_preset) {
   // Find the preset in custom_preset_config_ and store pointer from there
@@ -1513,49 +1461,49 @@ void ThermostatClimate::set_supports_humidification(bool supports_humidification
   }
 }
 
-Trigger<> *ThermostatClimate::get_cool_action_trigger() const { return this->cool_action_trigger_; }
-Trigger<> *ThermostatClimate::get_supplemental_cool_action_trigger() const {
-  return this->supplemental_cool_action_trigger_;
+Trigger<> *ThermostatClimate::get_cool_action_trigger() { return &this->cool_action_trigger_; }
+Trigger<> *ThermostatClimate::get_supplemental_cool_action_trigger() {
+  return &this->supplemental_cool_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_dry_action_trigger() const { return this->dry_action_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_only_action_trigger() const { return this->fan_only_action_trigger_; }
-Trigger<> *ThermostatClimate::get_heat_action_trigger() const { return this->heat_action_trigger_; }
-Trigger<> *ThermostatClimate::get_supplemental_heat_action_trigger() const {
-  return this->supplemental_heat_action_trigger_;
+Trigger<> *ThermostatClimate::get_dry_action_trigger() { return &this->dry_action_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_only_action_trigger() { return &this->fan_only_action_trigger_; }
+Trigger<> *ThermostatClimate::get_heat_action_trigger() { return &this->heat_action_trigger_; }
+Trigger<> *ThermostatClimate::get_supplemental_heat_action_trigger() {
+  return &this->supplemental_heat_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_idle_action_trigger() const { return this->idle_action_trigger_; }
-Trigger<> *ThermostatClimate::get_auto_mode_trigger() const { return this->auto_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_cool_mode_trigger() const { return this->cool_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_dry_mode_trigger() const { return this->dry_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_only_mode_trigger() const { return this->fan_only_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_heat_mode_trigger() const { return this->heat_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_heat_cool_mode_trigger() const { return this->heat_cool_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_off_mode_trigger() const { return this->off_mode_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_on_trigger() const { return this->fan_mode_on_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_off_trigger() const { return this->fan_mode_off_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_auto_trigger() const { return this->fan_mode_auto_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_low_trigger() const { return this->fan_mode_low_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_medium_trigger() const { return this->fan_mode_medium_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_high_trigger() const { return this->fan_mode_high_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_middle_trigger() const { return this->fan_mode_middle_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_focus_trigger() const { return this->fan_mode_focus_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_diffuse_trigger() const { return this->fan_mode_diffuse_trigger_; }
-Trigger<> *ThermostatClimate::get_fan_mode_quiet_trigger() const { return this->fan_mode_quiet_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_both_trigger() const { return this->swing_mode_both_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_off_trigger() const { return this->swing_mode_off_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_horizontal_trigger() const { return this->swing_mode_horizontal_trigger_; }
-Trigger<> *ThermostatClimate::get_swing_mode_vertical_trigger() const { return this->swing_mode_vertical_trigger_; }
-Trigger<> *ThermostatClimate::get_humidity_change_trigger() const { return this->humidity_change_trigger_; }
-Trigger<> *ThermostatClimate::get_temperature_change_trigger() const { return this->temperature_change_trigger_; }
-Trigger<> *ThermostatClimate::get_preset_change_trigger() const { return this->preset_change_trigger_; }
-Trigger<> *ThermostatClimate::get_humidity_control_dehumidify_action_trigger() const {
-  return this->humidity_control_dehumidify_action_trigger_;
+Trigger<> *ThermostatClimate::get_idle_action_trigger() { return &this->idle_action_trigger_; }
+Trigger<> *ThermostatClimate::get_auto_mode_trigger() { return &this->auto_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_cool_mode_trigger() { return &this->cool_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_dry_mode_trigger() { return &this->dry_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_only_mode_trigger() { return &this->fan_only_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_heat_mode_trigger() { return &this->heat_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_heat_cool_mode_trigger() { return &this->heat_cool_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_off_mode_trigger() { return &this->off_mode_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_on_trigger() { return &this->fan_mode_on_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_off_trigger() { return &this->fan_mode_off_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_auto_trigger() { return &this->fan_mode_auto_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_low_trigger() { return &this->fan_mode_low_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_medium_trigger() { return &this->fan_mode_medium_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_high_trigger() { return &this->fan_mode_high_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_middle_trigger() { return &this->fan_mode_middle_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_focus_trigger() { return &this->fan_mode_focus_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_diffuse_trigger() { return &this->fan_mode_diffuse_trigger_; }
+Trigger<> *ThermostatClimate::get_fan_mode_quiet_trigger() { return &this->fan_mode_quiet_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_both_trigger() { return &this->swing_mode_both_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_off_trigger() { return &this->swing_mode_off_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_horizontal_trigger() { return &this->swing_mode_horizontal_trigger_; }
+Trigger<> *ThermostatClimate::get_swing_mode_vertical_trigger() { return &this->swing_mode_vertical_trigger_; }
+Trigger<> *ThermostatClimate::get_humidity_change_trigger() { return &this->humidity_change_trigger_; }
+Trigger<> *ThermostatClimate::get_temperature_change_trigger() { return &this->temperature_change_trigger_; }
+Trigger<> *ThermostatClimate::get_preset_change_trigger() { return &this->preset_change_trigger_; }
+Trigger<> *ThermostatClimate::get_humidity_control_dehumidify_action_trigger() {
+  return &this->humidity_control_dehumidify_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_humidity_control_humidify_action_trigger() const {
-  return this->humidity_control_humidify_action_trigger_;
+Trigger<> *ThermostatClimate::get_humidity_control_humidify_action_trigger() {
+  return &this->humidity_control_humidify_action_trigger_;
 }
-Trigger<> *ThermostatClimate::get_humidity_control_off_action_trigger() const {
-  return this->humidity_control_off_action_trigger_;
+Trigger<> *ThermostatClimate::get_humidity_control_off_action_trigger() {
+  return &this->humidity_control_off_action_trigger_;
 }
 
 void ThermostatClimate::dump_config() {
diff --git a/esphome/components/thermostat/thermostat_climate.h b/esphome/components/thermostat/thermostat_climate.h
index d37c9a68a64..4268d5c5822 100644
--- a/esphome/components/thermostat/thermostat_climate.h
+++ b/esphome/components/thermostat/thermostat_climate.h
@@ -146,40 +146,40 @@ class ThermostatClimate : public climate::Climate, public Component {
   void set_preset_config(std::initializer_list<PresetEntry> presets);
   void set_custom_preset_config(std::initializer_list<CustomPresetEntry> presets);
 
-  Trigger<> *get_cool_action_trigger() const;
-  Trigger<> *get_supplemental_cool_action_trigger() const;
-  Trigger<> *get_dry_action_trigger() const;
-  Trigger<> *get_fan_only_action_trigger() const;
-  Trigger<> *get_heat_action_trigger() const;
-  Trigger<> *get_supplemental_heat_action_trigger() const;
-  Trigger<> *get_idle_action_trigger() const;
-  Trigger<> *get_auto_mode_trigger() const;
-  Trigger<> *get_cool_mode_trigger() const;
-  Trigger<> *get_dry_mode_trigger() const;
-  Trigger<> *get_fan_only_mode_trigger() const;
-  Trigger<> *get_heat_mode_trigger() const;
-  Trigger<> *get_heat_cool_mode_trigger() const;
-  Trigger<> *get_off_mode_trigger() const;
-  Trigger<> *get_fan_mode_on_trigger() const;
-  Trigger<> *get_fan_mode_off_trigger() const;
-  Trigger<> *get_fan_mode_auto_trigger() const;
-  Trigger<> *get_fan_mode_low_trigger() const;
-  Trigger<> *get_fan_mode_medium_trigger() const;
-  Trigger<> *get_fan_mode_high_trigger() const;
-  Trigger<> *get_fan_mode_middle_trigger() const;
-  Trigger<> *get_fan_mode_focus_trigger() const;
-  Trigger<> *get_fan_mode_diffuse_trigger() const;
-  Trigger<> *get_fan_mode_quiet_trigger() const;
-  Trigger<> *get_swing_mode_both_trigger() const;
-  Trigger<> *get_swing_mode_horizontal_trigger() const;
-  Trigger<> *get_swing_mode_off_trigger() const;
-  Trigger<> *get_swing_mode_vertical_trigger() const;
-  Trigger<> *get_humidity_change_trigger() const;
-  Trigger<> *get_temperature_change_trigger() const;
-  Trigger<> *get_preset_change_trigger() const;
-  Trigger<> *get_humidity_control_dehumidify_action_trigger() const;
-  Trigger<> *get_humidity_control_humidify_action_trigger() const;
-  Trigger<> *get_humidity_control_off_action_trigger() const;
+  Trigger<> *get_cool_action_trigger();
+  Trigger<> *get_supplemental_cool_action_trigger();
+  Trigger<> *get_dry_action_trigger();
+  Trigger<> *get_fan_only_action_trigger();
+  Trigger<> *get_heat_action_trigger();
+  Trigger<> *get_supplemental_heat_action_trigger();
+  Trigger<> *get_idle_action_trigger();
+  Trigger<> *get_auto_mode_trigger();
+  Trigger<> *get_cool_mode_trigger();
+  Trigger<> *get_dry_mode_trigger();
+  Trigger<> *get_fan_only_mode_trigger();
+  Trigger<> *get_heat_mode_trigger();
+  Trigger<> *get_heat_cool_mode_trigger();
+  Trigger<> *get_off_mode_trigger();
+  Trigger<> *get_fan_mode_on_trigger();
+  Trigger<> *get_fan_mode_off_trigger();
+  Trigger<> *get_fan_mode_auto_trigger();
+  Trigger<> *get_fan_mode_low_trigger();
+  Trigger<> *get_fan_mode_medium_trigger();
+  Trigger<> *get_fan_mode_high_trigger();
+  Trigger<> *get_fan_mode_middle_trigger();
+  Trigger<> *get_fan_mode_focus_trigger();
+  Trigger<> *get_fan_mode_diffuse_trigger();
+  Trigger<> *get_fan_mode_quiet_trigger();
+  Trigger<> *get_swing_mode_both_trigger();
+  Trigger<> *get_swing_mode_horizontal_trigger();
+  Trigger<> *get_swing_mode_off_trigger();
+  Trigger<> *get_swing_mode_vertical_trigger();
+  Trigger<> *get_humidity_change_trigger();
+  Trigger<> *get_temperature_change_trigger();
+  Trigger<> *get_preset_change_trigger();
+  Trigger<> *get_humidity_control_dehumidify_action_trigger();
+  Trigger<> *get_humidity_control_humidify_action_trigger();
+  Trigger<> *get_humidity_control_off_action_trigger();
   /// Get current hysteresis values
   float cool_deadband();
   float cool_overrun();
@@ -417,115 +417,65 @@ class ThermostatClimate : public climate::Climate, public Component {
   /// The sensor used for getting the current humidity
   sensor::Sensor *humidity_sensor_{nullptr};
 
-  /// The trigger to call when the controller should switch to cooling action/mode.
-  ///
-  /// A null value for this attribute means that the controller has no cooling action
-  /// For example electric heat, where only heating (power on) and not-heating
-  /// (power off) is possible.
-  Trigger<> *cool_action_trigger_{nullptr};
-  Trigger<> *supplemental_cool_action_trigger_{nullptr};
-  Trigger<> *cool_mode_trigger_{nullptr};
+  /// Trigger for cooling action/mode
+  Trigger<> cool_action_trigger_;
+  Trigger<> supplemental_cool_action_trigger_;
+  Trigger<> cool_mode_trigger_;
 
-  /// The trigger to call when the controller should switch to dry (dehumidification) mode.
-  ///
-  /// In dry mode, the controller is assumed to have both heating and cooling disabled,
-  /// although the system may use its cooling mechanism to achieve drying.
-  Trigger<> *dry_action_trigger_{nullptr};
-  Trigger<> *dry_mode_trigger_{nullptr};
+  /// Trigger for dry (dehumidification) mode
+  Trigger<> dry_action_trigger_;
+  Trigger<> dry_mode_trigger_;
 
-  /// The trigger to call when the controller should switch to heating action/mode.
-  ///
-  /// A null value for this attribute means that the controller has no heating action
-  /// For example window blinds, where only cooling (blinds closed) and not-cooling
-  /// (blinds open) is possible.
-  Trigger<> *heat_action_trigger_{nullptr};
-  Trigger<> *supplemental_heat_action_trigger_{nullptr};
-  Trigger<> *heat_mode_trigger_{nullptr};
+  /// Trigger for heating action/mode
+  Trigger<> heat_action_trigger_;
+  Trigger<> supplemental_heat_action_trigger_;
+  Trigger<> heat_mode_trigger_;
 
-  /// The trigger to call when the controller should switch to heat/cool mode.
-  ///
-  /// In heat/cool mode, the controller will enable heating/cooling as necessary and switch
-  /// to idle when the temperature is within the thresholds/set points.
-  Trigger<> *heat_cool_mode_trigger_{nullptr};
+  /// Trigger for heat/cool mode
+  Trigger<> heat_cool_mode_trigger_;
 
-  /// The trigger to call when the controller should switch to auto mode.
-  ///
-  /// In auto mode, the controller will enable heating/cooling as supported/necessary and switch
-  /// to idle when the temperature is within the thresholds/set points.
-  Trigger<> *auto_mode_trigger_{nullptr};
+  /// Trigger for auto mode
+  Trigger<> auto_mode_trigger_;
 
-  /// The trigger to call when the controller should switch to idle action/off mode.
-  ///
-  /// In these actions/modes, the controller is assumed to have both heating and cooling disabled.
-  Trigger<> *idle_action_trigger_{nullptr};
-  Trigger<> *off_mode_trigger_{nullptr};
+  /// Trigger for idle action/off mode
+  Trigger<> idle_action_trigger_;
+  Trigger<> off_mode_trigger_;
 
-  /// The trigger to call when the controller should switch to fan-only action/mode.
-  ///
-  /// In fan-only mode, the controller is assumed to have both heating and cooling disabled.
-  /// The system should activate the fan only.
-  Trigger<> *fan_only_action_trigger_{nullptr};
-  Trigger<> *fan_only_mode_trigger_{nullptr};
+  /// Trigger for fan-only action/mode
+  Trigger<> fan_only_action_trigger_;
+  Trigger<> fan_only_mode_trigger_;
 
-  /// The trigger to call when the controller should switch on the fan.
-  Trigger<> *fan_mode_on_trigger_{nullptr};
+  /// Fan mode triggers
+  Trigger<> fan_mode_on_trigger_;
+  Trigger<> fan_mode_off_trigger_;
+  Trigger<> fan_mode_auto_trigger_;
+  Trigger<> fan_mode_low_trigger_;
+  Trigger<> fan_mode_medium_trigger_;
+  Trigger<> fan_mode_high_trigger_;
+  Trigger<> fan_mode_middle_trigger_;
+  Trigger<> fan_mode_focus_trigger_;
+  Trigger<> fan_mode_diffuse_trigger_;
+  Trigger<> fan_mode_quiet_trigger_;
 
-  /// The trigger to call when the controller should switch off the fan.
-  Trigger<> *fan_mode_off_trigger_{nullptr};
+  /// Swing mode triggers
+  Trigger<> swing_mode_both_trigger_;
+  Trigger<> swing_mode_off_trigger_;
+  Trigger<> swing_mode_horizontal_trigger_;
+  Trigger<> swing_mode_vertical_trigger_;
 
-  /// The trigger to call when the controller should switch the fan to "auto" mode.
-  Trigger<> *fan_mode_auto_trigger_{nullptr};
+  /// Trigger for target humidity changes
+  Trigger<> humidity_change_trigger_;
 
-  /// The trigger to call when the controller should switch the fan to "low" speed.
-  Trigger<> *fan_mode_low_trigger_{nullptr};
+  /// Trigger for target temperature changes
+  Trigger<> temperature_change_trigger_;
 
-  /// The trigger to call when the controller should switch the fan to "medium" speed.
-  Trigger<> *fan_mode_medium_trigger_{nullptr};
+  /// Trigger for preset mode changes
+  Trigger<> preset_change_trigger_;
 
-  /// The trigger to call when the controller should switch the fan to "high" speed.
-  Trigger<> *fan_mode_high_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the fan to "middle" position.
-  Trigger<> *fan_mode_middle_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the fan to "focus" position.
-  Trigger<> *fan_mode_focus_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the fan to "diffuse" position.
-  Trigger<> *fan_mode_diffuse_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the fan to "quiet" position.
-  Trigger<> *fan_mode_quiet_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the swing mode to "both".
-  Trigger<> *swing_mode_both_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the swing mode to "off".
-  Trigger<> *swing_mode_off_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the swing mode to "horizontal".
-  Trigger<> *swing_mode_horizontal_trigger_{nullptr};
-
-  /// The trigger to call when the controller should switch the swing mode to "vertical".
-  Trigger<> *swing_mode_vertical_trigger_{nullptr};
-
-  /// The trigger to call when the target humidity changes.
-  Trigger<> *humidity_change_trigger_{nullptr};
-
-  /// The trigger to call when the target temperature(s) change(es).
-  Trigger<> *temperature_change_trigger_{nullptr};
-
-  /// The trigger to call when the preset mode changes
-  Trigger<> *preset_change_trigger_{nullptr};
-
-  /// The trigger to call when dehumidification is required
-  Trigger<> *humidity_control_dehumidify_action_trigger_{nullptr};
-
-  /// The trigger to call when humidification is required
-  Trigger<> *humidity_control_humidify_action_trigger_{nullptr};
-
-  /// The trigger to call when (de)humidification should stop
-  Trigger<> *humidity_control_off_action_trigger_{nullptr};
+  /// Humidity control triggers
+  Trigger<> humidity_control_dehumidify_action_trigger_;
+  Trigger<> humidity_control_humidify_action_trigger_;
+  Trigger<> humidity_control_off_action_trigger_;
 
   /// A reference to the trigger that was previously active.
   ///
diff --git a/esphome/components/time/real_time_clock.h b/esphome/components/time/real_time_clock.h
index 70469e11b0d..19aa1a4f4a5 100644
--- a/esphome/components/time/real_time_clock.h
+++ b/esphome/components/time/real_time_clock.h
@@ -62,7 +62,7 @@ class RealTimeClock : public PollingComponent {
   void apply_timezone_();
 #endif
 
-  CallbackManager<void()> time_sync_callback_;
+  LazyCallbackManager<void()> time_sync_callback_;
 };
 
 template<typename... Ts> class TimeHasTimeCondition : public Condition<Ts...> {
diff --git a/esphome/components/time_based/time_based_cover.cpp b/esphome/components/time_based/time_based_cover.cpp
index 1eb591fe6e5..f6a3048bd48 100644
--- a/esphome/components/time_based/time_based_cover.cpp
+++ b/esphome/components/time_based/time_based_cover.cpp
@@ -51,7 +51,7 @@ void TimeBasedCover::loop() {
     this->last_publish_time_ = now;
   }
 }
-float TimeBasedCover::get_setup_priority() const { return setup_priority::DATA; }
+
 CoverTraits TimeBasedCover::get_traits() {
   auto traits = CoverTraits();
   traits.set_supports_stop(true);
@@ -132,15 +132,15 @@ void TimeBasedCover::start_direction_(CoverOperation dir) {
   Trigger<> *trig;
   switch (dir) {
     case COVER_OPERATION_IDLE:
-      trig = this->stop_trigger_;
+      trig = &this->stop_trigger_;
       break;
     case COVER_OPERATION_OPENING:
       this->last_operation_ = dir;
-      trig = this->open_trigger_;
+      trig = &this->open_trigger_;
       break;
     case COVER_OPERATION_CLOSING:
       this->last_operation_ = dir;
-      trig = this->close_trigger_;
+      trig = &this->close_trigger_;
       break;
     default:
       return;
diff --git a/esphome/components/time_based/time_based_cover.h b/esphome/components/time_based/time_based_cover.h
index 42cf66c2ab7..0adc5cb370d 100644
--- a/esphome/components/time_based/time_based_cover.h
+++ b/esphome/components/time_based/time_based_cover.h
@@ -12,11 +12,10 @@ class TimeBasedCover : public cover::Cover, public Component {
   void setup() override;
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
-  Trigger<> *get_open_trigger() const { return this->open_trigger_; }
-  Trigger<> *get_close_trigger() const { return this->close_trigger_; }
-  Trigger<> *get_stop_trigger() const { return this->stop_trigger_; }
+  Trigger<> *get_open_trigger() { return &this->open_trigger_; }
+  Trigger<> *get_close_trigger() { return &this->close_trigger_; }
+  Trigger<> *get_stop_trigger() { return &this->stop_trigger_; }
   void set_open_duration(uint32_t open_duration) { this->open_duration_ = open_duration; }
   void set_close_duration(uint32_t close_duration) { this->close_duration_ = close_duration; }
   cover::CoverTraits get_traits() override;
@@ -34,11 +33,11 @@ class TimeBasedCover : public cover::Cover, public Component {
 
   void recompute_position_();
 
-  Trigger<> *open_trigger_{new Trigger<>()};
+  Trigger<> open_trigger_;
   uint32_t open_duration_;
-  Trigger<> *close_trigger_{new Trigger<>()};
+  Trigger<> close_trigger_;
   uint32_t close_duration_;
-  Trigger<> *stop_trigger_{new Trigger<>()};
+  Trigger<> stop_trigger_;
 
   Trigger<> *prev_command_trigger_{nullptr};
   uint32_t last_recompute_time_{0};
diff --git a/esphome/components/tmp102/tmp102.cpp b/esphome/components/tmp102/tmp102.cpp
index 7390d9fcc9c..99f6753ddcc 100644
--- a/esphome/components/tmp102/tmp102.cpp
+++ b/esphome/components/tmp102/tmp102.cpp
@@ -46,7 +46,5 @@ void TMP102Component::update() {
   });
 }
 
-float TMP102Component::get_setup_priority() const { return setup_priority::DATA; }
-
 }  // namespace tmp102
 }  // namespace esphome
diff --git a/esphome/components/tmp102/tmp102.h b/esphome/components/tmp102/tmp102.h
index 657b48c7cff..fe860a38191 100644
--- a/esphome/components/tmp102/tmp102.h
+++ b/esphome/components/tmp102/tmp102.h
@@ -11,8 +11,6 @@ class TMP102Component : public PollingComponent, public i2c::I2CDevice, public s
  public:
   void dump_config() override;
   void update() override;
-
-  float get_setup_priority() const override;
 };
 
 }  // namespace tmp102
diff --git a/esphome/components/tmp117/tmp117.cpp b/esphome/components/tmp117/tmp117.cpp
index c9eff413991..f8f52266e06 100644
--- a/esphome/components/tmp117/tmp117.cpp
+++ b/esphome/components/tmp117/tmp117.cpp
@@ -45,7 +45,7 @@ void TMP117Component::dump_config() {
   }
   LOG_SENSOR("  ", "Temperature", this);
 }
-float TMP117Component::get_setup_priority() const { return setup_priority::DATA; }
+
 bool TMP117Component::read_data_(int16_t *data) {
   if (!this->read_byte_16(0, (uint16_t *) data)) {
     ESP_LOGW(TAG, "Updating TMP117 failed!");
diff --git a/esphome/components/tmp117/tmp117.h b/esphome/components/tmp117/tmp117.h
index 162dbb64dbc..f501ee270c3 100644
--- a/esphome/components/tmp117/tmp117.h
+++ b/esphome/components/tmp117/tmp117.h
@@ -11,7 +11,6 @@ class TMP117Component : public PollingComponent, public i2c::I2CDevice, public s
  public:
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void update() override;
   void set_config(uint16_t config) { config_ = config; };
 
diff --git a/esphome/components/tsl2561/tsl2561.cpp b/esphome/components/tsl2561/tsl2561.cpp
index 1442dd176c6..cb4c38a83ce 100644
--- a/esphome/components/tsl2561/tsl2561.cpp
+++ b/esphome/components/tsl2561/tsl2561.cpp
@@ -144,7 +144,7 @@ void TSL2561Sensor::set_integration_time(TSL2561IntegrationTime integration_time
 }
 void TSL2561Sensor::set_gain(TSL2561Gain gain) { this->gain_ = gain; }
 void TSL2561Sensor::set_is_cs_package(bool package_cs) { this->package_cs_ = package_cs; }
-float TSL2561Sensor::get_setup_priority() const { return setup_priority::DATA; }
+
 bool TSL2561Sensor::tsl2561_write_byte(uint8_t a_register, uint8_t value) {
   return this->write_byte(a_register | TSL2561_COMMAND_BIT, value);
 }
diff --git a/esphome/components/tsl2561/tsl2561.h b/esphome/components/tsl2561/tsl2561.h
index c54f41fb81f..a8f0aef90f9 100644
--- a/esphome/components/tsl2561/tsl2561.h
+++ b/esphome/components/tsl2561/tsl2561.h
@@ -67,7 +67,6 @@ class TSL2561Sensor : public sensor::Sensor, public PollingComponent, public i2c
   void setup() override;
   void dump_config() override;
   void update() override;
-  float get_setup_priority() const override;
 
   bool tsl2561_read_byte(uint8_t a_register, uint8_t *value);
   bool tsl2561_read_uint(uint8_t a_register, uint16_t *value);
diff --git a/esphome/components/tsl2591/tsl2591.cpp b/esphome/components/tsl2591/tsl2591.cpp
index 999e42e949e..42c524a0741 100644
--- a/esphome/components/tsl2591/tsl2591.cpp
+++ b/esphome/components/tsl2591/tsl2591.cpp
@@ -247,8 +247,6 @@ void TSL2591Component::set_power_save_mode(bool enable) { this->power_save_mode_
 
 void TSL2591Component::set_name(const char *name) { this->name_ = name; }
 
-float TSL2591Component::get_setup_priority() const { return setup_priority::DATA; }
-
 bool TSL2591Component::is_adc_valid() {
   uint8_t status;
   if (!this->read_byte(TSL2591_COMMAND_BIT | TSL2591_REGISTER_STATUS, &status)) {
diff --git a/esphome/components/tsl2591/tsl2591.h b/esphome/components/tsl2591/tsl2591.h
index fa302b14b0f..84c92b6ba98 100644
--- a/esphome/components/tsl2591/tsl2591.h
+++ b/esphome/components/tsl2591/tsl2591.h
@@ -249,8 +249,6 @@ class TSL2591Component : public PollingComponent, public i2c::I2CDevice {
   void dump_config() override;
   /** Used by ESPHome framework. */
   void update() override;
-  /** Used by ESPHome framework. */
-  float get_setup_priority() const override;
 
  protected:
   const char *name_;
diff --git a/esphome/components/tx20/tx20.cpp b/esphome/components/tx20/tx20.cpp
index a6df61c053e..6bc5f0bb514 100644
--- a/esphome/components/tx20/tx20.cpp
+++ b/esphome/components/tx20/tx20.cpp
@@ -38,8 +38,6 @@ void Tx20Component::loop() {
   }
 }
 
-float Tx20Component::get_setup_priority() const { return setup_priority::DATA; }
-
 std::string Tx20Component::get_wind_cardinal_direction() const { return this->wind_cardinal_direction_; }
 
 void Tx20Component::decode_and_publish_() {
diff --git a/esphome/components/tx20/tx20.h b/esphome/components/tx20/tx20.h
index 95a95172276..d1673f99f2b 100644
--- a/esphome/components/tx20/tx20.h
+++ b/esphome/components/tx20/tx20.h
@@ -35,7 +35,6 @@ class Tx20Component : public Component {
 
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
   void loop() override;
 
  protected:
diff --git a/esphome/components/ultrasonic/__init__.py b/esphome/components/ultrasonic/__init__.py
index 71a87b6ae50..3bca12bffcb 100644
--- a/esphome/components/ultrasonic/__init__.py
+++ b/esphome/components/ultrasonic/__init__.py
@@ -1 +1 @@
-CODEOWNERS = ["@OttoWinter"]
+CODEOWNERS = ["@swoboda1337", "@ssieb"]
diff --git a/esphome/components/ultrasonic/sensor.py b/esphome/components/ultrasonic/sensor.py
index 4b04ee7578e..fad4e6b11dc 100644
--- a/esphome/components/ultrasonic/sensor.py
+++ b/esphome/components/ultrasonic/sensor.py
@@ -34,7 +34,7 @@ CONFIG_SCHEMA = (
         {
             cv.Required(CONF_TRIGGER_PIN): pins.internal_gpio_output_pin_schema,
             cv.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema,
-            cv.Optional(CONF_TIMEOUT): cv.distance,
+            cv.Optional(CONF_TIMEOUT, default="2m"): cv.distance,
             cv.Optional(
                 CONF_PULSE_TIME, default="10us"
             ): cv.positive_time_period_microseconds,
@@ -52,12 +52,5 @@ async def to_code(config):
     cg.add(var.set_trigger_pin(trigger))
     echo = await cg.gpio_pin_expression(config[CONF_ECHO_PIN])
     cg.add(var.set_echo_pin(echo))
-
-    # Remove before 2026.8.0
-    if CONF_TIMEOUT in config:
-        _LOGGER.warning(
-            "'timeout' option is deprecated and will be removed in 2026.8.0. "
-            "The option has no effect and can be safely removed."
-        )
-
+    cg.add(var.set_timeout_us(config[CONF_TIMEOUT] / (0.000343 / 2)))
     cg.add(var.set_pulse_time_us(config[CONF_PULSE_TIME]))
diff --git a/esphome/components/ultrasonic/ultrasonic_sensor.cpp b/esphome/components/ultrasonic/ultrasonic_sensor.cpp
index 369a10edbda..d3f7e694440 100644
--- a/esphome/components/ultrasonic/ultrasonic_sensor.cpp
+++ b/esphome/components/ultrasonic/ultrasonic_sensor.cpp
@@ -6,12 +6,11 @@ namespace esphome::ultrasonic {
 
 static const char *const TAG = "ultrasonic.sensor";
 
-static constexpr uint32_t DEBOUNCE_US = 50;                // Ignore edges within 50us (noise filtering)
-static constexpr uint32_t MEASUREMENT_TIMEOUT_US = 80000;  // Maximum time to wait for measurement completion
+static constexpr uint32_t START_TIMEOUT_US = 40000;  // Maximum time to wait for echo pulse to start
 
 void IRAM_ATTR UltrasonicSensorStore::gpio_intr(UltrasonicSensorStore *arg) {
   uint32_t now = micros();
-  if (!arg->echo_start || (now - arg->echo_start_us) <= DEBOUNCE_US) {
+  if (arg->echo_pin_isr.digital_read()) {
     arg->echo_start_us = now;
     arg->echo_start = true;
   } else {
@@ -38,6 +37,7 @@ void UltrasonicSensorComponent::setup() {
   this->trigger_pin_->digital_write(false);
   this->trigger_pin_isr_ = this->trigger_pin_->to_isr();
   this->echo_pin_->setup();
+  this->store_.echo_pin_isr = this->echo_pin_->to_isr();
   this->echo_pin_->attach_interrupt(UltrasonicSensorStore::gpio_intr, &this->store_, gpio::INTERRUPT_ANY_EDGE);
 }
 
@@ -53,29 +53,55 @@ void UltrasonicSensorComponent::loop() {
     return;
   }
 
+  if (!this->store_.echo_start) {
+    uint32_t elapsed = micros() - this->measurement_start_us_;
+    if (elapsed >= START_TIMEOUT_US) {
+      ESP_LOGW(TAG, "'%s' - Measurement start timed out", this->name_.c_str());
+      this->publish_state(NAN);
+      this->measurement_pending_ = false;
+      return;
+    }
+  } else {
+    uint32_t elapsed;
+    if (this->store_.echo_end) {
+      elapsed = this->store_.echo_end_us - this->store_.echo_start_us;
+    } else {
+      elapsed = micros() - this->store_.echo_start_us;
+    }
+    if (elapsed >= this->timeout_us_) {
+      ESP_LOGD(TAG, "'%s' - Measurement pulse timed out after %" PRIu32 "us", this->name_.c_str(), elapsed);
+      this->publish_state(NAN);
+      this->measurement_pending_ = false;
+      return;
+    }
+  }
+
   if (this->store_.echo_end) {
-    uint32_t pulse_duration = this->store_.echo_end_us - this->store_.echo_start_us;
-    ESP_LOGV(TAG, "Echo took %" PRIu32 "us", pulse_duration);
-    float result = UltrasonicSensorComponent::us_to_m(pulse_duration);
-    ESP_LOGD(TAG, "'%s' - Got distance: %.3f m", this->name_.c_str(), result);
+    float result;
+    if (this->store_.echo_start) {
+      uint32_t pulse_duration = this->store_.echo_end_us - this->store_.echo_start_us;
+      ESP_LOGV(TAG, "pulse start took %" PRIu32 "us, echo took %" PRIu32 "us",
+               this->store_.echo_start_us - this->measurement_start_us_, pulse_duration);
+      result = UltrasonicSensorComponent::us_to_m(pulse_duration);
+      ESP_LOGD(TAG, "'%s' - Got distance: %.3f m", this->name_.c_str(), result);
+    } else {
+      ESP_LOGW(TAG, "'%s' - pulse end before pulse start, does the echo pin need to be inverted?", this->name_.c_str());
+      result = NAN;
+    }
     this->publish_state(result);
     this->measurement_pending_ = false;
     return;
   }
-
-  uint32_t elapsed = micros() - this->measurement_start_us_;
-  if (elapsed >= MEASUREMENT_TIMEOUT_US) {
-    ESP_LOGD(TAG, "'%s' - Measurement timed out after %" PRIu32 "us", this->name_.c_str(), elapsed);
-    this->publish_state(NAN);
-    this->measurement_pending_ = false;
-  }
 }
 
 void UltrasonicSensorComponent::dump_config() {
   LOG_SENSOR("", "Ultrasonic Sensor", this);
   LOG_PIN("  Echo Pin: ", this->echo_pin_);
   LOG_PIN("  Trigger Pin: ", this->trigger_pin_);
-  ESP_LOGCONFIG(TAG, "  Pulse time: %" PRIu32 " us", this->pulse_time_us_);
+  ESP_LOGCONFIG(TAG,
+                "  Pulse time: %" PRIu32 " µs\n"
+                "  Timeout: %" PRIu32 " µs",
+                this->pulse_time_us_, this->timeout_us_);
   LOG_UPDATE_INTERVAL(this);
 }
 
diff --git a/esphome/components/ultrasonic/ultrasonic_sensor.h b/esphome/components/ultrasonic/ultrasonic_sensor.h
index b0c00e51f07..541f7d2b700 100644
--- a/esphome/components/ultrasonic/ultrasonic_sensor.h
+++ b/esphome/components/ultrasonic/ultrasonic_sensor.h
@@ -11,6 +11,8 @@ namespace esphome::ultrasonic {
 struct UltrasonicSensorStore {
   static void gpio_intr(UltrasonicSensorStore *arg);
 
+  ISRInternalGPIOPin echo_pin_isr;
+  volatile uint32_t wait_start_us{0};
   volatile uint32_t echo_start_us{0};
   volatile uint32_t echo_end_us{0};
   volatile bool echo_start{false};
@@ -27,8 +29,8 @@ class UltrasonicSensorComponent : public sensor::Sensor, public PollingComponent
   void dump_config() override;
   void update() override;
 
-  float get_setup_priority() const override { return setup_priority::DATA; }
-
+  /// Set the maximum time in µs to wait for the echo to return
+  void set_timeout_us(uint32_t timeout_us) { this->timeout_us_ = timeout_us; }
   /// Set the time in µs the trigger pin should be enabled for in µs, defaults to 10µs (for HC-SR04)
   void set_pulse_time_us(uint32_t pulse_time_us) { this->pulse_time_us_ = pulse_time_us; }
 
@@ -41,6 +43,7 @@ class UltrasonicSensorComponent : public sensor::Sensor, public PollingComponent
   ISRInternalGPIOPin trigger_pin_isr_;
   InternalGPIOPin *echo_pin_;
   UltrasonicSensorStore store_;
+  uint32_t timeout_us_{};
   uint32_t pulse_time_us_{};
 
   uint32_t measurement_start_us_{0};
diff --git a/esphome/components/vbus/__init__.py b/esphome/components/vbus/__init__.py
index d916d7c0648..5790a9cce05 100644
--- a/esphome/components/vbus/__init__.py
+++ b/esphome/components/vbus/__init__.py
@@ -16,6 +16,7 @@ CONF_VBUS_ID = "vbus_id"
 
 CONF_DELTASOL_BS_PLUS = "deltasol_bs_plus"
 CONF_DELTASOL_BS_2009 = "deltasol_bs_2009"
+CONF_DELTASOL_BS2 = "deltasol_bs2"
 CONF_DELTASOL_C = "deltasol_c"
 CONF_DELTASOL_CS2 = "deltasol_cs2"
 CONF_DELTASOL_CS_PLUS = "deltasol_cs_plus"
diff --git a/esphome/components/vbus/binary_sensor/__init__.py b/esphome/components/vbus/binary_sensor/__init__.py
index ae927656c08..70dda943007 100644
--- a/esphome/components/vbus/binary_sensor/__init__.py
+++ b/esphome/components/vbus/binary_sensor/__init__.py
@@ -15,6 +15,7 @@ from esphome.const import (
 )
 
 from .. import (
+    CONF_DELTASOL_BS2,
     CONF_DELTASOL_BS_2009,
     CONF_DELTASOL_BS_PLUS,
     CONF_DELTASOL_C,
@@ -27,6 +28,7 @@ from .. import (
 
 DeltaSol_BS_Plus = vbus_ns.class_("DeltaSolBSPlusBSensor", cg.Component)
 DeltaSol_BS_2009 = vbus_ns.class_("DeltaSolBS2009BSensor", cg.Component)
+DeltaSol_BS2 = vbus_ns.class_("DeltaSolBS2BSensor", cg.Component)
 DeltaSol_C = vbus_ns.class_("DeltaSolCBSensor", cg.Component)
 DeltaSol_CS2 = vbus_ns.class_("DeltaSolCS2BSensor", cg.Component)
 DeltaSol_CS_Plus = vbus_ns.class_("DeltaSolCSPlusBSensor", cg.Component)
@@ -118,6 +120,28 @@ CONFIG_SCHEMA = cv.typed_schema(
                 ),
             }
         ),
+        CONF_DELTASOL_BS2: cv.COMPONENT_SCHEMA.extend(
+            {
+                cv.GenerateID(): cv.declare_id(DeltaSol_BS2),
+                cv.GenerateID(CONF_VBUS_ID): cv.use_id(VBus),
+                cv.Optional(CONF_SENSOR1_ERROR): binary_sensor.binary_sensor_schema(
+                    device_class=DEVICE_CLASS_PROBLEM,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                ),
+                cv.Optional(CONF_SENSOR2_ERROR): binary_sensor.binary_sensor_schema(
+                    device_class=DEVICE_CLASS_PROBLEM,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                ),
+                cv.Optional(CONF_SENSOR3_ERROR): binary_sensor.binary_sensor_schema(
+                    device_class=DEVICE_CLASS_PROBLEM,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                ),
+                cv.Optional(CONF_SENSOR4_ERROR): binary_sensor.binary_sensor_schema(
+                    device_class=DEVICE_CLASS_PROBLEM,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                ),
+            }
+        ),
         CONF_DELTASOL_C: cv.COMPONENT_SCHEMA.extend(
             {
                 cv.GenerateID(): cv.declare_id(DeltaSol_C),
@@ -275,6 +299,23 @@ async def to_code(config):
             )
             cg.add(var.set_frost_protection_active_bsensor(sens))
 
+    elif config[CONF_MODEL] == CONF_DELTASOL_BS2:
+        cg.add(var.set_command(0x0100))
+        cg.add(var.set_source(0x4278))
+        cg.add(var.set_dest(0x0010))
+        if CONF_SENSOR1_ERROR in config:
+            sens = await binary_sensor.new_binary_sensor(config[CONF_SENSOR1_ERROR])
+            cg.add(var.set_s1_error_bsensor(sens))
+        if CONF_SENSOR2_ERROR in config:
+            sens = await binary_sensor.new_binary_sensor(config[CONF_SENSOR2_ERROR])
+            cg.add(var.set_s2_error_bsensor(sens))
+        if CONF_SENSOR3_ERROR in config:
+            sens = await binary_sensor.new_binary_sensor(config[CONF_SENSOR3_ERROR])
+            cg.add(var.set_s3_error_bsensor(sens))
+        if CONF_SENSOR4_ERROR in config:
+            sens = await binary_sensor.new_binary_sensor(config[CONF_SENSOR4_ERROR])
+            cg.add(var.set_s4_error_bsensor(sens))
+
     elif config[CONF_MODEL] == CONF_DELTASOL_C:
         cg.add(var.set_command(0x0100))
         cg.add(var.set_source(0x4212))
diff --git a/esphome/components/vbus/binary_sensor/vbus_binary_sensor.cpp b/esphome/components/vbus/binary_sensor/vbus_binary_sensor.cpp
index 4ccd1499357..c1d7bc1b18d 100644
--- a/esphome/components/vbus/binary_sensor/vbus_binary_sensor.cpp
+++ b/esphome/components/vbus/binary_sensor/vbus_binary_sensor.cpp
@@ -129,6 +129,25 @@ void DeltaSolCSPlusBSensor::handle_message(std::vector<uint8_t> &message) {
     this->s4_error_bsensor_->publish_state(message[20] & 8);
 }
 
+void DeltaSolBS2BSensor::dump_config() {
+  ESP_LOGCONFIG(TAG, "DeltaSol BS/2 (DrainBack):");
+  LOG_BINARY_SENSOR("  ", "Sensor 1 Error", this->s1_error_bsensor_);
+  LOG_BINARY_SENSOR("  ", "Sensor 2 Error", this->s2_error_bsensor_);
+  LOG_BINARY_SENSOR("  ", "Sensor 3 Error", this->s3_error_bsensor_);
+  LOG_BINARY_SENSOR("  ", "Sensor 4 Error", this->s4_error_bsensor_);
+}
+
+void DeltaSolBS2BSensor::handle_message(std::vector<uint8_t> &message) {
+  if (this->s1_error_bsensor_ != nullptr)
+    this->s1_error_bsensor_->publish_state(message[10] & 1);
+  if (this->s2_error_bsensor_ != nullptr)
+    this->s2_error_bsensor_->publish_state(message[10] & 2);
+  if (this->s3_error_bsensor_ != nullptr)
+    this->s3_error_bsensor_->publish_state(message[10] & 4);
+  if (this->s4_error_bsensor_ != nullptr)
+    this->s4_error_bsensor_->publish_state(message[10] & 8);
+}
+
 void VBusCustomBSensor::dump_config() {
   ESP_LOGCONFIG(TAG, "VBus Custom Binary Sensor:");
   if (this->source_ == 0xffff) {
diff --git a/esphome/components/vbus/binary_sensor/vbus_binary_sensor.h b/esphome/components/vbus/binary_sensor/vbus_binary_sensor.h
index 146aa1b673a..2decdde602a 100644
--- a/esphome/components/vbus/binary_sensor/vbus_binary_sensor.h
+++ b/esphome/components/vbus/binary_sensor/vbus_binary_sensor.h
@@ -111,6 +111,23 @@ class DeltaSolCSPlusBSensor : public VBusListener, public Component {
   void handle_message(std::vector<uint8_t> &message) override;
 };
 
+class DeltaSolBS2BSensor : public VBusListener, public Component {
+ public:
+  void dump_config() override;
+  void set_s1_error_bsensor(binary_sensor::BinarySensor *bsensor) { this->s1_error_bsensor_ = bsensor; }
+  void set_s2_error_bsensor(binary_sensor::BinarySensor *bsensor) { this->s2_error_bsensor_ = bsensor; }
+  void set_s3_error_bsensor(binary_sensor::BinarySensor *bsensor) { this->s3_error_bsensor_ = bsensor; }
+  void set_s4_error_bsensor(binary_sensor::BinarySensor *bsensor) { this->s4_error_bsensor_ = bsensor; }
+
+ protected:
+  binary_sensor::BinarySensor *s1_error_bsensor_{nullptr};
+  binary_sensor::BinarySensor *s2_error_bsensor_{nullptr};
+  binary_sensor::BinarySensor *s3_error_bsensor_{nullptr};
+  binary_sensor::BinarySensor *s4_error_bsensor_{nullptr};
+
+  void handle_message(std::vector<uint8_t> &message) override;
+};
+
 class VBusCustomSubBSensor;
 
 class VBusCustomBSensor : public VBusListener, public Component {
diff --git a/esphome/components/vbus/sensor/__init__.py b/esphome/components/vbus/sensor/__init__.py
index fcff698ac04..ff8ef98a1aa 100644
--- a/esphome/components/vbus/sensor/__init__.py
+++ b/esphome/components/vbus/sensor/__init__.py
@@ -31,6 +31,7 @@ from esphome.const import (
 )
 
 from .. import (
+    CONF_DELTASOL_BS2,
     CONF_DELTASOL_BS_2009,
     CONF_DELTASOL_BS_PLUS,
     CONF_DELTASOL_C,
@@ -43,6 +44,7 @@ from .. import (
 
 DeltaSol_BS_Plus = vbus_ns.class_("DeltaSolBSPlusSensor", cg.Component)
 DeltaSol_BS_2009 = vbus_ns.class_("DeltaSolBS2009Sensor", cg.Component)
+DeltaSol_BS2 = vbus_ns.class_("DeltaSolBS2Sensor", cg.Component)
 DeltaSol_C = vbus_ns.class_("DeltaSolCSensor", cg.Component)
 DeltaSol_CS2 = vbus_ns.class_("DeltaSolCS2Sensor", cg.Component)
 DeltaSol_CS_Plus = vbus_ns.class_("DeltaSolCSPlusSensor", cg.Component)
@@ -227,6 +229,79 @@ CONFIG_SCHEMA = cv.typed_schema(
                 ),
             }
         ),
+        CONF_DELTASOL_BS2: cv.COMPONENT_SCHEMA.extend(
+            {
+                cv.GenerateID(): cv.declare_id(DeltaSol_BS2),
+                cv.GenerateID(CONF_VBUS_ID): cv.use_id(VBus),
+                cv.Optional(CONF_TEMPERATURE_1): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_CELSIUS,
+                    icon=ICON_THERMOMETER,
+                    accuracy_decimals=1,
+                    device_class=DEVICE_CLASS_TEMPERATURE,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_TEMPERATURE_2): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_CELSIUS,
+                    icon=ICON_THERMOMETER,
+                    accuracy_decimals=1,
+                    device_class=DEVICE_CLASS_TEMPERATURE,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_TEMPERATURE_3): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_CELSIUS,
+                    icon=ICON_THERMOMETER,
+                    accuracy_decimals=1,
+                    device_class=DEVICE_CLASS_TEMPERATURE,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_TEMPERATURE_4): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_CELSIUS,
+                    icon=ICON_THERMOMETER,
+                    accuracy_decimals=1,
+                    device_class=DEVICE_CLASS_TEMPERATURE,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_PUMP_SPEED_1): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_PERCENT,
+                    icon=ICON_PERCENT,
+                    accuracy_decimals=0,
+                    device_class=DEVICE_CLASS_EMPTY,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_PUMP_SPEED_2): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_PERCENT,
+                    icon=ICON_PERCENT,
+                    accuracy_decimals=0,
+                    device_class=DEVICE_CLASS_EMPTY,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_OPERATING_HOURS_1): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_HOUR,
+                    icon=ICON_TIMER,
+                    accuracy_decimals=0,
+                    device_class=DEVICE_CLASS_DURATION,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_OPERATING_HOURS_2): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_HOUR,
+                    icon=ICON_TIMER,
+                    accuracy_decimals=0,
+                    device_class=DEVICE_CLASS_DURATION,
+                    state_class=STATE_CLASS_MEASUREMENT,
+                ),
+                cv.Optional(CONF_HEAT_QUANTITY): sensor.sensor_schema(
+                    unit_of_measurement=UNIT_WATT_HOURS,
+                    icon=ICON_RADIATOR,
+                    accuracy_decimals=0,
+                    device_class=DEVICE_CLASS_ENERGY,
+                    state_class=STATE_CLASS_TOTAL_INCREASING,
+                ),
+                cv.Optional(CONF_VERSION): sensor.sensor_schema(
+                    accuracy_decimals=2,
+                    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+                ),
+            }
+        ),
         CONF_DELTASOL_C: cv.COMPONENT_SCHEMA.extend(
             {
                 cv.GenerateID(): cv.declare_id(DeltaSol_C),
@@ -560,6 +635,41 @@ async def to_code(config):
             sens = await sensor.new_sensor(config[CONF_VERSION])
             cg.add(var.set_version_sensor(sens))
 
+    elif config[CONF_MODEL] == CONF_DELTASOL_BS2:
+        cg.add(var.set_command(0x0100))
+        cg.add(var.set_source(0x4278))
+        cg.add(var.set_dest(0x0010))
+        if CONF_TEMPERATURE_1 in config:
+            sens = await sensor.new_sensor(config[CONF_TEMPERATURE_1])
+            cg.add(var.set_temperature1_sensor(sens))
+        if CONF_TEMPERATURE_2 in config:
+            sens = await sensor.new_sensor(config[CONF_TEMPERATURE_2])
+            cg.add(var.set_temperature2_sensor(sens))
+        if CONF_TEMPERATURE_3 in config:
+            sens = await sensor.new_sensor(config[CONF_TEMPERATURE_3])
+            cg.add(var.set_temperature3_sensor(sens))
+        if CONF_TEMPERATURE_4 in config:
+            sens = await sensor.new_sensor(config[CONF_TEMPERATURE_4])
+            cg.add(var.set_temperature4_sensor(sens))
+        if CONF_PUMP_SPEED_1 in config:
+            sens = await sensor.new_sensor(config[CONF_PUMP_SPEED_1])
+            cg.add(var.set_pump_speed1_sensor(sens))
+        if CONF_PUMP_SPEED_2 in config:
+            sens = await sensor.new_sensor(config[CONF_PUMP_SPEED_2])
+            cg.add(var.set_pump_speed2_sensor(sens))
+        if CONF_OPERATING_HOURS_1 in config:
+            sens = await sensor.new_sensor(config[CONF_OPERATING_HOURS_1])
+            cg.add(var.set_operating_hours1_sensor(sens))
+        if CONF_OPERATING_HOURS_2 in config:
+            sens = await sensor.new_sensor(config[CONF_OPERATING_HOURS_2])
+            cg.add(var.set_operating_hours2_sensor(sens))
+        if CONF_HEAT_QUANTITY in config:
+            sens = await sensor.new_sensor(config[CONF_HEAT_QUANTITY])
+            cg.add(var.set_heat_quantity_sensor(sens))
+        if CONF_VERSION in config:
+            sens = await sensor.new_sensor(config[CONF_VERSION])
+            cg.add(var.set_version_sensor(sens))
+
     elif config[CONF_MODEL] == CONF_DELTASOL_C:
         cg.add(var.set_command(0x0100))
         cg.add(var.set_source(0x4212))
diff --git a/esphome/components/vbus/sensor/vbus_sensor.cpp b/esphome/components/vbus/sensor/vbus_sensor.cpp
index e81c0486d4b..75c9ea1aeed 100644
--- a/esphome/components/vbus/sensor/vbus_sensor.cpp
+++ b/esphome/components/vbus/sensor/vbus_sensor.cpp
@@ -214,6 +214,45 @@ void DeltaSolCSPlusSensor::handle_message(std::vector<uint8_t> &message) {
     this->flow_rate_sensor_->publish_state(get_u16(message, 38));
 }
 
+void DeltaSolBS2Sensor::dump_config() {
+  ESP_LOGCONFIG(TAG, "DeltaSol BS/2 (DrainBack):");
+  LOG_SENSOR("  ", "Temperature 1", this->temperature1_sensor_);
+  LOG_SENSOR("  ", "Temperature 2", this->temperature2_sensor_);
+  LOG_SENSOR("  ", "Temperature 3", this->temperature3_sensor_);
+  LOG_SENSOR("  ", "Temperature 4", this->temperature4_sensor_);
+  LOG_SENSOR("  ", "Pump Speed 1", this->pump_speed1_sensor_);
+  LOG_SENSOR("  ", "Pump Speed 2", this->pump_speed2_sensor_);
+  LOG_SENSOR("  ", "Operating Hours 1", this->operating_hours1_sensor_);
+  LOG_SENSOR("  ", "Operating Hours 2", this->operating_hours2_sensor_);
+  LOG_SENSOR("  ", "Heat Quantity", this->heat_quantity_sensor_);
+  LOG_SENSOR("  ", "FW Version", this->version_sensor_);
+}
+
+void DeltaSolBS2Sensor::handle_message(std::vector<uint8_t> &message) {
+  if (this->temperature1_sensor_ != nullptr)
+    this->temperature1_sensor_->publish_state(get_i16(message, 0) * 0.1f);
+  if (this->temperature2_sensor_ != nullptr)
+    this->temperature2_sensor_->publish_state(get_i16(message, 2) * 0.1f);
+  if (this->temperature3_sensor_ != nullptr)
+    this->temperature3_sensor_->publish_state(get_i16(message, 4) * 0.1f);
+  if (this->temperature4_sensor_ != nullptr)
+    this->temperature4_sensor_->publish_state(get_i16(message, 6) * 0.1f);
+  if (this->pump_speed1_sensor_ != nullptr)
+    this->pump_speed1_sensor_->publish_state(message[8]);
+  if (this->pump_speed2_sensor_ != nullptr)
+    this->pump_speed2_sensor_->publish_state(message[9]);
+  if (this->operating_hours1_sensor_ != nullptr)
+    this->operating_hours1_sensor_->publish_state(get_u16(message, 12));
+  if (this->operating_hours2_sensor_ != nullptr)
+    this->operating_hours2_sensor_->publish_state(get_u16(message, 14));
+  if (this->heat_quantity_sensor_ != nullptr) {
+    float heat_wh = get_u16(message, 16) + get_u16(message, 18) * 1000.0f + get_u16(message, 20) * 1000000.0f;
+    this->heat_quantity_sensor_->publish_state(heat_wh);
+  }
+  if (this->version_sensor_ != nullptr)
+    this->version_sensor_->publish_state(get_u16(message, 24) * 0.01f);
+}
+
 void VBusCustomSensor::dump_config() {
   ESP_LOGCONFIG(TAG, "VBus Custom Sensor:");
   if (this->source_ == 0xffff) {
diff --git a/esphome/components/vbus/sensor/vbus_sensor.h b/esphome/components/vbus/sensor/vbus_sensor.h
index d5535b20195..cea2ee1c862 100644
--- a/esphome/components/vbus/sensor/vbus_sensor.h
+++ b/esphome/components/vbus/sensor/vbus_sensor.h
@@ -157,6 +157,36 @@ class DeltaSolCSPlusSensor : public VBusListener, public Component {
   void handle_message(std::vector<uint8_t> &message) override;
 };
 
+class DeltaSolBS2Sensor : public VBusListener, public Component {
+ public:
+  void dump_config() override;
+
+  void set_temperature1_sensor(sensor::Sensor *sensor) { this->temperature1_sensor_ = sensor; }
+  void set_temperature2_sensor(sensor::Sensor *sensor) { this->temperature2_sensor_ = sensor; }
+  void set_temperature3_sensor(sensor::Sensor *sensor) { this->temperature3_sensor_ = sensor; }
+  void set_temperature4_sensor(sensor::Sensor *sensor) { this->temperature4_sensor_ = sensor; }
+  void set_pump_speed1_sensor(sensor::Sensor *sensor) { this->pump_speed1_sensor_ = sensor; }
+  void set_pump_speed2_sensor(sensor::Sensor *sensor) { this->pump_speed2_sensor_ = sensor; }
+  void set_operating_hours1_sensor(sensor::Sensor *sensor) { this->operating_hours1_sensor_ = sensor; }
+  void set_operating_hours2_sensor(sensor::Sensor *sensor) { this->operating_hours2_sensor_ = sensor; }
+  void set_heat_quantity_sensor(sensor::Sensor *sensor) { this->heat_quantity_sensor_ = sensor; }
+  void set_version_sensor(sensor::Sensor *sensor) { this->version_sensor_ = sensor; }
+
+ protected:
+  sensor::Sensor *temperature1_sensor_{nullptr};
+  sensor::Sensor *temperature2_sensor_{nullptr};
+  sensor::Sensor *temperature3_sensor_{nullptr};
+  sensor::Sensor *temperature4_sensor_{nullptr};
+  sensor::Sensor *pump_speed1_sensor_{nullptr};
+  sensor::Sensor *pump_speed2_sensor_{nullptr};
+  sensor::Sensor *operating_hours1_sensor_{nullptr};
+  sensor::Sensor *operating_hours2_sensor_{nullptr};
+  sensor::Sensor *heat_quantity_sensor_{nullptr};
+  sensor::Sensor *version_sensor_{nullptr};
+
+  void handle_message(std::vector<uint8_t> &message) override;
+};
+
 class VBusCustomSubSensor;
 
 class VBusCustomSensor : public VBusListener, public Component {
diff --git a/esphome/components/version/version_text_sensor.cpp b/esphome/components/version/version_text_sensor.cpp
index 584b8abfb29..2e5686008b9 100644
--- a/esphome/components/version/version_text_sensor.cpp
+++ b/esphome/components/version/version_text_sensor.cpp
@@ -32,7 +32,6 @@ void VersionTextSensor::setup() {
   version_str[sizeof(version_str) - 1] = '\0';
   this->publish_state(version_str);
 }
-float VersionTextSensor::get_setup_priority() const { return setup_priority::DATA; }
 void VersionTextSensor::set_hide_timestamp(bool hide_timestamp) { this->hide_timestamp_ = hide_timestamp; }
 void VersionTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Version Text Sensor", this); }
 
diff --git a/esphome/components/version/version_text_sensor.h b/esphome/components/version/version_text_sensor.h
index 6813da78300..b7d80011202 100644
--- a/esphome/components/version/version_text_sensor.h
+++ b/esphome/components/version/version_text_sensor.h
@@ -11,7 +11,6 @@ class VersionTextSensor : public text_sensor::TextSensor, public Component {
   void set_hide_timestamp(bool hide_timestamp);
   void setup() override;
   void dump_config() override;
-  float get_setup_priority() const override;
 
  protected:
   bool hide_timestamp_{false};
diff --git a/esphome/components/voice_assistant/voice_assistant.cpp b/esphome/components/voice_assistant/voice_assistant.cpp
index e2516d5fb8a..7f5fbe62e10 100644
--- a/esphome/components/voice_assistant/voice_assistant.cpp
+++ b/esphome/components/voice_assistant/voice_assistant.cpp
@@ -197,7 +197,7 @@ void VoiceAssistant::loop() {
   switch (this->state_) {
     case State::IDLE: {
       if (this->continuous_ && this->desired_state_ == State::IDLE) {
-        this->idle_trigger_->trigger();
+        this->idle_trigger_.trigger();
         this->set_state_(State::START_MICROPHONE, State::START_PIPELINE);
       } else {
         this->deallocate_buffers_();
@@ -254,7 +254,7 @@ void VoiceAssistant::loop() {
       if (this->api_client_ == nullptr ||
           !this->api_client_->send_message(msg, api::VoiceAssistantRequest::MESSAGE_TYPE)) {
         ESP_LOGW(TAG, "Could not request start");
-        this->error_trigger_->trigger("not-connected", "Could not request start");
+        this->error_trigger_.trigger("not-connected", "Could not request start");
         this->continuous_ = false;
         this->set_state_(State::IDLE, State::IDLE);
         break;
@@ -384,7 +384,7 @@ void VoiceAssistant::loop() {
         this->wait_for_stream_end_ = false;
         this->stream_ended_ = false;
 
-        this->tts_stream_end_trigger_->trigger();
+        this->tts_stream_end_trigger_.trigger();
       }
 #endif
       if (this->continue_conversation_) {
@@ -425,7 +425,7 @@ void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscr
       return;
     }
     this->api_client_ = nullptr;
-    this->client_disconnected_trigger_->trigger();
+    this->client_disconnected_trigger_.trigger();
     return;
   }
 
@@ -440,7 +440,7 @@ void VoiceAssistant::client_subscription(api::APIConnection *client, bool subscr
   }
 
   this->api_client_ = client;
-  this->client_connected_trigger_->trigger();
+  this->client_connected_trigger_.trigger();
 }
 
 static const LogString *voice_assistant_state_to_string(State state) {
@@ -491,7 +491,7 @@ void VoiceAssistant::set_state_(State state, State desired_state) {
 
 void VoiceAssistant::failed_to_start() {
   ESP_LOGE(TAG, "Failed to start server. See Home Assistant logs for more details.");
-  this->error_trigger_->trigger("failed-to-start", "Failed to start server. See Home Assistant logs for more details.");
+  this->error_trigger_.trigger("failed-to-start", "Failed to start server. See Home Assistant logs for more details.");
   this->set_state_(State::STOP_MICROPHONE, State::IDLE);
 }
 
@@ -637,18 +637,18 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
 #endif
-      this->defer([this]() { this->start_trigger_->trigger(); });
+      this->defer([this]() { this->start_trigger_.trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_WAKE_WORD_START:
       break;
     case api::enums::VOICE_ASSISTANT_WAKE_WORD_END: {
       ESP_LOGD(TAG, "Wake word detected");
-      this->defer([this]() { this->wake_word_detected_trigger_->trigger(); });
+      this->defer([this]() { this->wake_word_detected_trigger_.trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_STT_START:
       ESP_LOGD(TAG, "STT started");
-      this->defer([this]() { this->listening_trigger_->trigger(); });
+      this->defer([this]() { this->listening_trigger_.trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_STT_END: {
       std::string text;
@@ -665,12 +665,12 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         text += "...";
       }
       ESP_LOGD(TAG, "Speech recognised as: \"%s\"", text.c_str());
-      this->defer([this, text]() { this->stt_end_trigger_->trigger(text); });
+      this->defer([this, text]() { this->stt_end_trigger_.trigger(text); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_INTENT_START:
       ESP_LOGD(TAG, "Intent started");
-      this->defer([this]() { this->intent_start_trigger_->trigger(); });
+      this->defer([this]() { this->intent_start_trigger_.trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_INTENT_PROGRESS: {
       ESP_LOGD(TAG, "Intent progress");
@@ -693,7 +693,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
       }
 #endif
-      this->defer([this, tts_url_for_trigger]() { this->intent_progress_trigger_->trigger(tts_url_for_trigger); });
+      this->defer([this, tts_url_for_trigger]() { this->intent_progress_trigger_.trigger(tts_url_for_trigger); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_INTENT_END: {
@@ -704,7 +704,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
           this->continue_conversation_ = (arg.value == "1");
         }
       }
-      this->defer([this]() { this->intent_end_trigger_->trigger(); });
+      this->defer([this]() { this->intent_end_trigger_.trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_START: {
@@ -724,7 +724,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       }
       ESP_LOGD(TAG, "Response: \"%s\"", text.c_str());
       this->defer([this, text]() {
-        this->tts_start_trigger_->trigger(text);
+        this->tts_start_trigger_.trigger(text);
 #ifdef USE_SPEAKER
         if (this->speaker_ != nullptr) {
           this->speaker_->start();
@@ -756,7 +756,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         }
         this->started_streaming_tts_ = false;  // Helps indicate reaching the TTS_END stage
 #endif
-        this->tts_end_trigger_->trigger(url);
+        this->tts_end_trigger_.trigger(url);
       });
       State new_state = this->local_output_ ? State::STREAMING_RESPONSE : State::IDLE;
       if (new_state != this->state_) {
@@ -776,7 +776,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         // No TTS start event ("nevermind")
         this->set_state_(State::IDLE, State::IDLE);
       }
-      this->defer([this]() { this->end_trigger_->trigger(); });
+      this->defer([this]() { this->end_trigger_.trigger(); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_ERROR: {
@@ -796,7 +796,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         // Wake word is not set up or not ready on Home Assistant so stop and do not retry until user starts again.
         this->defer([this, code, message]() {
           this->request_stop();
-          this->error_trigger_->trigger(code, message);
+          this->error_trigger_.trigger(code, message);
         });
         return;
       }
@@ -805,7 +805,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
         this->signal_stop_();
         this->set_state_(State::STOP_MICROPHONE, State::IDLE);
       }
-      this->defer([this, code, message]() { this->error_trigger_->trigger(code, message); });
+      this->defer([this, code, message]() { this->error_trigger_.trigger(code, message); });
       break;
     }
     case api::enums::VOICE_ASSISTANT_TTS_STREAM_START: {
@@ -813,7 +813,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       if (this->speaker_ != nullptr) {
         this->wait_for_stream_end_ = true;
         ESP_LOGD(TAG, "TTS stream start");
-        this->defer([this] { this->tts_stream_start_trigger_->trigger(); });
+        this->defer([this] { this->tts_stream_start_trigger_.trigger(); });
       }
 #endif
       break;
@@ -829,12 +829,12 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
     }
     case api::enums::VOICE_ASSISTANT_STT_VAD_START:
       ESP_LOGD(TAG, "Starting STT by VAD");
-      this->defer([this]() { this->stt_vad_start_trigger_->trigger(); });
+      this->defer([this]() { this->stt_vad_start_trigger_.trigger(); });
       break;
     case api::enums::VOICE_ASSISTANT_STT_VAD_END:
       ESP_LOGD(TAG, "STT by VAD end");
       this->set_state_(State::STOP_MICROPHONE, State::AWAITING_RESPONSE);
-      this->defer([this]() { this->stt_vad_end_trigger_->trigger(); });
+      this->defer([this]() { this->stt_vad_end_trigger_.trigger(); });
       break;
     default:
       ESP_LOGD(TAG, "Unhandled event type: %" PRId32, msg.event_type);
@@ -876,17 +876,17 @@ void VoiceAssistant::on_timer_event(const api::VoiceAssistantTimerEventResponse
 
   switch (msg.event_type) {
     case api::enums::VOICE_ASSISTANT_TIMER_STARTED:
-      this->timer_started_trigger_->trigger(timer);
+      this->timer_started_trigger_.trigger(timer);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_UPDATED:
-      this->timer_updated_trigger_->trigger(timer);
+      this->timer_updated_trigger_.trigger(timer);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_CANCELLED:
-      this->timer_cancelled_trigger_->trigger(timer);
+      this->timer_cancelled_trigger_.trigger(timer);
       this->timers_.erase(timer.id);
       break;
     case api::enums::VOICE_ASSISTANT_TIMER_FINISHED:
-      this->timer_finished_trigger_->trigger(timer);
+      this->timer_finished_trigger_.trigger(timer);
       this->timers_.erase(timer.id);
       break;
   }
@@ -910,13 +910,13 @@ void VoiceAssistant::timer_tick_() {
     }
     res.push_back(timer);
   }
-  this->timer_tick_trigger_->trigger(res);
+  this->timer_tick_trigger_.trigger(res);
 }
 
 void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg) {
 #ifdef USE_MEDIA_PLAYER
   if (this->media_player_ != nullptr) {
-    this->tts_start_trigger_->trigger(msg.text);
+    this->tts_start_trigger_.trigger(msg.text);
 
     this->media_player_response_state_ = MediaPlayerResponseState::URL_SENT;
 
@@ -939,8 +939,8 @@ void VoiceAssistant::on_announce(const api::VoiceAssistantAnnounceRequest &msg)
       this->set_state_(State::STREAMING_RESPONSE, State::STREAMING_RESPONSE);
     }
 
-    this->tts_end_trigger_->trigger(msg.media_id);
-    this->end_trigger_->trigger();
+    this->tts_end_trigger_.trigger(msg.media_id);
+    this->end_trigger_.trigger();
   }
 #endif
 }
diff --git a/esphome/components/voice_assistant/voice_assistant.h b/esphome/components/voice_assistant/voice_assistant.h
index d61a8fbbc1a..2a5f3a55a77 100644
--- a/esphome/components/voice_assistant/voice_assistant.h
+++ b/esphome/components/voice_assistant/voice_assistant.h
@@ -195,38 +195,38 @@ class VoiceAssistant : public Component {
   void set_conversation_timeout(uint32_t conversation_timeout) { this->conversation_timeout_ = conversation_timeout; }
   void reset_conversation_id();
 
-  Trigger<> *get_intent_end_trigger() const { return this->intent_end_trigger_; }
-  Trigger<> *get_intent_start_trigger() const { return this->intent_start_trigger_; }
-  Trigger<std::string> *get_intent_progress_trigger() const { return this->intent_progress_trigger_; }
-  Trigger<> *get_listening_trigger() const { return this->listening_trigger_; }
-  Trigger<> *get_end_trigger() const { return this->end_trigger_; }
-  Trigger<> *get_start_trigger() const { return this->start_trigger_; }
-  Trigger<> *get_stt_vad_end_trigger() const { return this->stt_vad_end_trigger_; }
-  Trigger<> *get_stt_vad_start_trigger() const { return this->stt_vad_start_trigger_; }
+  Trigger<> *get_intent_end_trigger() { return &this->intent_end_trigger_; }
+  Trigger<> *get_intent_start_trigger() { return &this->intent_start_trigger_; }
+  Trigger<std::string> *get_intent_progress_trigger() { return &this->intent_progress_trigger_; }
+  Trigger<> *get_listening_trigger() { return &this->listening_trigger_; }
+  Trigger<> *get_end_trigger() { return &this->end_trigger_; }
+  Trigger<> *get_start_trigger() { return &this->start_trigger_; }
+  Trigger<> *get_stt_vad_end_trigger() { return &this->stt_vad_end_trigger_; }
+  Trigger<> *get_stt_vad_start_trigger() { return &this->stt_vad_start_trigger_; }
 #ifdef USE_SPEAKER
-  Trigger<> *get_tts_stream_start_trigger() const { return this->tts_stream_start_trigger_; }
-  Trigger<> *get_tts_stream_end_trigger() const { return this->tts_stream_end_trigger_; }
+  Trigger<> *get_tts_stream_start_trigger() { return &this->tts_stream_start_trigger_; }
+  Trigger<> *get_tts_stream_end_trigger() { return &this->tts_stream_end_trigger_; }
 #endif
-  Trigger<> *get_wake_word_detected_trigger() const { return this->wake_word_detected_trigger_; }
-  Trigger<std::string> *get_stt_end_trigger() const { return this->stt_end_trigger_; }
-  Trigger<std::string> *get_tts_end_trigger() const { return this->tts_end_trigger_; }
-  Trigger<std::string> *get_tts_start_trigger() const { return this->tts_start_trigger_; }
-  Trigger<std::string, std::string> *get_error_trigger() const { return this->error_trigger_; }
-  Trigger<> *get_idle_trigger() const { return this->idle_trigger_; }
+  Trigger<> *get_wake_word_detected_trigger() { return &this->wake_word_detected_trigger_; }
+  Trigger<std::string> *get_stt_end_trigger() { return &this->stt_end_trigger_; }
+  Trigger<std::string> *get_tts_end_trigger() { return &this->tts_end_trigger_; }
+  Trigger<std::string> *get_tts_start_trigger() { return &this->tts_start_trigger_; }
+  Trigger<std::string, std::string> *get_error_trigger() { return &this->error_trigger_; }
+  Trigger<> *get_idle_trigger() { return &this->idle_trigger_; }
 
-  Trigger<> *get_client_connected_trigger() const { return this->client_connected_trigger_; }
-  Trigger<> *get_client_disconnected_trigger() const { return this->client_disconnected_trigger_; }
+  Trigger<> *get_client_connected_trigger() { return &this->client_connected_trigger_; }
+  Trigger<> *get_client_disconnected_trigger() { return &this->client_disconnected_trigger_; }
 
   void client_subscription(api::APIConnection *client, bool subscribe);
   api::APIConnection *get_api_connection() const { return this->api_client_; }
 
   void set_wake_word(const std::string &wake_word) { this->wake_word_ = wake_word; }
 
-  Trigger<Timer> *get_timer_started_trigger() const { return this->timer_started_trigger_; }
-  Trigger<Timer> *get_timer_updated_trigger() const { return this->timer_updated_trigger_; }
-  Trigger<Timer> *get_timer_cancelled_trigger() const { return this->timer_cancelled_trigger_; }
-  Trigger<Timer> *get_timer_finished_trigger() const { return this->timer_finished_trigger_; }
-  Trigger<std::vector<Timer>> *get_timer_tick_trigger() const { return this->timer_tick_trigger_; }
+  Trigger<Timer> *get_timer_started_trigger() { return &this->timer_started_trigger_; }
+  Trigger<Timer> *get_timer_updated_trigger() { return &this->timer_updated_trigger_; }
+  Trigger<Timer> *get_timer_cancelled_trigger() { return &this->timer_cancelled_trigger_; }
+  Trigger<Timer> *get_timer_finished_trigger() { return &this->timer_finished_trigger_; }
+  Trigger<std::vector<Timer>> *get_timer_tick_trigger() { return &this->timer_tick_trigger_; }
   void set_has_timers(bool has_timers) { this->has_timers_ = has_timers; }
   const std::unordered_map<std::string, Timer> &get_timers() const { return this->timers_; }
 
@@ -243,37 +243,37 @@ class VoiceAssistant : public Component {
   std::unique_ptr<socket::Socket> socket_ = nullptr;
   struct sockaddr_storage dest_addr_;
 
-  Trigger<> *intent_end_trigger_ = new Trigger<>();
-  Trigger<> *intent_start_trigger_ = new Trigger<>();
-  Trigger<> *listening_trigger_ = new Trigger<>();
-  Trigger<> *end_trigger_ = new Trigger<>();
-  Trigger<> *start_trigger_ = new Trigger<>();
-  Trigger<> *stt_vad_start_trigger_ = new Trigger<>();
-  Trigger<> *stt_vad_end_trigger_ = new Trigger<>();
+  Trigger<> intent_end_trigger_;
+  Trigger<> intent_start_trigger_;
+  Trigger<> listening_trigger_;
+  Trigger<> end_trigger_;
+  Trigger<> start_trigger_;
+  Trigger<> stt_vad_start_trigger_;
+  Trigger<> stt_vad_end_trigger_;
 #ifdef USE_SPEAKER
-  Trigger<> *tts_stream_start_trigger_ = new Trigger<>();
-  Trigger<> *tts_stream_end_trigger_ = new Trigger<>();
+  Trigger<> tts_stream_start_trigger_;
+  Trigger<> tts_stream_end_trigger_;
 #endif
-  Trigger<std::string> *intent_progress_trigger_ = new Trigger<std::string>();
-  Trigger<> *wake_word_detected_trigger_ = new Trigger<>();
-  Trigger<std::string> *stt_end_trigger_ = new Trigger<std::string>();
-  Trigger<std::string> *tts_end_trigger_ = new Trigger<std::string>();
-  Trigger<std::string> *tts_start_trigger_ = new Trigger<std::string>();
-  Trigger<std::string, std::string> *error_trigger_ = new Trigger<std::string, std::string>();
-  Trigger<> *idle_trigger_ = new Trigger<>();
+  Trigger<std::string> intent_progress_trigger_;
+  Trigger<> wake_word_detected_trigger_;
+  Trigger<std::string> stt_end_trigger_;
+  Trigger<std::string> tts_end_trigger_;
+  Trigger<std::string> tts_start_trigger_;
+  Trigger<std::string, std::string> error_trigger_;
+  Trigger<> idle_trigger_;
 
-  Trigger<> *client_connected_trigger_ = new Trigger<>();
-  Trigger<> *client_disconnected_trigger_ = new Trigger<>();
+  Trigger<> client_connected_trigger_;
+  Trigger<> client_disconnected_trigger_;
 
   api::APIConnection *api_client_{nullptr};
 
   std::unordered_map<std::string, Timer> timers_;
   void timer_tick_();
-  Trigger<Timer> *timer_started_trigger_ = new Trigger<Timer>();
-  Trigger<Timer> *timer_finished_trigger_ = new Trigger<Timer>();
-  Trigger<Timer> *timer_updated_trigger_ = new Trigger<Timer>();
-  Trigger<Timer> *timer_cancelled_trigger_ = new Trigger<Timer>();
-  Trigger<std::vector<Timer>> *timer_tick_trigger_ = new Trigger<std::vector<Timer>>();
+  Trigger<Timer> timer_started_trigger_;
+  Trigger<Timer> timer_finished_trigger_;
+  Trigger<Timer> timer_updated_trigger_;
+  Trigger<Timer> timer_cancelled_trigger_;
+  Trigger<std::vector<Timer>> timer_tick_trigger_;
   bool has_timers_{false};
   bool timer_tick_running_{false};
 
diff --git a/esphome/components/water_heater/water_heater.cpp b/esphome/components/water_heater/water_heater.cpp
index 7266294d848..286addf7dbc 100644
--- a/esphome/components/water_heater/water_heater.cpp
+++ b/esphome/components/water_heater/water_heater.cpp
@@ -2,6 +2,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/core/controller_registry.h"
+#include "esphome/core/progmem.h"
 
 #include <cmath>
 
@@ -22,23 +23,23 @@ WaterHeaterCall &WaterHeaterCall::set_mode(WaterHeaterMode mode) {
   return *this;
 }
 
-WaterHeaterCall &WaterHeaterCall::set_mode(const std::string &mode) {
-  if (str_equals_case_insensitive(mode, "OFF")) {
+WaterHeaterCall &WaterHeaterCall::set_mode(const char *mode) {
+  if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("OFF")) == 0) {
     this->set_mode(WATER_HEATER_MODE_OFF);
-  } else if (str_equals_case_insensitive(mode, "ECO")) {
+  } else if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("ECO")) == 0) {
     this->set_mode(WATER_HEATER_MODE_ECO);
-  } else if (str_equals_case_insensitive(mode, "ELECTRIC")) {
+  } else if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("ELECTRIC")) == 0) {
     this->set_mode(WATER_HEATER_MODE_ELECTRIC);
-  } else if (str_equals_case_insensitive(mode, "PERFORMANCE")) {
+  } else if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("PERFORMANCE")) == 0) {
     this->set_mode(WATER_HEATER_MODE_PERFORMANCE);
-  } else if (str_equals_case_insensitive(mode, "HIGH_DEMAND")) {
+  } else if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("HIGH_DEMAND")) == 0) {
     this->set_mode(WATER_HEATER_MODE_HIGH_DEMAND);
-  } else if (str_equals_case_insensitive(mode, "HEAT_PUMP")) {
+  } else if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("HEAT_PUMP")) == 0) {
     this->set_mode(WATER_HEATER_MODE_HEAT_PUMP);
-  } else if (str_equals_case_insensitive(mode, "GAS")) {
+  } else if (ESPHOME_strcasecmp_P(mode, ESPHOME_PSTR("GAS")) == 0) {
     this->set_mode(WATER_HEATER_MODE_GAS);
   } else {
-    ESP_LOGW(TAG, "'%s' - Unrecognized mode %s", this->parent_->get_name().c_str(), mode.c_str());
+    ESP_LOGW(TAG, "'%s' - Unrecognized mode %s", this->parent_->get_name().c_str(), mode);
   }
   return *this;
 }
diff --git a/esphome/components/water_heater/water_heater.h b/esphome/components/water_heater/water_heater.h
index 84fc46d2084..7bd05ba7f5d 100644
--- a/esphome/components/water_heater/water_heater.h
+++ b/esphome/components/water_heater/water_heater.h
@@ -75,7 +75,8 @@ class WaterHeaterCall {
   WaterHeaterCall(WaterHeater *parent);
 
   WaterHeaterCall &set_mode(WaterHeaterMode mode);
-  WaterHeaterCall &set_mode(const std::string &mode);
+  WaterHeaterCall &set_mode(const char *mode);
+  WaterHeaterCall &set_mode(const std::string &mode) { return this->set_mode(mode.c_str()); }
   WaterHeaterCall &set_target_temperature(float temperature);
   WaterHeaterCall &set_target_temperature_low(float temperature);
   WaterHeaterCall &set_target_temperature_high(float temperature);
diff --git a/esphome/components/web_server/web_server.cpp b/esphome/components/web_server/web_server.cpp
index d30cb524f4e..42219f3aac9 100644
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -454,7 +454,7 @@ void WebServer::handle_index_request(AsyncWebServerRequest *request) {
 
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
 void WebServer::handle_pna_cors_request(AsyncWebServerRequest *request) {
-  AsyncWebServerResponse *response = request->beginResponse(200, "");
+  AsyncWebServerResponse *response = request->beginResponse(200, ESPHOME_F(""));
   response->addHeader(ESPHOME_F("Access-Control-Allow-Private-Network"), ESPHOME_F("true"));
   response->addHeader(ESPHOME_F("Private-Network-Access-Name"), App.get_name().c_str());
   char mac_s[18];
@@ -721,11 +721,7 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
     }
 
     if (action != SWITCH_ACTION_NONE) {
-#ifdef USE_ESP8266
-      execute_switch_action(obj, action);
-#else
       this->defer([obj, action]() { execute_switch_action(obj, action); });
-#endif
       request->send(200);
     } else {
       request->send(404);
@@ -1645,11 +1641,7 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
     }
 
     if (action != LOCK_ACTION_NONE) {
-#ifdef USE_ESP8266
-      execute_lock_action(obj, action);
-#else
       this->defer([obj, action]() { execute_lock_action(obj, action); });
-#endif
       request->send(200);
     } else {
       request->send(404);
@@ -1975,7 +1967,7 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
 
     // Only allow transmit if the device supports it
     if (!obj->has_transmitter()) {
-      request->send(400, ESPHOME_F("text/plain"), "Device does not support transmission");
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Device does not support transmission"));
       return;
     }
 
@@ -2001,7 +1993,7 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
     // Parse base64url-encoded raw timings (required)
     // Base64url is URL-safe: uses A-Za-z0-9-_ (no special characters needing escaping)
     if (!request->hasParam(ESPHOME_F("data"))) {
-      request->send(400, ESPHOME_F("text/plain"), "Missing 'data' parameter");
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Missing 'data' parameter"));
       return;
     }
 
@@ -2011,23 +2003,18 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
 
     // Validate base64url is not empty
     if (encoded.empty()) {
-      request->send(400, ESPHOME_F("text/plain"), "Empty 'data' parameter");
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Empty 'data' parameter"));
       return;
     }
 
-#ifdef USE_ESP8266
-    // ESP8266 is single-threaded, call directly
-    call.set_raw_timings_base64url(encoded);
-    call.perform();
-#else
     // Defer to main loop for thread safety. Move encoded string into lambda to ensure
     // it outlives the call - set_raw_timings_base64url stores a pointer, so the string
     // must remain valid until perform() completes.
+    // ESP8266 also needs this because ESPAsyncWebServer callbacks run in "sys" context.
     this->defer([call, encoded = std::move(encoded)]() mutable {
       call.set_raw_timings_base64url(encoded);
       call.perform();
     });
-#endif
 
     request->send(200);
     return;
@@ -2485,7 +2472,7 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
   else {
     // No matching handler found - send 404
     ESP_LOGV(TAG, "Request for unknown URL: %s", url.c_str());
-    request->send(404, "text/plain", "Not Found");
+    request->send(404, ESPHOME_F("text/plain"), ESPHOME_F("Not Found"));
   }
 }
 
diff --git a/esphome/components/web_server/web_server.h b/esphome/components/web_server/web_server.h
index 92a5c7edee0..224c051ecee 100644
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -42,13 +42,12 @@ using ParamNameType = const __FlashStringHelper *;
 using ParamNameType = const char *;
 #endif
 
-// ESP8266 is single-threaded, so actions can execute directly in request context.
-// Multi-core platforms need to defer to main loop thread for thread safety.
-#ifdef USE_ESP8266
-#define DEFER_ACTION(capture, action) action
-#else
+// All platforms need to defer actions to main loop thread.
+// Multi-core platforms need this for thread safety.
+// ESP8266 needs this because ESPAsyncWebServer callbacks run in "sys" context
+// (SDK system context), not "cont" context (continuation/main loop). Calling
+// yield() from sys context causes a panic in the Arduino core.
 #define DEFER_ACTION(capture, action) this->defer([capture]() mutable { action; })
-#endif
 
 /// Result of matching a URL against an entity
 struct EntityMatchResult {
diff --git a/esphome/components/web_server/web_server_v1.cpp b/esphome/components/web_server/web_server_v1.cpp
index ae4bbfa557b..f7b90018dc6 100644
--- a/esphome/components/web_server/web_server_v1.cpp
+++ b/esphome/components/web_server/web_server_v1.cpp
@@ -74,7 +74,7 @@ void WebServer::set_css_url(const char *css_url) { this->css_url_ = css_url; }
 void WebServer::set_js_url(const char *js_url) { this->js_url_ = js_url; }
 
 void WebServer::handle_index_request(AsyncWebServerRequest *request) {
-  AsyncResponseStream *stream = request->beginResponseStream("text/html");
+  AsyncResponseStream *stream = request->beginResponseStream(ESPHOME_F("text/html"));
   const std::string &title = App.get_name();
   stream->print(ESPHOME_F("<!DOCTYPE html><html lang=\"en\"><head><meta charset=UTF-8><meta "
                           "name=viewport content=\"width=device-width, initial-scale=1,user-scalable=no\"><title>"));
diff --git a/esphome/components/web_server_base/__init__.py b/esphome/components/web_server_base/__init__.py
index 6326b4d6ffe..11408ae2604 100644
--- a/esphome/components/web_server_base/__init__.py
+++ b/esphome/components/web_server_base/__init__.py
@@ -38,11 +38,8 @@ async def to_code(config):
         cg.add_define("WEB_SERVER_DEFAULT_HEADERS_COUNT", 1)
         return
 
+    # ESP32 uses IDF web server (early return above), so this is for other Arduino platforms
     if CORE.using_arduino:
-        if CORE.is_esp32:
-            cg.add_library("WiFi", None)
-            cg.add_library("FS", None)
-            cg.add_library("Update", None)
         if CORE.is_esp8266:
             cg.add_library("ESP8266WiFi", None)
         if CORE.is_libretiny:
diff --git a/esphome/components/web_server_idf/utils.cpp b/esphome/components/web_server_idf/utils.cpp
index f27814062c8..d3c3c3dc55a 100644
--- a/esphome/components/web_server_idf/utils.cpp
+++ b/esphome/components/web_server_idf/utils.cpp
@@ -73,18 +73,15 @@ optional<std::string> request_get_url_query(httpd_req_t *req) {
   return {str};
 }
 
-optional<std::string> query_key_value(const std::string &query_url, const std::string &key) {
-  if (query_url.empty()) {
+optional<std::string> query_key_value(const char *query_url, size_t query_len, const char *key) {
+  if (query_url == nullptr || query_len == 0) {
     return {};
   }
 
-  auto val = std::unique_ptr<char[]>(new char[query_url.size()]);
-  if (!val) {
-    ESP_LOGE(TAG, "Not enough memory to the query key value");
-    return {};
-  }
+  // Use stack buffer for typical query strings, heap fallback for large ones
+  SmallBufferWithHeapFallback<256, char> val(query_len);
 
-  if (httpd_query_key_value(query_url.c_str(), key.c_str(), val.get(), query_url.size()) != ESP_OK) {
+  if (httpd_query_key_value(query_url, key, val.get(), query_len) != ESP_OK) {
     return {};
   }
 
diff --git a/esphome/components/web_server_idf/utils.h b/esphome/components/web_server_idf/utils.h
index 3a86aec7ac3..ae58f82398c 100644
--- a/esphome/components/web_server_idf/utils.h
+++ b/esphome/components/web_server_idf/utils.h
@@ -15,7 +15,10 @@ size_t url_decode(char *str);
 bool request_has_header(httpd_req_t *req, const char *name);
 optional<std::string> request_get_header(httpd_req_t *req, const char *name);
 optional<std::string> request_get_url_query(httpd_req_t *req);
-optional<std::string> query_key_value(const std::string &query_url, const std::string &key);
+optional<std::string> query_key_value(const char *query_url, size_t query_len, const char *key);
+inline optional<std::string> query_key_value(const std::string &query_url, const std::string &key) {
+  return query_key_value(query_url.c_str(), query_url.size(), key.c_str());
+}
 
 // Helper function for case-insensitive character comparison
 inline bool char_equals_ci(char a, char b) { return ::tolower(a) == ::tolower(b); }
diff --git a/esphome/components/web_server_idf/web_server_idf.cpp b/esphome/components/web_server_idf/web_server_idf.cpp
index 2e5a74cbef2..98608104527 100644
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -366,7 +366,7 @@ void AsyncWebServerRequest::requestAuthentication(const char *realm) const {
 }
 #endif
 
-AsyncWebParameter *AsyncWebServerRequest::getParam(const std::string &name) {
+AsyncWebParameter *AsyncWebServerRequest::getParam(const char *name) {
   // Check cache first - only successful lookups are cached
   for (auto *param : this->params_) {
     if (param->name() == name) {
@@ -375,11 +375,11 @@ AsyncWebParameter *AsyncWebServerRequest::getParam(const std::string &name) {
   }
 
   // Look up value from query strings
-  optional<std::string> val = query_key_value(this->post_query_, name);
+  optional<std::string> val = query_key_value(this->post_query_.c_str(), this->post_query_.size(), name);
   if (!val.has_value()) {
     auto url_query = request_get_url_query(*this);
     if (url_query.has_value()) {
-      val = query_key_value(url_query.value(), name);
+      val = query_key_value(url_query.value().c_str(), url_query.value().size(), name);
     }
   }
 
diff --git a/esphome/components/web_server_idf/web_server_idf.h b/esphome/components/web_server_idf/web_server_idf.h
index e38913ef4a1..817f47da796 100644
--- a/esphome/components/web_server_idf/web_server_idf.h
+++ b/esphome/components/web_server_idf/web_server_idf.h
@@ -162,19 +162,24 @@ class AsyncWebServerRequest {
   }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
-  bool hasParam(const std::string &name) { return this->getParam(name) != nullptr; }
+  bool hasParam(const char *name) { return this->getParam(name) != nullptr; }
   // NOLINTNEXTLINE(readability-identifier-naming)
-  AsyncWebParameter *getParam(const std::string &name);
+  bool hasParam(const std::string &name) { return this->getParam(name.c_str()) != nullptr; }
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  AsyncWebParameter *getParam(const char *name);
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  AsyncWebParameter *getParam(const std::string &name) { return this->getParam(name.c_str()); }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
   bool hasArg(const char *name) { return this->hasParam(name); }
-  std::string arg(const std::string &name) {
+  std::string arg(const char *name) {
     auto *param = this->getParam(name);
     if (param) {
       return param->value();
     }
     return {};
   }
+  std::string arg(const std::string &name) { return this->arg(name.c_str()); }
 
   operator httpd_req_t *() const { return this->req_; }
   optional<std::string> get_header(const char *name) const;
diff --git a/esphome/components/wifi/__init__.py b/esphome/components/wifi/__init__.py
index 98266eb589e..6863e6fb62d 100644
--- a/esphome/components/wifi/__init__.py
+++ b/esphome/components/wifi/__init__.py
@@ -585,11 +585,13 @@ async def to_code(config):
     await cg.past_safe_mode()
 
     if on_connect_config := config.get(CONF_ON_CONNECT):
+        cg.add_define("USE_WIFI_CONNECT_TRIGGER")
         await automation.build_automation(
             var.get_connect_trigger(), [], on_connect_config
         )
 
     if on_disconnect_config := config.get(CONF_ON_DISCONNECT):
+        cg.add_define("USE_WIFI_DISCONNECT_TRIGGER")
         await automation.build_automation(
             var.get_disconnect_trigger(), [], on_disconnect_config
         )
diff --git a/esphome/components/wifi/automation.h b/esphome/components/wifi/automation.h
index fb0e71bcf66..1ad69b39925 100644
--- a/esphome/components/wifi/automation.h
+++ b/esphome/components/wifi/automation.h
@@ -48,7 +48,7 @@ template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, publi
     char ssid_buf[SSID_BUFFER_SIZE];
     if (strcmp(global_wifi_component->wifi_ssid_to(ssid_buf), ssid.c_str()) == 0) {
       // Callback to notify the user that the connection was successful
-      this->connect_trigger_->trigger();
+      this->connect_trigger_.trigger();
       return;
     }
     // Create a new WiFiAP object with the new SSID and password
@@ -79,13 +79,13 @@ template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, publi
       // Start a timeout for the fallback if the connection to the old AP fails
       this->set_timeout("wifi-fallback-timeout", this->connection_timeout_.value(x...), [this]() {
         this->connecting_ = false;
-        this->error_trigger_->trigger();
+        this->error_trigger_.trigger();
       });
     });
   }
 
-  Trigger<> *get_connect_trigger() const { return this->connect_trigger_; }
-  Trigger<> *get_error_trigger() const { return this->error_trigger_; }
+  Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
+  Trigger<> *get_error_trigger() { return &this->error_trigger_; }
 
   void loop() override {
     if (!this->connecting_)
@@ -98,10 +98,10 @@ template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, publi
       char ssid_buf[SSID_BUFFER_SIZE];
       if (strcmp(global_wifi_component->wifi_ssid_to(ssid_buf), this->new_sta_.get_ssid().c_str()) == 0) {
         // Callback to notify the user that the connection was successful
-        this->connect_trigger_->trigger();
+        this->connect_trigger_.trigger();
       } else {
         // Callback to notify the user that the connection failed
-        this->error_trigger_->trigger();
+        this->error_trigger_.trigger();
       }
     }
   }
@@ -110,8 +110,8 @@ template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, publi
   bool connecting_{false};
   WiFiAP new_sta_;
   WiFiAP old_sta_;
-  Trigger<> *connect_trigger_{new Trigger<>()};
-  Trigger<> *error_trigger_{new Trigger<>()};
+  Trigger<> connect_trigger_;
+  Trigger<> error_trigger_;
 };
 
 }  // namespace esphome::wifi
diff --git a/esphome/components/wifi/wifi_component.cpp b/esphome/components/wifi/wifi_component.cpp
index af4142591d8..44c92fcaa44 100644
--- a/esphome/components/wifi/wifi_component.cpp
+++ b/esphome/components/wifi/wifi_component.cpp
@@ -651,14 +651,21 @@ void WiFiComponent::loop() {
   const uint32_t now = App.get_loop_component_start_time();
 
   if (this->has_sta()) {
+#if defined(USE_WIFI_CONNECT_TRIGGER) || defined(USE_WIFI_DISCONNECT_TRIGGER)
     if (this->is_connected() != this->handled_connected_state_) {
+#ifdef USE_WIFI_DISCONNECT_TRIGGER
       if (this->handled_connected_state_) {
-        this->disconnect_trigger_->trigger();
-      } else {
-        this->connect_trigger_->trigger();
+        this->disconnect_trigger_.trigger();
       }
+#endif
+#ifdef USE_WIFI_CONNECT_TRIGGER
+      if (!this->handled_connected_state_) {
+        this->connect_trigger_.trigger();
+      }
+#endif
       this->handled_connected_state_ = this->is_connected();
     }
+#endif  // USE_WIFI_CONNECT_TRIGGER || USE_WIFI_DISCONNECT_TRIGGER
 
     switch (this->state_) {
       case WIFI_COMPONENT_STATE_COOLDOWN: {
@@ -1457,6 +1464,12 @@ void WiFiComponent::check_connecting_finished(uint32_t now) {
 
     this->release_scan_results_();
 
+#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+    // Notify listeners now that state machine has reached STA_CONNECTED
+    // This ensures wifi.connected condition returns true in listener automations
+    this->notify_connect_state_listeners_();
+#endif
+
     return;
   }
 
@@ -2180,6 +2193,21 @@ void WiFiComponent::release_scan_results_() {
   }
 }
 
+#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+void WiFiComponent::notify_connect_state_listeners_() {
+  if (!this->pending_.connect_state)
+    return;
+  this->pending_.connect_state = false;
+  // Get current SSID and BSSID from the WiFi driver
+  char ssid_buf[SSID_BUFFER_SIZE];
+  const char *ssid = this->wifi_ssid_to(ssid_buf);
+  bssid_t bssid = this->wifi_bssid();
+  for (auto *listener : this->connect_state_listeners_) {
+    listener->on_wifi_connect_state(StringRef(ssid, strlen(ssid)), bssid);
+  }
+}
+#endif  // USE_WIFI_CONNECT_STATE_LISTENERS
+
 void WiFiComponent::check_roaming_(uint32_t now) {
   // Guard: not for hidden networks (may not appear in scan)
   const WiFiAP *selected = this->get_selected_sta_();
diff --git a/esphome/components/wifi/wifi_component.h b/esphome/components/wifi/wifi_component.h
index 843e45cad68..e910da2cbb3 100644
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -460,8 +460,12 @@ class WiFiComponent : public Component {
   void set_keep_scan_results(bool keep_scan_results) { this->keep_scan_results_ = keep_scan_results; }
   void set_post_connect_roaming(bool enabled) { this->post_connect_roaming_ = enabled; }
 
-  Trigger<> *get_connect_trigger() const { return this->connect_trigger_; };
-  Trigger<> *get_disconnect_trigger() const { return this->disconnect_trigger_; };
+#ifdef USE_WIFI_CONNECT_TRIGGER
+  Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
+#endif
+#ifdef USE_WIFI_DISCONNECT_TRIGGER
+  Trigger<> *get_disconnect_trigger() { return &this->disconnect_trigger_; }
+#endif
 
   int32_t get_wifi_channel();
 
@@ -637,6 +641,11 @@ class WiFiComponent : public Component {
   /// Free scan results memory unless a component needs them
   void release_scan_results_();
 
+#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+  /// Notify connect state listeners (called after state machine reaches STA_CONNECTED)
+  void notify_connect_state_listeners_();
+#endif
+
 #ifdef USE_ESP8266
   static void wifi_event_callback(System_Event_t *event);
   void wifi_scan_done_callback_(void *arg, STATUS status);
@@ -732,7 +741,9 @@ class WiFiComponent : public Component {
 
   // Group all boolean values together
   bool has_ap_{false};
+#if defined(USE_WIFI_CONNECT_TRIGGER) || defined(USE_WIFI_DISCONNECT_TRIGGER)
   bool handled_connected_state_{false};
+#endif
   bool scan_done_{false};
   bool ap_setup_{false};
   bool ap_started_{false};
@@ -758,9 +769,22 @@ class WiFiComponent : public Component {
   SemaphoreHandle_t high_performance_semaphore_{nullptr};
 #endif
 
-  // Pointers at the end (naturally aligned)
-  Trigger<> *connect_trigger_{new Trigger<>()};
-  Trigger<> *disconnect_trigger_{new Trigger<>()};
+#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+  // Pending listener notifications deferred until state machine reaches appropriate state.
+  // Listeners are notified after state transitions complete so conditions like
+  // wifi.connected return correct values in automations.
+  // Uses bitfields to minimize memory; more flags may be added as needed.
+  struct {
+    bool connect_state : 1;  // Notify connect state listeners after STA_CONNECTED
+  } pending_{};
+#endif
+
+#ifdef USE_WIFI_CONNECT_TRIGGER
+  Trigger<> connect_trigger_;
+#endif
+#ifdef USE_WIFI_DISCONNECT_TRIGGER
+  Trigger<> disconnect_trigger_;
+#endif
 
  private:
   // Stores a pointer to a string literal (static storage duration).
diff --git a/esphome/components/wifi/wifi_component_esp8266.cpp b/esphome/components/wifi/wifi_component_esp8266.cpp
index 09ecdf857ad..222212c8e27 100644
--- a/esphome/components/wifi/wifi_component_esp8266.cpp
+++ b/esphome/components/wifi/wifi_component_esp8266.cpp
@@ -500,6 +500,10 @@ const LogString *get_disconnect_reason_str(uint8_t reason) {
   }
 }
 
+// TODO: This callback runs in ESP8266 system context with limited stack (~2KB).
+// All listener notifications should be deferred to wifi_loop_() via pending_ flags
+// to avoid stack overflow. Currently only connect_state is deferred; disconnect,
+// IP, and scan listeners still run in this context and should be migrated.
 void WiFiComponent::wifi_event_callback(System_Event_t *event) {
   switch (event->event) {
     case EVENT_STAMODE_CONNECTED: {
diff --git a/esphome/components/wifi/wifi_component_esp_idf.cpp b/esphome/components/wifi/wifi_component_esp_idf.cpp
index 1c78d962ef9..3c4e78d9261 100644
--- a/esphome/components/wifi/wifi_component_esp_idf.cpp
+++ b/esphome/components/wifi/wifi_component_esp_idf.cpp
@@ -710,6 +710,9 @@ void WiFiComponent::wifi_loop_() {
     delete data;  // NOLINT(cppcoreguidelines-owning-memory)
   }
 }
+// Events are processed from queue in main loop context, but listener notifications
+// must be deferred until after the state machine transitions (in check_connecting_finished)
+// so that conditions like wifi.connected return correct values in automations.
 void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
   esp_err_t err;
   if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_START) {
@@ -743,9 +746,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
 #endif
     s_sta_connected = true;
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-    for (auto *listener : this->connect_state_listeners_) {
-      listener->on_wifi_connect_state(StringRef(it.ssid, it.ssid_len), it.bssid);
-    }
+    // Defer listener notification until state machine reaches STA_CONNECTED
+    // This ensures wifi.connected condition returns true in listener automations
+    this->pending_.connect_state = true;
 #endif
     // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
 #if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
diff --git a/esphome/components/wifi/wifi_component_libretiny.cpp b/esphome/components/wifi/wifi_component_libretiny.cpp
index 9af4dfbadbc..4f9e2c48e95 100644
--- a/esphome/components/wifi/wifi_component_libretiny.cpp
+++ b/esphome/components/wifi/wifi_component_libretiny.cpp
@@ -423,7 +423,10 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
   }
 }
 
-// Process a single event from the queue - runs in main loop context
+// Process a single event from the queue - runs in main loop context.
+// Listener notifications must be deferred until after the state machine transitions
+// (in check_connecting_finished) so that conditions like wifi.connected return
+// correct values in automations.
 void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
   switch (event->event_id) {
     case ESPHOME_EVENT_ID_WIFI_READY: {
@@ -456,9 +459,9 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
       // This matches ESP32 IDF behavior where s_sta_connected is set but
       // wifi_sta_connect_status_() also checks got_ipv4_address_
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-      for (auto *listener : this->connect_state_listeners_) {
-        listener->on_wifi_connect_state(StringRef(it.ssid, it.ssid_len), it.bssid);
-      }
+      // Defer listener notification until state machine reaches STA_CONNECTED
+      // This ensures wifi.connected condition returns true in listener automations
+      this->pending_.connect_state = true;
 #endif
       // For static IP configurations, GOT_IP event may not fire, so set connected state here
 #ifdef USE_WIFI_MANUAL_IP
diff --git a/esphome/components/wifi/wifi_component_pico_w.cpp b/esphome/components/wifi/wifi_component_pico_w.cpp
index 84c10d5d432..1ce36c2d93f 100644
--- a/esphome/components/wifi/wifi_component_pico_w.cpp
+++ b/esphome/components/wifi/wifi_component_pico_w.cpp
@@ -252,6 +252,10 @@ network::IPAddress WiFiComponent::wifi_dns_ip_(int num) {
   return network::IPAddress(dns_ip);
 }
 
+// Pico W uses polling for connection state detection.
+// Connect state listener notifications are deferred until after the state machine
+// transitions (in check_connecting_finished) so that conditions like wifi.connected
+// return correct values in automations.
 void WiFiComponent::wifi_loop_() {
   // Handle scan completion
   if (this->state_ == WIFI_COMPONENT_STATE_STA_SCANNING && !cyw43_wifi_scan_active(&cyw43_state)) {
@@ -278,11 +282,9 @@ void WiFiComponent::wifi_loop_() {
     s_sta_was_connected = true;
     ESP_LOGV(TAG, "Connected");
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-    String ssid = WiFi.SSID();
-    bssid_t bssid = this->wifi_bssid();
-    for (auto *listener : this->connect_state_listeners_) {
-      listener->on_wifi_connect_state(StringRef(ssid.c_str(), ssid.length()), bssid);
-    }
+    // Defer listener notification until state machine reaches STA_CONNECTED
+    // This ensures wifi.connected condition returns true in listener automations
+    this->pending_.connect_state = true;
 #endif
     // For static IP configurations, notify IP listeners immediately as the IP is already configured
 #if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
diff --git a/esphome/components/wled/__init__.py b/esphome/components/wled/__init__.py
index fb20a030101..49eb15dad6a 100644
--- a/esphome/components/wled/__init__.py
+++ b/esphome/components/wled/__init__.py
@@ -3,6 +3,7 @@ from esphome.components.light.effects import register_addressable_effect
 from esphome.components.light.types import AddressableLightEffect
 import esphome.config_validation as cv
 from esphome.const import CONF_NAME, CONF_PORT
+from esphome.core import CORE
 
 wled_ns = cg.esphome_ns.namespace("wled")
 WLEDLightEffect = wled_ns.class_("WLEDLightEffect", AddressableLightEffect)
@@ -27,4 +28,6 @@ async def wled_light_effect_to_code(config, effect_id):
     cg.add(effect.set_port(config[CONF_PORT]))
     cg.add(effect.set_sync_group_mask(config[CONF_SYNC_GROUP_MASK]))
     cg.add(effect.set_blank_on_start(config[CONF_BLANK_ON_START]))
+    if CORE.is_esp32:
+        cg.add_library("WiFi", None)
     return effect
diff --git a/esphome/components/wts01/wts01.h b/esphome/components/wts01/wts01.h
index 298595a5d62..aae90c2c771 100644
--- a/esphome/components/wts01/wts01.h
+++ b/esphome/components/wts01/wts01.h
@@ -13,7 +13,6 @@ class WTS01Sensor : public sensor::Sensor, public uart::UARTDevice, public Compo
  public:
   void loop() override;
   void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::DATA; }
 
  protected:
   uint8_t buffer_[PACKET_SIZE];
diff --git a/esphome/components/zephyr/__init__.py b/esphome/components/zephyr/__init__.py
index 8e3ae86bbe0..43d5cebebb2 100644
--- a/esphome/components/zephyr/__init__.py
+++ b/esphome/components/zephyr/__init__.py
@@ -213,9 +213,10 @@ def copy_files():
         zephyr_data()[KEY_OVERLAY],
     )
 
-    if zephyr_data()[KEY_BOOTLOADER] == BOOTLOADER_MCUBOOT or zephyr_data()[
-        KEY_BOARD
-    ] in ["xiao_ble"]:
+    if (
+        zephyr_data()[KEY_BOOTLOADER] == BOOTLOADER_MCUBOOT
+        or zephyr_data()[KEY_BOARD] == "xiao_ble"
+    ):
         fake_board_manifest = """
 {
     "frameworks": [
diff --git a/esphome/components/zephyr/preferences.cpp b/esphome/components/zephyr/preferences.cpp
index 311133a813b..f02fa16326c 100644
--- a/esphome/components/zephyr/preferences.cpp
+++ b/esphome/components/zephyr/preferences.cpp
@@ -152,10 +152,11 @@ class ZephyrPreferences : public ESPPreferences {
   }
 };
 
+static ZephyrPreferences s_preferences;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 void setup_preferences() {
-  auto *prefs = new ZephyrPreferences();  // NOLINT(cppcoreguidelines-owning-memory)
-  global_preferences = prefs;
-  prefs->open();
+  global_preferences = &s_preferences;
+  s_preferences.open();
 }
 
 }  // namespace zephyr
diff --git a/esphome/components/zigbee/__init__.py b/esphome/components/zigbee/__init__.py
index c044148b328..7e917a9d704 100644
--- a/esphome/components/zigbee/__init__.py
+++ b/esphome/components/zigbee/__init__.py
@@ -84,8 +84,8 @@ def validate_number_of_ep(config: ConfigType) -> None:
         raise cv.Invalid("At least one zigbee device need to be included")
     count = len(CORE.data[KEY_ZIGBEE][KEY_EP_NUMBER])
     if count == 1:
-        raise cv.Invalid(
-            "Single endpoint is not supported https://github.com/Koenkk/zigbee2mqtt/issues/29888"
+        _LOGGER.warning(
+            "Single endpoint requires ZHA or at leatst Zigbee2MQTT 2.8.0. For older versions of Zigbee2MQTT use multiple endpoints"
         )
     if count > CONF_MAX_EP_NUMBER and not CORE.testing_mode:
         raise cv.Invalid(f"Maximum number of end points is {CONF_MAX_EP_NUMBER}")
@@ -151,7 +151,7 @@ def consume_endpoint(config: ConfigType) -> ConfigType:
         return config
     if CONF_NAME in config and " " in config[CONF_NAME]:
         _LOGGER.warning(
-            "Spaces in '%s' work with ZHA but not Zigbee2MQTT. For Zigbee2MQTT use '%s'",
+            "Spaces in '%s' requires ZHA or at least Zigbee2MQTT 2.8.0. For older version of Zigbee2MQTT use '%s'",
             config[CONF_NAME],
             config[CONF_NAME].replace(" ", "_"),
         )
diff --git a/esphome/config_validation.py b/esphome/config_validation.py
index b7ab02013d3..55e13a7050a 100644
--- a/esphome/config_validation.py
+++ b/esphome/config_validation.py
@@ -682,7 +682,7 @@ def only_with_framework(
     def validator_(obj):
         if CORE.target_framework not in frameworks:
             err_str = f"This feature is only available with framework(s) {', '.join([framework.value for framework in frameworks])}"
-            if suggestion := suggestions.get(CORE.target_framework, None):
+            if suggestion := suggestions.get(CORE.target_framework):
                 (component, docs_path) = suggestion
                 err_str += f"\nPlease use '{component}'"
                 if docs_path:
diff --git a/esphome/core/__init__.py b/esphome/core/__init__.py
index 5308ad241eb..484f6793696 100644
--- a/esphome/core/__init__.py
+++ b/esphome/core/__init__.py
@@ -892,6 +892,16 @@ class EsphomeCore:
             library.name if "/" not in library.name else library.name.split("/")[-1]
         )
 
+        # Auto-enable Arduino libraries on ESP32 Arduino builds
+        if self.is_esp32 and self.using_arduino:
+            from esphome.components.esp32 import (
+                ARDUINO_DISABLED_LIBRARIES,
+                _enable_arduino_library,
+            )
+
+            if short_name in ARDUINO_DISABLED_LIBRARIES:
+                _enable_arduino_library(short_name)
+
         if short_name not in self.platformio_libraries:
             _LOGGER.debug("Adding library: %s", library)
             self.platformio_libraries[short_name] = library
diff --git a/esphome/core/application.cpp b/esphome/core/application.cpp
index 0e77be9ee45..0daabc02828 100644
--- a/esphome/core/application.cpp
+++ b/esphome/core/application.cpp
@@ -81,6 +81,10 @@ void Application::register_component_(Component *comp) {
       return;
     }
   }
+  if (this->components_.size() >= ESPHOME_COMPONENT_COUNT) {
+    ESP_LOGE(TAG, "Cannot register component %s - at capacity!", LOG_STR_ARG(comp->get_component_log_str()));
+    return;
+  }
   this->components_.push_back(comp);
 }
 void Application::setup() {
diff --git a/esphome/core/component.cpp b/esphome/core/component.cpp
index 98e8c02d078..f09a39d2bbb 100644
--- a/esphome/core/component.cpp
+++ b/esphome/core/component.cpp
@@ -359,6 +359,10 @@ void Component::defer(const std::string &name, std::function<void()> &&f) {  //
 void Component::defer(const char *name, std::function<void()> &&f) {  // NOLINT
   App.scheduler.set_timeout(this, name, 0, std::move(f));
 }
+void Component::defer(uint32_t id, std::function<void()> &&f) {  // NOLINT
+  App.scheduler.set_timeout(this, id, 0, std::move(f));
+}
+bool Component::cancel_defer(uint32_t id) { return App.scheduler.cancel_timeout(this, id); }
 void Component::set_timeout(uint32_t timeout, std::function<void()> &&f) {  // NOLINT
   App.scheduler.set_timeout(this, static_cast<const char *>(nullptr), timeout, std::move(f));
 }
diff --git a/esphome/core/component.h b/esphome/core/component.h
index 49349d41993..97f2afe1a4e 100644
--- a/esphome/core/component.h
+++ b/esphome/core/component.h
@@ -494,11 +494,15 @@ class Component {
   /// Defer a callback to the next loop() call.
   void defer(std::function<void()> &&f);  // NOLINT
 
+  /// Defer a callback with a numeric ID (zero heap allocation)
+  void defer(uint32_t id, std::function<void()> &&f);  // NOLINT
+
   /// Cancel a defer callback using the specified name, name must not be empty.
   // Remove before 2026.7.0
   ESPDEPRECATED("Use const char* overload instead. Removed in 2026.7.0", "2026.1.0")
   bool cancel_defer(const std::string &name);  // NOLINT
   bool cancel_defer(const char *name);         // NOLINT
+  bool cancel_defer(uint32_t id);              // NOLINT
 
   // Ordered for optimal packing on 32-bit systems
   const LogString *component_source_{nullptr};
diff --git a/esphome/core/defines.h b/esphome/core/defines.h
index e98cdd0ba0e..ee865a7e65a 100644
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -227,6 +227,8 @@
 #define USE_WIFI_SCAN_RESULTS_LISTENERS
 #define USE_WIFI_CONNECT_STATE_LISTENERS
 #define USE_WIFI_POWER_SAVE_LISTENERS
+#define USE_WIFI_CONNECT_TRIGGER
+#define USE_WIFI_DISCONNECT_TRIGGER
 #define ESPHOME_WIFI_IP_STATE_LISTENERS 2
 #define ESPHOME_WIFI_SCAN_RESULTS_LISTENERS 2
 #define ESPHOME_WIFI_CONNECT_STATE_LISTENERS 2
@@ -240,6 +242,8 @@
 #define USE_ETHERNET_KSZ8081
 #define USE_ETHERNET_MANUAL_IP
 #define USE_ETHERNET_IP_STATE_LISTENERS
+#define USE_ETHERNET_CONNECT_TRIGGER
+#define USE_ETHERNET_DISCONNECT_TRIGGER
 #define ESPHOME_ETHERNET_IP_STATE_LISTENERS 2
 #endif
 
diff --git a/esphome/dashboard/dns.py b/esphome/dashboard/dns.py
index 58867f7bc14..eb4a87dbfbd 100644
--- a/esphome/dashboard/dns.py
+++ b/esphome/dashboard/dns.py
@@ -3,11 +3,16 @@ from __future__ import annotations
 import asyncio
 from contextlib import suppress
 from ipaddress import ip_address
+import logging
 
 from icmplib import NameLookupError, async_resolve
 
 RESOLVE_TIMEOUT = 3.0
 
+_LOGGER = logging.getLogger(__name__)
+
+_RESOLVE_EXCEPTIONS = (TimeoutError, NameLookupError, UnicodeError)
+
 
 async def _async_resolve_wrapper(hostname: str) -> list[str] | Exception:
     """Wrap the icmplib async_resolve function."""
@@ -16,7 +21,21 @@ async def _async_resolve_wrapper(hostname: str) -> list[str] | Exception:
     try:
         async with asyncio.timeout(RESOLVE_TIMEOUT):
             return await async_resolve(hostname)
-    except (TimeoutError, NameLookupError, UnicodeError) as ex:
+    except _RESOLVE_EXCEPTIONS as ex:
+        # If the hostname ends with .local and resolution failed,
+        # try the bare hostname as a fallback since mDNS may not be
+        # working on the system but unicast DNS might resolve it
+        if hostname.endswith(".local"):
+            bare_hostname = hostname[:-6]  # Remove ".local"
+            try:
+                async with asyncio.timeout(RESOLVE_TIMEOUT):
+                    result = await async_resolve(bare_hostname)
+                    _LOGGER.debug(
+                        "Bare hostname %s resolved to %s", bare_hostname, result
+                    )
+                    return result
+            except _RESOLVE_EXCEPTIONS:
+                _LOGGER.debug("Bare hostname %s also failed to resolve", bare_hostname)
         return ex
 
 
diff --git a/esphome/enum.py b/esphome/enum.py
index 0fe30cf92ab..cf0d8b645be 100644
--- a/esphome/enum.py
+++ b/esphome/enum.py
@@ -2,19 +2,7 @@
 
 from __future__ import annotations
 
-from enum import Enum
-from typing import Any
+from enum import StrEnum as _StrEnum
 
-
-class StrEnum(str, Enum):
-    """Partial backport of Python 3.11's StrEnum for our basic use cases."""
-
-    def __new__(cls, value: str, *args: Any, **kwargs: Any) -> StrEnum:
-        """Create a new StrEnum instance."""
-        if not isinstance(value, str):
-            raise TypeError(f"{value!r} is not a string")
-        return super().__new__(cls, value, *args, **kwargs)
-
-    def __str__(self) -> str:
-        """Return self.value."""
-        return str(self.value)
+# Re-export StrEnum from standard library for backwards compatibility
+StrEnum = _StrEnum
diff --git a/esphome/wizard.py b/esphome/wizard.py
index d77450b04dc..4b748479960 100644
--- a/esphome/wizard.py
+++ b/esphome/wizard.py
@@ -1,5 +1,7 @@
+import base64
 from pathlib import Path
 import random
+import secrets
 import string
 from typing import Literal, NotRequired, TypedDict, Unpack
 import unicodedata
@@ -116,7 +118,6 @@ class WizardFileKwargs(TypedDict):
     board: str
     ssid: NotRequired[str]
     psk: NotRequired[str]
-    password: NotRequired[str]
     ota_password: NotRequired[str]
     api_encryption_key: NotRequired[str]
     friendly_name: NotRequired[str]
@@ -144,9 +145,7 @@ def wizard_file(**kwargs: Unpack[WizardFileKwargs]) -> str:
 
     config += API_CONFIG
 
-    # Configure API
-    if "password" in kwargs:
-        config += f'  password: "{kwargs["password"]}"\n'
+    # Configure API encryption
     if "api_encryption_key" in kwargs:
         config += f'  encryption:\n    key: "{kwargs["api_encryption_key"]}"\n'
 
@@ -155,8 +154,6 @@ def wizard_file(**kwargs: Unpack[WizardFileKwargs]) -> str:
     config += "  - platform: esphome\n"
     if "ota_password" in kwargs:
         config += f'    password: "{kwargs["ota_password"]}"'
-    elif "password" in kwargs:
-        config += f'    password: "{kwargs["password"]}"'
 
     # Configuring wifi
     config += "\n\nwifi:\n"
@@ -205,7 +202,6 @@ class WizardWriteKwargs(TypedDict):
     platform: NotRequired[str]
     ssid: NotRequired[str]
     psk: NotRequired[str]
-    password: NotRequired[str]
     ota_password: NotRequired[str]
     api_encryption_key: NotRequired[str]
     friendly_name: NotRequired[str]
@@ -232,7 +228,7 @@ def wizard_write(path: Path, **kwargs: Unpack[WizardWriteKwargs]) -> bool:
     else:  # "basic"
         board = kwargs["board"]
 
-        for key in ("ssid", "psk", "password", "ota_password"):
+        for key in ("ssid", "psk", "ota_password"):
             if key in kwargs:
                 kwargs[key] = sanitize_double_quotes(kwargs[key])
         if "platform" not in kwargs:
@@ -474,7 +470,7 @@ def wizard(path: Path) -> int:
     sleep(1)
 
     # Do not create wifi if the board does not support it
-    if board not in ["rpipico"]:
+    if board != "rpipico":
         safe_print_step(3, WIFI_BIG)
         safe_print("In this step, I'm going to create the configuration for WiFi.")
         safe_print()
@@ -522,26 +518,54 @@ def wizard(path: Path) -> int:
             "Almost there! ESPHome can automatically upload custom firmwares over WiFi "
             "(over the air) and integrates into Home Assistant with a native API."
         )
+        safe_print()
+        sleep(0.5)
+
+        # Generate encryption key (32 bytes, base64 encoded) for secure API communication
+        noise_psk = secrets.token_bytes(32)
+        api_encryption_key = base64.b64encode(noise_psk).decode()
+
         safe_print(
-            f"This can be insecure if you do not trust the WiFi network. Do you want to set a {color(AnsiFore.GREEN, 'password')} for connecting to this ESP?"
+            "For secure API communication, I've generated a random encryption key."
+        )
+        safe_print()
+        safe_print(
+            f"Your {color(AnsiFore.GREEN, 'API encryption key')} is: "
+            f"{color(AnsiFore.BOLD_WHITE, api_encryption_key)}"
+        )
+        safe_print()
+        safe_print("You'll need this key when adding the device to Home Assistant.")
+        sleep(1)
+
+        safe_print()
+        safe_print(
+            f"Do you want to set a {color(AnsiFore.GREEN, 'password')} for OTA updates? "
+            "This can be insecure if you do not trust the WiFi network."
         )
         safe_print()
         sleep(0.25)
         safe_print("Press ENTER for no password")
-        password = safe_input(color(AnsiFore.BOLD_WHITE, "(password): "))
+        ota_password = safe_input(color(AnsiFore.BOLD_WHITE, "(password): "))
     else:
-        ssid, password, psk = "", "", ""
+        ssid, psk = "", ""
+        api_encryption_key = None
+        ota_password = ""
 
-    if not wizard_write(
-        path=path,
-        name=name,
-        platform=platform,
-        board=board,
-        ssid=ssid,
-        psk=psk,
-        password=password,
-        type="basic",
-    ):
+    kwargs = {
+        "path": path,
+        "name": name,
+        "platform": platform,
+        "board": board,
+        "ssid": ssid,
+        "psk": psk,
+        "type": "basic",
+    }
+    if api_encryption_key:
+        kwargs["api_encryption_key"] = api_encryption_key
+    if ota_password:
+        kwargs["ota_password"] = ota_password
+
+    if not wizard_write(**kwargs):
         return 1
 
     safe_print()
diff --git a/esphome/writer.py b/esphome/writer.py
index cb9c9216934..661118e5183 100644
--- a/esphome/writer.py
+++ b/esphome/writer.py
@@ -421,6 +421,11 @@ def _rmtree_error_handler(
     func(path)
 
 
+def rmtree(path: Path | str) -> None:
+    """Remove a directory tree, handling read-only files on Windows."""
+    shutil.rmtree(path, onerror=_rmtree_error_handler)
+
+
 def clean_build(clear_pio_cache: bool = True):
     # Allow skipping cache cleaning for integration tests
     if os.environ.get("ESPHOME_SKIP_CLEAN_BUILD"):
@@ -430,11 +435,11 @@ def clean_build(clear_pio_cache: bool = True):
     pioenvs = CORE.relative_pioenvs_path()
     if pioenvs.is_dir():
         _LOGGER.info("Deleting %s", pioenvs)
-        shutil.rmtree(pioenvs, onerror=_rmtree_error_handler)
+        rmtree(pioenvs)
     piolibdeps = CORE.relative_piolibdeps_path()
     if piolibdeps.is_dir():
         _LOGGER.info("Deleting %s", piolibdeps)
-        shutil.rmtree(piolibdeps, onerror=_rmtree_error_handler)
+        rmtree(piolibdeps)
     dependencies_lock = CORE.relative_build_path("dependencies.lock")
     if dependencies_lock.is_file():
         _LOGGER.info("Deleting %s", dependencies_lock)
@@ -455,7 +460,7 @@ def clean_build(clear_pio_cache: bool = True):
         cache_dir = Path(config.get("platformio", "cache_dir"))
         if cache_dir.is_dir():
             _LOGGER.info("Deleting PlatformIO cache %s", cache_dir)
-            shutil.rmtree(cache_dir, onerror=_rmtree_error_handler)
+            rmtree(cache_dir)
 
 
 def clean_all(configuration: list[str]):
@@ -480,7 +485,7 @@ def clean_all(configuration: list[str]):
                 if item.is_file() and not item.name.endswith(".json"):
                     item.unlink()
                 elif item.is_dir() and item.name != "storage":
-                    shutil.rmtree(item, onerror=_rmtree_error_handler)
+                    rmtree(item)
 
     # Clean PlatformIO project files
     try:
@@ -494,7 +499,7 @@ def clean_all(configuration: list[str]):
             path = Path(config.get("platformio", pio_dir))
             if path.is_dir():
                 _LOGGER.info("Deleting PlatformIO %s %s", pio_dir, path)
-                shutil.rmtree(path, onerror=_rmtree_error_handler)
+                rmtree(path)
 
 
 GITIGNORE_CONTENT = """# Gitignore settings for ESPHome
diff --git a/requirements.txt b/requirements.txt
index 821324262bd..bb118c5f9ab 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -8,7 +8,7 @@ tornado==6.5.4
 tzlocal==5.3.1    # from time
 tzdata>=2021.1  # from time
 pyserial==3.5
-platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
+platformio==6.1.19
 esptool==5.1.0
 click==8.1.7
 esphome-dashboard==20260110.0
diff --git a/requirements_test.txt b/requirements_test.txt
index 5d907640214..2cf6f6456e6 100644
--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,6 +1,6 @@
 pylint==4.0.4
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.14.14  # also change in .pre-commit-config.yaml when updating
+ruff==0.15.0  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.21.2  # also change in .pre-commit-config.yaml when updating
 pre-commit
 
diff --git a/script/api_protobuf/api_protobuf.py b/script/api_protobuf/api_protobuf.py
index 7625458f9fa..4021a062ca4 100755
--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -280,7 +280,7 @@ class TypeInfo(ABC):
         """
         field_id_size = self.calculate_field_id_size()
         method = f"{base_method}_force" if force else base_method
-        value = value_expr if value_expr else name
+        value = value_expr or name
         return f"size.{method}({field_id_size}, {value});"
 
     @abstractmethod
@@ -2599,15 +2599,8 @@ static inline void append_field_prefix(DumpBuffer &out, const char *field_name,
   out.append(indent, ' ').append(field_name).append(": ");
 }
 
-static inline void append_with_newline(DumpBuffer &out, const char *str) {
-  out.append(str);
-  out.append("\\n");
-}
-
 static inline void append_uint(DumpBuffer &out, uint32_t value) {
-  char buf[16];
-  snprintf(buf, sizeof(buf), "%" PRIu32, value);
-  out.append(buf);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu32, value));
 }
 
 // RAII helper for message dump formatting
@@ -2625,31 +2618,23 @@ class MessageDumpHelper {
 
 // Helper functions to reduce code duplication in dump methods
 static void dump_field(DumpBuffer &out, const char *field_name, int32_t value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%" PRId32, value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRId32 "\\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, uint32_t value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%" PRIu32, value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu32 "\\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, float value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%g", value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%g\\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, uint64_t value, int indent = 2) {
-  char buffer[64];
   append_field_prefix(out, field_name, indent);
-  snprintf(buffer, 64, "%" PRIu64, value);
-  append_with_newline(out, buffer);
+  out.set_pos(buf_append_printf(out.data(), DumpBuffer::CAPACITY, out.pos(), "%" PRIu64 "\\n", value));
 }
 
 static void dump_field(DumpBuffer &out, const char *field_name, bool value, int indent = 2) {
@@ -2689,7 +2674,7 @@ static void dump_bytes_field(DumpBuffer &out, const char *field_name, const uint
   char hex_buf[format_hex_pretty_size(160)];
   append_field_prefix(out, field_name, indent);
   format_hex_pretty_to(hex_buf, data, len);
-  append_with_newline(out, hex_buf);
+  out.append(hex_buf).append("\\n");
 }
 
 """
@@ -2863,7 +2848,7 @@ static const char *const TAG = "api.service";
     hpp += "    DumpBuffer dump_buf;\n"
     hpp += "    this->log_send_message_(msg.message_name(), msg.dump_to(dump_buf));\n"
     hpp += "#endif\n"
-    hpp += "    return this->send_message_(msg, message_type);\n"
+    hpp += "    return this->send_message_impl(msg, message_type);\n"
     hpp += "  }\n\n"
 
     # Add logging helper method implementations to cpp
diff --git a/script/ci-custom.py b/script/ci-custom.py
index b146c9867ee..b5bec74fa72 100755
--- a/script/ci-custom.py
+++ b/script/ci-custom.py
@@ -756,6 +756,28 @@ def lint_no_sprintf(fname, match):
     )
 
 
+@lint_re_check(
+    # Match scanf family functions: scanf, sscanf, fscanf, vscanf, vsscanf, vfscanf
+    # Also match std:: prefixed versions
+    # [^\w] ensures we match function calls, not substrings
+    r"[^\w]((?:std::)?v?[fs]?scanf)\s*\(" + CPP_RE_EOL,
+    include=cpp_include,
+)
+def lint_no_scanf(fname, match):
+    func = match.group(1)
+    return (
+        f"{highlight(func + '()')} is not allowed in new ESPHome code. The scanf family "
+        f"pulls in ~7KB flash on ESP8266 and ~9KB on ESP32, and ESPHome doesn't otherwise "
+        f"need this code.\n"
+        f"Please use alternatives:\n"
+        f"  - {highlight('parse_number<T>(str)')} for parsing integers/floats from strings\n"
+        f"  - {highlight('strtol()/strtof()')} for C-style number parsing with error checking\n"
+        f"  - {highlight('parse_hex()')} for hex string parsing\n"
+        f"  - Manual parsing for simple fixed formats\n"
+        f"(If strictly necessary, add `// NOLINT` to the end of the line)"
+    )
+
+
 @lint_content_find_check(
     "ESP_LOG",
     include=["*.h", "*.tcc"],
diff --git a/script/merge_component_configs.py b/script/merge_component_configs.py
index 59774edba9e..5e98f1fef5a 100755
--- a/script/merge_component_configs.py
+++ b/script/merge_component_configs.py
@@ -249,7 +249,7 @@ def merge_component_configs(
 
         if all_packages is None:
             # First component - initialize package dict
-            all_packages = comp_packages if comp_packages else {}
+            all_packages = comp_packages or {}
         elif comp_packages:
             # Merge packages - combine all unique package types
             # If both have the same package type, verify they're identical
diff --git a/tests/component_tests/epaper_spi/test_init.py b/tests/component_tests/epaper_spi/test_init.py
index 71e66cd0439..a9f5735fcab 100644
--- a/tests/component_tests/epaper_spi/test_init.py
+++ b/tests/component_tests/epaper_spi/test_init.py
@@ -289,3 +289,56 @@ def test_model_with_full_update_every(
             "full_update_every": 10,
         }
     )
+
+
+def test_busy_pin_input_mode_ssd1677(
+    set_core_config: SetCoreConfigCallable,
+    set_component_config: Callable[[str, Any], None],
+) -> None:
+    """Test that busy_pin has input mode and cs/dc/reset pins have output mode for ssd1677."""
+    set_core_config(
+        PlatformFramework.ESP32_IDF,
+        platform_data={KEY_BOARD: "esp32dev", KEY_VARIANT: VARIANT_ESP32},
+    )
+
+    # Configure SPI component which is required by epaper_spi
+    set_component_config("spi", {"id": "spi_bus", "clk_pin": 18, "mosi_pin": 19})
+
+    result = run_schema_validation(
+        {
+            "id": "test_display",
+            "model": "ssd1677",
+            "dc_pin": 21,
+            "busy_pin": 22,
+            "reset_pin": 23,
+            "cs_pin": 5,
+            "dimensions": {
+                "width": 200,
+                "height": 200,
+            },
+        }
+    )
+
+    # Verify that busy_pin has input mode set
+    assert CONF_BUSY_PIN in result
+    busy_pin_config = result[CONF_BUSY_PIN]
+    assert "mode" in busy_pin_config
+    assert busy_pin_config["mode"]["input"] is True
+
+    # Verify that cs_pin has output mode set
+    assert CONF_CS_PIN in result
+    cs_pin_config = result[CONF_CS_PIN]
+    assert "mode" in cs_pin_config
+    assert cs_pin_config["mode"]["output"] is True
+
+    # Verify that dc_pin has output mode set
+    assert CONF_DC_PIN in result
+    dc_pin_config = result[CONF_DC_PIN]
+    assert "mode" in dc_pin_config
+    assert dc_pin_config["mode"]["output"] is True
+
+    # Verify that reset_pin has output mode set
+    assert CONF_RESET_PIN in result
+    reset_pin_config = result[CONF_RESET_PIN]
+    assert "mode" in reset_pin_config
+    assert reset_pin_config["mode"]["output"] is True
diff --git a/tests/components/adc/test.esp32-c2-idf.yaml b/tests/components/adc/test.esp32-c2-idf.yaml
new file mode 100644
index 00000000000..e764f0fe210
--- /dev/null
+++ b/tests/components/adc/test.esp32-c2-idf.yaml
@@ -0,0 +1,12 @@
+sensor:
+  - id: my_sensor
+    platform: adc
+    pin: GPIO1
+    name: ADC Test sensor
+    update_interval: "1:01"
+    attenuation: 2.5db
+    unit_of_measurement: "°C"
+    icon: "mdi:water-percent"
+    accuracy_decimals: 5
+    setup_priority: -100
+    force_update: true
diff --git a/tests/components/dlms_meter/common-generic.yaml b/tests/components/dlms_meter/common-generic.yaml
new file mode 100644
index 00000000000..edb1c66f0f5
--- /dev/null
+++ b/tests/components/dlms_meter/common-generic.yaml
@@ -0,0 +1,11 @@
+dlms_meter:
+  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"   # change this to your decryption key!
+
+sensor:
+  - platform: dlms_meter
+    reactive_energy_plus:
+      name: "Reactive energy taken from grid"
+    reactive_energy_minus:
+      name: "Reactive energy put into grid"
+
+<<: !include common.yaml
diff --git a/tests/components/dlms_meter/common-netznoe.yaml b/tests/components/dlms_meter/common-netznoe.yaml
new file mode 100644
index 00000000000..db064b64f9d
--- /dev/null
+++ b/tests/components/dlms_meter/common-netznoe.yaml
@@ -0,0 +1,17 @@
+dlms_meter:
+  decryption_key: "36C66639E48A8CA4D6BC8B282A793BBB"  # change this to your decryption key!
+  provider: netznoe                                   # (optional) key - only set if using evn
+
+sensor:
+  - platform: dlms_meter
+    # EVN
+    power_factor:
+      name: "Power Factor"
+
+text_sensor:
+  - platform: dlms_meter
+    # EVN
+    meternumber:
+      name: "meterNumber"
+
+<<: !include common.yaml
diff --git a/tests/components/dlms_meter/common.yaml b/tests/components/dlms_meter/common.yaml
new file mode 100644
index 00000000000..6aa4e1b0ff9
--- /dev/null
+++ b/tests/components/dlms_meter/common.yaml
@@ -0,0 +1,27 @@
+sensor:
+  - platform: dlms_meter
+    voltage_l1:
+      name: "Voltage L1"
+    voltage_l2:
+      name: "Voltage L2"
+    voltage_l3:
+      name: "Voltage L3"
+    current_l1:
+      name: "Current L1"
+    current_l2:
+      name: "Current L2"
+    current_l3:
+      name: "Current L3"
+    active_power_plus:
+      name: "Active power taken from grid"
+    active_power_minus:
+      name: "Active power put into grid"
+    active_energy_plus:
+      name: "Active energy taken from grid"
+    active_energy_minus:
+      name: "Active energy put into grid"
+
+text_sensor:
+  - platform: dlms_meter
+    timestamp:
+      name: "timestamp"
diff --git a/tests/components/dlms_meter/test.esp32-ard.yaml b/tests/components/dlms_meter/test.esp32-ard.yaml
new file mode 100644
index 00000000000..c9910aa600b
--- /dev/null
+++ b/tests/components/dlms_meter/test.esp32-ard.yaml
@@ -0,0 +1,4 @@
+packages:
+  uart_2400: !include ../../test_build_components/common/uart_2400/esp32-ard.yaml
+
+<<: !include common-generic.yaml
diff --git a/tests/components/dlms_meter/test.esp32-idf.yaml b/tests/components/dlms_meter/test.esp32-idf.yaml
new file mode 100644
index 00000000000..1547532f1e0
--- /dev/null
+++ b/tests/components/dlms_meter/test.esp32-idf.yaml
@@ -0,0 +1,4 @@
+packages:
+  uart_2400: !include ../../test_build_components/common/uart_2400/esp32-idf.yaml
+
+<<: !include common-netznoe.yaml
diff --git a/tests/components/dlms_meter/test.esp8266-ard.yaml b/tests/components/dlms_meter/test.esp8266-ard.yaml
new file mode 100644
index 00000000000..119a1978de4
--- /dev/null
+++ b/tests/components/dlms_meter/test.esp8266-ard.yaml
@@ -0,0 +1,4 @@
+packages:
+  uart_2400: !include ../../test_build_components/common/uart_2400/esp8266-ard.yaml
+
+<<: !include common-generic.yaml
diff --git a/tests/components/ethernet/common-dm9051.yaml b/tests/components/ethernet/common-dm9051.yaml
index 4526e7732db..bb8c74b820f 100644
--- a/tests/components/ethernet/common-dm9051.yaml
+++ b/tests/components/ethernet/common-dm9051.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-dp83848.yaml b/tests/components/ethernet/common-dp83848.yaml
index f9069c5fb93..809613c79d9 100644
--- a/tests/components/ethernet/common-dp83848.yaml
+++ b/tests/components/ethernet/common-dp83848.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-ip101.yaml b/tests/components/ethernet/common-ip101.yaml
index cea7a5cc355..41716a7850a 100644
--- a/tests/components/ethernet/common-ip101.yaml
+++ b/tests/components/ethernet/common-ip101.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-jl1101.yaml b/tests/components/ethernet/common-jl1101.yaml
index 7b0a2dfdc4c..d70a576c816 100644
--- a/tests/components/ethernet/common-jl1101.yaml
+++ b/tests/components/ethernet/common-jl1101.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-ksz8081.yaml b/tests/components/ethernet/common-ksz8081.yaml
index 65541832c2e..e2add8d370a 100644
--- a/tests/components/ethernet/common-ksz8081.yaml
+++ b/tests/components/ethernet/common-ksz8081.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-ksz8081rna.yaml b/tests/components/ethernet/common-ksz8081rna.yaml
index f04cba15b20..1bb404f720b 100644
--- a/tests/components/ethernet/common-ksz8081rna.yaml
+++ b/tests/components/ethernet/common-ksz8081rna.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-lan8670.yaml b/tests/components/ethernet/common-lan8670.yaml
index fb751ebd232..ae4953974c0 100644
--- a/tests/components/ethernet/common-lan8670.yaml
+++ b/tests/components/ethernet/common-lan8670.yaml
@@ -12,3 +12,7 @@ ethernet:
     gateway: 192.168.178.1
     subnet: 255.255.255.0
   domain: .local
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-lan8720.yaml b/tests/components/ethernet/common-lan8720.yaml
index 838d57df28e..742800fdf48 100644
--- a/tests/components/ethernet/common-lan8720.yaml
+++ b/tests/components/ethernet/common-lan8720.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-openeth.yaml b/tests/components/ethernet/common-openeth.yaml
index fbb75795989..26595dbc523 100644
--- a/tests/components/ethernet/common-openeth.yaml
+++ b/tests/components/ethernet/common-openeth.yaml
@@ -1,2 +1,6 @@
 ethernet:
   type: OPENETH
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-rtl8201.yaml b/tests/components/ethernet/common-rtl8201.yaml
index 0e7cbe73c6c..d5a60f6e983 100644
--- a/tests/components/ethernet/common-rtl8201.yaml
+++ b/tests/components/ethernet/common-rtl8201.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/ethernet/common-w5500.yaml b/tests/components/ethernet/common-w5500.yaml
index b3e96f000db..1f8b8650dd0 100644
--- a/tests/components/ethernet/common-w5500.yaml
+++ b/tests/components/ethernet/common-w5500.yaml
@@ -13,3 +13,7 @@ ethernet:
     subnet: 255.255.255.0
   domain: .local
   mac_address: "02:AA:BB:CC:DD:01"
+  on_connect:
+    - logger.log: "Ethernet connected!"
+  on_disconnect:
+    - logger.log: "Ethernet disconnected!"
diff --git a/tests/components/i2s_audio/test.esp32-ard.yaml b/tests/components/i2s_audio/test.esp32-ard.yaml
new file mode 100644
index 00000000000..4276b4f9225
--- /dev/null
+++ b/tests/components/i2s_audio/test.esp32-ard.yaml
@@ -0,0 +1,16 @@
+substitutions:
+  i2s_bclk_pin: GPIO15
+  i2s_lrclk_pin: GPIO4
+  i2s_mclk_pin: GPIO5
+
+<<: !include common.yaml
+
+wifi:
+  ssid: test
+  password: test1234
+
+media_player:
+  - platform: i2s_audio
+    name: Test Media Player
+    dac_type: internal
+    mode: stereo
diff --git a/tests/components/key_collector/common.yaml b/tests/components/key_collector/common.yaml
index 12e541c8656..43a0478a18d 100644
--- a/tests/components/key_collector/common.yaml
+++ b/tests/components/key_collector/common.yaml
@@ -18,14 +18,23 @@ key_collector:
       - logger.log:
           format: "input progress: '%s', started by '%c'"
           args: ['x.c_str()', "(start == 0 ? '~' : start)"]
+      - logger.log:
+          format: "second listener - progress: '%s'"
+          args: ['x.c_str()']
     on_result:
       - logger.log:
           format: "input result: '%s', started by '%c', ended by '%c'"
           args: ['x.c_str()', "(start == 0 ? '~' : start)", "(end == 0 ? '~' : end)"]
+      - logger.log:
+          format: "second listener - result: '%s'"
+          args: ['x.c_str()']
     on_timeout:
       - logger.log:
           format: "input timeout: '%s', started by '%c'"
           args: ['x.c_str()', "(start == 0 ? '~' : start)"]
+      - logger.log:
+          format: "second listener - timeout: '%s'"
+          args: ['x.c_str()']
     enable_on_boot: false
 
 button:
@@ -34,3 +43,8 @@ button:
     on_press:
       - key_collector.enable:
       - key_collector.disable:
+
+text_sensor:
+  - platform: key_collector
+    id: collected_keys
+    source_id: reader
diff --git a/tests/components/template/common-base.yaml b/tests/components/template/common-base.yaml
index 9dc65fbab8e..d1849efaf75 100644
--- a/tests/components/template/common-base.yaml
+++ b/tests/components/template/common-base.yaml
@@ -245,6 +245,44 @@ cover:
     stop_action:
       - logger.log: stop_action
     optimistic: true
+  - platform: template
+    name: "Template Cover with Triggers"
+    id: template_cover_with_triggers
+    lambda: |-
+      if (id(some_binary_sensor).state) {
+        return COVER_OPEN;
+      }
+      return COVER_CLOSED;
+    open_action:
+      - logger.log: open_action
+    close_action:
+      - logger.log: close_action
+    stop_action:
+      - logger.log: stop_action
+    optimistic: true
+    on_open:
+      - logger.log: "Cover on_open (deprecated)"
+    on_opened:
+      - logger.log: "Cover fully opened"
+    on_closed:
+      - logger.log: "Cover fully closed"
+    on_opening:
+      - logger.log: "Cover started opening"
+    on_closing:
+      - logger.log: "Cover started closing"
+    on_idle:
+      - logger.log: "Cover stopped moving"
+      - logger.log: "Cover stopped moving"
+      - if:
+          condition:
+            cover.is_open: template_cover_with_triggers
+          then:
+            logger.log: Cover is open
+      - if:
+          condition:
+            cover.is_closed: template_cover_with_triggers
+          then:
+            logger.log: Cover is closed
 
 number:
   - platform: template
@@ -296,6 +334,16 @@ select:
           // Migration guide: Store in std::string
           std::string stored_option(id(template_select).current_option());
           ESP_LOGI("test", "Stored: %s", stored_option.c_str());
+  - platform: template
+    id: template_select_with_action
+    name: "Template select with action"
+    options:
+      - option_a
+      - option_b
+    set_action:
+      - logger.log:
+          format: "Selected: %s"
+          args: ["x.c_str()"]
 
 lock:
   - platform: template
diff --git a/tests/components/vbus/common.yaml b/tests/components/vbus/common.yaml
index 33d9e2935df..5c771be922b 100644
--- a/tests/components/vbus/common.yaml
+++ b/tests/components/vbus/common.yaml
@@ -4,11 +4,21 @@ binary_sensor:
   - platform: vbus
     model: deltasol_bs_plus
     relay1:
-      name: Relay 1 On
+      name: BS Plus Relay 1 On
     relay2:
-      name: Relay 2 On
+      name: BS Plus Relay 2 On
     sensor1_error:
-      name: Sensor 1 Error
+      name: BS Plus Sensor 1 Error
+  - platform: vbus
+    model: deltasol_bs2
+    sensor1_error:
+      name: BS2 Sensor 1 Error
+    sensor2_error:
+      name: BS2 Sensor 2 Error
+    sensor3_error:
+      name: BS2 Sensor 3 Error
+    sensor4_error:
+      name: BS2 Sensor 4 Error
   - platform: vbus
     model: custom
     command: 0x100
@@ -23,14 +33,36 @@ sensor:
   - platform: vbus
     model: deltasol c
     temperature_1:
-      name: Temperature 1
+      name: DeltaSol C Temperature 1
     temperature_2:
-      name: Temperature 2
+      name: DeltaSol C Temperature 2
     temperature_3:
-      name: Temperature 3
+      name: DeltaSol C Temperature 3
     operating_hours_1:
-      name: Operating Hours 1
+      name: DeltaSol C Operating Hours 1
     heat_quantity:
-      name: Heat Quantity
+      name: DeltaSol C Heat Quantity
     time:
-      name: System Time
+      name: DeltaSol C System Time
+  - platform: vbus
+    model: deltasol_bs2
+    temperature_1:
+      name: BS2 Temperature 1
+    temperature_2:
+      name: BS2 Temperature 2
+    temperature_3:
+      name: BS2 Temperature 3
+    temperature_4:
+      name: BS2 Temperature 4
+    pump_speed_1:
+      name: BS2 Pump Speed 1
+    pump_speed_2:
+      name: BS2 Pump Speed 2
+    operating_hours_1:
+      name: BS2 Operating Hours 1
+    operating_hours_2:
+      name: BS2 Operating Hours 2
+    heat_quantity:
+      name: BS2 Heat Quantity
+    version:
+      name: BS2 Firmware Version
diff --git a/tests/components/wifi/common.yaml b/tests/components/wifi/common.yaml
index 7ce74ab00d3..10b68347eb6 100644
--- a/tests/components/wifi/common.yaml
+++ b/tests/components/wifi/common.yaml
@@ -26,3 +26,7 @@ wifi:
     - ssid: MySSID3
       password: password3
       priority: 0
+  on_connect:
+    - logger.log: "WiFi connected!"
+  on_disconnect:
+    - logger.log: "WiFi disconnected!"
diff --git a/tests/dashboard/status/test_dns.py b/tests/dashboard/status/test_dns.py
index 9ca48ba2d83..f7c49920799 100644
--- a/tests/dashboard/status/test_dns.py
+++ b/tests/dashboard/status/test_dns.py
@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import time
-from unittest.mock import patch
+from unittest.mock import AsyncMock, patch
 
+from icmplib import NameLookupError
 import pytest
 
-from esphome.dashboard.dns import DNSCache
+from esphome.dashboard.dns import DNSCache, _async_resolve_wrapper
 
 
 @pytest.fixture
@@ -119,3 +120,80 @@ def test_async_resolve_not_called(dns_cache_fixture: DNSCache) -> None:
         result = dns_cache_fixture.get_cached_addresses("valid.com", now)
         assert result == ["192.168.1.10"]
         mock_resolve.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_async_resolve_wrapper_ip_address() -> None:
+    """Test _async_resolve_wrapper returns IP address directly."""
+    result = await _async_resolve_wrapper("192.168.1.10")
+    assert result == ["192.168.1.10"]
+
+    result = await _async_resolve_wrapper("2001:db8::1")
+    assert result == ["2001:db8::1"]
+
+
+@pytest.mark.asyncio
+async def test_async_resolve_wrapper_local_fallback_success() -> None:
+    """Test _async_resolve_wrapper falls back to bare hostname for .local."""
+    mock_resolve = AsyncMock()
+    # First call (device.local) fails, second call (device) succeeds
+    mock_resolve.side_effect = [
+        NameLookupError("device.local"),
+        ["192.168.1.50"],
+    ]
+
+    with patch("esphome.dashboard.dns.async_resolve", mock_resolve):
+        result = await _async_resolve_wrapper("device.local")
+
+    assert result == ["192.168.1.50"]
+    assert mock_resolve.call_count == 2
+    mock_resolve.assert_any_call("device.local")
+    mock_resolve.assert_any_call("device")
+
+
+@pytest.mark.asyncio
+async def test_async_resolve_wrapper_local_fallback_both_fail() -> None:
+    """Test _async_resolve_wrapper returns exception when both fail."""
+    mock_resolve = AsyncMock()
+    original_exception = NameLookupError("device.local")
+    mock_resolve.side_effect = [
+        original_exception,
+        NameLookupError("device"),
+    ]
+
+    with patch("esphome.dashboard.dns.async_resolve", mock_resolve):
+        result = await _async_resolve_wrapper("device.local")
+
+    # Should return the original exception, not the fallback exception
+    assert result is original_exception
+    assert mock_resolve.call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_async_resolve_wrapper_non_local_no_fallback() -> None:
+    """Test _async_resolve_wrapper doesn't fallback for non-.local hostnames."""
+    mock_resolve = AsyncMock()
+    original_exception = NameLookupError("device.example.com")
+    mock_resolve.side_effect = original_exception
+
+    with patch("esphome.dashboard.dns.async_resolve", mock_resolve):
+        result = await _async_resolve_wrapper("device.example.com")
+
+    assert result is original_exception
+    # Should only try the original hostname, no fallback
+    assert mock_resolve.call_count == 1
+    mock_resolve.assert_called_once_with("device.example.com")
+
+
+@pytest.mark.asyncio
+async def test_async_resolve_wrapper_local_success_no_fallback() -> None:
+    """Test _async_resolve_wrapper doesn't fallback when .local succeeds."""
+    mock_resolve = AsyncMock(return_value=["192.168.1.50"])
+
+    with patch("esphome.dashboard.dns.async_resolve", mock_resolve):
+        result = await _async_resolve_wrapper("device.local")
+
+    assert result == ["192.168.1.50"]
+    # Should only try once since it succeeded
+    assert mock_resolve.call_count == 1
+    mock_resolve.assert_called_once_with("device.local")
diff --git a/tests/integration/fixtures/scheduler_numeric_id_test.yaml b/tests/integration/fixtures/scheduler_numeric_id_test.yaml
index bf60f2fda92..1669f026f5c 100644
--- a/tests/integration/fixtures/scheduler_numeric_id_test.yaml
+++ b/tests/integration/fixtures/scheduler_numeric_id_test.yaml
@@ -20,6 +20,9 @@ globals:
   - id: retry_counter
     type: int
     initial_value: '0'
+  - id: defer_counter
+    type: int
+    initial_value: '0'
   - id: tests_done
     type: bool
     initial_value: 'false'
@@ -136,11 +139,49 @@ script:
           App.scheduler.cancel_retry(component1, 6002U);
           ESP_LOGI("test", "Cancelled numeric retry 6002");
 
+          // Test 12: defer with numeric ID (Component method)
+          class TestDeferComponent : public Component {
+          public:
+            void test_defer_methods() {
+              // Test defer with uint32_t ID - should execute on next loop
+              this->defer(7001U, []() {
+                ESP_LOGI("test", "Component numeric defer 7001 fired");
+                id(defer_counter) += 1;
+              });
+
+              // Test another defer with numeric ID
+              this->defer(7002U, []() {
+                ESP_LOGI("test", "Component numeric defer 7002 fired");
+                id(defer_counter) += 1;
+              });
+            }
+          };
+
+          static TestDeferComponent test_defer_component;
+          test_defer_component.test_defer_methods();
+
+          // Test 13: cancel_defer with numeric ID (Component method)
+          class TestCancelDeferComponent : public Component {
+          public:
+            void test_cancel_defer() {
+              // Set a defer that should be cancelled
+              this->defer(8001U, []() {
+                ESP_LOGE("test", "ERROR: Numeric defer 8001 should have been cancelled");
+              });
+              // Cancel it immediately
+              bool cancelled = this->cancel_defer(8001U);
+              ESP_LOGI("test", "Cancelled numeric defer 8001: %s", cancelled ? "true" : "false");
+            }
+          };
+
+          static TestCancelDeferComponent test_cancel_defer_component;
+          test_cancel_defer_component.test_cancel_defer();
+
   - id: report_results
     then:
       - lambda: |-
-          ESP_LOGI("test", "Final results - Timeouts: %d, Intervals: %d, Retries: %d",
-                   id(timeout_counter), id(interval_counter), id(retry_counter));
+          ESP_LOGI("test", "Final results - Timeouts: %d, Intervals: %d, Retries: %d, Defers: %d",
+                   id(timeout_counter), id(interval_counter), id(retry_counter), id(defer_counter));
 
 sensor:
   - platform: template
diff --git a/tests/integration/fixtures/select_stringref_trigger.yaml b/tests/integration/fixtures/select_stringref_trigger.yaml
index bb1e1fd8433..5858e2f5291 100644
--- a/tests/integration/fixtures/select_stringref_trigger.yaml
+++ b/tests/integration/fixtures/select_stringref_trigger.yaml
@@ -56,7 +56,21 @@ select:
             std::string prefix = x.substr(0, 6);
             ESP_LOGI("test", "Substr prefix: %s", prefix.c_str());
 
-  # Second select with numeric options to test ADL functions
+  # Second select with set_action trigger (uses TemplateSelectWithSetAction subclass)
+  - platform: template
+    name: "Action Select"
+    id: action_select
+    options:
+      - "Action A"
+      - "Action B"
+    set_action:
+      then:
+        # Test: set_action trigger receives StringRef
+        - logger.log:
+            format: "set_action triggered: %s"
+            args: ['x.c_str()']
+
+  # Third select with numeric options to test ADL functions
   - platform: template
     name: "Baud Rate"
     id: baud_select
diff --git a/tests/integration/test_scheduler_numeric_id_test.py b/tests/integration/test_scheduler_numeric_id_test.py
index 510256b9a49..c1958db6857 100644
--- a/tests/integration/test_scheduler_numeric_id_test.py
+++ b/tests/integration/test_scheduler_numeric_id_test.py
@@ -19,6 +19,7 @@ async def test_scheduler_numeric_id_test(
     timeout_count = 0
     interval_count = 0
     retry_count = 0
+    defer_count = 0
 
     # Events for each test completion
     numeric_timeout_1001_fired = asyncio.Event()
@@ -33,6 +34,9 @@ async def test_scheduler_numeric_id_test(
     max_id_timeout_fired = asyncio.Event()
     numeric_retry_done = asyncio.Event()
     numeric_retry_cancelled = asyncio.Event()
+    numeric_defer_7001_fired = asyncio.Event()
+    numeric_defer_7002_fired = asyncio.Event()
+    numeric_defer_cancelled = asyncio.Event()
     final_results_logged = asyncio.Event()
 
     # Track interval counts
@@ -40,7 +44,7 @@ async def test_scheduler_numeric_id_test(
     numeric_retry_count = 0
 
     def on_log_line(line: str) -> None:
-        nonlocal timeout_count, interval_count, retry_count
+        nonlocal timeout_count, interval_count, retry_count, defer_count
         nonlocal numeric_interval_count, numeric_retry_count
 
         # Strip ANSI color codes
@@ -105,15 +109,27 @@ async def test_scheduler_numeric_id_test(
         elif "Cancelled numeric retry 6002" in clean_line:
             numeric_retry_cancelled.set()
 
+        # Check for numeric defer tests
+        elif "Component numeric defer 7001 fired" in clean_line:
+            numeric_defer_7001_fired.set()
+
+        elif "Component numeric defer 7002 fired" in clean_line:
+            numeric_defer_7002_fired.set()
+
+        elif "Cancelled numeric defer 8001: true" in clean_line:
+            numeric_defer_cancelled.set()
+
         # Check for final results
         elif "Final results" in clean_line:
             match = re.search(
-                r"Timeouts: (\d+), Intervals: (\d+), Retries: (\d+)", clean_line
+                r"Timeouts: (\d+), Intervals: (\d+), Retries: (\d+), Defers: (\d+)",
+                clean_line,
             )
             if match:
                 timeout_count = int(match.group(1))
                 interval_count = int(match.group(2))
                 retry_count = int(match.group(3))
+                defer_count = int(match.group(4))
                 final_results_logged.set()
 
     async with (
@@ -201,6 +217,23 @@ async def test_scheduler_numeric_id_test(
             "Numeric retry 6002 should have been cancelled"
         )
 
+        # Wait for numeric defer tests
+        try:
+            await asyncio.wait_for(numeric_defer_7001_fired.wait(), timeout=0.5)
+        except TimeoutError:
+            pytest.fail("Numeric defer 7001 did not fire within 0.5 seconds")
+
+        try:
+            await asyncio.wait_for(numeric_defer_7002_fired.wait(), timeout=0.5)
+        except TimeoutError:
+            pytest.fail("Numeric defer 7002 did not fire within 0.5 seconds")
+
+        # Verify numeric defer was cancelled
+        try:
+            await asyncio.wait_for(numeric_defer_cancelled.wait(), timeout=0.5)
+        except TimeoutError:
+            pytest.fail("Numeric defer 8001 cancel confirmation not received")
+
         # Wait for final results
         try:
             await asyncio.wait_for(final_results_logged.wait(), timeout=3.0)
@@ -215,3 +248,4 @@ async def test_scheduler_numeric_id_test(
         assert retry_count >= 2, (
             f"Expected at least 2 retry attempts, got {retry_count}"
         )
+        assert defer_count >= 2, f"Expected at least 2 defer fires, got {defer_count}"
diff --git a/tests/integration/test_script_queued.py b/tests/integration/test_script_queued.py
index c86c2897191..84c7f950b63 100644
--- a/tests/integration/test_script_queued.py
+++ b/tests/integration/test_script_queued.py
@@ -98,9 +98,11 @@ async def test_script_queued(
             if not test3_complete.done():
                 loop.call_later(
                     0.3,
-                    lambda: test3_complete.set_result(True)
-                    if not test3_complete.done()
-                    else None,
+                    lambda: (
+                        test3_complete.set_result(True)
+                        if not test3_complete.done()
+                        else None
+                    ),
                 )
 
         # Test 4: Rejection
diff --git a/tests/integration/test_select_stringref_trigger.py b/tests/integration/test_select_stringref_trigger.py
index 7fc72a22901..5baba9c7f56 100644
--- a/tests/integration/test_select_stringref_trigger.py
+++ b/tests/integration/test_select_stringref_trigger.py
@@ -28,6 +28,8 @@ async def test_select_stringref_trigger(
     find_substr_future = loop.create_future()
     find_char_future = loop.create_future()
     substr_future = loop.create_future()
+    # set_action trigger (TemplateSelectWithSetAction subclass)
+    set_action_future = loop.create_future()
     # ADL functions
     stoi_future = loop.create_future()
     stol_future = loop.create_future()
@@ -43,6 +45,8 @@ async def test_select_stringref_trigger(
     find_substr_pattern = re.compile(r"Found 'Option' in value")
     find_char_pattern = re.compile(r"Space at position: 6")  # space at index 6
     substr_pattern = re.compile(r"Substr prefix: Option")
+    # set_action trigger pattern (TemplateSelectWithSetAction subclass)
+    set_action_pattern = re.compile(r"set_action triggered: Action B")
     # ADL function patterns (115200 from baud rate select)
     stoi_pattern = re.compile(r"stoi result: 115200")
     stol_pattern = re.compile(r"stol result: 115200")
@@ -67,6 +71,9 @@ async def test_select_stringref_trigger(
             find_char_future.set_result(True)
         if not substr_future.done() and substr_pattern.search(line):
             substr_future.set_result(True)
+        # set_action trigger
+        if not set_action_future.done() and set_action_pattern.search(line):
+            set_action_future.set_result(True)
         # ADL functions
         if not stoi_future.done() and stoi_pattern.search(line):
             stoi_future.set_result(True)
@@ -89,22 +96,21 @@ async def test_select_stringref_trigger(
         # List entities to find our select
         entities, _ = await client.list_entities_services()
 
-        select_entity = next(
-            (e for e in entities if hasattr(e, "options") and e.name == "Test Select"),
-            None,
-        )
+        select_entity = next((e for e in entities if e.name == "Test Select"), None)
         assert select_entity is not None, "Test Select entity not found"
 
-        baud_entity = next(
-            (e for e in entities if hasattr(e, "options") and e.name == "Baud Rate"),
-            None,
-        )
+        baud_entity = next((e for e in entities if e.name == "Baud Rate"), None)
         assert baud_entity is not None, "Baud Rate entity not found"
 
+        action_entity = next((e for e in entities if e.name == "Action Select"), None)
+        assert action_entity is not None, "Action Select entity not found"
+
         # Change select to Option B - this should trigger on_value with StringRef
         client.select_command(select_entity.key, "Option B")
         # Change baud to 115200 - this tests ADL functions (stoi, stol, stof, stod)
         client.select_command(baud_entity.key, "115200")
+        # Change action select - tests set_action trigger (TemplateSelectWithSetAction)
+        client.select_command(action_entity.key, "Action B")
 
         # Wait for all log messages confirming StringRef operations work
         try:
@@ -118,6 +124,7 @@ async def test_select_stringref_trigger(
                     find_substr_future,
                     find_char_future,
                     substr_future,
+                    set_action_future,
                     stoi_future,
                     stol_future,
                     stof_future,
@@ -135,6 +142,7 @@ async def test_select_stringref_trigger(
                 "find_substr": find_substr_future.done(),
                 "find_char": find_char_future.done(),
                 "substr": substr_future.done(),
+                "set_action": set_action_future.done(),
                 "stoi": stoi_future.done(),
                 "stol": stol_future.done(),
                 "stof": stof_future.done(),
diff --git a/tests/script/test_helpers.py b/tests/script/test_helpers.py
index c51273f2980..7e60ba41fcd 100644
--- a/tests/script/test_helpers.py
+++ b/tests/script/test_helpers.py
@@ -1011,8 +1011,8 @@ def test_get_all_dependencies_handles_missing_components() -> None:
         comp.dependencies = ["missing_comp"]
         comp.auto_load = []
 
-        mock_get_component.side_effect = (
-            lambda name: comp if name == "existing" else None
+        mock_get_component.side_effect = lambda name: (
+            comp if name == "existing" else None
         )
 
         result = helpers.get_all_dependencies({"existing", "nonexistent"})
diff --git a/tests/test_build_components/build_components_base.esp32-c2-idf.yaml b/tests/test_build_components/build_components_base.esp32-c2-idf.yaml
new file mode 100644
index 00000000000..59691be7aa9
--- /dev/null
+++ b/tests/test_build_components/build_components_base.esp32-c2-idf.yaml
@@ -0,0 +1,20 @@
+esphome:
+  name: componenttestesp32c2idf
+  friendly_name: $component_name
+
+esp32:
+  board: esp32-c2-devkitm-1
+  framework:
+    type: esp-idf
+  # Use custom partition table with larger app partition (3MB)
+  # Default IDF partitions only allow 1.75MB which is too small for grouped tests
+  partitions: ../partitions_testing.csv
+
+logger:
+  level: VERY_VERBOSE
+
+packages:
+  component_under_test: !include
+    file: $component_test_file
+    vars:
+      component_test_file: $component_test_file
diff --git a/tests/test_build_components/common/uart_2400/esp32-ard.yaml b/tests/test_build_components/common/uart_2400/esp32-ard.yaml
new file mode 100644
index 00000000000..e0b6571104a
--- /dev/null
+++ b/tests/test_build_components/common/uart_2400/esp32-ard.yaml
@@ -0,0 +1,11 @@
+# Common UART configuration for ESP32 Arduino tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400
diff --git a/tests/test_build_components/common/uart_2400/esp32-idf.yaml b/tests/test_build_components/common/uart_2400/esp32-idf.yaml
new file mode 100644
index 00000000000..7bded8c91d6
--- /dev/null
+++ b/tests/test_build_components/common/uart_2400/esp32-idf.yaml
@@ -0,0 +1,11 @@
+# Common UART configuration for ESP32 IDF tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO17
+  rx_pin: GPIO16
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400
diff --git a/tests/test_build_components/common/uart_2400/esp8266-ard.yaml b/tests/test_build_components/common/uart_2400/esp8266-ard.yaml
new file mode 100644
index 00000000000..6c9a4a558d1
--- /dev/null
+++ b/tests/test_build_components/common/uart_2400/esp8266-ard.yaml
@@ -0,0 +1,11 @@
+# Common UART configuration for ESP8266 Arduino tests - 2400 baud
+
+substitutions:
+  tx_pin: GPIO4
+  rx_pin: GPIO5
+
+uart:
+  - id: uart_bus
+    tx_pin: ${tx_pin}
+    rx_pin: ${rx_pin}
+    baud_rate: 2400
diff --git a/tests/unit_tests/core/test_config.py b/tests/unit_tests/core/test_config.py
index ab7bdbb98c1..88801a9ca03 100644
--- a/tests/unit_tests/core/test_config.py
+++ b/tests/unit_tests/core/test_config.py
@@ -453,11 +453,14 @@ def test_preload_core_config_no_platform(setup_core: Path) -> None:
     # Mock _is_target_platform to avoid expensive component loading
     with patch("esphome.core.config._is_target_platform") as mock_is_platform:
         # Return True for known platforms
-        mock_is_platform.side_effect = lambda name: name in [
-            "esp32",
-            "esp8266",
-            "rp2040",
-        ]
+        mock_is_platform.side_effect = lambda name: (
+            name
+            in [
+                "esp32",
+                "esp8266",
+                "rp2040",
+            ]
+        )
 
         with pytest.raises(cv.Invalid, match="Platform missing"):
             preload_core_config(config, result)
@@ -477,11 +480,14 @@ def test_preload_core_config_multiple_platforms(setup_core: Path) -> None:
     # Mock _is_target_platform to avoid expensive component loading
     with patch("esphome.core.config._is_target_platform") as mock_is_platform:
         # Return True for known platforms
-        mock_is_platform.side_effect = lambda name: name in [
-            "esp32",
-            "esp8266",
-            "rp2040",
-        ]
+        mock_is_platform.side_effect = lambda name: (
+            name
+            in [
+                "esp32",
+                "esp8266",
+                "rp2040",
+            ]
+        )
 
         with pytest.raises(cv.Invalid, match="Found multiple target platform blocks"):
             preload_core_config(config, result)
diff --git a/tests/unit_tests/test_core.py b/tests/unit_tests/test_core.py
index 1fc8dab358b..174b3fec85d 100644
--- a/tests/unit_tests/test_core.py
+++ b/tests/unit_tests/test_core.py
@@ -780,3 +780,78 @@ class TestEsphomeCore:
         target.config = {const.CONF_ESPHOME: {"name": "test"}, "logger": {}}
 
         assert target.has_networking is False
+
+    def test_add_library__esp32_arduino_enables_disabled_library(self, target):
+        """Test add_library auto-enables Arduino libraries on ESP32 Arduino builds."""
+        target.data[const.KEY_CORE] = {
+            const.KEY_TARGET_PLATFORM: "esp32",
+            const.KEY_TARGET_FRAMEWORK: "arduino",
+        }
+
+        library = core.Library("WiFi", None)
+
+        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
+            target.add_library(library)
+            mock_enable.assert_called_once_with("WiFi")
+
+        assert "WiFi" in target.platformio_libraries
+
+    def test_add_library__esp32_arduino_ignores_non_arduino_library(self, target):
+        """Test add_library doesn't enable libraries not in ARDUINO_DISABLED_LIBRARIES."""
+        target.data[const.KEY_CORE] = {
+            const.KEY_TARGET_PLATFORM: "esp32",
+            const.KEY_TARGET_FRAMEWORK: "arduino",
+        }
+
+        library = core.Library("SomeOtherLib", "1.0.0")
+
+        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
+            target.add_library(library)
+            mock_enable.assert_not_called()
+
+        assert "SomeOtherLib" in target.platformio_libraries
+
+    def test_add_library__esp32_idf_does_not_enable_arduino_library(self, target):
+        """Test add_library doesn't auto-enable Arduino libraries on ESP32 IDF builds."""
+        target.data[const.KEY_CORE] = {
+            const.KEY_TARGET_PLATFORM: "esp32",
+            const.KEY_TARGET_FRAMEWORK: "esp-idf",
+        }
+
+        library = core.Library("WiFi", None)
+
+        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
+            target.add_library(library)
+            mock_enable.assert_not_called()
+
+        assert "WiFi" in target.platformio_libraries
+
+    def test_add_library__esp8266_does_not_enable_arduino_library(self, target):
+        """Test add_library doesn't auto-enable Arduino libraries on ESP8266."""
+        target.data[const.KEY_CORE] = {
+            const.KEY_TARGET_PLATFORM: "esp8266",
+            const.KEY_TARGET_FRAMEWORK: "arduino",
+        }
+
+        library = core.Library("WiFi", None)
+
+        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
+            target.add_library(library)
+            mock_enable.assert_not_called()
+
+        assert "WiFi" in target.platformio_libraries
+
+    def test_add_library__extracts_short_name_from_path(self, target):
+        """Test add_library extracts short name from library paths like owner/lib."""
+        target.data[const.KEY_CORE] = {
+            const.KEY_TARGET_PLATFORM: "esp32",
+            const.KEY_TARGET_FRAMEWORK: "arduino",
+        }
+
+        library = core.Library("arduino/Wire", None)
+
+        with patch("esphome.components.esp32._enable_arduino_library") as mock_enable:
+            target.add_library(library)
+            mock_enable.assert_called_once_with("Wire")
+
+        assert "Wire" in target.platformio_libraries
diff --git a/tests/unit_tests/test_wizard.py b/tests/unit_tests/test_wizard.py
index fd53a0b0b70..eb44c1c20f4 100644
--- a/tests/unit_tests/test_wizard.py
+++ b/tests/unit_tests/test_wizard.py
@@ -25,7 +25,6 @@ def default_config() -> dict[str, Any]:
         "board": "esp01_1m",
         "ssid": "test_ssid",
         "psk": "test_psk",
-        "password": "",
     }
 
 
@@ -37,7 +36,7 @@ def wizard_answers() -> list[str]:
         "nodemcuv2",  # board
         "SSID",  # ssid
         "psk",  # wifi password
-        "ota_pass",  # ota password
+        "",  # ota password (empty for no password)
     ]
 
 
@@ -105,16 +104,35 @@ def test_config_file_should_include_ota_when_password_set(
     default_config: dict[str, Any],
 ):
     """
-    The Over-The-Air update should be enabled when a password is set
+    The Over-The-Air update should be enabled when an OTA password is set
     """
     # Given
-    default_config["password"] = "foo"
+    default_config["ota_password"] = "foo"
 
     # When
     config = wz.wizard_file(**default_config)
 
     # Then
     assert "ota:" in config
+    assert 'password: "foo"' in config
+
+
+def test_config_file_should_include_api_encryption_key(
+    default_config: dict[str, Any],
+):
+    """
+    The API encryption key should be included when set
+    """
+    # Given
+    default_config["api_encryption_key"] = "test_encryption_key_base64=="
+
+    # When
+    config = wz.wizard_file(**default_config)
+
+    # Then
+    assert "api:" in config
+    assert "encryption:" in config
+    assert 'key: "test_encryption_key_base64=="' in config
 
 
 def test_wizard_write_sets_platform(
@@ -556,3 +574,61 @@ def test_wizard_write_protects_existing_config(
     # Then
     assert result is False  # Should return False when file exists
     assert config_file.read_text() == original_content
+
+
+def test_wizard_accepts_ota_password(
+    tmp_path: Path, monkeypatch: MonkeyPatch, wizard_answers: list[str]
+):
+    """
+    The wizard should pass ota_password to wizard_write when the user provides one
+    """
+
+    # Given
+    wizard_answers[5] = "my_ota_password"  # Set OTA password
+    config_file = tmp_path / "test.yaml"
+    input_mock = MagicMock(side_effect=wizard_answers)
+    monkeypatch.setattr("builtins.input", input_mock)
+    monkeypatch.setattr(wz, "safe_print", lambda t=None, end=None: 0)
+    monkeypatch.setattr(wz, "sleep", lambda _: 0)
+    wizard_write_mock = MagicMock(return_value=True)
+    monkeypatch.setattr(wz, "wizard_write", wizard_write_mock)
+
+    # When
+    retval = wz.wizard(config_file)
+
+    # Then
+    assert retval == 0
+    call_kwargs = wizard_write_mock.call_args.kwargs
+    assert "ota_password" in call_kwargs
+    assert call_kwargs["ota_password"] == "my_ota_password"
+
+
+def test_wizard_accepts_rpipico_board(tmp_path: Path, monkeypatch: MonkeyPatch):
+    """
+    The wizard should handle rpipico board which doesn't support WiFi.
+    This tests the branch where api_encryption_key is None.
+    """
+
+    # Given
+    wizard_answers_rp2040 = [
+        "test-node",  # Name of the node
+        "RP2040",  # platform
+        "rpipico",  # board (no WiFi support)
+    ]
+    config_file = tmp_path / "test.yaml"
+    input_mock = MagicMock(side_effect=wizard_answers_rp2040)
+    monkeypatch.setattr("builtins.input", input_mock)
+    monkeypatch.setattr(wz, "safe_print", lambda t=None, end=None: 0)
+    monkeypatch.setattr(wz, "sleep", lambda _: 0)
+    wizard_write_mock = MagicMock(return_value=True)
+    monkeypatch.setattr(wz, "wizard_write", wizard_write_mock)
+
+    # When
+    retval = wz.wizard(config_file)
+
+    # Then
+    assert retval == 0
+    call_kwargs = wizard_write_mock.call_args.kwargs
+    # rpipico doesn't support WiFi, so no api_encryption_key or ota_password
+    assert "api_encryption_key" not in call_kwargs
+    assert "ota_password" not in call_kwargs
diff --git a/tests/unit_tests/test_writer.py b/tests/unit_tests/test_writer.py
index ac05e0d31bb..134b63df4a8 100644
--- a/tests/unit_tests/test_writer.py
+++ b/tests/unit_tests/test_writer.py
@@ -466,8 +466,8 @@ def test_clean_build(
     ) as mock_get_instance:
         mock_config = MagicMock()
         mock_get_instance.return_value = mock_config
-        mock_config.get.side_effect = (
-            lambda section, option: str(platformio_cache_dir)
+        mock_config.get.side_effect = lambda section, option: (
+            str(platformio_cache_dir)
             if (section, option) == ("platformio", "cache_dir")
             else ""
         )
@@ -630,8 +630,8 @@ def test_clean_build_empty_cache_dir(
     ) as mock_get_instance:
         mock_config = MagicMock()
         mock_get_instance.return_value = mock_config
-        mock_config.get.side_effect = (
-            lambda section, option: "   "  # Whitespace only
+        mock_config.get.side_effect = lambda section, option: (
+            "   "  # Whitespace only
             if (section, option) == ("platformio", "cache_dir")
             else ""
         )
@@ -1574,8 +1574,8 @@ def test_copy_src_tree_writes_build_info_files(
     mock_component.resources = mock_resources
 
     # Setup mocks
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF
     mock_core.comment = "Test comment"
@@ -1649,8 +1649,8 @@ def test_copy_src_tree_detects_config_hash_change(
     build_info_h_path.write_text("// old build_info_data.h")
 
     # Setup mocks
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF  # Different from existing
     mock_core.comment = ""
@@ -1711,8 +1711,8 @@ def test_copy_src_tree_detects_version_change(
     build_info_h_path.write_text("// old build_info_data.h")
 
     # Setup mocks
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF
     mock_core.comment = ""
@@ -1761,8 +1761,8 @@ def test_copy_src_tree_handles_invalid_build_info_json(
     build_info_h_path.write_text("// old build_info_data.h")
 
     # Setup mocks
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF
     mock_core.comment = ""
@@ -1835,8 +1835,8 @@ def test_copy_src_tree_build_info_timestamp_behavior(
     mock_component.resources = mock_resources
 
     # Setup mocks
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF
     mock_core.comment = ""
@@ -1930,8 +1930,8 @@ def test_copy_src_tree_detects_removed_source_file(
     existing_file.write_text("// test file")
 
     # Setup mocks - no components, so the file should be removed
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF
     mock_core.comment = ""
@@ -1992,8 +1992,8 @@ def test_copy_src_tree_ignores_removed_generated_file(
     build_info_h.write_text("// old generated file")
 
     # Setup mocks
-    mock_core.relative_src_path.side_effect = lambda *args: src_path.joinpath(*args)
-    mock_core.relative_build_path.side_effect = lambda *args: build_path.joinpath(*args)
+    mock_core.relative_src_path.side_effect = src_path.joinpath
+    mock_core.relative_build_path.side_effect = build_path.joinpath
     mock_core.defines = []
     mock_core.config_hash = 0xDEADBEEF
     mock_core.comment = ""