[wifi] Change priority type from float to int8_t

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         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@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v4.31.2
         with:
           category: "/language:${{matrix.language}}"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ ci:
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.14.5
+    rev: v0.14.4
     hooks:
       # Run the linter.
       - id: ruff

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.12.0-dev
+PROJECT_NUMBER         = 2025.11.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/analyze_memory/cli.py

@@ -16,11 +16,6 @@ from . import (
 class MemoryAnalyzerCLI(MemoryAnalyzer):
     """Memory analyzer with CLI-specific report generation."""
 
-    # Symbol size threshold for detailed analysis
-    SYMBOL_SIZE_THRESHOLD: int = (
-        100  # Show symbols larger than this in detailed analysis
-    )
-
     # Column width constants
     COL_COMPONENT: int = 29
     COL_FLASH_TEXT: int = 14
@@ -197,21 +192,14 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                     f"{len(symbols):>{self.COL_CORE_COUNT}} | {percentage:>{self.COL_CORE_PERCENT - 1}.1f}%"
                 )
 
-            # All core symbols above threshold
+            # Top 15 largest core symbols
             lines.append("")
+            lines.append(f"Top 15 Largest {_COMPONENT_CORE} Symbols:")
             sorted_core_symbols = sorted(
                 self._esphome_core_symbols, key=lambda x: x[2], reverse=True
             )
-            large_core_symbols = [
-                (symbol, demangled, size)
-                for symbol, demangled, size in sorted_core_symbols
-                if size > self.SYMBOL_SIZE_THRESHOLD
-            ]
 
-            lines.append(
-                f"{_COMPONENT_CORE} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_core_symbols)} symbols):"
-            )
-            for i, (symbol, demangled, size) in enumerate(large_core_symbols):
+            for i, (symbol, demangled, size) in enumerate(sorted_core_symbols[:15]):
                 lines.append(f"{i + 1}. {demangled} ({size:,} B)")
 
             lines.append("=" * self.TABLE_WIDTH)
@@ -281,15 +269,13 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
                 lines.append(f"Total size: {comp_mem.flash_total:,} B")
                 lines.append("")
 
-                # Show all symbols above threshold for better visibility
+                # Show all symbols > 100 bytes for better visibility
                 large_symbols = [
-                    (sym, dem, size)
-                    for sym, dem, size in sorted_symbols
-                    if size > self.SYMBOL_SIZE_THRESHOLD
+                    (sym, dem, size) for sym, dem, size in sorted_symbols if size > 100
                 ]
 
                 lines.append(
-                    f"{comp_name} Symbols > {self.SYMBOL_SIZE_THRESHOLD} B ({len(large_symbols)} symbols):"
+                    f"{comp_name} Symbols > 100 B ({len(large_symbols)} symbols):"
                 )
                 for i, (symbol, demangled, size) in enumerate(large_symbols):
                     lines.append(f"{i + 1}. {demangled} ({size:,} B)")

esphome/components/api/api_connection.cpp

@@ -476,9 +476,8 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
   auto *light = static_cast<light::LightState *>(entity);
   ListEntitiesLightResponse msg;
   auto traits = light->get_traits();
-  auto supported_modes = traits.get_supported_color_modes();
   // Pass pointer to ColorModeMask so the iterator can encode actual ColorMode enum values
-  msg.supported_color_modes = &supported_modes;
+  msg.supported_color_modes = &traits.get_supported_color_modes();
   if (traits.supports_color_capability(light::ColorCapability::COLOR_TEMPERATURE) ||
       traits.supports_color_capability(light::ColorCapability::COLD_WARM_WHITE)) {
     msg.min_mireds = traits.get_min_mireds();
@@ -1296,8 +1295,8 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 
 #ifdef USE_EVENT
 void APIConnection::send_event(event::Event *event, const char *event_type) {
-  this->send_message_smart_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
-                            EventResponse::ESTIMATED_SIZE);
+  this->schedule_message_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE,
+                          EventResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_event_response(event::Event *event, const char *event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {

esphome/components/api/api_connection.h

@@ -650,30 +650,21 @@ class APIConnection final : public APIServerConnection {
   }
 #endif
 
-  // Helper to check if a message type should bypass batching
-  // Returns true if:
-  // 1. It's an UpdateStateResponse (always send immediately to handle cases where
-  //    the main loop is blocked, e.g., during OTA updates)
-  // 2. It's an EventResponse (events are edge-triggered - every occurrence matters)
-  // 3. OR: User has opted into immediate sending (should_try_send_immediately = true
-  //    AND batch_delay = 0)
-  inline bool should_send_immediately_(uint8_t message_type) const {
-    return (
-#ifdef USE_UPDATE
-        message_type == UpdateStateResponse::MESSAGE_TYPE ||
-#endif
-#ifdef USE_EVENT
-        message_type == EventResponse::MESSAGE_TYPE ||
-#endif
-        (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0));
-  }
-
   // Helper method to send a message either immediately or via batching
-  // 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, MessageCreatorPtr creator, uint8_t message_type,
                            uint8_t estimated_size) {
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+    // Try to send immediately if:
+    // 1. It's an UpdateStateResponse (always send immediately to handle cases where
+    //    the main loop is blocked, e.g., during OTA updates)
+    // 2. OR: We should try to send immediately (should_try_send_immediately = true)
+    //        AND Batch delay is 0 (user has opted in to immediate sending)
+    // 3. AND: Buffer has space available
+    if ((
+#ifdef USE_UPDATE
+            message_type == UpdateStateResponse::MESSAGE_TYPE ||
+#endif
+            (this->flags_.should_try_send_immediately && this->get_batch_delay_ms_() == 0)) &&
+        this->helper_->can_write_without_blocking()) {
       // Now actually encode and send
       if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
@@ -691,27 +682,6 @@ class APIConnection final : public APIServerConnection {
     return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
-  // Overload for MessageCreator (used by events which need to capture event_type)
-  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
-    // Try to send immediately if message type should bypass batching and buffer has space
-    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-      // Now actually encode and send
-      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
-          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-        // Log the message in verbose mode
-        this->log_proto_message_(entity, creator, message_type);
-#endif
-        return true;
-      }
-
-      // If immediate send failed, fall through to batching
-    }
-
-    // Fall back to scheduled batching
-    return this->schedule_message_(entity, std::move(creator), message_type, estimated_size);
-  }
-
   // Helper function to schedule a deferred message with known message type
   bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
     this->deferred_batch_.add_item(entity, std::move(creator), message_type, estimated_size);

esphome/components/api/user_services.h

@@ -51,14 +51,13 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
       return false;
     if (req.args.size() != sizeof...(Ts))
       return false;
-    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, size_t... S>
-  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
+  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 
@@ -96,14 +95,13 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
       return false;
     if (req.args.size() != sizeof...(Ts))
       return false;
-    this->execute_(req.args, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_(req.args, typename gens<sizeof...(Ts)>::type());
     return true;
   }
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<typename ArgsContainer, size_t... S>
-  void execute_(const ArgsContainer &args, std::index_sequence<S...> type) {
+  template<typename ArgsContainer, int... S> void execute_(const ArgsContainer &args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 

esphome/components/bh1750/bh1750.cpp

@@ -1,8 +1,8 @@
 #include "bh1750.h"
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
 static const char *const TAG = "bh1750.sensor";
 
@@ -13,31 +13,6 @@ static const uint8_t BH1750_COMMAND_ONE_TIME_L = 0b00100011;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H = 0b00100000;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H2 = 0b00100001;
 
-static constexpr uint32_t MEASUREMENT_TIMEOUT_MS = 2000;
-static constexpr float HIGH_LIGHT_THRESHOLD_LX = 7000.0f;
-
-// Measurement time constants (datasheet values)
-static constexpr uint16_t MTREG_DEFAULT = 69;
-static constexpr uint16_t MTREG_MIN = 31;
-static constexpr uint16_t MTREG_MAX = 254;
-static constexpr uint16_t MEAS_TIME_L_MS = 24;   // L-resolution max measurement time @ mtreg=69
-static constexpr uint16_t MEAS_TIME_H_MS = 180;  // H/H2-resolution max measurement time @ mtreg=69
-
-// Conversion constants (datasheet formulas)
-static constexpr float RESOLUTION_DIVISOR = 1.2f;  // counts to lux conversion divisor
-static constexpr float MODE_H2_DIVISOR = 2.0f;     // H2 mode has 2x higher resolution
-
-// MTreg calculation constants
-static constexpr int COUNTS_TARGET = 50000;  // Target counts for optimal range (avoid saturation)
-static constexpr int COUNTS_NUMERATOR = 10;
-static constexpr int COUNTS_DENOMINATOR = 12;
-
-// MTreg register bit manipulation constants
-static constexpr uint8_t MTREG_HI_SHIFT = 5;       // High 3 bits start at bit 5
-static constexpr uint8_t MTREG_HI_MASK = 0b111;    // 3-bit mask for high bits
-static constexpr uint8_t MTREG_LO_SHIFT = 0;       // Low 5 bits start at bit 0
-static constexpr uint8_t MTREG_LO_MASK = 0b11111;  // 5-bit mask for low bits
-
 /*
 bh1750 properties:
 
@@ -68,7 +43,74 @@ void BH1750Sensor::setup() {
     this->mark_failed();
     return;
   }
-  this->state_ = IDLE;
+}
+
+void BH1750Sensor::read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f) {
+  // turn on (after one-shot sensor automatically powers down)
+  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
+  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Power on failed");
+    f(NAN);
+    return;
+  }
+
+  if (active_mtreg_ != mtreg) {
+    // set mtreg
+    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> 5) & 0b111);
+    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> 0) & 0b11111);
+    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Set measurement time failed");
+      active_mtreg_ = 0;
+      f(NAN);
+      return;
+    }
+    active_mtreg_ = mtreg;
+  }
+
+  uint8_t cmd;
+  uint16_t meas_time;
+  switch (mode) {
+    case BH1750_MODE_L:
+      cmd = BH1750_COMMAND_ONE_TIME_L;
+      meas_time = 24 * mtreg / 69;
+      break;
+    case BH1750_MODE_H:
+      cmd = BH1750_COMMAND_ONE_TIME_H;
+      meas_time = 180 * mtreg / 69;
+      break;
+    case BH1750_MODE_H2:
+      cmd = BH1750_COMMAND_ONE_TIME_H2;
+      meas_time = 180 * mtreg / 69;
+      break;
+    default:
+      f(NAN);
+      return;
+  }
+  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Start measurement failed");
+    f(NAN);
+    return;
+  }
+
+  // probably not needed, but adjust for rounding
+  meas_time++;
+
+  this->set_timeout("read", meas_time, [this, mode, mtreg, f]() {
+    uint16_t raw_value;
+    if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Read data failed");
+      f(NAN);
+      return;
+    }
+    raw_value = i2c::i2ctohs(raw_value);
+
+    float lx = float(raw_value) / 1.2f;
+    lx *= 69.0f / mtreg;
+    if (mode == BH1750_MODE_H2)
+      lx /= 2.0f;
+
+    f(lx);
+  });
 }
 
 void BH1750Sensor::dump_config() {
@@ -82,188 +124,45 @@ void BH1750Sensor::dump_config() {
 }
 
 void BH1750Sensor::update() {
-  const uint32_t now = millis();
-
-  // Start coarse measurement to determine optimal mode/mtreg
-  if (this->state_ != IDLE) {
-    // Safety timeout: reset if stuck
-    if (now - this->measurement_start_time_ > MEASUREMENT_TIMEOUT_MS) {
-      ESP_LOGW(TAG, "Measurement timeout, resetting state");
-      this->state_ = IDLE;
-    } else {
-      ESP_LOGW(TAG, "Previous measurement not complete, skipping update");
+  // first do a quick measurement in L-mode with full range
+  // to find right range
+  this->read_lx_(BH1750_MODE_L, 31, [this](float val) {
+    if (std::isnan(val)) {
+      this->status_set_warning();
+      this->publish_state(NAN);
       return;
     }
-  }
 
-  if (!this->start_measurement_(BH1750_MODE_L, MTREG_MIN, now)) {
-    this->status_set_warning();
-    this->publish_state(NAN);
-    return;
-  }
-
-  this->state_ = WAITING_COARSE_MEASUREMENT;
-  this->enable_loop();  // Enable loop while measurement in progress
-}
-
-void BH1750Sensor::loop() {
-  const uint32_t now = App.get_loop_component_start_time();
-
-  switch (this->state_) {
-    case IDLE:
-      // Disable loop when idle to save cycles
-      this->disable_loop();
-      break;
-
-    case WAITING_COARSE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_COARSE_RESULT;
-      }
-      break;
-
-    case READING_COARSE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->process_coarse_result_(lx);
-
-      // Start fine measurement with optimal settings
-      if (!this->start_measurement_(this->fine_mode_, this->fine_mtreg_, now)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->state_ = WAITING_FINE_MEASUREMENT;
-      break;
+    BH1750Mode use_mode;
+    uint8_t use_mtreg;
+    if (val <= 7000) {
+      use_mode = BH1750_MODE_H2;
+      use_mtreg = 254;
+    } else {
+      use_mode = BH1750_MODE_H;
+      // lx = counts / 1.2 * (69 / mtreg)
+      // -> mtreg = counts / 1.2 * (69 / lx)
+      // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
+      // -> mtreg = 50000*(10/12)*(69/lx)
+      int ideal_mtreg = 50000 * 10 * 69 / (12 * (int) val);
+      use_mtreg = std::min(254, std::max(31, ideal_mtreg));
     }
+    ESP_LOGV(TAG, "L result: %f -> Calculated mode=%d, mtreg=%d", val, (int) use_mode, use_mtreg);
 
-    case WAITING_FINE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_FINE_RESULT;
+    this->read_lx_(use_mode, use_mtreg, [this](float val) {
+      if (std::isnan(val)) {
+        this->status_set_warning();
+        this->publish_state(NAN);
+        return;
       }
-      break;
-
-    case READING_FINE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), val);
       this->status_clear_warning();
-      this->publish_state(lx);
-      this->state_ = IDLE;
-      break;
-    }
-  }
-}
-
-bool BH1750Sensor::start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now) {
-  // Power on
-  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
-  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Power on failed");
-    return false;
-  }
-
-  // Set MTreg if changed
-  if (this->active_mtreg_ != mtreg) {
-    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> MTREG_HI_SHIFT) & MTREG_HI_MASK);
-    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> MTREG_LO_SHIFT) & MTREG_LO_MASK);
-    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
-      ESP_LOGW(TAG, "Set measurement time failed");
-      this->active_mtreg_ = 0;
-      return false;
-    }
-    this->active_mtreg_ = mtreg;
-  }
-
-  // Start measurement
-  uint8_t cmd;
-  uint16_t meas_time;
-  switch (mode) {
-    case BH1750_MODE_L:
-      cmd = BH1750_COMMAND_ONE_TIME_L;
-      meas_time = MEAS_TIME_L_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H:
-      cmd = BH1750_COMMAND_ONE_TIME_H;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H2:
-      cmd = BH1750_COMMAND_ONE_TIME_H2;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    default:
-      return false;
-  }
-
-  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Start measurement failed");
-    return false;
-  }
-
-  // Store current measurement parameters
-  this->current_mode_ = mode;
-  this->current_mtreg_ = mtreg;
-  this->measurement_start_time_ = now;
-  this->measurement_duration_ = meas_time + 1;  // Add 1ms for safety
-
-  return true;
-}
-
-bool BH1750Sensor::read_measurement_(float &lx_out) {
-  uint16_t raw_value;
-  if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Read data failed");
-    return false;
-  }
-  raw_value = i2c::i2ctohs(raw_value);
-
-  float lx = float(raw_value) / RESOLUTION_DIVISOR;
-  lx *= float(MTREG_DEFAULT) / this->current_mtreg_;
-  if (this->current_mode_ == BH1750_MODE_H2) {
-    lx /= MODE_H2_DIVISOR;
-  }
-
-  lx_out = lx;
-  return true;
-}
-
-void BH1750Sensor::process_coarse_result_(float lx) {
-  if (std::isnan(lx)) {
-    // Use defaults if coarse measurement failed
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-    return;
-  }
-
-  if (lx <= HIGH_LIGHT_THRESHOLD_LX) {
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-  } else {
-    this->fine_mode_ = BH1750_MODE_H;
-    // lx = counts / 1.2 * (69 / mtreg)
-    // -> mtreg = counts / 1.2 * (69 / lx)
-    // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
-    // -> mtreg = 50000*(10/12)*(69/lx)
-    int ideal_mtreg = COUNTS_TARGET * COUNTS_NUMERATOR * MTREG_DEFAULT / (COUNTS_DENOMINATOR * (int) lx);
-    this->fine_mtreg_ = std::min((int) MTREG_MAX, std::max((int) MTREG_MIN, ideal_mtreg));
-  }
-
-  ESP_LOGV(TAG, "L result: %.1f -> Calculated mode=%d, mtreg=%d", lx, (int) this->fine_mode_, this->fine_mtreg_);
-}
-
-void BH1750Sensor::fail_and_reset_() {
-  this->status_set_warning();
-  this->publish_state(NAN);
-  this->state_ = IDLE;
+      this->publish_state(val);
+    });
+  });
 }
 
 float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/bh1750/bh1750.h

@@ -4,9 +4,10 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
-enum BH1750Mode : uint8_t {
+enum BH1750Mode {
   BH1750_MODE_L,
   BH1750_MODE_H,
   BH1750_MODE_H2,
@@ -20,36 +21,13 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void setup() override;
   void dump_config() override;
   void update() override;
-  void loop() override;
   float get_setup_priority() const override;
 
  protected:
-  // State machine states
-  enum State : uint8_t {
-    IDLE,
-    WAITING_COARSE_MEASUREMENT,
-    READING_COARSE_RESULT,
-    WAITING_FINE_MEASUREMENT,
-    READING_FINE_RESULT,
-  };
+  void read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f);
 
-  // 4-byte aligned members
-  uint32_t measurement_start_time_{0};
-  uint32_t measurement_duration_{0};
-
-  // 1-byte members grouped together to minimize padding
-  State state_{IDLE};
-  BH1750Mode current_mode_{BH1750_MODE_L};
-  uint8_t current_mtreg_{31};
-  BH1750Mode fine_mode_{BH1750_MODE_H2};
-  uint8_t fine_mtreg_{254};
   uint8_t active_mtreg_{0};
-
-  // Helper methods
-  bool start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now);
-  bool read_measurement_(float &lx_out);
-  void process_coarse_result_(float lx);
-  void fail_and_reset_();
 };
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/binary_sensor/automation.cpp

@@ -1,11 +1,12 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor.automation";
 
-void MultiClickTrigger::on_state_(bool state) {
+void binary_sensor::MultiClickTrigger::on_state_(bool state) {
   // Handle duplicate events
   if (state == this->last_state_) {
     return;
@@ -66,7 +67,7 @@ void MultiClickTrigger::on_state_(bool state) {
 
   *this->at_index_ = *this->at_index_ + 1;
 }
-void MultiClickTrigger::schedule_cooldown_() {
+void binary_sensor::MultiClickTrigger::schedule_cooldown_() {
   ESP_LOGV(TAG, "Multi Click: Invalid length of press, starting cooldown of %" PRIu32 " ms", this->invalid_cooldown_);
   this->is_in_cooldown_ = true;
   this->set_timeout("cooldown", this->invalid_cooldown_, [this]() {
@@ -78,7 +79,7 @@ void MultiClickTrigger::schedule_cooldown_() {
   this->cancel_timeout("is_valid");
   this->cancel_timeout("is_not_valid");
 }
-void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
   if (min_length == 0) {
     this->is_valid_ = true;
     return;
@@ -89,19 +90,19 @@ void MultiClickTrigger::schedule_is_valid_(uint32_t min_length) {
     this->is_valid_ = true;
   });
 }
-void MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
+void binary_sensor::MultiClickTrigger::schedule_is_not_valid_(uint32_t max_length) {
   this->set_timeout("is_not_valid", max_length, [this]() {
     ESP_LOGV(TAG, "Multi Click: You waited too long to %s.", this->parent_->state ? "RELEASE" : "PRESS");
     this->is_valid_ = false;
     this->schedule_cooldown_();
   });
 }
-void MultiClickTrigger::cancel() {
+void binary_sensor::MultiClickTrigger::cancel() {
   ESP_LOGV(TAG, "Multi Click: Sequence explicitly cancelled.");
   this->is_valid_ = false;
   this->schedule_cooldown_();
 }
-void MultiClickTrigger::trigger_() {
+void binary_sensor::MultiClickTrigger::trigger_() {
   ESP_LOGV(TAG, "Multi Click: Hooray, multi click is valid. Triggering!");
   this->at_index_.reset();
   this->cancel_timeout("trigger");
@@ -117,4 +118,5 @@ bool match_interval(uint32_t min_length, uint32_t max_length, uint32_t length) {
     return length >= min_length && length <= max_length;
   }
 }
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/automation.h

@@ -9,7 +9,8 @@
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/binary_sensor.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+namespace binary_sensor {
 
 struct MultiClickTriggerEvent {
   bool state;
@@ -171,4 +172,5 @@ template<typename... Ts> class BinarySensorInvalidateAction : public Action<Ts..
   BinarySensor *sensor_;
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/binary_sensor.cpp

@@ -3,7 +3,9 @@
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
@@ -61,4 +63,6 @@ void BinarySensor::add_filters(std::initializer_list<Filter *> filters) {
 }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/binary_sensor/binary_sensor.h

@@ -6,7 +6,9 @@
 
 #include <initializer_list>
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 class BinarySensor;
 void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj);
@@ -68,4 +70,5 @@ class BinarySensorInitiallyOff : public BinarySensor {
   bool has_state() const override { return true; }
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+}  // namespace esphome

esphome/components/binary_sensor/filter.cpp

@@ -2,7 +2,9 @@
 
 #include "binary_sensor.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
@@ -130,4 +132,6 @@ optional<bool> SettleFilter::new_value(bool value) {
 
 float SettleFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/binary_sensor/filter.h

@@ -4,7 +4,9 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-namespace esphome::binary_sensor {
+namespace esphome {
+
+namespace binary_sensor {
 
 class BinarySensor;
 
@@ -137,4 +139,6 @@ class SettleFilter : public Filter, public Component {
   bool steady_{true};
 };
 
-}  // namespace esphome::binary_sensor
+}  // namespace binary_sensor
+
+}  // namespace esphome

esphome/components/captive_portal/__init__.py

@@ -1,12 +1,9 @@
-import logging
-
 import esphome.codegen as cg
 from esphome.components import web_server_base
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_AP,
     CONF_ID,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
@@ -17,10 +14,6 @@ from esphome.const import (
 )
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
 
 
 def AUTO_LOAD() -> list[str]:
@@ -57,27 +50,6 @@ CONFIG_SCHEMA = cv.All(
 )
 
 
-def _final_validate(config: ConfigType) -> ConfigType:
-    full_config = fv.full_config.get()
-    wifi_conf = full_config.get("wifi")
-
-    if wifi_conf is None:
-        # This shouldn't happen due to DEPENDENCIES = ["wifi"], but check anyway
-        raise cv.Invalid("Captive portal requires the wifi component to be configured")
-
-    if CONF_AP not in wifi_conf:
-        _LOGGER.warning(
-            "Captive portal is enabled but no WiFi AP is configured. "
-            "The captive portal will not be accessible. "
-            "Add 'ap:' to your WiFi configuration to enable the captive portal."
-        )
-
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 @coroutine_with_priority(CoroPriority.CAPTIVE_PORTAL)
 async def to_code(config):
     paren = await cg.get_variable(config[CONF_WEB_SERVER_BASE_ID])

esphome/components/cover/automation.h

@@ -4,7 +4,8 @@
 #include "esphome/core/automation.h"
 #include "cover.h"
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 template<typename... Ts> class OpenAction : public Action<Ts...> {
  public:
@@ -130,4 +131,5 @@ class CoverClosedTrigger : public Trigger<> {
   }
 };
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/cover/cover.cpp

@@ -6,7 +6,8 @@
 
 #include "esphome/core/log.h"
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 static const char *const TAG = "cover";
 
@@ -211,4 +212,5 @@ void CoverRestoreState::apply(Cover *cover) {
   cover->publish_state();
 }
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/cover/cover.h

@@ -7,7 +7,8 @@
 
 #include "cover_traits.h"
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 const extern float COVER_OPEN;
 const extern float COVER_CLOSED;
@@ -156,4 +157,5 @@ class Cover : public EntityBase, public EntityBase_DeviceClass {
   ESPPreferenceObject rtc_;
 };
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/cover/cover_traits.h

@@ -1,6 +1,7 @@
 #pragma once
 
-namespace esphome::cover {
+namespace esphome {
+namespace cover {
 
 class CoverTraits {
  public:
@@ -25,4 +26,5 @@ class CoverTraits {
   bool supports_stop_{false};
 };
 
-}  // namespace esphome::cover
+}  // namespace cover
+}  // namespace esphome

esphome/components/dashboard_import/dashboard_import.cpp

@@ -3,10 +3,10 @@
 namespace esphome {
 namespace dashboard_import {
 
-static const char *g_package_import_url = "";  // NOLINT
+static std::string g_package_import_url;  // NOLINT
 
-const char *get_package_import_url() { return g_package_import_url; }
-void set_package_import_url(const char *url) { g_package_import_url = url; }
+const std::string &get_package_import_url() { return g_package_import_url; }
+void set_package_import_url(std::string url) { g_package_import_url = std::move(url); }
 
 }  // namespace dashboard_import
 }  // namespace esphome

esphome/components/dashboard_import/dashboard_import.h

@@ -1,10 +1,12 @@
 #pragma once
 
+#include <string>
+
 namespace esphome {
 namespace dashboard_import {
 
-const char *get_package_import_url();
-void set_package_import_url(const char *url);
+const std::string &get_package_import_url();
+void set_package_import_url(std::string url);
 
 }  // namespace dashboard_import
 }  // namespace esphome

esphome/components/debug/debug_component.cpp

@@ -49,9 +49,9 @@ void DebugComponent::dump_config() {
   }
 #endif  // USE_TEXT_SENSOR
 
-#if defined(USE_ESP32) || defined(USE_ZEPHYR)
-  this->log_partition_info_();  // Log partition information
-#endif
+#ifdef USE_ESP32
+  this->log_partition_info_();  // Log partition information for ESP32
+#endif                          // USE_ESP32
 }
 
 void DebugComponent::loop() {

esphome/components/debug/debug_component.h

@@ -62,19 +62,19 @@ class DebugComponent : public PollingComponent {
   sensor::Sensor *cpu_frequency_sensor_{nullptr};
 #endif  // USE_SENSOR
 
-#if defined(USE_ESP32) || defined(USE_ZEPHYR)
+#ifdef USE_ESP32
   /**
    * @brief Logs information about the device's partition table.
    *
-   * This function iterates through the partition table and logs details
+   * This function iterates through the ESP32's partition table and logs details
    * about each partition, including its name, type, subtype, starting address,
    * and size. The information is useful for diagnosing issues related to flash
    * memory or verifying the partition configuration dynamically at runtime.
    *
-   * Only available when compiled for ESP32 and ZEPHYR platforms.
+   * Only available when compiled for ESP32 platforms.
    */
   void log_partition_info_();
-#endif
+#endif  // USE_ESP32
 
 #ifdef USE_TEXT_SENSOR
   text_sensor::TextSensor *device_info_{nullptr};

esphome/components/debug/debug_zephyr.cpp

@@ -5,7 +5,6 @@
 #include <zephyr/drivers/hwinfo.h>
 #include <hal/nrf_power.h>
 #include <cstdint>
-#include <zephyr/storage/flash_map.h>
 
 #define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
 
@@ -87,37 +86,6 @@ std::string DebugComponent::get_reset_reason_() {
 
 uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
 
-static void fa_cb(const struct flash_area *fa, void *user_data) {
-#if CONFIG_FLASH_MAP_LABELS
-  const char *fa_label = flash_area_label(fa);
-
-  if (fa_label == nullptr) {
-    fa_label = "-";
-  }
-  ESP_LOGCONFIG(TAG, "%2d   0x%0*" PRIxPTR "   %-26s  %-24.24s  0x%-10x 0x%-12x", (int) fa->fa_id,
-                sizeof(uintptr_t) * 2, (uintptr_t) fa->fa_dev, fa->fa_dev->name, fa_label, (uint32_t) fa->fa_off,
-                fa->fa_size);
-#else
-  ESP_LOGCONFIG(TAG, "%2d   0x%0*" PRIxPTR "   %-26s  0x%-10x 0x%-12x", (int) fa->fa_id, sizeof(uintptr_t) * 2,
-                (uintptr_t) fa->fa_dev, fa->fa_dev->name, (uint32_t) fa->fa_off, fa->fa_size);
-#endif
-}
-
-void DebugComponent::log_partition_info_() {
-#if CONFIG_FLASH_MAP_LABELS
-  ESP_LOGCONFIG(TAG, "ID | Device     | Device Name               "
-                     "| Label                   | Offset     | Size");
-  ESP_LOGCONFIG(TAG, "--------------------------------------------"
-                     "-----------------------------------------------");
-#else
-  ESP_LOGCONFIG(TAG, "ID | Device     | Device Name               "
-                     "| Offset     | Size");
-  ESP_LOGCONFIG(TAG, "-----------------------------------------"
-                     "------------------------------");
-#endif
-  flash_area_foreach(fa_cb, nullptr);
-}
-
 void DebugComponent::get_device_info_(std::string &device_info) {
   std::string supply = "Main supply status: ";
   if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_NORMAL) {

esphome/components/ds1307/ds1307.cpp

@@ -23,7 +23,7 @@ void DS1307Component::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
-  RealTimeClock::dump_config();
+  ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }
 
 float DS1307Component::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/esp32/__init__.py

@@ -334,14 +334,12 @@ def _is_framework_url(source: str) -> str:
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
     "recommended": cv.Version(3, 3, 2),
-    "latest": cv.Version(3, 3, 4),
-    "dev": cv.Version(3, 3, 4),
+    "latest": cv.Version(3, 3, 2),
+    "dev": cv.Version(3, 3, 2),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 4): cv.Version(55, 3, 31, "2"),
-    cv.Version(3, 3, 3): cv.Version(55, 3, 31, "2"),
-    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "2"),
-    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "2"),
+    cv.Version(3, 3, 2): cv.Version(55, 3, 31, "1"),
+    cv.Version(3, 3, 1): cv.Version(55, 3, 31, "1"),
     cv.Version(3, 3, 0): cv.Version(55, 3, 30, "2"),
     cv.Version(3, 2, 1): cv.Version(54, 3, 21, "2"),
     cv.Version(3, 2, 0): cv.Version(54, 3, 20),
@@ -359,8 +357,8 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
     "dev": cv.Version(5, 5, 1),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "2"),
-    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "2"),
+    cv.Version(5, 5, 1): cv.Version(55, 3, 31, "1"),
+    cv.Version(5, 5, 0): cv.Version(55, 3, 31, "1"),
     cv.Version(5, 4, 3): cv.Version(55, 3, 32),
     cv.Version(5, 4, 2): cv.Version(54, 3, 21, "2"),
     cv.Version(5, 4, 1): cv.Version(54, 3, 21, "2"),
