Merge branch 'dev' into libretiny_1100_boards

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

.clang-tidy.hash

@@ -1 +1 @@
-15dc295268b2dcf75942f42759b3ddec64eba89f75525698eb39c95a7f4b14ce
+d565b0589e35e692b5f2fc0c14723a99595b4828a3a3ef96c442e86a23176c00

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
+        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         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@19b2f06db2b6f5108140aeb04014ef02b648f789 # v4.31.11
+        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
         with:
           category: "/language:${{matrix.language}}"

esphome/components/cover/cover.cpp

@@ -1,11 +1,11 @@
 #include "cover.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
+#include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 
 #include <strings.h>
 
-#include "esphome/core/log.h"
-
 namespace esphome::cover {
 
 static const char *const TAG = "cover";
@@ -39,13 +39,13 @@ Cover::Cover() : position{COVER_OPEN} {}
 
 CoverCall::CoverCall(Cover *parent) : parent_(parent) {}
 CoverCall &CoverCall::set_command(const char *command) {
-  if (strcasecmp(command, "OPEN") == 0) {
+  if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("OPEN")) == 0) {
     this->set_command_open();
-  } else if (strcasecmp(command, "CLOSE") == 0) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("CLOSE")) == 0) {
     this->set_command_close();
-  } else if (strcasecmp(command, "STOP") == 0) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("STOP")) == 0) {
     this->set_command_stop();
-  } else if (strcasecmp(command, "TOGGLE") == 0) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("TOGGLE")) == 0) {
     this->set_command_toggle();
   } else {
     ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command);

esphome/components/http_request/__init__.py

@@ -126,7 +126,7 @@ CONFIG_SCHEMA = cv.All(
             ),
             cv.Optional(CONF_CA_CERTIFICATE_PATH): cv.All(
                 cv.file_,
-                cv.only_on(PLATFORM_HOST),
+                cv.Any(cv.only_on(PLATFORM_HOST), cv.only_on_esp32),
             ),
         }
     ).extend(cv.COMPONENT_SCHEMA),
@@ -160,7 +160,14 @@ async def to_code(config):
         cg.add(var.set_verify_ssl(config[CONF_VERIFY_SSL]))
 
         if config.get(CONF_VERIFY_SSL):
