Optimize Application class memory layout and reduce loop_interval size

2025-06-26 02:43:00 +02:00
92 changed files with 1300 additions and 2166 deletions
--- a/.github/workflows/lock.yml
+++ b/.github/workflows/lock.yml
@@ -1,11 +1,28 @@
 ---
-name: Lock closed issues and PRs
+name: Lock

 on:
  schedule:
-    - cron: "30 0 * * *"  # Run daily at 00:30 UTC
+    - cron: "30 0 * * *"
  workflow_dispatch:

+permissions:
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: lock
+
 jobs:
  lock:
-    uses: esphome/workflows/.github/workflows/lock.yml@main
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v5.0.1
+        with:
+          pr-inactive-days: "1"
+          pr-lock-reason: ""
+          exclude-any-pr-labels: keep-open
+
+          issue-inactive-days: "7"
+          issue-lock-reason: ""
+          exclude-any-issue-labels: keep-open
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -4,7 +4,7 @@
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.12.1
+    rev: v0.12.0
    hooks:
      # Run the linter.
      - id: ruff
--- a/3
+++ b/3
@@ -146,7 +146,6 @@ esphome/components/esp32_ble_client/* @jesserockz
 esphome/components/esp32_ble_server/* @Rapsssito @clydebarrow @jesserockz
 esphome/components/esp32_camera_web_server/* @ayufan
 esphome/components/esp32_can/* @Sympatron
-esphome/components/esp32_hosted/* @swoboda1337
 esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
@@ -492,7 +491,7 @@ esphome/components/vbus/* @ssieb
 esphome/components/veml3235/* @kbx81
 esphome/components/veml7700/* @latonita
 esphome/components/version/* @esphome/core
-esphome/components/voice_assistant/* @jesserockz @kahrendt
+esphome/components/voice_assistant/* @jesserockz
 esphome/components/wake_on_lan/* @clydebarrow @willwill2will54
 esphome/components/watchdog/* @oarcher
 esphome/components/waveshare_epaper/* @clydebarrow
--- a/esphome/components/ac_dimmer/ac_dimmer.cpp
+++ b/esphome/components/ac_dimmer/ac_dimmer.cpp
@@ -4,7 +4,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include <cmath>
-#include <numbers>

 #ifdef USE_ESP8266
 #include <core_esp8266_waveform.h>
@@ -204,7 +203,7 @@ void AcDimmer::setup() {
 #endif
 }
 void AcDimmer::write_state(float state) {
-  state = std::acos(1 - (2 * state)) / std::numbers::pi;  // RMS power compensation
+  state = std::acos(1 - (2 * state)) / 3.14159;  // RMS power compensation
  auto new_value = static_cast<uint16_t>(roundf(state * 65535));
  if (new_value != 0 && this->store_.value == 0)
    this->store_.init_cycle = this->init_with_half_cycle_;
--- a/esphome/components/api/init.py
+++ b/esphome/components/api/init.py
@@ -177,11 +177,7 @@ async def to_code(config):
            # and plaintext disabled. Only a factory reset can remove it.
            cg.add_define("USE_API_PLAINTEXT")
        cg.add_define("USE_API_NOISE")
-        cg.add_library(
-            None,
-            None,
-            "https://github.com/esphome/noise-c.git#libsodium_update",
-        )
+        cg.add_library("esphome/noise-c", "0.1.6")
    else:
        cg.add_define("USE_API_PLAINTEXT")

--- a/esphome/components/api/api_connection.cpp
+++ b/esphome/components/api/api_connection.cpp
@@ -90,24 +90,11 @@ APIConnection::~APIConnection() {
 #endif
 }

-#ifdef HAS_PROTO_MESSAGE_DUMP
-void APIConnection::log_batch_item_(const DeferredBatch::BatchItem &item) {
-  // Set log-only mode
-  this->flags_.log_only_mode = true;
-
-  // Call the creator - it will create the message and log it via encode_message_to_buffer
-  item.creator(item.entity, this, std::numeric_limits<uint16_t>::max(), true, item.message_type);
-
-  // Clear log-only mode
-  this->flags_.log_only_mode = false;
-}
-#endif
-
 void APIConnection::loop() {
-  if (this->flags_.next_close) {
+  if (this->next_close_) {
    // requested a disconnect
    this->helper_->close();
-    this->flags_.remove = true;
+    this->remove_ = true;
    return;
  }

@@ -148,14 +135,15 @@ void APIConnection::loop() {
        } else {
          this->read_message(0, buffer.type, nullptr);
        }
-        if (this->flags_.remove)
+        if (this->remove_)
          return;
      }
    }
  }

  // Process deferred batch if scheduled
-  if (this->flags_.batch_scheduled && now - this->deferred_batch_.batch_start_time >= this->get_batch_delay_ms_()) {
+  if (this->deferred_batch_.batch_scheduled &&
+      now - this->deferred_batch_.batch_start_time >= this->get_batch_delay_ms_()) {
    this->process_batch_();
  }

@@ -165,7 +153,7 @@ void APIConnection::loop() {
    this->initial_state_iterator_.advance();
  }

-  if (this->flags_.sent_ping) {
+  if (this->sent_ping_) {
    // Disconnect if not responded within 2.5*keepalive
    if (now - this->last_traffic_ > KEEPALIVE_DISCONNECT_TIMEOUT) {
      on_fatal_error();
@@ -173,13 +161,13 @@ void APIConnection::loop() {
    }
  } else if (now - this->last_traffic_ > KEEPALIVE_TIMEOUT_MS) {
    ESP_LOGVV(TAG, "Sending keepalive PING");
-    this->flags_.sent_ping = this->send_message(PingRequest());
-    if (!this->flags_.sent_ping) {
+    this->sent_ping_ = this->send_message(PingRequest());
+    if (!this->sent_ping_) {
      // If we can't send the ping request directly (tx_buffer full),
      // schedule it at the front of the batch so it will be sent with priority
-      ESP_LOGW(TAG, "Buffer full, ping queued");
+      ESP_LOGVV(TAG, "Failed to send ping directly, scheduling at front of batch");
      this->schedule_message_front_(nullptr, &APIConnection::try_send_ping_request, PingRequest::MESSAGE_TYPE);
-      this->flags_.sent_ping = true;  // Mark as sent to avoid scheduling multiple pings
+      this->sent_ping_ = true;  // Mark as sent to avoid scheduling multiple pings
    }
  }

@@ -239,27 +227,19 @@ DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
  // don't close yet, we still need to send the disconnect response
  // close will happen on next loop
  ESP_LOGD(TAG, "%s disconnected", this->get_client_combined_info().c_str());
-  this->flags_.next_close = true;
+  this->next_close_ = true;
  DisconnectResponse resp;
  return resp;
 }
 void APIConnection::on_disconnect_response(const DisconnectResponse &value) {
  this->helper_->close();
-  this->flags_.remove = true;
+  this->remove_ = true;
 }

 // Encodes a message to the buffer and returns the total number of bytes used,
 // including header and footer overhead. Returns 0 if the message doesn't fit.
 uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint16_t message_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {
-#ifdef HAS_PROTO_MESSAGE_DUMP
-  // If in log-only mode, just log and return
-  if (conn->flags_.log_only_mode) {
-    conn->log_send_message_(msg.message_name(), msg.dump());
-    return 1;  // Return non-zero to indicate "success" for logging
-  }
-#endif
-
  // Calculate size
  uint32_t calculated_size = 0;
  msg.calculate_size(calculated_size);
@@ -1174,7 +1154,7 @@ void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {

 #ifdef USE_ESP32_CAMERA
 void APIConnection::set_camera_state(std::shared_ptr<esp32_camera::CameraImage> image) {
-  if (!this->flags_.state_subscription)
+  if (!this->state_subscription_)
    return;
  if (this->image_reader_.available())
    return;
@@ -1528,7 +1508,7 @@ void APIConnection::update_command(const UpdateCommandRequest &msg) {
 #endif

 bool APIConnection::try_send_log_message(int level, const char *tag, const char *line) {
-  if (this->flags_.log_subscription < level)
+  if (this->log_subscription_ < level)
    return false;

  // Pre-calculate message size to avoid reallocations
@@ -1569,7 +1549,7 @@ HelloResponse APIConnection::hello(const HelloRequest &msg) {
  resp.server_info = App.get_name() + " (esphome v" ESPHOME_VERSION ")";
  resp.name = App.get_name();

-  this->flags_.connection_state = static_cast<uint8_t>(ConnectionState::CONNECTED);
+  this->connection_state_ = ConnectionState::CONNECTED;
  return resp;
 }
 ConnectResponse APIConnection::connect(const ConnectRequest &msg) {
@@ -1580,7 +1560,7 @@ ConnectResponse APIConnection::connect(const ConnectRequest &msg) {
  resp.invalid_password = !correct;
  if (correct) {
    ESP_LOGD(TAG, "%s connected", this->get_client_combined_info().c_str());
-    this->flags_.connection_state = static_cast<uint8_t>(ConnectionState::AUTHENTICATED);
+    this->connection_state_ = ConnectionState::AUTHENTICATED;
    this->parent_->get_client_connected_trigger()->trigger(this->client_info_, this->client_peername_);
 #ifdef USE_HOMEASSISTANT_TIME
    if (homeassistant::global_homeassistant_time != nullptr) {
@@ -1694,7 +1674,7 @@ void APIConnection::subscribe_home_assistant_states(const SubscribeHomeAssistant
  state_subs_at_ = 0;
 }
 bool APIConnection::try_to_clear_buffer(bool log_out_of_space) {
-  if (this->flags_.remove)
+  if (this->remove_)
    return false;
  if (this->helper_->can_write_without_blocking())
    return true;
@@ -1744,7 +1724,7 @@ void APIConnection::on_no_setup_connection() {
 }
 void APIConnection::on_fatal_error() {
  this->helper_->close();
-  this->flags_.remove = true;
+  this->remove_ = true;
 }

 void APIConnection::DeferredBatch::add_item(EntityBase *entity, MessageCreator creator, uint16_t message_type) {
@@ -1769,8 +1749,8 @@ void APIConnection::DeferredBatch::add_item_front(EntityBase *entity, MessageCre
 }

 bool APIConnection::schedule_batch_() {
-  if (!this->flags_.batch_scheduled) {
-    this->flags_.batch_scheduled = true;
+  if (!this->deferred_batch_.batch_scheduled) {
+    this->deferred_batch_.batch_scheduled = true;
    this->deferred_batch_.batch_start_time = App.get_loop_component_start_time();
  }
  return true;
@@ -1779,14 +1759,14 @@ bool APIConnection::schedule_batch_() {
 ProtoWriteBuffer APIConnection::allocate_single_message_buffer(uint16_t size) { return this->create_buffer(size); }

 ProtoWriteBuffer APIConnection::allocate_batch_message_buffer(uint16_t size) {
-  ProtoWriteBuffer result = this->prepare_message_buffer(size, this->flags_.batch_first_message);
-  this->flags_.batch_first_message = false;
+  ProtoWriteBuffer result = this->prepare_message_buffer(size, this->batch_first_message_);
+  this->batch_first_message_ = false;
  return result;
 }

 void APIConnection::process_batch_() {
  if (this->deferred_batch_.empty()) {
-    this->flags_.batch_scheduled = false;
+    this->deferred_batch_.batch_scheduled = false;
    return;
  }

@@ -1839,7 +1819,7 @@ void APIConnection::process_batch_() {

  // Reserve based on estimated size (much more accurate than 24-byte worst-case)
  this->parent_->get_shared_buffer_ref().reserve(total_estimated_size + total_overhead);
-  this->flags_.batch_first_message = true;
+  this->batch_first_message_ = true;

  size_t items_processed = 0;
  uint16_t remaining_size = std::numeric_limits<uint16_t>::max();
@@ -1902,15 +1882,6 @@ void APIConnection::process_batch_() {
    }
  }

-#ifdef HAS_PROTO_MESSAGE_DUMP
-  // Log messages after send attempt for VV debugging
-  // It's safe to use the buffer for logging at this point regardless of send result
-  for (size_t i = 0; i < items_processed; i++) {
-    const auto &item = this->deferred_batch_.items[i];
-    this->log_batch_item_(item);
-  }
-#endif
-
  // Handle remaining items more efficiently
  if (items_processed < this->deferred_batch_.items.size()) {
    // Remove processed items from the beginning
--- a/esphome/components/api/api_connection.h
+++ b/esphome/components/api/api_connection.h
@@ -125,7 +125,7 @@ class APIConnection : public APIServerConnection {
 #endif
  bool try_send_log_message(int level, const char *tag, const char *line);
  void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
-    if (!this->flags_.service_call_subscription)
+    if (!this->service_call_subscription_)
      return;
    this->send_message(call);
  }
@@ -185,7 +185,7 @@ class APIConnection : public APIServerConnection {
  void on_disconnect_response(const DisconnectResponse &value) override;
  void on_ping_response(const PingResponse &value) override {
    // we initiated ping
-    this->flags_.sent_ping = false;
+    this->sent_ping_ = false;
  }
  void on_home_assistant_state_response(const HomeAssistantStateResponse &msg) override;
 #ifdef USE_HOMEASSISTANT_TIME
@@ -198,16 +198,16 @@ class APIConnection : public APIServerConnection {
  DeviceInfoResponse device_info(const DeviceInfoRequest &msg) override;
  void list_entities(const ListEntitiesRequest &msg) override { this->list_entities_iterator_.begin(); }
  void subscribe_states(const SubscribeStatesRequest &msg) override {
-    this->flags_.state_subscription = true;
+    this->state_subscription_ = true;
    this->initial_state_iterator_.begin();
  }
  void subscribe_logs(const SubscribeLogsRequest &msg) override {
-    this->flags_.log_subscription = msg.level;
+    this->log_subscription_ = msg.level;
    if (msg.dump_config)
      App.schedule_dump_config();
  }
  void subscribe_homeassistant_services(const SubscribeHomeassistantServicesRequest &msg) override {
-    this->flags_.service_call_subscription = true;
+    this->service_call_subscription_ = true;
  }
  void subscribe_home_assistant_states(const SubscribeHomeAssistantStatesRequest &msg) override;
  GetTimeResponse get_time(const GetTimeRequest &msg) override {
@@ -219,12 +219,9 @@ class APIConnection : public APIServerConnection {
  NoiseEncryptionSetKeyResponse noise_encryption_set_key(const NoiseEncryptionSetKeyRequest &msg) override;
 #endif

-  bool is_authenticated() override {
-    return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::AUTHENTICATED;
-  }
+  bool is_authenticated() override { return this->connection_state_ == ConnectionState::AUTHENTICATED; }
  bool is_connection_setup() override {
-    return static_cast<ConnectionState>(this->flags_.connection_state) == ConnectionState::CONNECTED ||
-           this->is_authenticated();
+    return this->connection_state_ == ConnectionState ::CONNECTED || this->is_authenticated();
  }
  void on_fatal_error() override;
  void on_unauthenticated_access() override;
@@ -447,28 +444,43 @@ class APIConnection : public APIServerConnection {
  static uint16_t try_send_ping_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);

-  // === Optimal member ordering for 32-bit systems ===
-
-  // Group 1: Pointers (4 bytes each on 32-bit)
+  // Pointers first (4 bytes each, naturally aligned)
  std::unique_ptr<APIFrameHelper> helper_;
  APIServer *parent_;

-  // Group 2: Larger objects (must be 4-byte aligned)
-  // These contain vectors/pointers internally, so putting them early ensures good alignment
+  // 4-byte aligned types
+  uint32_t last_traffic_;
+  int state_subs_at_ = -1;
+
+  // Strings (12 bytes each on 32-bit)
+  std::string client_info_;
+  std::string client_peername_;
+
+  // 2-byte aligned types
+  uint16_t client_api_version_major_{0};
+  uint16_t client_api_version_minor_{0};
+
+  // Group all 1-byte types together to minimize padding
+  enum class ConnectionState : uint8_t {
+    WAITING_FOR_HELLO,
+    CONNECTED,
+    AUTHENTICATED,
+  } connection_state_{ConnectionState::WAITING_FOR_HELLO};
+  uint8_t log_subscription_{ESPHOME_LOG_LEVEL_NONE};
+  bool remove_{false};
+  bool state_subscription_{false};
+  bool sent_ping_{false};
+  bool service_call_subscription_{false};
+  bool next_close_ = false;
+  // 7 bytes used, 1 byte padding
+
+  // Larger objects at the end
  InitialStateIterator initial_state_iterator_;
  ListEntitiesIterator list_entities_iterator_;
 #ifdef USE_ESP32_CAMERA
  esp32_camera::CameraImageReader image_reader_;
 #endif

-  // Group 3: Strings (12 bytes each on 32-bit, 4-byte aligned)
-  std::string client_info_;
-  std::string client_peername_;
-
-  // Group 4: 4-byte types
-  uint32_t last_traffic_;
-  int state_subs_at_ = -1;
-
  // Function pointer type for message encoding
  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size, bool is_single);

@@ -578,6 +590,7 @@ class APIConnection : public APIServerConnection {

    std::vector<BatchItem> items;
    uint32_t batch_start_time{0};
+    bool batch_scheduled{false};

    DeferredBatch() {
      // Pre-allocate capacity for typical batch sizes to avoid reallocation
@@ -590,47 +603,13 @@ class APIConnection : public APIServerConnection {
    void add_item_front(EntityBase *entity, MessageCreator creator, uint16_t message_type);
    void clear() {
      items.clear();
+      batch_scheduled = false;
      batch_start_time = 0;
    }
    bool empty() const { return items.empty(); }
  };

-  // DeferredBatch here (16 bytes, 4-byte aligned)
  DeferredBatch deferred_batch_;
-
-  // ConnectionState enum for type safety
-  enum class ConnectionState : uint8_t {
-    WAITING_FOR_HELLO = 0,
-    CONNECTED = 1,
-    AUTHENTICATED = 2,
-  };
-
-  // Group 5: Pack all small members together to minimize padding
-  // This group starts at a 4-byte boundary after DeferredBatch
-  struct APIFlags {
-    // Connection state only needs 2 bits (3 states)
-    uint8_t connection_state : 2;
-    // Log subscription needs 3 bits (log levels 0-7)
-    uint8_t log_subscription : 3;
-    // Boolean flags (1 bit each)
-    uint8_t remove : 1;
-    uint8_t state_subscription : 1;
-    uint8_t sent_ping : 1;
-
-    uint8_t service_call_subscription : 1;
-    uint8_t next_close : 1;
-    uint8_t batch_scheduled : 1;
-    uint8_t batch_first_message : 1;  // For batch buffer allocation
-#ifdef HAS_PROTO_MESSAGE_DUMP
-    uint8_t log_only_mode : 1;
-#endif
-  } flags_{};  // 2 bytes total
-
-  // 2-byte types immediately after flags_ (no padding between them)
-  uint16_t client_api_version_major_{0};
-  uint16_t client_api_version_minor_{0};
-  // Total: 2 (flags) + 2 + 2 = 6 bytes, then 2 bytes padding to next 4-byte boundary
-
  uint32_t get_batch_delay_ms_() const;
  // Message will use 8 more bytes than the minimum size, and typical
  // MTU is 1500. Sometimes users will see as low as 1460 MTU.
@@ -648,9 +627,8 @@ class APIConnection : public APIServerConnection {
  bool schedule_batch_();
  void process_batch_();

-#ifdef HAS_PROTO_MESSAGE_DUMP
-  void log_batch_item_(const DeferredBatch::BatchItem &item);
-#endif
+  // State for batch buffer allocation
+  bool batch_first_message_{false};

  // Helper function to schedule a deferred message with known message type
  bool schedule_message_(EntityBase *entity, MessageCreator creator, uint16_t message_type) {
--- a/esphome/components/api/api_pb2.h
+++ b/esphome/components/api/api_pb2.h
--- a/esphome/components/api/api_pb2_service.h
+++ b/esphome/components/api/api_pb2_service.h
@@ -19,7 +19,7 @@ class APIServerConnectionBase : public ProtoService {

  template<typename T> bool send_message(const T &msg) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
-    this->log_send_message_(msg.message_name(), msg.dump());
+    this->log_send_message_(T::message_name(), msg.dump());
 #endif
    return this->send_message_(msg, T::MESSAGE_TYPE);
  }
--- a/esphome/components/api/api_server.cpp
+++ b/esphome/components/api/api_server.cpp
@@ -104,7 +104,7 @@ void APIServer::setup() {
        return;
      }
      for (auto &c : this->clients_) {
-        if (!c->flags_.remove)
+        if (!c->remove_)
          c->try_send_log_message(level, tag, message);
      }
    });
@@ -116,7 +116,7 @@ void APIServer::setup() {
    esp32_camera::global_esp32_camera->add_image_callback(
        [this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
          for (auto &c : this->clients_) {
-            if (!c->flags_.remove)
+            if (!c->remove_)
              c->set_camera_state(image);
          }
        });
@@ -176,7 +176,7 @@ void APIServer::loop() {
  while (client_index < this->clients_.size()) {
    auto &client = this->clients_[client_index];

-    if (!client->flags_.remove) {
+    if (!client->remove_) {
      // Common case: process active client
      client->loop();
      client_index++;
@@ -502,7 +502,7 @@ bool APIServer::save_noise_psk(psk_t psk, bool make_active) {
 #ifdef USE_HOMEASSISTANT_TIME
 void APIServer::request_time() {
  for (auto &client : this->clients_) {
-    if (!client->flags_.remove && client->is_authenticated())
+    if (!client->remove_ && client->is_authenticated())
      client->send_time_request();
  }
 }
--- a/esphome/components/api/client.py
+++ b/esphome/components/api/client.py
@@ -4,15 +4,9 @@ import asyncio
 from datetime import datetime
 import logging
 from typing import TYPE_CHECKING, Any
-import warnings

-# Suppress protobuf version warnings
-with warnings.catch_warnings():
-    warnings.filterwarnings(
-        "ignore", category=UserWarning, message=".*Protobuf gencode version.*"
-    )
-    from aioesphomeapi import APIClient, parse_log_message
-    from aioesphomeapi.log_runner import async_run
+from aioesphomeapi import APIClient, parse_log_message
+from aioesphomeapi.log_runner import async_run

 from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
 from esphome.core import CORE
--- a/esphome/components/api/proto.h
+++ b/esphome/components/api/proto.h
@@ -335,7 +335,6 @@ class ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
  std::string dump() const;
  virtual void dump_to(std::string &out) const = 0;
-  virtual const char *message_name() const { return "unknown"; }
 #endif

 protected:
--- a/esphome/components/atm90e32/atm90e32.cpp
+++ b/esphome/components/atm90e32/atm90e32.cpp
@@ -1,7 +1,6 @@
 #include "atm90e32.h"
 #include <cinttypes>
 #include <cmath>
-#include <numbers>
 #include "esphome/core/log.h"

 namespace esphome {
@@ -849,7 +848,7 @@ uint16_t ATM90E32Component::calculate_voltage_threshold(int line_freq, uint16_t
  float nominal_voltage = (line_freq == 60) ? 120.0f : 220.0f;
  float target_voltage = nominal_voltage * multiplier;

-  float peak_01v = target_voltage * 100.0f * std::numbers::sqrt2_v<float>;  // convert RMS → peak, scale to 0.01V
+  float peak_01v = target_voltage * 100.0f * std::sqrt(2.0f);  // convert RMS → peak, scale to 0.01V
  float divider = (2.0f * ugain) / 32768.0f;

  float threshold = peak_01v / divider;
--- a/esphome/components/audio/audio_decoder.cpp
+++ b/esphome/components/audio/audio_decoder.cpp
@@ -312,7 +312,7 @@ FileDecoderState AudioDecoder::decode_mp3_() {
  if (err) {
    switch (err) {
      case esp_audio_libs::helix_decoder::ERR_MP3_OUT_OF_MEMORY:
-        [[fallthrough]];
+        // Intentional fallthrough
      case esp_audio_libs::helix_decoder::ERR_MP3_NULL_POINTER:
        return FileDecoderState::FAILED;
        break;
--- a/esphome/components/audio/audio_reader.cpp
+++ b/esphome/components/audio/audio_reader.cpp
@@ -5,7 +5,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"

 #if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
 #include "esp_crt_bundle.h"
@@ -17,13 +16,13 @@ namespace audio {
 static const uint32_t READ_WRITE_TIMEOUT_MS = 20;

 static const uint32_t CONNECTION_TIMEOUT_MS = 5000;
-static const uint8_t MAX_FETCHING_HEADER_ATTEMPTS = 6;
+
+// The number of times the http read times out with no data before throwing an error
+static const uint32_t ERROR_COUNT_NO_DATA_READ_TIMEOUT = 100;

 static const size_t HTTP_STREAM_BUFFER_SIZE = 2048;

-static const uint8_t MAX_REDIRECTIONS = 5;
-
-static const char *const TAG = "audio_reader";
+static const uint8_t MAX_REDIRECTION = 5;

 // Some common HTTP status codes - borrowed from http_request component accessed 20241224
 enum HttpStatus {
@@ -95,7 +94,7 @@ esp_err_t AudioReader::start(const std::string &uri, AudioFileType &file_type) {
  client_config.url = uri.c_str();
  client_config.cert_pem = nullptr;
  client_config.disable_auto_redirect = false;
-  client_config.max_redirection_count = MAX_REDIRECTIONS;
+  client_config.max_redirection_count = 10;
  client_config.event_handler = http_event_handler;
  client_config.user_data = this;
  client_config.buffer_size = HTTP_STREAM_BUFFER_SIZE;
@@ -117,29 +116,12 @@ esp_err_t AudioReader::start(const std::string &uri, AudioFileType &file_type) {
  esp_err_t err = esp_http_client_open(this->client_, 0);

  if (err != ESP_OK) {
-    ESP_LOGE(TAG, "Failed to open URL");
    this->cleanup_connection_();
    return err;
  }

  int64_t header_length = esp_http_client_fetch_headers(this->client_);
-  uint8_t reattempt_count = 0;
-  while ((header_length < 0) && (reattempt_count < MAX_FETCHING_HEADER_ATTEMPTS)) {
-    this->cleanup_connection_();
-    if (header_length != -ESP_ERR_HTTP_EAGAIN) {
-      // Serious error, no recovery
-      return ESP_FAIL;
-    } else {
-      // Reconnect from a fresh state to avoid a bug where it never reads the headers even if made available
-      this->client_ = esp_http_client_init(&client_config);
-      esp_http_client_open(this->client_, 0);
-      header_length = esp_http_client_fetch_headers(this->client_);
-      ++reattempt_count;
-    }
-  }
-
  if (header_length < 0) {
-    ESP_LOGE(TAG, "Failed to fetch headers");
    this->cleanup_connection_();
    return ESP_FAIL;
  }
@@ -153,7 +135,7 @@ esp_err_t AudioReader::start(const std::string &uri, AudioFileType &file_type) {

  ssize_t redirect_count = 0;

-  while ((esp_http_client_set_redirection(this->client_) == ESP_OK) && (redirect_count < MAX_REDIRECTIONS)) {
+  while ((esp_http_client_set_redirection(this->client_) == ESP_OK) && (redirect_count < MAX_REDIRECTION)) {
    err = esp_http_client_open(this->client_, 0);
    if (err != ESP_OK) {
      this->cleanup_connection_();
@@ -285,29 +267,27 @@ AudioReaderState AudioReader::http_read_() {
      return AudioReaderState::FINISHED;
    }
  } else if (this->output_transfer_buffer_->free() > 0) {
-    int received_len = esp_http_client_read(this->client_, (char *) this->output_transfer_buffer_->get_buffer_end(),
-                                            this->output_transfer_buffer_->free());
+    size_t bytes_to_read = this->output_transfer_buffer_->free();
+    int received_len =
+        esp_http_client_read(this->client_, (char *) this->output_transfer_buffer_->get_buffer_end(), bytes_to_read);

    if (received_len > 0) {
      this->output_transfer_buffer_->increase_buffer_length(received_len);
      this->last_data_read_ms_ = millis();
-      return AudioReaderState::READING;
-    } else if (received_len <= 0) {
+    } else if (received_len < 0) {
      // HTTP read error
-      if (received_len == -1) {
-        // A true connection error occured, no chance at recovery
-        this->cleanup_connection_();
-        return AudioReaderState::FAILED;
-      }
+      this->cleanup_connection_();
+      return AudioReaderState::FAILED;
+    } else {
+      if (bytes_to_read > 0) {
+        // Read timed out
+        if ((millis() - this->last_data_read_ms_) > CONNECTION_TIMEOUT_MS) {
+          this->cleanup_connection_();
+          return AudioReaderState::FAILED;
+        }

-      // Read timed out, manually verify if it has been too long since the last successful read
-      if ((millis() - this->last_data_read_ms_) > MAX_FETCHING_HEADER_ATTEMPTS * CONNECTION_TIMEOUT_MS) {
-        ESP_LOGE(TAG, "Timed out");
-        this->cleanup_connection_();
-        return AudioReaderState::FAILED;
+        delay(READ_WRITE_TIMEOUT_MS);
      }
-
-      delay(READ_WRITE_TIMEOUT_MS);
    }
  }

--- a/esphome/components/display/display.cpp
+++ b/esphome/components/display/display.cpp
@@ -1,6 +1,5 @@
 #include "display.h"
 #include <utility>
-#include <numbers>
 #include "display_color_utils.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -425,15 +424,15 @@ void HOT Display::get_regular_polygon_vertex(int vertex_id, int *vertex_x, int *
    // hence we rotate the shape by 270° to orient the polygon up.
    rotation_degrees += ROTATION_270_DEGREES;
    // Convert the rotation to radians, easier to use in trigonometrical calculations
-    float rotation_radians = rotation_degrees * std::numbers::pi / 180;
+    float rotation_radians = rotation_degrees * PI / 180;
    // A pointy top variation means the first vertex of the polygon is at the top center of the shape, this requires no
    // additional rotation of the shape.
    // A flat top variation means the first point of the polygon has to be rotated so that the first edge is horizontal,
    // this requires to rotate the shape by π/edges radians counter-clockwise so that the first point is located on the
    // left side of the first horizontal edge.
-    rotation_radians -= (variation == VARIATION_FLAT_TOP) ? std::numbers::pi / edges : 0.0;
+    rotation_radians -= (variation == VARIATION_FLAT_TOP) ? PI / edges : 0.0;

-    float vertex_angle = ((float) vertex_id) / edges * 2 * std::numbers::pi + rotation_radians;
+    float vertex_angle = ((float) vertex_id) / edges * 2 * PI + rotation_radians;
    *vertex_x = (int) round(cos(vertex_angle) * radius) + center_x;
    *vertex_y = (int) round(sin(vertex_angle) * radius) + center_y;
  }
--- a/esphome/components/display/display.h
+++ b/esphome/components/display/display.h
@@ -138,6 +138,8 @@ enum DisplayRotation {
  DISPLAY_ROTATION_270_DEGREES = 270,
 };

+#define PI 3.1415926535897932384626433832795
+
 const int EDGES_TRIGON = 3;
 const int EDGES_TRIANGLE = 3;
 const int EDGES_TETRAGON = 4;
--- a/esphome/components/esp32/init.py
+++ b/esphome/components/esp32/init.py
@@ -4,7 +4,7 @@ import logging
 import os
 from pathlib import Path

-from esphome import yaml_util
+from esphome import git
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -23,6 +23,7 @@ from esphome.const import (
    CONF_REFRESH,
    CONF_SOURCE,
    CONF_TYPE,
+    CONF_URL,
    CONF_VARIANT,
    CONF_VERSION,
    KEY_CORE,
@@ -31,13 +32,14 @@ from esphome.const import (
    KEY_TARGET_FRAMEWORK,
    KEY_TARGET_PLATFORM,
    PLATFORM_ESP32,
+    TYPE_GIT,
+    TYPE_LOCAL,
    __version__,
 )
 from esphome.core import CORE, HexInt, TimePeriod
 from esphome.cpp_generator import RawExpression
 import esphome.final_validate as fv
 from esphome.helpers import copy_file_if_changed, mkdir_p, write_file_if_changed
-from esphome.types import ConfigType

 from .boards import BOARDS
 from .const import (  # noqa
@@ -47,8 +49,10 @@ from .const import (  # noqa
    KEY_EXTRA_BUILD_FILES,
    KEY_PATH,
    KEY_REF,
+    KEY_REFRESH,
    KEY_REPO,
    KEY_SDKCONFIG_OPTIONS,
+    KEY_SUBMODULES,
    KEY_VARIANT,
    VARIANT_ESP32,
    VARIANT_ESP32C2,
@@ -231,7 +235,7 @@ def add_idf_sdkconfig_option(name: str, value: SdkconfigValueType):
 def add_idf_component(
    *,
    name: str,
-    repo: str = None,
+    repo: str,
    ref: str = None,
    path: str = None,
    refresh: TimePeriod = None,
@@ -241,27 +245,30 @@ def add_idf_component(
    """Add an esp-idf component to the project."""
    if not CORE.using_esp_idf:
        raise ValueError("Not an esp-idf project")
-    if not repo and not ref and not path:
-        raise ValueError("Requires at least one of repo, ref or path")
-    if refresh or submodules or components:
-        _LOGGER.warning(
-            "The refresh, components and submodules parameters in add_idf_component() are "
-            "deprecated and will be removed in ESPHome 2026.1. If you are seeing this, report "
-            "an issue to the external_component author and ask them to update it."
-        )
-    if components:
-        for comp in components:
-            CORE.data[KEY_ESP32][KEY_COMPONENTS][comp] = {
-                KEY_REPO: repo,
-                KEY_REF: ref,
-                KEY_PATH: f"{path}/{comp}" if path else comp,
-            }
-    else:
+    if components is None:
+        components = []
+    if name not in CORE.data[KEY_ESP32][KEY_COMPONENTS]:
        CORE.data[KEY_ESP32][KEY_COMPONENTS][name] = {
            KEY_REPO: repo,
            KEY_REF: ref,
            KEY_PATH: path,
+            KEY_REFRESH: refresh,
+            KEY_COMPONENTS: components,
+            KEY_SUBMODULES: submodules,
        }
+    else:
+        component_config = CORE.data[KEY_ESP32][KEY_COMPONENTS][name]
+        if components is not None:
+            component_config[KEY_COMPONENTS] = list(
+                set(component_config[KEY_COMPONENTS] + components)
+            )
+        if submodules is not None:
+            if component_config[KEY_SUBMODULES] is None:
+                component_config[KEY_SUBMODULES] = submodules
+            else:
+                component_config[KEY_SUBMODULES] = list(
+                    set(component_config[KEY_SUBMODULES] + submodules)
+                )


 def add_extra_script(stage: str, filename: str, path: str):
@@ -341,7 +348,6 @@ SUPPORTED_PLATFORMIO_ESP_IDF_5X = [
 # List based on https://github.com/pioarduino/esp-idf/releases
 SUPPORTED_PIOARDUINO_ESP_IDF_5X = [
    cv.Version(5, 5, 0),
-    cv.Version(5, 4, 2),
    cv.Version(5, 4, 1),
    cv.Version(5, 4, 0),
    cv.Version(5, 3, 3),
@@ -569,17 +575,6 @@ CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
 CONF_ENABLE_LWIP_MDNS_QUERIES = "enable_lwip_mdns_queries"
 CONF_ENABLE_LWIP_BRIDGE_INTERFACE = "enable_lwip_bridge_interface"

-
-def _validate_idf_component(config: ConfigType) -> ConfigType:
-    """Validate IDF component config and warn about deprecated options."""
-    if CONF_REFRESH in config:
-        _LOGGER.warning(
-            "The 'refresh' option for IDF components is deprecated and has no effect. "
-            "It will be removed in ESPHome 2026.1. Please remove it from your configuration."
-        )
-    return config
-
-
 ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
    cv.Schema(
        {
@@ -611,7 +606,7 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
                    ): cv.boolean,
                    cv.Optional(
-                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=True
+                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=False
                    ): cv.boolean,
                    cv.Optional(
                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
@@ -619,19 +614,15 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
                }
            ),
            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,
+                cv.Schema(
+                    {
+                        cv.Required(CONF_NAME): cv.string_strict,
+                        cv.Required(CONF_SOURCE): cv.SOURCE_SCHEMA,
+                        cv.Optional(CONF_PATH): cv.string,
+                        cv.Optional(CONF_REFRESH, default="1d"): cv.All(
+                            cv.string, cv.source_refresh
+                        ),
+                    }
                )
            ),
        }
@@ -705,7 +696,7 @@ FINAL_VALIDATE_SCHEMA = cv.Schema(final_validate)
 async def to_code(config):
    cg.add_platformio_option("board", config[CONF_BOARD])
    cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
-    cg.set_cpp_standard("gnu++20")
+    cg.set_cpp_standard("gnu++17")
    cg.add_build_flag("-DUSE_ESP32")
    cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
    cg.add_build_flag(f"-DUSE_ESP32_VARIANT_{config[CONF_VARIANT]}")
@@ -759,9 +750,6 @@ async def to_code(config):
        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
        add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)

-        # Disable dynamic log level control to save memory
-        add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
-
        # Set default CPU frequency
        add_idf_sdkconfig_option(f"CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_{freq}", True)

@@ -774,7 +762,7 @@ async def to_code(config):
            and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
        ):
            add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-        if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, True):
+        if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, False):
            add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
        if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
            add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
@@ -826,12 +814,18 @@ async def to_code(config):
            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))

        for component in conf[CONF_COMPONENTS]:
-            add_idf_component(
-                name=component[CONF_NAME],
-                repo=component.get(CONF_SOURCE),
-                ref=component.get(CONF_REF),
-                path=component.get(CONF_PATH),
-            )
+            source = component[CONF_SOURCE]
+            if source[CONF_TYPE] == TYPE_GIT:
+                add_idf_component(
+                    name=component[CONF_NAME],
+                    repo=source[CONF_URL],
+                    ref=source.get(CONF_REF),
+                    path=component.get(CONF_PATH),
+                    refresh=component[CONF_REFRESH],
+                )
+            elif source[CONF_TYPE] == TYPE_LOCAL:
+                _LOGGER.warning("Local components are not implemented yet.")
+
    elif conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
        cg.add_platformio_option("framework", "arduino")
        cg.add_build_flag("-DUSE_ARDUINO")
@@ -930,26 +924,6 @@ def _write_sdkconfig():
        write_file_if_changed(sdk_path, contents)


-def _write_idf_component_yml():
-    yml_path = Path(CORE.relative_build_path("src/idf_component.yml"))
-    if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
-        components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
-        dependencies = {}
-        for name, component in components.items():
-            dependency = {}
-            if component[KEY_REF]:
-                dependency["version"] = component[KEY_REF]
-            if component[KEY_REPO]:
-                dependency["git"] = component[KEY_REPO]
-            if component[KEY_PATH]:
-                dependency["path"] = component[KEY_PATH]
-            dependencies[name] = dependency
-        contents = yaml_util.dump({"dependencies": dependencies})
-    else:
-        contents = ""
-    write_file_if_changed(yml_path, contents)
-
-
 # Called by writer.py
 def copy_files():
    if CORE.using_arduino:
@@ -962,7 +936,6 @@ def copy_files():
            )
    if CORE.using_esp_idf:
        _write_sdkconfig()
-        _write_idf_component_yml()
        if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
            write_file_if_changed(
                CORE.relative_build_path("partitions.csv"),
@@ -979,6 +952,55 @@ def copy_files():
            __version__,
        )

+        import shutil
+
+        shutil.rmtree(CORE.relative_build_path("components"), ignore_errors=True)
+
+        if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
+            components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
+
+            for name, component in components.items():
+                repo_dir, _ = git.clone_or_update(
+                    url=component[KEY_REPO],
+                    ref=component[KEY_REF],
+                    refresh=component[KEY_REFRESH],
+                    domain="idf_components",
+                    submodules=component[KEY_SUBMODULES],
+                )
+                mkdir_p(CORE.relative_build_path("components"))
+                component_dir = repo_dir
+                if component[KEY_PATH] is not None:
+                    component_dir = component_dir / component[KEY_PATH]
+
+                if component[KEY_COMPONENTS] == ["*"]:
+                    shutil.copytree(
+                        component_dir,
+                        CORE.relative_build_path("components"),
+                        dirs_exist_ok=True,
+                        ignore=shutil.ignore_patterns(".git*"),
+                        symlinks=True,
+                        ignore_dangling_symlinks=True,
+                    )
+                elif len(component[KEY_COMPONENTS]) > 0:
+                    for comp in component[KEY_COMPONENTS]:
+                        shutil.copytree(
+                            component_dir / comp,
+                            CORE.relative_build_path(f"components/{comp}"),
+                            dirs_exist_ok=True,
+                            ignore=shutil.ignore_patterns(".git*"),
+                            symlinks=True,
+                            ignore_dangling_symlinks=True,
+                        )
+                else:
+                    shutil.copytree(
+                        component_dir,
+                        CORE.relative_build_path(f"components/{name}"),
+                        dirs_exist_ok=True,
+                        ignore=shutil.ignore_patterns(".git*"),
+                        symlinks=True,
+                        ignore_dangling_symlinks=True,
+                    )
+
    for _, file in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES].items():
        if file[KEY_PATH].startswith("http"):
            import requests
--- a/esphome/components/esp32/gpio.h
+++ b/esphome/components/esp32/gpio.h
@@ -29,9 +29,9 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
  void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;

  gpio_num_t pin_;
+  bool inverted_;
  gpio_drive_cap_t drive_strength_;
  gpio::Flags flags_;
-  bool inverted_;
  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
  static bool isr_service_installed;
 };
--- a/esphome/components/esp32_ble/ble.cpp
+++ b/esphome/components/esp32_ble/ble.cpp
@@ -1,6 +1,7 @@
 #ifdef USE_ESP32

 #include "ble.h"
+#include "ble_event_pool.h"

 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
--- a/esphome/components/esp32_ble/ble.h
+++ b/esphome/components/esp32_ble/ble.h
@@ -12,8 +12,8 @@
 #include "esphome/core/helpers.h"

 #include "ble_event.h"
-#include "esphome/core/lock_free_queue.h"
-#include "esphome/core/event_pool.h"
+#include "ble_event_pool.h"
+#include "queue.h"

 #ifdef USE_ESP32

@@ -148,8 +148,8 @@ class ESP32BLE : public Component {
  std::vector<BLEStatusEventHandler *> ble_status_event_handlers_;
  BLEComponentState state_{BLE_COMPONENT_STATE_OFF};

-  esphome::LockFreeQueue<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_events_;
-  esphome::EventPool<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_event_pool_;
+  LockFreeQueue<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_events_;
+  BLEEventPool<MAX_BLE_QUEUE_SIZE> ble_event_pool_;
  BLEAdvertising *advertising_{};
  esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};
  uint32_t advertising_cycle_time_{};
--- a/esphome/components/esp32_ble/ble_event.h
+++ b/esphome/components/esp32_ble/ble_event.h
@@ -134,13 +134,13 @@ class BLEEvent {
  }

  // Destructor to clean up heap allocations
-  ~BLEEvent() { this->release(); }
+  ~BLEEvent() { this->cleanup_heap_data(); }

  // Default constructor for pre-allocation in pool
  BLEEvent() : type_(GAP) {}

-  // Invoked on return to EventPool - clean up any heap-allocated data
-  void release() {
+  // Clean up any heap-allocated data
+  void cleanup_heap_data() {
    if (this->type_ == GAP) {
      return;
    }
@@ -161,19 +161,19 @@ class BLEEvent {

  // Load new event data for reuse (replaces previous event data)
  void load_gap_event(esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
-    this->release();
+    this->cleanup_heap_data();
    this->type_ = GAP;
    this->init_gap_data_(e, p);
  }

  void load_gattc_event(esp_gattc_cb_event_t e, esp_gatt_if_t i, esp_ble_gattc_cb_param_t *p) {
-    this->release();
+    this->cleanup_heap_data();
    this->type_ = GATTC;
    this->init_gattc_data_(e, i, p);
  }

  void load_gatts_event(esp_gatts_cb_event_t e, esp_gatt_if_t i, esp_ble_gatts_cb_param_t *p) {
-    this->release();
+    this->cleanup_heap_data();
    this->type_ = GATTS;
    this->init_gatts_data_(e, i, p);
  }
--- a/esphome/components/esp32_ble/ble_event_pool.h
+++ b/esphome/components/esp32_ble/ble_event_pool.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <atomic>
+#include <cstddef>
+#include "ble_event.h"
+#include "queue.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace esp32_ble {
+
+// BLE Event Pool - On-demand pool of BLEEvent objects to avoid heap fragmentation
+// Events are allocated on first use and reused thereafter, growing to peak usage
+template<uint8_t SIZE> class BLEEventPool {
+ public:
+  BLEEventPool() : total_created_(0) {}
+
+  ~BLEEventPool() {
+    // Clean up any remaining events in the free list
+    BLEEvent *event;
+    while ((event = this->free_list_.pop()) != nullptr) {
+      delete event;
+    }
+  }
+
+  // Allocate an event from the pool
+  // Returns nullptr if pool is full
+  BLEEvent *allocate() {
+    // Try to get from free list first
+    BLEEvent *event = this->free_list_.pop();
+    if (event != nullptr)
+      return event;
+
+    // Need to create a new event
+    if (this->total_created_ >= SIZE) {
+      // Pool is at capacity
+      return nullptr;
+    }
+
+    // Use internal RAM for better performance
+    RAMAllocator<BLEEvent> allocator(RAMAllocator<BLEEvent>::ALLOC_INTERNAL);
+    event = allocator.allocate(1);
+
+    if (event == nullptr) {
+      // Memory allocation failed
+      return nullptr;
+    }
+
+    // Placement new to construct the object
+    new (event) BLEEvent();
+    this->total_created_++;
+    return event;
+  }
+
+  // Return an event to the pool for reuse
+  void release(BLEEvent *event) {
+    if (event != nullptr) {
+      this->free_list_.push(event);
+    }
+  }
+
+ private:
+  LockFreeQueue<BLEEvent, SIZE> free_list_;  // Free events ready for reuse
+  uint8_t total_created_;                    // Total events created (high water mark)
+};
+
+}  // namespace esp32_ble
+}  // namespace esphome
+
+#endif
--- a/esphome/components/esp32_ble/queue.h
+++ b/esphome/components/esp32_ble/queue.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <atomic>
+#include <cstddef>
+
+/*
+ * BLE events come in from a separate Task (thread) in the ESP32 stack. Rather
+ * than using mutex-based locking, this lock-free queue allows the BLE
+ * task to enqueue events without blocking. The main loop() then processes
+ * these events at a safer time.
+ *
+ * This is a Single-Producer Single-Consumer (SPSC) lock-free ring buffer.
+ * The BLE task is the only producer, and the main loop() is the only consumer.
+ */
+
+namespace esphome {
+namespace esp32_ble {
+
+template<class T, uint8_t SIZE> class LockFreeQueue {
+ public:
+  LockFreeQueue() : head_(0), tail_(0), dropped_count_(0) {}
+
+  bool push(T *element) {
+    if (element == nullptr)
+      return false;
+
+    uint8_t current_tail = tail_.load(std::memory_order_relaxed);
+    uint8_t next_tail = (current_tail + 1) % SIZE;
+
+    if (next_tail == head_.load(std::memory_order_acquire)) {
+      // Buffer full
+      dropped_count_.fetch_add(1, std::memory_order_relaxed);
+      return false;
+    }
+
+    buffer_[current_tail] = element;
+    tail_.store(next_tail, std::memory_order_release);
+    return true;
+  }
+
+  T *pop() {
+    uint8_t current_head = head_.load(std::memory_order_relaxed);
+
+    if (current_head == tail_.load(std::memory_order_acquire)) {
+      return nullptr;  // Empty
+    }
+
+    T *element = buffer_[current_head];
+    head_.store((current_head + 1) % SIZE, std::memory_order_release);
+    return element;
+  }
+
+  size_t size() const {
+    uint8_t tail = tail_.load(std::memory_order_acquire);
+    uint8_t head = head_.load(std::memory_order_acquire);
+    return (tail - head + SIZE) % SIZE;
+  }
+
+  uint16_t get_and_reset_dropped_count() { return dropped_count_.exchange(0, std::memory_order_relaxed); }
+
+  void increment_dropped_count() { dropped_count_.fetch_add(1, std::memory_order_relaxed); }
+
+  bool empty() const { return head_.load(std::memory_order_acquire) == tail_.load(std::memory_order_acquire); }
+
+  bool full() const {
+    uint8_t next_tail = (tail_.load(std::memory_order_relaxed) + 1) % SIZE;
+    return next_tail == head_.load(std::memory_order_acquire);
+  }
+
+ protected:
+  T *buffer_[SIZE];
+  // Atomic: written by producer (push/increment), read+reset by consumer (get_and_reset)
+  std::atomic<uint16_t> dropped_count_;  // 65535 max - more than enough for drop tracking
+  // Atomic: written by consumer (pop), read by producer (push) to check if full
+  std::atomic<uint8_t> head_;
+  // Atomic: written by producer (push), read by consumer (pop) to check if empty
+  std::atomic<uint8_t> tail_;
+};
+
+}  // namespace esp32_ble
+}  // namespace esphome
+
+#endif
--- a/esphome/components/esp32_ble_client/ble_client_base.cpp
+++ b/esphome/components/esp32_ble_client/ble_client_base.cpp
@@ -496,17 +496,17 @@ float BLEClientBase::parse_char_value(uint8_t *value, uint16_t length) {
      if (length > 2) {
        return (float) encode_uint16(value[1], value[2]);
      }
-      [[fallthrough]];
+      // fall through
    case 0x7:  // uint24.
      if (length > 3) {
        return (float) encode_uint24(value[1], value[2], value[3]);
      }
-      [[fallthrough]];
+      // fall through
    case 0x8:  // uint32.
      if (length > 4) {
        return (float) encode_uint32(value[1], value[2], value[3], value[4]);
      }
-      [[fallthrough]];
+      // fall through
    case 0xC:  // int8.
      return (float) ((int8_t) value[1]);
    case 0xD:  // int12.
@@ -514,12 +514,12 @@ float BLEClientBase::parse_char_value(uint8_t *value, uint16_t length) {
      if (length > 2) {
        return (float) ((int16_t) (value[1] << 8) + (int16_t) value[2]);
      }
-      [[fallthrough]];
+      // fall through
    case 0xF:  // int24.
      if (length > 3) {
        return (float) ((int32_t) (value[1] << 16) + (int32_t) (value[2] << 8) + (int32_t) (value[3]));
      }
-      [[fallthrough]];
+      // fall through
    case 0x10:  // int32.
      if (length > 4) {
        return (float) ((int32_t) (value[1] << 24) + (int32_t) (value[2] << 16) + (int32_t) (value[3] << 8) +
--- a/esphome/components/esp32_camera/init.py
+++ b/esphome/components/esp32_camera/init.py
@@ -310,7 +310,11 @@ async def to_code(config):
    cg.add_define("USE_ESP32_CAMERA")

    if CORE.using_esp_idf:
-        add_idf_component(name="espressif/esp32-camera", ref="2.0.15")
+        add_idf_component(
+            name="esp32-camera",
+            repo="https://github.com/espressif/esp32-camera.git",
+            ref="v2.0.15",
+        )

    for conf in config.get(CONF_ON_STREAM_START, []):
        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
--- a/esphome/components/esp32_hosted/init.py
+++ b/esphome/components/esp32_hosted/init.py
@@ -1,101 +0,0 @@
-import os
-
-from esphome import pins
-from esphome.components import esp32
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_CLK_PIN,
-    CONF_RESET_PIN,
-    CONF_VARIANT,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
-)
-from esphome.core import CORE
-
-CODEOWNERS = ["@swoboda1337"]
-
-CONF_ACTIVE_HIGH = "active_high"
-CONF_CMD_PIN = "cmd_pin"
-CONF_D0_PIN = "d0_pin"
-CONF_D1_PIN = "d1_pin"
-CONF_D2_PIN = "d2_pin"
-CONF_D3_PIN = "d3_pin"
-CONF_SLOT = "slot"
-
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Required(CONF_VARIANT): cv.one_of(*esp32.VARIANTS, upper=True),
-            cv.Required(CONF_ACTIVE_HIGH): cv.boolean,
-            cv.Required(CONF_CLK_PIN): pins.internal_gpio_output_pin_number,
-            cv.Required(CONF_CMD_PIN): pins.internal_gpio_output_pin_number,
-            cv.Required(CONF_D0_PIN): pins.internal_gpio_output_pin_number,
-            cv.Required(CONF_D1_PIN): pins.internal_gpio_output_pin_number,
-            cv.Required(CONF_D2_PIN): pins.internal_gpio_output_pin_number,
-            cv.Required(CONF_D3_PIN): pins.internal_gpio_output_pin_number,
-            cv.Required(CONF_RESET_PIN): pins.internal_gpio_output_pin_number,
-            cv.Optional(CONF_SLOT, default=1): cv.int_range(min=0, max=1),
-        }
-    ),
-)
-
-
-async def to_code(config):
-    if config[CONF_ACTIVE_HIGH]:
-        esp32.add_idf_sdkconfig_option(
-            "CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH",
-            True,
-        )
-    else:
-        esp32.add_idf_sdkconfig_option(
-            "CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_LOW",
-            True,
-        )
-    esp32.add_idf_sdkconfig_option(
-        "CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE",  # NOLINT
-        config[CONF_RESET_PIN],
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_SLAVE_IDF_TARGET_{config[CONF_VARIANT]}",  # NOLINT
-        True,
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_SDIO_SLOT_{config[CONF_SLOT]}",
-        True,
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_{config[CONF_SLOT]}",
-        config[CONF_CLK_PIN],
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_{config[CONF_SLOT]}",
-        config[CONF_CMD_PIN],
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_{config[CONF_SLOT]}",
-        config[CONF_D0_PIN],
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_{config[CONF_SLOT]}",
-        config[CONF_D1_PIN],
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_{config[CONF_SLOT]}",
-        config[CONF_D2_PIN],
-    )
-    esp32.add_idf_sdkconfig_option(
-        f"CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_{config[CONF_SLOT]}",
-        config[CONF_D3_PIN],
-    )
-    esp32.add_idf_sdkconfig_option("CONFIG_ESP_HOSTED_CUSTOM_SDIO_PINS", True)
-
-    framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
-    os.environ["ESP_IDF_VERSION"] = f"{framework_ver.major}.{framework_ver.minor}"
-    esp32.add_idf_component(name="espressif/esp_wifi_remote", ref="0.10.2")
-    esp32.add_idf_component(name="espressif/eppp_link", ref="0.2.0")
-    esp32.add_idf_component(name="espressif/esp_hosted", ref="2.0.11")
-    esp32.add_extra_script(
-        "post",
-        "esp32_hosted.py",
-        os.path.join(os.path.dirname(__file__), "esp32_hosted.py.script"),
-    )
--- a/esphome/components/esp32_hosted/esp32_hosted.py.script
+++ b/esphome/components/esp32_hosted/esp32_hosted.py.script
@@ -1,12 +0,0 @@
-# pylint: disable=E0602
-Import("env")  # noqa
-
-# Workaround whole archive issue
-if "__LIB_DEPS" in env and "libespressif__esp_hosted.a" in env["__LIB_DEPS"]:
-    env.Append(
-        LINKFLAGS=[
-            "-Wl,--whole-archive",
-            env["BUILD_DIR"] + "/esp-idf/espressif__esp_hosted/libespressif__esp_hosted.a",
-            "-Wl,--no-whole-archive",
-        ]
-    )
--- a/esphome/components/esp8266/init.py
+++ b/esphome/components/esp8266/init.py
@@ -183,7 +183,7 @@ async def to_code(config):

    cg.add_platformio_option("board", config[CONF_BOARD])
    cg.add_build_flag("-DUSE_ESP8266")