@@ -375,15 +373,14 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 31, "2"),
-    "latest": cv.Version(55, 3, 31, "2"),
-    "dev": cv.Version(55, 3, 31, "2"),
+    "recommended": cv.Version(55, 3, 31, "1"),
+    "latest": cv.Version(55, 3, 31, "1"),
+    "dev": cv.Version(55, 3, 31, "1"),
 }
 
 
-def _check_versions(config):
-    config = config.copy()
-    value = config[CONF_FRAMEWORK]
+def _check_versions(value):
+    value = value.copy()
 
     if value[CONF_VERSION] in PLATFORM_VERSION_LOOKUP:
         if CONF_SOURCE in value or CONF_PLATFORM_VERSION in value:
@@ -448,7 +445,7 @@ def _check_versions(config):
             "If there are connectivity or build issues please remove the manual version."
         )
 
-    return config
+    return value
 
 
 def _parse_platform_version(value):
@@ -498,8 +495,6 @@ def final_validate(config):
     from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
 
     errs = []
-    conf_fw = config[CONF_FRAMEWORK]
-    advanced = conf_fw[CONF_ADVANCED]
     full_config = fv.full_config.get()
     if pio_options := full_config[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS):
         pio_flash_size_key = "board_upload.flash_size"
@@ -516,14 +511,22 @@ def final_validate(config):
                     f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
                 )
             )
-    if config[CONF_VARIANT] != VARIANT_ESP32 and advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
+    if (
+        config[CONF_VARIANT] != VARIANT_ESP32
+        and CONF_ADVANCED in (conf_fw := config[CONF_FRAMEWORK])
+        and CONF_IGNORE_EFUSE_MAC_CRC in conf_fw[CONF_ADVANCED]
+    ):
         errs.append(
             cv.Invalid(
                 f"'{CONF_IGNORE_EFUSE_MAC_CRC}' is not supported on {config[CONF_VARIANT]}",
                 path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
             )
         )
-    if advanced[CONF_EXECUTE_FROM_PSRAM]:
+    if (
+        config.get(CONF_FRAMEWORK, {})
+        .get(CONF_ADVANCED, {})
+        .get(CONF_EXECUTE_FROM_PSRAM)
+    ):
         if config[CONF_VARIANT] != VARIANT_ESP32S3:
             errs.append(
                 cv.Invalid(
@@ -539,17 +542,6 @@ def final_validate(config):
                 )
             )
 
-    if (
-        config[CONF_FLASH_SIZE] == "32MB"
-        and "ota" in full_config
-        and not advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]
-    ):
-        errs.append(
-            cv.Invalid(
-                f"OTA with 32MB flash requires '{CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES}' to be set in the '{CONF_ADVANCED}' section of the esp32 configuration",
-                path=[CONF_FLASH_SIZE],
-            )
-        )
     if errs:
         raise cv.MultipleInvalid(errs)
 
@@ -604,74 +596,89 @@ def _validate_idf_component(config: ConfigType) -> ConfigType:
 
 FRAMEWORK_ESP_IDF = "esp-idf"
 FRAMEWORK_ARDUINO = "arduino"
-FRAMEWORK_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_TYPE): cv.one_of(FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO),
-        cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
-        cv.Optional(CONF_RELEASE): cv.string_strict,
-        cv.Optional(CONF_SOURCE): cv.string_strict,
-        cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
-        cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
-            cv.string_strict: cv.string_strict
-        },
-        cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
-            *LOG_LEVELS_IDF, upper=True
-        ),
-        cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
-            {
-                cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
-                    *ASSERTION_LEVELS, upper=True
-                ),
-                cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
-                    *COMPILER_OPTIMIZATIONS, upper=True
-                ),
-                cv.Optional(
-                    CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES, default=False
-                ): cv.boolean,
-                cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
-                cv.Optional(CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False): cv.boolean,
-                cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC, default=False): cv.boolean,
-                # DHCP server is needed for WiFi AP mode. When WiFi component is used,
-                # it will handle disabling DHCP server when AP is not configured.
-                # Default to false (disabled) when WiFi is not used.
-                cv.OnlyWithout(
-                    CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
-                ): cv.boolean,
-                cv.Optional(CONF_ENABLE_LWIP_MDNS_QUERIES, default=True): cv.boolean,
-                cv.Optional(
-                    CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
-                ): cv.boolean,
-                cv.Optional(
-                    CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
-                ): cv.boolean,
-                cv.Optional(
-                    CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
-                ): cv.boolean,
-                cv.Optional(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_VFS_SUPPORT_SELECT, default=True): cv.boolean,
-                cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
-                cv.Optional(CONF_EXECUTE_FROM_PSRAM, default=False): cv.boolean,
-                cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
-                    min=8192, max=32768
-                ),
-            }
-        ),
-        cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
-            cv.All(
-                cv.Schema(
-                    {
-                        cv.Required(CONF_NAME): cv.string_strict,
-                        cv.Optional(CONF_SOURCE): cv.git_ref,
-                        cv.Optional(CONF_REF): cv.string,
-                        cv.Optional(CONF_PATH): cv.string,
-                        cv.Optional(CONF_REFRESH): cv.All(cv.string, cv.source_refresh),
-                    }
-                ),
-                _validate_idf_component,
-            )
-        ),
-    }
+FRAMEWORK_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Optional(CONF_TYPE, default=FRAMEWORK_ARDUINO): cv.one_of(
+                FRAMEWORK_ESP_IDF, FRAMEWORK_ARDUINO
+            ),
+            cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
+            cv.Optional(CONF_RELEASE): cv.string_strict,
+            cv.Optional(CONF_SOURCE): cv.string_strict,
+            cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
+            cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
+                cv.string_strict: cv.string_strict
+            },
+            cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
+                *LOG_LEVELS_IDF, upper=True
+            ),
+            cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
+                {
+                    cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
+                        *ASSERTION_LEVELS, upper=True
+                    ),
+                    cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
+                        *COMPILER_OPTIMIZATIONS, upper=True
+                    ),
+                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
+                    cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
+                    cv.Optional(
+                        CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
+                    ): cv.boolean,
+                    cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC): cv.boolean,
+                    # DHCP server is needed for WiFi AP mode. When WiFi component is used,
+                    # it will handle disabling DHCP server when AP is not configured.
+                    # Default to false (disabled) when WiFi is not used.
+                    cv.OnlyWithout(
+                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_DISABLE_LIBC_LOCKS_IN_IRAM, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_DISABLE_VFS_SUPPORT_TERMIOS, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_DISABLE_VFS_SUPPORT_SELECT, default=True
+                    ): cv.boolean,
+                    cv.Optional(CONF_DISABLE_VFS_SUPPORT_DIR, default=True): cv.boolean,
+                    cv.Optional(CONF_EXECUTE_FROM_PSRAM): cv.boolean,
+                    cv.Optional(CONF_LOOP_TASK_STACK_SIZE, default=8192): cv.int_range(
+                        min=8192, max=32768
+                    ),
+                }
+            ),
+            cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
+                cv.All(
+                    cv.Schema(
+                        {
+                            cv.Required(CONF_NAME): cv.string_strict,
+                            cv.Optional(CONF_SOURCE): cv.git_ref,
+                            cv.Optional(CONF_REF): cv.string,
+                            cv.Optional(CONF_PATH): cv.string,
+                            cv.Optional(CONF_REFRESH): cv.All(
+                                cv.string, cv.source_refresh
+                            ),
+                        }
+                    ),
+                    _validate_idf_component,
+                )
+            ),
+        }
+    ),
+    _check_versions,
 )
 
 
@@ -734,11 +741,11 @@ def _show_framework_migration_message(name: str, variant: str) -> None:
 
 
 def _set_default_framework(config):
-    config = config.copy()
     if CONF_FRAMEWORK not in config:
-        config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
-    if CONF_TYPE not in config[CONF_FRAMEWORK]:
+        config = config.copy()
+
         variant = config[CONF_VARIANT]
+        config[CONF_FRAMEWORK] = FRAMEWORK_SCHEMA({})
         if variant in ARDUINO_ALLOWED_VARIANTS:
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
             _show_framework_migration_message(
@@ -778,7 +785,6 @@ CONFIG_SCHEMA = cv.All(
     ),
     _detect_variant,
     _set_default_framework,
-    _check_versions,
     set_core_data,
     cv.has_at_least_one_key(CONF_BOARD, CONF_VARIANT),
 )
@@ -797,7 +803,9 @@ def _configure_lwip_max_sockets(conf: dict) -> None:
     from esphome.components.socket import KEY_SOCKET_CONSUMERS
 
     # Check if user manually specified CONFIG_LWIP_MAX_SOCKETS
-    user_max_sockets = conf[CONF_SDKCONFIG_OPTIONS].get("CONFIG_LWIP_MAX_SOCKETS")
+    user_max_sockets = conf.get(CONF_SDKCONFIG_OPTIONS, {}).get(
+        "CONFIG_LWIP_MAX_SOCKETS"
+    )
 
     socket_consumers: dict[str, int] = CORE.data.get(KEY_SOCKET_CONSUMERS, {})
     total_sockets = sum(socket_consumers.values())
@@ -967,18 +975,23 @@ async def to_code(config):
     # WiFi component handles its own optimization when AP mode is not used
     # When using Arduino with Ethernet, DHCP server functions must be available
     # for the Network library to compile, even if not actively used
-    if advanced.get(CONF_ENABLE_LWIP_DHCP_SERVER) is False and not (
-        conf[CONF_TYPE] == FRAMEWORK_ARDUINO and "ethernet" in CORE.loaded_integrations
+    if (
+        CONF_ENABLE_LWIP_DHCP_SERVER in advanced
+        and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
+        and not (
+            conf[CONF_TYPE] == FRAMEWORK_ARDUINO
+            and "ethernet" in CORE.loaded_integrations
+        )
     ):
         add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-    if not advanced[CONF_ENABLE_LWIP_MDNS_QUERIES]:
+    if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-    if not advanced[CONF_ENABLE_LWIP_BRIDGE_INTERFACE]:
+    if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
         add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
 
     _configure_lwip_max_sockets(conf)
 
-    if advanced[CONF_EXECUTE_FROM_PSRAM]:
+    if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
         add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
         add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
 
@@ -989,22 +1002,23 @@ async def to_code(config):
     # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
     # - Up to 200% slower under load when all operations queue through tcpip_thread
     # Enabling this makes ESP-IDF socket performance match Arduino framework.
-    if advanced[CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING]:
+    if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
-    if advanced[CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY]:
+    if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
         add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
 
     # Disable placing libc locks in IRAM to save RAM
     # This is safe for ESPHome since no IRAM ISRs (interrupts that run while cache is disabled)
     # use libc lock APIs. Saves approximately 1.3KB (1,356 bytes) of IRAM.
-    if advanced[CONF_DISABLE_LIBC_LOCKS_IN_IRAM]:
+    if advanced.get(CONF_DISABLE_LIBC_LOCKS_IN_IRAM, True):
         add_idf_sdkconfig_option("CONFIG_LIBC_LOCKS_PLACE_IN_IRAM", False)
 
     # Disable VFS support for termios (terminal I/O functions)
     # ESPHome doesn't use termios functions on ESP32 (only used in host UART driver).
     # Saves approximately 1.8KB of flash when disabled (default).
     add_idf_sdkconfig_option(
-        "CONFIG_VFS_SUPPORT_TERMIOS", not advanced[CONF_DISABLE_VFS_SUPPORT_TERMIOS]
+        "CONFIG_VFS_SUPPORT_TERMIOS",
+        not advanced.get(CONF_DISABLE_VFS_SUPPORT_TERMIOS, True),
     )
 
     # Disable VFS support for select() with file descriptors
@@ -1018,7 +1032,8 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_SELECT", not advanced[CONF_DISABLE_VFS_SUPPORT_SELECT]
+            "CONFIG_VFS_SUPPORT_SELECT",
+            not advanced.get(CONF_DISABLE_VFS_SUPPORT_SELECT, True),
         )
 
     # Disable VFS support for directory functions (opendir, readdir, mkdir, etc.)
@@ -1031,7 +1046,8 @@ async def to_code(config):
     else:
         # No component needs it - allow user to control (default: disabled)
         add_idf_sdkconfig_option(
-            "CONFIG_VFS_SUPPORT_DIR", not advanced[CONF_DISABLE_VFS_SUPPORT_DIR]
+            "CONFIG_VFS_SUPPORT_DIR",
+            not advanced.get(CONF_DISABLE_VFS_SUPPORT_DIR, True),
         )
 
     cg.add_platformio_option("board_build.partitions", "partitions.csv")
@@ -1045,7 +1061,7 @@ async def to_code(config):
             add_idf_sdkconfig_option(flag, assertion_level == key)
 
     add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-    compiler_optimization = advanced[CONF_COMPILER_OPTIMIZATION]
+    compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
     for key, flag in COMPILER_OPTIMIZATIONS.items():
         add_idf_sdkconfig_option(flag, compiler_optimization == key)
 
@@ -1054,20 +1070,18 @@ async def to_code(config):
         conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
     )
 
-    if advanced[CONF_IGNORE_EFUSE_MAC_CRC]:
+    if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
         add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
         add_idf_sdkconfig_option("CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False)
-    if advanced[CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES]:
+    if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
         _LOGGER.warning(
             "Using experimental features in ESP-IDF may result in unexpected failures."
         )
         add_idf_sdkconfig_option("CONFIG_IDF_EXPERIMENTAL_FEATURES", True)
-        if config[CONF_FLASH_SIZE] == "32MB":
-            add_idf_sdkconfig_option(
-                "CONFIG_BOOTLOADER_CACHE_32BIT_ADDR_QUAD_FLASH", True
-            )
 
-    cg.add_define("ESPHOME_LOOP_TASK_STACK_SIZE", advanced[CONF_LOOP_TASK_STACK_SIZE])
+    cg.add_define(
+        "ESPHOME_LOOP_TASK_STACK_SIZE", advanced.get(CONF_LOOP_TASK_STACK_SIZE)
+    )
 
     cg.add_define(
         "USE_ESP_IDF_VERSION_CODE",

esphome/components/esp32_ble/ble.cpp

@@ -638,13 +638,11 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
-    char mac_s[18];
-    format_mac_addr_upper(mac_address, mac_s);
     ESP_LOGCONFIG(TAG,
                   "BLE:\n"
                   "  MAC address: %s\n"
                   "  IO Capability: %s",
-                  mac_s, io_capability_s);
+                  format_mac_address_pretty(mac_address).c_str(), io_capability_s);
   } else {
     ESP_LOGCONFIG(TAG, "Bluetooth stack is not enabled");
   }

esphome/components/esp32_ble_tracker/automation.h