-            esp32.add_idf_sdkconfig_option("CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True)
+            if ca_cert_path := config.get(CONF_CA_CERTIFICATE_PATH):
+                with open(ca_cert_path, encoding="utf-8") as f:
+                    ca_cert_content = f.read()
+                cg.add(var.set_ca_certificate(ca_cert_content))
+            else:
+                esp32.add_idf_sdkconfig_option(
+                    "CONFIG_MBEDTLS_CERTIFICATE_BUNDLE", True
+                )
 
         esp32.add_idf_sdkconfig_option(
             "CONFIG_ESP_TLS_INSECURE",

esphome/components/http_request/http_request_idf.cpp

@@ -27,8 +27,9 @@ void HttpRequestIDF::dump_config() {
   HttpRequestComponent::dump_config();
   ESP_LOGCONFIG(TAG,
                 "  Buffer Size RX: %u\n"
-                "  Buffer Size TX: %u",
-                this->buffer_size_rx_, this->buffer_size_tx_);
+                "  Buffer Size TX: %u\n"
+                "  Custom CA Certificate: %s",
+                this->buffer_size_rx_, this->buffer_size_tx_, YESNO(this->ca_certificate_ != nullptr));
 }
 
 esp_err_t HttpRequestIDF::http_event_handler(esp_http_client_event_t *evt) {
@@ -88,11 +89,15 @@ std::shared_ptr<HttpContainer> HttpRequestIDF::perform(const std::string &url, c
   config.disable_auto_redirect = !this->follow_redirects_;
   config.max_redirection_count = this->redirect_limit_;
   config.auth_type = HTTP_AUTH_TYPE_BASIC;
-#if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
   if (secure && this->verify_ssl_) {
-    config.crt_bundle_attach = esp_crt_bundle_attach;
-  }
+    if (this->ca_certificate_ != nullptr) {
+      config.cert_pem = this->ca_certificate_;
+#if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
+    } else {
+      config.crt_bundle_attach = esp_crt_bundle_attach;
 #endif
+    }
+  }
 
   if (this->useragent_ != nullptr) {
     config.user_agent = this->useragent_;

esphome/components/http_request/http_request_idf.h

@@ -35,6 +35,7 @@ class HttpRequestIDF : public HttpRequestComponent {
   void set_buffer_size_rx(uint16_t buffer_size_rx) { this->buffer_size_rx_ = buffer_size_rx; }
   void set_buffer_size_tx(uint16_t buffer_size_tx) { this->buffer_size_tx_ = buffer_size_tx; }
   void set_verify_ssl(bool verify_ssl) { this->verify_ssl_ = verify_ssl; }
+  void set_ca_certificate(const char *ca_certificate) { this->ca_certificate_ = ca_certificate; }
 
  protected:
   std::shared_ptr<HttpContainer> perform(const std::string &url, const std::string &method, const std::string &body,
@@ -44,6 +45,7 @@ class HttpRequestIDF : public HttpRequestComponent {
   uint16_t buffer_size_rx_{};
   uint16_t buffer_size_tx_{};
   bool verify_ssl_{true};
+  const char *ca_certificate_{nullptr};
 
   /// @brief Monitors the http client events to gather response headers
   static esp_err_t http_event_handler(esp_http_client_event_t *evt);

esphome/components/http_request/ota/ota_http_request.cpp

@@ -82,7 +82,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
   uint32_t last_progress = 0;
   uint32_t update_start_time = millis();
   md5::MD5Digest md5_receive;
-  std::unique_ptr<char[]> md5_receive_str(new char[33]);
+  char md5_receive_str[33];
 
   if (this->md5_expected_.empty() && !this->http_get_md5_()) {
     return OTA_MD5_INVALID;
@@ -176,14 +176,14 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
 
   // verify MD5 is as expected and act accordingly
   md5_receive.calculate();
-  md5_receive.get_hex(md5_receive_str.get());
-  this->md5_computed_ = md5_receive_str.get();
+  md5_receive.get_hex(md5_receive_str);
+  this->md5_computed_ = md5_receive_str;
   if (strncmp(this->md5_computed_.c_str(), this->md5_expected_.c_str(), MD5_SIZE) != 0) {
     ESP_LOGE(TAG, "MD5 computed: %s - Aborting due to MD5 mismatch", this->md5_computed_.c_str());
     this->cleanup_(std::move(backend), container);
     return ota::OTA_RESPONSE_ERROR_MD5_MISMATCH;
   } else {
-    backend->set_update_md5(md5_receive_str.get());
+    backend->set_update_md5(md5_receive_str);
   }
 
   container->end();

esphome/components/improv_serial/improv_serial_component.cpp

@@ -267,26 +267,16 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       for (auto &scan : results) {
         if (scan.get_is_hidden())
           continue;
-        const char *ssid_cstr = scan.get_ssid().c_str();
-        // Check if we've already sent this SSID
-        bool duplicate = false;
-        for (const auto &seen : networks) {
-          if (strcmp(seen.c_str(), ssid_cstr) == 0) {
-            duplicate = true;
-            break;
-          }
-        }
-        if (duplicate)
+        const std::string &ssid = scan.get_ssid();
+        if (std::find(networks.begin(), networks.end(), ssid) != networks.end())
           continue;
-        // Only allocate std::string after confirming it's not a duplicate
-        std::string ssid(ssid_cstr);
         // Send each ssid separately to avoid overflowing the buffer
         char rssi_buf[5];  // int8_t: -128 to 127, max 4 chars + null
         *int8_to_str(rssi_buf, scan.get_rssi()) = '\0';
         std::vector<uint8_t> data =
             improv::build_rpc_response(improv::GET_WIFI_NETWORKS, {ssid, rssi_buf, YESNO(scan.get_with_auth())}, false);
         this->send_response_(data);
-        networks.push_back(std::move(ssid));
+        networks.push_back(ssid);
       }
       // Send empty response to signify the end of the list.
       std::vector<uint8_t> data =

esphome/components/libretiny/__init__.py

@@ -191,10 +191,17 @@ def _notify_old_style(config):
 
 
 # The dev and latest branches will be at *least* this version, which is what matters.
+# Use GitHub releases directly to avoid PlatformIO moderation delays.
 ARDUINO_VERSIONS = {
-    "dev": (cv.Version(1, 9, 2), "https://github.com/libretiny-eu/libretiny.git"),
-    "latest": (cv.Version(1, 9, 2), "libretiny"),
-    "recommended": (cv.Version(1, 9, 2), None),
+    "dev": (cv.Version(1, 11, 0), "https://github.com/libretiny-eu/libretiny.git"),
+    "latest": (
+        cv.Version(1, 11, 0),
+        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
+    ),
+    "recommended": (
+        cv.Version(1, 11, 0),
+        "https://github.com/libretiny-eu/libretiny.git#v1.11.0",
+    ),
 }
 
 

esphome/components/light/addressable_light_wrapper.h

@@ -7,9 +7,7 @@ namespace esphome::light {
 
 class AddressableLightWrapper : public light::AddressableLight {
  public:
-  explicit AddressableLightWrapper(light::LightState *light_state) : light_state_(light_state) {
-    this->wrapper_state_ = new uint8_t[5];  // NOLINT(cppcoreguidelines-owning-memory)
-  }
+  explicit AddressableLightWrapper(light::LightState *light_state) : light_state_(light_state) {}
 
   int32_t size() const override { return 1; }
 
@@ -118,7 +116,7 @@ class AddressableLightWrapper : public light::AddressableLight {
   }
 
   light::LightState *light_state_;
-  uint8_t *wrapper_state_;
+  mutable uint8_t wrapper_state_[5]{};
   ColorMode color_mode_{ColorMode::UNKNOWN};
 };
 

esphome/components/mhz19/mhz19.cpp

@@ -3,8 +3,7 @@
 
 #include <cinttypes>
 
-namespace esphome {
-namespace mhz19 {
+namespace esphome::mhz19 {
 
 static const char *const TAG = "mhz19";
 static const uint8_t MHZ19_REQUEST_LENGTH = 8;
@@ -17,6 +16,19 @@ static const uint8_t MHZ19_COMMAND_DETECTION_RANGE_0_2000PPM[] = {0xFF, 0x01, 0x
 static const uint8_t MHZ19_COMMAND_DETECTION_RANGE_0_5000PPM[] = {0xFF, 0x01, 0x99, 0x00, 0x00, 0x00, 0x13, 0x88};
 static const uint8_t MHZ19_COMMAND_DETECTION_RANGE_0_10000PPM[] = {0xFF, 0x01, 0x99, 0x00, 0x00, 0x00, 0x27, 0x10};
 
+static const LogString *detection_range_to_log_string(MHZ19DetectionRange range) {
+  switch (range) {
+    case MHZ19_DETECTION_RANGE_0_2000PPM:
+      return LOG_STR("0-2000 ppm");
+    case MHZ19_DETECTION_RANGE_0_5000PPM:
+      return LOG_STR("0-5000 ppm");
+    case MHZ19_DETECTION_RANGE_0_10000PPM:
+      return LOG_STR("0-10000 ppm");
+    default:
+      return LOG_STR("default");
+  }
+}
+
 uint8_t mhz19_checksum(const uint8_t *command) {
   uint8_t sum = 0;
   for (uint8_t i = 1; i < MHZ19_REQUEST_LENGTH; i++) {
@@ -91,24 +103,24 @@ void MHZ19Component::abc_disable() {
   this->mhz19_write_command_(MHZ19_COMMAND_ABC_DISABLE, nullptr);
 }
 
-void MHZ19Component::range_set(MHZ19DetectionRange detection_ppm) {
-  switch (detection_ppm) {
-    case MHZ19_DETECTION_RANGE_DEFAULT:
-      ESP_LOGV(TAG, "Using previously set detection range (no change)");
-      break;
+void MHZ19Component::range_set(MHZ19DetectionRange detection_range) {
+  const uint8_t *command;
+  switch (detection_range) {
     case MHZ19_DETECTION_RANGE_0_2000PPM:
-      ESP_LOGD(TAG, "Setting detection range to 0 to 2000ppm");
-      this->mhz19_write_command_(MHZ19_COMMAND_DETECTION_RANGE_0_2000PPM, nullptr);
+      command = MHZ19_COMMAND_DETECTION_RANGE_0_2000PPM;
       break;
     case MHZ19_DETECTION_RANGE_0_5000PPM:
-      ESP_LOGD(TAG, "Setting detection range to 0 to 5000ppm");
-      this->mhz19_write_command_(MHZ19_COMMAND_DETECTION_RANGE_0_5000PPM, nullptr);
+      command = MHZ19_COMMAND_DETECTION_RANGE_0_5000PPM;
       break;
     case MHZ19_DETECTION_RANGE_0_10000PPM:
-      ESP_LOGD(TAG, "Setting detection range to 0 to 10000ppm");
-      this->mhz19_write_command_(MHZ19_COMMAND_DETECTION_RANGE_0_10000PPM, nullptr);
+      command = MHZ19_COMMAND_DETECTION_RANGE_0_10000PPM;
       break;
+    default:
+      ESP_LOGV(TAG, "Using previously set detection range (no change)");
+      return;
   }
+  ESP_LOGD(TAG, "Setting detection range to %s", LOG_STR_ARG(detection_range_to_log_string(detection_range)));
+  this->mhz19_write_command_(command, nullptr);
 }
 
 bool MHZ19Component::mhz19_write_command_(const uint8_t *command, uint8_t *response) {
@@ -140,27 +152,7 @@ void MHZ19Component::dump_config() {
   }
 
   ESP_LOGCONFIG(TAG, "  Warmup time: %" PRIu32 " s", this->warmup_seconds_);
-
-  const char *range_str;
-  switch (this->detection_range_) {
-    case MHZ19_DETECTION_RANGE_DEFAULT:
-      range_str = "default";
-      break;
-    case MHZ19_DETECTION_RANGE_0_2000PPM:
-      range_str = "0 to 2000ppm";
-      break;
-    case MHZ19_DETECTION_RANGE_0_5000PPM:
-      range_str = "0 to 5000ppm";
-      break;
-    case MHZ19_DETECTION_RANGE_0_10000PPM:
-      range_str = "0 to 10000ppm";
-      break;
-    default:
-      range_str = "default";
-      break;
-  }
-  ESP_LOGCONFIG(TAG, "  Detection range: %s", range_str);
+  ESP_LOGCONFIG(TAG, "  Detection range: %s", LOG_STR_ARG(detection_range_to_log_string(this->detection_range_)));
 }
 
-}  // namespace mhz19
-}  // namespace esphome
+}  // namespace esphome::mhz19

esphome/components/mhz19/mhz19.h

@@ -5,8 +5,7 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
-namespace esphome {
-namespace mhz19 {
+namespace esphome::mhz19 {
 
 enum MHZ19ABCLogic {
   MHZ19_ABC_NONE = 0,
@@ -32,7 +31,7 @@ class MHZ19Component : public PollingComponent, public uart::UARTDevice {
   void calibrate_zero();
   void abc_enable();
   void abc_disable();
-  void range_set(MHZ19DetectionRange detection_ppm);
+  void range_set(MHZ19DetectionRange detection_range);
 
   void set_temperature_sensor(sensor::Sensor *temperature_sensor) { temperature_sensor_ = temperature_sensor; }
   void set_co2_sensor(sensor::Sensor *co2_sensor) { co2_sensor_ = co2_sensor; }
@@ -74,5 +73,4 @@ template<typename... Ts> class MHZ19DetectionRangeSetAction : public Action<Ts..
   void play(const Ts &...x) override { this->parent_->range_set(this->detection_range_.value(x...)); }
 };
 
-}  // namespace mhz19
-}  // namespace esphome
+}  // namespace esphome::mhz19

esphome/components/rtl87xx/boards.py

@@ -23,6 +23,10 @@ RTL87XX_BOARDS = {
         "name": "WR2 Wi-Fi Module",
         "family": FAMILY_RTL8710B,
     },
+    "wbr3": {
+        "name": "WBR3 Wi-Fi Module",
+        "family": FAMILY_RTL8720C,
+    },
     "generic-rtl8710bn-2mb-468k": {
         "name": "Generic - RTL8710BN (2M/468k)",
         "family": FAMILY_RTL8710B,
@@ -79,6 +83,10 @@ RTL87XX_BOARDS = {
         "name": "T103_V1.0",
         "family": FAMILY_RTL8710B,
     },
+    "generic-rtl8720cf-2mb-896k": {
+        "name": "Generic - RTL8720CF (2M/896k)",
+        "family": FAMILY_RTL8720C,
+    },
     "generic-rtl8720cf-2mb-992k": {
         "name": "Generic - RTL8720CF (2M/992k)",
         "family": FAMILY_RTL8720C,
@@ -221,6 +229,71 @@ RTL87XX_BOARD_PINS = {
         "D9": 29,
         "A1": 41,
     },
+    "wbr3": {
+        "WIRE0_SCL_0": 11,
+        "WIRE0_SCL_1": 2,
+        "WIRE0_SCL_2": 19,
+        "WIRE0_SCL_3": 15,
+        "WIRE0_SDA_0": 3,
+        "WIRE0_SDA_1": 12,
+        "WIRE0_SDA_2": 16,
+        "SERIAL0_RX_0": 12,
+        "SERIAL0_RX_1": 13,
+        "SERIAL0_TX_0": 11,
+        "SERIAL0_TX_1": 14,
+        "SERIAL1_CTS": 4,
+        "SERIAL1_RX_0": 2,
+        "SERIAL1_RX_1": 0,
+        "SERIAL1_TX_0": 3,
+        "SERIAL1_TX_1": 1,
+        "SERIAL2_CTS": 19,
+        "SERIAL2_RX": 15,
+        "SERIAL2_TX": 16,
+        "CS0": 15,
+        "CTS1": 4,
+        "CTS2": 19,
+        "PA00": 0,
+        "PA0": 0,
+        "PA01": 1,
+        "PA1": 1,
+        "PA02": 2,
+        "PA2": 2,
+        "PA03": 3,
+        "PA3": 3,
+        "PA04": 4,
+        "PA4": 4,
+        "PA07": 7,
+        "PA7": 7,
+        "PA11": 11,
+        "PA12": 12,
+        "PA13": 13,
+        "PA14": 14,
+        "PA15": 15,
+        "PA16": 16,
+        "PA17": 17,
+        "PA18": 18,
+        "PA19": 19,
+        "PWM5": 17,
+        "PWM6": 18,
+        "RX2": 15,
+        "SDA0": 16,
+        "TX2": 16,
+        "D0": 7,
+        "D1": 11,
+        "D2": 2,
+        "D3": 3,
+        "D4": 4,
+        "D5": 12,
+        "D6": 16,
+        "D7": 17,
+        "D8": 18,
+        "D9": 19,
+        "D10": 13,
+        "D11": 14,
+        "D12": 15,
+        "D13": 0,
+        "D14": 1,
+    },
     "generic-rtl8710bn-2mb-468k": {
         "SPI0_CS": 19,
         "SPI0_MISO": 22,
@@ -1178,6 +1251,104 @@ RTL87XX_BOARD_PINS = {
         "A0": 19,
         "A1": 41,
     },
+    "generic-rtl8720cf-2mb-896k": {
+        "SPI0_CS_0": 2,
+        "SPI0_CS_1": 7,
+        "SPI0_CS_2": 15,
+        "SPI0_MISO_0": 10,
+        "SPI0_MISO_1": 20,
+        "SPI0_MOSI_0": 4,
+        "SPI0_MOSI_1": 9,
+        "SPI0_MOSI_2": 19,
+        "SPI0_SCK_0": 3,
+        "SPI0_SCK_1": 8,
+        "SPI0_SCK_2": 16,
+        "WIRE0_SCL_0": 2,
+        "WIRE0_SCL_1": 11,
+        "WIRE0_SCL_2": 15,
+        "WIRE0_SCL_3": 19,
+        "WIRE0_SDA_0": 3,
+        "WIRE0_SDA_1": 12,
+        "WIRE0_SDA_2": 16,
+        "WIRE0_SDA_3": 20,
+        "SERIAL0_CTS": 10,
+        "SERIAL0_RTS": 9,
+        "SERIAL0_RX_0": 12,
+        "SERIAL0_RX_1": 13,
+        "SERIAL0_TX_0": 11,
+        "SERIAL0_TX_1": 14,
+        "SERIAL1_CTS": 4,
+        "SERIAL1_RX_0": 0,
+        "SERIAL1_RX_1": 2,
+        "SERIAL1_TX_0": 1,
+        "SERIAL1_TX_1": 3,
+        "SERIAL2_CTS": 19,
+        "SERIAL2_RTS": 20,
+        "SERIAL2_RX": 15,
+        "SERIAL2_TX": 16,
+        "CS0": 15,
+        "CTS0": 10,
+        "CTS1": 4,
+        "CTS2": 19,
+        "MOSI0": 19,
+        "PA00": 0,
+        "PA0": 0,
+        "PA01": 1,
+        "PA1": 1,
+        "PA02": 2,
+        "PA2": 2,
+        "PA03": 3,
+        "PA3": 3,
+        "PA04": 4,
+        "PA4": 4,
+        "PA07": 7,
+        "PA7": 7,
+        "PA08": 8,
+        "PA8": 8,
+        "PA09": 9,
+        "PA9": 9,
+        "PA10": 10,
+        "PA11": 11,
+        "PA12": 12,
+        "PA13": 13,
+        "PA14": 14,
+        "PA15": 15,
+        "PA16": 16,
+        "PA17": 17,
+        "PA18": 18,
+        "PA19": 19,
+        "PA20": 20,
+        "PA23": 23,
+        "PWM0": 20,
+        "PWM5": 17,
+        "PWM6": 18,
+        "PWM7": 23,
+        "RTS0": 9,
+        "RTS2": 20,
+        "RX2": 15,
+        "SCK0": 16,
+        "TX2": 16,
+        "D0": 0,
+        "D1": 1,
+        "D2": 2,
+        "D3": 3,
+        "D4": 4,
+        "D5": 7,
+        "D6": 8,
+        "D7": 9,
+        "D8": 10,
+        "D9": 11,
+        "D10": 12,
+        "D11": 13,
+        "D12": 14,
+        "D13": 15,
+        "D14": 16,
+        "D15": 17,
+        "D16": 18,
+        "D17": 19,
+        "D18": 20,
+        "D19": 23,
+    },
     "generic-rtl8720cf-2mb-992k": {
         "SPI0_CS_0": 2,
         "SPI0_CS_1": 7,

esphome/components/sml/constants.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <cstdint>
 
 namespace esphome {
@@ -21,7 +22,7 @@ enum SmlMessageType : uint16_t { SML_PUBLIC_OPEN_RES = 0x0101, SML_GET_LIST_RES
 const uint16_t START_MASK = 0x55aa;  // 0x1b 1b 1b 1b 01 01 01 01
 const uint16_t END_MASK = 0x0157;    // 0x1b 1b 1b 1b 1a
 
-const std::vector<uint8_t> START_SEQ = {0x1b, 0x1b, 0x1b, 0x1b, 0x01, 0x01, 0x01, 0x01};
+constexpr std::array<uint8_t, 8> START_SEQ = {0x1b, 0x1b, 0x1b, 0x1b, 0x01, 0x01, 0x01, 0x01};
 
 }  // namespace sml
 }  // namespace esphome

esphome/components/tm1638/tm1638.cpp

@@ -35,9 +35,6 @@ void TM1638Component::setup() {
   this->set_intensity(intensity_);
 
   this->reset_();  // all LEDs off
-
-  for (uint8_t i = 0; i < 8; i++)  // zero fill print buffer
-    this->buffer_[i] = 0;
 }
 
 void TM1638Component::dump_config() {

esphome/components/tm1638/tm1638.h

@@ -70,7 +70,7 @@ class TM1638Component : public PollingComponent {
   GPIOPin *clk_pin_;
   GPIOPin *stb_pin_;
   GPIOPin *dio_pin_;
-  uint8_t *buffer_ = new uint8_t[8];
+  uint8_t buffer_[8]{};
   tm1638_writer_t writer_{};
   std::vector<KeyListener *> listeners_{};
 };

esphome/components/uln2003/uln2003.cpp

@@ -1,11 +1,23 @@
 #include "uln2003.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace uln2003 {
+namespace esphome::uln2003 {
 
 static const char *const TAG = "uln2003.stepper";
 
+static const LogString *step_mode_to_log_string(ULN2003StepMode mode) {
+  switch (mode) {
+    case ULN2003_STEP_MODE_FULL_STEP:
+      return LOG_STR("FULL STEP");
+    case ULN2003_STEP_MODE_HALF_STEP:
+      return LOG_STR("HALF STEP");
+    case ULN2003_STEP_MODE_WAVE_DRIVE:
+      return LOG_STR("WAVE DRIVE");
+    default:
+      return LOG_STR("UNKNOWN");
+  }
+}
+
 void ULN2003::setup() {
   this->pin_a_->setup();
   this->pin_b_->setup();
@@ -42,22 +54,7 @@ void ULN2003::dump_config() {
   LOG_PIN("  Pin B: ", this->pin_b_);
   LOG_PIN("  Pin C: ", this->pin_c_);
   LOG_PIN("  Pin D: ", this->pin_d_);
-  const char *step_mode_s;
-  switch (this->step_mode_) {
-    case ULN2003_STEP_MODE_FULL_STEP:
-      step_mode_s = "FULL STEP";
-      break;
-    case ULN2003_STEP_MODE_HALF_STEP:
-      step_mode_s = "HALF STEP";
-      break;
-    case ULN2003_STEP_MODE_WAVE_DRIVE:
-      step_mode_s = "WAVE DRIVE";
-      break;
-    default:
-      step_mode_s = "UNKNOWN";
-      break;
-  }
-  ESP_LOGCONFIG(TAG, "  Step Mode: %s", step_mode_s);
+  ESP_LOGCONFIG(TAG, "  Step Mode: %s", LOG_STR_ARG(step_mode_to_log_string(this->step_mode_)));
 }
 void ULN2003::write_step_(int32_t step) {
   int32_t n = this->step_mode_ == ULN2003_STEP_MODE_HALF_STEP ? 8 : 4;
@@ -90,5 +87,4 @@ void ULN2003::write_step_(int32_t step) {
   this->pin_d_->digital_write((res >> 3) & 1);
 }
 
-}  // namespace uln2003
-}  // namespace esphome
+}  // namespace esphome::uln2003

esphome/components/uln2003/uln2003.h

@@ -4,8 +4,7 @@
 #include "esphome/core/hal.h"
 #include "esphome/components/stepper/stepper.h"
 
-namespace esphome {
-namespace uln2003 {
+namespace esphome::uln2003 {
 
 enum ULN2003StepMode {
   ULN2003_STEP_MODE_FULL_STEP,
@@ -40,5 +39,4 @@ class ULN2003 : public stepper::Stepper, public Component {
   int32_t current_uln_pos_{0};
 };
 
-}  // namespace uln2003
-}  // namespace esphome
+}  // namespace esphome::uln2003

esphome/components/valve/valve.cpp

@@ -2,6 +2,8 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
+
 #include <strings.h>
 
 namespace esphome {
@@ -38,13 +40,13 @@ Valve::Valve() : position{VALVE_OPEN} {}
 
 ValveCall::ValveCall(Valve *parent) : parent_(parent) {}
 ValveCall &ValveCall::set_command(const char *command) {
-  if (strcasecmp(command, "OPEN") == 0) {
+  if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("OPEN")) == 0) {
     this->set_command_open();
-  } else if (strcasecmp(command, "CLOSE") == 0) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("CLOSE")) == 0) {
     this->set_command_close();
-  } else if (strcasecmp(command, "STOP") == 0) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("STOP")) == 0) {
     this->set_command_stop();
-  } else if (strcasecmp(command, "TOGGLE") == 0) {
+  } else if (ESPHOME_strcasecmp_P(command, ESPHOME_PSTR("TOGGLE")) == 0) {
     this->set_command_toggle();
   } else {
     ESP_LOGW(TAG, "'%s' - Unrecognized command %s", this->parent_->get_name().c_str(), command);

esphome/components/wifi/wifi_component.cpp

@@ -39,10 +39,6 @@
 #include "esphome/components/esp32_improv/esp32_improv_component.h"
 #endif
 
-#ifdef USE_IMPROV_SERIAL
-#include "esphome/components/improv_serial/improv_serial_component.h"
-#endif
-
 namespace esphome::wifi {
 
 static const char *const TAG = "wifi";
@@ -351,7 +347,7 @@ bool WiFiComponent::needs_scan_results_() const {
   return this->scan_result_.empty() || !this->scan_result_[0].get_matches();
 }
 
-bool WiFiComponent::ssid_was_seen_in_scan_(const CompactString &ssid) const {
+bool WiFiComponent::ssid_was_seen_in_scan_(const std::string &ssid) const {
   // Check if this SSID is configured as hidden
   // If explicitly marked hidden, we should always try hidden mode regardless of scan results
   for (const auto &conf : this->sta_) {
@@ -369,75 +365,6 @@ bool WiFiComponent::ssid_was_seen_in_scan_(const CompactString &ssid) const {
   return false;
 }
 
-bool WiFiComponent::needs_full_scan_results_() const {
-  // Components that require full scan results (for example, scan result listeners)
-  // are expected to call request_wifi_scan_results(), which sets keep_scan_results_.
-  if (this->keep_scan_results_) {
-    return true;
-  }
-
-#ifdef USE_CAPTIVE_PORTAL
-  // Captive portal needs full results when active (showing network list to user)
-  if (captive_portal::global_captive_portal != nullptr && captive_portal::global_captive_portal->is_active()) {
-    return true;
-  }
-#endif
-
-#ifdef USE_IMPROV_SERIAL
-  // Improv serial needs results during provisioning (before connected)
-  if (improv_serial::global_improv_serial_component != nullptr && !this->is_connected()) {
-    return true;
-  }
-#endif
-
-#ifdef USE_IMPROV
-  // BLE improv also needs results during provisioning
-  if (esp32_improv::global_improv_component != nullptr && esp32_improv::global_improv_component->is_active()) {
-    return true;
-  }
-#endif
-
-  return false;
-}
-
-bool WiFiComponent::matches_configured_network_(const char *ssid, const uint8_t *bssid) const {
-  // Hidden networks in scan results have empty SSIDs - skip them
-  if (ssid[0] == '\0') {
-    return false;
-  }
-  for (const auto &sta : this->sta_) {
-    // Skip hidden network configs (they don't appear in normal scans)
-    if (sta.get_hidden()) {
-      continue;
-    }
-    // For BSSID-only configs (empty SSID), match by BSSID
-    if (sta.get_ssid().empty()) {
-      if (sta.has_bssid() && std::memcmp(sta.get_bssid().data(), bssid, 6) == 0) {
-        return true;
-      }
-      continue;
-    }
-    // Match by SSID
-    if (sta.get_ssid() == ssid) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void WiFiComponent::log_discarded_scan_result_(const char *ssid, const uint8_t *bssid, int8_t rssi, uint8_t channel) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  // Skip logging during roaming scans to avoid log buffer overflow
-  // (roaming scans typically find many networks but only care about same-SSID APs)
-  if (this->roaming_state_ == RoamingState::SCANNING) {
-    return;
-  }
-  char bssid_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
-  format_mac_addr_upper(bssid, bssid_s);
-  ESP_LOGV(TAG, "- " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") " %ddB Ch:%u", ssid, bssid_s, rssi, channel);
-#endif
-}
-
 int8_t WiFiComponent::find_next_hidden_sta_(int8_t start_index) {
   // Find next SSID to try in RETRY_HIDDEN phase.
   //
@@ -729,12 +656,8 @@ void WiFiComponent::loop() {
         ESP_LOGI(TAG, "Starting fallback AP");
         this->setup_ap_config_();
 #ifdef USE_CAPTIVE_PORTAL
-        if (captive_portal::global_captive_portal != nullptr) {
-          // Reset so we force one full scan after captive portal starts
-          // (previous scans were filtered because captive portal wasn't active yet)
-          this->has_completed_scan_after_captive_portal_start_ = false;
+        if (captive_portal::global_captive_portal != nullptr)
           captive_portal::global_captive_portal->start();
-        }
 #endif
       }
     }
@@ -939,12 +862,9 @@ WiFiAP WiFiComponent::get_sta() const {
   return config ? *config : WiFiAP{};
 }
 void WiFiComponent::save_wifi_sta(const std::string &ssid, const std::string &password) {
-  this->save_wifi_sta(ssid.c_str(), password.c_str());
-}
-void WiFiComponent::save_wifi_sta(const char *ssid, const char *password) {
   SavedWifiSettings save{};  // zero-initialized - all bytes set to \0, guaranteeing null termination
-  strncpy(save.ssid, ssid, sizeof(save.ssid) - 1);              // max 32 chars, byte 32 remains \0
-  strncpy(save.password, password, sizeof(save.password) - 1);  // max 64 chars, byte 64 remains \0
+  strncpy(save.ssid, ssid.c_str(), sizeof(save.ssid) - 1);              // max 32 chars, byte 32 remains \0
+  strncpy(save.password, password.c_str(), sizeof(save.password) - 1);  // max 64 chars, byte 64 remains \0
   this->pref_.save(&save);
   // ensure it's written immediately
   global_preferences->sync();
@@ -1259,7 +1179,7 @@ template<typename VectorType> static void insertion_sort_scan_results(VectorType
 // has overhead from UART transmission, so combining INFO+DEBUG into one line halves
 // the blocking time. Do NOT split this into separate ESP_LOGI/ESP_LOGD calls.
 __attribute__((noinline)) static void log_scan_result(const WiFiScanResult &res) {
-  char bssid_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
+  char bssid_s[18];
   auto bssid = res.get_bssid();
   format_mac_addr_upper(bssid.data(), bssid_s);
 
@@ -1275,6 +1195,18 @@ __attribute__((noinline)) static void log_scan_result(const WiFiScanResult &res)
 #endif
 }
 
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+// Helper function to log non-matching scan results at verbose level
+__attribute__((noinline)) static void log_scan_result_non_matching(const WiFiScanResult &res) {
+  char bssid_s[18];
+  auto bssid = res.get_bssid();
+  format_mac_addr_upper(bssid.data(), bssid_s);
+
+  ESP_LOGV(TAG, "- " LOG_SECRET("'%s'") " " LOG_SECRET("(%s) ") "%s", res.get_ssid().c_str(), bssid_s,
+           LOG_STR_ARG(get_signal_bars(res.get_rssi())));
+}
+#endif
+
 void WiFiComponent::check_scanning_finished() {
   if (!this->scan_done_) {
     if (millis() - this->action_started_ > WIFI_SCAN_TIMEOUT_MS) {
@@ -1284,8 +1216,6 @@ void WiFiComponent::check_scanning_finished() {
     return;
   }
   this->scan_done_ = false;
-  this->has_completed_scan_after_captive_portal_start_ =
-      true;  // Track that we've done a scan since captive portal started
   this->retry_hidden_mode_ = RetryHiddenMode::SCAN_BASED;
 
   if (this->scan_result_.empty()) {
@@ -1313,12 +1243,21 @@ void WiFiComponent::check_scanning_finished() {
   // Sort scan results using insertion sort for better memory efficiency
   insertion_sort_scan_results(this->scan_result_);
 
-  // Log matching networks (non-matching already logged at VERBOSE in scan callback)
+  size_t non_matching_count = 0;
   for (auto &res : this->scan_result_) {
     if (res.get_matches()) {
       log_scan_result(res);
+    } else {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+      log_scan_result_non_matching(res);
+#else
+      non_matching_count++;
+#endif
     }
   }
+  if (non_matching_count > 0) {
+    ESP_LOGD(TAG, "- %zu non-matching (VERBOSE to show)", non_matching_count);
+  }
 
   // SYNCHRONIZATION POINT: Establish link between scan_result_[0] and selected_sta_index_
   // After sorting, scan_result_[0] contains the best network. Now find which sta_[i] config
@@ -1577,10 +1516,7 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
       if (this->went_through_explicit_hidden_phase_()) {
         return WiFiRetryPhase::EXPLICIT_HIDDEN;
       }
-      // Skip scanning when captive portal/improv is active to avoid disrupting AP,
-      // BUT only if we've already completed at least one scan AFTER the portal started.
-      // When captive portal first starts, scan results may be filtered/stale, so we need
-      // to do one full scan to populate available networks for the captive portal UI.
+      // Skip scanning when captive portal/improv is active to avoid disrupting AP.
       //
       // WHY SCANNING DISRUPTS AP MODE:
       // WiFi scanning requires the radio to leave the AP's channel and hop through
@@ -1597,16 +1533,7 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
       //
       // This allows users to configure WiFi via captive portal while the device keeps
       // attempting to connect to all configured networks in sequence.
-      // Captive portal needs scan results to show available networks.
-      // If captive portal is active, only skip scanning if we've done a scan after it started.
-      // If only improv is active (no captive portal), skip scanning since improv doesn't need results.
-      if (this->is_captive_portal_active_()) {
-        if (this->has_completed_scan_after_captive_portal_start_) {
-          return WiFiRetryPhase::RETRY_HIDDEN;
-        }
-        // Need to scan for captive portal
-      } else if (this->is_esp32_improv_active_()) {
-        // Improv doesn't need scan results
+      if (this->is_captive_portal_active_() || this->is_esp32_improv_active_()) {
         return WiFiRetryPhase::RETRY_HIDDEN;
       }
       return WiFiRetryPhase::SCAN_CONNECTING;
@@ -1789,11 +1716,11 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
   }
 
   // Get SSID for logging (use pointer to avoid copy)
-  const char *ssid = nullptr;
+  const std::string *ssid = nullptr;
   if (this->retry_phase_ == WiFiRetryPhase::SCAN_CONNECTING && !this->scan_result_.empty()) {
-    ssid = this->scan_result_[0].get_ssid().c_str();
+    ssid = &this->scan_result_[0].get_ssid();
   } else if (const WiFiAP *config = this->get_selected_sta_()) {
-    ssid = config->get_ssid().c_str();
+    ssid = &config->get_ssid();
   }
 
   // Only decrease priority on the last attempt for this phase
@@ -1813,8 +1740,8 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
   }
   char bssid_s[18];
   format_mac_addr_upper(failed_bssid.value().data(), bssid_s);
-  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d", ssid != nullptr ? ssid : "",
-           bssid_s, old_priority, new_priority);
+  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d",
+           ssid != nullptr ? ssid->c_str() : "", bssid_s, old_priority, new_priority);
 
   // After adjusting priority, check if all priorities are now at minimum
   // If so, clear the vector to save memory and reset for fresh start
@@ -2062,14 +1989,10 @@ void WiFiComponent::save_fast_connect_settings_() {
 }
 #endif
 
-void WiFiAP::set_ssid(const std::string &ssid) { this->ssid_ = CompactString(ssid.c_str(), ssid.size()); }
-void WiFiAP::set_ssid(const char *ssid) { this->ssid_ = CompactString(ssid, strlen(ssid)); }
+void WiFiAP::set_ssid(const std::string &ssid) { this->ssid_ = ssid; }
 void WiFiAP::set_bssid(const bssid_t &bssid) { this->bssid_ = bssid; }
 void WiFiAP::clear_bssid() { this->bssid_ = {}; }
-void WiFiAP::set_password(const std::string &password) {
-  this->password_ = CompactString(password.c_str(), password.size());
-}
-void WiFiAP::set_password(const char *password) { this->password_ = CompactString(password, strlen(password)); }
+void WiFiAP::set_password(const std::string &password) { this->password_ = password; }
 #ifdef USE_WIFI_WPA2_EAP
 void WiFiAP::set_eap(optional<EAPAuth> eap_auth) { this->eap_ = std::move(eap_auth); }
 #endif
@@ -2079,8 +2002,10 @@ void WiFiAP::clear_channel() { this->channel_ = 0; }
 void WiFiAP::set_manual_ip(optional<ManualIP> manual_ip) { this->manual_ip_ = manual_ip; }
 #endif
 void WiFiAP::set_hidden(bool hidden) { this->hidden_ = hidden; }
+const std::string &WiFiAP::get_ssid() const { return this->ssid_; }
 const bssid_t &WiFiAP::get_bssid() const { return this->bssid_; }
 bool WiFiAP::has_bssid() const { return this->bssid_ != bssid_t{}; }
+const std::string &WiFiAP::get_password() const { return this->password_; }
 #ifdef USE_WIFI_WPA2_EAP
 const optional<EAPAuth> &WiFiAP::get_eap() const { return this->eap_; }
 #endif
@@ -2091,12 +2016,12 @@ const optional<ManualIP> &WiFiAP::get_manual_ip() const { return this->manual_ip
 #endif
 bool WiFiAP::get_hidden() const { return this->hidden_; }
 
-WiFiScanResult::WiFiScanResult(const bssid_t &bssid, const char *ssid, size_t ssid_len, uint8_t channel, int8_t rssi,
-                               bool with_auth, bool is_hidden)
+WiFiScanResult::WiFiScanResult(const bssid_t &bssid, std::string ssid, uint8_t channel, int8_t rssi, bool with_auth,
+                               bool is_hidden)
     : bssid_(bssid),
       channel_(channel),
       rssi_(rssi),
-      ssid_(ssid, ssid_len),
+      ssid_(std::move(ssid)),
       with_auth_(with_auth),
       is_hidden_(is_hidden) {}
 bool WiFiScanResult::matches(const WiFiAP &config) const {
@@ -2139,6 +2064,7 @@ bool WiFiScanResult::matches(const WiFiAP &config) const {
 bool WiFiScanResult::get_matches() const { return this->matches_; }
 void WiFiScanResult::set_matches(bool matches) { this->matches_ = matches; }
 const bssid_t &WiFiScanResult::get_bssid() const { return this->bssid_; }
+const std::string &WiFiScanResult::get_ssid() const { return this->ssid_; }
 uint8_t WiFiScanResult::get_channel() const { return this->channel_; }
 int8_t WiFiScanResult::get_rssi() const { return this->rssi_; }
 bool WiFiScanResult::get_with_auth() const { return this->with_auth_; }
@@ -2154,7 +2080,7 @@ void WiFiComponent::clear_roaming_state_() {
 
 void WiFiComponent::release_scan_results_() {
   if (!this->keep_scan_results_) {
-#if defined(USE_RP2040) || defined(USE_ESP32)
+#ifdef USE_RP2040
     // std::vector - use swap trick since shrink_to_fit is non-binding
     decltype(this->scan_result_)().swap(this->scan_result_);
 #else
@@ -2211,7 +2137,7 @@ void WiFiComponent::process_roaming_scan_() {
 
   for (const auto &result : this->scan_result_) {
     // Must be same SSID, different BSSID
-    if (result.get_ssid() != current_ssid.c_str() || result.get_bssid() == current_bssid)
+    if (current_ssid != result.get_ssid() || result.get_bssid() == current_bssid)
       continue;
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE

esphome/components/wifi/wifi_component.h

@@ -161,12 +161,9 @@ struct EAPAuth {
 
 using bssid_t = std::array<uint8_t, 6>;
 
-/// Initial reserve size for filtered scan results (typical: 1-3 matching networks per SSID)
-static constexpr size_t WIFI_SCAN_RESULT_FILTERED_RESERVE = 8;
-
-// Use std::vector for RP2040 (callback-based) and ESP32 (destructive scan API)
-// Use FixedVector for ESP8266 and LibreTiny where two-pass exact allocation is possible
-#if defined(USE_RP2040) || defined(USE_ESP32)
+// Use std::vector for RP2040 since scan count is unknown (callback-based)
+// Use FixedVector for other platforms where count is queried first
+#ifdef USE_RP2040
 template<typename T> using wifi_scan_vector_t = std::vector<T>;
 #else
 template<typename T> using wifi_scan_vector_t = FixedVector<T>;
@@ -175,13 +172,9 @@ template<typename T> using wifi_scan_vector_t = FixedVector<T>;
 class WiFiAP {
  public:
   void set_ssid(const std::string &ssid);
-  void set_ssid(const char *ssid);
-  void set_ssid(const CompactString &ssid) { this->ssid_ = ssid; }
   void set_bssid(const bssid_t &bssid);
   void clear_bssid();
   void set_password(const std::string &password);
-  void set_password(const char *password);
-  void set_password(const CompactString &password) { this->password_ = password; }
 #ifdef USE_WIFI_WPA2_EAP
   void set_eap(optional<EAPAuth> eap_auth);
 #endif  // USE_WIFI_WPA2_EAP
@@ -192,10 +185,10 @@ class WiFiAP {
   void set_manual_ip(optional<ManualIP> manual_ip);
 #endif
   void set_hidden(bool hidden);
-  const CompactString &get_ssid() const { return this->ssid_; }
-  const CompactString &get_password() const { return this->password_; }
+  const std::string &get_ssid() const;
   const bssid_t &get_bssid() const;
   bool has_bssid() const;
+  const std::string &get_password() const;
 #ifdef USE_WIFI_WPA2_EAP
   const optional<EAPAuth> &get_eap() const;
 #endif  // USE_WIFI_WPA2_EAP
@@ -208,8 +201,8 @@ class WiFiAP {
   bool get_hidden() const;
 
  protected:
-  CompactString ssid_;
-  CompactString password_;
+  std::string ssid_;
+  std::string password_;
 #ifdef USE_WIFI_WPA2_EAP
   optional<EAPAuth> eap_;
 #endif  // USE_WIFI_WPA2_EAP
@@ -225,15 +218,14 @@ class WiFiAP {
 
 class WiFiScanResult {
  public:
-  WiFiScanResult(const bssid_t &bssid, const char *ssid, size_t ssid_len, uint8_t channel, int8_t rssi, bool with_auth,
-                 bool is_hidden);
+  WiFiScanResult(const bssid_t &bssid, std::string ssid, uint8_t channel, int8_t rssi, bool with_auth, bool is_hidden);
 
   bool matches(const WiFiAP &config) const;
 
   bool get_matches() const;
   void set_matches(bool matches);
   const bssid_t &get_bssid() const;
-  const CompactString &get_ssid() const { return this->ssid_; }
+  const std::string &get_ssid() const;
   uint8_t get_channel() const;
   int8_t get_rssi() const;
   bool get_with_auth() const;
@@ -247,7 +239,7 @@ class WiFiScanResult {
   bssid_t bssid_;
   uint8_t channel_;
   int8_t rssi_;
-  CompactString ssid_;
+  std::string ssid_;
   int8_t priority_{0};
   bool matches_{false};
   bool with_auth_;
@@ -386,10 +378,6 @@ class WiFiComponent : public Component {
   void set_passive_scan(bool passive);
 
   void save_wifi_sta(const std::string &ssid, const std::string &password);
-  void save_wifi_sta(const char *ssid, const char *password);
-  void save_wifi_sta(const CompactString &ssid, const CompactString &password) {
-    this->save_wifi_sta(ssid.c_str(), password.c_str());
-  }
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
@@ -550,14 +538,7 @@ class WiFiComponent : public Component {
   int8_t find_first_non_hidden_index_() const;
   /// Check if an SSID was seen in the most recent scan results
   /// Used to skip hidden mode for SSIDs we know are visible
-  bool ssid_was_seen_in_scan_(const CompactString &ssid) const;
-  /// Check if full scan results are needed (captive portal active, improv, listeners)
-  bool needs_full_scan_results_() const;
-  /// Check if network matches any configured network (for scan result filtering)
-  /// Matches by SSID when configured, or by BSSID for BSSID-only configs
-  bool matches_configured_network_(const char *ssid, const uint8_t *bssid) const;
-  /// Log a discarded scan result at VERBOSE level (skipped during roaming scans to avoid log overflow)
-  void log_discarded_scan_result_(const char *ssid, const uint8_t *bssid, int8_t rssi, uint8_t channel);
+  bool ssid_was_seen_in_scan_(const std::string &ssid) const;
   /// Find next SSID that wasn't in scan results (might be hidden)
   /// Returns index of next potentially hidden SSID, or -1 if none found
   /// @param start_index Start searching from index after this (-1 to start from beginning)
@@ -729,8 +710,6 @@ class WiFiComponent : public Component {
   bool enable_on_boot_{true};
   bool got_ipv4_address_{false};
   bool keep_scan_results_{false};
-  bool has_completed_scan_after_captive_portal_start_{
-      false};  // Tracks if we've completed a scan after captive portal started
   RetryHiddenMode retry_hidden_mode_{RetryHiddenMode::BLIND_RETRY};
   bool skip_cooldown_next_cycle_{false};
   bool post_connect_roaming_{true};  // Enabled by default

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -760,35 +760,20 @@ void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
     return;
   }
 
+  // Count the number of results first
   auto *head = reinterpret_cast<bss_info *>(arg);
-  bool needs_full = this->needs_full_scan_results_();
-
-  // First pass: count matching networks (linked list is non-destructive)
-  size_t total = 0;
   size_t count = 0;
   for (bss_info *it = head; it != nullptr; it = STAILQ_NEXT(it, next)) {
-    total++;
-    const char *ssid_cstr = reinterpret_cast<const char *>(it->ssid);
-    if (needs_full || this->matches_configured_network_(ssid_cstr, it->bssid)) {
-      count++;
-    }
+    count++;
   }
 
-  this->scan_result_.init(count);  // Exact allocation
-
-  // Second pass: store matching networks
+  this->scan_result_.init(count);
   for (bss_info *it = head; it != nullptr; it = STAILQ_NEXT(it, next)) {
-    const char *ssid_cstr = reinterpret_cast<const char *>(it->ssid);
-    if (needs_full || this->matches_configured_network_(ssid_cstr, it->bssid)) {
-      this->scan_result_.emplace_back(
-          bssid_t{it->bssid[0], it->bssid[1], it->bssid[2], it->bssid[3], it->bssid[4], it->bssid[5]}, ssid_cstr,
-          it->ssid_len, it->channel, it->rssi, it->authmode != AUTH_OPEN, it->is_hidden != 0);
-    } else {
-      this->log_discarded_scan_result_(ssid_cstr, it->bssid, it->rssi, it->channel);
-    }
+    this->scan_result_.emplace_back(
+        bssid_t{it->bssid[0], it->bssid[1], it->bssid[2], it->bssid[3], it->bssid[4], it->bssid[5]},
+        std::string(reinterpret_cast<char *>(it->ssid), it->ssid_len), it->channel, it->rssi, it->authmode != AUTH_OPEN,
+        it->is_hidden != 0);
   }
-  ESP_LOGV(TAG, "Scan complete: %zu found, %zu stored%s", total, this->scan_result_.size(),
-           needs_full ? "" : " (filtered)");
   this->scan_done_ = true;
 #ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
   for (auto *listener : global_wifi_component->scan_results_listeners_) {

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -828,21 +828,11 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     }
 
     uint16_t number = it.number;
-    bool needs_full = this->needs_full_scan_results_();
-
-    // Smart reserve: full capacity if needed, small reserve otherwise
-    if (needs_full) {
-      this->scan_result_.reserve(number);
-    } else {
-      this->scan_result_.reserve(WIFI_SCAN_RESULT_FILTERED_RESERVE);
-    }
-
+    scan_result_.init(number);
 #ifdef USE_ESP32_HOSTED
     // getting records one at a time fails on P4 with hosted esp32 WiFi coprocessor
     // Presumably an upstream bug, work-around by getting all records at once
-    // Use stack buffer (3904 bytes / ~80 bytes per record = ~48 records) with heap fallback
-    static constexpr size_t SCAN_RECORD_STACK_COUNT = 3904 / sizeof(wifi_ap_record_t);
-    SmallBufferWithHeapFallback<SCAN_RECORD_STACK_COUNT, wifi_ap_record_t> records(number);
+    auto records = std::make_unique<wifi_ap_record_t[]>(number);
     err = esp_wifi_scan_get_ap_records(&number, records.get());
     if (err != ESP_OK) {
       esp_wifi_clear_ap_list();
@@ -850,7 +840,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
       return;
     }
     for (uint16_t i = 0; i < number; i++) {
-      wifi_ap_record_t &record = records.get()[i];
+      wifi_ap_record_t &record = records[i];
 #else
     // Process one record at a time to avoid large buffer allocation
     for (uint16_t i = 0; i < number; i++) {
@@ -862,22 +852,12 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
         break;
       }
 #endif  // USE_ESP32_HOSTED
-
-      // Check C string first - avoid std::string construction for non-matching networks
-      const char *ssid_cstr = reinterpret_cast<const char *>(record.ssid);
-
-      // Only construct std::string and store if needed
-      if (needs_full || this->matches_configured_network_(ssid_cstr, record.bssid)) {
-        bssid_t bssid;
-        std::copy(record.bssid, record.bssid + 6, bssid.begin());
-        this->scan_result_.emplace_back(bssid, ssid_cstr, strlen(ssid_cstr), record.primary, record.rssi,
-                                        record.authmode != WIFI_AUTH_OPEN, ssid_cstr[0] == '\0');
-      } else {
-        this->log_discarded_scan_result_(ssid_cstr, record.bssid, record.rssi, record.primary);
-      }
+      bssid_t bssid;
+      std::copy(record.bssid, record.bssid + 6, bssid.begin());
+      std::string ssid(reinterpret_cast<const char *>(record.ssid));
+      scan_result_.emplace_back(bssid, ssid, record.primary, record.rssi, record.authmode != WIFI_AUTH_OPEN,
+                                ssid.empty());
     }
-    ESP_LOGV(TAG, "Scan complete: %u found, %zu stored%s", number, this->scan_result_.size(),
-             needs_full ? "" : " (filtered)");
 #ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
     for (auto *listener : this->scan_results_listeners_) {
       listener->on_wifi_scan_results(this->scan_result_);

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -670,39 +670,18 @@ void WiFiComponent::wifi_scan_done_callback_() {
   if (num < 0)
     return;
 
-  bool needs_full = this->needs_full_scan_results_();
-
-  // Access scan results directly via WiFi.scan struct to avoid Arduino String allocations
-  // WiFi.scan is public in LibreTiny for WiFiEvents & WiFiScan static handlers
-  auto *scan = WiFi.scan;
-
-  // First pass: count matching networks
-  size_t count = 0;
+  this->scan_result_.init(static_cast<unsigned int>(num));
   for (int i = 0; i < num; i++) {
-    const char *ssid_cstr = scan->ap[i].ssid;
-    if (needs_full || this->matches_configured_network_(ssid_cstr, scan->ap[i].bssid.addr)) {
-      count++;
-    }
-  }
+    String ssid = WiFi.SSID(i);
+    wifi_auth_mode_t authmode = WiFi.encryptionType(i);
+    int32_t rssi = WiFi.RSSI(i);
+    uint8_t *bssid = WiFi.BSSID(i);
+    int32_t channel = WiFi.channel(i);
 
-  this->scan_result_.init(count);  // Exact allocation
-
-  // Second pass: store matching networks
-  for (int i = 0; i < num; i++) {
-    const char *ssid_cstr = scan->ap[i].ssid;
-    if (needs_full || this->matches_configured_network_(ssid_cstr, scan->ap[i].bssid.addr)) {
-      auto &ap = scan->ap[i];
-      this->scan_result_.emplace_back(bssid_t{ap.bssid.addr[0], ap.bssid.addr[1], ap.bssid.addr[2], ap.bssid.addr[3],
-                                              ap.bssid.addr[4], ap.bssid.addr[5]},
-                                      ssid_cstr, strlen(ssid_cstr), ap.channel, ap.rssi, ap.auth != WIFI_AUTH_OPEN,
-                                      ssid_cstr[0] == '\0');
-    } else {
-      auto &ap = scan->ap[i];
-      this->log_discarded_scan_result_(ssid_cstr, ap.bssid.addr, ap.rssi, ap.channel);
-    }
+    this->scan_result_.emplace_back(bssid_t{bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]},
+                                    std::string(ssid.c_str()), channel, rssi, authmode != WIFI_AUTH_OPEN,
+                                    ssid.length() == 0);
   }
-  ESP_LOGV(TAG, "Scan complete: %d found, %zu stored%s", num, this->scan_result_.size(),
-           needs_full ? "" : " (filtered)");
   WiFi.scanDelete();
 #ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
   for (auto *listener : this->scan_results_listeners_) {

esphome/components/wifi/wifi_component_pico_w.cpp

@@ -21,7 +21,6 @@ static const char *const TAG = "wifi_pico_w";
 // Track previous state for detecting changes
 static bool s_sta_was_connected = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 static bool s_sta_had_ip = false;         // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-static size_t s_scan_result_count = 0;    // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 bool WiFiComponent::wifi_mode_(optional<bool> sta, optional<bool> ap) {
   if (sta.has_value()) {
@@ -138,19 +137,10 @@ int WiFiComponent::s_wifi_scan_result(void *env, const cyw43_ev_scan_result_t *r
 }
 
 void WiFiComponent::wifi_scan_result(void *env, const cyw43_ev_scan_result_t *result) {
-  s_scan_result_count++;
-  const char *ssid_cstr = reinterpret_cast<const char *>(result->ssid);
-
-  // Skip networks that don't match any configured network (unless full results needed)
-  if (!this->needs_full_scan_results_() && !this->matches_configured_network_(ssid_cstr, result->bssid)) {
-    this->log_discarded_scan_result_(ssid_cstr, result->bssid, result->rssi, result->channel);
-    return;
-  }
-
   bssid_t bssid;
   std::copy(result->bssid, result->bssid + 6, bssid.begin());
-  WiFiScanResult res(bssid, ssid_cstr, strlen(ssid_cstr), result->channel, result->rssi,
-                     result->auth_mode != CYW43_AUTH_OPEN, ssid_cstr[0] == '\0');
+  std::string ssid(reinterpret_cast<const char *>(result->ssid));
+  WiFiScanResult res(bssid, ssid, result->channel, result->rssi, result->auth_mode != CYW43_AUTH_OPEN, ssid.empty());
   if (std::find(this->scan_result_.begin(), this->scan_result_.end(), res) == this->scan_result_.end()) {
     this->scan_result_.push_back(res);
   }
@@ -159,7 +149,6 @@ void WiFiComponent::wifi_scan_result(void *env, const cyw43_ev_scan_result_t *re
 bool WiFiComponent::wifi_scan_start_(bool passive) {
   this->scan_result_.clear();
   this->scan_done_ = false;
-  s_scan_result_count = 0;
   cyw43_wifi_scan_options_t scan_options = {0};
   scan_options.scan_type = passive ? 1 : 0;
   int err = cyw43_wifi_scan(&cyw43_state, &scan_options, nullptr, &s_wifi_scan_result);
@@ -255,9 +244,7 @@ void WiFiComponent::wifi_loop_() {
   // Handle scan completion
   if (this->state_ == WIFI_COMPONENT_STATE_STA_SCANNING && !cyw43_wifi_scan_active(&cyw43_state)) {
     this->scan_done_ = true;
-    bool needs_full = this->needs_full_scan_results_();
-    ESP_LOGV(TAG, "Scan complete: %zu found, %zu stored%s", s_scan_result_count, this->scan_result_.size(),
-             needs_full ? "" : " (filtered)");
+    ESP_LOGV(TAG, "Scan done");
 #ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
     for (auto *listener : this->scan_results_listeners_) {
       listener->on_wifi_scan_results(this->scan_result_);

esphome/components/wifi_info/wifi_info_text_sensor.cpp

@@ -89,7 +89,7 @@ void ScanResultsWiFiInfo::on_wifi_scan_results(const wifi::wifi_scan_vector_t<wi
   for (const auto &scan : results) {
     if (scan.get_is_hidden())
       continue;
-    const auto &ssid = scan.get_ssid();
+    const std::string &ssid = scan.get_ssid();
     // Max space: ssid + ": " (2) + "-128" (4) + "dB\n" (3) = ssid + 9
     if (ptr + ssid.size() + 9 > end)
       break;

esphome/core/helpers.cpp

@@ -3,6 +3,7 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"
 
 #include <strings.h>
@@ -12,7 +13,6 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
-#include <new>
 
 #ifdef USE_ESP32
 #include "rom/crc.h"
@@ -452,15 +452,15 @@ std::string format_bin(const uint8_t *data, size_t length) {
 }
 
 ParseOnOffState parse_on_off(const char *str, const char *on, const char *off) {
-  if (on == nullptr && strcasecmp(str, "on") == 0)
+  if (on == nullptr && ESPHOME_strcasecmp_P(str, ESPHOME_PSTR("on")) == 0)
     return PARSE_ON;
   if (on != nullptr && strcasecmp(str, on) == 0)
     return PARSE_ON;
-  if (off == nullptr && strcasecmp(str, "off") == 0)
+  if (off == nullptr && ESPHOME_strcasecmp_P(str, ESPHOME_PSTR("off")) == 0)
     return PARSE_OFF;
   if (off != nullptr && strcasecmp(str, off) == 0)
     return PARSE_OFF;
-  if (strcasecmp(str, "toggle") == 0)
+  if (ESPHOME_strcasecmp_P(str, ESPHOME_PSTR("toggle")) == 0)
     return PARSE_TOGGLE;
 
   return PARSE_NONE;
@@ -858,60 +858,4 @@ void IRAM_ATTR HOT delay_microseconds_safe(uint32_t us) {
     ;
 }
 
-// CompactString implementation
-CompactString::CompactString(const char *str, size_t len) {
-  if (len > MAX_LENGTH) {
-    len = MAX_LENGTH;  // Clamp to max valid length
-  }
-
-  this->length_ = len;
-  if (len <= INLINE_CAPACITY) {
-    // Store inline with null terminator
-    this->is_heap_ = 0;
-    if (len > 0) {
-      std::memcpy(this->storage_, str, len);
-    }
-    this->storage_[len] = '\0';
-  } else {
-    // Heap allocate with null terminator
-    this->is_heap_ = 1;
-    char *heap_data = new char[len + 1];  // NOLINT(cppcoreguidelines-owning-memory)
-    std::memcpy(heap_data, str, len);
-    heap_data[len] = '\0';
-    this->set_heap_ptr_(heap_data);
-  }
-}
-
-CompactString::CompactString(const CompactString &other) : CompactString(other.data(), other.size()) {}
-
-CompactString &CompactString::operator=(const CompactString &other) {
-  if (this != &other) {
-    this->~CompactString();
-    new (this) CompactString(other);
-  }
-  return *this;
-}
-
-CompactString::CompactString(CompactString &&other) noexcept : length_(other.length_), is_heap_(other.is_heap_) {
-  // Copy full storage (includes null terminator for inline, or pointer for heap)
-  std::memcpy(this->storage_, other.storage_, INLINE_CAPACITY + 1);
-  other.length_ = 0;
-  other.is_heap_ = 0;
-  other.storage_[0] = '\0';
-}
-
-CompactString &CompactString::operator=(CompactString &&other) noexcept {
-  if (this != &other) {
-    this->~CompactString();
-    new (this) CompactString(std::move(other));
-  }
-  return *this;
-}
-
-CompactString::~CompactString() {
-  if (this->is_heap_) {
-    delete[] this->get_heap_ptr_();  // NOLINT(cppcoreguidelines-owning-memory)
-  }
-}
-
 }  // namespace esphome

esphome/core/helpers.h

@@ -1749,58 +1749,4 @@ template<typename T, enable_if_t<std::is_pointer<T *>::value, int> = 0> T &id(T
 
 ///@}
 
-/// 20-byte string: 18 chars inline + null, heap for longer. Always null-terminated.
-class CompactString {
- public:
-  static constexpr uint8_t MAX_LENGTH = 127;
-  static constexpr uint8_t INLINE_CAPACITY = 18;          // 18 chars + null terminator fits in 19 bytes
-  static constexpr uint8_t BUFFER_SIZE = MAX_LENGTH + 1;  // For external buffer (128 bytes)
-
-  CompactString() : length_(0), is_heap_(0) { this->storage_[0] = '\0'; }
-  CompactString(const char *str, size_t len);
-  CompactString(const CompactString &other);
-  CompactString(CompactString &&other) noexcept;
-  CompactString &operator=(const CompactString &other);
-  CompactString &operator=(CompactString &&other) noexcept;
-  ~CompactString();
-
-  const char *data() const { return this->is_heap_ ? this->get_heap_ptr_() : this->storage_; }
-  const char *c_str() const { return this->data(); }  // Always null-terminated
-  size_t size() const { return this->length_; }
-  bool empty() const { return this->length_ == 0; }
-
-  // Implicit conversion to std::string for backwards compatibility
-  operator std::string() const { return std::string(this->data(), this->size()); }
-
-  bool operator==(const CompactString &other) const {
-    return this->size() == other.size() && std::memcmp(this->data(), other.data(), this->size()) == 0;
-  }
-  bool operator==(const std::string &other) const {
-    return this->size() == other.size() && std::memcmp(this->data(), other.data(), this->size()) == 0;
-  }
-  bool operator==(const char *other) const {
-    return this->size() == std::strlen(other) && std::memcmp(this->data(), other, this->size()) == 0;
-  }
-  bool operator!=(const CompactString &other) const { return !(*this == other); }
-  bool operator!=(const std::string &other) const { return !(*this == other); }
-  bool operator!=(const char *other) const { return !(*this == other); }
-
- protected:
-  char *get_heap_ptr_() const {
-    char *ptr;
-    std::memcpy(&ptr, this->storage_, sizeof(ptr));
-    return ptr;
-  }
-  void set_heap_ptr_(char *ptr) { std::memcpy(this->storage_, &ptr, sizeof(ptr)); }
-
-  // Storage for string data. When is_heap_=0, contains the string directly (null-terminated).
-  // When is_heap_=1, first sizeof(char*) bytes contain pointer to heap allocation.
-  char storage_[INLINE_CAPACITY + 1];  // 19 bytes: 18 chars + null terminator
-  uint8_t length_ : 7;                 // String length (0-127)
-  uint8_t is_heap_ : 1;                // 1 if using heap pointer, 0 if using inline storage
-  // Total size: 20 bytes (19 bytes storage + 1 byte bitfields)
-};
-
-static_assert(sizeof(CompactString) == 20, "CompactString must be exactly 20 bytes");
-
 }  // namespace esphome

esphome/core/progmem.h

@@ -12,6 +12,10 @@
 #define ESPHOME_strncpy_P strncpy_P
 #define ESPHOME_strncat_P strncat_P
 #define ESPHOME_snprintf_P snprintf_P
+#define ESPHOME_strcmp_P strcmp_P
+#define ESPHOME_strcasecmp_P strcasecmp_P
+#define ESPHOME_strncmp_P strncmp_P
+#define ESPHOME_strncasecmp_P strncasecmp_P
 // Type for pointers to PROGMEM strings (for use with ESPHOME_F return values)
 using ProgmemStr = const __FlashStringHelper *;
 #else
@@ -21,6 +25,10 @@ using ProgmemStr = const __FlashStringHelper *;
 #define ESPHOME_strncpy_P strncpy
 #define ESPHOME_strncat_P strncat
 #define ESPHOME_snprintf_P snprintf
+#define ESPHOME_strcmp_P strcmp
+#define ESPHOME_strcasecmp_P strcasecmp
+#define ESPHOME_strncmp_P strncmp
+#define ESPHOME_strncasecmp_P strncasecmp
 // Type for pointers to strings (no PROGMEM on non-ESP8266 platforms)
 using ProgmemStr = const char *;
 #endif

esphome/espota2.py

@@ -154,6 +154,12 @@ def check_error(data: list[int] | bytes, expect: int | list[int] | None) -> None
     """
     if not expect:
         return
+    if not data:
+        raise OTAError(
+            "Error: Device closed connection without responding. "
+            "This may indicate the device ran out of memory, "
+            "a network issue, or the connection was interrupted."
+        )
     dat = data[0]
     if dat == RESPONSE_ERROR_MAGIC:
         raise OTAError("Error: Invalid magic byte")

platformio.ini

@@ -212,7 +212,7 @@ build_unflags =
 ; This are common settings for the LibreTiny (all variants) using Arduino.
 [common:libretiny-arduino]
 extends = common:arduino
-platform = libretiny@1.9.2
+platform = https://github.com/libretiny-eu/libretiny.git#v1.11.0
 framework = arduino
 lib_compat_mode = soft
 lib_deps =

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools==80.10.1", "wheel>=0.43,<0.47"]
+requires = ["setuptools==80.10.2", "wheel>=0.43,<0.47"]
 build-backend = "setuptools.build_meta"
 
 [project]

requirements.txt

@@ -12,7 +12,7 @@ platformio==6.1.18  # When updating platformio, also update /docker/Dockerfile
 esptool==5.1.0
 click==8.1.7
 esphome-dashboard==20260110.0
-aioesphomeapi==43.13.0
+aioesphomeapi==43.14.0
 zeroconf==0.148.0
 puremagic==1.30
 ruamel.yaml==0.19.1 # dashboard_import

tests/components/http_request/test-custom-ca.esp32-idf.yaml

@@ -0,0 +1,7 @@
+substitutions:
+  verify_ssl: "true"
+
+http_request:
+  ca_certificate_path: $component_dir/test_ca.pem
+
+<<: !include common.yaml

tests/components/http_request/test_ca.pem

@@ -0,0 +1,10 @@
+-----BEGIN CERTIFICATE-----
+MIIBkTCB+wIJAKHBfpegPjMCMA0GCSqGSIb3DQEBCwUAMBExDzANBgNVBAMMBnVu
+dXNlZDAeFw0yNDAxMDEwMDAwMDBaFw0yNTAxMDEwMDAwMDBaMBExDzANBgNVBAMM
+BnVudXNlZDBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQC5mMUB1hOgLmlnXtsvcGMP
+XkhAqZaR0dDPW5OS8VEopWLJCX9Y0cvNCqiDI8cnP8pP8XJGU1hGLvA5PJzWnWZz
+AgMBAAGjUzBRMB0GA1UdDgQWBBR5oQ9KqFeZOdBuAJrXxEP0dqzPtTAfBgNVHSME
+GDAWgBR5oQ9KqFeZOdBuAJrXxEP0dqzPtTAPBgNVHRMBAf8EBTADAQH/MA0GCSqG
+SIb3DQEBCwUAA0EAKqZFf6+f8FPDbKyPCpssquojgn7fEXqr/I/yz0R5CowGdMms
+H3WH3aKP4lLSHdPTBtfIoJi3gEIZjFxp3S1TWw==
+-----END CERTIFICATE-----

tests/components/text_sensor/common.yaml

@@ -64,3 +64,16 @@ text_sensor:
           - suffix -> SUFFIX
       - map:
           - PREFIX text SUFFIX -> mapped
+
+  - platform: template
+    name: "Test Lambda Filter"
+    id: test_lambda_filter
+    filters:
+      - lambda: |-
+          return {"[" + x + "]"};
+      - to_upper
+      - lambda: |-
+          if (x.length() > 10) {
+            return {x.substr(0, 10) + "..."};
+          }
+          return {x};

tests/integration/fixtures/text_sensor_raw_state.yaml

@@ -56,6 +56,36 @@ text_sensor:
       - prepend: "["
       - append: "]"
 
+  - platform: template
+    name: "To Lower Sensor"
+    id: to_lower_sensor
+    filters:
+      - to_lower
+
+  - platform: template
+    name: "Lambda Sensor"
+    id: lambda_sensor
+    filters:
+      - lambda: |-
+          return {"[" + x + "]"};
+
+  - platform: template
+    name: "Lambda Raw State Sensor"
+    id: lambda_raw_state_sensor
+    filters:
+      - lambda: |-
+          return {x + " MODIFIED"};
+
+  - platform: template
+    name: "Lambda Skip Sensor"
+    id: lambda_skip_sensor
+    filters:
+      - lambda: |-
+          if (x == "skip") {
+            return {};
+          }
+          return {x + " passed"};
+
 # Button to publish values and log raw_state vs state
 button:
   - platform: template
@@ -179,3 +209,73 @@ button:
           format: "CHAINED: state='%s'"
           args:
             - id(chained_sensor).state.c_str()
+
+  - platform: template
+    name: "Test To Lower Button"
+    id: test_to_lower_button
+    on_press:
+      - text_sensor.template.publish:
+          id: to_lower_sensor
+          state: "HELLO WORLD"
+      - delay: 50ms
+      - logger.log:
+          format: "TO_LOWER: state='%s'"
+          args:
+            - id(to_lower_sensor).state.c_str()
+
+  - platform: template
+    name: "Test Lambda Button"
+    id: test_lambda_button
+    on_press:
+      - text_sensor.template.publish:
+          id: lambda_sensor
+          state: "test"
+      - delay: 50ms
+      - logger.log:
+          format: "LAMBDA: state='%s'"
+          args:
+            - id(lambda_sensor).state.c_str()
+
+  - platform: template
+    name: "Test Lambda Pass Button"
+    id: test_lambda_pass_button
+    on_press:
+      - text_sensor.template.publish:
+          id: lambda_skip_sensor
+          state: "value"
+      - delay: 50ms
+      - logger.log:
+          format: "LAMBDA_PASS: state='%s'"
+          args:
+            - id(lambda_skip_sensor).state.c_str()
+
+  - platform: template
+    name: "Test Lambda Skip Button"
+    id: test_lambda_skip_button
+    on_press:
+      - text_sensor.template.publish:
+          id: lambda_skip_sensor
+          state: "skip"
+      - delay: 50ms
+      # When lambda returns {}, the value should NOT be published
+      # so state should remain from previous publish (or empty if first)
+      - logger.log:
+          format: "LAMBDA_SKIP: state='%s'"
+          args:
+            - id(lambda_skip_sensor).state.c_str()
+
+  - platform: template
+    name: "Test Lambda Raw State Button"
+    id: test_lambda_raw_state_button
+    on_press:
+      - text_sensor.template.publish:
+          id: lambda_raw_state_sensor
+          state: "original"
+      - delay: 50ms
+      # Verify raw_state is preserved (not mutated) after lambda filter
+      # state should be "original MODIFIED", raw_state should be "original"
+      - logger.log:
+          format: "LAMBDA_RAW_STATE: state='%s' raw_state='%s'"
+          args:
+            - id(lambda_raw_state_sensor).state.c_str()
+            - id(lambda_raw_state_sensor).get_raw_state().c_str()

tests/integration/test_text_sensor_raw_state.py

@@ -42,6 +42,11 @@ async def test_text_sensor_raw_state(
     map_off_future: asyncio.Future[str] = loop.create_future()
     map_unknown_future: asyncio.Future[str] = loop.create_future()
     chained_future: asyncio.Future[str] = loop.create_future()
+    to_lower_future: asyncio.Future[str] = loop.create_future()
+    lambda_future: asyncio.Future[str] = loop.create_future()
+    lambda_pass_future: asyncio.Future[str] = loop.create_future()
+    lambda_skip_future: asyncio.Future[str] = loop.create_future()
+    lambda_raw_state_future: asyncio.Future[tuple[str, str]] = loop.create_future()
 
     # Patterns to match log output
     # NO_FILTER: state='hello world' raw_state='hello world'
@@ -58,6 +63,13 @@ async def test_text_sensor_raw_state(
     map_off_pattern = re.compile(r"MAP_OFF: state='([^']*)'")
     map_unknown_pattern = re.compile(r"MAP_UNKNOWN: state='([^']*)'")
     chained_pattern = re.compile(r"CHAINED: state='([^']*)'")
+    to_lower_pattern = re.compile(r"TO_LOWER: state='([^']*)'")
+    lambda_pattern = re.compile(r"LAMBDA: state='([^']*)'")
+    lambda_pass_pattern = re.compile(r"LAMBDA_PASS: state='([^']*)'")
+    lambda_skip_pattern = re.compile(r"LAMBDA_SKIP: state='([^']*)'")
+    lambda_raw_state_pattern = re.compile(
+        r"LAMBDA_RAW_STATE: state='([^']*)' raw_state='([^']*)'"
+    )
 
     def check_output(line: str) -> None:
         """Check log output for expected messages."""
@@ -92,6 +104,27 @@ async def test_text_sensor_raw_state(
         if not chained_future.done() and (match := chained_pattern.search(line)):
             chained_future.set_result(match.group(1))
 
+        if not to_lower_future.done() and (match := to_lower_pattern.search(line)):
+            to_lower_future.set_result(match.group(1))
+
+        if not lambda_future.done() and (match := lambda_pattern.search(line)):
+            lambda_future.set_result(match.group(1))
+
+        if not lambda_pass_future.done() and (
+            match := lambda_pass_pattern.search(line)
+        ):
+            lambda_pass_future.set_result(match.group(1))
+
+        if not lambda_skip_future.done() and (
+            match := lambda_skip_pattern.search(line)
+        ):
+            lambda_skip_future.set_result(match.group(1))
+
+        if not lambda_raw_state_future.done() and (
+            match := lambda_raw_state_pattern.search(line)
+        ):
+            lambda_raw_state_future.set_result((match.group(1), match.group(2)))
+
     async with (
         run_compiled(yaml_config, line_callback=check_output),
         api_client_connected() as client,
@@ -272,3 +305,111 @@ async def test_text_sensor_raw_state(
             pytest.fail("Timeout waiting for CHAINED log message")
 
         assert state == "[value]", f"Chained failed: expected '[value]', got '{state}'"
+
+        # Test 10: to_lower filter
+        # "HELLO WORLD" -> "hello world"
+        to_lower_button = next(
+            (e for e in entities if "test_to_lower_button" in e.object_id.lower()),
+            None,
+        )
+        assert to_lower_button is not None, "Test To Lower Button not found"
+        client.button_command(to_lower_button.key)
+
+        try:
+            state = await asyncio.wait_for(to_lower_future, timeout=5.0)
+        except TimeoutError:
+            pytest.fail("Timeout waiting for TO_LOWER log message")
+
+        assert state == "hello world", (
+            f"to_lower failed: expected 'hello world', got '{state}'"
+        )
+
+        # Test 11: Lambda filter
+        # "test" -> "[test]"
+        lambda_button = next(
+            (e for e in entities if "test_lambda_button" in e.object_id.lower()),
+            None,
+        )
+        assert lambda_button is not None, "Test Lambda Button not found"
+        client.button_command(lambda_button.key)
+
+        try:
+            state = await asyncio.wait_for(lambda_future, timeout=5.0)
+        except TimeoutError:
+            pytest.fail("Timeout waiting for LAMBDA log message")
+
+        assert state == "[test]", f"Lambda failed: expected '[test]', got '{state}'"
+
+        # Test 12: Lambda filter - value passes through
+        # "value" -> "value passed"
+        lambda_pass_button = next(
+            (e for e in entities if "test_lambda_pass_button" in e.object_id.lower()),
+            None,
+        )
+        assert lambda_pass_button is not None, "Test Lambda Pass Button not found"
+        client.button_command(lambda_pass_button.key)
+
+        try:
+            state = await asyncio.wait_for(lambda_pass_future, timeout=5.0)
+        except TimeoutError:
+            pytest.fail("Timeout waiting for LAMBDA_PASS log message")
+
+        assert state == "value passed", (
+            f"Lambda pass failed: expected 'value passed', got '{state}'"
+        )
+
+        # Test 13: Lambda filter - skip publishing (return {})
+        # "skip" -> no publish, state remains "value passed" from previous test
+        lambda_skip_button = next(
+            (e for e in entities if "test_lambda_skip_button" in e.object_id.lower()),
+            None,
+        )
+        assert lambda_skip_button is not None, "Test Lambda Skip Button not found"
+        client.button_command(lambda_skip_button.key)
+
+        try:
+            state = await asyncio.wait_for(lambda_skip_future, timeout=5.0)
+        except TimeoutError:
+            pytest.fail("Timeout waiting for LAMBDA_SKIP log message")
+
+        # When lambda returns {}, value should NOT be published
+        # State remains from previous successful publish ("value passed")
+        assert state == "value passed", (
+            f"Lambda skip failed: expected 'value passed' (unchanged), got '{state}'"
+        )
+
+        # Test 14: Lambda filter - verify raw_state is preserved (not mutated)
+        # This is critical to verify the in-place mutation optimization is safe
+        # "original" -> state="original MODIFIED", raw_state="original"
+        lambda_raw_state_button = next(
+            (
+                e
+                for e in entities
+                if "test_lambda_raw_state_button" in e.object_id.lower()
+            ),
+            None,
+        )
+        assert lambda_raw_state_button is not None, (
+            "Test Lambda Raw State Button not found"
+        )
+        client.button_command(lambda_raw_state_button.key)
+
+        try:
+            state, raw_state = await asyncio.wait_for(
+                lambda_raw_state_future, timeout=5.0
+            )
+        except TimeoutError:
+            pytest.fail("Timeout waiting for LAMBDA_RAW_STATE log message")
+
+        assert state == "original MODIFIED", (
+            f"Lambda raw_state test failed: expected state='original MODIFIED', "
+            f"got '{state}'"
+        )
+        assert raw_state == "original", (
+            f"Lambda raw_state test failed: raw_state was mutated! "
+            f"Expected 'original', got '{raw_state}'"
+        )
+        assert state != raw_state, (
+            f"Lambda filter should modify state but preserve raw_state. "
+            f"state='{state}', raw_state='{raw_state}'"
+        )

tests/unit_tests/test_espota2.py

@@ -192,6 +192,20 @@ def test_check_error_unexpected_response() -> None:
         espota2.check_error([0x7F], [espota2.RESPONSE_OK, espota2.RESPONSE_AUTH_OK])
 
 
+def test_check_error_empty_data() -> None:
+    """Test check_error raises error when device closes connection without responding."""
+    with pytest.raises(
+        espota2.OTAError, match="Device closed connection without responding"
+    ):
+        espota2.check_error([], [espota2.RESPONSE_OK])
+
+    # Also test with empty bytes
+    with pytest.raises(
+        espota2.OTAError, match="Device closed connection without responding"
+    ):
+        espota2.check_error(b"", [espota2.RESPONSE_OK])
+
+
 def test_send_check_with_various_data_types(mock_socket: Mock) -> None:
     """Test send_check handles different data types."""