-    cg.set_cpp_standard("gnu++20")
+    cg.set_cpp_standard("gnu++17")
    cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
    cg.add_define("ESPHOME_VARIANT", "ESP8266")

--- a/esphome/components/esp8266/gpio.cpp
+++ b/esphome/components/esp8266/gpio.cpp
@@ -129,9 +129,9 @@ void IRAM_ATTR ISRInternalGPIOPin::digital_write(bool value) {
    }
  } else {
    if (value != arg->inverted) {
-      *arg->out_set_reg = *arg->out_set_reg | 1;
+      *arg->out_set_reg |= 1;
    } else {
-      *arg->out_set_reg = *arg->out_set_reg & ~1;
+      *arg->out_set_reg &= ~1;
    }
  }
 }
@@ -147,7 +147,7 @@ void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {
    if (flags & gpio::FLAG_OUTPUT) {
      *arg->mode_set_reg = arg->mask;
      if (flags & gpio::FLAG_OPEN_DRAIN) {
-        *arg->control_reg = *arg->control_reg | (1 << GPCD);
+        *arg->control_reg |= 1 << GPCD;
      } else {
        *arg->control_reg &= ~(1 << GPCD);
      }
@@ -155,21 +155,21 @@ void IRAM_ATTR ISRInternalGPIOPin::pin_mode(gpio::Flags flags) {
      *arg->mode_clr_reg = arg->mask;
    }
    if (flags & gpio::FLAG_PULLUP) {
-      *arg->func_reg = *arg->func_reg | (1 << GPFPU);
-      *arg->control_reg = *arg->control_reg | (1 << GPCD);
+      *arg->func_reg |= 1 << GPFPU;
+      *arg->control_reg |= 1 << GPCD;
    } else {
-      *arg->func_reg = *arg->func_reg & ~(1 << GPFPU);
+      *arg->func_reg &= ~(1 << GPFPU);
    }
  } else {
    if (flags & gpio::FLAG_OUTPUT) {
-      *arg->mode_set_reg = *arg->mode_set_reg | 1;
+      *arg->mode_set_reg |= 1;
    } else {
-      *arg->mode_set_reg = *arg->mode_set_reg & ~1;
+      *arg->mode_set_reg &= ~1;
    }
    if (flags & gpio::FLAG_PULLDOWN) {
-      *arg->func_reg = *arg->func_reg | (1 << GP16FPD);
+      *arg->func_reg |= 1 << GP16FPD;
    } else {
-      *arg->func_reg = *arg->func_reg & ~(1 << GP16FPD);
+      *arg->func_reg &= ~(1 << GP16FPD);
    }
  }
 }