@@ -10,7 +10,7 @@ namespace esphome::esp32_ble_tracker {
 class ESPBTAdvertiseTrigger : public Trigger<const ESPBTDevice &>, public ESPBTDeviceListener {
  public:
   explicit ESPBTAdvertiseTrigger(ESP32BLETracker *parent) { parent->register_listener(this); }
-  void set_addresses(std::initializer_list<uint64_t> addresses) { this->address_vec_ = addresses; }
+  void set_addresses(const std::vector<uint64_t> &addresses) { this->address_vec_ = addresses; }
 
   bool parse_device(const ESPBTDevice &device) override {
     uint64_t u64_addr = device.address_uint64();

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -336,7 +336,7 @@ void ESP32ImprovComponent::process_incoming_data_() {
         this->connecting_sta_ = sta;
 
         wifi::global_wifi_component->set_sta(sta);
-        wifi::global_wifi_component->start_connecting(sta);
+        wifi::global_wifi_component->start_connecting(sta, false);
         this->set_state_(improv::STATE_PROVISIONING);
         ESP_LOGD(TAG, "Received Improv Wi-Fi settings ssid=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
                  command.password.c_str());

esphome/components/ethernet/__init__.py

@@ -383,7 +383,6 @@ async def to_code(config):
     cg.add(var.set_use_address(config[CONF_USE_ADDRESS]))
 
     if CONF_MANUAL_IP in config:
-        cg.add_define("USE_ETHERNET_MANUAL_IP")
         cg.add(var.set_manual_ip(manual_ip(config[CONF_MANUAL_IP])))
 
     # Add compile-time define for PHY types with specific code

esphome/components/ethernet/ethernet_component.cpp

@@ -381,10 +381,7 @@ void EthernetComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "Ethernet:\n"
-                "  Connected: %s",
-                YESNO(this->is_connected()));
+  ESP_LOGCONFIG(TAG, "Ethernet:");
   this->dump_connect_params_();
 #ifdef USE_ETHERNET_SPI
   ESP_LOGCONFIG(TAG,
@@ -553,14 +550,11 @@ void EthernetComponent::start_connect_() {
   }
 
   esp_netif_ip_info_t info;
-#ifdef USE_ETHERNET_MANUAL_IP
   if (this->manual_ip_.has_value()) {
     info.ip = this->manual_ip_->static_ip;
     info.gw = this->manual_ip_->gateway;
     info.netmask = this->manual_ip_->subnet;
-  } else
-#endif
-  {
+  } else {
     info.ip.addr = 0;
     info.gw.addr = 0;
     info.netmask.addr = 0;
@@ -581,7 +575,6 @@ void EthernetComponent::start_connect_() {
   err = esp_netif_set_ip_info(this->eth_netif_, &info);
   ESPHL_ERROR_CHECK(err, "DHCPC set IP info error");
 
-#ifdef USE_ETHERNET_MANUAL_IP
   if (this->manual_ip_.has_value()) {
     LwIPLock lock;
     if (this->manual_ip_->dns1.is_set()) {
@@ -594,9 +587,7 @@ void EthernetComponent::start_connect_() {
       d = this->manual_ip_->dns2;
       dns_setserver(1, &d);
     }
-  } else
-#endif
-  {
+  } else {
     err = esp_netif_dhcpc_start(this->eth_netif_);
     if (err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STARTED) {
       ESPHL_ERROR_CHECK(err, "DHCPC start error");
@@ -694,9 +685,7 @@ void EthernetComponent::set_clk_mode(emac_rmii_clock_mode_t clk_mode) { this->cl
 void EthernetComponent::add_phy_register(PHYRegister register_value) { this->phy_registers_.push_back(register_value); }
 #endif
 void EthernetComponent::set_type(EthernetType type) { this->type_ = type; }
-#ifdef USE_ETHERNET_MANUAL_IP
 void EthernetComponent::set_manual_ip(const ManualIP &manual_ip) { this->manual_ip_ = manual_ip; }
-#endif
 
 // set_use_address() is guaranteed to be called during component setup by Python code generation,
 // so use_address_ will always be valid when get_use_address() is called - no fallback needed.

esphome/components/ethernet/ethernet_component.h

@@ -82,9 +82,7 @@ class EthernetComponent : public Component {
   void add_phy_register(PHYRegister register_value);
 #endif
   void set_type(EthernetType type);
-#ifdef USE_ETHERNET_MANUAL_IP
   void set_manual_ip(const ManualIP &manual_ip);
-#endif
   void set_fixed_mac(const std::array<uint8_t, 6> &mac) { this->fixed_mac_ = mac; }
 
   network::IPAddresses get_ip_addresses();
@@ -139,9 +137,7 @@ class EthernetComponent : public Component {
   uint8_t mdc_pin_{23};
   uint8_t mdio_pin_{18};
 #endif
-#ifdef USE_ETHERNET_MANUAL_IP
   optional<ManualIP> manual_ip_{};
-#endif
   uint32_t connect_begin_;
 
   // Group all uint8_t types together (enums and bools)

esphome/components/font/__init__.py

@@ -36,6 +36,7 @@ from esphome.const import (
     CONF_WEIGHT,
 )
 from esphome.core import CORE, HexInt
+from esphome.helpers import cpp_string_escape
 from esphome.types import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -49,6 +50,7 @@ font_ns = cg.esphome_ns.namespace("font")
 
 Font = font_ns.class_("Font")
 Glyph = font_ns.class_("Glyph")
+GlyphData = font_ns.struct("GlyphData")
 
 CONF_BPP = "bpp"
 CONF_EXTRAS = "extras"
@@ -461,7 +463,7 @@ FONT_SCHEMA = cv.Schema(
             )
         ),
         cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
-        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(Glyph),
+        cv.GenerateID(CONF_RAW_GLYPH_ID): cv.declare_id(GlyphData),
     },
 )
 
@@ -486,8 +488,6 @@ class GlyphInfo:
 
 
 def glyph_to_glyphinfo(glyph, font, size, bpp):
-    # Convert to 32 bit unicode codepoint
-    glyph = ord(glyph)
     scale = 256 // (1 << bpp)
     if not font.is_scalable:
         sizes = [pt_to_px(x.size) for x in font.available_sizes]
@@ -583,15 +583,22 @@ async def to_code(config):
 
     # Create the glyph table that points to data in the above array.
     glyph_initializer = [
-        [
-            x.glyph,
-            prog_arr + (y - len(x.bitmap_data)),
-            x.advance,
-            x.offset_x,
-            x.offset_y,
-            x.width,
-            x.height,
-        ]
+        cg.StructInitializer(
+            GlyphData,
+            (
+                "a_char",
+                cg.RawExpression(f"(const uint8_t *){cpp_string_escape(x.glyph)}"),
+            ),
+            (
+                "data",
+                cg.RawExpression(f"{str(prog_arr)} + {str(y - len(x.bitmap_data))}"),
+            ),
+            ("advance", x.advance),
+            ("offset_x", x.offset_x),
+            ("offset_y", x.offset_y),
+            ("width", x.width),
+            ("height", x.height),
+        )
         for (x, y) in zip(
             glyph_args, list(accumulate([len(x.bitmap_data) for x in glyph_args]))
         )

esphome/components/font/font.cpp

@@ -6,245 +6,133 @@
 
 namespace esphome {
 namespace font {
+
 static const char *const TAG = "font";
 
-#ifdef USE_LVGL_FONT
-const uint8_t *Font::get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter) {
-  auto *fe = (Font *) font->dsc;
-  const auto *gd = fe->get_glyph_data_(unicode_letter);
-  if (gd == nullptr) {
-    return nullptr;
+const uint8_t *Glyph::get_char() const { return this->glyph_data_->a_char; }
+// Compare the char at the string position with this char.
+// Return true if this char is less than or equal the other.
+bool Glyph::compare_to(const uint8_t *str) const {
+  // 1 -> this->char_
+  // 2 -> str
+  for (uint32_t i = 0;; i++) {
+    if (this->glyph_data_->a_char[i] == '\0')
+      return true;
+    if (str[i] == '\0')
+      return false;
+    if (this->glyph_data_->a_char[i] > str[i])
+      return false;
+    if (this->glyph_data_->a_char[i] < str[i])
+      return true;
   }
-  return gd->data;
+  // this should not happen
+  return false;
+}
+int Glyph::match_length(const uint8_t *str) const {
+  for (uint32_t i = 0;; i++) {
+    if (this->glyph_data_->a_char[i] == '\0')
+      return i;
+    if (str[i] != this->glyph_data_->a_char[i])
+      return 0;
+  }
+  // this should not happen
+  return 0;
+}
+void Glyph::scan_area(int *x1, int *y1, int *width, int *height) const {
+  *x1 = this->glyph_data_->offset_x;
+  *y1 = this->glyph_data_->offset_y;
+  *width = this->glyph_data_->width;
+  *height = this->glyph_data_->height;
 }
 
-bool Font::get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next) {
-  auto *fe = (Font *) font->dsc;
-  const auto *gd = fe->get_glyph_data_(unicode_letter);
-  if (gd == nullptr) {
-    return false;
-  }
-  dsc->adv_w = gd->advance;
-  dsc->ofs_x = gd->offset_x;
-  dsc->ofs_y = fe->height_ - gd->height - gd->offset_y - fe->lv_font_.base_line;
-  dsc->box_w = gd->width;
-  dsc->box_h = gd->height;
-  dsc->is_placeholder = 0;
-  dsc->bpp = fe->get_bpp();
-  return true;
-}
-
-const Glyph *Font::get_glyph_data_(uint32_t unicode_letter) {
-  if (unicode_letter == this->last_letter_ && this->last_letter_ != 0)
-    return this->last_data_;
-  auto *glyph = this->find_glyph(unicode_letter);
-  if (glyph == nullptr) {
-    return nullptr;
-  }
-  this->last_data_ = glyph;
-  this->last_letter_ = unicode_letter;
-  return glyph;
-}
-#endif
-
-/**
- *  Attempt to extract a 32 bit Unicode codepoint from a UTF-8 string.
- *  If successful, return the codepoint and set the length to the number of bytes read.
- *  If the end of the string has been reached and a valid codepoint has not been found, return 0 and set the length to
- * 0.
- *
- * @param utf8_str The input string
- * @param length Pointer to length storage
- * @return The extracted code point
- */
-static uint32_t extract_unicode_codepoint(const char *utf8_str, size_t *length) {
-  // Safely cast to uint8_t* for correct bitwise operations on bytes
-  const uint8_t *current = reinterpret_cast<const uint8_t *>(utf8_str);
-  uint32_t code_point = 0;
-  uint8_t c1 = *current++;
-
-  // check for end of string
-  if (c1 == 0) {
-    *length = 0;
-    return 0;
-  }
-
-  // --- 1-Byte Sequence: 0xxxxxxx (ASCII) ---
-  if (c1 < 0x80) {
-    // Valid ASCII byte.
-    code_point = c1;
-    // Optimization: No need to check for continuation bytes.
-  }
-  // --- 2-Byte Sequence: 110xxxxx 10xxxxxx ---
-  else if ((c1 & 0xE0) == 0xC0) {
-    uint8_t c2 = *current++;
-
-    // Error Check 1: Check if c2 is a valid continuation byte (10xxxxxx)
-    if ((c2 & 0xC0) != 0x80) {
-      *length = 0;
-      return 0;
-    }
-
-    code_point = (c1 & 0x1F) << 6;
-    code_point |= (c2 & 0x3F);
-
-    // Error Check 2: Overlong check (2-byte must be > 0x7F)
-    if (code_point <= 0x7F) {
-      *length = 0;
-      return 0;
-    }
-  }
-  // --- 3-Byte Sequence: 1110xxxx 10xxxxxx 10xxxxxx ---
-  else if ((c1 & 0xF0) == 0xE0) {
-    uint8_t c2 = *current++;
-    uint8_t c3 = *current++;
-
-    // Error Check 1: Check continuation bytes
-    if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80)) {
-      *length = 0;
-      return 0;
-    }
-
-    code_point = (c1 & 0x0F) << 12;
-    code_point |= (c2 & 0x3F) << 6;
-    code_point |= (c3 & 0x3F);
-
-    // Error Check 2: Overlong check (3-byte must be > 0x7FF)
-    // Also check for surrogates (0xD800-0xDFFF)
-    if (code_point <= 0x7FF || (code_point >= 0xD800 && code_point <= 0xDFFF)) {
-      *length = 0;
-      return 0;
-    }
-  }
-  // --- 4-Byte Sequence: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx ---
-  else if ((c1 & 0xF8) == 0xF0) {
-    uint8_t c2 = *current++;
-    uint8_t c3 = *current++;
-    uint8_t c4 = *current++;
-
-    // Error Check 1: Check continuation bytes
-    if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80) || ((c4 & 0xC0) != 0x80)) {
-      *length = 0;
-      return 0;
-    }
-
-    code_point = (c1 & 0x07) << 18;
-    code_point |= (c2 & 0x3F) << 12;
-    code_point |= (c3 & 0x3F) << 6;
-    code_point |= (c4 & 0x3F);
-
-    // Error Check 2: Overlong check (4-byte must be > 0xFFFF)
-    // Also check for valid Unicode range (must be <= 0x10FFFF)
-    if (code_point <= 0xFFFF || code_point > 0x10FFFF) {
-      *length = 0;
-      return 0;
-    }
-  }
-  // --- Invalid leading byte (e.g., 10xxxxxx or 11111xxx) ---
-  else {
-    *length = 0;
-    return 0;
-  }
-  *length = current - reinterpret_cast<const uint8_t *>(utf8_str);
-  return code_point;
-}
-
-Font::Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+Font::Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
            uint8_t bpp)
-    : glyphs_(ConstVector(data, data_nr)),
-      baseline_(baseline),
+    : baseline_(baseline),
       height_(height),
       descender_(descender),
       linegap_(height - baseline - descender),
       xheight_(xheight),
       capheight_(capheight),
       bpp_(bpp) {
-#ifdef USE_LVGL_FONT
-  this->lv_font_.dsc = this;
-  this->lv_font_.line_height = this->get_height();
-  this->lv_font_.base_line = this->lv_font_.line_height - this->get_baseline();
-  this->lv_font_.get_glyph_dsc = get_glyph_dsc_cb;
-  this->lv_font_.get_glyph_bitmap = get_glyph_bitmap;
-  this->lv_font_.subpx = LV_FONT_SUBPX_NONE;
-  this->lv_font_.underline_position = -1;
-  this->lv_font_.underline_thickness = 1;
-#endif
+  glyphs_.reserve(data_nr);
+  for (int i = 0; i < data_nr; ++i)
+    glyphs_.emplace_back(&data[i]);
 }
-
-const Glyph *Font::find_glyph(uint32_t codepoint) const {
+int Font::match_next_glyph(const uint8_t *str, int *match_length) {
   int lo = 0;
   int hi = this->glyphs_.size() - 1;
   while (lo != hi) {
     int mid = (lo + hi + 1) / 2;
-    if (this->glyphs_[mid].is_less_or_equal(codepoint)) {
+    if (this->glyphs_[mid].compare_to(str)) {
       lo = mid;
     } else {
       hi = mid - 1;
     }
   }
-  auto *result = &this->glyphs_[lo];
-  if (result->code_point == codepoint)
-    return result;
-  return nullptr;
+  *match_length = this->glyphs_[lo].match_length(str);
+  if (*match_length <= 0)
+    return -1;
+  return lo;
 }
-
 #ifdef USE_DISPLAY
 void Font::measure(const char *str, int *width, int *x_offset, int *baseline, int *height) {
   *baseline = this->baseline_;
   *height = this->height_;
+  int i = 0;
   int min_x = 0;
   bool has_char = false;
   int x = 0;
-  for (;;) {
-    size_t length;
-    auto code_point = extract_unicode_codepoint(str, &length);
-    if (length == 0)
-      break;
-    str += length;
-    auto *glyph = this->find_glyph(code_point);
-    if (glyph == nullptr) {
+  while (str[i] != '\0') {
+    int match_length;
+    int glyph_n = this->match_next_glyph((const uint8_t *) str + i, &match_length);
+    if (glyph_n < 0) {
       // Unknown char, skip
-      if (!this->glyphs_.empty())
-        x += this->glyphs_[0].advance;
+      if (!this->get_glyphs().empty())
+        x += this->get_glyphs()[0].glyph_data_->advance;
+      i++;
       continue;
     }
 
+    const Glyph &glyph = this->glyphs_[glyph_n];
     if (!has_char) {
-      min_x = glyph->offset_x;
+      min_x = glyph.glyph_data_->offset_x;
     } else {
-      min_x = std::min(min_x, x + glyph->offset_x);
+      min_x = std::min(min_x, x + glyph.glyph_data_->offset_x);
     }
-    x += glyph->advance;
+    x += glyph.glyph_data_->advance;
 
+    i += match_length;
     has_char = true;
   }
   *x_offset = min_x;
   *width = x - min_x;
 }
-
 void Font::print(int x_start, int y_start, display::Display *display, Color color, const char *text, Color background) {
+  int i = 0;
   int x_at = x_start;
-  for (;;) {
-    size_t length;
-    auto code_point = extract_unicode_codepoint(text, &length);
-    if (length == 0)
-      break;
-    text += length;
-    auto *glyph = this->find_glyph(code_point);
-    if (glyph == nullptr) {
+  int scan_x1, scan_y1, scan_width, scan_height;
+  while (text[i] != '\0') {
+    int match_length;
+    int glyph_n = this->match_next_glyph((const uint8_t *) text + i, &match_length);
+    if (glyph_n < 0) {
       // Unknown char, skip
-      ESP_LOGW(TAG, "Codepoint 0x%08" PRIx32 " not found in font", code_point);
-      if (!this->glyphs_.empty()) {
-        uint8_t glyph_width = this->glyphs_[0].advance;
-        display->rectangle(x_at, y_start, glyph_width, this->height_, color);
+      ESP_LOGW(TAG, "Encountered character without representation in font: '%c'", text[i]);
+      if (!this->get_glyphs().empty()) {
+        uint8_t glyph_width = this->get_glyphs()[0].glyph_data_->advance;
+        display->filled_rectangle(x_at, y_start, glyph_width, this->height_, color);
         x_at += glyph_width;
       }
+
+      i++;
       continue;
     }
 
-    const uint8_t *data = glyph->data;
-    const int max_x = x_at + glyph->offset_x + glyph->width;
-    const int max_y = y_start + glyph->offset_y + glyph->height;
+    const Glyph &glyph = this->get_glyphs()[glyph_n];
+    glyph.scan_area(&scan_x1, &scan_y1, &scan_width, &scan_height);
+
+    const uint8_t *data = glyph.glyph_data_->data;
+    const int max_x = x_at + scan_x1 + scan_width;
+    const int max_y = y_start + scan_y1 + scan_height;
 
     uint8_t bitmask = 0;
     uint8_t pixel_data = 0;
@@ -257,10 +145,10 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
     auto b_g = (float) background.g;
     auto b_b = (float) background.b;
     auto b_w = (float) background.w;
-    for (int glyph_y = y_start + glyph->offset_y; glyph_y != max_y; glyph_y++) {
-      for (int glyph_x = x_at + glyph->offset_x; glyph_x != max_x; glyph_x++) {
+    for (int glyph_y = y_start + scan_y1; glyph_y != max_y; glyph_y++) {
+      for (int glyph_x = x_at + scan_x1; glyph_x != max_x; glyph_x++) {
         uint8_t pixel = 0;
-        for (uint8_t bit_num = 0; bit_num != this->bpp_; bit_num++) {
+        for (int bit_num = 0; bit_num != this->bpp_; bit_num++) {
           if (bitmask == 0) {
             pixel_data = progmem_read_byte(data++);
             bitmask = 0x80;
@@ -280,9 +168,12 @@ void Font::print(int x_start, int y_start, display::Display *display, Color colo
         }
       }
     }
-    x_at += glyph->advance;
+    x_at += glyph.glyph_data_->advance;
+
+    i += match_length;
   }
 }
 #endif
+
 }  // namespace font
 }  // namespace esphome

esphome/components/font/font.h

@@ -6,30 +6,14 @@
 #ifdef USE_DISPLAY
 #include "esphome/components/display/display.h"
 #endif
-#ifdef USE_LVGL_FONT
-#include <lvgl.h>
-#endif
 
 namespace esphome {
 namespace font {
 
 class Font;
 
-class Glyph {
- public:
-  constexpr Glyph(uint32_t code_point, const uint8_t *data, int advance, int offset_x, int offset_y, int width,
-                  int height)
-      : code_point(code_point),
-        data(data),
-        advance(advance),
-        offset_x(offset_x),
-        offset_y(offset_y),
-        width(width),
-        height(height) {}
-
-  bool is_less_or_equal(uint32_t other) const { return this->code_point <= other; }
-
-  const uint32_t code_point;
+struct GlyphData {
+  const uint8_t *a_char;
   const uint8_t *data;
   int advance;
   int offset_x;
@@ -38,6 +22,26 @@ class Glyph {
   int height;
 };
 
+class Glyph {
+ public:
+  Glyph(const GlyphData *data) : glyph_data_(data) {}
+
+  const uint8_t *get_char() const;
+
+  bool compare_to(const uint8_t *str) const;
+
+  int match_length(const uint8_t *str) const;
+
+  void scan_area(int *x1, int *y1, int *width, int *height) const;
+
+  const GlyphData *get_glyph_data() const { return this->glyph_data_; }
+
+ protected:
+  friend Font;
+
+  const GlyphData *glyph_data_;
+};
+
 class Font
 #ifdef USE_DISPLAY
     : public display::BaseFont
@@ -46,8 +50,8 @@ class Font
  public:
   /** Construct the font with the given glyphs.
    *
-   * @param data A list of glyphs, must be sorted lexicographically.
-   * @param data_nr The number of glyphs
+   * @param data A vector of glyphs, must be sorted lexicographically.
+   * @param data_nr The number of glyphs in data.
    * @param baseline The y-offset from the top of the text to the baseline.
    * @param height The y-offset from the top of the text to the bottom.
    * @param descender The y-offset from the baseline to the lowest stroke in the font (e.g. from letters like g or p).
@@ -55,10 +59,10 @@ class Font
    * @param capheight The height of capital letters, usually measured at the "X" glyph.
    * @param bpp The bits per pixel used for this font. Used to read data out of the glyph bitmaps.
    */
-  Font(const Glyph *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
+  Font(const GlyphData *data, int data_nr, int baseline, int height, int descender, int xheight, int capheight,
        uint8_t bpp = 1);
 
-  const Glyph *find_glyph(uint32_t codepoint) const;
+  int match_next_glyph(const uint8_t *str, int *match_length);
 
 #ifdef USE_DISPLAY
   void print(int x_start, int y_start, display::Display *display, Color color, const char *text,
@@ -73,14 +77,11 @@ class Font
   inline int get_xheight() { return this->xheight_; }
   inline int get_capheight() { return this->capheight_; }
   inline int get_bpp() { return this->bpp_; }
-#ifdef USE_LVGL_FONT
-  const lv_font_t *get_lv_font() const { return &this->lv_font_; }
-#endif
 
-  const ConstVector<Glyph> &get_glyphs() const { return glyphs_; }
+  const std::vector<Glyph, RAMAllocator<Glyph>> &get_glyphs() const { return glyphs_; }
 
  protected:
-  ConstVector<Glyph> glyphs_;
+  std::vector<Glyph, RAMAllocator<Glyph>> glyphs_;
   int baseline_;
   int height_;
   int descender_;
@@ -88,14 +89,6 @@ class Font
   int xheight_;
   int capheight_;
   uint8_t bpp_;  // bits per pixel
-#ifdef USE_LVGL_FONT
-  lv_font_t lv_font_{};
-  static const uint8_t *get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter);
-  static bool get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next);
-  const Glyph *get_glyph_data_(uint32_t unicode_letter);
-  uint32_t last_letter_{};
-  const Glyph *last_data_{};
-#endif
 };
 
 }  // namespace font

esphome/components/homeassistant/time/homeassistant_time.cpp

@@ -7,8 +7,10 @@ namespace homeassistant {
 static const char *const TAG = "homeassistant.time";
 
 void HomeassistantTime::dump_config() {
-  ESP_LOGCONFIG(TAG, "Home Assistant Time");
-  RealTimeClock::dump_config();
+  ESP_LOGCONFIG(TAG,
+                "Home Assistant Time:\n"
+                "  Timezone: '%s'",
+                this->timezone_.c_str());
 }
 
 float HomeassistantTime::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/improv_serial/improv_serial_component.cpp

@@ -231,7 +231,7 @@ bool ImprovSerialComponent::parse_improv_payload_(improv::ImprovCommand &command
       this->connecting_sta_ = sta;
 
       wifi::global_wifi_component->set_sta(sta);
-      wifi::global_wifi_component->start_connecting(sta);
+      wifi::global_wifi_component->start_connecting(sta, false);
       this->set_state_(improv::STATE_PROVISIONING);
       ESP_LOGD(TAG, "Received settings: SSID=%s, password=" LOG_SECRET("%s"), command.ssid.c_str(),
                command.password.c_str());

esphome/components/ld2410/sensor.py

@@ -31,83 +31,35 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_LIGHTBULB,
         ),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
@@ -121,13 +73,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -135,13 +81,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/ld2412/sensor.py

@@ -31,84 +31,36 @@ CONFIG_SCHEMA = cv.Schema(
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_LIGHT): sensor.sensor_schema(
             device_class=DEVICE_CLASS_ILLUMINANCE,
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_LIGHTBULB,
             unit_of_measurement=UNIT_EMPTY,  # No standard unit for this light sensor
         ),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_MOVING_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_MOTION_SENSOR,
             unit_of_measurement=UNIT_PERCENT,
         ),
         cv.Optional(CONF_STILL_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_SIGNAL,
             unit_of_measurement=UNIT_CENTIMETER,
         ),
         cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
-            filters=[
-                {
-                    "timeout": {
-                        "timeout": cv.TimePeriod(milliseconds=1000),
-                        "value": "last",
-                    }
-                },
-                {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
-            ],
+            filters=[{"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}],
             icon=ICON_FLASH,
             unit_of_measurement=UNIT_PERCENT,
         ),
@@ -122,13 +74,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_MOVE_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_MOTION_SENSOR,
                     unit_of_measurement=UNIT_PERCENT,
@@ -136,13 +82,7 @@ CONFIG_SCHEMA = CONFIG_SCHEMA.extend(
                 cv.Optional(CONF_STILL_ENERGY): sensor.sensor_schema(
                     entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
                     filters=[
-                        {
-                            "timeout": {
-                                "timeout": cv.TimePeriod(milliseconds=1000),
-                                "value": "last",
-                            }
-                        },
-                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)},
+                        {"throttle_with_priority": cv.TimePeriod(milliseconds=1000)}
                     ],
                     icon=ICON_FLASH,
                     unit_of_measurement=UNIT_PERCENT,

esphome/components/light/light_call.cpp

@@ -52,10 +52,8 @@ static void log_invalid_parameter(const char *name, const LogString *message) {
   }
 
 static const LogString *color_mode_to_human(ColorMode color_mode) {
-  if (color_mode == ColorMode::ON_OFF)
-    return LOG_STR("On/Off");
-  if (color_mode == ColorMode::BRIGHTNESS)
-    return LOG_STR("Brightness");
+  if (color_mode == ColorMode::UNKNOWN)
+    return LOG_STR("Unknown");
   if (color_mode == ColorMode::WHITE)
     return LOG_STR("White");
   if (color_mode == ColorMode::COLOR_TEMPERATURE)
@@ -70,7 +68,7 @@ static const LogString *color_mode_to_human(ColorMode color_mode) {
     return LOG_STR("RGB + cold/warm white");
   if (color_mode == ColorMode::RGB_COLOR_TEMPERATURE)
     return LOG_STR("RGB + color temperature");
-  return LOG_STR("Unknown");
+  return LOG_STR("");
 }
 
 // Helper to log percentage values
@@ -408,7 +406,7 @@ void LightCall::transform_parameters_() {
   }
 }
 ColorMode LightCall::compute_color_mode_() {
-  auto supported_modes = this->parent_->get_traits().get_supported_color_modes();
+  const auto &supported_modes = this->parent_->get_traits().get_supported_color_modes();
   int supported_count = supported_modes.size();
 
   // Some lights don't support any color modes (e.g. monochromatic light), leave it at unknown.

esphome/components/light/light_state.cpp

@@ -24,9 +24,6 @@ void LightState::setup() {
     effect->init_internal(this);
   }
 
-  // Start with loop disabled if idle - respects any effects/transitions set up during initialization
-  this->disable_loop_if_idle_();
-
   // When supported color temperature range is known, initialize color temperature setting within bounds.
   auto traits = this->get_traits();
   float min_mireds = traits.get_min_mireds();
@@ -129,9 +126,6 @@ void LightState::loop() {
       this->is_transformer_active_ = false;
       this->transformer_ = nullptr;
       this->target_state_reached_callback_.call();
-
-      // Disable loop if idle (no transformer and no effect)
-      this->disable_loop_if_idle_();
     }
   }
 
@@ -139,8 +133,6 @@ void LightState::loop() {
   if (this->next_write_) {
     this->next_write_ = false;
     this->output_->write_state(this);
-    // Disable loop if idle (no transformer and no effect)
-    this->disable_loop_if_idle_();
   }
 }
 
@@ -236,8 +228,6 @@ void LightState::start_effect_(uint32_t effect_index) {
   this->active_effect_index_ = effect_index;
   auto *effect = this->get_active_effect_();
   effect->start_internal();
-  // Enable loop while effect is active
-  this->enable_loop();
 }
 LightEffect *LightState::get_active_effect_() {
   if (this->active_effect_index_ == 0) {
@@ -252,8 +242,6 @@ void LightState::stop_effect_() {
     effect->stop();
   }
   this->active_effect_index_ = 0;
-  // Disable loop if idle (no effect and no transformer)
-  this->disable_loop_if_idle_();
 }
 
 void LightState::start_transition_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
@@ -263,8 +251,6 @@ void LightState::start_transition_(const LightColorValues &target, uint32_t leng
   if (set_remote_values) {
     this->remote_values = target;
   }
-  // Enable loop while transition is active
-  this->enable_loop();
 }
 
 void LightState::start_flash_(const LightColorValues &target, uint32_t length, bool set_remote_values) {
@@ -280,8 +266,6 @@ void LightState::start_flash_(const LightColorValues &target, uint32_t length, b
   if (set_remote_values) {
     this->remote_values = target;
   };
-  // Enable loop while flash is active
-  this->enable_loop();
 }
 
 void LightState::set_immediately_(const LightColorValues &target, bool set_remote_values) {
@@ -293,14 +277,6 @@ void LightState::set_immediately_(const LightColorValues &target, bool set_remot
   }
   this->output_->update_state(this);
   this->next_write_ = true;
-  this->enable_loop();
-}
-
-void LightState::disable_loop_if_idle_() {
-  // Only disable loop if both transformer and effect are inactive, and no pending writes
-  if (this->transformer_ == nullptr && this->get_active_effect_() == nullptr && !this->next_write_) {
-    this->disable_loop();
-  }
 }
 
 void LightState::save_remote_values_() {

esphome/components/light/light_state.h

@@ -256,9 +256,6 @@ class LightState : public EntityBase, public Component {
   /// Internal method to save the current remote_values to the preferences
   void save_remote_values_();
 
-  /// Disable loop if neither transformer nor effect is active
-  void disable_loop_if_idle_();
-
   /// Store the output to allow effects to have more access.
   LightOutput *output_;
   /// The currently active transformer for this light (transition/flash).

esphome/components/light/light_traits.h

@@ -18,8 +18,7 @@ class LightTraits {
  public:
   LightTraits() = default;
 
-  // Return by value to avoid dangling reference when get_traits() returns a temporary
-  ColorModeMask get_supported_color_modes() const { return this->supported_color_modes_; }
+  const ColorModeMask &get_supported_color_modes() const { return this->supported_color_modes_; }
   void set_supported_color_modes(ColorModeMask supported_color_modes) {
     this->supported_color_modes_ = supported_color_modes;
   }

esphome/components/logger/__init__.py

@@ -365,10 +365,8 @@ async def to_code(config):
     if CORE.is_esp32:
         if config[CONF_HARDWARE_UART] == USB_CDC:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_CDC", True)
-            cg.add_define("USE_LOGGER_UART_SELECTION_USB_CDC")
         elif config[CONF_HARDWARE_UART] == USB_SERIAL_JTAG:
             add_idf_sdkconfig_option("CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG", True)
-            cg.add_define("USE_LOGGER_UART_SELECTION_USB_SERIAL_JTAG")
     try:
         uart_selection(USB_SERIAL_JTAG)
         cg.add_define("USE_LOGGER_USB_SERIAL_JTAG")

esphome/components/logger/logger.cpp

@@ -65,9 +65,7 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
     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 if platform needs it (ESP32 doesn't add via write_msg_)
-    this->add_newline_to_buffer_if_needed_(console_buffer, &buffer_at, MAX_CONSOLE_LOG_MSG_SIZE);
-    this->write_msg_(console_buffer, buffer_at);
+    this->write_msg_(console_buffer);
   }
 
   // Reset the recursion guard for this task
@@ -133,19 +131,18 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
 
   // 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_;
+  uint32_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 =
+  // Write to console and send callback starting at the msg_start
+  if (this->baud_rate_ > 0) {
+    this->write_msg_(this->tx_buffer_ + msg_start);
+  }
+  size_t msg_length =
       this->tx_buffer_at_ - msg_start;  // Don't subtract 1 - tx_buffer_at_ is already at the null terminator position
-
-  // Callbacks get message first (before console write)
   this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start, msg_length);
 
-  // Write to console starting at the msg_start
-  this->write_tx_buffer_to_console_(msg_start, &msg_length);
-
   global_recursion_guard_ = false;
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
@@ -212,7 +209,9 @@ void Logger::process_messages_() {
       // This ensures all log messages appear on the console in a clean, serialized manner
       // Note: Messages may appear slightly out of order due to async processing, but
       // this is preferred over corrupted/interleaved console output
-      this->write_tx_buffer_to_console_();
+      if (this->baud_rate_ > 0) {
+        this->write_msg_(this->tx_buffer_);
+      }
     }
   } else {
     // No messages to process, disable loop if appropriate

esphome/components/logger/logger.h

@@ -71,17 +71,6 @@ 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;
 
-// Platform-specific: does write_msg_ add its own newline?
-// false: Caller must add newline to buffer before calling write_msg_ (ESP32, ESP8266, LibreTiny)
-//        Allows single write call with newline included for efficiency
-// true:  write_msg_ adds newline itself via puts()/println() (other platforms)
-//        Newline should NOT be added to buffer
-#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_LIBRETINY)
-static constexpr bool WRITE_MSG_ADDS_NEWLINE = false;
-#else
-static constexpr bool WRITE_MSG_ADDS_NEWLINE = true;
-#endif
-
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
 /** Enum for logging UART selection
  *
@@ -184,7 +173,7 @@ class Logger : public Component {
 
  protected:
   void process_messages_();
-  void write_msg_(const char *msg, size_t len);
+  void write_msg_(const char *msg);
 
   // 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)
@@ -211,35 +200,6 @@ class Logger : public Component {
     }
   }
 
-  // Helper to add newline to buffer for platforms that need it
-  // Modifies buffer_at to include the newline
-  inline void HOT add_newline_to_buffer_if_needed_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    if constexpr (!WRITE_MSG_ADDS_NEWLINE) {
-      // Add newline - don't need to maintain null termination
-      // write_msg_ now always 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;
-      }
-    }
-  }
-
-  // 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_if_needed_(this->tx_buffer_ + offset, len_ptr, this->tx_buffer_size_ - offset);
-      this->write_msg_(this->tx_buffer_ + offset, *len_ptr);
-    }
-  }
-
   // Helper to format and send a log message to both console and callbacks
   inline void HOT log_message_to_buffer_and_send_(uint8_t level, const char *tag, int line, const char *format,
                                                   va_list args) {
@@ -248,11 +208,10 @@ class Logger : public Component {
     this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, this->tx_buffer_, &this->tx_buffer_at_,
                                                 this->tx_buffer_size_);
 
-    // Callbacks get message WITHOUT newline (for API/MQTT/syslog)
+    if (this->baud_rate_ > 0) {
+      this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
+    }
     this->log_callback_.call(level, tag, this->tx_buffer_, this->tx_buffer_at_);
-
-    // Console gets message WITH newline (if platform needs it)
-    this->write_tx_buffer_to_console_();
   }
 
   // Write the body of the log message to the buffer
@@ -466,9 +425,7 @@ class Logger : public Component {
     }
 
     // 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;
+    uint16_t formatted_len = (ret >= remaining) ? remaining : ret;
     *buffer_at += formatted_len;
 
     // Remove all trailing newlines right after formatting

esphome/components/logger/logger_esp32.cpp

@@ -121,23 +121,25 @@ 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
-
-#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
-  //
-  // Note: These defines indicate the user's YAML configuration choice (hardware_uart: USB_CDC/USB_SERIAL_JTAG).
-  // They are ONLY defined when the user explicitly selects USB as the logger output in their config.
-  // This is compile-time selection, not runtime detection - if USB is configured, it's always used.
-  // There is no fallback to regular UART if "USB isn't connected" - that's the user's responsibility
-  // to configure correctly for their hardware. This approach eliminates runtime overhead.
-  fwrite(msg, 1, len, stdout);
+void HOT Logger::write_msg_(const char *msg) {
+  if (
+#if defined(USE_LOGGER_USB_CDC) && !defined(USE_LOGGER_USB_SERIAL_JTAG)
+      this->uart_ == UART_SELECTION_USB_CDC
+#elif defined(USE_LOGGER_USB_SERIAL_JTAG) && !defined(USE_LOGGER_USB_CDC)
+      this->uart_ == UART_SELECTION_USB_SERIAL_JTAG
+#elif defined(USE_LOGGER_USB_CDC) && defined(USE_LOGGER_USB_SERIAL_JTAG)
+      this->uart_ == UART_SELECTION_USB_CDC || this->uart_ == UART_SELECTION_USB_SERIAL_JTAG
 #else
-  // Regular UART - single write including newline (already in buffer)
-  uart_write_bytes(this->uart_num_, msg, len);
+      /* DISABLES CODE */ (false)  // NOLINT
 #endif
+  ) {
+    puts(msg);
+  } else {
+    // Use tx_buffer_at_ if msg points to tx_buffer_, otherwise fall back to strlen
+    size_t len = (msg == this->tx_buffer_) ? this->tx_buffer_at_ : strlen(msg);
+    uart_write_bytes(this->uart_num_, msg, len);
+    uart_write_bytes(this->uart_num_, "\n", 1);
+  }
 }
 
 const LogString *Logger::get_uart_selection_() {

esphome/components/logger/logger_esp8266.cpp

@@ -33,10 +33,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t len) {
-  // Single write with newline already in buffer (added by caller)
-  this->hw_serial_->write(msg, len);
-}
+void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
 
 const LogString *Logger::get_uart_selection_() {
   switch (this->uart_) {

esphome/components/logger/logger_host.cpp

@@ -3,7 +3,7 @@
 
 namespace esphome::logger {
 
-void HOT Logger::write_msg_(const char *msg, size_t) {
+void HOT Logger::write_msg_(const char *msg) {
   time_t rawtime;
   struct tm *timeinfo;
   char buffer[80];

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) { this->hw_serial_->println(msg); }
 
 const LogString *Logger::get_uart_selection_() {
   switch (this->uart_) {

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) { this->hw_serial_->println(msg); }
+void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
 
 const LogString *Logger::get_uart_selection_() {
   switch (this->uart_) {

esphome/components/logger/logger_zephyr.cpp

@@ -62,7 +62,7 @@ void Logger::pre_setup() {
   ESP_LOGI(TAG, "Log initialized");
 }
 
-void HOT Logger::write_msg_(const char *msg, size_t) {
+void HOT Logger::write_msg_(const char *msg) {
 #ifdef CONFIG_PRINTK
   printk("%s\n", msg);
 #endif

esphome/components/lvgl/__init__.py

@@ -52,7 +52,15 @@ from .schemas import (
 from .styles import add_top_layer, styles_to_code, theme_to_code
 from .touchscreens import touchscreen_schema, touchscreens_to_code
 from .trigger import add_on_boot_triggers, generate_triggers
-from .types import IdleTrigger, PlainTrigger, lv_font_t, lv_group_t, lv_style_t, lvgl_ns
+from .types import (
+    FontEngine,
+    IdleTrigger,
+    PlainTrigger,
+    lv_font_t,
+    lv_group_t,
+    lv_style_t,
+    lvgl_ns,
+)
 from .widgets import (
     LvScrActType,
     Widget,
@@ -236,6 +244,7 @@ async def to_code(configs):
     cg.add_global(lvgl_ns.using)
     for font in helpers.esphome_fonts_used:
         await cg.get_variable(font)
+        cg.new_Pvariable(ID(f"{font}_engine", True, type=FontEngine), MockObj(font))
     default_font = config_0[df.CONF_DEFAULT_FONT]
     if not lvalid.is_lv_font(default_font):
         add_define(
@@ -247,8 +256,7 @@ async def to_code(configs):
             type=lv_font_t.operator("ptr").operator("const"),
         )
         cg.new_variable(
-            globfont_id,
-            MockObj(await lvalid.lv_font.process(default_font), "->").get_lv_font(),
+            globfont_id, MockObj(await lvalid.lv_font.process(default_font))
         )
         add_define("LV_FONT_DEFAULT", df.DEFAULT_ESPHOME_FONT)
     else:
@@ -323,7 +331,7 @@ async def to_code(configs):
     # This must be done after all widgets are created
     for comp in helpers.lvgl_components_required:
         cg.add_define(f"USE_LVGL_{comp.upper()}")
-    if {"transform_angle", "transform_zoom"} & styles_used:
+    if "transform_angle" in styles_used:
         add_define("LV_COLOR_SCREEN_TRANSP", "1")
     for use in helpers.lv_uses:
         add_define(f"LV_USE_{use.upper()}")

esphome/components/lvgl/font.cpp

@@ -0,0 +1,76 @@
+#include "lvgl_esphome.h"
+
+#ifdef USE_LVGL_FONT
+namespace esphome {
+namespace lvgl {
+
+static const uint8_t *get_glyph_bitmap(const lv_font_t *font, uint32_t unicode_letter) {
+  auto *fe = (FontEngine *) font->dsc;
+  const auto *gd = fe->get_glyph_data(unicode_letter);
+  if (gd == nullptr)
+    return nullptr;
+  // esph_log_d(TAG, "Returning bitmap @  %X", (uint32_t)gd->data);
+
+  return gd->data;
+}
+
+static bool get_glyph_dsc_cb(const lv_font_t *font, lv_font_glyph_dsc_t *dsc, uint32_t unicode_letter, uint32_t next) {
+  auto *fe = (FontEngine *) font->dsc;
+  const auto *gd = fe->get_glyph_data(unicode_letter);
+  if (gd == nullptr)
+    return false;
+  dsc->adv_w = gd->advance;
+  dsc->ofs_x = gd->offset_x;
+  dsc->ofs_y = fe->height - gd->height - gd->offset_y - fe->baseline;
+  dsc->box_w = gd->width;
+  dsc->box_h = gd->height;
+  dsc->is_placeholder = 0;
+  dsc->bpp = fe->bpp;
+  return true;
+}
+
+FontEngine::FontEngine(font::Font *esp_font) : font_(esp_font) {
+  this->bpp = esp_font->get_bpp();
+  this->lv_font_.dsc = this;
+  this->lv_font_.line_height = this->height = esp_font->get_height();
+  this->lv_font_.base_line = this->baseline = this->lv_font_.line_height - esp_font->get_baseline();
+  this->lv_font_.get_glyph_dsc = get_glyph_dsc_cb;
+  this->lv_font_.get_glyph_bitmap = get_glyph_bitmap;
+  this->lv_font_.subpx = LV_FONT_SUBPX_NONE;
+  this->lv_font_.underline_position = -1;
+  this->lv_font_.underline_thickness = 1;
+}
+
+const lv_font_t *FontEngine::get_lv_font() { return &this->lv_font_; }
+
+const font::GlyphData *FontEngine::get_glyph_data(uint32_t unicode_letter) {
+  if (unicode_letter == last_letter_)
+    return this->last_data_;
+  uint8_t unicode[5];
+  memset(unicode, 0, sizeof unicode);
+  if (unicode_letter > 0xFFFF) {
+    unicode[0] = 0xF0 + ((unicode_letter >> 18) & 0x7);
+    unicode[1] = 0x80 + ((unicode_letter >> 12) & 0x3F);
+    unicode[2] = 0x80 + ((unicode_letter >> 6) & 0x3F);
+    unicode[3] = 0x80 + (unicode_letter & 0x3F);
+  } else if (unicode_letter > 0x7FF) {
+    unicode[0] = 0xE0 + ((unicode_letter >> 12) & 0xF);
+    unicode[1] = 0x80 + ((unicode_letter >> 6) & 0x3F);
+    unicode[2] = 0x80 + (unicode_letter & 0x3F);
+  } else if (unicode_letter > 0x7F) {
+    unicode[0] = 0xC0 + ((unicode_letter >> 6) & 0x1F);
+    unicode[1] = 0x80 + (unicode_letter & 0x3F);
+  } else {
+    unicode[0] = unicode_letter;
+  }
+  int match_length;
+  int glyph_n = this->font_->match_next_glyph(unicode, &match_length);
+  if (glyph_n < 0)
+    return nullptr;
+  this->last_data_ = this->font_->get_glyphs()[glyph_n].get_glyph_data();
+  this->last_letter_ = unicode_letter;
+  return this->last_data_;
+}
+}  // namespace lvgl
+}  // namespace esphome
+#endif  // USES_LVGL_FONT

esphome/components/lvgl/lv_validation.py

@@ -493,7 +493,6 @@ class LvFont(LValidator):
                 return LV_FONTS
             if is_lv_font(value):
                 return lv_builtin_font(value)
-            add_lv_use("font")
             fontval = cv.use_id(Font)(value)
             esphome_fonts_used.add(fontval)
             return requires_component("font")(fontval)
@@ -503,9 +502,7 @@ class LvFont(LValidator):
     async def process(self, value, args=()):
         if is_lv_font(value):
             return literal(f"&lv_font_{value}")
-        if isinstance(value, str):
-            return literal(f"{value}")
-        return await super().process(value, args)
+        return literal(f"{value}_engine->get_lv_font()")
 
 
 lv_font = LvFont()

esphome/components/lvgl/lvgl_esphome.h

@@ -50,14 +50,6 @@ static const display::ColorBitness LV_BITNESS = display::ColorBitness::COLOR_BIT
 static const display::ColorBitness LV_BITNESS = display::ColorBitness::COLOR_BITNESS_332;
 #endif  // LV_COLOR_DEPTH
 
-#ifdef USE_LVGL_FONT
-inline void lv_obj_set_style_text_font(lv_obj_t *obj, const font::Font *font, lv_style_selector_t part) {
-  lv_obj_set_style_text_font(obj, font->get_lv_font(), part);
-}
-inline void lv_style_set_text_font(lv_style_t *style, const font::Font *font) {
-  lv_style_set_text_font(style, font->get_lv_font());
-}
-#endif
 #ifdef USE_LVGL_IMAGE
 // Shortcut / overload, so that the source of an image can easily be updated
 // from within a lambda.
@@ -142,6 +134,24 @@ template<typename... Ts> class ObjUpdateAction : public Action<Ts...> {
  protected:
   std::function<void(Ts...)> lamb_;
 };
+#ifdef USE_LVGL_FONT
+class FontEngine {
+ public:
+  FontEngine(font::Font *esp_font);
+  const lv_font_t *get_lv_font();
+
+  const font::GlyphData *get_glyph_data(uint32_t unicode_letter);
+  uint16_t baseline{};
+  uint16_t height{};
+  uint8_t bpp{};
+
+ protected:
+  font::Font *font_{};
+  uint32_t last_letter_{};
+  const font::GlyphData *last_data_{};
+  lv_font_t lv_font_{};
+};
+#endif  // USE_LVGL_FONT
 #ifdef USE_LVGL_ANIMIMG
 void lv_animimg_stop(lv_obj_t *obj);
 #endif  // USE_LVGL_ANIMIMG

esphome/components/lvgl/types.py

@@ -45,6 +45,7 @@ lv_coord_t = cg.global_ns.namespace("lv_coord_t")
 lv_event_code_t = cg.global_ns.enum("lv_event_code_t")
 lv_indev_type_t = cg.global_ns.enum("lv_indev_type_t")
 lv_key_t = cg.global_ns.enum("lv_key_t")
+FontEngine = lvgl_ns.class_("FontEngine")
 PlainTrigger = esphome_ns.class_("Trigger<>", automation.Trigger.template())
 DrawEndTrigger = esphome_ns.class_(
     "Trigger<uint32_t, uint32_t>", automation.Trigger.template(cg.uint32, cg.uint32)

esphome/components/mdns/mdns_component.cpp

@@ -135,7 +135,8 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
 
 #ifdef USE_DASHBOARD_IMPORT
     MDNS_STATIC_CONST_CHAR(TXT_PACKAGE_IMPORT_URL, "package_import_url");
-    txt_records.push_back({MDNS_STR(TXT_PACKAGE_IMPORT_URL), MDNS_STR(dashboard_import::get_package_import_url())});
+    txt_records.push_back(
+        {MDNS_STR(TXT_PACKAGE_IMPORT_URL), MDNS_STR(dashboard_import::get_package_import_url().c_str())});
 #endif
   }
 #endif  // USE_API

esphome/components/network/__init__.py

@@ -1,9 +1,7 @@
 import ipaddress
-import logging
 
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_sdkconfig_option
-from esphome.components.psram import is_guaranteed as psram_is_guaranteed
 import esphome.config_validation as cv
 from esphome.const import CONF_ENABLE_IPV6, CONF_MIN_IPV6_ADDR_COUNT
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
@@ -11,13 +9,6 @@ from esphome.core import CORE, CoroPriority, coroutine_with_priority
 CODEOWNERS = ["@esphome/core"]
 AUTO_LOAD = ["mdns"]
 
-_LOGGER = logging.getLogger(__name__)
-
-# High performance networking tracking infrastructure
-# Components can request high performance networking and this configures lwip and WiFi settings
-KEY_HIGH_PERFORMANCE_NETWORKING = "high_performance_networking"
-CONF_ENABLE_HIGH_PERFORMANCE = "enable_high_performance"
-
 network_ns = cg.esphome_ns.namespace("network")
 IPAddress = network_ns.class_("IPAddress")
 
@@ -56,55 +47,6 @@ def ip_address_literal(ip: str | int | None) -> cg.MockObj:
     return IPAddress(str(ip))
 
 
-def require_high_performance_networking() -> None:
-    """Request high performance networking for network and WiFi.
-
-    Call this from components that need optimized network performance for streaming
-    or high-throughput data transfer. This enables high performance mode which
-    configures both lwip TCP settings and WiFi driver settings for improved
-    network performance.
-
-    Settings applied (ESP-IDF only):
-    - lwip: Larger TCP buffers, windows, and mailbox sizes
-    - WiFi: Increased RX/TX buffers, AMPDU aggregation, PSRAM allocation (set by wifi component)
-
-    Configuration is PSRAM-aware:
-    - With PSRAM guaranteed: Aggressive settings (512 RX buffers, 512KB TCP windows)
-    - Without PSRAM: Conservative optimized settings (64 buffers, 65KB TCP windows)
-
-    Example:
-        from esphome.components import network
-
-        def _request_high_performance_networking(config):
-            network.require_high_performance_networking()
-            return config
-
-        CONFIG_SCHEMA = cv.All(
-            ...,
-            _request_high_performance_networking,
-        )
-    """
-    # Only set up once (idempotent - multiple components can call this)
-    if not CORE.data.get(KEY_HIGH_PERFORMANCE_NETWORKING, False):
-        CORE.data[KEY_HIGH_PERFORMANCE_NETWORKING] = True
-
-
-def has_high_performance_networking() -> bool:
-    """Check if high performance networking mode is enabled.
-
-    Returns True when high performance networking has been requested by a
-    component or explicitly enabled in the network configuration. This indicates
-    that lwip and WiFi will use optimized buffer sizes and settings.
-
-    This function should be called during code generation (to_code phase) by
-    components that need to apply performance-related settings.
-
-    Returns:
-        bool: True if high performance networking is enabled, False otherwise
-    """
-    return CORE.data.get(KEY_HIGH_PERFORMANCE_NETWORKING, False)
-
-
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.SplitDefault(
@@ -129,7 +71,6 @@ CONFIG_SCHEMA = cv.Schema(
             ),
         ),
         cv.Optional(CONF_MIN_IPV6_ADDR_COUNT, default=0): cv.positive_int,
-        cv.Optional(CONF_ENABLE_HIGH_PERFORMANCE): cv.All(cv.boolean, cv.only_on_esp32),
     }
 )
 
@@ -139,70 +80,6 @@ async def to_code(config):
     cg.add_define("USE_NETWORK")
     if CORE.using_arduino and CORE.is_esp32:
         cg.add_library("Networking", None)
-
-    # Apply high performance networking settings
-    # Config can explicitly enable/disable, or default to component-driven behavior
-    enable_high_perf = config.get(CONF_ENABLE_HIGH_PERFORMANCE)
-    component_requested = CORE.data.get(KEY_HIGH_PERFORMANCE_NETWORKING, False)
-
-    # Explicit config overrides component request
-    should_enable = (
-        enable_high_perf if enable_high_perf is not None else component_requested
-    )
-
-    # Log when user explicitly disables but a component requested it
-    if enable_high_perf is False and component_requested:
-        _LOGGER.info(
-            "High performance networking disabled by user configuration (overriding component request)"
-        )
-
-    if CORE.is_esp32 and CORE.using_esp_idf and should_enable:
-        # Check if PSRAM is guaranteed (set by psram component during final validation)
-        psram_guaranteed = psram_is_guaranteed()
-
-        if psram_guaranteed:
-            _LOGGER.info(
-                "Applying high-performance lwip settings (PSRAM guaranteed): 512KB TCP windows, 512 mailbox sizes"
-            )
-            # PSRAM is guaranteed - use aggressive settings
-            # Higher maximum values are allowed because CONFIG_LWIP_WND_SCALE is set to true
-            # CONFIG_LWIP_WND_SCALE can only be enabled if CONFIG_SPIRAM_IGNORE_NOTFOUND isn't set
-            # Based on https://github.com/espressif/esp-adf/issues/297#issuecomment-783811702
-
-            # Enable window scaling for much larger TCP windows
-            add_idf_sdkconfig_option("CONFIG_LWIP_WND_SCALE", True)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RCV_SCALE", 3)
-
-            # Large TCP buffers and windows (requires PSRAM)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_SND_BUF_DEFAULT", 65534)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_WND_DEFAULT", 512000)
-
-            # Large mailboxes for high throughput
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_RECVMBOX_SIZE", 512)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RECVMBOX_SIZE", 512)
-
-            # TCP connection limits
-            add_idf_sdkconfig_option("CONFIG_LWIP_MAX_ACTIVE_TCP", 16)
-            add_idf_sdkconfig_option("CONFIG_LWIP_MAX_LISTENING_TCP", 16)
-
-            # TCP optimizations
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_MAXRTX", 12)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_SYNMAXRTX", 6)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_MSS", 1436)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_MSL", 60000)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_OVERSIZE_MSS", True)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_QUEUE_OOSEQ", True)
-        else:
-            _LOGGER.info(
-                "Applying optimized lwip settings: 65KB TCP windows, 64 mailbox sizes"
-            )
-            # PSRAM not guaranteed - use more conservative, but still optimized settings
-            # Based on https://github.com/espressif/esp-idf/blob/release/v5.4/examples/wifi/iperf/sdkconfig.defaults.esp32
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_SND_BUF_DEFAULT", 65534)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_WND_DEFAULT", 65534)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RECVMBOX_SIZE", 64)
-            add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_RECVMBOX_SIZE", 64)
-
     if (enable_ipv6 := config.get(CONF_ENABLE_IPV6, None)) is not None:
         cg.add_define("USE_NETWORK_IPV6", enable_ipv6)
         if enable_ipv6:

esphome/components/network/ip_address.h

@@ -118,10 +118,10 @@ struct IPAddress {
   operator arduino_ns::IPAddress() const { return ip_addr_get_ip4_u32(&ip_addr_); }
 #endif
 
-  bool is_set() const { return !ip_addr_isany(&ip_addr_); }  // NOLINT(readability-simplify-boolean-expr)
-  bool is_ip4() const { return IP_IS_V4(&ip_addr_); }
-  bool is_ip6() const { return IP_IS_V6(&ip_addr_); }
-  bool is_multicast() const { return ip_addr_ismulticast(&ip_addr_); }
+  bool is_set() { return !ip_addr_isany(&ip_addr_); }  // NOLINT(readability-simplify-boolean-expr)
+  bool is_ip4() { return IP_IS_V4(&ip_addr_); }
+  bool is_ip6() { return IP_IS_V6(&ip_addr_); }
+  bool is_multicast() { return ip_addr_ismulticast(&ip_addr_); }
   std::string str() const { return str_lower_case(ipaddr_ntoa(&ip_addr_)); }
   bool operator==(const IPAddress &other) const { return ip_addr_cmp(&ip_addr_, &other.ip_addr_); }
   bool operator!=(const IPAddress &other) const { return !ip_addr_cmp(&ip_addr_, &other.ip_addr_); }

esphome/components/nrf52/__init__.py

@@ -25,7 +25,6 @@ from esphome.const import (
     CONF_FRAMEWORK,
     CONF_ID,
     CONF_RESET_PIN,
-    CONF_VOLTAGE,
     KEY_CORE,
     KEY_FRAMEWORK_VERSION,
     KEY_TARGET_FRAMEWORK,
@@ -103,11 +102,6 @@ nrf52_ns = cg.esphome_ns.namespace("nrf52")
 DeviceFirmwareUpdate = nrf52_ns.class_("DeviceFirmwareUpdate", cg.Component)
 
 CONF_DFU = "dfu"
-CONF_DCDC = "dcdc"
-CONF_REG0 = "reg0"
-CONF_UICR_ERASE = "uicr_erase"
-
-VOLTAGE_LEVELS = [1.8, 2.1, 2.4, 2.7, 3.0, 3.3]
 
 CONFIG_SCHEMA = cv.All(
     _detect_bootloader,
@@ -122,16 +116,6 @@ CONFIG_SCHEMA = cv.All(
                     cv.Required(CONF_RESET_PIN): pins.gpio_output_pin_schema,
                 }
             ),
-            cv.Optional(CONF_DCDC, default=True): cv.boolean,
-            cv.Optional(CONF_REG0): cv.Schema(
-                {
-                    cv.Required(CONF_VOLTAGE): cv.All(
-                        cv.voltage,
-                        cv.one_of(*VOLTAGE_LEVELS, float=True),
-                    ),
-                    cv.Optional(CONF_UICR_ERASE, default=False): cv.boolean,
-                }
-            ),
         }
     ),
 )
@@ -198,13 +182,6 @@ async def to_code(config: ConfigType) -> None:
 
     if dfu_config := config.get(CONF_DFU):
         CORE.add_job(_dfu_to_code, dfu_config)
-    zephyr_add_prj_conf("BOARD_ENABLE_DCDC", config[CONF_DCDC])
-
-    if reg0_config := config.get(CONF_REG0):
-        value = VOLTAGE_LEVELS.index(reg0_config[CONF_VOLTAGE])
-        cg.add_define("USE_NRF52_REG0_VOUT", value)
-        if reg0_config[CONF_UICR_ERASE]:
-            cg.add_define("USE_NRF52_UICR_ERASE")
 
 
 @coroutine_with_priority(CoroPriority.DIAGNOSTICS)

esphome/components/nrf52/uicr.cpp

@@ -1,121 +0,0 @@
-#include "esphome/core/defines.h"
-
-#ifdef USE_NRF52_REG0_VOUT
-#include <zephyr/init.h>
-#include <hal/nrf_power.h>
-#include <zephyr/sys/printk.h>
-
-extern "C" {
-void nvmc_config(uint32_t mode);
-void nvmc_wait();
-nrfx_err_t nrfx_nvmc_uicr_erase();
-}
-
-namespace esphome::nrf52 {
-
-enum class StatusFlags : uint8_t {
-  OK = 0x00,
-  NEED_RESET = 0x01,
-  NEED_ERASE = 0x02,
-};
-
-constexpr StatusFlags &operator|=(StatusFlags &a, StatusFlags b) {
-  a = static_cast<StatusFlags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
-  return a;
-}
-
-constexpr bool operator&(StatusFlags a, StatusFlags b) {
-  return (static_cast<uint8_t>(a) & static_cast<uint8_t>(b)) != 0;
-}
-
-static bool regout0_ok() {
-  return (NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) == (USE_NRF52_REG0_VOUT << UICR_REGOUT0_VOUT_Pos);
-}
-
-static StatusFlags set_regout0() {
-  /* If the board is powered from USB (high voltage mode),
-   * GPIO output voltage is set to 1.8 volts by default.
-   */
-  if (!regout0_ok()) {
-    nvmc_config(NVMC_CONFIG_WEN_Wen);
-    NRF_UICR->REGOUT0 =
-        (NRF_UICR->REGOUT0 & ~((uint32_t) UICR_REGOUT0_VOUT_Msk)) | (USE_NRF52_REG0_VOUT << UICR_REGOUT0_VOUT_Pos);
-    nvmc_wait();
-    nvmc_config(NVMC_CONFIG_WEN_Ren);
-    return regout0_ok() ? StatusFlags::NEED_RESET : StatusFlags::NEED_ERASE;
-  }
-  return StatusFlags::OK;
-}
-
-#ifndef USE_BOOTLOADER_MCUBOOT
-// https://github.com/adafruit/Adafruit_nRF52_Bootloader/blob/6a9a6a3e6d0f86918e9286188426a279976645bd/lib/sdk11/components/libraries/bootloader_dfu/dfu_types.h#L61
-constexpr uint32_t BOOTLOADER_REGION_START = 0x000F4000;
-constexpr uint32_t BOOTLOADER_MBR_PARAMS_PAGE_ADDRESS = 0x000FE000;
-
-static bool bootloader_ok() {
-  return NRF_UICR->NRFFW[0] == BOOTLOADER_REGION_START && NRF_UICR->NRFFW[1] == BOOTLOADER_MBR_PARAMS_PAGE_ADDRESS;
-}
-
-static StatusFlags fix_bootloader() {
-  if (!bootloader_ok()) {
-    nvmc_config(NVMC_CONFIG_WEN_Wen);
-    NRF_UICR->NRFFW[0] = BOOTLOADER_REGION_START;
-    NRF_UICR->NRFFW[1] = BOOTLOADER_MBR_PARAMS_PAGE_ADDRESS;
-    nvmc_wait();
-    nvmc_config(NVMC_CONFIG_WEN_Ren);
-    return bootloader_ok() ? StatusFlags::NEED_RESET : StatusFlags::NEED_ERASE;
-  }
-  return StatusFlags::OK;
-}
-#endif
-
-#define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
-
-static StatusFlags set_uicr() {
-  StatusFlags status = StatusFlags::OK;
-#ifndef USE_BOOTLOADER_MCUBOOT
-  if (BOOTLOADER_VERSION_REGISTER <= 0x902) {
-#ifdef CONFIG_PRINTK
-    printk("cannot control regout0 for %#x\n", BOOTLOADER_VERSION_REGISTER);
-#endif
-  } else
-#endif
-  {
-    status |= set_regout0();
-  }
-#ifndef USE_BOOTLOADER_MCUBOOT
-  status |= fix_bootloader();
-#endif
-  return status;
-}
-
-static int board_esphome_init() {
-  StatusFlags status = set_uicr();
-
-#ifdef USE_NRF52_UICR_ERASE
-  if (status & StatusFlags::NEED_ERASE) {
-    nrfx_err_t ret = nrfx_nvmc_uicr_erase();
-    if (ret != NRFX_SUCCESS) {
-#ifdef CONFIG_PRINTK
-      printk("nrfx_nvmc_uicr_erase failed %d\n", ret);
-#endif
-    } else {
-      status |= set_uicr();
-    }
-  }
-#endif
-
-  if (status & StatusFlags::NEED_RESET) {
-    /* a reset is required for changes to take effect */
-    NVIC_SystemReset();
-  }
-
-  return 0;
-}
-}  // namespace esphome::nrf52
-
-static int board_esphome_init() { return esphome::nrf52::board_esphome_init(); }
-
-SYS_INIT(board_esphome_init, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);
-
-#endif

esphome/components/number/automation.cpp

@@ -1,7 +1,8 @@
 #include "automation.h"
 #include "esphome/core/log.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 static const char *const TAG = "number.automation";
 
@@ -51,4 +52,5 @@ void ValueRangeTrigger::on_state_(float state) {
   this->rtc_.save(&in_range);
 }
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/automation.h

@@ -4,7 +4,8 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 class NumberStateTrigger : public Trigger<float> {
  public:
@@ -90,4 +91,5 @@ template<typename... Ts> class NumberInRangeCondition : public Condition<Ts...>
   float max_{NAN};
 };
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number.cpp

@@ -3,7 +3,8 @@
 #include "esphome/core/controller_registry.h"
 #include "esphome/core/log.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 static const char *const TAG = "number";
 
@@ -42,4 +43,5 @@ void Number::add_on_state_callback(std::function<void(float)> &&callback) {
   this->state_callback_.add(std::move(callback));
 }
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number.h

@@ -6,7 +6,8 @@
 #include "number_call.h"
 #include "number_traits.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 class Number;
 void log_number(const char *tag, const char *prefix, const char *type, Number *obj);
@@ -52,4 +53,5 @@ class Number : public EntityBase {
   CallbackManager<void(float)> state_callback_;
 };
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_call.cpp

@@ -2,7 +2,8 @@
 #include "number.h"
 #include "esphome/core/log.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 static const char *const TAG = "number";
 
@@ -124,4 +125,5 @@ void NumberCall::perform() {
   this->parent_->control(target_value);
 }
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_call.h

@@ -4,7 +4,8 @@
 #include "esphome/core/log.h"
 #include "number_traits.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 class Number;
 
@@ -43,4 +44,5 @@ class NumberCall {
   bool cycle_;
 };
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_traits.cpp

@@ -1,8 +1,10 @@
 #include "esphome/core/log.h"
 #include "number_traits.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 static const char *const TAG = "number";
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/number/number_traits.h

@@ -3,7 +3,8 @@
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 
-namespace esphome::number {
+namespace esphome {
+namespace number {
 
 enum NumberMode : uint8_t {
   NUMBER_MODE_AUTO = 0,
@@ -34,4 +35,5 @@ class NumberTraits : public EntityBase_DeviceClass, public EntityBase_UnitOfMeas
   NumberMode mode_{NUMBER_MODE_AUTO};
 };
 
-}  // namespace esphome::number
+}  // namespace number
+}  // namespace esphome

esphome/components/pcf85063/pcf85063.cpp

@@ -23,7 +23,7 @@ void PCF85063Component::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
-  RealTimeClock::dump_config();
+  ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }
 
 float PCF85063Component::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/pcf8563/pcf8563.cpp

@@ -23,7 +23,7 @@ void PCF8563Component::dump_config() {
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
-  RealTimeClock::dump_config();
+  ESP_LOGCONFIG(TAG, "  Timezone: '%s'", this->timezone_.c_str());
 }
 
 float PCF8563Component::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/psram/__init__.py

@@ -35,9 +35,6 @@ DOMAIN = "psram"
 
 DEPENDENCIES = [PLATFORM_ESP32]
 
-# PSRAM availability tracking for cross-component coordination
-KEY_PSRAM_GUARANTEED = "psram_guaranteed"
-
 _LOGGER = logging.getLogger(__name__)
 
 psram_ns = cg.esphome_ns.namespace(DOMAIN)
@@ -74,23 +71,6 @@ def supported() -> bool:
     return variant in SPIRAM_MODES
 
 
-def is_guaranteed() -> bool:
-    """Check if PSRAM is guaranteed to be available.
-
-    Returns True when PSRAM is configured with both 'disabled: false' and
-    'ignore_not_found: false', meaning the device will fail to boot if PSRAM
-    is not found. This ensures safe use of high buffer configurations that
-    depend on PSRAM.
-
-    This function should be called during code generation (to_code phase) by
-    components that need to know PSRAM availability for configuration decisions.
-
-    Returns:
-        bool: True if PSRAM is guaranteed, False otherwise
-    """
-    return CORE.data.get(KEY_PSRAM_GUARANTEED, False)
-
-
 def validate_psram_mode(config):
     esp32_config = fv.full_config.get()[PLATFORM_ESP32]
     if config[CONF_SPEED] == "120MHZ":
@@ -151,22 +131,7 @@ def get_config_schema(config):
 
 CONFIG_SCHEMA = get_config_schema
 
-
-def _store_psram_guaranteed(config):
-    """Store PSRAM guaranteed status in CORE.data for other components.
-
-    PSRAM is "guaranteed" when it will fail if not found, ensuring safe use
-    of high buffer configurations in network/wifi components.
-
-    Called during final validation to ensure the flag is available
-    before any to_code() functions run.
-    """
-    psram_guaranteed = not config[CONF_DISABLED] and not config[CONF_IGNORE_NOT_FOUND]
-    CORE.data[KEY_PSRAM_GUARANTEED] = psram_guaranteed
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = cv.All(validate_psram_mode, _store_psram_guaranteed)
+FINAL_VALIDATE_SCHEMA = validate_psram_mode
 
 
 async def to_code(config):

esphome/components/rx8130/rx8130.cpp

@@ -62,7 +62,6 @@ void RX8130Component::update() { this->read_time(); }
 void RX8130Component::dump_config() {
   ESP_LOGCONFIG(TAG, "RX8130:");
   LOG_I2C_DEVICE(this);
-  RealTimeClock::dump_config();
 }
 
 void RX8130Component::read_time() {

esphome/components/script/script.h

@@ -46,14 +46,14 @@ template<typename... Ts> class Script : public ScriptLogger, public Trigger<Ts..
 
   // execute this script using a tuple that contains the arguments
   void execute_tuple(const std::tuple<Ts...> &tuple) {
-    this->execute_tuple_(tuple, std::make_index_sequence<sizeof...(Ts)>{});
+    this->execute_tuple_(tuple, typename gens<sizeof...(Ts)>::type());
   }
 
   // Internal function to give scripts readable names.
   void set_name(const LogString *name) { name_ = name; }
 
  protected:
-  template<size_t... S> void execute_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void execute_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->execute(std::get<S>(tuple)...);
   }
 
@@ -157,7 +157,7 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
       const size_t queue_capacity = static_cast<size_t>(this->max_runs_ - 1);
       auto tuple_ptr = std::move(this->var_queue_[this->queue_front_]);
       this->queue_front_ = (this->queue_front_ + 1) % queue_capacity;
-      this->trigger_tuple_(*tuple_ptr, std::make_index_sequence<sizeof...(Ts)>{});
+      this->trigger_tuple_(*tuple_ptr, typename gens<sizeof...(Ts)>::type());
     }
   }
 
@@ -174,7 +174,7 @@ template<typename... Ts> class QueueingScript : public Script<Ts...>, public Com
     }
   }
 
-  template<size_t... S> void trigger_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void trigger_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->trigger(std::get<S>(tuple)...);
   }
 
@@ -305,7 +305,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
 
     while (!this->param_queue_.empty()) {
       auto &params = this->param_queue_.front();
-      this->play_next_tuple_(params, std::make_index_sequence<sizeof...(Ts)>{});
+      this->play_next_tuple_(params, typename gens<sizeof...(Ts)>::type());
       this->param_queue_.pop_front();
     }
     // Queue is now empty - disable loop until next play_complex
@@ -321,7 +321,7 @@ template<class C, typename... Ts> class ScriptWaitAction : public Action<Ts...>,
   }
 
  protected:
-  template<size_t... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, std::index_sequence<S...> /*unused*/) {
+  template<int... S> void play_next_tuple_(const std::tuple<Ts...> &tuple, seq<S...> /*unused*/) {
     this->play_next_(std::get<S>(tuple)...);
   }
 

esphome/components/sntp/sntp_component.cpp

@@ -61,7 +61,6 @@ void SNTPComponent::dump_config() {
   for (auto &server : this->servers_) {
     ESP_LOGCONFIG(TAG, "  Server %zu: '%s'", i++, server);
   }
-  RealTimeClock::dump_config();
 }
 void SNTPComponent::update() {
 #if !defined(USE_ESP32)

esphome/components/sntp/time.py

@@ -1,14 +1,9 @@
-import logging
-
 import esphome.codegen as cg
 from esphome.components import time as time_
-from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
-    CONF_PLATFORM,
     CONF_SERVERS,
-    CONF_TIME,
     PLATFORM_BK72XX,
     PLATFORM_ESP32,
     PLATFORM_ESP8266,
@@ -17,74 +12,13 @@ from esphome.const import (
     PLATFORM_RTL87XX,
 )
 from esphome.core import CORE
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
 
 DEPENDENCIES = ["network"]
-
-CONF_SNTP = "sntp"
-
 sntp_ns = cg.esphome_ns.namespace("sntp")
 SNTPComponent = sntp_ns.class_("SNTPComponent", time_.RealTimeClock)
 
 DEFAULT_SERVERS = ["0.pool.ntp.org", "1.pool.ntp.org", "2.pool.ntp.org"]
 
-
-def _sntp_final_validate(config: ConfigType) -> None:
-    """Merge multiple SNTP instances into one, similar to OTA merging behavior."""
-    full_conf = fv.full_config.get()
-    time_confs = full_conf.get(CONF_TIME, [])
-
-    sntp_configs: list[ConfigType] = []
-    other_time_configs: list[ConfigType] = []
-
-    for time_conf in time_confs:
-        if time_conf.get(CONF_PLATFORM) == CONF_SNTP:
-            sntp_configs.append(time_conf)
-        else:
-            other_time_configs.append(time_conf)
-
-    if len(sntp_configs) <= 1:
-        return
-
-    # Merge all SNTP configs into the first one
-    merged = sntp_configs[0]
-    for sntp_conf in sntp_configs[1:]:
-        # Validate that IDs are consistent if manually specified
-        if merged[CONF_ID].is_manual and sntp_conf[CONF_ID].is_manual:
-            raise cv.Invalid(
-                f"Found multiple SNTP configurations but {CONF_ID} is inconsistent"
-            )
-        merged = merge_config(merged, sntp_conf)
-
-    # Deduplicate servers while preserving order
-    servers = merged[CONF_SERVERS]
-    unique_servers = list(dict.fromkeys(servers))
-
-    # Warn if we're dropping servers due to 3-server limit
-    if len(unique_servers) > 3:
-        dropped = unique_servers[3:]
-        unique_servers = unique_servers[:3]
-        _LOGGER.warning(
-            "SNTP supports maximum 3 servers. Dropped excess server(s): %s",
-            dropped,
-        )
-
-    merged[CONF_SERVERS] = unique_servers
-
-    _LOGGER.warning(
-        "Found and merged %d SNTP time configurations into one instance",
-        len(sntp_configs),
-    )
-
-    # Replace time configs with merged SNTP + other time platforms
-    other_time_configs.append(merged)
-    full_conf[CONF_TIME] = other_time_configs
-    fv.full_config.set(full_conf)
-
-
 CONFIG_SCHEMA = cv.All(
     time_.TIME_SCHEMA.extend(
         {
@@ -106,8 +40,6 @@ CONFIG_SCHEMA = cv.All(
     ),
 )
 
-FINAL_VALIDATE_SCHEMA = _sntp_final_validate
-
 
 async def to_code(config):
     servers = config[CONF_SERVERS]

esphome/components/speaker/media_player/__init__.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from esphome import automation, external_files
 import esphome.codegen as cg
-from esphome.components import audio, esp32, media_player, network, psram, speaker
+from esphome.components import audio, esp32, media_player, psram, speaker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BUFFER_SIZE,
@@ -32,7 +32,6 @@ _LOGGER = logging.getLogger(__name__)
 
 
 AUTO_LOAD = ["audio"]
-DEPENDENCIES = ["network"]
 
 CODEOWNERS = ["@kahrendt", "@synesthesiam"]
 DOMAIN = "media_player"
@@ -281,18 +280,6 @@ PIPELINE_SCHEMA = cv.Schema(
     }
 )
 
-
-def _request_high_performance_networking(config):
-    """Request high performance networking for streaming media.
-
-    Speaker media player streams audio data, so it always benefits from
-    optimized WiFi and lwip settings regardless of codec support.
-    Called during config validation to ensure flags are set before to_code().
-    """
-    network.require_high_performance_networking()
-    return config
-
-
 CONFIG_SCHEMA = cv.All(
     media_player.media_player_schema(SpeakerMediaPlayer).extend(
         {
@@ -317,7 +304,6 @@ CONFIG_SCHEMA = cv.All(
     ),
     cv.only_with_esp_idf,
     _validate_repeated_speaker,
-    _request_high_performance_networking,
 )
 
 
@@ -335,10 +321,28 @@ FINAL_VALIDATE_SCHEMA = cv.All(
 
 async def to_code(config):
     if CORE.data[DOMAIN][config[CONF_ID].id][CONF_CODEC_SUPPORT_ENABLED]:
-        # Compile all supported audio codecs
+        # Compile all supported audio codecs and optimize the wifi settings
+
         cg.add_define("USE_AUDIO_FLAC_SUPPORT", True)
         cg.add_define("USE_AUDIO_MP3_SUPPORT", True)
 
+        # Based on https://github.com/espressif/esp-idf/blob/release/v5.4/examples/wifi/iperf/sdkconfig.defaults.esp32
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM", 16)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM", 64)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM", 64)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_TX_ENABLED", True)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_TX_BA_WIN", 32)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_RX_ENABLED", True)
+        esp32.add_idf_sdkconfig_option("CONFIG_ESP_WIFI_RX_BA_WIN", 32)
+
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_SND_BUF_DEFAULT", 65534)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_WND_DEFAULT", 65534)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCP_RECVMBOX_SIZE", 64)
+        esp32.add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_RECVMBOX_SIZE", 64)
+
+        # Allocate wifi buffers in PSRAM
+        esp32.add_idf_sdkconfig_option("CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP", True)
+
     var = await media_player.new_media_player(config)
     await cg.register_component(var, config)
 

esphome/components/template/alarm_control_panel/__init__.py

@@ -137,11 +137,7 @@ async def to_code(config):
         cg.add(var.set_arming_night_time(config[CONF_ARMING_NIGHT_TIME]))
         supports_arm_night = True
 
-    if sensors := config.get(CONF_BINARY_SENSORS, []):
-        # Initialize FixedVector with the exact number of sensors
-        cg.add(var.init_sensors(len(sensors)))
-
-    for sensor in sensors:
+    for sensor in config.get(CONF_BINARY_SENSORS, []):
         bs = await cg.get_variable(sensor[CONF_INPUT])
 
         flags = BinarySensorFlags[FLAG_NORMAL]

esphome/components/template/alarm_control_panel/template_alarm_control_panel.cpp

@@ -20,13 +20,10 @@ void TemplateAlarmControlPanel::add_sensor(binary_sensor::BinarySensor *sensor,
   // Save the flags and type. Assign a store index for the per sensor data type.
   SensorDataStore sd;
   sd.last_chime_state = false;
-  AlarmSensor alarm_sensor;
-  alarm_sensor.sensor = sensor;
-  alarm_sensor.info.flags = flags;
-  alarm_sensor.info.type = type;
-  alarm_sensor.info.store_index = this->next_store_index_++;
-  this->sensors_.push_back(alarm_sensor);
+  this->sensor_map_[sensor].flags = flags;
+  this->sensor_map_[sensor].type = type;
   this->sensor_data_.push_back(sd);
+  this->sensor_map_[sensor].store_index = this->next_store_index_++;
 };
 
 static const LogString *sensor_type_to_string(AlarmSensorType type) {
@@ -48,7 +45,7 @@ void TemplateAlarmControlPanel::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "TemplateAlarmControlPanel:\n"
                 "  Current State: %s\n"
-                "  Number of Codes: %zu\n"
+                "  Number of Codes: %u\n"
                 "  Requires Code To Arm: %s\n"
                 "  Arming Away Time: %" PRIu32 "s\n"
                 "  Arming Home Time: %" PRIu32 "s\n"
@@ -61,8 +58,7 @@ void TemplateAlarmControlPanel::dump_config() {
                 (this->arming_home_time_ / 1000), (this->arming_night_time_ / 1000), (this->pending_time_ / 1000),
                 (this->trigger_time_ / 1000), this->get_supported_features());
 #ifdef USE_BINARY_SENSOR
-  for (const auto &alarm_sensor : this->sensors_) {
-    const uint16_t flags = alarm_sensor.info.flags;
+  for (auto const &[sensor, info] : this->sensor_map_) {
     ESP_LOGCONFIG(TAG,
                   "  Binary Sensor:\n"
                   "    Name: %s\n"
@@ -71,10 +67,11 @@ void TemplateAlarmControlPanel::dump_config() {
                   "    Armed night bypass: %s\n"
                   "    Auto bypass: %s\n"
                   "    Chime mode: %s",
-                  alarm_sensor.sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(alarm_sensor.info.type)),
-                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
-                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
-                  TRUEFALSE(flags & BINARY_SENSOR_MODE_BYPASS_AUTO), TRUEFALSE(flags & BINARY_SENSOR_MODE_CHIME));
+                  sensor->get_name().c_str(), LOG_STR_ARG(sensor_type_to_string(info.type)),
+                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_HOME),
+                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_ARMED_NIGHT),
+                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO),
+                  TRUEFALSE(info.flags & BINARY_SENSOR_MODE_CHIME));
   }
 #endif
 }
@@ -124,9 +121,7 @@ void TemplateAlarmControlPanel::loop() {
 
 #ifdef USE_BINARY_SENSOR
   // Test all of the sensors regardless of the alarm panel state
-  for (const auto &alarm_sensor : this->sensors_) {
-    const auto &info = alarm_sensor.info;
-    auto *sensor = alarm_sensor.sensor;
+  for (auto const &[sensor, info] : this->sensor_map_) {
     // Check for chime zones
     if (info.flags & BINARY_SENSOR_MODE_CHIME) {
       // Look for the transition from closed to open
@@ -247,11 +242,11 @@ void TemplateAlarmControlPanel::arm_(optional<std::string> code, alarm_control_p
 
 void TemplateAlarmControlPanel::bypass_before_arming() {
 #ifdef USE_BINARY_SENSOR
-  for (const auto &alarm_sensor : this->sensors_) {
+  for (auto const &[sensor, info] : this->sensor_map_) {
     // Check for faulted bypass_auto sensors and remove them from monitoring
-    if ((alarm_sensor.info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (alarm_sensor.sensor->state)) {
-      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", alarm_sensor.sensor->get_name().c_str());
-      this->bypassed_sensor_indicies_.push_back(alarm_sensor.info.store_index);
+    if ((info.flags & BINARY_SENSOR_MODE_BYPASS_AUTO) && (sensor->state)) {
+      ESP_LOGW(TAG, "'%s' is faulted and will be automatically bypassed", sensor->get_name().c_str());
+      this->bypassed_sensor_indicies_.push_back(info.store_index);
     }
   }
 #endif

esphome/components/template/alarm_control_panel/template_alarm_control_panel.h

@@ -1,12 +1,11 @@
 #pragma once
 
 #include <cinttypes>
-#include <vector>
+#include <map>
 
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
 
 #include "esphome/components/alarm_control_panel/alarm_control_panel.h"
 
@@ -50,13 +49,6 @@ struct SensorInfo {
   uint8_t store_index;
 };
 
-#ifdef USE_BINARY_SENSOR
-struct AlarmSensor {
-  binary_sensor::BinarySensor *sensor;
-  SensorInfo info;
-};
-#endif
-
 class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControlPanel, public Component {
  public:
   TemplateAlarmControlPanel();
@@ -71,12 +63,6 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
   void bypass_before_arming();
 
 #ifdef USE_BINARY_SENSOR
-  /** Initialize the sensors vector with the specified capacity.
-   *
-   * @param capacity The number of sensors to allocate space for.
-   */
-  void init_sensors(size_t capacity) { this->sensors_.init(capacity); }
-
   /** Add a binary_sensor to the alarm_panel.
    *
    * @param sensor The BinarySensor instance.
@@ -136,8 +122,8 @@ class TemplateAlarmControlPanel final : public alarm_control_panel::AlarmControl
  protected:
   void control(const alarm_control_panel::AlarmControlPanelCall &call) override;
 #ifdef USE_BINARY_SENSOR
-  // List of binary sensors with their alarm-specific info
-  FixedVector<AlarmSensor> sensors_;
+  // This maps a binary sensor to its alarm specific info
+  std::map<binary_sensor::BinarySensor *, SensorInfo> sensor_map_;
   // a list of automatically bypassed sensors
   std::vector<uint8_t> bypassed_sensor_indicies_;
 #endif

esphome/components/thermostat/climate.py

@@ -945,10 +945,6 @@ async def to_code(config):
     cg.add(var.set_humidity_hysteresis(config[CONF_HUMIDITY_HYSTERESIS]))
 
     if CONF_PRESET in config:
-        # Separate standard and custom presets, and build preset config variables
-        standard_presets: list[tuple[cg.MockObj, cg.MockObj]] = []
-        custom_presets: list[tuple[str, cg.MockObj]] = []
-
         for preset_config in config[CONF_PRESET]:
             name = preset_config[CONF_NAME]
             standard_preset = None
@@ -991,39 +987,9 @@ async def to_code(config):
                 )
 
             if standard_preset is not None:
-                standard_presets.append((standard_preset, preset_target_variable))
+                cg.add(var.set_preset_config(standard_preset, preset_target_variable))
             else:
-                custom_presets.append((name, preset_target_variable))
-
-        # Build initializer list for standard presets
-        if standard_presets:
-            cg.add(
-                var.set_preset_config(
-                    [
-                        cg.StructInitializer(
-                            thermostat_ns.struct("ThermostatPresetEntry"),
-                            ("preset", preset),
-                            ("config", preset_var),
-                        )
-                        for preset, preset_var in standard_presets
-                    ]
-                )
-            )
-
-        # Build initializer list for custom presets
-        if custom_presets:
-            cg.add(
-                var.set_custom_preset_config(
-                    [
-                        cg.StructInitializer(
-                            thermostat_ns.struct("ThermostatCustomPresetEntry"),
-                            ("name", cg.RawExpression(f'"{name}"')),
-                            ("config", preset_var),
-                        )
-                        for name, preset_var in custom_presets
-                    ]
-                )
-            )
+                cg.add(var.set_custom_preset_config(name, preset_target_variable))
 
     if CONF_DEFAULT_PRESET in config:
         default_preset_name = config[CONF_DEFAULT_PRESET]

esphome/components/thermostat/thermostat_climate.cpp

@@ -53,8 +53,8 @@ void ThermostatClimate::setup() {
   if (use_default_preset) {
     if (this->default_preset_ != climate::ClimatePreset::CLIMATE_PRESET_NONE) {
       this->change_preset_(this->default_preset_);
-    } else if (this->default_custom_preset_ != nullptr) {
-      this->change_custom_preset_(this->default_custom_preset_);
+    } else if (!this->default_custom_preset_.empty()) {
+      this->change_custom_preset_(this->default_custom_preset_.c_str());
     }
   }
 
@@ -319,16 +319,16 @@ climate::ClimateTraits ThermostatClimate::traits() {
   if (this->supports_swing_mode_vertical_)
     traits.add_supported_swing_mode(climate::CLIMATE_SWING_VERTICAL);
 
-  for (const auto &entry : this->preset_config_) {
-    traits.add_supported_preset(entry.preset);
+  for (auto &it : this->preset_config_) {
+    traits.add_supported_preset(it.first);
   }
 
-  // Extract custom preset names from the custom_preset_config_ vector
+  // Extract custom preset names from the custom_preset_config_ map
   if (!this->custom_preset_config_.empty()) {
     std::vector<const char *> custom_preset_names;
     custom_preset_names.reserve(this->custom_preset_config_.size());
-    for (const auto &entry : this->custom_preset_config_) {
-      custom_preset_names.push_back(entry.name);
+    for (const auto &it : this->custom_preset_config_) {
+      custom_preset_names.push_back(it.first.c_str());
     }
     traits.set_supported_custom_presets(custom_preset_names);
   }
@@ -1154,18 +1154,12 @@ void ThermostatClimate::dump_preset_config_(const char *preset_name, const Therm
 }
 
 void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
-  // Linear search through preset configurations
-  const ThermostatClimateTargetTempConfig *config = nullptr;
-  for (const auto &entry : this->preset_config_) {
-    if (entry.preset == preset) {
-      config = &entry.config;
-      break;
-    }
-  }
+  auto config = this->preset_config_.find(preset);
 
-  if (config != nullptr) {
+  if (config != this->preset_config_.end()) {
     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) {
+    if (this->change_preset_internal_(config->second) || (!this->preset.has_value()) ||
+        this->preset.value() != preset) {
       // Fire any preset changed trigger if defined
       Trigger<> *trig = this->preset_change_trigger_;
       this->set_preset_(preset);
@@ -1184,18 +1178,11 @@ void ThermostatClimate::change_preset_(climate::ClimatePreset preset) {
 }
 
 void ThermostatClimate::change_custom_preset_(const char *custom_preset) {
-  // Linear search through custom preset configurations
-  const ThermostatClimateTargetTempConfig *config = nullptr;
-  for (const auto &entry : this->custom_preset_config_) {
-    if (strcmp(entry.name, custom_preset) == 0) {
-      config = &entry.config;
-      break;
-    }
-  }
+  auto config = this->custom_preset_config_.find(custom_preset);
 
-  if (config != nullptr) {
+  if (config != this->custom_preset_config_.end()) {
     ESP_LOGV(TAG, "Custom preset %s requested", custom_preset);
-    if (this->change_preset_internal_(*config) || !this->has_custom_preset() ||
+    if (this->change_preset_internal_(config->second) || !this->has_custom_preset() ||
         strcmp(this->get_custom_preset(), custom_preset) != 0) {
       // Fire any preset changed trigger if defined
       Trigger<> *trig = this->preset_change_trigger_;
@@ -1260,12 +1247,14 @@ bool ThermostatClimate::change_preset_internal_(const ThermostatClimateTargetTem
   return something_changed;
 }
 
-void ThermostatClimate::set_preset_config(std::initializer_list<PresetEntry> presets) {
-  this->preset_config_ = presets;
+void ThermostatClimate::set_preset_config(climate::ClimatePreset preset,
+                                          const ThermostatClimateTargetTempConfig &config) {
+  this->preset_config_[preset] = config;
 }
 
-void ThermostatClimate::set_custom_preset_config(std::initializer_list<CustomPresetEntry> presets) {
-  this->custom_preset_config_ = presets;
+void ThermostatClimate::set_custom_preset_config(const std::string &name,
+                                                 const ThermostatClimateTargetTempConfig &config) {
+  this->custom_preset_config_[name] = config;
 }
 
 ThermostatClimate::ThermostatClimate()
@@ -1304,16 +1293,8 @@ ThermostatClimate::ThermostatClimate()
       humidity_control_humidify_action_trigger_(new Trigger<>()),
       humidity_control_off_action_trigger_(new Trigger<>()) {}
 
-void ThermostatClimate::set_default_preset(const char *custom_preset) {
-  // Find the preset in custom_preset_config_ and store pointer from there
-  for (const auto &entry : this->custom_preset_config_) {
-    if (strcmp(entry.name, custom_preset) == 0) {
-      this->default_custom_preset_ = entry.name;
-      return;
-    }
-  }
-  // If not found, it will be caught during validation
-  this->default_custom_preset_ = nullptr;
+void ThermostatClimate::set_default_preset(const std::string &custom_preset) {
+  this->default_custom_preset_ = custom_preset;
 }
 
 void ThermostatClimate::set_default_preset(climate::ClimatePreset preset) { this->default_preset_ = preset; }
@@ -1624,22 +1605,19 @@ void ThermostatClimate::dump_config() {
 
   if (!this->preset_config_.empty()) {
     ESP_LOGCONFIG(TAG, "  Supported PRESETS:");
-    for (const auto &entry : this->preset_config_) {
-      const auto *preset_name = LOG_STR_ARG(climate::climate_preset_to_string(entry.preset));
-      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name, entry.preset == this->default_preset_ ? " (default)" : "");
-      this->dump_preset_config_(preset_name, entry.config);
+    for (auto &it : this->preset_config_) {
+      const auto *preset_name = LOG_STR_ARG(climate::climate_preset_to_string(it.first));
+      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name, it.first == this->default_preset_ ? " (default)" : "");
+      this->dump_preset_config_(preset_name, it.second);
     }
   }
 
   if (!this->custom_preset_config_.empty()) {
     ESP_LOGCONFIG(TAG, "  Supported CUSTOM PRESETS:");
-    for (const auto &entry : this->custom_preset_config_) {
-      const auto *preset_name = entry.name;
-      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name,
-                    (this->default_custom_preset_ != nullptr && strcmp(entry.name, this->default_custom_preset_) == 0)
-                        ? " (default)"
-                        : "");
-      this->dump_preset_config_(preset_name, entry.config);
+    for (auto &it : this->custom_preset_config_) {
+      const auto *preset_name = it.first.c_str();
+      ESP_LOGCONFIG(TAG, "    %s:%s", preset_name, it.first == this->default_custom_preset_ ? " (default)" : "");
+      this->dump_preset_config_(preset_name, it.second);
     }
   }
 }

esphome/components/thermostat/thermostat_climate.h

@@ -3,12 +3,12 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/sensor/sensor.h"
 
 #include <array>
 #include <cinttypes>
+#include <map>
 
 namespace esphome {
 namespace thermostat {
@@ -72,29 +72,14 @@ struct ThermostatClimateTargetTempConfig {
   optional<climate::ClimateMode> mode_{};
 };
 
-/// Entry for standard preset lookup
-struct ThermostatPresetEntry {
-  climate::ClimatePreset preset;
-  ThermostatClimateTargetTempConfig config;
-};
-
-/// Entry for custom preset lookup
-struct ThermostatCustomPresetEntry {
-  const char *name;
-  ThermostatClimateTargetTempConfig config;
-};
-
 class ThermostatClimate : public climate::Climate, public Component {
  public:
-  using PresetEntry = ThermostatPresetEntry;
-  using CustomPresetEntry = ThermostatCustomPresetEntry;
-
   ThermostatClimate();
   void setup() override;
   void dump_config() override;
   void loop() override;
 
-  void set_default_preset(const char *custom_preset);
+  void set_default_preset(const std::string &custom_preset);
   void set_default_preset(climate::ClimatePreset preset);
   void set_on_boot_restore_from(OnBootRestoreFrom on_boot_restore_from);
   void set_set_point_minimum_differential(float differential);
@@ -146,8 +131,8 @@ class ThermostatClimate : public climate::Climate, public Component {
   void set_supports_humidification(bool supports_humidification);
   void set_supports_two_points(bool supports_two_points);
 
-  void set_preset_config(std::initializer_list<PresetEntry> presets);
-  void set_custom_preset_config(std::initializer_list<CustomPresetEntry> presets);
+  void set_preset_config(climate::ClimatePreset preset, const ThermostatClimateTargetTempConfig &config);
+  void set_custom_preset_config(const std::string &name, const ThermostatClimateTargetTempConfig &config);
 
   Trigger<> *get_cool_action_trigger() const;
   Trigger<> *get_supplemental_cool_action_trigger() const;
@@ -531,6 +516,9 @@ class ThermostatClimate : public climate::Climate, public Component {
   Trigger<> *prev_swing_mode_trigger_{nullptr};
   Trigger<> *prev_humidity_control_trigger_{nullptr};
 
+  /// Default custom preset to use on start up
+  std::string default_custom_preset_{};
+
   /// Climate action timers
   std::array<ThermostatClimateTimer, THERMOSTAT_TIMER_COUNT> timer_{
       ThermostatClimateTimer(false, 0, 0, std::bind(&ThermostatClimate::cooling_max_run_time_timer_callback_, this)),
@@ -546,12 +534,9 @@ class ThermostatClimate : public climate::Climate, public Component {
   };
 
   /// The set of standard preset configurations this thermostat supports (Eg. AWAY, ECO, etc)
-  FixedVector<PresetEntry> preset_config_{};
+  std::map<climate::ClimatePreset, ThermostatClimateTargetTempConfig> preset_config_{};
   /// The set of custom preset configurations this thermostat supports (eg. "My Custom Preset")
-  FixedVector<CustomPresetEntry> custom_preset_config_{};
-  /// Default custom preset to use on start up (pointer to entry in custom_preset_config_)
- private:
-  const char *default_custom_preset_{nullptr};
+  std::map<std::string, ThermostatClimateTargetTempConfig> custom_preset_config_{};
 };
 
 }  // namespace thermostat

esphome/components/time/real_time_clock.cpp

@@ -23,13 +23,6 @@ namespace time {
 static const char *const TAG = "time";
 
 RealTimeClock::RealTimeClock() = default;
-
-void RealTimeClock::dump_config() {
-#ifdef USE_TIME_TIMEZONE
-  ESP_LOGCONFIG(TAG, "Timezone: '%s'", this->timezone_.c_str());
-#endif
-}
-
 void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
   ESP_LOGVV(TAG, "Got epoch %" PRIu32, epoch);
   // Update UTC epoch time.

esphome/components/time/real_time_clock.h

@@ -52,8 +52,6 @@ class RealTimeClock : public PollingComponent {
     this->time_sync_callback_.add(std::move(callback));
   };
 
-  void dump_config() override;
-
  protected:
   /// Report a unix epoch as current time.
   void synchronize_epoch_(uint32_t epoch);

esphome/components/uart/__init__.py

@@ -1,4 +1,3 @@
-from logging import getLogger
 import math
 import re
 
@@ -36,8 +35,6 @@ from esphome.core import CORE, ID
 import esphome.final_validate as fv
 from esphome.yaml_util import make_data_base
 
-_LOGGER = getLogger(__name__)
-
 CODEOWNERS = ["@esphome/core"]
 uart_ns = cg.esphome_ns.namespace("uart")
 UARTComponent = uart_ns.class_("UARTComponent")
@@ -133,21 +130,6 @@ def validate_host_config(config):
     return config
 
 
-def validate_rx_buffer_size(config):
-    if CORE.is_esp32:
-        # ESP32 UART hardware FIFO is 128 bytes (LP UART is 16 bytes, but we use 128 as safe minimum)
-        # rx_buffer_size must be greater than the hardware FIFO length
-        min_buffer_size = 128
-        if config[CONF_RX_BUFFER_SIZE] <= min_buffer_size:
-            _LOGGER.warning(
-                "UART rx_buffer_size (%d bytes) is too small and must be greater than the hardware "
-                "FIFO size (%d bytes). The buffer size will be automatically adjusted at runtime.",
-                config[CONF_RX_BUFFER_SIZE],
-                min_buffer_size,
-            )
-    return config
-
-
 def _uart_declare_type(value):
     if CORE.is_esp8266:
         return cv.declare_id(ESP8266UartComponent)(value)
@@ -265,7 +247,6 @@ CONFIG_SCHEMA = cv.All(
     ).extend(cv.COMPONENT_SCHEMA),
     cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN, CONF_PORT),
     validate_host_config,
-    validate_rx_buffer_size,
 )
 
 

esphome/components/uart/uart_component_esp8266.cpp

@@ -56,19 +56,11 @@ uint32_t ESP8266UartComponent::get_config() {
 }
 
 void ESP8266UartComponent::setup() {
-  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
-    if (!pin) {
-      return;
-    }
-    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
-    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
-      pin->setup();
-    }
-  };
-
-  setup_pin_if_needed(this->rx_pin_);
-  if (this->rx_pin_ != this->tx_pin_) {
-    setup_pin_if_needed(this->tx_pin_);
+  if (this->rx_pin_) {
+    this->rx_pin_->setup();
+  }
+  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
+    this->tx_pin_->setup();
   }
 
   // Use Arduino HardwareSerial UARTs if all used pins match the ones

esphome/components/uart/uart_component_esp_idf.cpp

@@ -91,16 +91,6 @@ void IDFUARTComponent::setup() {
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
   this->lock_ = xSemaphoreCreateMutex();
 
-#if (SOC_UART_LP_NUM >= 1)
-  size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
-#else
-  size_t fifo_len = SOC_UART_FIFO_LEN;
-#endif
-  if (this->rx_buffer_size_ <= fifo_len) {
-    ESP_LOGW(TAG, "rx_buffer_size is too small, must be greater than %zu", fifo_len);
-    this->rx_buffer_size_ = fifo_len * 2;
-  }
-
   xSemaphoreTake(this->lock_, portMAX_DELAY);
 
   this->load_settings(false);
@@ -133,19 +123,11 @@ void IDFUARTComponent::load_settings(bool dump_config) {
     return;
   }
 
-  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
-    if (!pin) {
-      return;
-    }
-    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
-    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
-      pin->setup();
-    }
-  };
-
-  setup_pin_if_needed(this->rx_pin_);
-  if (this->rx_pin_ != this->tx_pin_) {
-    setup_pin_if_needed(this->tx_pin_);
+  if (this->rx_pin_) {
+    this->rx_pin_->setup();
+  }
+  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
+    this->tx_pin_->setup();
   }
 
   int8_t tx = this->tx_pin_ != nullptr ? this->tx_pin_->get_pin() : -1;
@@ -255,12 +237,8 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
+  uart_write_bytes(this->uart_num_, data, len);
   xSemaphoreGive(this->lock_);
-  if (write_len != (int32_t) len) {
-    ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
-    this->mark_failed();
-  }
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_TX, data[i]);
@@ -289,7 +267,6 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
 
 bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   size_t length_to_read = len;
-  int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
   xSemaphoreTake(this->lock_, portMAX_DELAY);
@@ -300,31 +277,25 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
     this->has_peek_ = false;
   }
   if (length_to_read > 0)
-    read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+    uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
   xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
   }
 #endif
-  return read_len == (int32_t) length_to_read;
+  return true;
 }
 
 int IDFUARTComponent::available() {
-  size_t available = 0;
-  esp_err_t err;
+  size_t available;
 
   xSemaphoreTake(this->lock_, portMAX_DELAY);
-  err = uart_get_buffered_data_len(this->uart_num_, &available);
+  uart_get_buffered_data_len(this->uart_num_, &available);
+  if (this->has_peek_)
+    available++;
   xSemaphoreGive(this->lock_);
 
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
-    this->mark_failed();
-  }
-  if (this->has_peek_) {
-    available++;
-  }
   return available;
 }
 

esphome/components/uart/uart_component_libretiny.cpp

@@ -53,7 +53,7 @@ void LibreTinyUARTComponent::setup() {
 
   auto shouldFallbackToSoftwareSerial = [&]() -> bool {
     auto hasFlags = [](InternalGPIOPin *pin, const gpio::Flags mask) -> bool {
-      return pin && (pin->get_flags() & mask) != gpio::Flags::FLAG_NONE;
+      return pin && pin->get_flags() & mask != gpio::Flags::FLAG_NONE;
     };
     if (hasFlags(this->tx_pin_, gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN) ||
         hasFlags(this->rx_pin_, gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN)) {

esphome/components/uart/uart_component_rp2040.cpp

@@ -52,19 +52,11 @@ uint16_t RP2040UartComponent::get_config() {
 }
 
 void RP2040UartComponent::setup() {
-  auto setup_pin_if_needed = [](InternalGPIOPin *pin) {
-    if (!pin) {
-      return;
-    }
-    const auto mask = gpio::Flags::FLAG_OPEN_DRAIN | gpio::Flags::FLAG_PULLUP | gpio::Flags::FLAG_PULLDOWN;
-    if ((pin->get_flags() & mask) != gpio::Flags::FLAG_NONE) {
-      pin->setup();
-    }
-  };
-
-  setup_pin_if_needed(this->rx_pin_);
-  if (this->rx_pin_ != this->tx_pin_) {
-    setup_pin_if_needed(this->tx_pin_);
+  if (this->rx_pin_) {
+    this->rx_pin_->setup();
+  }
+  if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
+    this->tx_pin_->setup();
   }
 
   uint16_t config = get_config();

esphome/components/web_server/ota/__init__.py

@@ -1,17 +1,10 @@
-import logging
-
 import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
 from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
-from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_OTA, CONF_PLATFORM, CONF_WEB_SERVER
+from esphome.const import CONF_ID
 from esphome.core import CORE, coroutine_with_priority
 from esphome.coroutine import CoroPriority
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-_LOGGER = logging.getLogger(__name__)
 
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network", "web_server_base"]
@@ -19,53 +12,6 @@ DEPENDENCIES = ["network", "web_server_base"]
 web_server_ns = cg.esphome_ns.namespace("web_server")
 WebServerOTAComponent = web_server_ns.class_("WebServerOTAComponent", OTAComponent)
 
-
-def _web_server_ota_final_validate(config: ConfigType) -> None:
-    """Merge multiple web_server OTA instances into one.
-
-    Multiple web_server OTA instances register duplicate HTTP handlers for /update,
-    causing undefined behavior. Merge them into a single instance.
-    """
-    full_conf = fv.full_config.get()
-    ota_confs = full_conf.get(CONF_OTA, [])
-
-    web_server_ota_configs: list[ConfigType] = []
-    other_ota_configs: list[ConfigType] = []
-
-    for ota_conf in ota_confs:
-        if ota_conf.get(CONF_PLATFORM) == CONF_WEB_SERVER:
-            web_server_ota_configs.append(ota_conf)
-        else:
-            other_ota_configs.append(ota_conf)
-
-    if len(web_server_ota_configs) <= 1:
-        return
-
-    # Merge all web_server OTA configs into the first one
-    merged = web_server_ota_configs[0]
-    for ota_conf in web_server_ota_configs[1:]:
-        # Validate that IDs are consistent if manually specified
-        if (
-            merged[CONF_ID].is_manual
-            and ota_conf[CONF_ID].is_manual
-            and merged[CONF_ID] != ota_conf[CONF_ID]
-        ):
-            raise cv.Invalid(
-                f"Found multiple web_server OTA configurations but {CONF_ID} is inconsistent"
-            )
-        merged = merge_config(merged, ota_conf)
-
-    _LOGGER.warning(
-        "Found and merged %d web_server OTA configurations into one instance",
-        len(web_server_ota_configs),
-    )
-
-    # Replace OTA configs with merged web_server + other OTA platforms
-    other_ota_configs.append(merged)
-    full_conf[CONF_OTA] = other_ota_configs
-    fv.full_config.set(full_conf)
-
-
 CONFIG_SCHEMA = (
     cv.Schema(
         {
@@ -76,8 +22,6 @@ CONFIG_SCHEMA = (
     .extend(cv.COMPONENT_SCHEMA)
 )
 
-FINAL_VALIDATE_SCHEMA = _web_server_ota_final_validate
-
 
 @coroutine_with_priority(CoroPriority.WEB_SERVER_OTA)
 async def to_code(config):

esphome/components/web_server_idf/web_server_idf.cpp

@@ -490,18 +490,10 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
 
 void AsyncEventSourceResponse::destroy(void *ptr) {
   auto *rsp = static_cast<AsyncEventSourceResponse *>(ptr);
-  int fd = rsp->fd_.exchange(0);  // Atomically get and clear fd
-
-  if (fd > 0) {
-    ESP_LOGD(TAG, "Event source connection closed (fd: %d)", fd);
-    // Immediately shut down the socket to prevent lwIP from delivering more data
-    // This prevents "recv_tcp: recv for wrong pcb!" assertions when the TCP stack
-    // tries to deliver queued data after the session is marked as dead
-    // See: https://github.com/esphome/esphome/issues/11936
-    shutdown(fd, SHUT_RDWR);
-    // Note: We don't close() the socket - httpd owns it and will close it
-  }
-  // Session will be cleaned up in the main loop to avoid race conditions
+  ESP_LOGD(TAG, "Event source connection closed (fd: %d)", rsp->fd_.load());
+  // Mark as dead by setting fd to 0 - will be cleaned up in the main loop
+  rsp->fd_.store(0);
+  // Note: We don't delete or remove from set here to avoid race conditions
 }
 
 // helper for allowing only unique entries in the queue

esphome/components/wifi/__init__.py

@@ -5,13 +5,10 @@ from esphome.automation import Condition
 import esphome.codegen as cg
 from esphome.components.const import CONF_USE_PSRAM
 from esphome.components.esp32 import add_idf_sdkconfig_option, const, get_esp32_variant
-from esphome.components.network import (
-    has_high_performance_networking,
-    ip_address_literal,
-)
-from esphome.components.psram import is_guaranteed as psram_is_guaranteed
+from esphome.components.network import ip_address_literal
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
+from esphome.config_validation import only_with_esp_idf
 from esphome.const import (
     CONF_AP,
     CONF_BSSID,
@@ -59,8 +56,6 @@ _LOGGER = logging.getLogger(__name__)
 
 AUTO_LOAD = ["network"]
 
-_LOGGER = logging.getLogger(__name__)
-
 NO_WIFI_VARIANTS = [const.VARIANT_ESP32H2, const.VARIANT_ESP32P4]
 CONF_SAVE = "save"
 CONF_MIN_AUTH_MODE = "min_auth_mode"
@@ -351,7 +346,7 @@ CONFIG_SCHEMA = cv.All(
                 single=True
             ),
             cv.Optional(CONF_USE_PSRAM): cv.All(
-                cv.only_on_esp32, cv.requires_component("psram"), cv.boolean
+                only_with_esp_idf, cv.requires_component("psram"), cv.boolean
             ),
         }
     ),
@@ -430,8 +425,6 @@ async def to_code(config):
 
     # Track if any network uses Enterprise authentication
     has_eap = False
-    # Track if any network uses manual IP
-    has_manual_ip = False
 
     # Initialize FixedVector with the count of networks
     networks = config.get(CONF_NETWORKS, [])
@@ -445,15 +438,11 @@ async def to_code(config):
         for network in networks:
             if CONF_EAP in network:
                 has_eap = True
-            if network.get(CONF_MANUAL_IP) or config.get(CONF_MANUAL_IP):
-                has_manual_ip = True
             cg.with_local_variable(network[CONF_ID], WiFiAP(), add_sta, network)
 
     if CONF_AP in config:
         conf = config[CONF_AP]
         ip_config = conf.get(CONF_MANUAL_IP)
-        if ip_config:
-            has_manual_ip = True
         cg.with_local_variable(
             conf[CONF_ID],
             WiFiAP(),
@@ -469,10 +458,6 @@ async def to_code(config):
     if CORE.is_esp32:
         add_idf_sdkconfig_option("CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT", has_eap)
 
-    # Only define USE_WIFI_MANUAL_IP if any AP uses manual IP
-    if has_manual_ip:
-        cg.add_define("USE_WIFI_MANUAL_IP")
-
     cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
     cg.add(var.set_power_save_mode(config[CONF_POWER_SAVE_MODE]))
     if CONF_MIN_AUTH_MODE in config:
@@ -501,56 +486,6 @@ async def to_code(config):
 
     if config.get(CONF_USE_PSRAM):
         add_idf_sdkconfig_option("CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP", True)
-
-    # Apply high performance WiFi settings if high performance networking is enabled
-    if CORE.is_esp32 and CORE.using_esp_idf and has_high_performance_networking():
-        # Check if PSRAM is guaranteed (set by psram component during final validation)
-        psram_guaranteed = psram_is_guaranteed()
-
-        # Always allocate WiFi buffers in PSRAM if available
-        add_idf_sdkconfig_option("CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP", True)
-
-        if psram_guaranteed:
-            _LOGGER.info(
-                "Applying high-performance WiFi settings (PSRAM guaranteed): 512 RX buffers, 32 TX buffers"
-            )
-            # PSRAM is guaranteed - use aggressive settings
-            # Higher maximum values are allowed because CONFIG_LWIP_WND_SCALE is set to true in networking component
-            # Based on https://github.com/espressif/esp-adf/issues/297#issuecomment-783811702
-
-            # Large dynamic RX buffers (requires PSRAM)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM", 16)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM", 512)
-
-            # Static TX buffers for better performance
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_STATIC_TX_BUFFER", True)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_TX_BUFFER_TYPE", 0)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_CACHE_TX_BUFFER_NUM", 32)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_STATIC_TX_BUFFER_NUM", 8)
-
-            # AMPDU settings optimized for PSRAM
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_TX_ENABLED", True)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_TX_BA_WIN", 16)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_RX_ENABLED", True)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_RX_BA_WIN", 32)
-        else:
-            _LOGGER.info(
-                "Applying optimized WiFi settings: 64 RX buffers, 64 TX buffers"
-            )
-            # PSRAM not guaranteed - use more conservative, but still optimized settings
-            # Based on https://github.com/espressif/esp-idf/blob/release/v5.4/examples/wifi/iperf/sdkconfig.defaults.esp32
-
-            # Standard buffer counts
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_STATIC_RX_BUFFER_NUM", 16)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM", 64)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_DYNAMIC_TX_BUFFER_NUM", 64)
-
-            # Standard AMPDU settings
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_TX_ENABLED", True)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_TX_BA_WIN", 32)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_AMPDU_RX_ENABLED", True)
-            add_idf_sdkconfig_option("CONFIG_ESP_WIFI_RX_BA_WIN", 32)
-
     cg.add_define("USE_WIFI")
 
     # must register before OTA safe mode check

esphome/components/wifi/wifi_component.cpp

@@ -197,10 +197,6 @@ static constexpr uint8_t WIFI_RETRY_COUNT_PER_SSID = 1;
 // Rationale: Fast connect prioritizes speed - try each AP once to find a working one quickly
 static constexpr uint8_t WIFI_RETRY_COUNT_PER_AP = 1;
 
-/// Cooldown duration in milliseconds after adapter restart or repeated failures
-/// Allows WiFi hardware to stabilize before next connection attempt
-static constexpr uint32_t WIFI_COOLDOWN_DURATION_MS = 1000;
-
 static constexpr uint8_t get_max_retries_for_phase(WiFiRetryPhase phase) {
   switch (phase) {
     case WiFiRetryPhase::INITIAL_CONNECT:
@@ -257,19 +253,17 @@ bool WiFiComponent::ssid_was_seen_in_scan_(const std::string &ssid) const {
   return false;
 }
 
-int8_t WiFiComponent::find_next_hidden_sta_(int8_t start_index) {
+int8_t WiFiComponent::find_next_hidden_sta_(int8_t start_index, bool include_explicit_hidden) {
   // Find next SSID that wasn't in scan results (might be hidden)
-  bool include_explicit_hidden = !this->went_through_explicit_hidden_phase_();
   // Start searching from start_index + 1
   for (size_t i = start_index + 1; i < this->sta_.size(); i++) {
     const auto &sta = this->sta_[i];
 
     // Skip networks that were already tried in EXPLICIT_HIDDEN phase
     // Those are: networks marked hidden:true that appear before the first non-hidden network
-    // If all networks are hidden (first_non_hidden_idx == -1), skip all of them
     if (!include_explicit_hidden && sta.get_hidden()) {
       int8_t first_non_hidden_idx = this->find_first_non_hidden_index_();
-      if (first_non_hidden_idx < 0 || static_cast<int8_t>(i) < first_non_hidden_idx) {
+      if (first_non_hidden_idx >= 0 && static_cast<int8_t>(i) < first_non_hidden_idx) {
         ESP_LOGD(TAG, "Skipping " LOG_SECRET("'%s'") " (explicit hidden, already tried)", sta.get_ssid().c_str());
         continue;
       }
@@ -279,7 +273,7 @@ int8_t WiFiComponent::find_next_hidden_sta_(int8_t start_index) {
       ESP_LOGD(TAG, "Hidden candidate " LOG_SECRET("'%s'") " at index %d", sta.get_ssid().c_str(), static_cast<int>(i));
       return static_cast<int8_t>(i);
     }
-    ESP_LOGD(TAG, "Skipping hidden retry for visible network " LOG_SECRET("'%s'"), sta.get_ssid().c_str());
+    ESP_LOGD(TAG, "Skipping " LOG_SECRET("'%s'") " (visible in scan)", sta.get_ssid().c_str());
   }
   // No hidden SSIDs found
   return -1;
@@ -293,7 +287,7 @@ void WiFiComponent::start_initial_connection_() {
     this->selected_sta_index_ = 0;
     this->retry_phase_ = WiFiRetryPhase::EXPLICIT_HIDDEN;
     WiFiAP params = this->build_params_for_current_phase_();
-    this->start_connecting(params);
+    this->start_connecting(params, false);
   } else {
     ESP_LOGI(TAG, "Starting scan");
     this->start_scanning();
@@ -375,13 +369,13 @@ void WiFiComponent::start() {
     // Without saved data, try first configured network or use normal flow
     if (loaded_fast_connect) {
       ESP_LOGI(TAG, "Starting fast_connect (saved) " LOG_SECRET("'%s'"), params.get_ssid().c_str());
-      this->start_connecting(params);
+      this->start_connecting(params, false);
     } else if (!this->sta_.empty() && !this->sta_[0].get_hidden()) {
       // No saved data, but have configured networks - try first non-hidden network
       ESP_LOGI(TAG, "Starting fast_connect (config) " LOG_SECRET("'%s'"), this->sta_[0].get_ssid().c_str());
       this->selected_sta_index_ = 0;
       params = this->build_params_for_current_phase_();
-      this->start_connecting(params);
+      this->start_connecting(params, false);
     } else {
       // No saved data and (no networks OR first is hidden) - use normal flow
       this->start_initial_connection_();
@@ -417,11 +411,8 @@ void WiFiComponent::start() {
 void WiFiComponent::restart_adapter() {
   ESP_LOGW(TAG, "Restarting adapter");
   this->wifi_mode_(false, {});
-  // Enter cooldown state to allow WiFi hardware to stabilize after restart
+  delay(100);  // NOLINT
   // Don't set retry_phase_ or num_retried_ here - state machine handles transitions
-  this->state_ = WIFI_COMPONENT_STATE_COOLDOWN;
-  this->action_started_ = millis();
-  this->error_from_callback_ = false;
 }
 
 void WiFiComponent::loop() {
@@ -441,12 +432,20 @@ void WiFiComponent::loop() {
     switch (this->state_) {
       case WIFI_COMPONENT_STATE_COOLDOWN: {
         this->status_set_warning(LOG_STR("waiting to reconnect"));
-        if (now - this->action_started_ > WIFI_COOLDOWN_DURATION_MS) {
-          // After cooldown we either restarted the adapter because of
-          // a failure, or something tried to connect over and over
-          // so we entered cooldown. In both cases we call
-          // check_connecting_finished to continue the state machine.
-          this->check_connecting_finished();
+        if (millis() - this->action_started_ > 5000) {
+          // After cooldown, connect based on current retry phase
+          this->reset_selected_ap_to_first_if_invalid_();
+
+          // Check if we need to trigger a scan first
+          if (this->needs_scan_results_() && !this->all_networks_hidden_()) {
+            // Need scan results or no matching networks found - scan/rescan
+            ESP_LOGD(TAG, "Scanning required for phase %s", LOG_STR_ARG(retry_phase_to_log_string(this->retry_phase_)));
+            this->start_scanning();
+          } else {
+            // Have everything we need to connect (or all networks are hidden, skip scanning)
+            WiFiAP params = this->build_params_for_current_phase_();
+            this->start_connecting(params, false);
+          }
         }
         break;
       }
@@ -455,7 +454,8 @@ void WiFiComponent::loop() {
         this->check_scanning_finished();
         break;
       }
-      case WIFI_COMPONENT_STATE_STA_CONNECTING: {
+      case WIFI_COMPONENT_STATE_STA_CONNECTING:
+      case WIFI_COMPONENT_STATE_STA_CONNECTING_2: {
         this->status_set_warning(LOG_STR("associating to network"));
         this->check_connecting_finished();
         break;
@@ -465,8 +465,6 @@ void WiFiComponent::loop() {
         if (!this->is_connected()) {
           ESP_LOGW(TAG, "Connection lost; reconnecting");
           this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING;
-          // Clear error flag before reconnecting so first attempt is not seen as immediate failure
-          this->error_from_callback_ = false;
           this->retry_connect();
         } else {
           this->status_clear_warning();
@@ -571,7 +569,6 @@ void WiFiComponent::setup_ap_config_() {
                 "  IP Address: %s",
                 this->ap_.get_ssid().c_str(), this->ap_.get_password().c_str(), ip_address.c_str());
 
-#ifdef USE_WIFI_MANUAL_IP
   auto manual_ip = this->ap_.get_manual_ip();
   if (manual_ip.has_value()) {
     ESP_LOGCONFIG(TAG,
@@ -581,7 +578,6 @@ void WiFiComponent::setup_ap_config_() {
                   manual_ip->static_ip.str().c_str(), manual_ip->gateway.str().c_str(),
                   manual_ip->subnet.str().c_str());
   }
-#endif
 
   if (!this->has_sta()) {
     this->state_ = WIFI_COMPONENT_STATE_AP;
@@ -668,27 +664,27 @@ void WiFiComponent::save_wifi_sta(const std::string &ssid, const std::string &pa
   this->set_sta(sta);
 }
 
-void WiFiComponent::start_connecting(const WiFiAP &ap) {
+void WiFiComponent::start_connecting(const WiFiAP &ap, bool two) {
   // Log connection attempt at INFO level with priority
-  char bssid_s[18];
-  int8_t priority = 0;
+  std::string bssid_formatted;
+  float priority = 0.0f;
 
   if (ap.get_bssid().has_value()) {
-    format_mac_addr_upper(ap.get_bssid().value().data(), bssid_s);
+    bssid_formatted = format_mac_address_pretty(ap.get_bssid().value().data());
     priority = this->get_sta_priority(ap.get_bssid().value());
   }
 
   ESP_LOGI(TAG,
            "Connecting to " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") " (priority %d, attempt %u/%u in phase %s)...",
-           ap.get_ssid().c_str(), ap.get_bssid().has_value() ? bssid_s : LOG_STR_LITERAL("any"), priority,
-           this->num_retried_ + 1, get_max_retries_for_phase(this->retry_phase_),
+           ap.get_ssid().c_str(), ap.get_bssid().has_value() ? bssid_formatted.c_str() : LOG_STR_LITERAL("any"),
+           priority, this->num_retried_ + 1, get_max_retries_for_phase(this->retry_phase_),
            LOG_STR_ARG(retry_phase_to_log_string(this->retry_phase_)));
 
 #ifdef ESPHOME_LOG_HAS_VERBOSE
   ESP_LOGV(TAG, "Connection Params:");
   ESP_LOGV(TAG, "  SSID: '%s'", ap.get_ssid().c_str());
   if (ap.get_bssid().has_value()) {
-    ESP_LOGV(TAG, "  BSSID: %s", bssid_s);
+    ESP_LOGV(TAG, "  BSSID: %s", format_mac_address_pretty(ap.get_bssid()->data()).c_str());
   } else {
     ESP_LOGV(TAG, "  BSSID: Not Set");
   }
@@ -720,14 +716,11 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
   } else {
     ESP_LOGV(TAG, "  Channel not set");
   }
-#ifdef USE_WIFI_MANUAL_IP
   if (ap.get_manual_ip().has_value()) {
     ManualIP m = *ap.get_manual_ip();
     ESP_LOGV(TAG, "  Manual IP: Static IP=%s Gateway=%s Subnet=%s DNS1=%s DNS2=%s", m.static_ip.str().c_str(),
              m.gateway.str().c_str(), m.subnet.str().c_str(), m.dns1.str().c_str(), m.dns2.str().c_str());
-  } else
-#endif
-  {
+  } else {
     ESP_LOGV(TAG, "  Using DHCP IP");
   }
   ESP_LOGV(TAG, "  Hidden: %s", YESNO(ap.get_hidden()));
@@ -735,24 +728,19 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
 
   if (!this->wifi_sta_connect_(ap)) {
     ESP_LOGE(TAG, "wifi_sta_connect_ failed");
-    // Enter cooldown to allow WiFi hardware to stabilize
-    // (immediate failure suggests hardware not ready, different from connection timeout)
-    this->state_ = WIFI_COMPONENT_STATE_COOLDOWN;
-  } else {
+    this->retry_connect();
+    return;
+  }
+
+  if (!two) {
     this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING;
+  } else {
+    this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING_2;
   }
   this->action_started_ = millis();
 }
 
 const LogString *get_signal_bars(int8_t rssi) {
-  // Check for disconnected sentinel value first
-  if (rssi == WIFI_RSSI_DISCONNECTED) {
-    // MULTIPLICATION SIGN
-    // Unicode: U+00D7, UTF-8: C3 97
-    return LOG_STR("\033[0;31m"  // red
-                   "\xc3\x97\xc3\x97\xc3\x97\xc3\x97"
-                   "\033[0m");
-  }
   // LOWER ONE QUARTER BLOCK
   // Unicode: U+2582, UTF-8: E2 96 82
   // LOWER HALF BLOCK
@@ -797,8 +785,6 @@ const LogString *get_signal_bars(int8_t rssi) {
 
 void WiFiComponent::print_connect_params_() {
   bssid_t bssid = wifi_bssid();
-  char bssid_s[18];
-  format_mac_addr_upper(bssid.data(), bssid_s);
 
   ESP_LOGCONFIG(TAG, "  Local MAC: %s", get_mac_address_pretty().c_str());
   if (this->is_disabled()) {
@@ -821,9 +807,9 @@ void WiFiComponent::print_connect_params_() {
                                                                            "  Gateway: %s\n"
                                                                            "  DNS1: %s\n"
                                                                            "  DNS2: %s",
-                wifi_ssid().c_str(), bssid_s, App.get_name().c_str(), rssi, LOG_STR_ARG(get_signal_bars(rssi)),
-                get_wifi_channel(), wifi_subnet_mask_().str().c_str(), wifi_gateway_ip_().str().c_str(),
-                wifi_dns_ip_(0).str().c_str(), wifi_dns_ip_(1).str().c_str());
+                wifi_ssid().c_str(), format_mac_address_pretty(bssid.data()).c_str(), App.get_name().c_str(), rssi,
+                LOG_STR_ARG(get_signal_bars(rssi)), get_wifi_channel(), wifi_subnet_mask_().str().c_str(),
+                wifi_gateway_ip_().str().c_str(), wifi_dns_ip_(0).str().c_str(), wifi_dns_ip_(1).str().c_str());
 #ifdef ESPHOME_LOG_HAS_VERBOSE
   if (const WiFiAP *config = this->get_selected_sta_(); config && config->get_bssid().has_value()) {
     ESP_LOGV(TAG, "  Priority: %d", this->get_sta_priority(*config->get_bssid()));
@@ -1016,10 +1002,6 @@ void WiFiComponent::check_scanning_finished() {
     // No scan results matched our configured networks - transition directly to hidden mode
     // Don't call retry_connect() since we never attempted a connection (no BSSID to penalize)
     this->transition_to_phase_(WiFiRetryPhase::RETRY_HIDDEN);
-    // If no hidden networks to try, skip connection attempt (will be handled on next loop)
-    if (this->selected_sta_index_ == -1) {
-      return;
-    }
     // Now start connection attempt in hidden mode
   } else if (this->transition_to_phase_(WiFiRetryPhase::SCAN_CONNECTING)) {
     return;  // scan started, wait for next loop iteration
@@ -1030,14 +1012,11 @@ void WiFiComponent::check_scanning_finished() {
   WiFiAP params = this->build_params_for_current_phase_();
   // Ensure we're in SCAN_CONNECTING phase when connecting with scan results
   // (needed when scan was started directly without transition_to_phase_, e.g., initial scan)
-  this->start_connecting(params);
+  this->start_connecting(params, false);
 }
 
 void WiFiComponent::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "WiFi:\n"
-                "  Connected: %s",
-                YESNO(this->is_connected()));
+  ESP_LOGCONFIG(TAG, "WiFi:");
   this->print_connect_params_();
 }
 
@@ -1062,10 +1041,6 @@ void WiFiComponent::check_connecting_finished() {
     // Reset to initial phase on successful connection (don't log transition, just reset state)
     this->retry_phase_ = WiFiRetryPhase::INITIAL_CONNECT;
     this->num_retried_ = 0;
-    // Ensure next connection attempt does not inherit error state
-    // so when WiFi disconnects later we start fresh and don't see
-    // the first connection as a failure.
-    this->error_from_callback_ = false;
 
     this->print_connect_params_();
 
@@ -1087,8 +1062,8 @@ void WiFiComponent::check_connecting_finished() {
     this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTED;
     this->num_retried_ = 0;
 
-    // Clear priority tracking if all priorities are at minimum
-    this->clear_priorities_if_all_min_();
+    // Reset all priorities if they're all the same (can't differentiate)
+    this->reset_priorities_if_all_same_();
 
 #ifdef USE_WIFI_FAST_CONNECT
     this->save_fast_connect_settings_();
@@ -1111,7 +1086,7 @@ void WiFiComponent::check_connecting_finished() {
   }
 
   if (this->error_from_callback_) {
-    ESP_LOGW(TAG, "Connecting to network failed (callback)");
+    ESP_LOGW(TAG, "Connecting to network failed");
     this->retry_connect();
     return;
   }
@@ -1152,11 +1127,6 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
         return WiFiRetryPhase::FAST_CONNECT_CYCLING_APS;  // Move to next AP
       }
 #endif
-      // Check if we should try explicit hidden networks before scanning
-      // This handles reconnection after connection loss where first network is hidden
-      if (!this->sta_.empty() && this->sta_[0].get_hidden()) {
-        return WiFiRetryPhase::EXPLICIT_HIDDEN;
-      }
       // No more APs to try, fall back to scan
       return WiFiRetryPhase::SCAN_CONNECTING;
 
@@ -1174,12 +1144,7 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
         return WiFiRetryPhase::EXPLICIT_HIDDEN;
       }
 
-      // No more consecutive explicitly hidden networks
-      // If ALL networks are hidden, skip scanning and go directly to restart
-      if (this->find_first_non_hidden_index_() < 0) {
-        return WiFiRetryPhase::RESTARTING_ADAPTER;
-      }
-      // Otherwise proceed to scanning for non-hidden networks
+      // No more consecutive explicitly hidden networks - proceed to scanning
       return WiFiRetryPhase::SCAN_CONNECTING;
     }
 
@@ -1197,12 +1162,14 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
       // Its priority has been decreased, so on next scan it will be sorted lower
       // and we'll try the next best BSSID.
       // Check if there are any potentially hidden networks to try
-      if (this->find_next_hidden_sta_(-1) >= 0) {
+      if (this->find_next_hidden_sta_(-1, !this->went_through_explicit_hidden_phase_()) >= 0) {
         return WiFiRetryPhase::RETRY_HIDDEN;  // Found hidden networks to try
       }
-      // No hidden networks - always go through RESTARTING_ADAPTER phase
-      // This ensures num_retried_ gets reset and a fresh scan is triggered
-      // The actual adapter restart will be skipped if captive portal/improv is active
+      // No hidden networks - skip directly to restart/rescan
+      if (this->is_captive_portal_active_() || this->is_esp32_improv_active_()) {
+        return this->went_through_explicit_hidden_phase_() ? WiFiRetryPhase::EXPLICIT_HIDDEN
+                                                           : WiFiRetryPhase::SCAN_CONNECTING;
+      }
       return WiFiRetryPhase::RESTARTING_ADAPTER;
 
     case WiFiRetryPhase::RETRY_HIDDEN:
@@ -1214,18 +1181,20 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
 
         // Exhausted retries on current SSID - check if there are more potentially hidden SSIDs to try
         if (this->selected_sta_index_ < static_cast<int8_t>(this->sta_.size()) - 1) {
-          // Check if find_next_hidden_sta_() would actually find another hidden SSID
-          // as it might have been seen in the scan results and we want to skip those
-          // otherwise we will get stuck in RETRY_HIDDEN phase
-          if (this->find_next_hidden_sta_(this->selected_sta_index_) != -1) {
-            // More hidden SSIDs available - stay in RETRY_HIDDEN, advance will happen in retry_connect()
-            return WiFiRetryPhase::RETRY_HIDDEN;
-          }
+          // More SSIDs available - stay in RETRY_HIDDEN, advance will happen in retry_connect()
+          return WiFiRetryPhase::RETRY_HIDDEN;
         }
       }
-      // Exhausted all potentially hidden SSIDs - always go through RESTARTING_ADAPTER
-      // This ensures num_retried_ gets reset and a fresh scan is triggered
-      // The actual adapter restart will be skipped if captive portal/improv is active
+      // Exhausted all potentially hidden SSIDs - rescan to try next BSSID
+      // If captive portal/improv is active, skip adapter restart and go back to start
+      // Otherwise restart adapter to clear any stuck state
+      if (this->is_captive_portal_active_() || this->is_esp32_improv_active_()) {
+        // Go back to explicit hidden if we went through it initially, otherwise scan
+        return this->went_through_explicit_hidden_phase_() ? WiFiRetryPhase::EXPLICIT_HIDDEN
+                                                           : WiFiRetryPhase::SCAN_CONNECTING;
+      }
+
+      // Restart adapter
       return WiFiRetryPhase::RESTARTING_ADAPTER;
 
     case WiFiRetryPhase::RESTARTING_ADAPTER:
@@ -1245,8 +1214,8 @@ WiFiRetryPhase WiFiComponent::determine_next_phase_() {
 /// - Performing phase-specific initialization (e.g., advancing AP index, starting scans)
 ///
 /// @param new_phase The phase we're transitioning TO
-/// @return true if connection attempt should be skipped (scan started or no networks to try)
-///         false if caller can proceed with connection attempt
+/// @return true if an async scan was started (caller should wait for completion)
+///         false if no scan started (caller can proceed with connection attempt)
 bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
   WiFiRetryPhase old_phase = this->retry_phase_;
 
@@ -1304,7 +1273,7 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
         // If first network is marked hidden, we went through EXPLICIT_HIDDEN phase
         // In that case, skip networks marked hidden:true (already tried)
         // Otherwise, include them (they haven't been tried yet)
-        this->selected_sta_index_ = this->find_next_hidden_sta_(-1);
+        this->selected_sta_index_ = this->find_next_hidden_sta_(-1, !this->went_through_explicit_hidden_phase_());
 
         if (this->selected_sta_index_ == -1) {
           ESP_LOGD(TAG, "All SSIDs visible or already tried, skipping hidden mode");
@@ -1313,12 +1282,7 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
       break;
 
     case WiFiRetryPhase::RESTARTING_ADAPTER:
-      // Skip actual adapter restart if captive portal/improv is active
-      // This allows state machine to reset num_retried_ and trigger fresh scan
-      // without disrupting the captive portal/improv connection
-      if (!this->is_captive_portal_active_() && !this->is_esp32_improv_active_()) {
-        this->restart_adapter();
-      }
+      this->restart_adapter();
       // Return true to indicate we should wait (go to COOLDOWN) instead of immediately connecting
       return true;
 
@@ -1329,32 +1293,25 @@ bool WiFiComponent::transition_to_phase_(WiFiRetryPhase new_phase) {
   return false;  // Did not start scan, can proceed with connection
 }
 
-/// Clear BSSID priority tracking if all priorities are at minimum (saves memory)
-/// At minimum priority, all BSSIDs are equally bad, so priority tracking is useless
-/// Called after successful connection or after failed connection attempts
-void WiFiComponent::clear_priorities_if_all_min_() {
+/// Reset all BSSID priorities to 0 if they're all identical (can't differentiate)
+/// Called when starting a fresh connection attempt or after successful connection
+void WiFiComponent::reset_priorities_if_all_same_() {
   if (this->sta_priorities_.empty()) {
     return;
   }
 
   int8_t first_priority = this->sta_priorities_[0].priority;
-
-  // Only clear if all priorities have been decremented to the minimum value
-  // At this point, all BSSIDs have been equally penalized and priority info is useless
-  if (first_priority != std::numeric_limits<int8_t>::min()) {
-    return;
-  }
-
   for (const auto &pri : this->sta_priorities_) {
     if (pri.priority != first_priority) {
       return;  // Not all same, nothing to do
     }
   }
 
-  // All priorities are at minimum - clear the vector to save memory and reset
-  ESP_LOGD(TAG, "Clearing BSSID priorities (all at minimum)");
-  this->sta_priorities_.clear();
-  this->sta_priorities_.shrink_to_fit();
+  // All priorities are identical, reset to 0
+  ESP_LOGD(TAG, "Resetting all BSSID priorities (all identical)");
+  for (auto &pri : this->sta_priorities_) {
+    pri.priority = 0;
+  }
 }
 
 /// Log failed connection attempt and decrease BSSID priority to avoid repeated failures
@@ -1370,11 +1327,6 @@ void WiFiComponent::clear_priorities_if_all_min_() {
 /// - Other phases: Uses BSSID from config if explicitly specified by user or fast_connect
 ///
 /// If no BSSID is available (SSID-only connection), priority adjustment is skipped.
-///
-/// IMPORTANT: Priority is only decreased on the LAST attempt for a BSSID in SCAN_CONNECTING phase.
-/// This prevents false positives from transient WiFi stack state issues after scanning.
-/// Single failures don't necessarily mean the AP is bad - two genuine failures provide
-/// higher confidence before degrading priority and skipping the BSSID in future scans.
 void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
   // Determine which BSSID we tried to connect to
   optional<bssid_t> failed_bssid;
@@ -1391,6 +1343,12 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
     return;  // No BSSID to penalize
   }
 
+  // Decrease priority to avoid repeatedly trying the same failed BSSID
+  int8_t old_priority = this->get_sta_priority(failed_bssid.value());
+  int8_t new_priority =
+      (old_priority > std::numeric_limits<int8_t>::min()) ? (old_priority - 1) : std::numeric_limits<int8_t>::min();
+  this->set_sta_priority(failed_bssid.value(), new_priority);
+
   // Get SSID for logging
   std::string ssid;
   if (this->retry_phase_ == WiFiRetryPhase::SCAN_CONNECTING && !this->scan_result_.empty()) {
@@ -1399,30 +1357,12 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
     ssid = config->get_ssid();
   }
 
-  // Only decrease priority on the last attempt for this phase
-  // This prevents false positives from transient WiFi stack issues
-  uint8_t max_retries = get_max_retries_for_phase(this->retry_phase_);
-  bool is_last_attempt = (this->num_retried_ + 1 >= max_retries);
+  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d", ssid.c_str(),
+           format_mac_address_pretty(failed_bssid.value().data()).c_str(), old_priority, new_priority);
 
-  // Decrease priority only on last attempt to avoid false positives from transient failures
-  int8_t old_priority = this->get_sta_priority(failed_bssid.value());
-  int8_t new_priority = old_priority;
-
-  if (is_last_attempt) {
-    // Decrease priority, but clamp to int8_t::min to prevent overflow
-    new_priority =
-        (old_priority > std::numeric_limits<int8_t>::min()) ? (old_priority - 1) : std::numeric_limits<int8_t>::min();
-    this->set_sta_priority(failed_bssid.value(), new_priority);
-  }
-
-  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.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
-  this->clear_priorities_if_all_min_();
+  // After adjusting priority, check if all priorities are now identical
+  // If so, reset them all to 0 to start fresh
+  this->reset_priorities_if_all_same_();
 }
 
 /// Handle target advancement or retry counter increment when staying in the same phase
@@ -1467,7 +1407,8 @@ void WiFiComponent::advance_to_next_target_or_increment_retry_() {
     // If first network is marked hidden, we went through EXPLICIT_HIDDEN phase
     // In that case, skip networks marked hidden:true (already tried)
     // Otherwise, include them (they haven't been tried yet)
-    int8_t next_index = this->find_next_hidden_sta_(this->selected_sta_index_);
+    int8_t next_index =
+        this->find_next_hidden_sta_(this->selected_sta_index_, !this->went_through_explicit_hidden_phase_());
     if (next_index != -1) {
       // Found another potentially hidden SSID
       this->selected_sta_index_ = next_index;
@@ -1495,13 +1436,15 @@ void WiFiComponent::advance_to_next_target_or_increment_retry_() {
 void WiFiComponent::retry_connect() {
   this->log_and_adjust_priority_for_failed_connect_();
 
+  delay(10);
+
   // Determine next retry phase based on current state
   WiFiRetryPhase current_phase = this->retry_phase_;
   WiFiRetryPhase next_phase = this->determine_next_phase_();
 
   // Handle phase transitions (transition_to_phase_ handles same-phase no-op internally)
   if (this->transition_to_phase_(next_phase)) {
-    return;  // Scan started or adapter restarted (which sets its own state)
+    return;  // Wait for scan to complete
   }
 
   if (next_phase == current_phase) {
@@ -1510,14 +1453,22 @@ void WiFiComponent::retry_connect() {
 
   this->error_from_callback_ = false;
 
-  yield();
-  // Check if we have a valid target before building params
-  // After exhausting all networks in a phase, selected_sta_index_ may be -1
-  // In that case, skip connection and let next wifi_loop() handle phase transition
-  if (this->selected_sta_index_ >= 0) {
-    WiFiAP params = this->build_params_for_current_phase_();
-    this->start_connecting(params);
+  if (this->state_ == WIFI_COMPONENT_STATE_STA_CONNECTING) {
+    yield();
+    // Check if we have a valid target before building params
+    // After exhausting all networks in a phase, selected_sta_index_ may be -1
+    // In that case, skip connection and let next wifi_loop() handle phase transition
+    if (this->selected_sta_index_ >= 0) {
+      this->state_ = WIFI_COMPONENT_STATE_STA_CONNECTING_2;
+      WiFiAP params = this->build_params_for_current_phase_();
+      this->start_connecting(params, true);
+      return;
+    }
+    // No valid target - fall through to set state to allow phase transition
   }
+
+  this->state_ = WIFI_COMPONENT_STATE_COOLDOWN;
+  this->action_started_ = millis();
 }
 
 void WiFiComponent::set_reboot_timeout(uint32_t reboot_timeout) { this->reboot_timeout_ = reboot_timeout; }
@@ -1609,9 +1560,7 @@ void WiFiAP::set_password(const std::string &password) { this->password_ = passw
 void WiFiAP::set_eap(optional<EAPAuth> eap_auth) { this->eap_ = std::move(eap_auth); }
 #endif
 void WiFiAP::set_channel(optional<uint8_t> channel) { this->channel_ = channel; }
-#ifdef USE_WIFI_MANUAL_IP
 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 optional<bssid_t> &WiFiAP::get_bssid() const { return this->bssid_; }
@@ -1620,17 +1569,15 @@ const std::string &WiFiAP::get_password() const { return this->password_; }
 const optional<EAPAuth> &WiFiAP::get_eap() const { return this->eap_; }
 #endif
 const optional<uint8_t> &WiFiAP::get_channel() const { return this->channel_; }
-#ifdef USE_WIFI_MANUAL_IP
 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, std::string ssid, uint8_t channel, int8_t rssi, bool with_auth,
                                bool is_hidden)
     : bssid_(bssid),
+      ssid_(std::move(ssid)),
       channel_(channel),
       rssi_(rssi),
-      ssid_(std::move(ssid)),
       with_auth_(with_auth),
       is_hidden_(is_hidden) {}
 bool WiFiScanResult::matches(const WiFiAP &config) const {

esphome/components/wifi/wifi_component.h

@@ -52,9 +52,6 @@ extern "C" {
 namespace esphome {
 namespace wifi {
 
-/// Sentinel value for RSSI when WiFi is not connected
-static constexpr int8_t WIFI_RSSI_DISCONNECTED = -127;
-
 struct SavedWifiSettings {
   char ssid[33];
   char password[65];
@@ -77,6 +74,12 @@ enum WiFiComponentState : uint8_t {
   WIFI_COMPONENT_STATE_STA_SCANNING,
   /** WiFi is in STA(+AP) mode and currently connecting to an AP. */
   WIFI_COMPONENT_STATE_STA_CONNECTING,
+  /** WiFi is in STA(+AP) mode and currently connecting to an AP a second time.
+   *
+   * This is required because for some reason ESPs don't like to connect to WiFi APs directly after
+   * a scan.
+   * */
+  WIFI_COMPONENT_STATE_STA_CONNECTING_2,
   /** WiFi is in STA(+AP) mode and successfully connected. */
   WIFI_COMPONENT_STATE_STA_CONNECTED,
   /** WiFi is in AP-only mode and internal AP is already enabled. */
@@ -155,9 +158,7 @@ class WiFiAP {
 #endif  // USE_WIFI_WPA2_EAP
   void set_channel(optional<uint8_t> channel);
   void set_priority(int8_t priority) { priority_ = priority; }
-#ifdef USE_WIFI_MANUAL_IP
   void set_manual_ip(optional<ManualIP> manual_ip);
-#endif
   void set_hidden(bool hidden);
   const std::string &get_ssid() const;
   const optional<bssid_t> &get_bssid() const;
@@ -167,9 +168,7 @@ class WiFiAP {
 #endif  // USE_WIFI_WPA2_EAP
   const optional<uint8_t> &get_channel() const;
   int8_t get_priority() const { return priority_; }
-#ifdef USE_WIFI_MANUAL_IP
   const optional<ManualIP> &get_manual_ip() const;
-#endif
   bool get_hidden() const;
 
  protected:
@@ -179,9 +178,7 @@ class WiFiAP {
 #ifdef USE_WIFI_WPA2_EAP
   optional<EAPAuth> eap_;
 #endif  // USE_WIFI_WPA2_EAP
-#ifdef USE_WIFI_MANUAL_IP
   optional<ManualIP> manual_ip_;
-#endif
   optional<uint8_t> channel_;
   int8_t priority_{0};
   bool hidden_{false};
@@ -272,9 +269,7 @@ class WiFiComponent : public Component {
   bool is_disabled();
   void start_scanning();
   void check_scanning_finished();
-  void start_connecting(const WiFiAP &ap);
-  // Backward compatibility overload - ignores 'two' parameter
-  void start_connecting(const WiFiAP &ap, bool /* two */) { this->start_connecting(ap); }
+  void start_connecting(const WiFiAP &ap, bool two);
 
   void check_connecting_finished();
 
@@ -391,11 +386,12 @@ class WiFiComponent : public Component {
   /// 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)
-  int8_t find_next_hidden_sta_(int8_t start_index);
+  /// @param include_explicit_hidden If true, include SSIDs marked hidden:true. If false, only find truly hidden SSIDs.
+  int8_t find_next_hidden_sta_(int8_t start_index, bool include_explicit_hidden = true);
   /// Log failed connection and decrease BSSID priority to avoid repeated attempts
   void log_and_adjust_priority_for_failed_connect_();
-  /// Clear BSSID priority tracking if all priorities are at minimum (saves memory)
-  void clear_priorities_if_all_min_();
+  /// Reset all BSSID priorities to 0 if they're all identical (can't differentiate)
+  void reset_priorities_if_all_same_();
   /// Advance to next target (AP/SSID) within current phase, or increment retry counter
   /// Called when staying in the same phase after a failed connection attempt
   void advance_to_next_target_or_increment_retry_();
@@ -429,7 +425,7 @@ class WiFiComponent : public Component {
   bool wifi_sta_pre_setup_();
   bool wifi_apply_output_power_(float output_power);
   bool wifi_apply_power_save_();
-  bool wifi_sta_ip_config_(const optional<ManualIP> &manual_ip);
+  bool wifi_sta_ip_config_(optional<ManualIP> manual_ip);
   bool wifi_apply_hostname_();
   bool wifi_sta_connect_(const WiFiAP &ap);
   void wifi_pre_setup_();
@@ -437,7 +433,7 @@ class WiFiComponent : public Component {
   bool wifi_scan_start_(bool passive);
 
 #ifdef USE_WIFI_AP
-  bool wifi_ap_ip_config_(const optional<ManualIP> &manual_ip);
+  bool wifi_ap_ip_config_(optional<ManualIP> manual_ip);
   bool wifi_start_ap_(const WiFiAP &ap);
 #endif  // USE_WIFI_AP
 

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -117,7 +117,7 @@ void netif_set_addr(struct netif *netif, const ip4_addr_t *ip, const ip4_addr_t
 };
 #endif
 
-bool WiFiComponent::wifi_sta_ip_config_(const optional<ManualIP> &manual_ip) {
+bool WiFiComponent::wifi_sta_ip_config_(optional<ManualIP> manual_ip) {
   // enable STA
   if (!this->wifi_mode_(true, {}))
     return false;
@@ -282,15 +282,9 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
     return false;
   }
 
-#ifdef USE_WIFI_MANUAL_IP
   if (!this->wifi_sta_ip_config_(ap.get_manual_ip())) {
     return false;
   }
-#else
-  if (!this->wifi_sta_ip_config_({})) {
-    return false;
-  }
-#endif
 
   // setup enterprise authentication if required
 #ifdef USE_WIFI_WPA2_EAP
@@ -525,10 +519,8 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
         ESP_LOGW(TAG, "Disconnected ssid='%s' reason='Probe Request Unsuccessful'", buf);
         s_sta_connect_not_found = true;
       } else {
-        char bssid_s[18];
-        format_mac_addr_upper(it.bssid, bssid_s);
-        ESP_LOGW(TAG, "Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf, bssid_s,
-                 LOG_STR_ARG(get_disconnect_reason_str(it.reason)));
+        ESP_LOGW(TAG, "Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf,
+                 format_mac_address_pretty(it.bssid).c_str(), LOG_STR_ARG(get_disconnect_reason_str(it.reason)));
         s_sta_connect_error = true;
       }
       s_sta_connected = false;
@@ -732,7 +724,7 @@ void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
 }
 
 #ifdef USE_WIFI_AP
-bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
+bool WiFiComponent::wifi_ap_ip_config_(optional<ManualIP> manual_ip) {
   // enable AP
   if (!this->wifi_mode_({}, true))
     return false;
@@ -840,17 +832,10 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
     return false;
   }
 
-#ifdef USE_WIFI_MANUAL_IP
   if (!this->wifi_ap_ip_config_(ap.get_manual_ip())) {
     ESP_LOGV(TAG, "wifi_ap_ip_config_ failed");
     return false;
   }
-#else
-  if (!this->wifi_ap_ip_config_({})) {
-    ESP_LOGV(TAG, "wifi_ap_ip_config_ failed");
-    return false;
-  }
-#endif
 
   return true;
 }
@@ -872,7 +857,7 @@ bssid_t WiFiComponent::wifi_bssid() {
   return bssid;
 }
 std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
-int8_t WiFiComponent::wifi_rssi() { return WiFi.status() == WL_CONNECTED ? WiFi.RSSI() : WIFI_RSSI_DISCONNECTED; }
+int8_t WiFiComponent::wifi_rssi() { return WiFi.RSSI(); }
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {(const ip_addr_t *) WiFi.subnetMask()}; }
 network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {(const ip_addr_t *) WiFi.gatewayIP()}; }

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -380,15 +380,9 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
     return false;
   }
 
-#ifdef USE_WIFI_MANUAL_IP
   if (!this->wifi_sta_ip_config_(ap.get_manual_ip())) {
     return false;
   }
-#else
-  if (!this->wifi_sta_ip_config_({})) {
-    return false;
-  }
-#endif
 
   // setup enterprise authentication if required
 #ifdef USE_WIFI_WPA2_EAP
@@ -487,7 +481,7 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
   return true;
 }
 
-bool WiFiComponent::wifi_sta_ip_config_(const optional<ManualIP> &manual_ip) {
+bool WiFiComponent::wifi_sta_ip_config_(optional<ManualIP> manual_ip) {
   // enable STA
   if (!this->wifi_mode_(true, {}))
     return false;
@@ -746,10 +740,8 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
       ESP_LOGI(TAG, "Disconnected ssid='%s' reason='Station Roaming'", buf);
       return;
     } else {
-      char bssid_s[18];
-      format_mac_addr_upper(it.bssid, bssid_s);
-      ESP_LOGW(TAG, "Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf, bssid_s,
-               get_disconnect_reason_str(it.reason));
+      ESP_LOGW(TAG, "Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf,
+               format_mac_address_pretty(it.bssid).c_str(), get_disconnect_reason_str(it.reason));
       s_sta_connect_error = true;
     }
     s_sta_connected = false;
@@ -886,7 +878,7 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
 }
 
 #ifdef USE_WIFI_AP
-bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
+bool WiFiComponent::wifi_ap_ip_config_(optional<ManualIP> manual_ip) {
   esp_err_t err;
 
   // enable AP
@@ -1002,17 +994,10 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
     return false;
   }
 
-#ifdef USE_WIFI_MANUAL_IP
   if (!this->wifi_ap_ip_config_(ap.get_manual_ip())) {
     ESP_LOGE(TAG, "wifi_ap_ip_config_ failed:");
     return false;
   }
-#else
-  if (!this->wifi_ap_ip_config_({})) {
-    ESP_LOGE(TAG, "wifi_ap_ip_config_ failed:");
-    return false;
-  }
-#endif
 
   return true;
 }
@@ -1031,8 +1016,7 @@ bssid_t WiFiComponent::wifi_bssid() {
   wifi_ap_record_t info;
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);
   if (err != ESP_OK) {
-    // Very verbose only: this is expected during dump_config() before connection is established (PR #9823)
-    ESP_LOGVV(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
+    ESP_LOGW(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
     return bssid;
   }
   std::copy(info.bssid, info.bssid + 6, bssid.begin());
@@ -1042,8 +1026,7 @@ std::string WiFiComponent::wifi_ssid() {
   wifi_ap_record_t info{};
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);
   if (err != ESP_OK) {
-    // Very verbose only: this is expected during dump_config() before connection is established (PR #9823)
-    ESP_LOGVV(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
+    ESP_LOGW(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
     return "";
   }
   auto *ssid_s = reinterpret_cast<const char *>(info.ssid);
@@ -1054,9 +1037,8 @@ int8_t WiFiComponent::wifi_rssi() {
   wifi_ap_record_t info;
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);
   if (err != ESP_OK) {
-    // Very verbose only: this is expected during dump_config() before connection is established (PR #9823)
-    ESP_LOGVV(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
-    return WIFI_RSSI_DISCONNECTED;
+    ESP_LOGW(TAG, "esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
+    return 0;
   }
   return info.rssi;
 }

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -68,7 +68,7 @@ bool WiFiComponent::wifi_sta_pre_setup_() {
   return true;
 }
 bool WiFiComponent::wifi_apply_power_save_() { return WiFi.setSleep(this->power_save_ != WIFI_POWER_SAVE_NONE); }
-bool WiFiComponent::wifi_sta_ip_config_(const optional<ManualIP> &manual_ip) {
+bool WiFiComponent::wifi_sta_ip_config_(optional<ManualIP> manual_ip) {
   // enable STA
   if (!this->wifi_mode_(true, {}))
     return false;
@@ -112,15 +112,9 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
     WiFi.disconnect();
   }
 
-#ifdef USE_WIFI_MANUAL_IP
   if (!this->wifi_sta_ip_config_(ap.get_manual_ip())) {
     return false;
   }
-#else
-  if (!this->wifi_sta_ip_config_({})) {
-    return false;
-  }
-#endif
 
   this->wifi_apply_hostname_();
 
@@ -299,10 +293,8 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
       if (it.reason == WIFI_REASON_NO_AP_FOUND) {
         ESP_LOGW(TAG, "Disconnected ssid='%s' reason='Probe Request Unsuccessful'", buf);
       } else {
-        char bssid_s[18];
-        format_mac_addr_upper(it.bssid, bssid_s);
-        ESP_LOGW(TAG, "Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf, bssid_s,
-                 get_disconnect_reason_str(it.reason));
+        ESP_LOGW(TAG, "Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf,
+                 format_mac_address_pretty(it.bssid).c_str(), get_disconnect_reason_str(it.reason));
       }
 
       uint8_t reason = it.reason;
@@ -436,7 +428,7 @@ void WiFiComponent::wifi_scan_done_callback_() {
 }
 
 #ifdef USE_WIFI_AP
-bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
+bool WiFiComponent::wifi_ap_ip_config_(optional<ManualIP> manual_ip) {
   // enable AP
   if (!this->wifi_mode_({}, true))
     return false;
@@ -453,17 +445,10 @@ bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
   if (!this->wifi_mode_({}, true))
     return false;
 
-#ifdef USE_WIFI_MANUAL_IP
   if (!this->wifi_ap_ip_config_(ap.get_manual_ip())) {
     ESP_LOGV(TAG, "wifi_ap_ip_config_ failed");
     return false;
   }
-#else
-  if (!this->wifi_ap_ip_config_({})) {
-    ESP_LOGV(TAG, "wifi_ap_ip_config_ failed");
-    return false;
-  }
-#endif
 
   yield();
 
@@ -486,7 +471,7 @@ bssid_t WiFiComponent::wifi_bssid() {
   return bssid;
 }
 std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
-int8_t WiFiComponent::wifi_rssi() { return WiFi.status() == WL_CONNECTED ? WiFi.RSSI() : WIFI_RSSI_DISCONNECTED; }
+int8_t WiFiComponent::wifi_rssi() { return WiFi.RSSI(); }
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {WiFi.subnetMask()}; }
 network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {WiFi.gatewayIP()}; }