--- a/esphome/components/ethernet/ethernet_component.h
+++ b/esphome/components/ethernet/ethernet_component.h
@@ -15,7 +15,7 @@
 namespace esphome {
 namespace ethernet {

-enum EthernetType : uint8_t {
+enum EthernetType {
  ETHERNET_TYPE_UNKNOWN = 0,
  ETHERNET_TYPE_LAN8720,
  ETHERNET_TYPE_RTL8201,
@@ -42,7 +42,7 @@ struct PHYRegister {
  uint32_t page;
 };

-enum class EthernetComponentState : uint8_t {
+enum class EthernetComponentState {
  STOPPED,
  CONNECTING,
  CONNECTED,
@@ -119,31 +119,25 @@ class EthernetComponent : public Component {
  uint32_t polling_interval_{0};
 #endif
 #else
-  // Group all 32-bit members first
+  uint8_t phy_addr_{0};
  int power_pin_{-1};
+  uint8_t mdc_pin_{23};
+  uint8_t mdio_pin_{18};
  emac_rmii_clock_mode_t clk_mode_{EMAC_CLK_EXT_IN};
  emac_rmii_clock_gpio_t clk_gpio_{EMAC_CLK_IN_GPIO};
  std::vector<PHYRegister> phy_registers_{};
-
-  // Group all 8-bit members together
-  uint8_t phy_addr_{0};
-  uint8_t mdc_pin_{23};
-  uint8_t mdio_pin_{18};
 #endif
-  optional<ManualIP> manual_ip_{};
-  uint32_t connect_begin_;
-
-  // Group all uint8_t types together (enums and bools)
  EthernetType type_{ETHERNET_TYPE_UNKNOWN};
-  EthernetComponentState state_{EthernetComponentState::STOPPED};
+  optional<ManualIP> manual_ip_{};
+
  bool started_{false};
  bool connected_{false};
  bool got_ipv4_address_{false};
 #if LWIP_IPV6
  uint8_t ipv6_count_{0};
 #endif /* LWIP_IPV6 */
-
-  // Pointers at the end (naturally aligned)
+  EthernetComponentState state_{EthernetComponentState::STOPPED};
+  uint32_t connect_begin_;
  esp_netif_t *eth_netif_{nullptr};
  esp_eth_handle_t eth_handle_;
  esp_eth_phy_t *phy_{nullptr};
--- a/esphome/components/host/init.py
+++ b/esphome/components/host/init.py
@@ -41,6 +41,6 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
    cg.add_build_flag("-DUSE_HOST")
    cg.add_define("USE_ESPHOME_HOST_MAC_ADDRESS", config[CONF_MAC_ADDRESS].parts)
-    cg.add_build_flag("-std=gnu++20")
+    cg.add_build_flag("-std=gnu++17")
    cg.add_define("ESPHOME_BOARD", "host")
    cg.add_platformio_option("platform", "platformio/native")
--- a/esphome/components/http_request/ota/ota_http_request.cpp
+++ b/esphome/components/http_request/ota/ota_http_request.cpp
@@ -258,7 +258,7 @@ bool OtaHttpRequestComponent::http_get_md5_() {
 }

 bool OtaHttpRequestComponent::validate_url_(const std::string &url) {
-  if ((url.length() < 8) || !url.starts_with("http") || (url.find("://") == std::string::npos)) {
+  if ((url.length() < 8) || (url.find("http") != 0) || (url.find("://") == std::string::npos)) {
    ESP_LOGE(TAG, "URL is invalid and/or must be prefixed with 'http://' or 'https://'");
    return false;
  }
--- a/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
+++ b/esphome/components/hydreon_rgxx/hydreon_rgxx.cpp
@@ -159,6 +159,12 @@ void HydreonRGxxComponent::schedule_reboot_() {
  });
 }

+bool HydreonRGxxComponent::buffer_starts_with_(const std::string &prefix) {
+  return this->buffer_starts_with_(prefix.c_str());
+}
+
+bool HydreonRGxxComponent::buffer_starts_with_(const char *prefix) { return buffer_.rfind(prefix, 0) == 0; }
+
 void HydreonRGxxComponent::process_line_() {
  ESP_LOGV(TAG, "Read from serial: %s", this->buffer_.substr(0, this->buffer_.size() - 2).c_str());

@@ -185,7 +191,7 @@ void HydreonRGxxComponent::process_line_() {
    ESP_LOGW(TAG, "Received EmSat!");
    this->em_sat_ = true;
  }
-  if (buffer_.starts_with("PwrDays")) {
+  if (this->buffer_starts_with_("PwrDays")) {
    if (this->boot_count_ <= 0) {
      this->boot_count_ = 1;
    } else {
@@ -214,7 +220,7 @@ void HydreonRGxxComponent::process_line_() {
    }
    return;
  }
-  if (buffer_.starts_with("SW")) {
+  if (this->buffer_starts_with_("SW")) {
    std::string::size_type majend = this->buffer_.find('.');
    std::string::size_type endversion = this->buffer_.find(' ', 3);
    if (majend == std::string::npos || endversion == std::string::npos || majend > endversion) {
@@ -276,7 +282,7 @@ void HydreonRGxxComponent::process_line_() {
    }
  } else {
    for (const auto *ignore : IGNORE_STRINGS) {
-      if (buffer_.starts_with(ignore)) {
+      if (this->buffer_starts_with_(ignore)) {
        ESP_LOGI(TAG, "Ignoring %s", this->buffer_.substr(0, this->buffer_.size() - 2).c_str());
        return;
      }
--- a/esphome/components/i2c/init.py
+++ b/esphome/components/i2c/init.py
@@ -1,8 +1,5 @@
-import logging
-
 from esphome import pins
 import esphome.codegen as cg
-from esphome.components import esp32
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_ADDRESS,
@@ -15,8 +12,6 @@ from esphome.const import (
    CONF_SCL,
    CONF_SDA,
    CONF_TIMEOUT,
-    KEY_CORE,
-    KEY_FRAMEWORK_VERSION,
    PLATFORM_ESP32,
    PLATFORM_ESP8266,
    PLATFORM_RP2040,
@@ -24,7 +19,6 @@ from esphome.const import (
 from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv

-LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@esphome/core"]
 i2c_ns = cg.esphome_ns.namespace("i2c")
 I2CBus = i2c_ns.class_("I2CBus")
@@ -47,32 +41,6 @@ def _bus_declare_type(value):
    raise NotImplementedError


-def validate_config(config):
-    if (
-        config[CONF_SCAN]
-        and CORE.is_esp32
-        and CORE.using_esp_idf
-        and esp32.get_esp32_variant()
-        in [
-            esp32.const.VARIANT_ESP32C5,
-            esp32.const.VARIANT_ESP32C6,
-            esp32.const.VARIANT_ESP32P4,
-        ]
-    ):
-        version: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
-        if version.major == 5 and (
-            (version.minor == 3 and version.patch <= 3)
-            or (version.minor == 4 and version.patch <= 1)
-        ):
-            LOGGER.warning(
-                "There is a bug in esp-idf version %s that breaks I2C scan, I2C scan "
-                "has been disabled, see https://github.com/esphome/issues/issues/7128",
-                str(version),
-            )
-            config[CONF_SCAN] = False
-    return config
-
-
 pin_with_input_and_output_support = pins.internal_gpio_pin_number(
    {CONF_OUTPUT: True, CONF_INPUT: True}
 )
@@ -98,7 +66,6 @@ CONFIG_SCHEMA = cv.All(
        }
    ).extend(cv.COMPONENT_SCHEMA),
    cv.only_on([PLATFORM_ESP32, PLATFORM_ESP8266, PLATFORM_RP2040]),
-    validate_config,
 )


--- a/esphome/components/ld2410/ld2410.cpp
+++ b/esphome/components/ld2410/ld2410.cpp
@@ -10,7 +10,6 @@

 #include "esphome/core/application.h"

-#define CHECK_BIT(var, pos) (((var) >> (pos)) & 1)
 #define highbyte(val) (uint8_t)((val) >> 8)
 #define lowbyte(val) (uint8_t)((val) &0xff)

@@ -18,162 +17,8 @@ namespace esphome {
 namespace ld2410 {

 static const char *const TAG = "ld2410";
-static const char *const NO_MAC = "08:05:04:03:02:01";
-static const char *const UNKNOWN_MAC = "unknown";
-static const char *const VERSION_FMT = "%u.%02X.%02X%02X%02X%02X";

-enum BaudRateStructure : uint8_t {
-  BAUD_RATE_9600 = 1,
-  BAUD_RATE_19200 = 2,
-  BAUD_RATE_38400 = 3,
-  BAUD_RATE_57600 = 4,
-  BAUD_RATE_115200 = 5,
-  BAUD_RATE_230400 = 6,
-  BAUD_RATE_256000 = 7,
-  BAUD_RATE_460800 = 8,
-};
-
-enum DistanceResolutionStructure : uint8_t {
-  DISTANCE_RESOLUTION_0_2 = 0x01,
-  DISTANCE_RESOLUTION_0_75 = 0x00,
-};
-
-enum LightFunctionStructure : uint8_t {
-  LIGHT_FUNCTION_OFF = 0x00,
-  LIGHT_FUNCTION_BELOW = 0x01,
-  LIGHT_FUNCTION_ABOVE = 0x02,
-};
-
-enum OutPinLevelStructure : uint8_t {
-  OUT_PIN_LEVEL_LOW = 0x00,
-  OUT_PIN_LEVEL_HIGH = 0x01,
-};
-
-enum PeriodicDataStructure : uint8_t {
-  DATA_TYPES = 6,
-  TARGET_STATES = 8,
-  MOVING_TARGET_LOW = 9,
-  MOVING_TARGET_HIGH = 10,
-  MOVING_ENERGY = 11,
-  STILL_TARGET_LOW = 12,
-  STILL_TARGET_HIGH = 13,
-  STILL_ENERGY = 14,
-  DETECT_DISTANCE_LOW = 15,
-  DETECT_DISTANCE_HIGH = 16,
-  MOVING_SENSOR_START = 19,
-  STILL_SENSOR_START = 28,
-  LIGHT_SENSOR = 37,
-  OUT_PIN_SENSOR = 38,
-};
-
-enum PeriodicDataValue : uint8_t {
-  HEAD = 0xAA,
-  END = 0x55,
-  CHECK = 0x00,
-};
-
-enum AckDataStructure : uint8_t {
-  COMMAND = 6,
-  COMMAND_STATUS = 7,
-};
-
-// Memory-efficient lookup tables
-struct StringToUint8 {
-  const char *str;
-  uint8_t value;
-};
-
-struct Uint8ToString {
-  uint8_t value;
-  const char *str;
-};
-
-constexpr StringToUint8 BAUD_RATES_BY_STR[] = {
-    {"9600", BAUD_RATE_9600},     {"19200", BAUD_RATE_19200},   {"38400", BAUD_RATE_38400},
-    {"57600", BAUD_RATE_57600},   {"115200", BAUD_RATE_115200}, {"230400", BAUD_RATE_230400},
-    {"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800},
-};
-
-constexpr StringToUint8 DISTANCE_RESOLUTIONS_BY_STR[] = {
-    {"0.2m", DISTANCE_RESOLUTION_0_2},
-    {"0.75m", DISTANCE_RESOLUTION_0_75},
-};
-
-constexpr Uint8ToString DISTANCE_RESOLUTIONS_BY_UINT[] = {
-    {DISTANCE_RESOLUTION_0_2, "0.2m"},
-    {DISTANCE_RESOLUTION_0_75, "0.75m"},
-};
-
-constexpr StringToUint8 LIGHT_FUNCTIONS_BY_STR[] = {
-    {"off", LIGHT_FUNCTION_OFF},
-    {"below", LIGHT_FUNCTION_BELOW},
-    {"above", LIGHT_FUNCTION_ABOVE},
-};
-
-constexpr Uint8ToString LIGHT_FUNCTIONS_BY_UINT[] = {
-    {LIGHT_FUNCTION_OFF, "off"},
-    {LIGHT_FUNCTION_BELOW, "below"},
-    {LIGHT_FUNCTION_ABOVE, "above"},
-};
-
-constexpr StringToUint8 OUT_PIN_LEVELS_BY_STR[] = {
-    {"low", OUT_PIN_LEVEL_LOW},
-    {"high", OUT_PIN_LEVEL_HIGH},
-};
-
-constexpr Uint8ToString OUT_PIN_LEVELS_BY_UINT[] = {
-    {OUT_PIN_LEVEL_LOW, "low"},
-    {OUT_PIN_LEVEL_HIGH, "high"},
-};
-
-// Helper functions for lookups
-template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const std::string &str) {
-  for (const auto &entry : arr) {
-    if (str == entry.str)
-      return entry.value;
-  }
-  return 0xFF;  // Not found
-}
-
-template<size_t N> const char *find_str(const Uint8ToString (&arr)[N], uint8_t value) {
-  for (const auto &entry : arr) {
-    if (value == entry.value)
-      return entry.str;
-  }
-  return "";  // Not found
-}
-
-// Commands
-static const uint8_t CMD_ENABLE_CONF = 0xFF;
-static const uint8_t CMD_DISABLE_CONF = 0xFE;
-static const uint8_t CMD_ENABLE_ENG = 0x62;
-static const uint8_t CMD_DISABLE_ENG = 0x63;
-static const uint8_t CMD_MAXDIST_DURATION = 0x60;
-static const uint8_t CMD_QUERY = 0x61;
-static const uint8_t CMD_GATE_SENS = 0x64;
-static const uint8_t CMD_VERSION = 0xA0;
-static const uint8_t CMD_QUERY_DISTANCE_RESOLUTION = 0xAB;
-static const uint8_t CMD_SET_DISTANCE_RESOLUTION = 0xAA;
-static const uint8_t CMD_QUERY_LIGHT_CONTROL = 0xAE;
-static const uint8_t CMD_SET_LIGHT_CONTROL = 0xAD;
-static const uint8_t CMD_SET_BAUD_RATE = 0xA1;
-static const uint8_t CMD_BT_PASSWORD = 0xA9;
-static const uint8_t CMD_MAC = 0xA5;
-static const uint8_t CMD_RESET = 0xA2;
-static const uint8_t CMD_RESTART = 0xA3;
-static const uint8_t CMD_BLUETOOTH = 0xA4;
-// Commands values
-static const uint8_t CMD_MAX_MOVE_VALUE = 0x00;
-static const uint8_t CMD_MAX_STILL_VALUE = 0x01;
-static const uint8_t CMD_DURATION_VALUE = 0x02;
-// Command Header & Footer
-static const uint8_t CMD_FRAME_HEADER[4] = {0xFD, 0xFC, 0xFB, 0xFA};
-static const uint8_t CMD_FRAME_END[4] = {0x04, 0x03, 0x02, 0x01};
-// Data Header & Footer
-static const uint8_t DATA_FRAME_HEADER[4] = {0xF4, 0xF3, 0xF2, 0xF1};
-static const uint8_t DATA_FRAME_END[4] = {0xF8, 0xF7, 0xF6, 0xF5};
-
-static inline int two_byte_to_int(char firstbyte, char secondbyte) { return (int16_t) (secondbyte << 8) + firstbyte; }
+LD2410Component::LD2410Component() {}

 void LD2410Component::dump_config() {
  ESP_LOGCONFIG(TAG, "LD2410:");
@@ -233,7 +78,7 @@ void LD2410Component::dump_config() {
                "  Throttle: %ums\n"
                "  MAC address: %s\n"
                "  Firmware version: %s",
-                this->throttle_, this->mac_ == NO_MAC ? UNKNOWN_MAC : this->mac_.c_str(), this->version_.c_str());
+                this->throttle_, const_cast<char *>(this->mac_.c_str()), const_cast<char *>(this->version_.c_str()));
 }

 void LD2410Component::setup() {
@@ -355,7 +200,7 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
  */
 #ifdef USE_SENSOR
  if (this->moving_target_distance_sensor_ != nullptr) {
-    int new_moving_target_distance = ld2410::two_byte_to_int(buffer[MOVING_TARGET_LOW], buffer[MOVING_TARGET_HIGH]);
+    int new_moving_target_distance = this->two_byte_to_int_(buffer[MOVING_TARGET_LOW], buffer[MOVING_TARGET_HIGH]);
    if (this->moving_target_distance_sensor_->get_state() != new_moving_target_distance)
      this->moving_target_distance_sensor_->publish_state(new_moving_target_distance);
  }
@@ -365,7 +210,7 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
      this->moving_target_energy_sensor_->publish_state(new_moving_target_energy);
  }
  if (this->still_target_distance_sensor_ != nullptr) {
-    int new_still_target_distance = ld2410::two_byte_to_int(buffer[STILL_TARGET_LOW], buffer[STILL_TARGET_HIGH]);
+    int new_still_target_distance = this->two_byte_to_int_(buffer[STILL_TARGET_LOW], buffer[STILL_TARGET_HIGH]);
    if (this->still_target_distance_sensor_->get_state() != new_still_target_distance)
      this->still_target_distance_sensor_->publish_state(new_still_target_distance);
  }
@@ -375,7 +220,7 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
      this->still_target_energy_sensor_->publish_state(new_still_target_energy);
  }
  if (this->detection_distance_sensor_ != nullptr) {
-    int new_detect_distance = ld2410::two_byte_to_int(buffer[DETECT_DISTANCE_LOW], buffer[DETECT_DISTANCE_HIGH]);
+    int new_detect_distance = this->two_byte_to_int_(buffer[DETECT_DISTANCE_LOW], buffer[DETECT_DISTANCE_HIGH]);
    if (this->detection_distance_sensor_->get_state() != new_detect_distance)
      this->detection_distance_sensor_->publish_state(new_detect_distance);
  }
@@ -437,6 +282,25 @@ void LD2410Component::handle_periodic_data_(uint8_t *buffer, int len) {
 #endif
 }

+const char VERSION_FMT[] = "%u.%02X.%02X%02X%02X%02X";
+
+std::string format_version(uint8_t *buffer) {
+  std::string::size_type version_size = 256;
+  std::string version;
+  do {
+    version.resize(version_size + 1);
+    version_size = std::snprintf(&version[0], version.size(), VERSION_FMT, buffer[13], buffer[12], buffer[17],
+                                 buffer[16], buffer[15], buffer[14]);
+  } while (version_size + 1 > version.size());
+  version.resize(version_size);
+  return version;
+}
+
+const char MAC_FMT[] = "%02X:%02X:%02X:%02X:%02X:%02X";
+
+const std::string UNKNOWN_MAC("unknown");
+const std::string NO_MAC("08:05:04:03:02:01");
+
 #ifdef USE_NUMBER
 std::function<void(void)> set_number_value(number::Number *n, float value) {
  float normalized_value = value * 1.0;
@@ -462,7 +326,7 @@ bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
    ESP_LOGE(TAG, "Invalid status");
    return true;
  }
-  if (ld2410::two_byte_to_int(buffer[8], buffer[9]) != 0x00) {
+  if (this->two_byte_to_int_(buffer[8], buffer[9]) != 0x00) {
    ESP_LOGE(TAG, "Invalid command: %u, %u", buffer[8], buffer[9]);
    return true;
  }
@@ -483,8 +347,8 @@ bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
 #endif
      break;
    case lowbyte(CMD_VERSION):
-      this->version_ = str_sprintf(VERSION_FMT, buffer[13], buffer[12], buffer[17], buffer[16], buffer[15], buffer[14]);
-      ESP_LOGV(TAG, "Firmware version: %s", this->version_.c_str());
+      this->version_ = format_version(buffer);
+      ESP_LOGV(TAG, "Firmware version: %s", const_cast<char *>(this->version_.c_str()));
 #ifdef USE_TEXT_SENSOR
      if (this->version_text_sensor_ != nullptr) {
        this->version_text_sensor_->publish_state(this->version_);
@@ -493,8 +357,8 @@ bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
      break;
    case lowbyte(CMD_QUERY_DISTANCE_RESOLUTION): {
      std::string distance_resolution =
-          find_str(DISTANCE_RESOLUTIONS_BY_UINT, ld2410::two_byte_to_int(buffer[10], buffer[11]));
-      ESP_LOGV(TAG, "Distance resolution: %s", distance_resolution.c_str());
+          DISTANCE_RESOLUTION_INT_TO_ENUM.at(this->two_byte_to_int_(buffer[10], buffer[11]));
+      ESP_LOGV(TAG, "Distance resolution: %s", const_cast<char *>(distance_resolution.c_str()));
 #ifdef USE_SELECT
      if (this->distance_resolution_select_ != nullptr &&
          this->distance_resolution_select_->state != distance_resolution) {
@@ -503,9 +367,9 @@ bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
 #endif
    } break;
    case lowbyte(CMD_QUERY_LIGHT_CONTROL): {
-      this->light_function_ = find_str(LIGHT_FUNCTIONS_BY_UINT, buffer[10]);
+      this->light_function_ = LIGHT_FUNCTION_INT_TO_ENUM.at(buffer[10]);
      this->light_threshold_ = buffer[11] * 1.0;
-      this->out_pin_level_ = find_str(OUT_PIN_LEVELS_BY_UINT, buffer[12]);
+      this->out_pin_level_ = OUT_PIN_LEVEL_INT_TO_ENUM.at(buffer[12]);
      ESP_LOGV(TAG, "Light function: %s", const_cast<char *>(this->light_function_.c_str()));
      ESP_LOGV(TAG, "Light threshold: %f", this->light_threshold_);
      ESP_LOGV(TAG, "Out pin level: %s", const_cast<char *>(this->out_pin_level_.c_str()));
@@ -538,7 +402,7 @@ bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
 #endif
 #ifdef USE_SWITCH
      if (this->bluetooth_switch_ != nullptr) {
-        this->bluetooth_switch_->publish_state(this->mac_ != NO_MAC);
+        this->bluetooth_switch_->publish_state(this->mac_ != UNKNOWN_MAC);
      }
 #endif
      break;
@@ -584,7 +448,7 @@ bool LD2410Component::handle_ack_data_(uint8_t *buffer, int len) {
      /*
        None Duration: 33~34th bytes
      */
-      updates.push_back(set_number_value(this->timeout_number_, ld2410::two_byte_to_int(buffer[32], buffer[33])));
+      updates.push_back(set_number_value(this->timeout_number_, this->two_byte_to_int_(buffer[32], buffer[33])));
      for (auto &update : updates) {
        update();
      }
@@ -641,14 +505,14 @@ void LD2410Component::set_bluetooth(bool enable) {

 void LD2410Component::set_distance_resolution(const std::string &state) {
  this->set_config_mode_(true);
-  uint8_t cmd_value[2] = {find_uint8(DISTANCE_RESOLUTIONS_BY_STR, state), 0x00};
+  uint8_t cmd_value[2] = {DISTANCE_RESOLUTION_ENUM_TO_INT.at(state), 0x00};
  this->send_command_(CMD_SET_DISTANCE_RESOLUTION, cmd_value, 2);
  this->set_timeout(200, [this]() { this->restart_and_read_all_info(); });
 }

 void LD2410Component::set_baud_rate(const std::string &state) {
  this->set_config_mode_(true);
-  uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
+  uint8_t cmd_value[2] = {BAUD_RATE_ENUM_TO_INT.at(state), 0x00};
  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, 2);
  this->set_timeout(200, [this]() { this->restart_(); });
 }
@@ -782,9 +646,9 @@ void LD2410Component::set_light_out_control() {
    return;
  }
  this->set_config_mode_(true);
-  uint8_t light_function = find_uint8(LIGHT_FUNCTIONS_BY_STR, this->light_function_);
+  uint8_t light_function = LIGHT_FUNCTION_ENUM_TO_INT.at(this->light_function_);
  uint8_t light_threshold = static_cast<uint8_t>(this->light_threshold_);
-  uint8_t out_pin_level = find_uint8(OUT_PIN_LEVELS_BY_STR, this->out_pin_level_);
+  uint8_t out_pin_level = OUT_PIN_LEVEL_ENUM_TO_INT.at(this->out_pin_level_);
  uint8_t value[4] = {light_function, light_threshold, out_pin_level, 0x00};
  this->send_command_(CMD_SET_LIGHT_CONTROL, value, 4);
  delay(50);  // NOLINT
--- a/esphome/components/ld2410/ld2410.h
+++ b/esphome/components/ld2410/ld2410.h
@@ -26,9 +26,114 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"

+#include <map>
+
 namespace esphome {
 namespace ld2410 {

+#define CHECK_BIT(var, pos) (((var) >> (pos)) & 1)
+
+// Commands
+static const uint8_t CMD_ENABLE_CONF = 0x00FF;
+static const uint8_t CMD_DISABLE_CONF = 0x00FE;
+static const uint8_t CMD_ENABLE_ENG = 0x0062;
+static const uint8_t CMD_DISABLE_ENG = 0x0063;
+static const uint8_t CMD_MAXDIST_DURATION = 0x0060;
+static const uint8_t CMD_QUERY = 0x0061;
+static const uint8_t CMD_GATE_SENS = 0x0064;
+static const uint8_t CMD_VERSION = 0x00A0;
+static const uint8_t CMD_QUERY_DISTANCE_RESOLUTION = 0x00AB;
+static const uint8_t CMD_SET_DISTANCE_RESOLUTION = 0x00AA;
+static const uint8_t CMD_QUERY_LIGHT_CONTROL = 0x00AE;
+static const uint8_t CMD_SET_LIGHT_CONTROL = 0x00AD;
+static const uint8_t CMD_SET_BAUD_RATE = 0x00A1;
+static const uint8_t CMD_BT_PASSWORD = 0x00A9;
+static const uint8_t CMD_MAC = 0x00A5;
+static const uint8_t CMD_RESET = 0x00A2;
+static const uint8_t CMD_RESTART = 0x00A3;
+static const uint8_t CMD_BLUETOOTH = 0x00A4;
+
+enum BaudRateStructure : uint8_t {
+  BAUD_RATE_9600 = 1,
+  BAUD_RATE_19200 = 2,
+  BAUD_RATE_38400 = 3,
+  BAUD_RATE_57600 = 4,
+  BAUD_RATE_115200 = 5,
+  BAUD_RATE_230400 = 6,
+  BAUD_RATE_256000 = 7,
+  BAUD_RATE_460800 = 8
+};
+
+static const std::map<std::string, uint8_t> BAUD_RATE_ENUM_TO_INT{
+    {"9600", BAUD_RATE_9600},     {"19200", BAUD_RATE_19200},   {"38400", BAUD_RATE_38400},
+    {"57600", BAUD_RATE_57600},   {"115200", BAUD_RATE_115200}, {"230400", BAUD_RATE_230400},
+    {"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800}};
+
+enum DistanceResolutionStructure : uint8_t { DISTANCE_RESOLUTION_0_2 = 0x01, DISTANCE_RESOLUTION_0_75 = 0x00 };
+
+static const std::map<std::string, uint8_t> DISTANCE_RESOLUTION_ENUM_TO_INT{{"0.2m", DISTANCE_RESOLUTION_0_2},
+                                                                            {"0.75m", DISTANCE_RESOLUTION_0_75}};
+static const std::map<uint8_t, std::string> DISTANCE_RESOLUTION_INT_TO_ENUM{{DISTANCE_RESOLUTION_0_2, "0.2m"},
+                                                                            {DISTANCE_RESOLUTION_0_75, "0.75m"}};
+
+enum LightFunctionStructure : uint8_t {
+  LIGHT_FUNCTION_OFF = 0x00,
+  LIGHT_FUNCTION_BELOW = 0x01,
+  LIGHT_FUNCTION_ABOVE = 0x02
+};
+
+static const std::map<std::string, uint8_t> LIGHT_FUNCTION_ENUM_TO_INT{
+    {"off", LIGHT_FUNCTION_OFF}, {"below", LIGHT_FUNCTION_BELOW}, {"above", LIGHT_FUNCTION_ABOVE}};
+static const std::map<uint8_t, std::string> LIGHT_FUNCTION_INT_TO_ENUM{
+    {LIGHT_FUNCTION_OFF, "off"}, {LIGHT_FUNCTION_BELOW, "below"}, {LIGHT_FUNCTION_ABOVE, "above"}};
+
+enum OutPinLevelStructure : uint8_t { OUT_PIN_LEVEL_LOW = 0x00, OUT_PIN_LEVEL_HIGH = 0x01 };
+
+static const std::map<std::string, uint8_t> OUT_PIN_LEVEL_ENUM_TO_INT{{"low", OUT_PIN_LEVEL_LOW},
+                                                                      {"high", OUT_PIN_LEVEL_HIGH}};
+static const std::map<uint8_t, std::string> OUT_PIN_LEVEL_INT_TO_ENUM{{OUT_PIN_LEVEL_LOW, "low"},
+                                                                      {OUT_PIN_LEVEL_HIGH, "high"}};
+
+// Commands values
+static const uint8_t CMD_MAX_MOVE_VALUE = 0x0000;
+static const uint8_t CMD_MAX_STILL_VALUE = 0x0001;
+static const uint8_t CMD_DURATION_VALUE = 0x0002;
+// Command Header & Footer
+static const uint8_t CMD_FRAME_HEADER[4] = {0xFD, 0xFC, 0xFB, 0xFA};
+static const uint8_t CMD_FRAME_END[4] = {0x04, 0x03, 0x02, 0x01};
+// Data Header & Footer
+static const uint8_t DATA_FRAME_HEADER[4] = {0xF4, 0xF3, 0xF2, 0xF1};
+static const uint8_t DATA_FRAME_END[4] = {0xF8, 0xF7, 0xF6, 0xF5};
+/*
+Data Type: 6th byte
+Target states: 9th byte
+    Moving target distance: 10~11th bytes
+    Moving target energy: 12th byte
+    Still target distance: 13~14th bytes
+    Still target energy: 15th byte
+    Detect distance: 16~17th bytes
+*/
+enum PeriodicDataStructure : uint8_t {
+  DATA_TYPES = 6,
+  TARGET_STATES = 8,
+  MOVING_TARGET_LOW = 9,
+  MOVING_TARGET_HIGH = 10,
+  MOVING_ENERGY = 11,
+  STILL_TARGET_LOW = 12,
+  STILL_TARGET_HIGH = 13,
+  STILL_ENERGY = 14,
+  DETECT_DISTANCE_LOW = 15,
+  DETECT_DISTANCE_HIGH = 16,
+  MOVING_SENSOR_START = 19,
+  STILL_SENSOR_START = 28,
+  LIGHT_SENSOR = 37,
+  OUT_PIN_SENSOR = 38,
+};
+enum PeriodicDataValue : uint8_t { HEAD = 0xAA, END = 0x55, CHECK = 0x00 };
+
+enum AckDataStructure : uint8_t { COMMAND = 6, COMMAND_STATUS = 7 };
+
+//  char cmd[2] = {enable ? 0xFF : 0xFE, 0x00};
 class LD2410Component : public Component, public uart::UARTDevice {
 #ifdef USE_SENSOR
  SUB_SENSOR(moving_target_distance)
@@ -71,6 +176,7 @@ class LD2410Component : public Component, public uart::UARTDevice {
 #endif

 public:
+  LD2410Component();
  void setup() override;
  void dump_config() override;
  void loop() override;
@@ -96,6 +202,7 @@ class LD2410Component : public Component, public uart::UARTDevice {
  void factory_reset();

 protected:
+  int two_byte_to_int_(char firstbyte, char secondbyte) { return (int16_t) (secondbyte << 8) + firstbyte; }
  void send_command_(uint8_t command_str, const uint8_t *command_value, int command_value_len);
  void set_config_mode_(bool enable);
  void handle_periodic_data_(uint8_t *buffer, int len);
@@ -108,14 +215,14 @@ class LD2410Component : public Component, public uart::UARTDevice {
  void get_light_control_();
  void restart_();

-  int32_t last_periodic_millis_ = 0;
-  int32_t last_engineering_mode_change_millis_ = 0;
+  int32_t last_periodic_millis_ = millis();
+  int32_t last_engineering_mode_change_millis_ = millis();
  uint16_t throttle_;
-  float light_threshold_ = -1;
  std::string version_;
  std::string mac_;
  std::string out_pin_level_;
  std::string light_function_;
+  float light_threshold_ = -1;
 #ifdef USE_NUMBER
  std::vector<number::Number *> gate_still_threshold_numbers_ = std::vector<number::Number *>(9);
  std::vector<number::Number *> gate_move_threshold_numbers_ = std::vector<number::Number *>(9);
--- a/esphome/components/ld2450/ld2450.cpp
+++ b/esphome/components/ld2450/ld2450.cpp
@@ -17,109 +17,23 @@ namespace esphome {
 namespace ld2450 {

 static const char *const TAG = "ld2450";
-static const char *const NO_MAC = "08:05:04:03:02:01";
-static const char *const UNKNOWN_MAC = "unknown";
-static const char *const VERSION_FMT = "%u.%02X.%02X%02X%02X%02X";
+static const char *const NO_MAC("08:05:04:03:02:01");
+static const char *const UNKNOWN_MAC("unknown");

-enum BaudRateStructure : uint8_t {
-  BAUD_RATE_9600 = 1,
-  BAUD_RATE_19200 = 2,
-  BAUD_RATE_38400 = 3,
-  BAUD_RATE_57600 = 4,
-  BAUD_RATE_115200 = 5,
-  BAUD_RATE_230400 = 6,
-  BAUD_RATE_256000 = 7,
-  BAUD_RATE_460800 = 8
-};
-
-// Zone type struct
-enum ZoneTypeStructure : uint8_t {
-  ZONE_DISABLED = 0,
-  ZONE_DETECTION = 1,
-  ZONE_FILTER = 2,
-};
-
-enum PeriodicDataStructure : uint8_t {
-  TARGET_X = 4,
-  TARGET_Y = 6,
-  TARGET_SPEED = 8,
-  TARGET_RESOLUTION = 10,
-};
-
-enum PeriodicDataValue : uint8_t {
-  HEAD = 0xAA,
-  END = 0x55,
-  CHECK = 0x00,
-};
-
-enum AckDataStructure : uint8_t {
-  COMMAND = 6,
-  COMMAND_STATUS = 7,
-};
-
-// Memory-efficient lookup tables
-struct StringToUint8 {
-  const char *str;
-  uint8_t value;
-};
-
-struct Uint8ToString {
-  uint8_t value;
-  const char *str;
-};
-
-constexpr StringToUint8 BAUD_RATES_BY_STR[] = {
-    {"9600", BAUD_RATE_9600},     {"19200", BAUD_RATE_19200},   {"38400", BAUD_RATE_38400},
-    {"57600", BAUD_RATE_57600},   {"115200", BAUD_RATE_115200}, {"230400", BAUD_RATE_230400},
-    {"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800},
-};
-
-constexpr Uint8ToString ZONE_TYPE_BY_UINT[] = {
-    {ZONE_DISABLED, "Disabled"},
-    {ZONE_DETECTION, "Detection"},
-    {ZONE_FILTER, "Filter"},
-};
-
-constexpr StringToUint8 ZONE_TYPE_BY_STR[] = {
-    {"Disabled", ZONE_DISABLED},
-    {"Detection", ZONE_DETECTION},
-    {"Filter", ZONE_FILTER},
-};
-
-// Helper functions for lookups
-template<size_t N> uint8_t find_uint8(const StringToUint8 (&arr)[N], const std::string &str) {
-  for (const auto &entry : arr) {
-    if (str == entry.str)
-      return entry.value;
-  }
-  return 0xFF;  // Not found
-}
-
-template<size_t N> const char *find_str(const Uint8ToString (&arr)[N], uint8_t value) {
-  for (const auto &entry : arr) {
-    if (value == entry.value)
-      return entry.str;
-  }
-  return "";  // Not found
-}
-
-// LD2450 serial command header & footer
-static const uint8_t CMD_FRAME_HEADER[4] = {0xFD, 0xFC, 0xFB, 0xFA};
-static const uint8_t CMD_FRAME_END[4] = {0x04, 0x03, 0x02, 0x01};
 // LD2450 UART Serial Commands
-static const uint8_t CMD_ENABLE_CONF = 0xFF;
-static const uint8_t CMD_DISABLE_CONF = 0xFE;
-static const uint8_t CMD_VERSION = 0xA0;
-static const uint8_t CMD_MAC = 0xA5;
-static const uint8_t CMD_RESET = 0xA2;
-static const uint8_t CMD_RESTART = 0xA3;
-static const uint8_t CMD_BLUETOOTH = 0xA4;
-static const uint8_t CMD_SINGLE_TARGET_MODE = 0x80;
-static const uint8_t CMD_MULTI_TARGET_MODE = 0x90;
-static const uint8_t CMD_QUERY_TARGET_MODE = 0x91;
-static const uint8_t CMD_SET_BAUD_RATE = 0xA1;
-static const uint8_t CMD_QUERY_ZONE = 0xC1;
-static const uint8_t CMD_SET_ZONE = 0xC2;
+static const uint8_t CMD_ENABLE_CONF = 0x00FF;
+static const uint8_t CMD_DISABLE_CONF = 0x00FE;
+static const uint8_t CMD_VERSION = 0x00A0;
+static const uint8_t CMD_MAC = 0x00A5;
+static const uint8_t CMD_RESET = 0x00A2;
+static const uint8_t CMD_RESTART = 0x00A3;
+static const uint8_t CMD_BLUETOOTH = 0x00A4;
+static const uint8_t CMD_SINGLE_TARGET_MODE = 0x0080;
+static const uint8_t CMD_MULTI_TARGET_MODE = 0x0090;
+static const uint8_t CMD_QUERY_TARGET_MODE = 0x0091;
+static const uint8_t CMD_SET_BAUD_RATE = 0x00A1;
+static const uint8_t CMD_QUERY_ZONE = 0x00C1;
+static const uint8_t CMD_SET_ZONE = 0x00C2;

 static inline uint16_t convert_seconds_to_ms(uint16_t value) { return value * 1000; };

@@ -184,6 +98,13 @@ static inline std::string get_direction(int16_t speed) {
  return STATIONARY;
 }

+static inline std::string format_version(uint8_t *buffer) {
+  return str_sprintf("%u.%02X.%02X%02X%02X%02X", buffer[13], buffer[12], buffer[17], buffer[16], buffer[15],
+                     buffer[14]);
+}
+
+LD2450Component::LD2450Component() {}
+
 void LD2450Component::setup() {
  ESP_LOGCONFIG(TAG, "Running setup");
 #ifdef USE_NUMBER
@@ -268,7 +189,7 @@ void LD2450Component::dump_config() {
                "  Throttle: %ums\n"
                "  MAC Address: %s\n"
                "  Firmware version: %s",
-                this->throttle_, this->mac_ == NO_MAC ? UNKNOWN_MAC : this->mac_.c_str(), this->version_.c_str());
+                this->throttle_, const_cast<char *>(this->mac_.c_str()), const_cast<char *>(this->version_.c_str()));
 }

 void LD2450Component::loop() {
@@ -675,7 +596,7 @@ bool LD2450Component::handle_ack_data_(uint8_t *buffer, uint8_t len) {
 #endif
      break;
    case lowbyte(CMD_VERSION):
-      this->version_ = str_sprintf(VERSION_FMT, buffer[13], buffer[12], buffer[17], buffer[16], buffer[15], buffer[14]);
+      this->version_ = ld2450::format_version(buffer);
      ESP_LOGV(TAG, "Firmware version: %s", this->version_.c_str());
 #ifdef USE_TEXT_SENSOR
      if (this->version_text_sensor_ != nullptr) {
@@ -696,7 +617,7 @@ bool LD2450Component::handle_ack_data_(uint8_t *buffer, uint8_t len) {
 #endif
 #ifdef USE_SWITCH
      if (this->bluetooth_switch_ != nullptr) {
-        this->bluetooth_switch_->publish_state(this->mac_ != NO_MAC);
+        this->bluetooth_switch_->publish_state(this->mac_ != UNKNOWN_MAC);
      }
 #endif
      break;
@@ -805,7 +726,7 @@ void LD2450Component::set_bluetooth(bool enable) {
 // Set Baud rate
 void LD2450Component::set_baud_rate(const std::string &state) {
  this->set_config_mode_(true);
-  uint8_t cmd_value[2] = {find_uint8(BAUD_RATES_BY_STR, state), 0x00};
+  uint8_t cmd_value[2] = {BAUD_RATE_ENUM_TO_INT.at(state), 0x00};
  this->send_command_(CMD_SET_BAUD_RATE, cmd_value, 2);
  this->set_timeout(200, [this]() { this->restart_(); });
 }
@@ -813,7 +734,7 @@ void LD2450Component::set_baud_rate(const std::string &state) {
 // Set Zone Type - one of: Disabled, Detection, Filter
 void LD2450Component::set_zone_type(const std::string &state) {
  ESP_LOGV(TAG, "Set zone type: %s", state.c_str());
-  uint8_t zone_type = find_uint8(ZONE_TYPE_BY_STR, state);
+  uint8_t zone_type = ZONE_TYPE_ENUM_TO_INT.at(state);
  this->zone_type_ = zone_type;
  this->send_set_zone_command_();
 }
@@ -821,7 +742,7 @@ void LD2450Component::set_zone_type(const std::string &state) {
 // Publish Zone Type to Select component
 void LD2450Component::publish_zone_type() {
 #ifdef USE_SELECT
-  std::string zone_type = find_str(ZONE_TYPE_BY_UINT, this->zone_type_);
+  std::string zone_type = ZONE_TYPE_INT_TO_ENUM.at(static_cast<ZoneTypeStructure>(this->zone_type_));
  if (this->zone_type_select_ != nullptr) {
    this->zone_type_select_->publish_state(zone_type);
  }
--- a/esphome/components/ld2450/ld2450.h
+++ b/esphome/components/ld2450/ld2450.h
@@ -1,5 +1,7 @@
 #pragma once

+#include <iomanip>
+#include <map>
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
@@ -64,6 +66,49 @@ struct ZoneOfNumbers {
 };
 #endif

+enum BaudRateStructure : uint8_t {
+  BAUD_RATE_9600 = 1,
+  BAUD_RATE_19200 = 2,
+  BAUD_RATE_38400 = 3,
+  BAUD_RATE_57600 = 4,
+  BAUD_RATE_115200 = 5,
+  BAUD_RATE_230400 = 6,
+  BAUD_RATE_256000 = 7,
+  BAUD_RATE_460800 = 8
+};
+
+// Convert baud rate enum to int
+static const std::map<std::string, uint8_t> BAUD_RATE_ENUM_TO_INT{
+    {"9600", BAUD_RATE_9600},     {"19200", BAUD_RATE_19200},   {"38400", BAUD_RATE_38400},
+    {"57600", BAUD_RATE_57600},   {"115200", BAUD_RATE_115200}, {"230400", BAUD_RATE_230400},
+    {"256000", BAUD_RATE_256000}, {"460800", BAUD_RATE_460800}};
+
+// Zone type struct
+enum ZoneTypeStructure : uint8_t { ZONE_DISABLED = 0, ZONE_DETECTION = 1, ZONE_FILTER = 2 };
+
+// Convert zone type int to enum
+static const std::map<ZoneTypeStructure, std::string> ZONE_TYPE_INT_TO_ENUM{
+    {ZONE_DISABLED, "Disabled"}, {ZONE_DETECTION, "Detection"}, {ZONE_FILTER, "Filter"}};
+
+// Convert zone type enum to int
+static const std::map<std::string, uint8_t> ZONE_TYPE_ENUM_TO_INT{
+    {"Disabled", ZONE_DISABLED}, {"Detection", ZONE_DETECTION}, {"Filter", ZONE_FILTER}};
+
+// LD2450 serial command header & footer
+static const uint8_t CMD_FRAME_HEADER[4] = {0xFD, 0xFC, 0xFB, 0xFA};
+static const uint8_t CMD_FRAME_END[4] = {0x04, 0x03, 0x02, 0x01};
+
+enum PeriodicDataStructure : uint8_t {
+  TARGET_X = 4,
+  TARGET_Y = 6,
+  TARGET_SPEED = 8,
+  TARGET_RESOLUTION = 10,
+};
+
+enum PeriodicDataValue : uint8_t { HEAD = 0xAA, END = 0x55, CHECK = 0x00 };
+
+enum AckDataStructure : uint8_t { COMMAND = 6, COMMAND_STATUS = 7 };
+
 class LD2450Component : public Component, public uart::UARTDevice {
 #ifdef USE_SENSOR
  SUB_SENSOR(target_count)
@@ -96,6 +141,7 @@ class LD2450Component : public Component, public uart::UARTDevice {
 #endif

 public:
+  LD2450Component();
  void setup() override;
  void dump_config() override;
  void loop() override;
@@ -151,17 +197,17 @@ class LD2450Component : public Component, public uart::UARTDevice {
  bool get_timeout_status_(uint32_t check_millis);
  uint8_t count_targets_in_zone_(const Zone &zone, bool is_moving);

+  Target target_info_[MAX_TARGETS];
+  Zone zone_config_[MAX_ZONES];
+  uint8_t buffer_pos_ = 0;  // where to resume processing/populating buffer
+  uint8_t buffer_data_[MAX_LINE_LENGTH];
  uint32_t last_periodic_millis_ = 0;
  uint32_t presence_millis_ = 0;
  uint32_t still_presence_millis_ = 0;
  uint32_t moving_presence_millis_ = 0;
  uint16_t throttle_ = 0;
  uint16_t timeout_ = 5;
-  uint8_t buffer_pos_ = 0;  // where to resume processing/populating buffer
-  uint8_t buffer_data_[MAX_LINE_LENGTH];
  uint8_t zone_type_ = 0;
-  Target target_info_[MAX_TARGETS];
-  Zone zone_config_[MAX_ZONES];
  std::string version_{};
  std::string mac_{};
 #ifdef USE_NUMBER
--- a/esphome/components/libretiny/init.py
+++ b/esphome/components/libretiny/init.py
@@ -264,7 +264,7 @@ async def component_to_code(config):
    # force using arduino framework
    cg.add_platformio_option("framework", "arduino")
    cg.add_build_flag("-DUSE_ARDUINO")
-    cg.set_cpp_standard("gnu++20")
+    cg.set_cpp_standard("gnu++17")

    # disable library compatibility checks
    cg.add_platformio_option("lib_ldf_mode", "off")
--- a/esphome/components/libretiny/lt_component.cpp
+++ b/esphome/components/libretiny/lt_component.cpp
@@ -10,11 +10,9 @@ namespace libretiny {
 static const char *const TAG = "lt.component";

 void LTComponent::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "LibreTiny:\n"
-                "  Version: %s\n"
-                "  Loglevel: %u",
-                LT_BANNER_STR + 10, LT_LOGLEVEL);
+  ESP_LOGCONFIG(TAG, "LibreTiny:");
+  ESP_LOGCONFIG(TAG, "  Version: %s", LT_BANNER_STR + 10);
+  ESP_LOGCONFIG(TAG, "  Loglevel: %u", LT_LOGLEVEL);

 #ifdef USE_TEXT_SENSOR
  if (this->version_ != nullptr) {
--- a/esphome/components/mcp23xxx_base/mcp23xxx_base.cpp
+++ b/esphome/components/mcp23xxx_base/mcp23xxx_base.cpp
@@ -6,11 +6,7 @@ namespace mcp23xxx_base {

 float MCP23XXXBase::get_setup_priority() const { return setup_priority::IO; }

-void MCP23XXXGPIOPin::setup() {
-  pin_mode(flags_);
-  this->parent_->pin_interrupt_mode(this->pin_, this->interrupt_mode_);
-}
-
+void MCP23XXXGPIOPin::setup() { pin_mode(flags_); }
 void MCP23XXXGPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
 bool MCP23XXXGPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void MCP23XXXGPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
--- a/esphome/components/mdns/init.py
+++ b/esphome/components/mdns/init.py
@@ -88,7 +88,12 @@ async def to_code(config):
    if CORE.using_esp_idf and CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] >= cv.Version(
        5, 0, 0
    ):
-        add_idf_component(name="espressif/mdns", ref="1.8.2")
+        add_idf_component(
+            name="mdns",
+            repo="https://github.com/espressif/esp-protocols.git",
+            ref="mdns-v1.8.2",
+            path="components/mdns",
+        )

    cg.add_define("USE_MDNS")

--- a/esphome/components/micro_wake_word/init.py
+++ b/esphome/components/micro_wake_word/init.py
@@ -449,7 +449,11 @@ async def to_code(config):
    cg.add_define("USE_MICRO_WAKE_WORD")
    cg.add_define("USE_OTA_STATE_CALLBACK")

-    esp32.add_idf_component(name="espressif/esp-tflite-micro", ref="1.3.3~1")
+    esp32.add_idf_component(
+        name="esp-tflite-micro",
+        repo="https://github.com/espressif/esp-tflite-micro",
+        ref="v1.3.3.1",
+    )

    cg.add_build_flag("-DTF_LITE_STATIC_MEMORY")
    cg.add_build_flag("-DTF_LITE_DISABLE_X86_NEON")
--- a/esphome/components/online_image/online_image.cpp
+++ b/esphome/components/online_image/online_image.cpp
@@ -344,7 +344,7 @@ void OnlineImage::end_connection_() {
 }

 bool OnlineImage::validate_url_(const std::string &url) {
-  if ((url.length() < 8) || !url.starts_with("http") || (url.find("://") == std::string::npos)) {
+  if ((url.length() < 8) || (url.find("http") != 0) || (url.find("://") == std::string::npos)) {
    ESP_LOGE(TAG, "URL is invalid and/or must be prefixed with 'http://' or 'https://'");
    return false;
  }
--- a/esphome/components/pn7150/pn7150.cpp
+++ b/esphome/components/pn7150/pn7150.cpp
@@ -584,7 +584,7 @@ void PN7150::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::NFCC_INIT);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_INIT:
      if (this->init_core_() != nfc::STATUS_OK) {
@@ -594,7 +594,7 @@ void PN7150::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::NFCC_CONFIG);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_CONFIG:
      if (this->send_init_config_() != nfc::STATUS_OK) {
@@ -605,7 +605,7 @@ void PN7150::nci_fsm_transition_() {
        this->config_refresh_pending_ = false;
        this->nci_fsm_set_state_(NCIState::NFCC_SET_DISCOVER_MAP);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_SET_DISCOVER_MAP:
      if (this->set_discover_map_() != nfc::STATUS_OK) {
@@ -615,7 +615,7 @@ void PN7150::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::NFCC_SET_LISTEN_MODE_ROUTING);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_SET_LISTEN_MODE_ROUTING:
      if (this->set_listen_mode_routing_() != nfc::STATUS_OK) {
@@ -625,7 +625,7 @@ void PN7150::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::RFST_IDLE);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::RFST_IDLE:
      if (this->nci_state_error_ == NCIState::RFST_DISCOVERY) {
@@ -650,14 +650,14 @@ void PN7150::nci_fsm_transition_() {

    case NCIState::RFST_W4_HOST_SELECT:
      select_endpoint_();
-      [[fallthrough]];
+      // fall through

    // All cases below are waiting for NOTIFICATION messages
    case NCIState::RFST_DISCOVERY:
      if (this->config_refresh_pending_) {
        this->refresh_core_config_();
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::RFST_LISTEN_ACTIVE:
    case NCIState::RFST_LISTEN_SLEEP:
--- a/esphome/components/pn7160/pn7160.cpp
+++ b/esphome/components/pn7160/pn7160.cpp
@@ -609,7 +609,7 @@ void PN7160::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::NFCC_INIT);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_INIT:
      if (this->init_core_() != nfc::STATUS_OK) {
@@ -619,7 +619,7 @@ void PN7160::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::NFCC_CONFIG);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_CONFIG:
      if (this->send_init_config_() != nfc::STATUS_OK) {
@@ -630,7 +630,7 @@ void PN7160::nci_fsm_transition_() {
        this->config_refresh_pending_ = false;
        this->nci_fsm_set_state_(NCIState::NFCC_SET_DISCOVER_MAP);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_SET_DISCOVER_MAP:
      if (this->set_discover_map_() != nfc::STATUS_OK) {
@@ -640,7 +640,7 @@ void PN7160::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::NFCC_SET_LISTEN_MODE_ROUTING);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::NFCC_SET_LISTEN_MODE_ROUTING:
      if (this->set_listen_mode_routing_() != nfc::STATUS_OK) {
@@ -650,7 +650,7 @@ void PN7160::nci_fsm_transition_() {
      } else {
        this->nci_fsm_set_state_(NCIState::RFST_IDLE);
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::RFST_IDLE:
      if (this->nci_state_error_ == NCIState::RFST_DISCOVERY) {
@@ -675,14 +675,14 @@ void PN7160::nci_fsm_transition_() {

    case NCIState::RFST_W4_HOST_SELECT:
      select_endpoint_();
-      [[fallthrough]];
+      // fall through

    // All cases below are waiting for NOTIFICATION messages
    case NCIState::RFST_DISCOVERY:
      if (this->config_refresh_pending_) {
        this->refresh_core_config_();
      }
-      [[fallthrough]];
+      // fall through

    case NCIState::RFST_LISTEN_ACTIVE:
    case NCIState::RFST_LISTEN_SLEEP:
--- a/esphome/components/pulse_meter/pulse_meter_sensor.cpp
+++ b/esphome/components/pulse_meter/pulse_meter_sensor.cpp
@@ -63,7 +63,7 @@ void PulseMeterSensor::loop() {
  // If an edge was peeked, repay the debt
  if (this->peeked_edge_ && this->get_->count_ > 0) {
    this->peeked_edge_ = false;
-    this->get_->count_--;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    this->get_->count_--;
  }

  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early
@@ -71,7 +71,7 @@ void PulseMeterSensor::loop() {
      now - this->get_->last_rising_edge_us_ >= this->filter_us_) {
    this->peeked_edge_ = true;
    this->get_->last_detected_edge_us_ = this->get_->last_rising_edge_us_;
-    this->get_->count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    this->get_->count_++;
  }

  // Check if we detected a pulse this loop
@@ -146,7 +146,7 @@ void IRAM_ATTR PulseMeterSensor::edge_intr(PulseMeterSensor *sensor) {
    state.last_sent_edge_us_ = now;
    set.last_detected_edge_us_ = now;
    set.last_rising_edge_us_ = now;
-    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    set.count_++;
  }

  // This ISR is bound to rising edges, so the pin is high
@@ -169,7 +169,7 @@ void IRAM_ATTR PulseMeterSensor::pulse_intr(PulseMeterSensor *sensor) {
  } else if (length && !state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
    state.latched_ = true;
    set.last_detected_edge_us_ = state.last_intr_;
-    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    set.count_++;
  }

  // Due to order of operations this includes
--- a/esphome/components/radon_eye_ble/radon_eye_listener.cpp
+++ b/esphome/components/radon_eye_ble/radon_eye_listener.cpp
@@ -17,7 +17,7 @@ bool RadonEyeListener::parse_device(const esp32_ble_tracker::ESPBTDevice &device

    // Check if the device name starts with any of the prefixes
    if (std::any_of(prefixes.begin(), prefixes.end(),
-                    [&](const std::string &prefix) { return device.get_name().starts_with(prefix); })) {
+                    [&](const std::string &prefix) { return device.get_name().rfind(prefix, 0) == 0; })) {
      // Device found
      ESP_LOGD(TAG, "Found Radon Eye device Name: %s (MAC: %s)", device.get_name().c_str(),
               device.address_str().c_str());
--- a/esphome/components/remote_receiver/remote_receiver_esp8266.cpp
+++ b/esphome/components/remote_receiver/remote_receiver_esp8266.cpp
@@ -27,7 +27,7 @@ void IRAM_ATTR HOT RemoteReceiverComponentStore::gpio_intr(RemoteReceiverCompone
  if (time_since_change <= arg->filter_us)
    return;

-  arg->buffer[arg->buffer_write_at = next] = now;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  arg->buffer[arg->buffer_write_at = next] = now;
 }

 void RemoteReceiverComponent::setup() {
--- a/esphome/components/rp2040/init.py
+++ b/esphome/components/rp2040/init.py
@@ -167,7 +167,7 @@ async def to_code(config):
    cg.add_platformio_option("lib_ldf_mode", "chain+")
    cg.add_platformio_option("board", config[CONF_BOARD])
    cg.add_build_flag("-DUSE_RP2040")
-    cg.set_cpp_standard("gnu++20")
+    cg.set_cpp_standard("gnu++17")
    cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
    cg.add_define("ESPHOME_VARIANT", "RP2040")

--- a/esphome/components/safe_mode/safe_mode.h
+++ b/esphome/components/safe_mode/safe_mode.h
@@ -33,15 +33,12 @@ class SafeModeComponent : public Component {
  void write_rtc_(uint32_t val);
  uint32_t read_rtc_();

-  // Group all 4-byte aligned members together to avoid padding
+  bool boot_successful_{false};                   ///< set to true after boot is considered successful
  uint32_t safe_mode_boot_is_good_after_{60000};  ///< The amount of time after which the boot is considered successful
  uint32_t safe_mode_enable_time_{60000};         ///< The time safe mode should remain active for
  uint32_t safe_mode_rtc_value_{0};
  uint32_t safe_mode_start_time_{0};  ///< stores when safe mode was enabled
-  // Group 1-byte members together to minimize padding
-  bool boot_successful_{false};  ///< set to true after boot is considered successful
  uint8_t safe_mode_num_attempts_{0};
-  // Larger objects at the end
  ESPPreferenceObject rtc_;
  CallbackManager<void()> safe_mode_callback_{};

--- a/esphome/components/shelly_dimmer/stm32flash.cpp
+++ b/esphome/components/shelly_dimmer/stm32flash.cpp
@@ -445,7 +445,8 @@ template<typename T> stm32_err_t stm32_check_ack_timeout(const stm32_err_t s_err
      return STM32_ERR_OK;
    case STM32_ERR_NACK:
      log();
-      [[fallthrough]];
+      // TODO: c++17 [[fallthrough]]
+      /* fallthrough */
    default:
      return STM32_ERR_UNKNOWN;
  }
--- a/esphome/components/sn74hc595/sn74hc595.cpp
+++ b/esphome/components/sn74hc595/sn74hc595.cpp
@@ -1,6 +1,5 @@
 #include "sn74hc595.h"
 #include "esphome/core/log.h"
-#include <ranges>

 namespace esphome {
 namespace sn74hc595 {
@@ -56,9 +55,9 @@ void SN74HC595Component::digital_write_(uint16_t pin, bool value) {
 }

 void SN74HC595GPIOComponent::write_gpio() {
-  for (uint8_t &output_byte : std::ranges::reverse_view(this->output_bytes_)) {
+  for (auto byte = this->output_bytes_.rbegin(); byte != this->output_bytes_.rend(); byte++) {
    for (int8_t i = 7; i >= 0; i--) {
-      bool bit = (output_byte >> i) & 1;
+      bool bit = (*byte >> i) & 1;
      this->data_pin_->digital_write(bit);
      this->clock_pin_->digital_write(true);
      this->clock_pin_->digital_write(false);
@@ -69,9 +68,9 @@ void SN74HC595GPIOComponent::write_gpio() {

 #ifdef USE_SPI
 void SN74HC595SPIComponent::write_gpio() {
-  for (uint8_t &output_byte : std::ranges::reverse_view(this->output_bytes_)) {
+  for (auto byte = this->output_bytes_.rbegin(); byte != this->output_bytes_.rend(); byte++) {
    this->enable();
-    this->transfer_byte(output_byte);
+    this->transfer_byte(*byte);
    this->disable();
  }
  SN74HC595Component::write_gpio();
--- a/esphome/components/speaker/media_player/audio_pipeline.cpp
+++ b/esphome/components/speaker/media_player/audio_pipeline.cpp
@@ -343,12 +343,13 @@ void AudioPipeline::read_task(void *params) {
    xEventGroupSetBits(this_pipeline->event_group_, EventGroupBits::READER_MESSAGE_FINISHED);

    // Wait until the pipeline notifies us the source of the media file
-    EventBits_t event_bits = xEventGroupWaitBits(
-        this_pipeline->event_group_,
-        EventGroupBits::READER_COMMAND_INIT_FILE | EventGroupBits::READER_COMMAND_INIT_HTTP,  // Bit message to read
-        pdFALSE,                                                                              // Clear the bit on exit
-        pdFALSE,                                                                              // Wait for all the bits,
-        portMAX_DELAY);  // Block indefinitely until bit is set
+    EventBits_t event_bits =
+        xEventGroupWaitBits(this_pipeline->event_group_,
+                            EventGroupBits::READER_COMMAND_INIT_FILE | EventGroupBits::READER_COMMAND_INIT_HTTP |
+                                EventGroupBits::PIPELINE_COMMAND_STOP,  // Bit message to read
+                            pdFALSE,                                    // Clear the bit on exit
+                            pdFALSE,                                    // Wait for all the bits,
+                            portMAX_DELAY);                             // Block indefinitely until bit is set

    if (!(event_bits & EventGroupBits::PIPELINE_COMMAND_STOP)) {
      xEventGroupClearBits(this_pipeline->event_group_, EventGroupBits::READER_MESSAGE_FINISHED |
@@ -433,12 +434,12 @@ void AudioPipeline::decode_task(void *params) {
    xEventGroupSetBits(this_pipeline->event_group_, EventGroupBits::DECODER_MESSAGE_FINISHED);

    // Wait until the reader notifies us that the media type is available
-    EventBits_t event_bits =
-        xEventGroupWaitBits(this_pipeline->event_group_,
-                            EventGroupBits::READER_MESSAGE_LOADED_MEDIA_TYPE,  // Bit message to read
-                            pdFALSE,                                           // Clear the bit on exit
-                            pdFALSE,                                           // Wait for all the bits,
-                            portMAX_DELAY);                                    // Block indefinitely until bit is set
+    EventBits_t event_bits = xEventGroupWaitBits(this_pipeline->event_group_,
+                                                 EventGroupBits::READER_MESSAGE_LOADED_MEDIA_TYPE |
+                                                     EventGroupBits::PIPELINE_COMMAND_STOP,  // Bit message to read
+                                                 pdFALSE,                                    // Clear the bit on exit
+                                                 pdFALSE,                                    // Wait for all the bits,
+                                                 portMAX_DELAY);  // Block indefinitely until bit is set

    xEventGroupClearBits(this_pipeline->event_group_,
                         EventGroupBits::DECODER_MESSAGE_FINISHED | EventGroupBits::READER_MESSAGE_LOADED_MEDIA_TYPE);
--- a/esphome/components/sun/sun.cpp
+++ b/esphome/components/sun/sun.cpp
@@ -1,6 +1,5 @@
 #include "sun.h"
 #include "esphome/core/log.h"
-#include <numbers>

 /*
 The formulas/algorithms in this module are based on the book
@@ -19,12 +18,14 @@ using namespace esphome::sun::internal;

 static const char *const TAG = "sun";

+#undef PI
 #undef degrees
 #undef radians
 #undef sq

-inline num_t degrees(num_t rad) { return rad * 180 / std::numbers::pi; }
-inline num_t radians(num_t deg) { return deg * std::numbers::pi / 180; }
+static const num_t PI = 3.141592653589793;
+inline num_t degrees(num_t rad) { return rad * 180 / PI; }
+inline num_t radians(num_t deg) { return deg * PI / 180; }
 inline num_t arcdeg(num_t deg, num_t minutes, num_t seconds) { return deg + minutes / 60 + seconds / 3600; }
 inline num_t sq(num_t x) { return x * x; }
 inline num_t cb(num_t x) { return x * x * x; }
--- a/esphome/components/tx20/tx20.cpp
+++ b/esphome/components/tx20/tx20.cpp
@@ -152,7 +152,7 @@ void IRAM_ATTR Tx20ComponentStore::gpio_intr(Tx20ComponentStore *arg) {
    }
    arg->buffer[arg->buffer_index] = 1;
    arg->start_time = now;
-    arg->buffer_index++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+    arg->buffer_index++;
    return;
  }
  const uint32_t delay = now - arg->start_time;
@@ -183,7 +183,7 @@ void IRAM_ATTR Tx20ComponentStore::gpio_intr(Tx20ComponentStore *arg) {
  }
  arg->spent_time += delay;
  arg->start_time = now;
-  arg->buffer_index++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  arg->buffer_index++;
 }
 void IRAM_ATTR Tx20ComponentStore::reset() {
  tx20_available = false;
--- a/esphome/components/voice_assistant/init.py
+++ b/esphome/components/voice_assistant/init.py
@@ -17,11 +17,10 @@ from esphome.const import (
 AUTO_LOAD = ["socket"]
 DEPENDENCIES = ["api", "microphone"]

-CODEOWNERS = ["@jesserockz", "@kahrendt"]
+CODEOWNERS = ["@jesserockz"]

 CONF_ON_END = "on_end"
 CONF_ON_INTENT_END = "on_intent_end"
-CONF_ON_INTENT_PROGRESS = "on_intent_progress"
 CONF_ON_INTENT_START = "on_intent_start"
 CONF_ON_LISTENING = "on_listening"
 CONF_ON_START = "on_start"
@@ -137,9 +136,6 @@ CONFIG_SCHEMA = cv.All(
            cv.Optional(CONF_ON_INTENT_START): automation.validate_automation(
                single=True
            ),
-            cv.Optional(CONF_ON_INTENT_PROGRESS): automation.validate_automation(
-                single=True
-            ),
            cv.Optional(CONF_ON_INTENT_END): automation.validate_automation(
                single=True
            ),
@@ -286,13 +282,6 @@ async def to_code(config):
            config[CONF_ON_INTENT_START],
        )

-    if CONF_ON_INTENT_PROGRESS in config:
-        await automation.build_automation(
-            var.get_intent_progress_trigger(),
-            [(cg.std_string, "x")],
-            config[CONF_ON_INTENT_PROGRESS],
-        )
-
    if CONF_ON_INTENT_END in config:
        await automation.build_automation(
            var.get_intent_end_trigger(),
--- a/esphome/components/voice_assistant/voice_assistant.cpp
+++ b/esphome/components/voice_assistant/voice_assistant.cpp
@@ -555,7 +555,7 @@ void VoiceAssistant::request_stop() {
      break;
    case State::AWAITING_RESPONSE:
      this->signal_stop_();
-      // Fallthrough intended to stop a streaming TTS announcement that has potentially started
+      break;
    case State::STREAMING_RESPONSE:
 #ifdef USE_MEDIA_PLAYER
      // Stop any ongoing media player announcement
@@ -599,14 +599,6 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
  switch (msg.event_type) {
    case api::enums::VOICE_ASSISTANT_RUN_START:
      ESP_LOGD(TAG, "Assist Pipeline running");
-#ifdef USE_MEDIA_PLAYER
-      this->started_streaming_tts_ = false;
-      for (auto arg : msg.data) {
-        if (arg.name == "url") {
-          this->tts_response_url_ = std::move(arg.value);
-        }
-      }
-#endif
      this->defer([this]() { this->start_trigger_->trigger(); });
      break;
    case api::enums::VOICE_ASSISTANT_WAKE_WORD_START:
@@ -630,8 +622,6 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
      if (text.empty()) {
        ESP_LOGW(TAG, "No text in STT_END event");
        return;
-      } else if (text.length() > 500) {
-        text = text.substr(0, 497) + "...";
      }
      ESP_LOGD(TAG, "Speech recognised as: \"%s\"", text.c_str());
      this->defer([this, text]() { this->stt_end_trigger_->trigger(text); });
@@ -641,27 +631,6 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
      ESP_LOGD(TAG, "Intent started");
      this->defer([this]() { this->intent_start_trigger_->trigger(); });
      break;
-    case api::enums::VOICE_ASSISTANT_INTENT_PROGRESS: {
-      ESP_LOGD(TAG, "Intent progress");
-      std::string tts_url_for_trigger = "";
-#ifdef USE_MEDIA_PLAYER
-      if (this->media_player_ != nullptr) {
-        for (const auto &arg : msg.data) {
-          if ((arg.name == "tts_start_streaming") && (arg.value == "1") && !this->tts_response_url_.empty()) {
-            this->media_player_->make_call().set_media_url(this->tts_response_url_).set_announcement(true).perform();
-
-            this->media_player_wait_for_announcement_start_ = true;
-            this->media_player_wait_for_announcement_end_ = false;
-            this->started_streaming_tts_ = true;
-            tts_url_for_trigger = this->tts_response_url_;
-            this->tts_response_url_.clear();  // Reset streaming URL
-          }
-        }
-      }
-#endif
-      this->defer([this, tts_url_for_trigger]() { this->intent_progress_trigger_->trigger(tts_url_for_trigger); });
-      break;
-    }
    case api::enums::VOICE_ASSISTANT_INTENT_END: {
      for (auto arg : msg.data) {
        if (arg.name == "conversation_id") {
@@ -684,9 +653,6 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
        ESP_LOGW(TAG, "No text in TTS_START event");
        return;
      }
-      if (text.length() > 500) {
-        text = text.substr(0, 497) + "...";
-      }
      ESP_LOGD(TAG, "Response: \"%s\"", text.c_str());
      this->defer([this, text]() {
        this->tts_start_trigger_->trigger(text);
@@ -712,7 +678,7 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
      ESP_LOGD(TAG, "Response URL: \"%s\"", url.c_str());
      this->defer([this, url]() {
 #ifdef USE_MEDIA_PLAYER
-        if ((this->media_player_ != nullptr) && (!this->started_streaming_tts_)) {
+        if (this->media_player_ != nullptr) {
          this->media_player_->make_call().set_media_url(url).set_announcement(true).perform();

          this->media_player_wait_for_announcement_start_ = true;
--- a/esphome/components/voice_assistant/voice_assistant.h
+++ b/esphome/components/voice_assistant/voice_assistant.h
@@ -177,7 +177,6 @@ class VoiceAssistant : public Component {

  Trigger<> *get_intent_end_trigger() const { return this->intent_end_trigger_; }
  Trigger<> *get_intent_start_trigger() const { return this->intent_start_trigger_; }
-  Trigger<std::string> *get_intent_progress_trigger() const { return this->intent_progress_trigger_; }
  Trigger<> *get_listening_trigger() const { return this->listening_trigger_; }
  Trigger<> *get_end_trigger() const { return this->end_trigger_; }
  Trigger<> *get_start_trigger() const { return this->start_trigger_; }
@@ -234,7 +233,6 @@ class VoiceAssistant : public Component {
  Trigger<> *tts_stream_start_trigger_ = new Trigger<>();
  Trigger<> *tts_stream_end_trigger_ = new Trigger<>();
 #endif
-  Trigger<std::string> *intent_progress_trigger_ = new Trigger<std::string>();
  Trigger<> *wake_word_detected_trigger_ = new Trigger<>();
  Trigger<std::string> *stt_end_trigger_ = new Trigger<std::string>();
  Trigger<std::string> *tts_end_trigger_ = new Trigger<std::string>();
@@ -270,8 +268,6 @@ class VoiceAssistant : public Component {
 #endif
 #ifdef USE_MEDIA_PLAYER
  media_player::MediaPlayer *media_player_{nullptr};
-  std::string tts_response_url_{""};
-  bool started_streaming_tts_{false};
  bool media_player_wait_for_announcement_start_{false};
  bool media_player_wait_for_announcement_end_{false};
 #endif
--- a/esphome/components/web_server/init.py
+++ b/esphome/components/web_server/init.py
@@ -211,7 +211,6 @@ async def add_entity_config(entity, config):
    sorting_weight = config.get(CONF_SORTING_WEIGHT, 50)
    sorting_group_hash = hash(config.get(CONF_SORTING_GROUP_ID))

-    cg.add_define("USE_WEBSERVER_SORTING")
    cg.add(
        web_server.add_entity_config(
            entity,
@@ -297,5 +296,4 @@ async def to_code(config):
        cg.add_define("USE_WEBSERVER_LOCAL")

    if (sorting_group_config := config.get(CONF_SORTING_GROUPS)) is not None:
-        cg.add_define("USE_WEBSERVER_SORTING")
        add_sorting_groups(var, sorting_group_config)
--- a/esphome/components/web_server/web_server.cpp
+++ b/esphome/components/web_server/web_server.cpp
@@ -184,7 +184,6 @@ void DeferredUpdateEventSourceList::on_client_connect_(WebServer *ws, DeferredUp
  std::string message = ws->get_config_json();
  source->try_send_nodefer(message.c_str(), "ping", millis(), 30000);

-#ifdef USE_WEBSERVER_SORTING
  for (auto &group : ws->sorting_groups_) {
    message = json::build_json([group](JsonObject root) {
      root["name"] = group.second.name;
@@ -194,7 +193,6 @@ void DeferredUpdateEventSourceList::on_client_connect_(WebServer *ws, DeferredUp
    // up to 31 groups should be able to be queued initially without defer
    source->try_send_nodefer(message.c_str(), "sorting_group");
  }
-#endif

  source->entities_iterator_.begin(ws->include_internal_);

@@ -372,12 +370,6 @@ void WebServer::handle_js_request(AsyncWebServerRequest *request) {
  set_json_value(root, obj, sensor, value, start_config); \
  (root)["state"] = state;

-// Helper to get request detail parameter
-static JsonDetail get_request_detail_(AsyncWebServerRequest *request) {
-  auto *param = request->getParam("detail");
-  return (param && param->value() == "all") ? DETAIL_ALL : DETAIL_STATE;
-}
-
 #ifdef USE_SENSOR
 void WebServer::on_sensor_update(sensor::Sensor *obj, float state) {
  if (this->events_.empty())
@@ -389,7 +381,11 @@ void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlM
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->sensor_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -415,7 +411,12 @@ std::string WebServer::sensor_json(sensor::Sensor *obj, float value, JsonDetail
    }
    set_json_icon_state_value(root, obj, "sensor-" + obj->get_object_id(), state, value, start_config);
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
      if (!obj->get_unit_of_measurement().empty())
        root["uom"] = obj->get_unit_of_measurement();
    }
@@ -434,7 +435,11 @@ void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->text_sensor_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -455,7 +460,12 @@ std::string WebServer::text_sensor_json(text_sensor::TextSensor *obj, const std:
  return json::build_json([this, obj, value, start_config](JsonObject root) {
    set_json_icon_state_value(root, obj, "text_sensor-" + obj->get_object_id(), value, value, start_config);
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -473,7 +483,11 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->switch_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method == "toggle") {
@@ -503,7 +517,12 @@ std::string WebServer::switch_json(switch_::Switch *obj, bool value, JsonDetail
    set_json_icon_state_value(root, obj, "switch-" + obj->get_object_id(), value ? "ON" : "OFF", value, start_config);
    if (start_config == DETAIL_ALL) {
      root["assumed_state"] = obj->assumed_state();
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -515,7 +534,11 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->button_json(obj, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method == "press") {
@@ -539,7 +562,12 @@ std::string WebServer::button_json(button::Button *obj, JsonDetail start_config)
  return json::build_json([this, obj, start_config](JsonObject root) {
    set_json_id(root, obj, "button-" + obj->get_object_id(), start_config);
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -556,7 +584,11 @@ void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, con
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->binary_sensor_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -577,7 +609,12 @@ std::string WebServer::binary_sensor_json(binary_sensor::BinarySensor *obj, bool
    set_json_icon_state_value(root, obj, "binary_sensor-" + obj->get_object_id(), value ? "ON" : "OFF", value,
                              start_config);
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -595,7 +632,11 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->fan_json(obj, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method == "toggle") {
@@ -658,7 +699,12 @@ std::string WebServer::fan_json(fan::Fan *obj, JsonDetail start_config) {
    if (obj->get_traits().supports_oscillation())
      root["oscillation"] = obj->oscillating;
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -676,7 +722,11 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->light_json(obj, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method == "toggle") {
@@ -774,7 +824,12 @@ std::string WebServer::light_json(light::LightState *obj, JsonDetail start_confi
      for (auto const &option : obj->get_effects()) {
        opt.add(option->get_name());
      }
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -792,7 +847,11 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->cover_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -855,7 +914,12 @@ std::string WebServer::cover_json(cover::Cover *obj, JsonDetail start_config) {
    if (obj->get_traits().get_supports_tilt())
      root["tilt"] = obj->tilt;
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -873,7 +937,11 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->number_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -916,7 +984,12 @@ std::string WebServer::number_json(number::Number *obj, float value, JsonDetail
      root["mode"] = (int) obj->traits.get_mode();
      if (!obj->traits.get_unit_of_measurement().empty())
        root["uom"] = obj->traits.get_unit_of_measurement();
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
    if (std::isnan(value)) {
      root["value"] = "\"NaN\"";
@@ -943,7 +1016,11 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->date_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -985,7 +1062,12 @@ std::string WebServer::date_json(datetime::DateEntity *obj, JsonDetail start_con
    root["value"] = value;
    root["state"] = value;
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1002,7 +1084,11 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->time_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1043,7 +1129,12 @@ std::string WebServer::time_json(datetime::TimeEntity *obj, JsonDetail start_con
    root["value"] = value;
    root["state"] = value;
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1060,7 +1151,11 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
    if (obj->get_object_id() != match.id)
      continue;
    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->datetime_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1102,7 +1197,12 @@ std::string WebServer::datetime_json(datetime::DateTimeEntity *obj, JsonDetail s
    root["value"] = value;
    root["state"] = value;
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1120,7 +1220,11 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->text_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1163,7 +1267,12 @@ std::string WebServer::text_json(text::Text *obj, const std::string &value, Json
    root["value"] = value;
    if (start_config == DETAIL_ALL) {
      root["mode"] = (int) obj->traits.get_mode();
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1181,7 +1290,11 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->select_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1219,7 +1332,12 @@ std::string WebServer::select_json(select::Select *obj, const std::string &value
      for (auto &option : obj->traits.get_options()) {
        opt.add(option);
      }
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1240,7 +1358,11 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->climate_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1336,7 +1458,12 @@ std::string WebServer::climate_json(climate::Climate *obj, JsonDetail start_conf
        for (auto const &custom_preset : traits.get_supported_custom_presets())
          opt.add(custom_preset);
      }
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }

    bool has_state = false;
@@ -1399,7 +1526,11 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->lock_json(obj, obj->state, detail);
      request->send(200, "application/json", data.c_str());
    } else if (match.method == "lock") {
@@ -1429,7 +1560,12 @@ std::string WebServer::lock_json(lock::Lock *obj, lock::LockState value, JsonDet
    set_json_icon_state_value(root, obj, "lock-" + obj->get_object_id(), lock::lock_state_to_string(value), value,
                              start_config);
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1447,7 +1583,11 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->valve_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1501,7 +1641,12 @@ std::string WebServer::valve_json(valve::Valve *obj, JsonDetail start_config) {
    if (obj->get_traits().get_supports_position())
      root["position"] = obj->position;
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1519,7 +1664,11 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->alarm_control_panel_json(obj, obj->get_state(), detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1569,7 +1718,12 @@ std::string WebServer::alarm_control_panel_json(alarm_control_panel::AlarmContro
    set_json_icon_state_value(root, obj, "alarm-control-panel-" + obj->get_object_id(),
                              PSTR_LOCAL(alarm_control_panel_state_to_string(value)), value, start_config);
    if (start_config == DETAIL_ALL) {
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1586,7 +1740,11 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->event_json(obj, "", detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1614,7 +1772,12 @@ std::string WebServer::event_json(event::Event *obj, const std::string &event_ty
        event_types.add(event_type);
      }
      root["device_class"] = obj->get_device_class();
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1632,7 +1795,11 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
      continue;

    if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = get_request_detail_(request);
+      auto detail = DETAIL_STATE;
+      auto *param = request->getParam("detail");
+      if (param && param->value() == "all") {
+        detail = DETAIL_ALL;
+      }
      std::string data = this->update_json(obj, detail);
      request->send(200, "application/json", data.c_str());
      return;
@@ -1678,7 +1845,12 @@ std::string WebServer::update_json(update::UpdateEntity *obj, JsonDetail start_c
      root["title"] = obj->update_info.title;
      root["summary"] = obj->update_info.summary;
      root["release_url"] = obj->update_info.release_url;
-      this->add_sorting_info_(root, obj);
+      if (this->sorting_entitys_.find(obj) != this->sorting_entitys_.end()) {
+        root["sorting_weight"] = this->sorting_entitys_[obj].weight;
+        if (this->sorting_groups_.find(this->sorting_entitys_[obj].group_id) != this->sorting_groups_.end()) {
+          root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[obj].group_id].name;
+        }
+      }
    }
  });
 }
@@ -1988,18 +2160,6 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {

 bool WebServer::isRequestHandlerTrivial() const { return false; }

-void WebServer::add_sorting_info_(JsonObject &root, EntityBase *entity) {
-#ifdef USE_WEBSERVER_SORTING
-  if (this->sorting_entitys_.find(entity) != this->sorting_entitys_.end()) {
-    root["sorting_weight"] = this->sorting_entitys_[entity].weight;
-    if (this->sorting_groups_.find(this->sorting_entitys_[entity].group_id) != this->sorting_groups_.end()) {
-      root["sorting_group"] = this->sorting_groups_[this->sorting_entitys_[entity].group_id].name;
-    }
-  }
-#endif
-}
-
-#ifdef USE_WEBSERVER_SORTING
 void WebServer::add_entity_config(EntityBase *entity, float weight, uint64_t group) {
  this->sorting_entitys_[entity] = SortingComponents{weight, group};
 }
@@ -2007,7 +2167,6 @@ void WebServer::add_entity_config(EntityBase *entity, float weight, uint64_t gro
 void WebServer::add_sorting_group(uint64_t group_id, const std::string &group_name, float weight) {
  this->sorting_groups_[group_id] = SortingGroup{group_name, weight};
 }
-#endif

 void WebServer::schedule_(std::function<void()> &&f) {
 #ifdef USE_ESP32
--- a/esphome/components/web_server/web_server.h
+++ b/esphome/components/web_server/web_server.h
@@ -46,7 +46,6 @@ struct UrlMatch {
  bool valid;          ///< Whether this match is valid
 };

-#ifdef USE_WEBSERVER_SORTING
 struct SortingComponents {
  float weight;
  uint64_t group_id;
@@ -56,7 +55,6 @@ struct SortingGroup {
  std::string name;
  float weight;
 };
-#endif

 enum JsonDetail { DETAIL_ALL, DETAIL_STATE };

@@ -476,18 +474,14 @@ class WebServer : public Controller, public Component, public AsyncWebHandler {
  /// This web handle is not trivial.
  bool isRequestHandlerTrivial() const override;  // NOLINT(readability-identifier-naming)

-#ifdef USE_WEBSERVER_SORTING
  void add_entity_config(EntityBase *entity, float weight, uint64_t group);
  void add_sorting_group(uint64_t group_id, const std::string &group_name, float weight);

  std::map<EntityBase *, SortingComponents> sorting_entitys_;
  std::map<uint64_t, SortingGroup> sorting_groups_;
-#endif
-
  bool include_internal_{false};

 protected:
-  void add_sorting_info_(JsonObject &root, EntityBase *entity);
  void schedule_(std::function<void()> &&f);
  web_server_base::WebServerBase *base_;
 #ifdef USE_ARDUINO
--- a/esphome/components/web_server_idf/web_server_idf.cpp
+++ b/esphome/components/web_server_idf/web_server_idf.cpp
@@ -338,7 +338,6 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
  std::string message = ws->get_config_json();
  this->try_send_nodefer(message.c_str(), "ping", millis(), 30000);

-#ifdef USE_WEBSERVER_SORTING
  for (auto &group : ws->sorting_groups_) {
    message = json::build_json([group](JsonObject root) {
      root["name"] = group.second.name;
@@ -349,7 +348,6 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
    // since the only thing in the send buffer at this point is the initial ping/config
    this->try_send_nodefer(message.c_str(), "sorting_group");
  }
-#endif

  this->entities_iterator_->begin(ws->include_internal_);

--- a/esphome/components/wiegand/wiegand.cpp
+++ b/esphome/components/wiegand/wiegand.cpp
@@ -11,7 +11,7 @@ static const char *const KEYS = "0123456789*#";
 void IRAM_ATTR HOT WiegandStore::d0_gpio_intr(WiegandStore *arg) {
  if (arg->d0.digital_read())
    return;
-  arg->count++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  arg->count++;
  arg->value <<= 1;
  arg->last_bit_time = millis();
  arg->done = false;
@@ -20,7 +20,7 @@ void IRAM_ATTR HOT WiegandStore::d0_gpio_intr(WiegandStore *arg) {
 void IRAM_ATTR HOT WiegandStore::d1_gpio_intr(WiegandStore *arg) {
  if (arg->d1.digital_read())
    return;
-  arg->count++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  arg->count++;
  arg->value = (arg->value << 1) | 1;
  arg->last_bit_time = millis();
  arg->done = false;
--- a/esphome/components/wifi/wifi_component.h
+++ b/esphome/components/wifi/wifi_component.h
@@ -62,7 +62,7 @@ struct SavedWifiFastConnectSettings {
  uint8_t channel;
 } PACKED;  // NOLINT

-enum WiFiComponentState : uint8_t {
+enum WiFiComponentState {
  /** Nothing has been initialized yet. Internal AP, if configured, is disabled at this point. */
  WIFI_COMPONENT_STATE_OFF = 0,
  /** WiFi is disabled. */
@@ -146,14 +146,14 @@ class WiFiAP {

 protected:
  std::string ssid_;
-  std::string password_;
  optional<bssid_t> bssid_;
+  std::string password_;
 #ifdef USE_WIFI_WPA2_EAP
  optional<EAPAuth> eap_;
 #endif  // USE_WIFI_WPA2_EAP
-  optional<ManualIP> manual_ip_;
-  float priority_{0};
  optional<uint8_t> channel_;
+  float priority_{0};
+  optional<ManualIP> manual_ip_;
  bool hidden_{false};
 };

@@ -177,14 +177,14 @@ class WiFiScanResult {
  bool operator==(const WiFiScanResult &rhs) const;

 protected:
+  bool matches_{false};
  bssid_t bssid_;
  std::string ssid_;
-  float priority_{0.0f};
  uint8_t channel_;
  int8_t rssi_;
-  bool matches_{false};
  bool with_auth_;
  bool is_hidden_;
+  float priority_{0.0f};
 };

 struct WiFiSTAPriority {
@@ -192,7 +192,7 @@ struct WiFiSTAPriority {
  float priority;
 };

-enum WiFiPowerSaveMode : uint8_t {
+enum WiFiPowerSaveMode {
  WIFI_POWER_SAVE_NONE = 0,
  WIFI_POWER_SAVE_LIGHT,
  WIFI_POWER_SAVE_HIGH,
@@ -383,36 +383,28 @@ class WiFiComponent : public Component {
  std::string use_address_;
  std::vector<WiFiAP> sta_;
  std::vector<WiFiSTAPriority> sta_priorities_;
-  std::vector<WiFiScanResult> scan_result_;
  WiFiAP selected_ap_;
-  WiFiAP ap_;
-  optional<float> output_power_;
-  ESPPreferenceObject pref_;
-  ESPPreferenceObject fast_connect_pref_;
+  bool fast_connect_{false};
+  bool retry_hidden_{false};

-  // Group all 32-bit integers together
+  bool has_ap_{false};
+  WiFiAP ap_;
+  WiFiComponentState state_{WIFI_COMPONENT_STATE_OFF};
+  bool handled_connected_state_{false};
  uint32_t action_started_;
+  uint8_t num_retried_{0};
  uint32_t last_connected_{0};
  uint32_t reboot_timeout_{};
  uint32_t ap_timeout_{};
-
-  // Group all 8-bit values together
-  WiFiComponentState state_{WIFI_COMPONENT_STATE_OFF};
  WiFiPowerSaveMode power_save_{WIFI_POWER_SAVE_NONE};
-  uint8_t num_retried_{0};
-#if USE_NETWORK_IPV6
-  uint8_t num_ipv6_addresses_{0};
-#endif /* USE_NETWORK_IPV6 */
-
-  // Group all boolean values together
-  bool fast_connect_{false};
-  bool retry_hidden_{false};
-  bool has_ap_{false};
-  bool handled_connected_state_{false};
  bool error_from_callback_{false};
+  std::vector<WiFiScanResult> scan_result_;
  bool scan_done_{false};
  bool ap_setup_{false};
+  optional<float> output_power_;
  bool passive_scan_{false};
+  ESPPreferenceObject pref_;
+  ESPPreferenceObject fast_connect_pref_;
  bool has_saved_wifi_settings_{false};
 #ifdef USE_WIFI_11KV_SUPPORT
  bool btm_{false};
@@ -420,8 +412,10 @@ class WiFiComponent : public Component {
 #endif
  bool enable_on_boot_;
  bool got_ipv4_address_{false};
+#if USE_NETWORK_IPV6
+  uint8_t num_ipv6_addresses_{0};
+#endif /* USE_NETWORK_IPV6 */

-  // Pointers at the end (naturally aligned)
  Trigger<> *connect_trigger_{new Trigger<>()};
  Trigger<> *disconnect_trigger_{new Trigger<>()};
 };
--- a/esphome/core/application.cpp
+++ b/esphome/core/application.cpp
@@ -3,7 +3,6 @@
 #include "esphome/core/version.h"
 #include "esphome/core/hal.h"
 #include <algorithm>
-#include <ranges>

 #ifdef USE_STATUS_LED
 #include "esphome/components/status_led/status_led.h"
@@ -189,8 +188,8 @@ void IRAM_ATTR HOT Application::feed_wdt(uint32_t time) {
 }
 void Application::reboot() {
  ESP_LOGI(TAG, "Forcing a reboot");
-  for (auto &component : std::ranges::reverse_view(this->components_)) {
-    component->on_shutdown();
+  for (auto it = this->components_.rbegin(); it != this->components_.rend(); ++it) {
+    (*it)->on_shutdown();
  }
  arch_restart();
 }
@@ -203,17 +202,17 @@ void Application::safe_reboot() {
 }

 void Application::run_safe_shutdown_hooks() {
-  for (auto &component : std::ranges::reverse_view(this->components_)) {
-    component->on_safe_shutdown();
+  for (auto it = this->components_.rbegin(); it != this->components_.rend(); ++it) {
+    (*it)->on_safe_shutdown();
  }
-  for (auto &component : std::ranges::reverse_view(this->components_)) {
-    component->on_shutdown();
+  for (auto it = this->components_.rbegin(); it != this->components_.rend(); ++it) {
+    (*it)->on_shutdown();
  }
 }

 void Application::run_powerdown_hooks() {
-  for (auto &component : std::ranges::reverse_view(this->components_)) {
-    component->on_powerdown();
+  for (auto it = this->components_.rbegin(); it != this->components_.rend(); ++it) {
+    (*it)->on_powerdown();
  }
 }

--- a/esphome/core/application.h
+++ b/esphome/core/application.h
@@ -338,9 +338,6 @@ class Application {
   * Each component can request a high frequency loop execution by using the HighFrequencyLoopRequester
   * helper in helpers.h
   *
-   * Note: This method is not called by ESPHome core code. It is only used by lambda functions
-   * in YAML configurations or by external components.
-   *
   * @param loop_interval The interval in milliseconds to run the core loop at. Defaults to 16 milliseconds.
   */
  void set_loop_interval(uint32_t loop_interval) {
--- a/esphome/core/component.cpp
+++ b/esphome/core/component.cpp
@@ -60,18 +60,10 @@ void Component::set_interval(const std::string &name, uint32_t interval, std::fu
  App.scheduler.set_interval(this, name, interval, std::move(f));
 }

-void Component::set_interval(const char *name, uint32_t interval, std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_interval(this, name, interval, std::move(f));
-}
-
 bool Component::cancel_interval(const std::string &name) {  // NOLINT
  return App.scheduler.cancel_interval(this, name);
 }

-bool Component::cancel_interval(const char *name) {  // NOLINT
-  return App.scheduler.cancel_interval(this, name);
-}
-
 void Component::set_retry(const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,
                          std::function<RetryResult(uint8_t)> &&f, float backoff_increase_factor) {  // NOLINT
  App.scheduler.set_retry(this, name, initial_wait_time, max_attempts, std::move(f), backoff_increase_factor);
@@ -85,18 +77,10 @@ void Component::set_timeout(const std::string &name, uint32_t timeout, std::func
  App.scheduler.set_timeout(this, name, timeout, std::move(f));
 }

-void Component::set_timeout(const char *name, uint32_t timeout, std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_timeout(this, name, timeout, std::move(f));
-}
-
 bool Component::cancel_timeout(const std::string &name) {  // NOLINT
  return App.scheduler.cancel_timeout(this, name);
 }

-bool Component::cancel_timeout(const char *name) {  // NOLINT
-  return App.scheduler.cancel_timeout(this, name);
-}
-
 void Component::call_loop() { this->loop(); }
 void Component::call_setup() { this->setup(); }
 void Component::call_dump_config() {
@@ -205,7 +189,7 @@ bool Component::is_in_loop_state() const {
  return (this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_LOOP;
 }
 void Component::defer(std::function<void()> &&f) {  // NOLINT
-  App.scheduler.set_timeout(this, static_cast<const char *>(nullptr), 0, std::move(f));
+  App.scheduler.set_timeout(this, "", 0, std::move(f));
 }
 bool Component::cancel_defer(const std::string &name) {  // NOLINT
  return App.scheduler.cancel_timeout(this, name);
--- a/esphome/core/component.h
+++ b/esphome/core/component.h
@@ -261,22 +261,6 @@ class Component {
   */
  void set_interval(const std::string &name, uint32_t interval, std::function<void()> &&f);  // NOLINT

-  /** Set an interval function with a const char* name.
-   *
-   * IMPORTANT: The provided name pointer must remain valid for the lifetime of the scheduler item.
-   * This means the name should be:
-   *   - A string literal (e.g., "update")
-   *   - A static const char* variable
-   *   - A pointer with lifetime >= the scheduled task
-   *
-   * For dynamic strings, use the std::string overload instead.
-   *
-   * @param name The identifier for this interval function (must have static lifetime)
-   * @param interval The interval in ms
-   * @param f The function to call
-   */
-  void set_interval(const char *name, uint32_t interval, std::function<void()> &&f);  // NOLINT
-
  void set_interval(uint32_t interval, std::function<void()> &&f);  // NOLINT

  /** Cancel an interval function.
@@ -285,7 +269,6 @@ class Component {
   * @return Whether an interval functions was deleted.
   */
  bool cancel_interval(const std::string &name);  // NOLINT
-  bool cancel_interval(const char *name);         // NOLINT

  /** Set an retry function with a unique name. Empty name means no cancelling possible.
   *
@@ -346,22 +329,6 @@ class Component {
   */
  void set_timeout(const std::string &name, uint32_t timeout, std::function<void()> &&f);  // NOLINT

-  /** Set a timeout function with a const char* name.
-   *
-   * IMPORTANT: The provided name pointer must remain valid for the lifetime of the scheduler item.
-   * This means the name should be:
-   *   - A string literal (e.g., "init")
-   *   - A static const char* variable
-   *   - A pointer with lifetime >= the timeout duration
-   *
-   * For dynamic strings, use the std::string overload instead.
-   *
-   * @param name The identifier for this timeout function (must have static lifetime)
-   * @param timeout The timeout in ms
-   * @param f The function to call
-   */
-  void set_timeout(const char *name, uint32_t timeout, std::function<void()> &&f);  // NOLINT
-
  void set_timeout(uint32_t timeout, std::function<void()> &&f);  // NOLINT

  /** Cancel a timeout function.
@@ -370,7 +337,6 @@ class Component {
   * @return Whether a timeout functions was deleted.
   */
  bool cancel_timeout(const std::string &name);  // NOLINT
-  bool cancel_timeout(const char *name);         // NOLINT

  /** Defer a callback to the next loop() call.
   *
--- a/esphome/core/component_iterator.cpp
+++ b/esphome/core/component_iterator.cpp
@@ -375,7 +375,7 @@ void ComponentIterator::advance() {
  }

  if (advance_platform) {
-    this->state_ = static_cast<IteratorState>(static_cast<uint8_t>(this->state_) + 1);
+    this->state_ = static_cast<IteratorState>(static_cast<uint16_t>(this->state_) + 1);
    this->at_ = 0;
  } else if (success) {
    this->at_++;
--- a/esphome/core/datatypes.h
+++ b/esphome/core/datatypes.h
@@ -11,7 +11,7 @@ namespace internal {
 /// Wrapper class for memory using big endian data layout, transparently converting it to native order.
 template<typename T> class BigEndianLayout {
 public:
-  constexpr operator T() { return convert_big_endian(val_); }
+  constexpr14 operator T() { return convert_big_endian(val_); }

 private:
  T val_;
@@ -20,7 +20,7 @@ template<typename T> class BigEndianLayout {
 /// Wrapper class for memory using big endian data layout, transparently converting it to native order.
 template<typename T> class LittleEndianLayout {
 public:
-  constexpr operator T() { return convert_little_endian(val_); }
+  constexpr14 operator T() { return convert_little_endian(val_); }

 private:
  T val_;
--- a/esphome/core/defines.h
+++ b/esphome/core/defines.h
@@ -151,7 +151,6 @@
 #define USE_VOICE_ASSISTANT
 #define USE_WEBSERVER
 #define USE_WEBSERVER_PORT 80  // NOLINT
-#define USE_WEBSERVER_SORTING
 #define USE_WIFI_11KV_SUPPORT

 #ifdef USE_ARDUINO
--- a/esphome/core/event_pool.h
+++ b/esphome/core/event_pool.h
@@ -1,81 +0,0 @@
-#pragma once
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-
-#include <atomic>
-#include <cstddef>
-#include "esphome/core/helpers.h"
-#include "esphome/core/lock_free_queue.h"
-
-namespace esphome {
-
-// Event Pool - On-demand pool of objects to avoid heap fragmentation
-// Events are allocated on first use and reused thereafter, growing to peak usage
-// @tparam T The type of objects managed by the pool (must have a release() method)
-// @tparam SIZE The maximum number of objects in the pool (1-255, limited by uint8_t)
-template<class T, uint8_t SIZE> class EventPool {
- public:
-  EventPool() : total_created_(0) {}
-
-  ~EventPool() {
-    // Clean up any remaining events in the free list
-    // IMPORTANT: This destructor assumes no concurrent access. The EventPool must not
-    // be destroyed while any thread might still call allocate() or release().
-    // In practice, this is typically ensured by destroying the pool only during
-    // component shutdown when all producer/consumer threads have been stopped.
-    T *event;
-    RAMAllocator<T> allocator(RAMAllocator<T>::ALLOC_INTERNAL);
-    while ((event = this->free_list_.pop()) != nullptr) {
-      // Call destructor
-      event->~T();
-      // Deallocate using RAMAllocator
-      allocator.deallocate(event, 1);
-    }
-  }
-
-  // Allocate an event from the pool
-  // Returns nullptr if pool is full
-  T *allocate() {
-    // Try to get from free list first
-    T *event = this->free_list_.pop();
-    if (event != nullptr)
-      return event;
-
-    // Need to create a new event
-    if (this->total_created_ >= SIZE) {
-      // Pool is at capacity
-      return nullptr;
-    }
-
-    // Use internal RAM for better performance
-    RAMAllocator<T> allocator(RAMAllocator<T>::ALLOC_INTERNAL);
-    event = allocator.allocate(1);
-
-    if (event == nullptr) {
-      // Memory allocation failed
-      return nullptr;
-    }
-
-    // Placement new to construct the object
-    new (event) T();
-    this->total_created_++;
-    return event;
-  }
-
-  // Return an event to the pool for reuse
-  void release(T *event) {
-    if (event != nullptr) {
-      // Clean up the event's allocated memory
-      event->release();
-      this->free_list_.push(event);
-    }
-  }
-
- private:
-  LockFreeQueue<T, SIZE> free_list_;  // Free events ready for reuse
-  uint8_t total_created_;             // Total events created (high water mark, max 255)
-};
-
-}  // namespace esphome
-
-#endif  // defined(USE_ESP32) || defined(USE_LIBRETINY)
--- a/esphome/core/helpers.cpp
+++ b/esphome/core/helpers.cpp
@@ -76,8 +76,23 @@ static const uint16_t CRC16_1021_BE_LUT_H[] = {0x0000, 0x1231, 0x2462, 0x3653, 0
                                               0x9188, 0x83b9, 0xb5ea, 0xa7db, 0xd94c, 0xcb7d, 0xfd2e, 0xef1f};
 #endif

+// STL backports
+
+#if _GLIBCXX_RELEASE < 8
+std::string to_string(int value) { return str_snprintf("%d", 32, value); }                   // NOLINT
+std::string to_string(long value) { return str_snprintf("%ld", 32, value); }                 // NOLINT
+std::string to_string(long long value) { return str_snprintf("%lld", 32, value); }           // NOLINT
+std::string to_string(unsigned value) { return str_snprintf("%u", 32, value); }              // NOLINT
+std::string to_string(unsigned long value) { return str_snprintf("%lu", 32, value); }        // NOLINT
+std::string to_string(unsigned long long value) { return str_snprintf("%llu", 32, value); }  // NOLINT
+std::string to_string(float value) { return str_snprintf("%f", 32, value); }
+std::string to_string(double value) { return str_snprintf("%f", 32, value); }
+std::string to_string(long double value) { return str_snprintf("%Lf", 32, value); }
+#endif
+
 // Mathematics

+float lerp(float completion, float start, float end) { return start + (end - start) * completion; }
 uint8_t crc8(const uint8_t *data, uint8_t len) {
  uint8_t crc = 0;

--- a/esphome/core/helpers.h
+++ b/esphome/core/helpers.h
@@ -37,18 +37,89 @@
 #define ESPHOME_ALWAYS_INLINE __attribute__((always_inline))
 #define PACKED __attribute__((packed))

+// Various functions can be constexpr in C++14, but not in C++11 (because their body isn't just a return statement).
+// Define a substitute constexpr keyword for those functions, until we can drop C++11 support.
+#if __cplusplus >= 201402L
+#define constexpr14 constexpr
+#else
+#define constexpr14 inline  // constexpr implies inline
+#endif
+
 namespace esphome {

 /// @name STL backports
 ///@{

-// Keep "using" even after the removal of our backports, to avoid breaking existing code.
+// Backports for various STL features we like to use. Pull in the STL implementation wherever available, to avoid
+// ambiguity and to provide a uniform API.
+
+// std::to_string() from C++11, available from libstdc++/g++ 8
+// See https://github.com/espressif/esp-idf/issues/1445
+#if _GLIBCXX_RELEASE >= 8
 using std::to_string;
+#else
+std::string to_string(int value);                 // NOLINT
+std::string to_string(long value);                // NOLINT
+std::string to_string(long long value);           // NOLINT
+std::string to_string(unsigned value);            // NOLINT
+std::string to_string(unsigned long value);       // NOLINT
+std::string to_string(unsigned long long value);  // NOLINT
+std::string to_string(float value);
+std::string to_string(double value);
+std::string to_string(long double value);
+#endif
+
+// std::is_trivially_copyable from C++11, implemented in libstdc++/g++ 5.1 (but minor releases can't be detected)
+#if _GLIBCXX_RELEASE >= 6
 using std::is_trivially_copyable;
+#else
+// Implementing this is impossible without compiler intrinsics, so don't bother. Invalid usage will be detected on
+// other variants that use a newer compiler anyway.
+// NOLINTNEXTLINE(readability-identifier-naming)
+template<typename T> struct is_trivially_copyable : public std::integral_constant<bool, true> {};
+#endif
+
+// std::make_unique() from C++14
+#if __cpp_lib_make_unique >= 201304
 using std::make_unique;
+#else
+template<typename T, typename... Args> std::unique_ptr<T> make_unique(Args &&...args) {
+  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+#endif
+
+// std::enable_if_t from C++14
+#if __cplusplus >= 201402L
 using std::enable_if_t;
+#else
+template<bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;
+#endif
+
+// std::clamp from C++17
+#if __cpp_lib_clamp >= 201603
 using std::clamp;
+#else
+template<typename T, typename Compare> constexpr const T &clamp(const T &v, const T &lo, const T &hi, Compare comp) {
+  return comp(v, lo) ? lo : comp(hi, v) ? hi : v;
+}
+template<typename T> constexpr const T &clamp(const T &v, const T &lo, const T &hi) {
+  return clamp(v, lo, hi, std::less<T>{});
+}
+#endif
+
+// std::is_invocable from C++17
+#if __cpp_lib_is_invocable >= 201703
 using std::is_invocable;
+#else
+// https://stackoverflow.com/a/37161919/8924614
+template<class T, class... Args> struct is_invocable {  // NOLINT(readability-identifier-naming)
+  template<class U> static auto test(U *p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type());
+  template<class U> static auto test(...) -> decltype(std::false_type());
+  static constexpr auto value = decltype(test<T>(nullptr))::value;  // NOLINT
+};
+#endif
+
+// std::bit_cast from C++20
 #if __cpp_lib_bit_cast >= 201806
 using std::bit_cast;
 #else
@@ -63,29 +134,31 @@ To bit_cast(const From &src) {
  return dst;
 }
 #endif
-using std::lerp;

 // std::byteswap from C++23
-template<typename T> constexpr T byteswap(T n) {
+template<typename T> constexpr14 T byteswap(T n) {
  T m;
  for (size_t i = 0; i < sizeof(T); i++)
    reinterpret_cast<uint8_t *>(&m)[i] = reinterpret_cast<uint8_t *>(&n)[sizeof(T) - 1 - i];
  return m;
 }
-template<> constexpr uint8_t byteswap(uint8_t n) { return n; }
-template<> constexpr uint16_t byteswap(uint16_t n) { return __builtin_bswap16(n); }
-template<> constexpr uint32_t byteswap(uint32_t n) { return __builtin_bswap32(n); }
-template<> constexpr uint64_t byteswap(uint64_t n) { return __builtin_bswap64(n); }
-template<> constexpr int8_t byteswap(int8_t n) { return n; }
-template<> constexpr int16_t byteswap(int16_t n) { return __builtin_bswap16(n); }
-template<> constexpr int32_t byteswap(int32_t n) { return __builtin_bswap32(n); }
-template<> constexpr int64_t byteswap(int64_t n) { return __builtin_bswap64(n); }
+template<> constexpr14 uint8_t byteswap(uint8_t n) { return n; }
+template<> constexpr14 uint16_t byteswap(uint16_t n) { return __builtin_bswap16(n); }
+template<> constexpr14 uint32_t byteswap(uint32_t n) { return __builtin_bswap32(n); }
+template<> constexpr14 uint64_t byteswap(uint64_t n) { return __builtin_bswap64(n); }
+template<> constexpr14 int8_t byteswap(int8_t n) { return n; }
+template<> constexpr14 int16_t byteswap(int16_t n) { return __builtin_bswap16(n); }
+template<> constexpr14 int32_t byteswap(int32_t n) { return __builtin_bswap32(n); }
+template<> constexpr14 int64_t byteswap(int64_t n) { return __builtin_bswap64(n); }

 ///@}

 /// @name Mathematics
 ///@{

+/// Linearly interpolate between \p start and \p end by \p completion (between 0 and 1).
+float lerp(float completion, float start, float end);
+
 /// Remap \p value from the range (\p min, \p max) to (\p min_out, \p max_out).
 template<typename T, typename U> T remap(U value, U min, U max, T min_out, T max_out) {
  return (value - min) * (max_out - min_out) / (max - min) + min_out;
@@ -130,7 +203,8 @@ constexpr uint32_t encode_uint32(uint8_t byte1, uint8_t byte2, uint8_t byte3, ui
 }

 /// Encode a value from its constituent bytes (from most to least significant) in an array with length sizeof(T).
-template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> constexpr T encode_value(const uint8_t *bytes) {
+template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
+constexpr14 T encode_value(const uint8_t *bytes) {
  T val = 0;
  for (size_t i = 0; i < sizeof(T); i++) {
    val <<= 8;
@@ -140,12 +214,12 @@ template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> constexpr
 }
 /// Encode a value from its constituent bytes (from most to least significant) in an std::array with length sizeof(T).
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
-constexpr T encode_value(const std::array<uint8_t, sizeof(T)> bytes) {
+constexpr14 T encode_value(const std::array<uint8_t, sizeof(T)> bytes) {
  return encode_value<T>(bytes.data());
 }
 /// Decode a value into its constituent bytes (from most to least significant).
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
-constexpr std::array<uint8_t, sizeof(T)> decode_value(T val) {
+constexpr14 std::array<uint8_t, sizeof(T)> decode_value(T val) {
  std::array<uint8_t, sizeof(T)> ret{};
  for (size_t i = sizeof(T); i > 0; i--) {
    ret[i - 1] = val & 0xFF;
@@ -172,7 +246,7 @@ inline uint32_t reverse_bits(uint32_t x) {
 }

 /// Convert a value between host byte order and big endian (most significant byte first) order.
-template<typename T> constexpr T convert_big_endian(T val) {
+template<typename T> constexpr14 T convert_big_endian(T val) {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  return byteswap(val);
 #else
@@ -181,7 +255,7 @@ template<typename T> constexpr T convert_big_endian(T val) {
 }

 /// Convert a value between host byte order and little endian (least significant byte first) order.
-template<typename T> constexpr T convert_little_endian(T val) {
+template<typename T> constexpr14 T convert_little_endian(T val) {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  return val;
 #else
@@ -202,6 +276,9 @@ bool str_startswith(const std::string &str, const std::string &start);
 /// Check whether a string ends with a value.
 bool str_endswith(const std::string &str, const std::string &end);

+/// Convert the value to a string (added as extra overload so that to_string() can be used on all stringifiable types).
+inline std::string to_string(const std::string &val) { return val; }
+
 /// Truncate a string to a specific length.
 std::string str_truncate(const std::string &str, size_t length);

--- a/esphome/core/lock_free_queue.h
+++ b/esphome/core/lock_free_queue.h
@@ -1,132 +0,0 @@
-#pragma once
-
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-
-#include <atomic>
-#include <cstddef>
-
-#if defined(USE_ESP32)
-#include <freertos/FreeRTOS.h>
-#include <freertos/task.h>
-#elif defined(USE_LIBRETINY)
-#include <FreeRTOS.h>
-#include <task.h>
-#endif
-
-/*
- * Lock-free queue for single-producer single-consumer scenarios.
- * This allows one thread to push items and another to pop them without
- * blocking each other.
- *
- * This is a Single-Producer Single-Consumer (SPSC) lock-free ring buffer.
- * Available on platforms with FreeRTOS support (ESP32, LibreTiny).
- *
- * Common use cases:
- * - BLE events: BLE task produces, main loop consumes
- * - MQTT messages: main task produces, MQTT thread consumes
- *
- * @tparam T The type of elements stored in the queue (must be a pointer type)
- * @tparam SIZE The maximum number of elements (1-255, limited by uint8_t indices)
- */
-
-namespace esphome {
-
-template<class T, uint8_t SIZE> class LockFreeQueue {
- public:
-  LockFreeQueue() : head_(0), tail_(0), dropped_count_(0), task_to_notify_(nullptr) {}
-
-  bool push(T *element) {
-    if (element == nullptr)
-      return false;
-
-    uint8_t current_tail = tail_.load(std::memory_order_relaxed);
-    uint8_t next_tail = (current_tail + 1) % SIZE;
-
-    // Read head before incrementing tail
-    uint8_t head_before = head_.load(std::memory_order_acquire);
-
-    if (next_tail == head_before) {
-      // Buffer full
-      dropped_count_.fetch_add(1, std::memory_order_relaxed);
-      return false;
-    }
-
-    // Check if queue was empty before push
-    bool was_empty = (current_tail == head_before);
-
-    buffer_[current_tail] = element;
-    tail_.store(next_tail, std::memory_order_release);
-
-    // Notify optimization: only notify if we need to
-    if (task_to_notify_ != nullptr) {
-      if (was_empty) {
-        // Queue was empty - consumer might be going to sleep, must notify
-        xTaskNotifyGive(task_to_notify_);
-      } else {
-        // Queue wasn't empty - check if consumer has caught up to previous tail
-        uint8_t head_after = head_.load(std::memory_order_acquire);
-        if (head_after == current_tail) {
-          // Consumer just caught up to where tail was - might go to sleep, must notify
-          // Note: There's a benign race here - between reading head_after and calling
-          // xTaskNotifyGive(), the consumer could advance further. This would result
-          // in an unnecessary wake-up, but is harmless and extremely rare in practice.
-          xTaskNotifyGive(task_to_notify_);
-        }
-        // Otherwise: consumer is still behind, no need to notify
-      }
-    }
-
-    return true;
-  }
-
-  T *pop() {
-    uint8_t current_head = head_.load(std::memory_order_relaxed);
-
-    if (current_head == tail_.load(std::memory_order_acquire)) {
-      return nullptr;  // Empty
-    }
-
-    T *element = buffer_[current_head];
-    head_.store((current_head + 1) % SIZE, std::memory_order_release);
-    return element;
-  }
-
-  size_t size() const {
-    uint8_t tail = tail_.load(std::memory_order_acquire);
-    uint8_t head = head_.load(std::memory_order_acquire);
-    return (tail - head + SIZE) % SIZE;
-  }
-
-  uint16_t get_and_reset_dropped_count() { return dropped_count_.exchange(0, std::memory_order_relaxed); }
-
-  void increment_dropped_count() { dropped_count_.fetch_add(1, std::memory_order_relaxed); }
-
-  bool empty() const { return head_.load(std::memory_order_acquire) == tail_.load(std::memory_order_acquire); }
-
-  bool full() const {
-    uint8_t next_tail = (tail_.load(std::memory_order_relaxed) + 1) % SIZE;
-    return next_tail == head_.load(std::memory_order_acquire);
-  }
-
-  // Set the FreeRTOS task handle to notify when items are pushed to the queue
-  // This enables efficient wake-up of a consumer task that's waiting for data
-  // @param task The FreeRTOS task handle to notify, or nullptr to disable notifications
-  void set_task_to_notify(TaskHandle_t task) { task_to_notify_ = task; }
-
- protected:
-  T *buffer_[SIZE];
-  // Atomic: written by producer (push/increment), read+reset by consumer (get_and_reset)
-  std::atomic<uint16_t> dropped_count_;  // 65535 max - more than enough for drop tracking
-  // Atomic: written by consumer (pop), read by producer (push) to check if full
-  // Using uint8_t limits queue size to 255 elements but saves memory and ensures
-  // atomic operations are efficient on all platforms
-  std::atomic<uint8_t> head_;
-  // Atomic: written by producer (push), read by consumer (pop) to check if empty
-  std::atomic<uint8_t> tail_;
-  // Task handle for notification (optional)
-  TaskHandle_t task_to_notify_;
-};
-
-}  // namespace esphome
-
-#endif  // defined(USE_ESP32) || defined(USE_LIBRETINY)
--- a/esphome/core/scheduler.cpp
+++ b/esphome/core/scheduler.cpp
@@ -7,7 +7,6 @@
 #include "esphome/core/log.h"
 #include <algorithm>
 #include <cinttypes>
-#include <cstring>

 namespace esphome {

@@ -18,138 +17,75 @@ static const uint32_t MAX_LOGICALLY_DELETED_ITEMS = 10;
 // Uncomment to debug scheduler
 // #define ESPHOME_DEBUG_SCHEDULER

-#ifdef ESPHOME_DEBUG_SCHEDULER
-// Helper to validate that a pointer looks like it's in static memory
-static void validate_static_string(const char *name) {
-  if (name == nullptr)
-    return;
-
-  // This is a heuristic check - stack and heap pointers are typically
-  // much higher in memory than static data
-  uintptr_t addr = reinterpret_cast<uintptr_t>(name);
-
-  // Create a stack variable to compare against
-  int stack_var;
-  uintptr_t stack_addr = reinterpret_cast<uintptr_t>(&stack_var);
-
-  // If the string pointer is near our stack variable, it's likely on the stack
-  // Using 8KB range as ESP32 main task stack is typically 8192 bytes
-  if (addr > (stack_addr - 0x2000) && addr < (stack_addr + 0x2000)) {
-    ESP_LOGW(TAG,
-             "WARNING: Scheduler name '%s' at %p appears to be on the stack - this is unsafe!\n"
-             "         Stack reference at %p",
-             name, name, &stack_var);
-  }
-
-  // Also check if it might be on the heap by seeing if it's in a very different range
-  // This is platform-specific but generally heap is allocated far from static memory
-  static const char *static_str = "test";
-  uintptr_t static_addr = reinterpret_cast<uintptr_t>(static_str);
-
-  // If the address is very far from known static memory, it might be heap
-  if (addr > static_addr + 0x100000 || (static_addr > 0x100000 && addr < static_addr - 0x100000)) {
-    ESP_LOGW(TAG, "WARNING: Scheduler name '%s' at %p might be on heap (static ref at %p)", name, name, static_str);
-  }
-}
-#endif
-
 // A note on locking: the `lock_` lock protects the `items_` and `to_add_` containers. It must be taken when writing to
 // them (i.e. when adding/removing items, but not when changing items). As items are only deleted from the loop task,
 // iterating over them from the loop task is fine; but iterating from any other context requires the lock to be held to
 // avoid the main thread modifying the list while it is being accessed.

-// Common implementation for both timeout and interval
-void HOT Scheduler::set_timer_common_(Component *component, SchedulerItem::Type type, bool is_static_string,
-                                      const void *name_ptr, uint32_t delay, std::function<void()> func) {
-  // Get the name as const char*
-  const char *name_cstr =
-      is_static_string ? static_cast<const char *>(name_ptr) : static_cast<const std::string *>(name_ptr)->c_str();
-
-  // Cancel existing timer if name is not empty
-  if (name_cstr != nullptr && name_cstr[0] != '\0') {
-    this->cancel_item_(component, name_cstr, type);
-  }
-
-  if (delay == SCHEDULER_DONT_RUN)
-    return;
-
-  const auto now = this->millis_();
-
-  // Create and populate the scheduler item
-  auto item = make_unique<SchedulerItem>();
-  item->component = component;
-  item->set_name(name_cstr, !is_static_string);
-  item->type = type;
-  item->callback = std::move(func);
-  item->remove = false;
-
-  // Type-specific setup
-  if (type == SchedulerItem::INTERVAL) {
-    item->interval = delay;
-    // Calculate random offset (0 to interval/2)
-    uint32_t offset = (delay != 0) ? (random_uint32() % delay) / 2 : 0;
-    item->next_execution_ = now + offset;
-  } else {
-    item->interval = 0;
-    item->next_execution_ = now + delay;
-  }
-
-#ifdef ESPHOME_DEBUG_SCHEDULER
-  // Validate static strings in debug mode
-  if (is_static_string && name_cstr != nullptr) {
-    validate_static_string(name_cstr);
-  }
-
-  // Debug logging
-  const char *type_str = (type == SchedulerItem::TIMEOUT) ? "timeout" : "interval";
-  if (type == SchedulerItem::TIMEOUT) {
-    ESP_LOGD(TAG, "set_%s(name='%s/%s', %s=%" PRIu32 ")", type_str, item->get_source(),
-             name_cstr ? name_cstr : "(null)", type_str, delay);
-  } else {
-    ESP_LOGD(TAG, "set_%s(name='%s/%s', %s=%" PRIu32 ", offset=%" PRIu32 ")", type_str, item->get_source(),
-             name_cstr ? name_cstr : "(null)", type_str, delay, static_cast<uint32_t>(item->next_execution_ - now));
-  }
-#endif
-
-  this->push_(std::move(item));
-}
-
-void HOT Scheduler::set_timeout(Component *component, const char *name, uint32_t timeout, std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::TIMEOUT, true, name, timeout, std::move(func));
-}
-
 void HOT Scheduler::set_timeout(Component *component, const std::string &name, uint32_t timeout,
                                std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::TIMEOUT, false, &name, timeout, std::move(func));
+  const auto now = this->millis_();
+
+  if (!name.empty())
+    this->cancel_timeout(component, name);
+
+  if (timeout == SCHEDULER_DONT_RUN)
+    return;
+
+  auto item = make_unique<SchedulerItem>();
+  item->component = component;
+  item->name = name;
+  item->type = SchedulerItem::TIMEOUT;
+  item->next_execution_ = now + timeout;
+  item->callback = std::move(func);
+  item->remove = false;
+#ifdef ESPHOME_DEBUG_SCHEDULER
+  ESP_LOGD(TAG, "set_timeout(name='%s/%s', timeout=%" PRIu32 ")", item->get_source(), name.c_str(), timeout);
+#endif
+  this->push_(std::move(item));
 }
 bool HOT Scheduler::cancel_timeout(Component *component, const std::string &name) {
  return this->cancel_item_(component, name, SchedulerItem::TIMEOUT);
 }
-bool HOT Scheduler::cancel_timeout(Component *component, const char *name) {
-  return this->cancel_item_(component, name, SchedulerItem::TIMEOUT);
-}
 void HOT Scheduler::set_interval(Component *component, const std::string &name, uint32_t interval,
                                 std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::INTERVAL, false, &name, interval, std::move(func));
-}
+  const auto now = this->millis_();

-void HOT Scheduler::set_interval(Component *component, const char *name, uint32_t interval,
-                                 std::function<void()> func) {
-  this->set_timer_common_(component, SchedulerItem::INTERVAL, true, name, interval, std::move(func));
+  if (!name.empty())
+    this->cancel_interval(component, name);
+
+  if (interval == SCHEDULER_DONT_RUN)
+    return;
+
+  // only put offset in lower half
+  uint32_t offset = 0;
+  if (interval != 0)
+    offset = (random_uint32() % interval) / 2;
+
+  auto item = make_unique<SchedulerItem>();
+  item->component = component;
+  item->name = name;
+  item->type = SchedulerItem::INTERVAL;
+  item->interval = interval;
+  item->next_execution_ = now + offset;
+  item->callback = std::move(func);
+  item->remove = false;
+#ifdef ESPHOME_DEBUG_SCHEDULER
+  ESP_LOGD(TAG, "set_interval(name='%s/%s', interval=%" PRIu32 ", offset=%" PRIu32 ")", item->get_source(),
+           name.c_str(), interval, offset);
+#endif
+  this->push_(std::move(item));
 }
 bool HOT Scheduler::cancel_interval(Component *component, const std::string &name) {
  return this->cancel_item_(component, name, SchedulerItem::INTERVAL);
 }
-bool HOT Scheduler::cancel_interval(Component *component, const char *name) {
-  return this->cancel_item_(component, name, SchedulerItem::INTERVAL);
-}

 struct RetryArgs {
  std::function<RetryResult(uint8_t)> func;
  uint8_t retry_countdown;
  uint32_t current_interval;
  Component *component;
-  std::string name;  // Keep as std::string since retry uses it dynamically
+  std::string name;
  float backoff_increase_factor;
  Scheduler *scheduler;
 };
@@ -218,7 +154,7 @@ void HOT Scheduler::call() {
  if (now - last_print > 2000) {
    last_print = now;
    std::vector<std::unique_ptr<SchedulerItem>> old_items;
-    ESP_LOGD(TAG, "Items: count=%zu, now=%" PRIu64 " (%u, %" PRIu32 ")", this->items_.size(), now, this->millis_major_,
+    ESP_LOGD(TAG, "Items: count=%u, now=%" PRIu64 " (%u, %" PRIu32 ")", this->items_.size(), now, this->millis_major_,
             this->last_millis_);
    while (!this->empty_()) {
      this->lock_.lock();
@@ -226,9 +162,8 @@ void HOT Scheduler::call() {
      this->pop_raw_();
      this->lock_.unlock();

-      const char *name = item->get_name();
      ESP_LOGD(TAG, "  %s '%s/%s' interval=%" PRIu32 " next_execution in %" PRIu64 "ms at %" PRIu64,
-               item->get_type_str(), item->get_source(), name ? name : "(null)", item->interval,
+               item->get_type_str(), item->get_source(), item->name.c_str(), item->interval,
               item->next_execution_ - now, item->next_execution_);

      old_items.push_back(std::move(item));
@@ -285,10 +220,9 @@ void HOT Scheduler::call() {
      App.set_current_component(item->component);

 #ifdef ESPHOME_DEBUG_SCHEDULER
-      const char *item_name = item->get_name();
      ESP_LOGV(TAG, "Running %s '%s/%s' with interval=%" PRIu32 " next_execution=%" PRIu64 " (now=%" PRIu64 ")",
-               item->get_type_str(), item->get_source(), item_name ? item_name : "(null)", item->interval,
-               item->next_execution_, now);
+               item->get_type_str(), item->get_source(), item->name.c_str(), item->interval, item->next_execution_,
+               now);
 #endif

      // Warning: During callback(), a lot of stuff can happen, including:
@@ -364,33 +298,19 @@ void HOT Scheduler::push_(std::unique_ptr<Scheduler::SchedulerItem> item) {
  LockGuard guard{this->lock_};
  this->to_add_.push_back(std::move(item));
 }
-// Common implementation for cancel operations
-bool HOT Scheduler::cancel_item_common_(Component *component, bool is_static_string, const void *name_ptr,
-                                        SchedulerItem::Type type) {
-  // Get the name as const char*
-  const char *name_cstr =
-      is_static_string ? static_cast<const char *>(name_ptr) : static_cast<const std::string *>(name_ptr)->c_str();
-
-  // Handle null or empty names
-  if (name_cstr == nullptr)
-    return false;
-
+bool HOT Scheduler::cancel_item_(Component *component, const std::string &name, Scheduler::SchedulerItem::Type type) {
  // obtain lock because this function iterates and can be called from non-loop task context
  LockGuard guard{this->lock_};
  bool ret = false;
-
  for (auto &it : this->items_) {
-    const char *item_name = it->get_name();
-    if (it->component == component && item_name != nullptr && strcmp(name_cstr, item_name) == 0 && it->type == type &&
-        !it->remove) {
+    if (it->component == component && it->name == name && it->type == type && !it->remove) {
      to_remove_++;
      it->remove = true;
      ret = true;
    }
  }
  for (auto &it : this->to_add_) {
-    const char *item_name = it->get_name();
-    if (it->component == component && item_name != nullptr && strcmp(name_cstr, item_name) == 0 && it->type == type) {
+    if (it->component == component && it->name == name && it->type == type) {
      it->remove = true;
      ret = true;
    }
@@ -398,15 +318,6 @@ bool HOT Scheduler::cancel_item_common_(Component *component, bool is_static_str

  return ret;
 }
-
-bool HOT Scheduler::cancel_item_(Component *component, const std::string &name, Scheduler::SchedulerItem::Type type) {
-  return this->cancel_item_common_(component, false, &name, type);
-}
-
-bool HOT Scheduler::cancel_item_(Component *component, const char *name, SchedulerItem::Type type) {
-  return this->cancel_item_common_(component, true, name, type);
-}
-
 uint64_t Scheduler::millis_() {
  // Get the current 32-bit millis value
  const uint32_t now = millis();
--- a/esphome/core/scheduler.h
+++ b/esphome/core/scheduler.h
@@ -12,40 +12,11 @@ class Component;

 class Scheduler {
 public:
-  // Public API - accepts std::string for backward compatibility
  void set_timeout(Component *component, const std::string &name, uint32_t timeout, std::function<void()> func);
-
-  /** Set a timeout with a const char* name.
-   *
-   * IMPORTANT: The provided name pointer must remain valid for the lifetime of the scheduler item.
-   * This means the name should be:
-   *   - A string literal (e.g., "update")
-   *   - A static const char* variable
-   *   - A pointer with lifetime >= the scheduled task
-   *
-   * For dynamic strings, use the std::string overload instead.
-   */
-  void set_timeout(Component *component, const char *name, uint32_t timeout, std::function<void()> func);
-
  bool cancel_timeout(Component *component, const std::string &name);
-  bool cancel_timeout(Component *component, const char *name);
-
  void set_interval(Component *component, const std::string &name, uint32_t interval, std::function<void()> func);
-
-  /** Set an interval with a const char* name.
-   *
-   * IMPORTANT: The provided name pointer must remain valid for the lifetime of the scheduler item.
-   * This means the name should be:
-   *   - A string literal (e.g., "update")
-   *   - A static const char* variable
-   *   - A pointer with lifetime >= the scheduled task
-   *
-   * For dynamic strings, use the std::string overload instead.
-   */
-  void set_interval(Component *component, const char *name, uint32_t interval, std::function<void()> func);
-
  bool cancel_interval(Component *component, const std::string &name);
-  bool cancel_interval(Component *component, const char *name);
+
  void set_retry(Component *component, const std::string &name, uint32_t initial_wait_time, uint8_t max_attempts,
                 std::function<RetryResult(uint8_t)> func, float backoff_increase_factor = 1.0f);
  bool cancel_retry(Component *component, const std::string &name);
@@ -65,86 +36,32 @@ class Scheduler {
    // with a 16-bit rollover counter to create a 64-bit time that won't roll over for
    // billions of years. This ensures correct scheduling even when devices run for months.
    uint64_t next_execution_;
-
-    // Optimized name storage using tagged union
-    union {
-      const char *static_name;  // For string literals (no allocation)
-      char *dynamic_name;       // For allocated strings
-    } name_;
-
+    std::string name;
    std::function<void()> callback;
-
-    // Bit-packed fields to minimize padding
-    enum Type : uint8_t { TIMEOUT, INTERVAL } type : 1;
-    bool remove : 1;
-    bool name_is_dynamic : 1;  // True if name was dynamically allocated (needs delete[])
-    // 5 bits padding
-
-    // Constructor
-    SchedulerItem()
-        : component(nullptr), interval(0), next_execution_(0), type(TIMEOUT), remove(false), name_is_dynamic(false) {
-      name_.static_name = nullptr;
-    }
-
-    // Destructor to clean up dynamic names
-    ~SchedulerItem() {
-      if (name_is_dynamic) {
-        delete[] name_.dynamic_name;
-      }
-    }
-
-    // Delete copy operations to prevent accidental copies
-    SchedulerItem(const SchedulerItem &) = delete;
-    SchedulerItem &operator=(const SchedulerItem &) = delete;
-
-    // Default move operations
-    SchedulerItem(SchedulerItem &&) = default;
-    SchedulerItem &operator=(SchedulerItem &&) = default;
-
-    // Helper to get the name regardless of storage type
-    const char *get_name() const { return name_is_dynamic ? name_.dynamic_name : name_.static_name; }
-
-    // Helper to set name with proper ownership
-    void set_name(const char *name, bool make_copy = false) {
-      // Clean up old dynamic name if any
-      if (name_is_dynamic && name_.dynamic_name) {
-        delete[] name_.dynamic_name;
-        name_is_dynamic = false;
-      }
-
-      if (!name || !name[0]) {
-        name_.static_name = nullptr;
-      } else if (make_copy) {
-        // Make a copy for dynamic strings
-        size_t len = strlen(name);
-        name_.dynamic_name = new char[len + 1];
-        memcpy(name_.dynamic_name, name, len + 1);
-        name_is_dynamic = true;
-      } else {
-        // Use static string directly
-        name_.static_name = name;
-      }
-    }
+    enum Type : uint8_t { TIMEOUT, INTERVAL } type;
+    bool remove;

    static bool cmp(const std::unique_ptr<SchedulerItem> &a, const std::unique_ptr<SchedulerItem> &b);
-    const char *get_type_str() const { return (type == TIMEOUT) ? "timeout" : "interval"; }
-    const char *get_source() const { return component ? component->get_component_source() : "unknown"; }
+    const char *get_type_str() {
+      switch (this->type) {
+        case SchedulerItem::INTERVAL:
+          return "interval";
+        case SchedulerItem::TIMEOUT:
+          return "timeout";
+        default:
+          return "";
+      }
+    }
+    const char *get_source() {
+      return this->component != nullptr ? this->component->get_component_source() : "unknown";
+    }
  };

-  // Common implementation for both timeout and interval
-  void set_timer_common_(Component *component, SchedulerItem::Type type, bool is_static_string, const void *name_ptr,
-                         uint32_t delay, std::function<void()> func);
-
  uint64_t millis_();
  void cleanup_();
  void pop_raw_();
  void push_(std::unique_ptr<SchedulerItem> item);
-  // Common implementation for cancel operations
-  bool cancel_item_common_(Component *component, bool is_static_string, const void *name_ptr, SchedulerItem::Type type);
-
  bool cancel_item_(Component *component, const std::string &name, SchedulerItem::Type type);
-  bool cancel_item_(Component *component, const char *name, SchedulerItem::Type type);
-
  bool empty_() {
    this->cleanup_();
    return this->items_.empty();
--- a/esphome/cpp_generator.py
+++ b/esphome/cpp_generator.py
@@ -617,7 +617,7 @@ def set_cpp_standard(standard: str) -> None:
    """Set C++ standard with compiler flag `-std={standard}`."""
    CORE.add_build_unflag("-std=gnu++11")
    CORE.add_build_unflag("-std=gnu++14")
-    CORE.add_build_unflag("-std=gnu++17")
+    CORE.add_build_unflag("-std=gnu++20")
    CORE.add_build_unflag("-std=gnu++23")
    CORE.add_build_unflag("-std=gnu++2a")
    CORE.add_build_unflag("-std=gnu++2b")
--- a/esphome/idf_component.yml
+++ b/esphome/idf_component.yml
@@ -1,19 +1,13 @@
 dependencies:
-  espressif/esp-tflite-micro:
-    version: 1.3.3~1
-  espressif/esp32-camera:
-    version: 2.0.15
-  espressif/mdns:
-    version: 1.8.2
-  espressif/esp_wifi_remote:
-    version: 0.10.2
+  esp-tflite-micro:
+    git: https://github.com/espressif/esp-tflite-micro.git
+    version: v1.3.1
+  esp32_camera:
+    git: https://github.com/espressif/esp32-camera.git
+    version: v2.0.15
+  mdns:
+    git: https://github.com/espressif/esp-protocols.git
+    version: mdns-v1.8.2
+    path: components/mdns
    rules:
-      - if: "target in [esp32h2, esp32p4]"
-  espressif/eppp_link:
-    version: 0.2.0
-    rules:
-      - if: "target in [esp32h2, esp32p4]"
-  espressif/esp_hosted:
-    version: 2.0.11
-    rules:
-      - if: "target in [esp32h2, esp32p4]"
+      - if: "idf_version >=5.0"
--- a/platformio.ini
+++ b/platformio.ini
@@ -47,11 +47,11 @@ lib_deps =
    lvgl/lvgl@8.4.0                                       ; lvgl
 build_flags =
    -DESPHOME_LOG_LEVEL=ESPHOME_LOG_LEVEL_VERY_VERBOSE
-    -std=gnu++20
+    -std=gnu++17
 build_unflags =
    -std=gnu++11
    -std=gnu++14
-    -std=gnu++17
+    -std=gnu++20
    -std=gnu++23
    -std=gnu++2a
    -std=gnu++2b
@@ -560,7 +560,7 @@ lib_deps =
 build_flags =
    ${common.build_flags}
    -DUSE_HOST
-    -std=c++20
+    -std=c++17
 build_unflags =
    ${common.build_unflags}

--- a/requirements_test.txt
+++ b/requirements_test.txt
@@ -1,6 +1,6 @@
 pylint==3.3.7
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.12.1  # also change in .pre-commit-config.yaml when updating
+ruff==0.12.0  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.20.0  # also change in .pre-commit-config.yaml when updating
 pre-commit

--- a/script/api_protobuf/api_protobuf.py
+++ b/script/api_protobuf/api_protobuf.py
@@ -886,7 +886,7 @@ def build_message_type(
        public_content.append("#ifdef HAS_PROTO_MESSAGE_DUMP")
        snake_name = camel_to_snake(desc.name)
        public_content.append(
-            f'const char *message_name() const override {{ return "{snake_name}"; }}'
+            f'static constexpr const char *message_name() {{ return "{snake_name}"; }}'
        )
        public_content.append("#endif")

@@ -1356,7 +1356,7 @@ def main() -> None:
    hpp += "  template<typename T>\n"
    hpp += "  bool send_message(const T &msg) {\n"
    hpp += "#ifdef HAS_PROTO_MESSAGE_DUMP\n"
-    hpp += "    this->log_send_message_(msg.message_name(), msg.dump());\n"
+    hpp += "    this->log_send_message_(T::message_name(), msg.dump());\n"
    hpp += "#endif\n"
    hpp += "    return this->send_message_(msg, T::MESSAGE_TYPE);\n"
    hpp += "  }\n\n"
--- a/script/run-in-env.py
+++ b/script/run-in-env.py
--- a/tests/components/esp32_hosted/common.yaml
+++ b/tests/components/esp32_hosted/common.yaml
@@ -1,15 +0,0 @@
-esp32_hosted:
-  variant: ESP32C6
-  slot: 1
-  active_high: true
-  reset_pin: GPIO15
-  cmd_pin: GPIO13
-  clk_pin: GPIO12
-  d0_pin: GPIO11
-  d1_pin: GPIO10
-  d2_pin: GPIO9
-  d3_pin: GPIO8
-
-wifi:
-  ssid: MySSID
-  password: password1
--- a/tests/components/esp32_hosted/test.esp32-p4-idf.yaml
+++ b/tests/components/esp32_hosted/test.esp32-p4-idf.yaml
@@ -1 +0,0 @@
-<<: !include common.yaml
--- a/tests/integration/fixtures/api_vv_logging.yaml
+++ b/tests/integration/fixtures/api_vv_logging.yaml
@@ -1,89 +0,0 @@
-esphome:
-  name: vv-logging-test
-
-host:
-
-api:
-
-logger:
-  level: VERY_VERBOSE
-  # Enable VV logging for API components where the issue occurs
-  logs:
-    api.connection: VERY_VERBOSE
-    api.service: VERY_VERBOSE
-    api.proto: VERY_VERBOSE
-    sensor: VERY_VERBOSE
-
-# Create many sensors that update frequently to generate API traffic
-# This will cause many messages to be batched and sent, triggering the
-# code path where VV logging could cause buffer corruption
-sensor:
-  - platform: template
-    name: "Test Sensor 1"
-    lambda: 'return millis() / 1000.0;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 2"
-    lambda: 'return (millis() / 1000.0) + 10;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 3"
-    lambda: 'return (millis() / 1000.0) + 20;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 4"
-    lambda: 'return (millis() / 1000.0) + 30;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 5"
-    lambda: 'return (millis() / 1000.0) + 40;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 6"
-    lambda: 'return (millis() / 1000.0) + 50;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 7"
-    lambda: 'return (millis() / 1000.0) + 60;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 8"
-    lambda: 'return (millis() / 1000.0) + 70;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 9"
-    lambda: 'return (millis() / 1000.0) + 80;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-  - platform: template
-    name: "Test Sensor 10"
-    lambda: 'return (millis() / 1000.0) + 90;'
-    update_interval: 50ms
-    unit_of_measurement: "s"
-
-# Add some binary sensors too for variety
-binary_sensor:
-  - platform: template
-    name: "Test Binary 1"
-    lambda: 'return (millis() / 1000) % 2 == 0;'
-
-  - platform: template
-    name: "Test Binary 2"
-    lambda: 'return (millis() / 1000) % 3 == 0;'
--- a/tests/integration/fixtures/scheduler_string_test.yaml
+++ b/tests/integration/fixtures/scheduler_string_test.yaml
@@ -1,164 +0,0 @@
-esphome:
-  name: scheduler-string-test
-  on_boot:
-    priority: -100
-    then:
-      - logger.log: "Starting scheduler string tests"
-  platformio_options:
-    build_flags:
-      - "-DESPHOME_DEBUG_SCHEDULER"  # Enable scheduler debug logging
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-globals:
-  - id: timeout_counter
-    type: int
-    initial_value: '0'
-  - id: interval_counter
-    type: int
-    initial_value: '0'
-  - id: dynamic_counter
-    type: int
-    initial_value: '0'
-  - id: static_tests_done
-    type: bool
-    initial_value: 'false'
-  - id: dynamic_tests_done
-    type: bool
-    initial_value: 'false'
-  - id: results_reported
-    type: bool
-    initial_value: 'false'
-
-script:
-  - id: test_static_strings
-    then:
-      - logger.log: "Testing static string timeouts and intervals"
-      - lambda: |-
-          auto *component1 = id(test_sensor1);
-          // Test 1: Static string literals with set_timeout
-          App.scheduler.set_timeout(component1, "static_timeout_1", 50, []() {
-            ESP_LOGI("test", "Static timeout 1 fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 2: Static const char* with set_timeout
-          static const char* TIMEOUT_NAME = "static_timeout_2";
-          App.scheduler.set_timeout(component1, TIMEOUT_NAME, 100, []() {
-            ESP_LOGI("test", "Static timeout 2 fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 3: Static string literal with set_interval
-          App.scheduler.set_interval(component1, "static_interval_1", 200, []() {
-            ESP_LOGI("test", "Static interval 1 fired, count: %d", id(interval_counter));
-            id(interval_counter) += 1;
-            if (id(interval_counter) >= 3) {
-              App.scheduler.cancel_interval(id(test_sensor1), "static_interval_1");
-              ESP_LOGI("test", "Cancelled static interval 1");
-            }
-          });
-
-          // Test 4: Empty string (should be handled safely)
-          App.scheduler.set_timeout(component1, "", 150, []() {
-            ESP_LOGI("test", "Empty string timeout fired");
-          });
-
-          // Test 5: Cancel timeout with const char* literal
-          App.scheduler.set_timeout(component1, "cancel_static_timeout", 5000, []() {
-            ESP_LOGI("test", "This static timeout should be cancelled");
-          });
-          // Cancel using const char* directly
-          App.scheduler.cancel_timeout(component1, "cancel_static_timeout");
-          ESP_LOGI("test", "Cancelled static timeout using const char*");
-
-  - id: test_dynamic_strings
-    then:
-      - logger.log: "Testing dynamic string timeouts and intervals"
-      - lambda: |-
-          auto *component2 = id(test_sensor2);
-
-          // Test 6: Dynamic string with set_timeout (std::string)
-          std::string dynamic_name = "dynamic_timeout_" + std::to_string(id(dynamic_counter)++);
-          App.scheduler.set_timeout(component2, dynamic_name, 100, []() {
-            ESP_LOGI("test", "Dynamic timeout fired");
-            id(timeout_counter) += 1;
-          });
-
-          // Test 7: Dynamic string with set_interval
-          std::string interval_name = "dynamic_interval_" + std::to_string(id(dynamic_counter)++);
-          App.scheduler.set_interval(component2, interval_name, 250, [interval_name]() {
-            ESP_LOGI("test", "Dynamic interval fired: %s", interval_name.c_str());
-            id(interval_counter) += 1;
-            if (id(interval_counter) >= 6) {
-              App.scheduler.cancel_interval(id(test_sensor2), interval_name);
-              ESP_LOGI("test", "Cancelled dynamic interval");
-            }
-          });
-
-          // Test 8: Cancel with different string object but same content
-          std::string cancel_name = "cancel_test";
-          App.scheduler.set_timeout(component2, cancel_name, 2000, []() {
-            ESP_LOGI("test", "This should be cancelled");
-          });
-
-          // Cancel using a different string object
-          std::string cancel_name_2 = "cancel_test";
-          App.scheduler.cancel_timeout(component2, cancel_name_2);
-          ESP_LOGI("test", "Cancelled timeout using different string object");
-
-  - id: report_results
-    then:
-      - lambda: |-
-          ESP_LOGI("test", "Final results - Timeouts: %d, Intervals: %d",
-                   id(timeout_counter), id(interval_counter));
-
-sensor:
-  - platform: template
-    name: Test Sensor 1
-    id: test_sensor1
-    lambda: return 1.0;
-    update_interval: never
-
-  - platform: template
-    name: Test Sensor 2
-    id: test_sensor2
-    lambda: return 2.0;
-    update_interval: never
-
-interval:
-  # Run static string tests after boot - using script to run once
-  - interval: 0.1s
-    then:
-      - if:
-          condition:
-            lambda: 'return id(static_tests_done) == false;'
-          then:
-            - lambda: 'id(static_tests_done) = true;'
-            - script.execute: test_static_strings
-            - logger.log: "Started static string tests"
-
-  # Run dynamic string tests after static tests
-  - interval: 0.2s
-    then:
-      - if:
-          condition:
-            lambda: 'return id(static_tests_done) && !id(dynamic_tests_done);'
-          then:
-            - lambda: 'id(dynamic_tests_done) = true;'
-            - delay: 0.2s
-            - script.execute: test_dynamic_strings
-
-  # Report results after all tests
-  - interval: 0.2s
-    then:
-      - if:
-          condition:
-            lambda: 'return id(dynamic_tests_done) && !id(results_reported);'
-          then:
-            - lambda: 'id(results_reported) = true;'
-            - delay: 1s
-            - script.execute: report_results
--- a/tests/integration/test_api_vv_logging.py
+++ b/tests/integration/test_api_vv_logging.py
@@ -1,83 +0,0 @@
-"""Integration test for API with VERY_VERBOSE logging to verify no buffer corruption."""
-
-from __future__ import annotations
-
-import asyncio
-from typing import Any
-
-from aioesphomeapi import LogLevel
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_api_vv_logging(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test that VERY_VERBOSE logging doesn't cause buffer corruption with API messages."""
-
-    # Track that we're receiving VV log messages and sensor updates
-    vv_logs_received = 0
-    sensor_updates_received = 0
-    errors_detected = []
-
-    def on_log(msg: Any) -> None:
-        """Capture log messages."""
-        nonlocal vv_logs_received
-        # msg is a SubscribeLogsResponse object with 'message' attribute
-        # The message field is always bytes
-        message_text = msg.message.decode("utf-8", errors="replace")
-
-        # Only count VV logs specifically
-        if "[VV]" in message_text:
-            vv_logs_received += 1
-
-        # Check for assertion or error messages
-        if "assert" in message_text.lower() or "error" in message_text.lower():
-            errors_detected.append(message_text)
-
-    # Write, compile and run the ESPHome device
-    async with run_compiled(yaml_config), api_client_connected() as client:
-        # Subscribe to VERY_VERBOSE logs - this enables the code path that could cause corruption
-        client.subscribe_logs(on_log, log_level=LogLevel.LOG_LEVEL_VERY_VERBOSE)
-
-        # Wait for device to be ready
-        device_info = await client.device_info()
-        assert device_info is not None
-        assert device_info.name == "vv-logging-test"
-
-        # Subscribe to sensor states
-        states = {}
-
-        def on_state(state):
-            nonlocal sensor_updates_received
-            sensor_updates_received += 1
-            states[state.key] = state
-
-        client.subscribe_states(on_state)
-
-        # List entities to find our test sensors
-        entity_info, _ = await client.list_entities_services()
-
-        # Count sensors
-        sensor_count = sum(1 for e in entity_info if hasattr(e, "unit_of_measurement"))
-        assert sensor_count >= 10, f"Expected at least 10 sensors, got {sensor_count}"
-
-        # Wait for sensor updates to flow with VV logging active
-        # The sensors update every 50ms, so we should get many updates
-        await asyncio.sleep(0.25)
-
-        # Verify we received both VV logs and sensor updates
-        assert vv_logs_received > 0, "Expected to receive VERY_VERBOSE log messages"
-        assert sensor_updates_received > 10, (
-            f"Expected many sensor updates, got {sensor_updates_received}"
-        )
-
-        # Check for any errors
-        if errors_detected:
-            pytest.fail(f"Errors detected during test: {errors_detected}")
-
-        # The test passes if we didn't hit any assertions or buffer corruption
--- a/tests/integration/test_scheduler_string_test.py
+++ b/tests/integration/test_scheduler_string_test.py
@@ -1,166 +0,0 @@
-"""Test scheduler string optimization with static and dynamic strings."""
-
-import asyncio
-import re
-
-import pytest
-
-from .types import APIClientConnectedFactory, RunCompiledFunction
-
-
-@pytest.mark.asyncio
-async def test_scheduler_string_test(
-    yaml_config: str,
-    run_compiled: RunCompiledFunction,
-    api_client_connected: APIClientConnectedFactory,
-) -> None:
-    """Test that scheduler handles both static and dynamic strings correctly."""
-    # Track counts
-    timeout_count = 0
-    interval_count = 0
-
-    # Events for each test completion
-    static_timeout_1_fired = asyncio.Event()
-    static_timeout_2_fired = asyncio.Event()
-    static_interval_fired = asyncio.Event()
-    static_interval_cancelled = asyncio.Event()
-    empty_string_timeout_fired = asyncio.Event()
-    static_timeout_cancelled = asyncio.Event()
-    dynamic_timeout_fired = asyncio.Event()
-    dynamic_interval_fired = asyncio.Event()
-    cancel_test_done = asyncio.Event()
-    final_results_logged = asyncio.Event()
-
-    # Track interval counts
-    static_interval_count = 0
-    dynamic_interval_count = 0
-
-    def on_log_line(line: str) -> None:
-        nonlocal \
-            timeout_count, \
-            interval_count, \
-            static_interval_count, \
-            dynamic_interval_count
-
-        # Strip ANSI color codes
-        clean_line = re.sub(r"\x1b\[[0-9;]*m", "", line)
-
-        # Check for static timeout completions
-        if "Static timeout 1 fired" in clean_line:
-            static_timeout_1_fired.set()
-            timeout_count += 1
-
-        elif "Static timeout 2 fired" in clean_line:
-            static_timeout_2_fired.set()
-            timeout_count += 1
-
-        # Check for static interval
-        elif "Static interval 1 fired" in clean_line:
-            match = re.search(r"count: (\d+)", clean_line)
-            if match:
-                static_interval_count = int(match.group(1))
-                static_interval_fired.set()
-
-        elif "Cancelled static interval 1" in clean_line:
-            static_interval_cancelled.set()
-
-        # Check for empty string timeout
-        elif "Empty string timeout fired" in clean_line:
-            empty_string_timeout_fired.set()
-
-        # Check for static timeout cancellation
-        elif "Cancelled static timeout using const char*" in clean_line:
-            static_timeout_cancelled.set()
-
-        # Check for dynamic string tests
-        elif "Dynamic timeout fired" in clean_line:
-            dynamic_timeout_fired.set()
-            timeout_count += 1
-
-        elif "Dynamic interval fired" in clean_line:
-            dynamic_interval_count += 1
-            dynamic_interval_fired.set()
-
-        # Check for cancel test
-        elif "Cancelled timeout using different string object" in clean_line:
-            cancel_test_done.set()
-
-        # Check for final results
-        elif "Final results" in clean_line:
-            match = re.search(r"Timeouts: (\d+), Intervals: (\d+)", clean_line)
-            if match:
-                timeout_count = int(match.group(1))
-                interval_count = int(match.group(2))
-                final_results_logged.set()
-
-    async with (
-        run_compiled(yaml_config, line_callback=on_log_line),
-        api_client_connected() as client,
-    ):
-        # Verify we can connect
-        device_info = await client.device_info()
-        assert device_info is not None
-        assert device_info.name == "scheduler-string-test"
-
-        # Wait for static string tests
-        try:
-            await asyncio.wait_for(static_timeout_1_fired.wait(), timeout=0.5)
-        except asyncio.TimeoutError:
-            pytest.fail("Static timeout 1 did not fire within 0.5 seconds")
-
-        try:
-            await asyncio.wait_for(static_timeout_2_fired.wait(), timeout=0.5)
-        except asyncio.TimeoutError:
-            pytest.fail("Static timeout 2 did not fire within 0.5 seconds")
-
-        try:
-            await asyncio.wait_for(static_interval_fired.wait(), timeout=1.0)
-        except asyncio.TimeoutError:
-            pytest.fail("Static interval did not fire within 1 second")
-
-        try:
-            await asyncio.wait_for(static_interval_cancelled.wait(), timeout=2.0)
-        except asyncio.TimeoutError:
-            pytest.fail("Static interval was not cancelled within 2 seconds")
-
-        # Verify static interval ran at least 3 times
-        assert static_interval_count >= 2, (
-            f"Expected static interval to run at least 3 times, got {static_interval_count + 1}"
-        )
-
-        # Verify static timeout was cancelled
-        assert static_timeout_cancelled.is_set(), (
-            "Static timeout should have been cancelled"
-        )
-
-        # Wait for dynamic string tests
-        try:
-            await asyncio.wait_for(dynamic_timeout_fired.wait(), timeout=1.0)
-        except asyncio.TimeoutError:
-            pytest.fail("Dynamic timeout did not fire within 1 second")
-
-        try:
-            await asyncio.wait_for(dynamic_interval_fired.wait(), timeout=1.5)
-        except asyncio.TimeoutError:
-            pytest.fail("Dynamic interval did not fire within 1.5 seconds")
-
-        # Wait for cancel test
-        try:
-            await asyncio.wait_for(cancel_test_done.wait(), timeout=1.0)
-        except asyncio.TimeoutError:
-            pytest.fail("Cancel test did not complete within 1 second")
-
-        # Wait for final results
-        try:
-            await asyncio.wait_for(final_results_logged.wait(), timeout=4.0)
-        except asyncio.TimeoutError:
-            pytest.fail("Final results were not logged within 4 seconds")
-
-        # Verify results
-        assert timeout_count >= 3, f"Expected at least 3 timeouts, got {timeout_count}"
-        assert interval_count >= 3, (
-            f"Expected at least 3 interval fires, got {interval_count}"
-        )
-
-        # Empty string timeout DOES fire (scheduler accepts empty names)
-        assert empty_string_timeout_fired.is_set(), "Empty string timeout should fire"
--- a/tests/test_build_components/build_components_base.esp32-p4-idf.yaml
+++ b/tests/test_build_components/build_components_base.esp32-p4-idf.yaml
@@ -15,3 +15,4 @@ packages:
    file: $component_test_file
    vars:
      component_test_file: $component_test_file
+