Merge branch 'ota_fix_s3' into integration

Co-authored-by: Jonathan Swoboda <154711427+swoboda1337@users.noreply.github.com>

.clang-tidy.hash

@@ -1 +1 @@
-4368db58e8f884aff245996b1e8b644cc0796c0bb2fa706d5740d40b823d3ac9
+499db61c1aa55b98b6629df603a56a1ba7aff5a9a7c781a5c1552a9dcd186c08

.github/workflows/stale.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Stale
-        uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f # v10.0.0
+        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
         with:
           debug-only: ${{ github.ref != 'refs/heads/dev' }} # Dry-run when not run on dev branch
           remove-stale-when-updated: true

.pre-commit-config.yaml

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

CODEOWNERS

@@ -160,7 +160,6 @@ esphome/components/esp_ldo/* @clydebarrow
 esphome/components/espnow/* @jesserockz
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/event/* @nohat
-esphome/components/event_emitter/* @Rapsssito
 esphome/components/exposure_notifications/* @OttoWinter
 esphome/components/ezo/* @ssieb
 esphome/components/ezo_pmp/* @carlos-sarmiento

esphome/__main__.py

@@ -14,9 +14,11 @@ from typing import Protocol
 
 import argcomplete
 
+# Note: Do not import modules from esphome.components here, as this would
+# cause them to be loaded before external components are processed, resulting
+# in the built-in version being used instead of the external component one.
 from esphome import const, writer, yaml_util
 import esphome.codegen as cg
-from esphome.components.mqtt import CONF_DISCOVER_IP
 from esphome.config import iter_component_configs, read_config, strip_default_ids
 from esphome.const import (
     ALLOWED_NAME_CHARS,
@@ -240,6 +242,8 @@ def has_ota() -> bool:
 
 def has_mqtt_ip_lookup() -> bool:
     """Check if MQTT is available and IP lookup is supported."""
+    from esphome.components.mqtt import CONF_DISCOVER_IP
+
     if CONF_MQTT not in CORE.config:
         return False
     # Default Enabled
@@ -636,6 +640,13 @@ def command_vscode(args: ArgsProtocol) -> int | None:
 
 
 def command_compile(args: ArgsProtocol, config: ConfigType) -> int | None:
+    # Set memory analysis options in config
+    if args.analyze_memory:
+        config.setdefault(CONF_ESPHOME, {})["analyze_memory"] = True
+
+    if args.memory_report:
+        config.setdefault(CONF_ESPHOME, {})["memory_report_file"] = args.memory_report
+
     exit_code = write_cpp(config)
     if exit_code != 0:
         return exit_code
@@ -1042,6 +1053,17 @@ def parse_args(argv):
         help="Only generate source code, do not compile.",
         action="store_true",
     )
+    parser_compile.add_argument(
+        "--analyze-memory",
+        help="Analyze and display memory usage by component after compilation.",
+        action="store_true",
+    )
+    parser_compile.add_argument(
+        "--memory-report",
+        help="Save memory analysis report to a file (supports .json or .txt).",
+        type=str,
+        metavar="FILE",
+    )
 
     parser_upload = subparsers.add_parser(
         "upload",

esphome/components/api/__init__.py

@@ -14,6 +14,7 @@ from esphome.const import (
     CONF_EVENT,
     CONF_ID,
     CONF_KEY,
+    CONF_MAX_CONNECTIONS,
     CONF_ON_CLIENT_CONNECTED,
     CONF_ON_CLIENT_DISCONNECTED,
     CONF_PASSWORD,
@@ -60,7 +61,7 @@ CONF_CUSTOM_SERVICES = "custom_services"
 CONF_HOMEASSISTANT_SERVICES = "homeassistant_services"
 CONF_HOMEASSISTANT_STATES = "homeassistant_states"
 CONF_LISTEN_BACKLOG = "listen_backlog"
-CONF_MAX_CONNECTIONS = "max_connections"
+CONF_MAX_SEND_QUEUE = "max_send_queue"
 
 
 def validate_encryption_key(value):
@@ -183,6 +184,19 @@ CONFIG_SCHEMA = cv.All(
                 host=8,  # Abundant resources
                 ln882x=8,  # Moderate RAM
             ): cv.int_range(min=1, max=20),
+            # Maximum queued send buffers per connection before dropping connection
+            # Each buffer uses ~8-12 bytes overhead plus actual message size
+            # Platform defaults based on available RAM and typical message rates:
+            cv.SplitDefault(
+                CONF_MAX_SEND_QUEUE,
+                esp8266=5,  # Limited RAM, need to fail fast
+                esp32=8,  # More RAM, can buffer more
+                rp2040=5,  # Limited RAM
+                bk72xx=8,  # Moderate RAM
+                rtl87xx=8,  # Moderate RAM
+                host=16,  # Abundant resources
+                ln882x=8,  # Moderate RAM
+            ): cv.int_range(min=1, max=64),
         }
     ).extend(cv.COMPONENT_SCHEMA),
     cv.rename_key(CONF_SERVICES, CONF_ACTIONS),
@@ -205,6 +219,7 @@ async def to_code(config):
         cg.add(var.set_listen_backlog(config[CONF_LISTEN_BACKLOG]))
     if CONF_MAX_CONNECTIONS in config:
         cg.add(var.set_max_connections(config[CONF_MAX_CONNECTIONS]))
+    cg.add_define("API_MAX_SEND_QUEUE", config[CONF_MAX_SEND_QUEUE])
 
     # Set USE_API_SERVICES if any services are enabled
     if config.get(CONF_ACTIONS) or config[CONF_CUSTOM_SERVICES]:

esphome/components/api/api_frame_helper.cpp

@@ -81,7 +81,7 @@ const LogString *api_error_to_logstr(APIError err) {
 
 // Default implementation for loop - handles sending buffered data
 APIError APIFrameHelper::loop() {
-  if (!this->tx_buf_.empty()) {
+  if (this->tx_buf_count_ > 0) {
     APIError err = try_send_tx_buf_();
     if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
       return err;
@@ -103,9 +103,20 @@ APIError APIFrameHelper::handle_socket_write_error_() {
 // Helper method to buffer data from IOVs
 void APIFrameHelper::buffer_data_from_iov_(const struct iovec *iov, int iovcnt, uint16_t total_write_len,
                                            uint16_t offset) {
-  SendBuffer buffer;
-  buffer.size = total_write_len - offset;
-  buffer.data = std::make_unique<uint8_t[]>(buffer.size);
+  // Check if queue is full
+  if (this->tx_buf_count_ >= API_MAX_SEND_QUEUE) {
+    HELPER_LOG("Send queue full (%u buffers), dropping connection", this->tx_buf_count_);
+    this->state_ = State::FAILED;
+    return;
+  }
+
+  uint16_t buffer_size = total_write_len - offset;
+  auto &buffer = this->tx_buf_[this->tx_buf_tail_];
+  buffer = std::make_unique<SendBuffer>(SendBuffer{
+      .data = std::make_unique<uint8_t[]>(buffer_size),
+      .size = buffer_size,
+      .offset = 0,
+  });
 
   uint16_t to_skip = offset;
   uint16_t write_pos = 0;
@@ -118,12 +129,15 @@ void APIFrameHelper::buffer_data_from_iov_(const struct iovec *iov, int iovcnt,
       // Include this segment (partially or fully)
       const uint8_t *src = reinterpret_cast<uint8_t *>(iov[i].iov_base) + to_skip;
       uint16_t len = static_cast<uint16_t>(iov[i].iov_len) - to_skip;
-      std::memcpy(buffer.data.get() + write_pos, src, len);
+      std::memcpy(buffer->data.get() + write_pos, src, len);
       write_pos += len;
       to_skip = 0;
     }
   }
-  this->tx_buf_.push_back(std::move(buffer));
+
+  // Update circular buffer tracking
+  this->tx_buf_tail_ = (this->tx_buf_tail_ + 1) % API_MAX_SEND_QUEUE;
+  this->tx_buf_count_++;
 }
 
 // This method writes data to socket or buffers it
@@ -141,7 +155,7 @@ APIError APIFrameHelper::write_raw_(const struct iovec *iov, int iovcnt, uint16_
 #endif
 
   // Try to send any existing buffered data first if there is any
-  if (!this->tx_buf_.empty()) {
+  if (this->tx_buf_count_ > 0) {
     APIError send_result = try_send_tx_buf_();
     // If real error occurred (not just WOULD_BLOCK), return it
     if (send_result != APIError::OK && send_result != APIError::WOULD_BLOCK) {
@@ -150,7 +164,7 @@ APIError APIFrameHelper::write_raw_(const struct iovec *iov, int iovcnt, uint16_
 
     // If there is still data in the buffer, we can't send, buffer
     // the new data and return
-    if (!this->tx_buf_.empty()) {
+    if (this->tx_buf_count_ > 0) {
       this->buffer_data_from_iov_(iov, iovcnt, total_write_len, 0);
       return APIError::OK;  // Success, data buffered
     }
@@ -178,32 +192,31 @@ APIError APIFrameHelper::write_raw_(const struct iovec *iov, int iovcnt, uint16_
 }
 
 // Common implementation for trying to send buffered data
-// IMPORTANT: Caller MUST ensure tx_buf_ is not empty before calling this method
+// IMPORTANT: Caller MUST ensure tx_buf_count_ > 0 before calling this method
 APIError APIFrameHelper::try_send_tx_buf_() {
   // Try to send from tx_buf - we assume it's not empty as it's the caller's responsibility to check
-  bool tx_buf_empty = false;
-  while (!tx_buf_empty) {
+  while (this->tx_buf_count_ > 0) {
     // Get the first buffer in the queue
-    SendBuffer &front_buffer = this->tx_buf_.front();
+    SendBuffer *front_buffer = this->tx_buf_[this->tx_buf_head_].get();
 
     // Try to send the remaining data in this buffer
-    ssize_t sent = this->socket_->write(front_buffer.current_data(), front_buffer.remaining());
+    ssize_t sent = this->socket_->write(front_buffer->current_data(), front_buffer->remaining());
 
     if (sent == -1) {
       return this->handle_socket_write_error_();
     } else if (sent == 0) {
       // Nothing sent but not an error
       return APIError::WOULD_BLOCK;
-    } else if (static_cast<uint16_t>(sent) < front_buffer.remaining()) {
+    } else if (static_cast<uint16_t>(sent) < front_buffer->remaining()) {
       // Partially sent, update offset
       // Cast to ensure no overflow issues with uint16_t
-      front_buffer.offset += static_cast<uint16_t>(sent);
+      front_buffer->offset += static_cast<uint16_t>(sent);
       return APIError::WOULD_BLOCK;  // Stop processing more buffers if we couldn't send a complete buffer
     } else {
       // Buffer completely sent, remove it from the queue
-      this->tx_buf_.pop_front();
-      // Update empty status for the loop condition
-      tx_buf_empty = this->tx_buf_.empty();
+      this->tx_buf_[this->tx_buf_head_].reset();
+      this->tx_buf_head_ = (this->tx_buf_head_ + 1) % API_MAX_SEND_QUEUE;
+      this->tx_buf_count_--;
       // Continue loop to try sending the next buffer
     }
   }

esphome/components/api/api_frame_helper.h

@@ -1,7 +1,8 @@
 #pragma once
+#include <array>
 #include <cstdint>
-#include <deque>
 #include <limits>
+#include <memory>
 #include <span>
 #include <utility>
 #include <vector>
@@ -17,6 +18,16 @@ namespace esphome::api {
 // uncomment to log raw packets
 //#define HELPER_LOG_PACKETS
 
+// Maximum message size limits to prevent OOM on constrained devices
+// Voice Assistant is our largest user at 1024 bytes per audio chunk
+// Using 2048 + 256 bytes overhead = 2304 bytes total to support voice and future needs
+// ESP8266 has very limited RAM and cannot support voice assistant
+#ifdef USE_ESP8266
+static constexpr uint16_t MAX_MESSAGE_SIZE = 512;  // Keep small for memory constrained ESP8266
+#else
+static constexpr uint16_t MAX_MESSAGE_SIZE = 2304;  // Support voice (1024) + headroom for larger messages
+#endif
+
 // Forward declaration
 struct ClientInfo;
 
@@ -79,7 +90,7 @@ class APIFrameHelper {
   virtual APIError init() = 0;
   virtual APIError loop();
   virtual APIError read_packet(ReadPacketBuffer *buffer) = 0;
-  bool can_write_without_blocking() { return state_ == State::DATA && tx_buf_.empty(); }
+  bool can_write_without_blocking() { return this->state_ == State::DATA && this->tx_buf_count_ == 0; }
   std::string getpeername() { return socket_->getpeername(); }
   int getpeername(struct sockaddr *addr, socklen_t *addrlen) { return socket_->getpeername(addr, addrlen); }
   APIError close() {
@@ -161,7 +172,7 @@ class APIFrameHelper {
   };
 
   // Containers (size varies, but typically 12+ bytes on 32-bit)
-  std::deque<SendBuffer> tx_buf_;
+  std::array<std::unique_ptr<SendBuffer>, API_MAX_SEND_QUEUE> tx_buf_;
   std::vector<struct iovec> reusable_iovs_;
   std::vector<uint8_t> rx_buf_;
 
@@ -174,7 +185,10 @@ class APIFrameHelper {
   State state_{State::INITIALIZE};
   uint8_t frame_header_padding_{0};
   uint8_t frame_footer_size_{0};
-  // 5 bytes total, 3 bytes padding
+  uint8_t tx_buf_head_{0};
+  uint8_t tx_buf_tail_{0};
+  uint8_t tx_buf_count_{0};
+  // 8 bytes total, 0 bytes padding
 
   // Common initialization for both plaintext and noise protocols
   APIError init_common_();

esphome/components/api/api_frame_helper_noise.cpp

@@ -185,6 +185,13 @@ APIError APINoiseFrameHelper::try_read_frame_(std::vector<uint8_t> *frame) {
     return APIError::BAD_HANDSHAKE_PACKET_LEN;
   }
 
+  // Check against maximum message size to prevent OOM
+  if (msg_size > MAX_MESSAGE_SIZE) {
+    state_ = State::FAILED;
+    HELPER_LOG("Bad packet: message size %u exceeds maximum %u", msg_size, MAX_MESSAGE_SIZE);
+    return APIError::BAD_DATA_PACKET;
+  }
+
   // reserve space for body
   if (rx_buf_.size() != msg_size) {
     rx_buf_.resize(msg_size);

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -123,10 +123,10 @@ APIError APIPlaintextFrameHelper::try_read_frame_(std::vector<uint8_t> *frame) {
       continue;
     }
 
-    if (msg_size_varint->as_uint32() > std::numeric_limits<uint16_t>::max()) {
+    if (msg_size_varint->as_uint32() > MAX_MESSAGE_SIZE) {
       state_ = State::FAILED;
       HELPER_LOG("Bad packet: message size %" PRIu32 " exceeds maximum %u", msg_size_varint->as_uint32(),
-                 std::numeric_limits<uint16_t>::max());
+                 MAX_MESSAGE_SIZE);
       return APIError::BAD_DATA_PACKET;
     }
     rx_header_parsed_len_ = msg_size_varint->as_uint16();

esphome/components/ble_client/__init__.py

@@ -116,7 +116,7 @@ CONFIG_SCHEMA = cv.All(
     )
     .extend(cv.COMPONENT_SCHEMA)
     .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
-    esp32_ble_tracker.consume_connection_slots(1, "ble_client"),
+    esp32_ble.consume_connection_slots(1, "ble_client"),
 )
 
 CONF_BLE_CLIENT_ID = "ble_client_id"

esphome/components/bluetooth_proxy/__init__.py

@@ -42,9 +42,7 @@ def validate_connections(config):
             )
     elif config[CONF_ACTIVE]:
         connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        esp32_ble_tracker.consume_connection_slots(connection_slots, "bluetooth_proxy")(
-            config
-        )
+        esp32_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
 
         return {
             **config,
@@ -65,11 +63,11 @@ CONFIG_SCHEMA = cv.All(
                     default=DEFAULT_CONNECTION_SLOTS,
                 ): cv.All(
                     cv.positive_int,
-                    cv.Range(min=1, max=esp32_ble_tracker.IDF_MAX_CONNECTIONS),
+                    cv.Range(min=1, max=esp32_ble.IDF_MAX_CONNECTIONS),
                 ),
                 cv.Optional(CONF_CONNECTIONS): cv.All(
                     cv.ensure_list(CONNECTION_SCHEMA),
-                    cv.Length(min=1, max=esp32_ble_tracker.IDF_MAX_CONNECTIONS),
+                    cv.Length(min=1, max=esp32_ble.IDF_MAX_CONNECTIONS),
                 ),
             }
         )

esphome/components/captive_portal/captive_portal.cpp

@@ -11,14 +11,14 @@ namespace captive_portal {
 static const char *const TAG = "captive_portal";
 
 void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
-  AsyncResponseStream *stream = request->beginResponseStream(F("application/json"));
-  stream->addHeader(F("cache-control"), F("public, max-age=0, must-revalidate"));
+  AsyncResponseStream *stream = request->beginResponseStream(ESPHOME_F("application/json"));
+  stream->addHeader(ESPHOME_F("cache-control"), ESPHOME_F("public, max-age=0, must-revalidate"));
 #ifdef USE_ESP8266
-  stream->print(F("{\"mac\":\""));
+  stream->print(ESPHOME_F("{\"mac\":\""));
   stream->print(get_mac_address_pretty().c_str());
-  stream->print(F("\",\"name\":\""));
+  stream->print(ESPHOME_F("\",\"name\":\""));
   stream->print(App.get_name().c_str());
-  stream->print(F("\",\"aps\":[{}"));
+  stream->print(ESPHOME_F("\",\"aps\":[{}"));
 #else
   stream->printf(R"({"mac":"%s","name":"%s","aps":[{})", get_mac_address_pretty().c_str(), App.get_name().c_str());
 #endif
@@ -29,19 +29,19 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
 
       // Assumes no " in ssid, possible unicode isses?
 #ifdef USE_ESP8266
-    stream->print(F(",{\"ssid\":\""));
+    stream->print(ESPHOME_F(",{\"ssid\":\""));
     stream->print(scan.get_ssid().c_str());
-    stream->print(F("\",\"rssi\":"));
+    stream->print(ESPHOME_F("\",\"rssi\":"));
     stream->print(scan.get_rssi());
-    stream->print(F(",\"lock\":"));
+    stream->print(ESPHOME_F(",\"lock\":"));
     stream->print(scan.get_with_auth());
-    stream->print(F("}"));
+    stream->print(ESPHOME_F("}"));
 #else
     stream->printf(R"(,{"ssid":"%s","rssi":%d,"lock":%d})", scan.get_ssid().c_str(), scan.get_rssi(),
                    scan.get_with_auth());
 #endif
   }
-  stream->print(F("]}"));
+  stream->print(ESPHOME_F("]}"));
   request->send(stream);
 }
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
@@ -52,7 +52,7 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
   ESP_LOGI(TAG, "  Password=" LOG_SECRET("'%s'"), psk.c_str());
   wifi::global_wifi_component->save_wifi_sta(ssid, psk);
   wifi::global_wifi_component->start_scanning();
-  request->redirect(F("/?save"));
+  request->redirect(ESPHOME_F("/?save"));
 }
 
 void CaptivePortal::setup() {
@@ -75,7 +75,7 @@ void CaptivePortal::start() {
 #ifdef USE_ARDUINO
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
-  this->dns_server_->start(53, F("*"), ip);
+  this->dns_server_->start(53, ESPHOME_F("*"), ip);
 #endif
 
   this->initialized_ = true;
@@ -88,10 +88,10 @@ void CaptivePortal::start() {
 }
 
 void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
-  if (req->url() == F("/config.json")) {
+  if (req->url() == ESPHOME_F("/config.json")) {
     this->handle_config(req);
     return;
-  } else if (req->url() == F("/wifisave")) {
+  } else if (req->url() == ESPHOME_F("/wifisave")) {
     this->handle_wifisave(req);
     return;
   }
@@ -100,11 +100,11 @@ void CaptivePortal::handleRequest(AsyncWebServerRequest *req) {
   // This includes OS captive portal detection endpoints which will trigger
   // the captive portal when they don't receive their expected responses
 #ifndef USE_ESP8266
-  auto *response = req->beginResponse(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
+  auto *response = req->beginResponse(200, ESPHOME_F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
 #else
-  auto *response = req->beginResponse_P(200, F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
+  auto *response = req->beginResponse_P(200, ESPHOME_F("text/html"), INDEX_GZ, sizeof(INDEX_GZ));
 #endif
-  response->addHeader(F("Content-Encoding"), F("gzip"));
+  response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("gzip"));
   req->send(response);
 }
 

esphome/components/copy/lock/copy_lock.cpp

@@ -11,7 +11,7 @@ void CopyLock::setup() {
 
   traits.set_assumed_state(source_->traits.get_assumed_state());
   traits.set_requires_code(source_->traits.get_requires_code());
-  traits.set_supported_states(source_->traits.get_supported_states());
+  traits.set_supported_states_mask(source_->traits.get_supported_states_mask());
   traits.set_supports_open(source_->traits.get_supports_open());
 
   this->publish_state(source_->state);

esphome/components/esp32_ble/__init__.py

@@ -1,5 +1,8 @@
+from collections.abc import Callable, MutableMapping
 from enum import Enum
+import logging
 import re
+from typing import Any
 
 from esphome import automation
 import esphome.codegen as cg
@@ -9,16 +12,19 @@ from esphome.const import (
     CONF_ENABLE_ON_BOOT,
     CONF_ESPHOME,
     CONF_ID,
+    CONF_MAX_CONNECTIONS,
     CONF_NAME,
     CONF_NAME_ADD_MAC_SUFFIX,
 )
-from esphome.core import TimePeriod
+from esphome.core import CORE, TimePeriod
 import esphome.final_validate as fv
 
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@jesserockz", "@Rapsssito", "@bdraco"]
 DOMAIN = "esp32_ble"
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class BTLoggers(Enum):
     """Bluetooth logger categories available in ESP-IDF.
@@ -127,6 +133,28 @@ CONF_DISABLE_BT_LOGS = "disable_bt_logs"
 CONF_CONNECTION_TIMEOUT = "connection_timeout"
 CONF_MAX_NOTIFICATIONS = "max_notifications"
 
+# BLE connection limits
+# ESP-IDF CONFIG_BT_ACL_CONNECTIONS has range 1-9, default 4
+# Total instances: 10 (ADV + SCAN + connections)
+# - ADV only: up to 9 connections
+# - SCAN only: up to 9 connections
+# - ADV + SCAN: up to 8 connections
+DEFAULT_MAX_CONNECTIONS = 3
+IDF_MAX_CONNECTIONS = 9
+
+# Connection slot tracking keys
+KEY_ESP32_BLE = "esp32_ble"
+KEY_USED_CONNECTION_SLOTS = "used_connection_slots"
+
+# Export for use by other components (bluetooth_proxy, etc.)
+__all__ = [
+    "DEFAULT_MAX_CONNECTIONS",
+    "IDF_MAX_CONNECTIONS",
+    "KEY_ESP32_BLE",
+    "KEY_USED_CONNECTION_SLOTS",
+    "consume_connection_slots",
+]
+
 NO_BLUETOOTH_VARIANTS = [const.VARIANT_ESP32S2]
 
 esp32_ble_ns = cg.esphome_ns.namespace("esp32_ble")
@@ -183,6 +211,9 @@ CONFIG_SCHEMA = cv.Schema(
             cv.positive_int,
             cv.Range(min=1, max=64),
         ),
+        cv.Optional(CONF_MAX_CONNECTIONS, default=DEFAULT_MAX_CONNECTIONS): cv.All(
+            cv.positive_int, cv.Range(min=1, max=IDF_MAX_CONNECTIONS)
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -230,6 +261,56 @@ def validate_variant(_):
         raise cv.Invalid(f"{variant} does not support Bluetooth")
 
 
+def consume_connection_slots(
+    value: int, consumer: str
+) -> Callable[[MutableMapping], MutableMapping]:
+    """Reserve BLE connection slots for a component.
+
+    Args:
+        value: Number of connection slots to reserve
+        consumer: Name of the component consuming the slots
+
+    Returns:
+        A validator function that records the slot usage
+    """
+
+    def _consume_connection_slots(config: MutableMapping) -> MutableMapping:
+        data: dict[str, Any] = CORE.data.setdefault(KEY_ESP32_BLE, {})
+        slots: list[str] = data.setdefault(KEY_USED_CONNECTION_SLOTS, [])
+        slots.extend([consumer] * value)
+        return config
+
+    return _consume_connection_slots
+
+
+def validate_connection_slots(max_connections: int) -> None:
+    """Validate that BLE connection slots don't exceed the configured maximum."""
+    ble_data = CORE.data.get(KEY_ESP32_BLE, {})
+    used_slots = ble_data.get(KEY_USED_CONNECTION_SLOTS, [])
+    num_used = len(used_slots)
+
+    if num_used <= max_connections:
+        return
+
+    slot_users = ", ".join(used_slots)
+
+    if num_used > IDF_MAX_CONNECTIONS:
+        raise cv.Invalid(
+            f"BLE components require {num_used} connection slots but maximum is {IDF_MAX_CONNECTIONS}. "
+            f"Reduce the number of BLE clients. Components: {slot_users}"
+        )
+
+    _LOGGER.warning(
+        "BLE components require %d connection slot(s) but only %d configured. "
+        "Please set 'max_connections: %d' in the 'esp32_ble' component. "
+        "Components: %s",
+        num_used,
+        max_connections,
+        num_used,
+        slot_users,
+    )
+
+
 def final_validation(config):
     validate_variant(config)
     if (name := config.get(CONF_NAME)) is not None:
@@ -245,6 +326,10 @@ def final_validation(config):
     # Set GATT Client/Server sdkconfig options based on which components are loaded
     full_config = fv.full_config.get()
 
+    # Validate connection slots usage
+    max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
+    validate_connection_slots(max_connections)
+
     # Check if BLE Server is needed
     has_ble_server = "esp32_ble_server" in full_config
     add_idf_sdkconfig_option("CONFIG_BT_GATTS_ENABLE", has_ble_server)
@@ -255,6 +340,26 @@ def final_validation(config):
     )
     add_idf_sdkconfig_option("CONFIG_BT_GATTC_ENABLE", has_ble_client)
 
+    # Handle max_connections: check for deprecated location in esp32_ble_tracker
+    max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
+
+    # Use value from tracker if esp32_ble doesn't have it explicitly set (backward compat)
+    if "esp32_ble_tracker" in full_config:
+        tracker_config = full_config["esp32_ble_tracker"]
+        if "max_connections" in tracker_config and CONF_MAX_CONNECTIONS not in config:
+            max_connections = tracker_config["max_connections"]
+
+    # Set CONFIG_BT_ACL_CONNECTIONS to the maximum connections needed + 1 for ADV/SCAN
+    # This is the Bluedroid host stack total instance limit (range 1-9, default 4)
+    # Total instances = ADV/SCAN (1) + connection slots (max_connections)
+    # Shared between client (tracker/ble_client) and server
+    add_idf_sdkconfig_option("CONFIG_BT_ACL_CONNECTIONS", max_connections + 1)
+
+    # Set controller-specific max connections for ESP32 (classic)
+    # CONFIG_BTDM_CTRL_BLE_MAX_CONN is ESP32-specific controller limit (just connections, not ADV/SCAN)
+    # For newer chips (C3/S3/etc), different configs are used automatically
+    add_idf_sdkconfig_option("CONFIG_BTDM_CTRL_BLE_MAX_CONN", max_connections)
+
     return config
 
 
@@ -270,6 +375,10 @@ async def to_code(config):
         cg.add(var.set_name(name))
     await cg.register_component(var, config)
 
+    # Define max connections for use in C++ code (e.g., ble_server.h)
+    max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
+    cg.add_define("USE_ESP32_BLE_MAX_CONNECTIONS", max_connections)
+
     add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
     add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
 

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -1,5 +1,6 @@
 #include "esp32_ble_beacon.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -389,7 +389,8 @@ bool BLEClientBase::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_
       if (this->conn_id_ != param->search_res.conn_id)
         return false;
       this->service_count_++;
-      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE) {
+      if (this->connection_type_ == espbt::ConnectionType::V3_WITHOUT_CACHE ||
+          this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE) {
         // V3 clients don't need services initialized since
         // as they use the ESP APIs to get services.
         break;

esphome/components/esp32_ble_server/__init__.py

@@ -26,7 +26,7 @@ from esphome.const import (
 from esphome.core import CORE
 from esphome.schema_extractors import SCHEMA_EXTRACT
 
-AUTO_LOAD = ["esp32_ble", "bytebuffer", "event_emitter"]
+AUTO_LOAD = ["esp32_ble", "bytebuffer"]
 CODEOWNERS = ["@jesserockz", "@clydebarrow", "@Rapsssito"]
 DEPENDENCIES = ["esp32"]
 DOMAIN = "esp32_ble_server"

esphome/components/esp32_ble_server/ble_characteristic.cpp

@@ -49,7 +49,11 @@ void BLECharacteristic::notify() {
       this->service_->get_server()->get_connected_client_count() == 0)
     return;
 
-  for (auto &client : this->service_->get_server()->get_clients()) {
+  const uint16_t *clients = this->service_->get_server()->get_clients();
+  uint8_t client_count = this->service_->get_server()->get_client_count();
+
+  for (uint8_t i = 0; i < client_count; i++) {
+    uint16_t client = clients[i];
     size_t length = this->value_.size();
     // Find the client in the list of clients to notify
     auto *entry = this->find_client_in_notify_list_(client);
@@ -73,7 +77,7 @@ void BLECharacteristic::notify() {
 void BLECharacteristic::add_descriptor(BLEDescriptor *descriptor) {
   // If the descriptor is the CCCD descriptor, listen to its write event to know if the client wants to be notified
   if (descriptor->get_uuid() == ESPBTUUID::from_uint16(ESP_GATT_UUID_CHAR_CLIENT_CONFIG)) {
-    descriptor->on(BLEDescriptorEvt::VectorEvt::ON_WRITE, [this](const std::vector<uint8_t> &value, uint16_t conn_id) {
+    descriptor->on_write([this](std::span<const uint8_t> value, uint16_t conn_id) {
       if (value.size() != 2)
         return;
       uint16_t cccd = encode_uint16(value[1], value[0]);
@@ -208,8 +212,9 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
       if (!param->read.need_rsp)
         break;  // For some reason you can request a read but not want a response
 
-      this->EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t>::emit_(BLECharacteristicEvt::EmptyEvt::ON_READ,
-                                                                          param->read.conn_id);
+      if (this->on_read_callback_) {
+        (*this->on_read_callback_)(param->read.conn_id);
+      }
 
       uint16_t max_offset = 22;
 
@@ -277,8 +282,9 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
       }
 
       if (!param->write.is_prep) {
-        this->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::emit_(
-            BLECharacteristicEvt::VectorEvt::ON_WRITE, this->value_, param->write.conn_id);
+        if (this->on_write_callback_) {
+          (*this->on_write_callback_)(this->value_, param->write.conn_id);
+        }
       }
 
       break;
@@ -289,8 +295,9 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
         break;
       this->write_event_ = false;
       if (param->exec_write.exec_write_flag == ESP_GATT_PREP_WRITE_EXEC) {
-        this->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::emit_(
-            BLECharacteristicEvt::VectorEvt::ON_WRITE, this->value_, param->exec_write.conn_id);
+        if (this->on_write_callback_) {
+          (*this->on_write_callback_)(this->value_, param->exec_write.conn_id);
+        }
       }
       esp_err_t err =
           esp_ble_gatts_send_response(gatts_if, param->write.conn_id, param->write.trans_id, ESP_GATT_OK, nullptr);

esphome/components/esp32_ble_server/ble_characteristic.h

@@ -2,10 +2,12 @@
 
 #include "ble_descriptor.h"
 #include "esphome/components/esp32_ble/ble_uuid.h"
-#include "esphome/components/event_emitter/event_emitter.h"
 #include "esphome/components/bytebuffer/bytebuffer.h"
 
 #include <vector>
+#include <span>
+#include <functional>
+#include <memory>
 
 #ifdef USE_ESP32
 
@@ -22,22 +24,10 @@ namespace esp32_ble_server {
 
 using namespace esp32_ble;
 using namespace bytebuffer;
-using namespace event_emitter;
 
 class BLEService;
 
-namespace BLECharacteristicEvt {
-enum VectorEvt {
-  ON_WRITE,
-};
-
-enum EmptyEvt {
-  ON_READ,
-};
-}  // namespace BLECharacteristicEvt
-
-class BLECharacteristic : public EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>,
-                          public EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t> {
+class BLECharacteristic {
  public:
   BLECharacteristic(ESPBTUUID uuid, uint32_t properties);
   ~BLECharacteristic();
@@ -76,6 +66,15 @@ class BLECharacteristic : public EventEmitter<BLECharacteristicEvt::VectorEvt, s
   bool is_created();
   bool is_failed();
 
+  // Direct callback registration - only allocates when callback is set
+  void on_write(std::function<void(std::span<const uint8_t>, uint16_t)> &&callback) {
+    this->on_write_callback_ =
+        std::make_unique<std::function<void(std::span<const uint8_t>, uint16_t)>>(std::move(callback));
+  }
+  void on_read(std::function<void(uint16_t)> &&callback) {
+    this->on_read_callback_ = std::make_unique<std::function<void(uint16_t)>>(std::move(callback));
+  }
+
  protected:
   bool write_event_{false};
   BLEService *service_{};
@@ -98,6 +97,9 @@ class BLECharacteristic : public EventEmitter<BLECharacteristicEvt::VectorEvt, s
   void remove_client_from_notify_list_(uint16_t conn_id);
   ClientNotificationEntry *find_client_in_notify_list_(uint16_t conn_id);
 
+  std::unique_ptr<std::function<void(std::span<const uint8_t>, uint16_t)>> on_write_callback_;
+  std::unique_ptr<std::function<void(uint16_t)>> on_read_callback_;
+
   esp_gatt_perm_t permissions_ = ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE;
 
   enum State : uint8_t {

esphome/components/esp32_ble_server/ble_descriptor.cpp

@@ -74,9 +74,10 @@ void BLEDescriptor::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_
         break;
       this->value_.attr_len = param->write.len;
       memcpy(this->value_.attr_value, param->write.value, param->write.len);
-      this->emit_(BLEDescriptorEvt::VectorEvt::ON_WRITE,
-                  std::vector<uint8_t>(param->write.value, param->write.value + param->write.len),
-                  param->write.conn_id);
+      if (this->on_write_callback_) {
+        (*this->on_write_callback_)(std::span<const uint8_t>(param->write.value, param->write.len),
+                                    param->write.conn_id);
+      }
       break;
     }
     default:

esphome/components/esp32_ble_server/ble_descriptor.h

@@ -1,30 +1,26 @@
 #pragma once
 
 #include "esphome/components/esp32_ble/ble_uuid.h"
-#include "esphome/components/event_emitter/event_emitter.h"
 #include "esphome/components/bytebuffer/bytebuffer.h"
 
 #ifdef USE_ESP32
 
 #include <esp_gatt_defs.h>
 #include <esp_gatts_api.h>
+#include <span>
+#include <functional>
+#include <memory>
 
 namespace esphome {
 namespace esp32_ble_server {
 
 using namespace esp32_ble;
 using namespace bytebuffer;
-using namespace event_emitter;
 
 class BLECharacteristic;
 
-namespace BLEDescriptorEvt {
-enum VectorEvt {
-  ON_WRITE,
-};
-}  // namespace BLEDescriptorEvt
-
-class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vector<uint8_t>, uint16_t> {
+// Base class for BLE descriptors
+class BLEDescriptor {
  public:
   BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100, bool read = true, bool write = true);
   virtual ~BLEDescriptor();
@@ -39,6 +35,12 @@ class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vect
   bool is_created() { return this->state_ == CREATED; }
   bool is_failed() { return this->state_ == FAILED; }
 
+  // Direct callback registration - only allocates when callback is set
+  void on_write(std::function<void(std::span<const uint8_t>, uint16_t)> &&callback) {
+    this->on_write_callback_ =
+        std::make_unique<std::function<void(std::span<const uint8_t>, uint16_t)>>(std::move(callback));
+  }
+
  protected:
   BLECharacteristic *characteristic_{nullptr};
   ESPBTUUID uuid_;
@@ -46,6 +48,8 @@ class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vect
 
   esp_attr_value_t value_{};
 
+  std::unique_ptr<std::function<void(std::span<const uint8_t>, uint16_t)>> on_write_callback_;
+
   esp_gatt_perm_t permissions_{};
 
   enum State : uint8_t {

esphome/components/esp32_ble_server/ble_server.cpp

@@ -147,20 +147,28 @@ BLEService *BLEServer::get_service(ESPBTUUID uuid, uint8_t inst_id) {
   return nullptr;
 }
 
+void BLEServer::dispatch_callbacks_(CallbackType type, uint16_t conn_id) {
+  for (auto &entry : this->callbacks_) {
+    if (entry.type == type) {
+      entry.callback(conn_id);
+    }
+  }
+}
+
 void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                     esp_ble_gatts_cb_param_t *param) {
   switch (event) {
     case ESP_GATTS_CONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client connected");
       this->add_client_(param->connect.conn_id);
-      this->emit_(BLEServerEvt::EmptyEvt::ON_CONNECT, param->connect.conn_id);
+      this->dispatch_callbacks_(CallbackType::ON_CONNECT, param->connect.conn_id);
       break;
     }
     case ESP_GATTS_DISCONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client disconnected");
       this->remove_client_(param->disconnect.conn_id);
       this->parent_->advertising_start();
-      this->emit_(BLEServerEvt::EmptyEvt::ON_DISCONNECT, param->disconnect.conn_id);
+      this->dispatch_callbacks_(CallbackType::ON_DISCONNECT, param->disconnect.conn_id);
       break;
     }
     case ESP_GATTS_REG_EVT: {
@@ -177,9 +185,38 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
   }
 }
 
+int8_t BLEServer::find_client_index_(uint16_t conn_id) const {
+  for (uint8_t i = 0; i < this->client_count_; i++) {
+    if (this->clients_[i] == conn_id)
+      return i;
+  }
+  return -1;
+}
+
+void BLEServer::add_client_(uint16_t conn_id) {
+  // Check if already in list
+  if (this->find_client_index_(conn_id) >= 0)
+    return;
+  // Add if there's space
+  if (this->client_count_ < USE_ESP32_BLE_MAX_CONNECTIONS) {
+    this->clients_[this->client_count_++] = conn_id;
+  } else {
+    // This should never happen since max clients is known at compile time
+    ESP_LOGE(TAG, "Client array full");
+  }
+}
+
+void BLEServer::remove_client_(uint16_t conn_id) {
+  int8_t index = this->find_client_index_(conn_id);
+  if (index >= 0) {
+    // Replace with last element and decrement count (client order not preserved)
+    this->clients_[index] = this->clients_[--this->client_count_];
+  }
+}
+
 void BLEServer::ble_before_disabled_event_handler() {
   // Delete all clients
-  this->clients_.clear();
+  this->client_count_ = 0;
   // Delete all services
   for (auto &entry : this->services_) {
     entry.service->do_delete();

esphome/components/esp32_ble_server/ble_server.h

@@ -12,7 +12,7 @@
 #include <memory>
 #include <vector>
 #include <unordered_map>
-#include <unordered_set>
+#include <functional>
 
 #ifdef USE_ESP32
 
@@ -24,18 +24,7 @@ namespace esp32_ble_server {
 using namespace esp32_ble;
 using namespace bytebuffer;
 
-namespace BLEServerEvt {
-enum EmptyEvt {
-  ON_CONNECT,
-  ON_DISCONNECT,
-};
-}  // namespace BLEServerEvt
-
-class BLEServer : public Component,
-                  public GATTsEventHandler,
-                  public BLEStatusEventHandler,
-                  public Parented<ESP32BLE>,
-                  public EventEmitter<BLEServerEvt::EmptyEvt, uint16_t> {
+class BLEServer : public Component, public GATTsEventHandler, public BLEStatusEventHandler, public Parented<ESP32BLE> {
  public:
   void setup() override;
   void loop() override;
@@ -57,15 +46,34 @@ class BLEServer : public Component,
   void set_device_information_service(BLEService *service) { this->device_information_service_ = service; }
 
   esp_gatt_if_t get_gatts_if() { return this->gatts_if_; }
-  uint32_t get_connected_client_count() { return this->clients_.size(); }
-  const std::unordered_set<uint16_t> &get_clients() { return this->clients_; }
+  uint32_t get_connected_client_count() { return this->client_count_; }
+  const uint16_t *get_clients() const { return this->clients_; }
+  uint8_t get_client_count() const { return this->client_count_; }
 
   void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                            esp_ble_gatts_cb_param_t *param) override;
 
   void ble_before_disabled_event_handler() override;
 
+  // Direct callback registration - supports multiple callbacks
+  void on_connect(std::function<void(uint16_t)> &&callback) {
+    this->callbacks_.push_back({CallbackType::ON_CONNECT, std::move(callback)});
+  }
+  void on_disconnect(std::function<void(uint16_t)> &&callback) {
+    this->callbacks_.push_back({CallbackType::ON_DISCONNECT, std::move(callback)});
+  }
+
  protected:
+  enum class CallbackType : uint8_t {
+    ON_CONNECT,
+    ON_DISCONNECT,
+  };
+
+  struct CallbackEntry {
+    CallbackType type;
+    std::function<void(uint16_t)> callback;
+  };
+
   struct ServiceEntry {
     ESPBTUUID uuid;
     uint8_t inst_id;
@@ -74,14 +82,19 @@ class BLEServer : public Component,
 
   void restart_advertising_();
 
-  void add_client_(uint16_t conn_id) { this->clients_.insert(conn_id); }
-  void remove_client_(uint16_t conn_id) { this->clients_.erase(conn_id); }
+  int8_t find_client_index_(uint16_t conn_id) const;
+  void add_client_(uint16_t conn_id);
+  void remove_client_(uint16_t conn_id);
+  void dispatch_callbacks_(CallbackType type, uint16_t conn_id);
+
+  std::vector<CallbackEntry> callbacks_;
 
   std::vector<uint8_t> manufacturer_data_{};
   esp_gatt_if_t gatts_if_{0};
   bool registered_{false};
 
-  std::unordered_set<uint16_t> clients_;
+  uint16_t clients_[USE_ESP32_BLE_MAX_CONNECTIONS]{};
+  uint8_t client_count_{0};
   std::vector<ServiceEntry> services_{};
   std::vector<BLEService *> services_to_start_{};
   BLEService *device_information_service_{};

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -14,9 +14,10 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
     BLECharacteristic *characteristic) {
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
-  characteristic->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::on(
-      BLECharacteristicEvt::VectorEvt::ON_WRITE,
-      [on_write_trigger](const std::vector<uint8_t> &data, uint16_t id) { on_write_trigger->trigger(data, id); });
+  characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
+    // Convert span to vector for trigger
+    on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
+  });
   return on_write_trigger;
 }
 #endif
@@ -25,9 +26,10 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
 Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write_trigger(BLEDescriptor *descriptor) {
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
-  descriptor->on(
-      BLEDescriptorEvt::VectorEvt::ON_WRITE,
-      [on_write_trigger](const std::vector<uint8_t> &data, uint16_t id) { on_write_trigger->trigger(data, id); });
+  descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
+    // Convert span to vector for trigger
+    on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
+  });
   return on_write_trigger;
 }
 #endif
@@ -35,8 +37,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
 #ifdef USE_ESP32_BLE_SERVER_ON_CONNECT
 Trigger<uint16_t> *BLETriggers::create_server_on_connect_trigger(BLEServer *server) {
   Trigger<uint16_t> *on_connect_trigger = new Trigger<uint16_t>();  // NOLINT(cppcoreguidelines-owning-memory)
-  server->on(BLEServerEvt::EmptyEvt::ON_CONNECT,
-             [on_connect_trigger](uint16_t conn_id) { on_connect_trigger->trigger(conn_id); });
+  server->on_connect([on_connect_trigger](uint16_t conn_id) { on_connect_trigger->trigger(conn_id); });
   return on_connect_trigger;
 }
 #endif
@@ -44,38 +45,22 @@ Trigger<uint16_t> *BLETriggers::create_server_on_connect_trigger(BLEServer *serv
 #ifdef USE_ESP32_BLE_SERVER_ON_DISCONNECT
 Trigger<uint16_t> *BLETriggers::create_server_on_disconnect_trigger(BLEServer *server) {
   Trigger<uint16_t> *on_disconnect_trigger = new Trigger<uint16_t>();  // NOLINT(cppcoreguidelines-owning-memory)
-  server->on(BLEServerEvt::EmptyEvt::ON_DISCONNECT,
-             [on_disconnect_trigger](uint16_t conn_id) { on_disconnect_trigger->trigger(conn_id); });
+  server->on_disconnect([on_disconnect_trigger](uint16_t conn_id) { on_disconnect_trigger->trigger(conn_id); });
   return on_disconnect_trigger;
 }
 #endif
 
 #ifdef USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
 void BLECharacteristicSetValueActionManager::set_listener(BLECharacteristic *characteristic,
-                                                          EventEmitterListenerID listener_id,
                                                           const std::function<void()> &pre_notify_listener) {
   // Find and remove existing listener for this characteristic
   auto *existing = this->find_listener_(characteristic);
   if (existing != nullptr) {
-    // Remove the previous listener
-    characteristic->EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t>::off(BLECharacteristicEvt::EmptyEvt::ON_READ,
-                                                                                existing->listener_id);
-    // Remove the pre-notify listener
-    this->off(BLECharacteristicSetValueActionEvt::PRE_NOTIFY, existing->pre_notify_listener_id);
     // Remove from vector
     this->remove_listener_(characteristic);
   }
-  // Create a new listener for the pre-notify event
-  EventEmitterListenerID pre_notify_listener_id =
-      this->on(BLECharacteristicSetValueActionEvt::PRE_NOTIFY,
-               [pre_notify_listener, characteristic](const BLECharacteristic *evt_characteristic) {
-                 // Only call the pre-notify listener if the characteristic is the one we are interested in
-                 if (characteristic == evt_characteristic) {
-                   pre_notify_listener();
-                 }
-               });
   // Save the entry to the vector
-  this->listeners_.push_back({characteristic, listener_id, pre_notify_listener_id});
+  this->listeners_.push_back({characteristic, pre_notify_listener});
 }
 
 BLECharacteristicSetValueActionManager::ListenerEntry *BLECharacteristicSetValueActionManager::find_listener_(

esphome/components/esp32_ble_server/ble_server_automations.h

@@ -4,7 +4,6 @@
 #include "ble_characteristic.h"
 #include "ble_descriptor.h"
 
-#include "esphome/components/event_emitter/event_emitter.h"
 #include "esphome/core/automation.h"
 
 #include <vector>
@@ -18,10 +17,6 @@ namespace esp32_ble_server {
 namespace esp32_ble_server_automations {
 
 using namespace esp32_ble;
-using namespace event_emitter;
-
-// Invalid listener ID constant - 0 is used as sentinel value in EventEmitter
-static constexpr EventEmitterListenerID INVALID_LISTENER_ID = 0;
 
 class BLETriggers {
  public:
@@ -41,38 +36,29 @@ class BLETriggers {
 };
 
 #ifdef USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
-enum BLECharacteristicSetValueActionEvt {
-  PRE_NOTIFY,
-};
-
 // Class to make sure only one BLECharacteristicSetValueAction is active at a time for each characteristic
-class BLECharacteristicSetValueActionManager
-    : public EventEmitter<BLECharacteristicSetValueActionEvt, BLECharacteristic *> {
+class BLECharacteristicSetValueActionManager {
  public:
   // Singleton pattern
   static BLECharacteristicSetValueActionManager *get_instance() {
     static BLECharacteristicSetValueActionManager instance;
     return &instance;
   }
-  void set_listener(BLECharacteristic *characteristic, EventEmitterListenerID listener_id,
-                    const std::function<void()> &pre_notify_listener);
-  EventEmitterListenerID get_listener(BLECharacteristic *characteristic) {
+  void set_listener(BLECharacteristic *characteristic, const std::function<void()> &pre_notify_listener);
+  bool has_listener(BLECharacteristic *characteristic) { return this->find_listener_(characteristic) != nullptr; }
+  void emit_pre_notify(BLECharacteristic *characteristic) {
     for (const auto &entry : this->listeners_) {
       if (entry.characteristic == characteristic) {
-        return entry.listener_id;
+        entry.pre_notify_listener();
+        break;
       }
     }
-    return INVALID_LISTENER_ID;
-  }
-  void emit_pre_notify(BLECharacteristic *characteristic) {
-    this->emit_(BLECharacteristicSetValueActionEvt::PRE_NOTIFY, characteristic);
   }
 
  private:
   struct ListenerEntry {
     BLECharacteristic *characteristic;
-    EventEmitterListenerID listener_id;
-    EventEmitterListenerID pre_notify_listener_id;
+    std::function<void()> pre_notify_listener;
   };
   std::vector<ListenerEntry> listeners_;
 
@@ -87,24 +73,22 @@ template<typename... Ts> class BLECharacteristicSetValueAction : public Action<T
   void set_buffer(ByteBuffer buffer) { this->set_buffer(buffer.get_data()); }
   void play(Ts... x) override {
     // If the listener is already set, do nothing
-    if (BLECharacteristicSetValueActionManager::get_instance()->get_listener(this->parent_) == this->listener_id_)
+    if (BLECharacteristicSetValueActionManager::get_instance()->has_listener(this->parent_))
       return;
     // Set initial value
     this->parent_->set_value(this->buffer_.value(x...));
     // Set the listener for read events
-    this->listener_id_ = this->parent_->EventEmitter<BLECharacteristicEvt::EmptyEvt, uint16_t>::on(
-        BLECharacteristicEvt::EmptyEvt::ON_READ, [this, x...](uint16_t id) {
-          // Set the value of the characteristic every time it is read
-          this->parent_->set_value(this->buffer_.value(x...));
-        });
+    this->parent_->on_read([this, x...](uint16_t id) {
+      // Set the value of the characteristic every time it is read
+      this->parent_->set_value(this->buffer_.value(x...));
+    });
     // Set the listener in the global manager so only one BLECharacteristicSetValueAction is set for each characteristic
     BLECharacteristicSetValueActionManager::get_instance()->set_listener(
-        this->parent_, this->listener_id_, [this, x...]() { this->parent_->set_value(this->buffer_.value(x...)); });
+        this->parent_, [this, x...]() { this->parent_->set_value(this->buffer_.value(x...)); });
   }
 
  protected:
   BLECharacteristic *parent_;
-  EventEmitterListenerID listener_id_;
 };
 #endif  // USE_ESP32_BLE_SERVER_SET_VALUE_ACTION
 

esphome/components/esp32_ble_tracker/__init__.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-from collections.abc import Callable, MutableMapping
 import logging
-from typing import Any
 
 from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32_ble
 from esphome.components.esp32 import add_idf_sdkconfig_option
 from esphome.components.esp32_ble import (
+    IDF_MAX_CONNECTIONS,
     BTLoggers,
     bt_uuid,
     bt_uuid16_format,
@@ -24,6 +23,7 @@ from esphome.const import (
     CONF_INTERVAL,
     CONF_MAC_ADDRESS,
     CONF_MANUFACTURER_ID,
+    CONF_MAX_CONNECTIONS,
     CONF_ON_BLE_ADVERTISE,
     CONF_ON_BLE_MANUFACTURER_DATA_ADVERTISE,
     CONF_ON_BLE_SERVICE_DATA_ADVERTISE,
@@ -38,19 +38,12 @@ AUTO_LOAD = ["esp32_ble"]
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@bdraco"]
 
-KEY_ESP32_BLE_TRACKER = "esp32_ble_tracker"
-KEY_USED_CONNECTION_SLOTS = "used_connection_slots"
-
-CONF_MAX_CONNECTIONS = "max_connections"
 CONF_ESP32_BLE_ID = "esp32_ble_id"
 CONF_SCAN_PARAMETERS = "scan_parameters"
 CONF_WINDOW = "window"
 CONF_ON_SCAN_END = "on_scan_end"
 CONF_SOFTWARE_COEXISTENCE = "software_coexistence"
 
-DEFAULT_MAX_CONNECTIONS = 3
-IDF_MAX_CONNECTIONS = 9
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -128,6 +121,15 @@ def validate_scan_parameters(config):
     return config
 
 
+def validate_max_connections_deprecated(config: ConfigType) -> ConfigType:
+    if CONF_MAX_CONNECTIONS in config:
+        _LOGGER.warning(
+            "The 'max_connections' option in 'esp32_ble_tracker' is deprecated. "
+            "Please move it to the 'esp32_ble' component instead."
+        )
+    return config
+
+
 def as_hex(value):
     return cg.RawExpression(f"0x{value}ULL")
 
@@ -150,24 +152,12 @@ def as_reversed_hex_array(value):
     )
 
 
-def consume_connection_slots(
-    value: int, consumer: str
-) -> Callable[[MutableMapping], MutableMapping]:
-    def _consume_connection_slots(config: MutableMapping) -> MutableMapping:
-        data: dict[str, Any] = CORE.data.setdefault(KEY_ESP32_BLE_TRACKER, {})
-        slots: list[str] = data.setdefault(KEY_USED_CONNECTION_SLOTS, [])
-        slots.extend([consumer] * value)
-        return config
-
-    return _consume_connection_slots
-
-
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(ESP32BLETracker),
             cv.GenerateID(esp32_ble.CONF_BLE_ID): cv.use_id(esp32_ble.ESP32BLE),
-            cv.Optional(CONF_MAX_CONNECTIONS, default=DEFAULT_MAX_CONNECTIONS): cv.All(
+            cv.Optional(CONF_MAX_CONNECTIONS): cv.All(
                 cv.positive_int, cv.Range(min=0, max=IDF_MAX_CONNECTIONS)
             ),
             cv.Optional(CONF_SCAN_PARAMETERS, default={}): cv.All(
@@ -224,48 +214,11 @@ CONFIG_SCHEMA = cv.All(
             cv.OnlyWith(CONF_SOFTWARE_COEXISTENCE, "wifi", default=True): bool,
         }
     ).extend(cv.COMPONENT_SCHEMA),
+    validate_max_connections_deprecated,
 )
 
 
-def validate_remaining_connections(config):
-    data: dict[str, Any] = CORE.data.get(KEY_ESP32_BLE_TRACKER, {})
-    slots: list[str] = data.get(KEY_USED_CONNECTION_SLOTS, [])
-    used_slots = len(slots)
-    if used_slots <= config[CONF_MAX_CONNECTIONS]:
-        return config
-    slot_users = ", ".join(slots)
-
-    if used_slots < IDF_MAX_CONNECTIONS:
-        _LOGGER.warning(
-            "esp32_ble_tracker exceeded `%s`: components attempted to consume %d "
-            "connection slot(s) out of available configured maximum %d connection "
-            "slot(s); The system automatically increased `%s` to %d to match the "
-            "number of used connection slot(s) by components: %s.",
-            CONF_MAX_CONNECTIONS,
-            used_slots,
-            config[CONF_MAX_CONNECTIONS],
-            CONF_MAX_CONNECTIONS,
-            used_slots,
-            slot_users,
-        )
-        config[CONF_MAX_CONNECTIONS] = used_slots
-        return config
-
-    msg = (
-        f"esp32_ble_tracker exceeded `{CONF_MAX_CONNECTIONS}`: "
-        f"components attempted to consume {used_slots} connection slot(s) "
-        f"out of available configured maximum {config[CONF_MAX_CONNECTIONS]} "
-        f"connection slot(s); Decrease the number of BLE clients ({slot_users})"
-    )
-    if config[CONF_MAX_CONNECTIONS] < IDF_MAX_CONNECTIONS:
-        msg += f" or increase {CONF_MAX_CONNECTIONS}` to {used_slots}"
-    msg += f" to stay under the {IDF_MAX_CONNECTIONS} connection slot(s) limit."
-    raise cv.Invalid(msg)
-
-
-FINAL_VALIDATE_SCHEMA = cv.All(
-    validate_remaining_connections, esp32_ble.validate_variant
-)
+FINAL_VALIDATE_SCHEMA = esp32_ble.validate_variant
 
 ESP_BLE_DEVICE_SCHEMA = cv.Schema(
     {
@@ -345,10 +298,8 @@ async def to_code(config):
     # Match arduino CONFIG_BTU_TASK_STACK_SIZE
     # https://github.com/espressif/arduino-esp32/blob/fd72cf46ad6fc1a6de99c1d83ba8eba17d80a4ee/tools/sdk/esp32/sdkconfig#L1866
     add_idf_sdkconfig_option("CONFIG_BT_BTU_TASK_STACK_SIZE", 8192)
-    add_idf_sdkconfig_option("CONFIG_BT_ACL_CONNECTIONS", 9)
-    add_idf_sdkconfig_option(
-        "CONFIG_BTDM_CTRL_BLE_MAX_CONN", config[CONF_MAX_CONNECTIONS]
-    )
+    # Note: CONFIG_BT_ACL_CONNECTIONS and CONFIG_BTDM_CTRL_BLE_MAX_CONN are now
+    # configured in esp32_ble component based on max_connections setting
 
     cg.add_define("USE_OTA_STATE_CALLBACK")  # To be notified when an OTA update starts
     cg.add_define("USE_ESP32_BLE_CLIENT")

esphome/components/esp32_can/esp32_can.cpp

@@ -67,8 +67,16 @@ static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config
 }
 
 bool ESP32Can::setup_internal() {
+  static int next_twai_ctrl_num = 0;
+  if (next_twai_ctrl_num >= SOC_TWAI_CONTROLLER_NUM) {
+    ESP_LOGW(TAG, "Maximum number of esp32_can components created already");
+    this->mark_failed();
+    return false;
+  }
+
   twai_general_config_t g_config =
       TWAI_GENERAL_CONFIG_DEFAULT((gpio_num_t) this->tx_, (gpio_num_t) this->rx_, TWAI_MODE_NORMAL);
+  g_config.controller_id = next_twai_ctrl_num++;
   if (this->tx_queue_len_.has_value()) {
     g_config.tx_queue_len = this->tx_queue_len_.value();
   }
@@ -86,14 +94,14 @@ bool ESP32Can::setup_internal() {
   }
 
   // Install TWAI driver
-  if (twai_driver_install(&g_config, &t_config, &f_config) != ESP_OK) {
+  if (twai_driver_install_v2(&g_config, &t_config, &f_config, &(this->twai_handle_)) != ESP_OK) {
     // Failed to install driver
     this->mark_failed();
     return false;
   }
 
   // Start TWAI driver
-  if (twai_start() != ESP_OK) {
+  if (twai_start_v2(this->twai_handle_) != ESP_OK) {
     // Failed to start driver
     this->mark_failed();
     return false;
@@ -102,6 +110,11 @@ bool ESP32Can::setup_internal() {
 }
 
 canbus::Error ESP32Can::send_message(struct canbus::CanFrame *frame) {
+  if (this->twai_handle_ == nullptr) {
+    // not setup yet or setup failed
+    return canbus::ERROR_FAIL;
+  }
+
   if (frame->can_data_length_code > canbus::CAN_MAX_DATA_LENGTH) {
     return canbus::ERROR_FAILTX;
   }
@@ -124,7 +137,7 @@ canbus::Error ESP32Can::send_message(struct canbus::CanFrame *frame) {
     memcpy(message.data, frame->data, frame->can_data_length_code);
   }
 
-  if (twai_transmit(&message, this->tx_enqueue_timeout_ticks_) == ESP_OK) {
+  if (twai_transmit_v2(this->twai_handle_, &message, this->tx_enqueue_timeout_ticks_) == ESP_OK) {
     return canbus::ERROR_OK;
   } else {
     return canbus::ERROR_ALLTXBUSY;
@@ -132,9 +145,14 @@ canbus::Error ESP32Can::send_message(struct canbus::CanFrame *frame) {
 }
 
 canbus::Error ESP32Can::read_message(struct canbus::CanFrame *frame) {
+  if (this->twai_handle_ == nullptr) {
+    // not setup yet or setup failed
+    return canbus::ERROR_FAIL;
+  }
+
   twai_message_t message;
 
-  if (twai_receive(&message, 0) != ESP_OK) {
+  if (twai_receive_v2(this->twai_handle_, &message, 0) != ESP_OK) {
     return canbus::ERROR_NOMSG;
   }
 

esphome/components/esp32_can/esp32_can.h

@@ -5,6 +5,8 @@
 #include "esphome/components/canbus/canbus.h"
 #include "esphome/core/component.h"
 
+#include <driver/twai.h>
+
 namespace esphome {
 namespace esp32_can {
 
@@ -29,6 +31,7 @@ class ESP32Can : public canbus::Canbus {
   TickType_t tx_enqueue_timeout_ticks_{};
   optional<uint32_t> tx_queue_len_{};
   optional<uint32_t> rx_queue_len_{};
+  twai_handle_t twai_handle_{nullptr};
 };
 
 }  // namespace esp32_can

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -38,8 +38,7 @@ void ESP32ImprovComponent::setup() {
     });
   }
 #endif
-  global_ble_server->on(BLEServerEvt::EmptyEvt::ON_DISCONNECT,
-                        [this](uint16_t conn_id) { this->set_error_(improv::ERROR_NONE); });
+  global_ble_server->on_disconnect([this](uint16_t conn_id) { this->set_error_(improv::ERROR_NONE); });
 
   // Start with loop disabled - will be enabled by start() when needed
   this->disable_loop();
@@ -57,12 +56,11 @@ void ESP32ImprovComponent::setup_characteristics() {
   this->error_->add_descriptor(error_descriptor);
 
   this->rpc_ = this->service_->create_characteristic(improv::RPC_COMMAND_UUID, BLECharacteristic::PROPERTY_WRITE);
-  this->rpc_->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>, uint16_t>::on(
-      BLECharacteristicEvt::VectorEvt::ON_WRITE, [this](const std::vector<uint8_t> &data, uint16_t id) {
-        if (!data.empty()) {
-          this->incoming_data_.insert(this->incoming_data_.end(), data.begin(), data.end());
-        }
-      });
+  this->rpc_->on_write([this](std::span<const uint8_t> data, uint16_t id) {
+    if (!data.empty()) {
+      this->incoming_data_.insert(this->incoming_data_.end(), data.begin(), data.end());
+    }
+  });
   BLEDescriptor *rpc_descriptor = new BLE2902();
   this->rpc_->add_descriptor(rpc_descriptor);
 

esphome/components/esphome/ota/ota_esphome.cpp

@@ -614,24 +614,67 @@ bool ESPHomeOTAComponent::handle_auth_send_() {
       return false;
     }
 
-    // Generate nonce with appropriate hasher
-    bool success = false;
+    // Generate nonce - hasher must be created and used in same stack frame
+    // CRITICAL ESP32-S3 HARDWARE SHA ACCELERATION REQUIREMENTS:
+    // 1. Hash objects must NEVER be passed to another function (different stack frame)
+    // 2. NO Variable Length Arrays (VLAs) - they corrupt the stack with hardware DMA
+    // 3. All hash operations (init/add/calculate) must happen in the SAME function where object is created
+    // Violating these causes truncated hash output (20 bytes instead of 32) or memory corruption.
+    //
+    // Buffer layout after AUTH_READ completes:
+    //   [0]: auth_type (1 byte)
+    //   [1...hex_size]: nonce (hex_size bytes) - our random nonce sent in AUTH_SEND
+    //   [1+hex_size...1+2*hex_size-1]: cnonce (hex_size bytes) - client's nonce
+    //   [1+2*hex_size...1+3*hex_size-1]: response (hex_size bytes) - client's hash
+
+    // Declare both hash objects in same stack frame, use pointer to select.
+    // NOTE: Both objects are declared here even though only one is used. This is REQUIRED for ESP32-S3
+    // hardware SHA acceleration - the object must exist in this stack frame for all operations.
+    // Do NOT try to "optimize" by creating the object inside the if block, as it would go out of scope.
+#ifdef USE_OTA_SHA256
+    sha256::SHA256 sha_hasher;
+#endif
+#ifdef USE_OTA_MD5
+    md5::MD5Digest md5_hasher;
+#endif
+    HashBase *hasher = nullptr;
+
 #ifdef USE_OTA_SHA256
     if (this->auth_type_ == ota::OTA_RESPONSE_REQUEST_SHA256_AUTH) {
-      sha256::SHA256 sha_hasher;
-      success = this->prepare_auth_nonce_(&sha_hasher);
+      hasher = &sha_hasher;
     }
 #endif
 #ifdef USE_OTA_MD5
     if (this->auth_type_ == ota::OTA_RESPONSE_REQUEST_AUTH) {
-      md5::MD5Digest md5_hasher;
-      success = this->prepare_auth_nonce_(&md5_hasher);
+      hasher = &md5_hasher;
     }
 #endif
 
-    if (!success) {
+    const size_t hex_size = hasher->get_size() * 2;
+    const size_t nonce_len = hasher->get_size() / 4;
+    const size_t auth_buf_size = 1 + 3 * hex_size;
+    this->auth_buf_ = std::make_unique<uint8_t[]>(auth_buf_size);
+    this->auth_buf_pos_ = 0;
+
+    char *buf = reinterpret_cast<char *>(this->auth_buf_.get() + 1);
+    if (!random_bytes(reinterpret_cast<uint8_t *>(buf), nonce_len)) {
+      this->log_auth_warning_(LOG_STR("Random failed"));
+      this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_UNKNOWN);
       return false;
     }
+
+    hasher->init();
+    hasher->add(buf, nonce_len);
+    hasher->calculate();
+    this->auth_buf_[0] = this->auth_type_;
+    hasher->get_hex(buf);
+
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+    char log_buf[65];  // Fixed size for SHA256 hex (64) + null, works for MD5 (32) too
+    memcpy(log_buf, buf, hex_size);
+    log_buf[hex_size] = '\0';
+    ESP_LOGV(TAG, "Auth: Nonce is %s", log_buf);
+#endif
   }
 
   // Try to write auth_type + nonce
@@ -678,89 +721,41 @@ bool ESPHomeOTAComponent::handle_auth_read_() {
   }
 
   // We have all the data, verify it
-  bool matches = false;
+  const char *nonce = reinterpret_cast<char *>(this->auth_buf_.get() + 1);
+  const char *cnonce = nonce + hex_size;
+  const char *response = cnonce + hex_size;
+
+  // CRITICAL ESP32-S3: Hash objects must stay in same stack frame (no passing to other functions).
+  // Declare both hash objects in same stack frame, use pointer to select.
+  // NOTE: Both objects are declared here even though only one is used. This is REQUIRED for ESP32-S3
+  // hardware SHA acceleration - the object must exist in this stack frame for all operations.
+  // Do NOT try to "optimize" by creating the object inside the if block, as it would go out of scope.
+#ifdef USE_OTA_SHA256
+  sha256::SHA256 sha_hasher;
+#endif
+#ifdef USE_OTA_MD5
+  md5::MD5Digest md5_hasher;
+#endif
+  HashBase *hasher = nullptr;
 
 #ifdef USE_OTA_SHA256
   if (this->auth_type_ == ota::OTA_RESPONSE_REQUEST_SHA256_AUTH) {
-    sha256::SHA256 sha_hasher;
-    matches = this->verify_hash_auth_(&sha_hasher, hex_size);
+    hasher = &sha_hasher;
   }
 #endif
 #ifdef USE_OTA_MD5
   if (this->auth_type_ == ota::OTA_RESPONSE_REQUEST_AUTH) {
-    md5::MD5Digest md5_hasher;
-    matches = this->verify_hash_auth_(&md5_hasher, hex_size);
+    hasher = &md5_hasher;
   }
 #endif
 
-  if (!matches) {
-    this->log_auth_warning_(LOG_STR("Password mismatch"));
-    this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_AUTH_INVALID);
-    return false;
-  }
-
-  // Authentication successful - clean up auth state
-  this->cleanup_auth_();
-
-  return true;
-}
-
-bool ESPHomeOTAComponent::prepare_auth_nonce_(HashBase *hasher) {
-  // Calculate required buffer size using the hasher
-  const size_t hex_size = hasher->get_size() * 2;
-  const size_t nonce_len = hasher->get_size() / 4;
-
-  // Buffer layout after AUTH_READ completes:
-  //   [0]: auth_type (1 byte)
-  //   [1...hex_size]: nonce (hex_size bytes) - our random nonce sent in AUTH_SEND
-  //   [1+hex_size...1+2*hex_size-1]: cnonce (hex_size bytes) - client's nonce
-  //   [1+2*hex_size...1+3*hex_size-1]: response (hex_size bytes) - client's hash
-  // Total: 1 + 3*hex_size
-  const size_t auth_buf_size = 1 + 3 * hex_size;
-  this->auth_buf_ = std::make_unique<uint8_t[]>(auth_buf_size);
-  this->auth_buf_pos_ = 0;
-
-  // Generate nonce
-  char *buf = reinterpret_cast<char *>(this->auth_buf_.get() + 1);
-  if (!random_bytes(reinterpret_cast<uint8_t *>(buf), nonce_len)) {
-    this->log_auth_warning_(LOG_STR("Random failed"));
-    this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_UNKNOWN);
-    return false;
-  }
-
-  hasher->init();
-  hasher->add(buf, nonce_len);
-  hasher->calculate();
-
-  // Prepare buffer: auth_type (1 byte) + nonce (hex_size bytes)
-  this->auth_buf_[0] = this->auth_type_;
-  hasher->get_hex(buf);
-
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char log_buf[hex_size + 1];
-  // Log nonce for debugging
-  memcpy(log_buf, buf, hex_size);
-  log_buf[hex_size] = '\0';
-  ESP_LOGV(TAG, "Auth: Nonce is %s", log_buf);
-#endif
-
-  return true;
-}
-
-bool ESPHomeOTAComponent::verify_hash_auth_(HashBase *hasher, size_t hex_size) {
-  // Get pointers to the data in the buffer (see prepare_auth_nonce_ for buffer layout)
-  const char *nonce = reinterpret_cast<char *>(this->auth_buf_.get() + 1);  // Skip auth_type byte
-  const char *cnonce = nonce + hex_size;                                    // CNonce immediately follows nonce
-  const char *response = cnonce + hex_size;                                 // Response immediately follows cnonce
-
-  // Calculate expected hash: password + nonce + cnonce
   hasher->init();
   hasher->add(this->password_.c_str(), this->password_.length());
   hasher->add(nonce, hex_size * 2);  // Add both nonce and cnonce (contiguous in buffer)
   hasher->calculate();
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  char log_buf[hex_size + 1];
+  char log_buf[65];  // Fixed size for SHA256 hex (64) + null, works for MD5 (32) too
   // Log CNonce
   memcpy(log_buf, cnonce, hex_size);
   log_buf[hex_size] = '\0';
@@ -778,7 +773,18 @@ bool ESPHomeOTAComponent::verify_hash_auth_(HashBase *hasher, size_t hex_size) {
 #endif
 
   // Compare response
-  return hasher->equals_hex(response);
+  bool matches = hasher->equals_hex(response);
+
+  if (!matches) {
+    this->log_auth_warning_(LOG_STR("Password mismatch"));
+    this->send_error_and_cleanup_(ota::OTA_RESPONSE_ERROR_AUTH_INVALID);
+    return false;
+  }
+
+  // Authentication successful - clean up auth state
+  this->cleanup_auth_();
+
+  return true;
 }
 
 size_t ESPHomeOTAComponent::get_auth_hex_size_() const {

esphome/components/esphome/ota/ota_esphome.h

@@ -47,8 +47,6 @@ class ESPHomeOTAComponent : public ota::OTAComponent {
   bool handle_auth_send_();
   bool handle_auth_read_();
   bool select_auth_type_();
-  bool prepare_auth_nonce_(HashBase *hasher);
-  bool verify_hash_auth_(HashBase *hasher, size_t hex_size);
   size_t get_auth_hex_size_() const;
   void cleanup_auth_();
   void log_auth_warning_(const LogString *msg);

esphome/components/ethernet/ethernet_component.h

@@ -162,7 +162,7 @@ class EthernetComponent : public Component {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern EthernetComponent *global_eth_component;
 
-#if defined(USE_ARDUINO) || ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2)
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 4, 2)
 extern "C" esp_eth_phy_t *esp_eth_phy_new_jl1101(const eth_phy_config_t *config);
 #endif
 

esphome/components/event_emitter/__init__.py

@@ -1,5 +0,0 @@
-CODEOWNERS = ["@Rapsssito"]
-
-# Allows event_emitter to be configured in yaml, to allow use of the C++ api.
-
-CONFIG_SCHEMA = {}

esphome/components/event_emitter/event_emitter.h

@@ -1,117 +0,0 @@
-#pragma once
-#include <vector>
-#include <functional>
-#include <limits>
-
-#include "esphome/core/log.h"
-
-namespace esphome {
-namespace event_emitter {
-
-using EventEmitterListenerID = uint32_t;
-static constexpr EventEmitterListenerID INVALID_LISTENER_ID = 0;
-
-// EventEmitter class that can emit events with a specific name (it is highly recommended to use an enum class for this)
-// and a list of arguments. Supports multiple listeners for each event.
-template<typename EvtType, typename... Args> class EventEmitter {
- public:
-  EventEmitterListenerID on(EvtType event, std::function<void(Args...)> listener) {
-    EventEmitterListenerID listener_id = this->get_next_id_();
-
-    // Find or create event entry
-    EventEntry *entry = this->find_or_create_event_(event);
-    entry->listeners.push_back({listener_id, listener});
-
-    return listener_id;
-  }
-
-  void off(EvtType event, EventEmitterListenerID id) {
-    EventEntry *entry = this->find_event_(event);
-    if (entry == nullptr)
-      return;
-
-    // Remove listener with given id
-    for (auto it = entry->listeners.begin(); it != entry->listeners.end(); ++it) {
-      if (it->id == id) {
-        // Swap with last and pop for efficient removal
-        *it = entry->listeners.back();
-        entry->listeners.pop_back();
-
-        // Remove event entry if no more listeners
-        if (entry->listeners.empty()) {
-          this->remove_event_(event);
-        }
-        return;
-      }
-    }
-  }
-
- protected:
-  void emit_(EvtType event, Args... args) {
-    EventEntry *entry = this->find_event_(event);
-    if (entry == nullptr)
-      return;
-
-    // Call all listeners for this event
-    for (const auto &listener : entry->listeners) {
-      listener.callback(args...);
-    }
-  }
-
- private:
-  struct Listener {
-    EventEmitterListenerID id;
-    std::function<void(Args...)> callback;
-  };
-
-  struct EventEntry {
-    EvtType event;
-    std::vector<Listener> listeners;
-  };
-
-  EventEmitterListenerID get_next_id_() {
-    // Simple incrementing ID, wrapping around at max
-    EventEmitterListenerID next_id = (this->current_id_ + 1);
-    if (next_id == INVALID_LISTENER_ID) {
-      next_id = 1;
-    }
-    this->current_id_ = next_id;
-    return this->current_id_;
-  }
-
-  EventEntry *find_event_(EvtType event) {
-    for (auto &entry : this->events_) {
-      if (entry.event == event) {
-        return &entry;
-      }
-    }
-    return nullptr;
-  }
-
-  EventEntry *find_or_create_event_(EvtType event) {
-    EventEntry *entry = this->find_event_(event);
-    if (entry != nullptr)
-      return entry;
-
-    // Create new event entry
-    this->events_.push_back({event, {}});
-    return &this->events_.back();
-  }
-
-  void remove_event_(EvtType event) {
-    for (auto it = this->events_.begin(); it != this->events_.end(); ++it) {
-      if (it->event == event) {
-        // Swap with last and pop
-        *it = this->events_.back();
-        this->events_.pop_back();
-        return;
-      }
-    }
-  }
-
-  std::vector<EventEntry> events_;
-  EventEmitterListenerID current_id_ = 0;
-};
-
-}  // namespace event_emitter
-}  // namespace esphome

esphome/components/i2c/i2c_bus_esp_idf.cpp

@@ -107,7 +107,7 @@ void IDFI2CBus::dump_config() {
         if (s.second) {
           ESP_LOGCONFIG(TAG, "Found device at address 0x%02X", s.first);
         } else {
-          ESP_LOGE(TAG, "Unknown error at address 0x%02X", s.first);
+          ESP_LOGCONFIG(TAG, "Unknown error at address 0x%02X", s.first);
         }
       }
     }

esphome/components/json/json_util.h

@@ -2,6 +2,7 @@
 
 #include <vector>
 
+#include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 
 #define ARDUINOJSON_ENABLE_STD_STRING 1  // NOLINT

esphome/components/lock/lock.h

@@ -5,7 +5,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
-#include <set>
+#include <initializer_list>
 
 namespace esphome {
 namespace lock {
@@ -44,16 +44,22 @@ class LockTraits {
   bool get_assumed_state() const { return this->assumed_state_; }
   void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 
-  bool supports_state(LockState state) const { return supported_states_.count(state); }
-  std::set<LockState> get_supported_states() const { return supported_states_; }
-  void set_supported_states(std::set<LockState> states) { supported_states_ = std::move(states); }
-  void add_supported_state(LockState state) { supported_states_.insert(state); }
+  bool supports_state(LockState state) const { return supported_states_mask_ & (1 << state); }
+  void set_supported_states(std::initializer_list<LockState> states) {
+    supported_states_mask_ = 0;
+    for (auto state : states) {
+      supported_states_mask_ |= (1 << state);
+    }
+  }
+  uint8_t get_supported_states_mask() const { return supported_states_mask_; }
+  void set_supported_states_mask(uint8_t mask) { supported_states_mask_ = mask; }
+  void add_supported_state(LockState state) { supported_states_mask_ |= (1 << state); }
 
  protected:
   bool supports_open_{false};
   bool requires_code_{false};
   bool assumed_state_{false};
-  std::set<LockState> supported_states_ = {LOCK_STATE_NONE, LOCK_STATE_LOCKED, LOCK_STATE_UNLOCKED};
+  uint8_t supported_states_mask_{(1 << LOCK_STATE_NONE) | (1 << LOCK_STATE_LOCKED) | (1 << LOCK_STATE_UNLOCKED)};
 };
 
 /** This class is used to encode all control actions on a lock device.

esphome/components/logger/__init__.py

@@ -95,6 +95,7 @@ DEFAULT = "DEFAULT"
 
 CONF_INITIAL_LEVEL = "initial_level"
 CONF_LOGGER_ID = "logger_id"
+CONF_RUNTIME_TAG_LEVELS = "runtime_tag_levels"
 CONF_TASK_LOG_BUFFER_SIZE = "task_log_buffer_size"
 
 UART_SELECTION_ESP32 = {
@@ -249,6 +250,7 @@ CONFIG_SCHEMA = cv.All(
                 }
             ),
             cv.Optional(CONF_INITIAL_LEVEL): is_log_level,
+            cv.Optional(CONF_RUNTIME_TAG_LEVELS, default=False): cv.boolean,
             cv.Optional(CONF_ON_MESSAGE): automation.validate_automation(
                 {
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoggerMessageTrigger),
@@ -291,8 +293,12 @@ async def to_code(config):
         )
     cg.add(log.pre_setup())
 
-    for tag, log_level in config[CONF_LOGS].items():
-        cg.add(log.set_log_level(tag, LOG_LEVELS[log_level]))
+    # Enable runtime tag levels if logs are configured or explicitly enabled
+    logs_config = config[CONF_LOGS]
+    if logs_config or config[CONF_RUNTIME_TAG_LEVELS]:
+        cg.add_define("USE_LOGGER_RUNTIME_TAG_LEVELS")
+        for tag, log_level in logs_config.items():
+            cg.add(log.set_log_level(tag, LOG_LEVELS[log_level]))
 
     cg.add_define("USE_LOGGER")
     this_severity = LOG_LEVEL_SEVERITY.index(level)
@@ -443,6 +449,7 @@ async def logger_set_level_to_code(config, action_id, template_arg, args):
     level = LOG_LEVELS[config[CONF_LEVEL]]
     logger = await cg.get_variable(config[CONF_LOGGER_ID])
     if tag := config.get(CONF_TAG):
+        cg.add_define("USE_LOGGER_RUNTIME_TAG_LEVELS")
         text = str(cg.statement(logger.set_log_level(tag, level)))
     else:
         text = str(cg.statement(logger.set_log_level(level)))

esphome/components/logger/logger.cpp

@@ -148,9 +148,11 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 
 inline uint8_t Logger::level_for(const char *tag) {
+#ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
   auto it = this->log_levels_.find(tag);
   if (it != this->log_levels_.end())
     return it->second;
+#endif
   return this->current_level_;
 }
 
@@ -220,7 +222,9 @@ void Logger::process_messages_() {
 }
 
 void Logger::set_baud_rate(uint32_t baud_rate) { this->baud_rate_ = baud_rate; }
-void Logger::set_log_level(const std::string &tag, uint8_t log_level) { this->log_levels_[tag] = log_level; }
+#ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
+void Logger::set_log_level(const char *tag, uint8_t log_level) { this->log_levels_[tag] = log_level; }
+#endif
 
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
 UARTSelection Logger::get_uart() const { return this->uart_; }
@@ -271,9 +275,11 @@ void Logger::dump_config() {
   }
 #endif
 
+#ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
   for (auto &it : this->log_levels_) {
-    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first.c_str(), LOG_STR_ARG(LOG_LEVELS[it.second]));
+    ESP_LOGCONFIG(TAG, "  Level for '%s': %s", it.first, LOG_STR_ARG(LOG_LEVELS[it.second]));
   }
+#endif
 }
 
 void Logger::set_log_level(uint8_t level) {

esphome/components/logger/logger.h

@@ -36,6 +36,13 @@ struct device;
 
 namespace esphome::logger {
 
+#ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
+// Comparison function for const char* keys in log_levels_ map
+struct CStrCompare {
+  bool operator()(const char *a, const char *b) const { return strcmp(a, b) < 0; }
+};
+#endif
+
 // ANSI color code last digit (30-38 range, store only last digit to save RAM)
 static constexpr char LOG_LEVEL_COLOR_DIGIT[] = {
     '\0',  // NONE
@@ -133,8 +140,10 @@ class Logger : public Component {
 
   /// Set the default log level for this logger.
   void set_log_level(uint8_t level);
+#ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
   /// Set the log level of the specified tag.
-  void set_log_level(const std::string &tag, uint8_t log_level);
+  void set_log_level(const char *tag, uint8_t log_level);
+#endif
   uint8_t get_log_level() { return this->current_level_; }
 
   // ========== INTERNAL METHODS ==========
@@ -242,7 +251,9 @@ class Logger : public Component {
 #endif
 
   // Large objects (internally aligned)
-  std::map<std::string, uint8_t> log_levels_{};
+#ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
+  std::map<const char *, uint8_t, CStrCompare> log_levels_{};
+#endif
   CallbackManager<void(uint8_t, const char *, const char *, size_t)> log_callback_{};
   CallbackManager<void(uint8_t)> level_callback_{};
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
@@ -355,9 +366,18 @@ class Logger : public Component {
     buffer[pos++] = '[';
     copy_string(buffer, pos, tag);
     buffer[pos++] = ':';
-    buffer[pos++] = '0' + (line / 100) % 10;
-    buffer[pos++] = '0' + (line / 10) % 10;
-    buffer[pos++] = '0' + line % 10;
+    // Format line number without modulo operations (passed by value, safe to mutate)
+    if (line > 999) [[unlikely]] {
+      int thousands = line / 1000;
+      buffer[pos++] = '0' + thousands;
+      line -= thousands * 1000;
+    }
+    int hundreds = line / 100;
+    int remainder = line - hundreds * 100;
+    int tens = remainder / 10;
+    buffer[pos++] = '0' + hundreds;
+    buffer[pos++] = '0' + tens;
+    buffer[pos++] = '0' + (remainder - tens * 10);
     buffer[pos++] = ']';
 
 #if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)

esphome/components/logger/select/logger_level_select.cpp

@@ -3,11 +3,10 @@
 namespace esphome::logger {
 
 void LoggerLevelSelect::publish_state(int level) {
-  auto value = this->at(level);
-  if (!value) {
+  const auto &option = this->at(level_to_index(level));
+  if (!option)
     return;
-  }
-  Select::publish_state(value.value());
+  Select::publish_state(option.value());
 }
 
 void LoggerLevelSelect::setup() {
@@ -16,10 +15,10 @@ void LoggerLevelSelect::setup() {
 }
 
 void LoggerLevelSelect::control(const std::string &value) {
-  auto level = this->index_of(value);
-  if (!level)
+  const auto index = this->index_of(value);
+  if (!index)
     return;
-  this->parent_->set_log_level(level.value());
+  this->parent_->set_log_level(index_to_level(index.value()));
 }
 
 }  // namespace esphome::logger

esphome/components/logger/select/logger_level_select.h

@@ -3,11 +3,18 @@
 #include "esphome/components/select/select.h"
 #include "esphome/core/component.h"
 #include "esphome/components/logger/logger.h"
+
 namespace esphome::logger {
 class LoggerLevelSelect : public Component, public select::Select, public Parented<Logger> {
  public:
   void publish_state(int level);
   void setup() override;
   void control(const std::string &value) override;
+
+ protected:
+  // Convert log level to option index (skip CONFIG at level 4)
+  static uint8_t level_to_index(uint8_t level) { return (level > ESPHOME_LOG_LEVEL_CONFIG) ? level - 1 : level; }
+  // Convert option index to log level (skip CONFIG at level 4)
+  static uint8_t index_to_level(uint8_t index) { return (index >= ESPHOME_LOG_LEVEL_CONFIG) ? index + 1 : index; }
 };
 }  // namespace esphome::logger

esphome/components/mcp23016/mcp23016.cpp

@@ -56,7 +56,7 @@ void MCP23016::pin_mode(uint8_t pin, gpio::Flags flags) {
     this->update_reg_(pin, false, iodir);
   }
 }
-float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
+float MCP23016::get_setup_priority() const { return setup_priority::IO; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/components/mdns/__init__.py

@@ -17,6 +17,11 @@ from esphome.coroutine import CoroPriority
 CODEOWNERS = ["@esphome/core"]
 DEPENDENCIES = ["network"]
 
+# Components that create mDNS services at runtime
+# IMPORTANT: If you add a new component here, you must also update the corresponding
+# #ifdef blocks in mdns_component.cpp compile_records_() method
+COMPONENTS_WITH_MDNS_SERVICES = ("api", "prometheus", "web_server")
+
 mdns_ns = cg.esphome_ns.namespace("mdns")
 MDNSComponent = mdns_ns.class_("MDNSComponent", cg.Component)
 MDNSTXTRecord = mdns_ns.struct("MDNSTXTRecord")
@@ -91,12 +96,20 @@ async def to_code(config):
 
     cg.add_define("USE_MDNS")
 
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
+    # Calculate compile-time service count
+    service_count = sum(
+        1 for key in COMPONENTS_WITH_MDNS_SERVICES if key in CORE.config
+    ) + len(config[CONF_SERVICES])
 
     if config[CONF_SERVICES]:
         cg.add_define("USE_MDNS_EXTRA_SERVICES")
 
+    # Ensure at least 1 service (fallback service)
+    cg.add_define("MDNS_SERVICE_COUNT", max(1, service_count))
+
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
     for service in config[CONF_SERVICES]:
         txt = [
             cg.StructInitializer(

esphome/components/mdns/mdns_component.cpp

@@ -74,32 +74,12 @@ MDNS_STATIC_CONST_CHAR(NETWORK_THREAD, "thread");
 void MDNSComponent::compile_records_() {
   this->hostname_ = App.get_name();
 
-  // Calculate exact capacity needed for services vector
-  size_t services_count = 0;
-#ifdef USE_API
-  if (api::global_api_server != nullptr) {
-    services_count++;
-  }
-#endif
-#ifdef USE_PROMETHEUS
-  services_count++;
-#endif
-#ifdef USE_WEBSERVER
-  services_count++;
-#endif
-#ifdef USE_MDNS_EXTRA_SERVICES
-  services_count += this->services_extra_.size();
-#endif
-  // Reserve for fallback service if needed
-  if (services_count == 0) {
-    services_count = 1;
-  }
-  this->services_.reserve(services_count);
+  // IMPORTANT: The #ifdef blocks below must match COMPONENTS_WITH_MDNS_SERVICES
+  // in mdns/__init__.py. If you add a new service here, update both locations.
 
 #ifdef USE_API
   if (api::global_api_server != nullptr) {
-    this->services_.emplace_back();
-    auto &service = this->services_.back();
+    auto &service = this->services_[this->services_.count()++];
     service.service_type = MDNS_STR(SERVICE_ESPHOMELIB);
     service.proto = MDNS_STR(SERVICE_TCP);
     service.port = api::global_api_server->get_port();
@@ -178,30 +158,23 @@ void MDNSComponent::compile_records_() {
 #endif  // USE_API
 
 #ifdef USE_PROMETHEUS
-  this->services_.emplace_back();
-  auto &prom_service = this->services_.back();
+  auto &prom_service = this->services_[this->services_.count()++];
   prom_service.service_type = MDNS_STR(SERVICE_PROMETHEUS);
   prom_service.proto = MDNS_STR(SERVICE_TCP);
   prom_service.port = USE_WEBSERVER_PORT;
 #endif
 
 #ifdef USE_WEBSERVER
-  this->services_.emplace_back();
-  auto &web_service = this->services_.back();
+  auto &web_service = this->services_[this->services_.count()++];
   web_service.service_type = MDNS_STR(SERVICE_HTTP);
   web_service.proto = MDNS_STR(SERVICE_TCP);
   web_service.port = USE_WEBSERVER_PORT;
 #endif
 
-#ifdef USE_MDNS_EXTRA_SERVICES
-  this->services_.insert(this->services_.end(), this->services_extra_.begin(), this->services_extra_.end());
-#endif
-
 #if !defined(USE_API) && !defined(USE_PROMETHEUS) && !defined(USE_WEBSERVER) && !defined(USE_MDNS_EXTRA_SERVICES)
   // Publish "http" service if not using native API or any other services
   // This is just to have *some* mDNS service so that .local resolution works
-  this->services_.emplace_back();
-  auto &fallback_service = this->services_.back();
+  auto &fallback_service = this->services_[this->services_.count()++];
   fallback_service.service_type = "_http";
   fallback_service.proto = "_tcp";
   fallback_service.port = USE_WEBSERVER_PORT;
@@ -214,7 +187,7 @@ void MDNSComponent::dump_config() {
                 "mDNS:\n"
                 "  Hostname: %s",
                 this->hostname_.c_str());
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   ESP_LOGV(TAG, "  Services:");
   for (const auto &service : this->services_) {
     ESP_LOGV(TAG, "  - %s, %s, %d", service.service_type.c_str(), service.proto.c_str(),
@@ -227,8 +200,6 @@ void MDNSComponent::dump_config() {
 #endif
 }
 
-std::vector<MDNSService> MDNSComponent::get_services() { return this->services_; }
-
 }  // namespace mdns
 }  // namespace esphome
 #endif

esphome/components/mdns/mdns_component.h

@@ -2,13 +2,16 @@
 #include "esphome/core/defines.h"
 #ifdef USE_MDNS
 #include <string>
-#include <vector>
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace mdns {
 
+// Service count is calculated at compile time by Python codegen
+// MDNS_SERVICE_COUNT will always be defined
+
 struct MDNSTXTRecord {
   std::string key;
   TemplatableValue<std::string> value;
@@ -36,18 +39,15 @@ class MDNSComponent : public Component {
   float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
 #ifdef USE_MDNS_EXTRA_SERVICES
-  void add_extra_service(MDNSService service) { services_extra_.push_back(std::move(service)); }
+  void add_extra_service(MDNSService service) { this->services_[this->services_.count()++] = std::move(service); }
 #endif
 
-  std::vector<MDNSService> get_services();
+  const StaticVector<MDNSService, MDNS_SERVICE_COUNT> &get_services() const { return this->services_; }
 
   void on_shutdown() override;
 
  protected:
-#ifdef USE_MDNS_EXTRA_SERVICES
-  std::vector<MDNSService> services_extra_{};
-#endif
-  std::vector<MDNSService> services_{};
+  StaticVector<MDNSService, MDNS_SERVICE_COUNT> services_{};
   std::string hostname_;
   void compile_records_();
 };

esphome/components/mpr121/mpr121.cpp

@@ -13,45 +13,46 @@ static const char *const TAG = "mpr121";
 void MPR121Component::setup() {
   // soft reset device
   this->write_byte(MPR121_SOFTRESET, 0x63);
-  delay(100);  // NOLINT
-  if (!this->write_byte(MPR121_ECR, 0x0)) {
-    this->error_code_ = COMMUNICATION_FAILED;
-    this->mark_failed();
-    return;
-  }
+  this->set_timeout(100, [this]() {
+    if (!this->write_byte(MPR121_ECR, 0x0)) {
+      this->error_code_ = COMMUNICATION_FAILED;
+      this->mark_failed();
+      return;
+    }
+    // set touch sensitivity for all 12 channels
+    for (auto *channel : this->channels_) {
+      channel->setup();
+    }
+    this->write_byte(MPR121_MHDR, 0x01);
+    this->write_byte(MPR121_NHDR, 0x01);
+    this->write_byte(MPR121_NCLR, 0x0E);
+    this->write_byte(MPR121_FDLR, 0x00);
 
-  // set touch sensitivity for all 12 channels
-  for (auto *channel : this->channels_) {
-    channel->setup();
-  }
-  this->write_byte(MPR121_MHDR, 0x01);
-  this->write_byte(MPR121_NHDR, 0x01);
-  this->write_byte(MPR121_NCLR, 0x0E);
-  this->write_byte(MPR121_FDLR, 0x00);
+    this->write_byte(MPR121_MHDF, 0x01);
+    this->write_byte(MPR121_NHDF, 0x05);
+    this->write_byte(MPR121_NCLF, 0x01);
+    this->write_byte(MPR121_FDLF, 0x00);
 
-  this->write_byte(MPR121_MHDF, 0x01);
-  this->write_byte(MPR121_NHDF, 0x05);
-  this->write_byte(MPR121_NCLF, 0x01);
-  this->write_byte(MPR121_FDLF, 0x00);
+    this->write_byte(MPR121_NHDT, 0x00);
+    this->write_byte(MPR121_NCLT, 0x00);
+    this->write_byte(MPR121_FDLT, 0x00);
 
-  this->write_byte(MPR121_NHDT, 0x00);
-  this->write_byte(MPR121_NCLT, 0x00);
-  this->write_byte(MPR121_FDLT, 0x00);
+    this->write_byte(MPR121_DEBOUNCE, 0);
+    // default, 16uA charge current
+    this->write_byte(MPR121_CONFIG1, 0x10);
+    // 0.5uS encoding, 1ms period
+    this->write_byte(MPR121_CONFIG2, 0x20);
 
-  this->write_byte(MPR121_DEBOUNCE, 0);
-  // default, 16uA charge current
-  this->write_byte(MPR121_CONFIG1, 0x10);
-  // 0.5uS encoding, 1ms period
-  this->write_byte(MPR121_CONFIG2, 0x20);
+    // Write the Electrode Configuration Register
+    // * Highest 2 bits is "Calibration Lock", which we set to a value corresponding to 5 bits.
+    // * The 2 bits below is "Proximity Enable" and are left at 0.
+    // * The 4 least significant bits control how many electrodes are enabled. Electrodes are enabled
+    //   as a range, starting at 0 up to the highest channel index used.
+    this->write_byte(MPR121_ECR, 0x80 | (this->max_touch_channel_ + 1));
 
-  // Write the Electrode Configuration Register
-  // * Highest 2 bits is "Calibration Lock", which we set to a value corresponding to 5 bits.
-  // * The 2 bits below is "Proximity Enable" and are left at 0.
-  // * The 4 least significant bits control how many electrodes are enabled. Electrodes are enabled
-  //   as a range, starting at 0 up to the highest channel index used.
-  this->write_byte(MPR121_ECR, 0x80 | (this->max_touch_channel_ + 1));
-
-  this->flush_gpio_();
+    this->flush_gpio_();
+    this->setup_complete_ = true;
+  });
 }
 
 void MPR121Component::set_touch_debounce(uint8_t debounce) {
@@ -73,15 +74,15 @@ void MPR121Component::dump_config() {
     case COMMUNICATION_FAILED:
       ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
       break;
-    case WRONG_CHIP_STATE:
-      ESP_LOGE(TAG, "MPR121 has wrong default value for CONFIG2?");
-      break;
     case NONE:
     default:
       break;
   }
 }
 void MPR121Component::loop() {
+  if (!this->setup_complete_)
+    return;
+
   uint16_t val = 0;
   this->read_byte_16(MPR121_TOUCHSTATUS_L, &val);
 

esphome/components/mpr121/mpr121.h

@@ -80,6 +80,7 @@ class MPR121Component : public Component, public i2c::I2CDevice {
   void pin_mode(uint8_t ionum, gpio::Flags flags);
 
  protected:
+  bool setup_complete_{false};
   std::vector<MPR121Channel *> channels_{};
   uint8_t debounce_{0};
   uint8_t touch_threshold_{};
@@ -88,7 +89,6 @@ class MPR121Component : public Component, public i2c::I2CDevice {
   enum ErrorCode {
     NONE = 0,
     COMMUNICATION_FAILED,
-    WRONG_CHIP_STATE,
   } error_code_{NONE};
 
   bool flush_gpio_();

esphome/components/number/number_call.cpp

@@ -7,6 +7,17 @@ namespace number {
 
 static const char *const TAG = "number";
 
+// Helper functions to reduce code size for logging
+void NumberCall::log_perform_warning_(const LogString *message) {
+  ESP_LOGW(TAG, "'%s': %s", this->parent_->get_name().c_str(), LOG_STR_ARG(message));
+}
+
+void NumberCall::log_perform_warning_value_range_(const LogString *comparison, const LogString *limit_type, float val,
+                                                  float limit) {
+  ESP_LOGW(TAG, "'%s': %f %s %s %f", this->parent_->get_name().c_str(), val, LOG_STR_ARG(comparison),
+           LOG_STR_ARG(limit_type), limit);
+}
+
 NumberCall &NumberCall::set_value(float value) { return this->with_operation(NUMBER_OP_SET).with_value(value); }
 
 NumberCall &NumberCall::number_increment(bool cycle) {
@@ -42,7 +53,7 @@ void NumberCall::perform() {
   const auto &traits = parent->traits;
 
   if (this->operation_ == NUMBER_OP_NONE) {
-    ESP_LOGW(TAG, "'%s' - NumberCall performed without selecting an operation", name);
+    this->log_perform_warning_(LOG_STR("No operation"));
     return;
   }
 
@@ -51,28 +62,28 @@ void NumberCall::perform() {
   float max_value = traits.get_max_value();
 
   if (this->operation_ == NUMBER_OP_SET) {
-    ESP_LOGD(TAG, "'%s' - Setting number value", name);
+    ESP_LOGD(TAG, "'%s': Setting value", name);
     if (!this->value_.has_value() || std::isnan(*this->value_)) {
-      ESP_LOGW(TAG, "'%s' - No value set for NumberCall", name);
+      this->log_perform_warning_(LOG_STR("No value"));
       return;
     }
     target_value = this->value_.value();
   } else if (this->operation_ == NUMBER_OP_TO_MIN) {
     if (std::isnan(min_value)) {
-      ESP_LOGW(TAG, "'%s' - Can't set to min value through NumberCall: no min_value defined", name);
+      this->log_perform_warning_(LOG_STR("min undefined"));
     } else {
       target_value = min_value;
     }
   } else if (this->operation_ == NUMBER_OP_TO_MAX) {
     if (std::isnan(max_value)) {
-      ESP_LOGW(TAG, "'%s' - Can't set to max value through NumberCall: no max_value defined", name);
+      this->log_perform_warning_(LOG_STR("max undefined"));
     } else {
       target_value = max_value;
     }
   } else if (this->operation_ == NUMBER_OP_INCREMENT) {
-    ESP_LOGD(TAG, "'%s' - Increment number, with%s cycling", name, this->cycle_ ? "" : "out");
+    ESP_LOGD(TAG, "'%s': Increment with%s cycling", name, this->cycle_ ? "" : "out");
     if (!parent->has_state()) {
-      ESP_LOGW(TAG, "'%s' - Can't increment number through NumberCall: no active state to modify", name);
+      this->log_perform_warning_(LOG_STR("Can't increment, no state"));
       return;
     }
     auto step = traits.get_step();
@@ -85,9 +96,9 @@ void NumberCall::perform() {
       }
     }
   } else if (this->operation_ == NUMBER_OP_DECREMENT) {
-    ESP_LOGD(TAG, "'%s' - Decrement number, with%s cycling", name, this->cycle_ ? "" : "out");
+    ESP_LOGD(TAG, "'%s': Decrement with%s cycling", name, this->cycle_ ? "" : "out");
     if (!parent->has_state()) {
-      ESP_LOGW(TAG, "'%s' - Can't decrement number through NumberCall: no active state to modify", name);
+      this->log_perform_warning_(LOG_STR("Can't decrement, no state"));
       return;
     }
     auto step = traits.get_step();
@@ -102,15 +113,15 @@ void NumberCall::perform() {
   }
 
   if (target_value < min_value) {
-    ESP_LOGW(TAG, "'%s' - Value %f must not be less than minimum %f", name, target_value, min_value);
+    this->log_perform_warning_value_range_(LOG_STR("<"), LOG_STR("min"), target_value, min_value);
     return;
   }
   if (target_value > max_value) {
-    ESP_LOGW(TAG, "'%s' - Value %f must not be greater than maximum %f", name, target_value, max_value);
+    this->log_perform_warning_value_range_(LOG_STR(">"), LOG_STR("max"), target_value, max_value);
     return;
   }
 
-  ESP_LOGD(TAG, "  New number value: %f", target_value);
+  ESP_LOGD(TAG, "  New value: %f", target_value);
   this->parent_->control(target_value);
 }
 

esphome/components/number/number_call.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "number_traits.h"
 
 namespace esphome {
@@ -33,6 +34,10 @@ class NumberCall {
   NumberCall &with_cycle(bool cycle);
 
  protected:
+  void log_perform_warning_(const LogString *message);
+  void log_perform_warning_value_range_(const LogString *comparison, const LogString *limit_type, float val,
+                                        float limit);
+
   Number *const parent_;
   NumberOperation operation_{NUMBER_OP_NONE};
   optional<float> value_;

esphome/components/openthread/openthread.cpp

@@ -143,11 +143,10 @@ void OpenThreadSrpComponent::setup() {
     return;
   }
 
-  // Copy the mdns services to our local instance so that the c_str pointers remain valid for the lifetime of this
-  // component
-  this->mdns_services_ = this->mdns_->get_services();
-  ESP_LOGD(TAG, "Setting up SRP services. count = %d\n", this->mdns_services_.size());
-  for (const auto &service : this->mdns_services_) {
+  // Get mdns services and copy their data (strings are copied with strdup below)
+  const auto &mdns_services = this->mdns_->get_services();
+  ESP_LOGD(TAG, "Setting up SRP services. count = %d\n", mdns_services.size());
+  for (const auto &service : mdns_services) {
     otSrpClientBuffersServiceEntry *entry = otSrpClientBuffersAllocateService(instance);
     if (!entry) {
       ESP_LOGW(TAG, "Failed to allocate service entry");

esphome/components/openthread/openthread.h

@@ -57,7 +57,6 @@ class OpenThreadSrpComponent : public Component {
 
  protected:
   esphome::mdns::MDNSComponent *mdns_{nullptr};
-  std::vector<esphome::mdns::MDNSService> mdns_services_;
   std::vector<std::unique_ptr<uint8_t[]>> memory_pool_;
   void *pool_alloc_(size_t size);
 };

esphome/components/prometheus/prometheus_handler.cpp

@@ -110,21 +110,21 @@ std::string PrometheusHandler::relabel_name_(EntityBase *obj) {
 
 void PrometheusHandler::add_area_label_(AsyncResponseStream *stream, std::string &area) {
   if (!area.empty()) {
-    stream->print(F("\",area=\""));
+    stream->print(ESPHOME_F("\",area=\""));
     stream->print(area.c_str());
   }
 }
 
 void PrometheusHandler::add_node_label_(AsyncResponseStream *stream, std::string &node) {
   if (!node.empty()) {
-    stream->print(F("\",node=\""));
+    stream->print(ESPHOME_F("\",node=\""));
     stream->print(node.c_str());
   }
 }
 
 void PrometheusHandler::add_friendly_name_label_(AsyncResponseStream *stream, std::string &friendly_name) {
   if (!friendly_name.empty()) {
-    stream->print(F("\",friendly_name=\""));
+    stream->print(ESPHOME_F("\",friendly_name=\""));
     stream->print(friendly_name.c_str());
   }
 }
@@ -132,8 +132,8 @@ void PrometheusHandler::add_friendly_name_label_(AsyncResponseStream *stream, st
 // Type-specific implementation
 #ifdef USE_SENSOR
 void PrometheusHandler::sensor_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_sensor_value gauge\n"));
-  stream->print(F("#TYPE esphome_sensor_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_sensor_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_sensor_failed gauge\n"));
 }
 void PrometheusHandler::sensor_row_(AsyncResponseStream *stream, sensor::Sensor *obj, std::string &area,
                                     std::string &node, std::string &friendly_name) {
@@ -141,37 +141,37 @@ void PrometheusHandler::sensor_row_(AsyncResponseStream *stream, sensor::Sensor
     return;
   if (!std::isnan(obj->state)) {
     // We have a valid value, output this value
-    stream->print(F("esphome_sensor_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_sensor_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // Data itself
-    stream->print(F("esphome_sensor_value{id=\""));
+    stream->print(ESPHOME_F("esphome_sensor_value{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",unit=\""));
+    stream->print(ESPHOME_F("\",unit=\""));
     stream->print(obj->get_unit_of_measurement().c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(value_accuracy_to_string(obj->state, obj->get_accuracy_decimals()).c_str());
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
   } else {
     // Invalid state
-    stream->print(F("esphome_sensor_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_sensor_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
@@ -179,8 +179,8 @@ void PrometheusHandler::sensor_row_(AsyncResponseStream *stream, sensor::Sensor
 // Type-specific implementation
 #ifdef USE_BINARY_SENSOR
 void PrometheusHandler::binary_sensor_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_binary_sensor_value gauge\n"));
-  stream->print(F("#TYPE esphome_binary_sensor_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_binary_sensor_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_binary_sensor_failed gauge\n"));
 }
 void PrometheusHandler::binary_sensor_row_(AsyncResponseStream *stream, binary_sensor::BinarySensor *obj,
                                            std::string &area, std::string &node, std::string &friendly_name) {
@@ -188,204 +188,204 @@ void PrometheusHandler::binary_sensor_row_(AsyncResponseStream *stream, binary_s
     return;
   if (obj->has_state()) {
     // We have a valid value, output this value
-    stream->print(F("esphome_binary_sensor_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_binary_sensor_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // Data itself
-    stream->print(F("esphome_binary_sensor_value{id=\""));
+    stream->print(ESPHOME_F("esphome_binary_sensor_value{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(obj->state);
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
   } else {
     // Invalid state
-    stream->print(F("esphome_binary_sensor_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_binary_sensor_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
 
 #ifdef USE_FAN
 void PrometheusHandler::fan_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_fan_value gauge\n"));
-  stream->print(F("#TYPE esphome_fan_failed gauge\n"));
-  stream->print(F("#TYPE esphome_fan_speed gauge\n"));
-  stream->print(F("#TYPE esphome_fan_oscillation gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_fan_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_fan_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_fan_speed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_fan_oscillation gauge\n"));
 }
 void PrometheusHandler::fan_row_(AsyncResponseStream *stream, fan::Fan *obj, std::string &area, std::string &node,
                                  std::string &friendly_name) {
   if (obj->is_internal() && !this->include_internal_)
     return;
-  stream->print(F("esphome_fan_failed{id=\""));
+  stream->print(ESPHOME_F("esphome_fan_failed{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} 0\n"));
+  stream->print(ESPHOME_F("\"} 0\n"));
   // Data itself
-  stream->print(F("esphome_fan_value{id=\""));
+  stream->print(ESPHOME_F("esphome_fan_value{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   stream->print(obj->state);
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
   // Speed if available
   if (obj->get_traits().supports_speed()) {
-    stream->print(F("esphome_fan_speed{id=\""));
+    stream->print(ESPHOME_F("esphome_fan_speed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(obj->speed);
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
   }
   // Oscillation if available
   if (obj->get_traits().supports_oscillation()) {
-    stream->print(F("esphome_fan_oscillation{id=\""));
+    stream->print(ESPHOME_F("esphome_fan_oscillation{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(obj->oscillating);
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
   }
 }
 #endif
 
 #ifdef USE_LIGHT
 void PrometheusHandler::light_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_light_state gauge\n"));
-  stream->print(F("#TYPE esphome_light_color gauge\n"));
-  stream->print(F("#TYPE esphome_light_effect_active gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_light_state gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_light_color gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_light_effect_active gauge\n"));
 }
 void PrometheusHandler::light_row_(AsyncResponseStream *stream, light::LightState *obj, std::string &area,
                                    std::string &node, std::string &friendly_name) {
   if (obj->is_internal() && !this->include_internal_)
     return;
   // State
-  stream->print(F("esphome_light_state{id=\""));
+  stream->print(ESPHOME_F("esphome_light_state{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   stream->print(obj->remote_values.is_on());
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
   // Brightness and RGBW
   light::LightColorValues color = obj->current_values;
   float brightness, r, g, b, w;
   color.as_brightness(&brightness);
   color.as_rgbw(&r, &g, &b, &w);
-  stream->print(F("esphome_light_color{id=\""));
+  stream->print(ESPHOME_F("esphome_light_color{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",channel=\"brightness\"} "));
+  stream->print(ESPHOME_F("\",channel=\"brightness\"} "));
   stream->print(brightness);
-  stream->print(F("\n"));
-  stream->print(F("esphome_light_color{id=\""));
+  stream->print(ESPHOME_F("\n"));
+  stream->print(ESPHOME_F("esphome_light_color{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",channel=\"r\"} "));
+  stream->print(ESPHOME_F("\",channel=\"r\"} "));
   stream->print(r);
-  stream->print(F("\n"));
-  stream->print(F("esphome_light_color{id=\""));
+  stream->print(ESPHOME_F("\n"));
+  stream->print(ESPHOME_F("esphome_light_color{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",channel=\"g\"} "));
+  stream->print(ESPHOME_F("\",channel=\"g\"} "));
   stream->print(g);
-  stream->print(F("\n"));
-  stream->print(F("esphome_light_color{id=\""));
+  stream->print(ESPHOME_F("\n"));
+  stream->print(ESPHOME_F("esphome_light_color{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",channel=\"b\"} "));
+  stream->print(ESPHOME_F("\",channel=\"b\"} "));
   stream->print(b);
-  stream->print(F("\n"));
-  stream->print(F("esphome_light_color{id=\""));
+  stream->print(ESPHOME_F("\n"));
+  stream->print(ESPHOME_F("esphome_light_color{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",channel=\"w\"} "));
+  stream->print(ESPHOME_F("\",channel=\"w\"} "));
   stream->print(w);
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
   // Effect
   std::string effect = obj->get_effect_name();
   if (effect == "None") {
-    stream->print(F("esphome_light_effect_active{id=\""));
+    stream->print(ESPHOME_F("esphome_light_effect_active{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",effect=\"None\"} 0\n"));
+    stream->print(ESPHOME_F("\",effect=\"None\"} 0\n"));
   } else {
-    stream->print(F("esphome_light_effect_active{id=\""));
+    stream->print(ESPHOME_F("esphome_light_effect_active{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",effect=\""));
+    stream->print(ESPHOME_F("\",effect=\""));
     stream->print(effect.c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
 
 #ifdef USE_COVER
 void PrometheusHandler::cover_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_cover_value gauge\n"));
-  stream->print(F("#TYPE esphome_cover_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_cover_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_cover_failed gauge\n"));
 }
 void PrometheusHandler::cover_row_(AsyncResponseStream *stream, cover::Cover *obj, std::string &area, std::string &node,
                                    std::string &friendly_name) {
@@ -393,118 +393,118 @@ void PrometheusHandler::cover_row_(AsyncResponseStream *stream, cover::Cover *ob
     return;
   if (!std::isnan(obj->position)) {
     // We have a valid value, output this value
-    stream->print(F("esphome_cover_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_cover_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // Data itself
-    stream->print(F("esphome_cover_value{id=\""));
+    stream->print(ESPHOME_F("esphome_cover_value{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(obj->position);
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
     if (obj->get_traits().get_supports_tilt()) {
-      stream->print(F("esphome_cover_tilt{id=\""));
+      stream->print(ESPHOME_F("esphome_cover_tilt{id=\""));
       stream->print(relabel_id_(obj).c_str());
       add_area_label_(stream, area);
       add_node_label_(stream, node);
       add_friendly_name_label_(stream, friendly_name);
-      stream->print(F("\",name=\""));
+      stream->print(ESPHOME_F("\",name=\""));
       stream->print(relabel_name_(obj).c_str());
-      stream->print(F("\"} "));
+      stream->print(ESPHOME_F("\"} "));
       stream->print(obj->tilt);
-      stream->print(F("\n"));
+      stream->print(ESPHOME_F("\n"));
     }
   } else {
     // Invalid state
-    stream->print(F("esphome_cover_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_cover_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
 
 #ifdef USE_SWITCH
 void PrometheusHandler::switch_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_switch_value gauge\n"));
-  stream->print(F("#TYPE esphome_switch_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_switch_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_switch_failed gauge\n"));
 }
 void PrometheusHandler::switch_row_(AsyncResponseStream *stream, switch_::Switch *obj, std::string &area,
                                     std::string &node, std::string &friendly_name) {
   if (obj->is_internal() && !this->include_internal_)
     return;
-  stream->print(F("esphome_switch_failed{id=\""));
+  stream->print(ESPHOME_F("esphome_switch_failed{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} 0\n"));
+  stream->print(ESPHOME_F("\"} 0\n"));
   // Data itself
-  stream->print(F("esphome_switch_value{id=\""));
+  stream->print(ESPHOME_F("esphome_switch_value{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   stream->print(obj->state);
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
 }
 #endif
 
 #ifdef USE_LOCK
 void PrometheusHandler::lock_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_lock_value gauge\n"));
-  stream->print(F("#TYPE esphome_lock_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_lock_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_lock_failed gauge\n"));
 }
 void PrometheusHandler::lock_row_(AsyncResponseStream *stream, lock::Lock *obj, std::string &area, std::string &node,
                                   std::string &friendly_name) {
   if (obj->is_internal() && !this->include_internal_)
     return;
-  stream->print(F("esphome_lock_failed{id=\""));
+  stream->print(ESPHOME_F("esphome_lock_failed{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} 0\n"));
+  stream->print(ESPHOME_F("\"} 0\n"));
   // Data itself
-  stream->print(F("esphome_lock_value{id=\""));
+  stream->print(ESPHOME_F("esphome_lock_value{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   stream->print(obj->state);
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
 }
 #endif
 
 // Type-specific implementation
 #ifdef USE_TEXT_SENSOR
 void PrometheusHandler::text_sensor_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_text_sensor_value gauge\n"));
-  stream->print(F("#TYPE esphome_text_sensor_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_text_sensor_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_text_sensor_failed gauge\n"));
 }
 void PrometheusHandler::text_sensor_row_(AsyncResponseStream *stream, text_sensor::TextSensor *obj, std::string &area,
                                          std::string &node, std::string &friendly_name) {
@@ -512,37 +512,37 @@ void PrometheusHandler::text_sensor_row_(AsyncResponseStream *stream, text_senso
     return;
   if (obj->has_state()) {
     // We have a valid value, output this value
-    stream->print(F("esphome_text_sensor_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_text_sensor_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // Data itself
-    stream->print(F("esphome_text_sensor_value{id=\""));
+    stream->print(ESPHOME_F("esphome_text_sensor_value{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",value=\""));
+    stream->print(ESPHOME_F("\",value=\""));
     stream->print(obj->state.c_str());
-    stream->print(F("\"} "));
-    stream->print(F("1.0"));
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\"} "));
+    stream->print(ESPHOME_F("1.0"));
+    stream->print(ESPHOME_F("\n"));
   } else {
     // Invalid state
-    stream->print(F("esphome_text_sensor_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_text_sensor_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
@@ -550,8 +550,8 @@ void PrometheusHandler::text_sensor_row_(AsyncResponseStream *stream, text_senso
 // Type-specific implementation
 #ifdef USE_NUMBER
 void PrometheusHandler::number_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_number_value gauge\n"));
-  stream->print(F("#TYPE esphome_number_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_number_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_number_failed gauge\n"));
 }
 void PrometheusHandler::number_row_(AsyncResponseStream *stream, number::Number *obj, std::string &area,
                                     std::string &node, std::string &friendly_name) {
@@ -559,43 +559,43 @@ void PrometheusHandler::number_row_(AsyncResponseStream *stream, number::Number
     return;
   if (!std::isnan(obj->state)) {
     // We have a valid value, output this value
-    stream->print(F("esphome_number_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_number_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // Data itself
-    stream->print(F("esphome_number_value{id=\""));
+    stream->print(ESPHOME_F("esphome_number_value{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(obj->state);
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
   } else {
     // Invalid state
-    stream->print(F("esphome_number_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_number_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
 
 #ifdef USE_SELECT
 void PrometheusHandler::select_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_select_value gauge\n"));
-  stream->print(F("#TYPE esphome_select_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_select_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_select_failed gauge\n"));
 }
 void PrometheusHandler::select_row_(AsyncResponseStream *stream, select::Select *obj, std::string &area,
                                     std::string &node, std::string &friendly_name) {
@@ -603,105 +603,105 @@ void PrometheusHandler::select_row_(AsyncResponseStream *stream, select::Select
     return;
   if (obj->has_state()) {
     // We have a valid value, output this value
-    stream->print(F("esphome_select_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_select_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // Data itself
-    stream->print(F("esphome_select_value{id=\""));
+    stream->print(ESPHOME_F("esphome_select_value{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",value=\""));
+    stream->print(ESPHOME_F("\",value=\""));
     stream->print(obj->state.c_str());
-    stream->print(F("\"} "));
-    stream->print(F("1.0"));
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\"} "));
+    stream->print(ESPHOME_F("1.0"));
+    stream->print(ESPHOME_F("\n"));
   } else {
     // Invalid state
-    stream->print(F("esphome_select_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_select_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
 
 #ifdef USE_MEDIA_PLAYER
 void PrometheusHandler::media_player_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_media_player_state_value gauge\n"));
-  stream->print(F("#TYPE esphome_media_player_volume gauge\n"));
-  stream->print(F("#TYPE esphome_media_player_is_muted gauge\n"));
-  stream->print(F("#TYPE esphome_media_player_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_media_player_state_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_media_player_volume gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_media_player_is_muted gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_media_player_failed gauge\n"));
 }
 void PrometheusHandler::media_player_row_(AsyncResponseStream *stream, media_player::MediaPlayer *obj,
                                           std::string &area, std::string &node, std::string &friendly_name) {
   if (obj->is_internal() && !this->include_internal_)
     return;
-  stream->print(F("esphome_media_player_failed{id=\""));
+  stream->print(ESPHOME_F("esphome_media_player_failed{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} 0\n"));
+  stream->print(ESPHOME_F("\"} 0\n"));
   // Data itself
-  stream->print(F("esphome_media_player_state_value{id=\""));
+  stream->print(ESPHOME_F("esphome_media_player_state_value{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",value=\""));
+  stream->print(ESPHOME_F("\",value=\""));
   stream->print(media_player::media_player_state_to_string(obj->state));
-  stream->print(F("\"} "));
-  stream->print(F("1.0"));
-  stream->print(F("\n"));
-  stream->print(F("esphome_media_player_volume{id=\""));
+  stream->print(ESPHOME_F("\"} "));
+  stream->print(ESPHOME_F("1.0"));
+  stream->print(ESPHOME_F("\n"));
+  stream->print(ESPHOME_F("esphome_media_player_volume{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   stream->print(obj->volume);
-  stream->print(F("\n"));
-  stream->print(F("esphome_media_player_is_muted{id=\""));
+  stream->print(ESPHOME_F("\n"));
+  stream->print(ESPHOME_F("esphome_media_player_is_muted{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   if (obj->is_muted()) {
-    stream->print(F("1.0"));
+    stream->print(ESPHOME_F("1.0"));
   } else {
-    stream->print(F("0.0"));
+    stream->print(ESPHOME_F("0.0"));
   }
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
 }
 #endif
 
 #ifdef USE_UPDATE
 void PrometheusHandler::update_entity_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_update_entity_state gauge\n"));
-  stream->print(F("#TYPE esphome_update_entity_info gauge\n"));
-  stream->print(F("#TYPE esphome_update_entity_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_update_entity_state gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_update_entity_info gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_update_entity_failed gauge\n"));
 }
 
 void PrometheusHandler::handle_update_state_(AsyncResponseStream *stream, update::UpdateState state) {
@@ -730,168 +730,168 @@ void PrometheusHandler::update_entity_row_(AsyncResponseStream *stream, update::
     return;
   if (obj->has_state()) {
     // We have a valid value, output this value
-    stream->print(F("esphome_update_entity_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_update_entity_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 0\n"));
+    stream->print(ESPHOME_F("\"} 0\n"));
     // First update state
-    stream->print(F("esphome_update_entity_state{id=\""));
+    stream->print(ESPHOME_F("esphome_update_entity_state{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",value=\""));
+    stream->print(ESPHOME_F("\",value=\""));
     handle_update_state_(stream, obj->state);
-    stream->print(F("\"} "));
-    stream->print(F("1.0"));
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\"} "));
+    stream->print(ESPHOME_F("1.0"));
+    stream->print(ESPHOME_F("\n"));
     // Next update info
-    stream->print(F("esphome_update_entity_info{id=\""));
+    stream->print(ESPHOME_F("esphome_update_entity_info{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\",current_version=\""));
+    stream->print(ESPHOME_F("\",current_version=\""));
     stream->print(obj->update_info.current_version.c_str());
-    stream->print(F("\",latest_version=\""));
+    stream->print(ESPHOME_F("\",latest_version=\""));
     stream->print(obj->update_info.latest_version.c_str());
-    stream->print(F("\",title=\""));
+    stream->print(ESPHOME_F("\",title=\""));
     stream->print(obj->update_info.title.c_str());
-    stream->print(F("\"} "));
-    stream->print(F("1.0"));
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\"} "));
+    stream->print(ESPHOME_F("1.0"));
+    stream->print(ESPHOME_F("\n"));
   } else {
     // Invalid state
-    stream->print(F("esphome_update_entity_failed{id=\""));
+    stream->print(ESPHOME_F("esphome_update_entity_failed{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} 1\n"));
+    stream->print(ESPHOME_F("\"} 1\n"));
   }
 }
 #endif
 
 #ifdef USE_VALVE
 void PrometheusHandler::valve_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_valve_operation gauge\n"));
-  stream->print(F("#TYPE esphome_valve_failed gauge\n"));
-  stream->print(F("#TYPE esphome_valve_position gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_valve_operation gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_valve_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_valve_position gauge\n"));
 }
 
 void PrometheusHandler::valve_row_(AsyncResponseStream *stream, valve::Valve *obj, std::string &area, std::string &node,
                                    std::string &friendly_name) {
   if (obj->is_internal() && !this->include_internal_)
     return;
-  stream->print(F("esphome_valve_failed{id=\""));
+  stream->print(ESPHOME_F("esphome_valve_failed{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\"} 0\n"));
+  stream->print(ESPHOME_F("\"} 0\n"));
   // Data itself
-  stream->print(F("esphome_valve_operation{id=\""));
+  stream->print(ESPHOME_F("esphome_valve_operation{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",operation=\""));
+  stream->print(ESPHOME_F("\",operation=\""));
   stream->print(valve::valve_operation_to_str(obj->current_operation));
-  stream->print(F("\"} "));
-  stream->print(F("1.0"));
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\"} "));
+  stream->print(ESPHOME_F("1.0"));
+  stream->print(ESPHOME_F("\n"));
   // Now see if position is supported
   if (obj->get_traits().get_supports_position()) {
-    stream->print(F("esphome_valve_position{id=\""));
+    stream->print(ESPHOME_F("esphome_valve_position{id=\""));
     stream->print(relabel_id_(obj).c_str());
     add_area_label_(stream, area);
     add_node_label_(stream, node);
     add_friendly_name_label_(stream, friendly_name);
-    stream->print(F("\",name=\""));
+    stream->print(ESPHOME_F("\",name=\""));
     stream->print(relabel_name_(obj).c_str());
-    stream->print(F("\"} "));
+    stream->print(ESPHOME_F("\"} "));
     stream->print(obj->position);
-    stream->print(F("\n"));
+    stream->print(ESPHOME_F("\n"));
   }
 }
 #endif
 
 #ifdef USE_CLIMATE
 void PrometheusHandler::climate_type_(AsyncResponseStream *stream) {
-  stream->print(F("#TYPE esphome_climate_setting gauge\n"));
-  stream->print(F("#TYPE esphome_climate_value gauge\n"));
-  stream->print(F("#TYPE esphome_climate_failed gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_climate_setting gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_climate_value gauge\n"));
+  stream->print(ESPHOME_F("#TYPE esphome_climate_failed gauge\n"));
 }
 
 void PrometheusHandler::climate_setting_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
                                              std::string &node, std::string &friendly_name, std::string &setting,
                                              const LogString *setting_value) {
-  stream->print(F("esphome_climate_setting{id=\""));
+  stream->print(ESPHOME_F("esphome_climate_setting{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",category=\""));
+  stream->print(ESPHOME_F("\",category=\""));
   stream->print(setting.c_str());
-  stream->print(F("\",setting_value=\""));
+  stream->print(ESPHOME_F("\",setting_value=\""));
   stream->print(LOG_STR_ARG(setting_value));
-  stream->print(F("\"} "));
-  stream->print(F("1.0"));
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\"} "));
+  stream->print(ESPHOME_F("1.0"));
+  stream->print(ESPHOME_F("\n"));
 }
 
 void PrometheusHandler::climate_value_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
                                            std::string &node, std::string &friendly_name, std::string &category,
                                            std::string &climate_value) {
-  stream->print(F("esphome_climate_value{id=\""));
+  stream->print(ESPHOME_F("esphome_climate_value{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",category=\""));
+  stream->print(ESPHOME_F("\",category=\""));
   stream->print(category.c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   stream->print(climate_value.c_str());
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
 }
 
 void PrometheusHandler::climate_failed_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,
                                             std::string &node, std::string &friendly_name, std::string &category,
                                             bool is_failed_value) {
-  stream->print(F("esphome_climate_failed{id=\""));
+  stream->print(ESPHOME_F("esphome_climate_failed{id=\""));
   stream->print(relabel_id_(obj).c_str());
   add_area_label_(stream, area);
   add_node_label_(stream, node);
   add_friendly_name_label_(stream, friendly_name);
-  stream->print(F("\",name=\""));
+  stream->print(ESPHOME_F("\",name=\""));
   stream->print(relabel_name_(obj).c_str());
-  stream->print(F("\",category=\""));
+  stream->print(ESPHOME_F("\",category=\""));
   stream->print(category.c_str());
-  stream->print(F("\"} "));
+  stream->print(ESPHOME_F("\"} "));
   if (is_failed_value) {
-    stream->print(F("1.0"));
+    stream->print(ESPHOME_F("1.0"));
   } else {
-    stream->print(F("0.0"));
+    stream->print(ESPHOME_F("0.0"));
   }
-  stream->print(F("\n"));
+  stream->print(ESPHOME_F("\n"));
 }
 
 void PrometheusHandler::climate_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area,

esphome/components/sha256/sha256.cpp

@@ -10,6 +10,41 @@ namespace esphome::sha256 {
 
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
 
+// CRITICAL ESP32-S3 HARDWARE SHA ACCELERATION REQUIREMENTS:
+//
+// The ESP32-S3 uses hardware DMA for SHA acceleration. The mbedtls_sha256_context structure contains
+// internal state that the DMA engine references. This imposes two critical constraints:
+//
+// 1. NO VARIABLE LENGTH ARRAYS (VLAs): VLAs corrupt the stack layout, causing the DMA engine to
+//    write to incorrect memory locations. This results in null pointer dereferences and crashes.
+//    ALWAYS use fixed-size arrays (e.g., char buf[65], not char buf[size+1]).
+//
+// 2. SAME STACK FRAME ONLY: The SHA256 object must be created and used entirely within the same
+//    function. NEVER pass the SHA256 object or HashBase pointer to another function. When the stack
+//    frame changes (function call/return), the DMA references become invalid and will produce
+//    truncated hash output (20 bytes instead of 32) or corrupt memory.
+//
+// CORRECT USAGE:
+//   void my_function() {
+//     sha256::SHA256 hasher;  // Created locally
+//     hasher.init();
+//     hasher.add(data, len);  // Any size, no chunking needed
+//     hasher.calculate();
+//     bool ok = hasher.equals_hex(expected);
+//     // hasher destroyed when function returns
+//   }
+//
+// INCORRECT USAGE (WILL FAIL ON ESP32-S3):
+//   void my_function() {
+//     sha256::SHA256 hasher;
+//     helper(&hasher);  // WRONG: Passed to different stack frame
+//   }
+//   void helper(HashBase *h) {
+//     h->init();  // WRONG: Will produce truncated/corrupted output
+//   }
+//
+// See s3_hardware_sha.md for complete details on symptoms and debugging.
+
 SHA256::~SHA256() { mbedtls_sha256_free(&this->ctx_); }
 
 void SHA256::init() {

esphome/components/sha256/sha256.h

@@ -39,6 +39,10 @@ class SHA256 : public esphome::HashBase {
 
  protected:
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
+  // CRITICAL: The mbedtls context MUST be stack-allocated (not a pointer) for ESP32-S3 hardware SHA acceleration.
+  // The ESP32-S3 DMA engine references this structure's memory addresses. If the context is passed to another
+  // function (crossing stack frames) or if VLAs are present, the DMA operations will corrupt memory and produce
+  // truncated/incorrect hash results. See s3_hardware_sha.md for details.
   mbedtls_sha256_context ctx_{};
 #elif defined(USE_ESP8266) || defined(USE_RP2040)
   br_sha256_context ctx_{};

esphome/components/sps30/sps30.cpp

@@ -45,24 +45,26 @@ void SPS30Component::setup() {
     }
     ESP_LOGV(TAG, "  Serial number: %s", this->serial_number_);
 
-    bool result;
     if (this->fan_interval_.has_value()) {
       // override default value
-      result = this->write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS, this->fan_interval_.value());
+      this->result_ =
+          this->write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS, this->fan_interval_.value());
     } else {
-      result = this->write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS);
-    }
-    if (result) {
-      delay(20);
-      uint16_t secs[2];
-      if (this->read_data(secs, 2)) {
-        this->fan_interval_ = secs[0] << 16 | secs[1];
-      }
+      this->result_ = this->write_command(SPS30_CMD_SET_AUTOMATIC_CLEANING_INTERVAL_SECONDS);
     }
 
-    this->status_clear_warning();
-    this->skipped_data_read_cycles_ = 0;
-    this->start_continuous_measurement_();
+    this->set_timeout(20, [this]() {
+      if (this->result_) {
+        uint16_t secs[2];
+        if (this->read_data(secs, 2)) {
+          this->fan_interval_ = secs[0] << 16 | secs[1];
+        }
+      }
+      this->status_clear_warning();
+      this->skipped_data_read_cycles_ = 0;
+      this->start_continuous_measurement_();
+      this->setup_complete_ = true;
+    });
   });
 }
 
@@ -111,6 +113,8 @@ void SPS30Component::dump_config() {
 }
 
 void SPS30Component::update() {
+  if (!this->setup_complete_)
+    return;
   /// Check if warning flag active (sensor reconnected?)
   if (this->status_has_warning()) {
     ESP_LOGD(TAG, "Reconnecting");

esphome/components/sps30/sps30.h

@@ -30,9 +30,12 @@ class SPS30Component : public PollingComponent, public sensirion_common::Sensiri
   bool start_fan_cleaning();
 
  protected:
+  bool result_{false};
+  bool setup_complete_{false};
   uint16_t raw_firmware_version_;
   char serial_number_[17] = {0};  /// Terminating NULL character
   uint8_t skipped_data_read_cycles_ = 0;
+
   bool start_continuous_measurement_();
 
   enum ErrorCode : uint8_t {

esphome/components/web_server/list_entities.cpp

@@ -9,13 +9,12 @@
 namespace esphome {
 namespace web_server {
 
-#ifdef USE_ARDUINO
+#ifdef USE_ESP32
+ListEntitiesIterator::ListEntitiesIterator(const WebServer *ws, AsyncEventSource *es) : web_server_(ws), events_(es) {}
+#elif USE_ARDUINO
 ListEntitiesIterator::ListEntitiesIterator(const WebServer *ws, DeferredUpdateEventSource *es)
     : web_server_(ws), events_(es) {}
 #endif
-#ifdef USE_ESP_IDF
-ListEntitiesIterator::ListEntitiesIterator(const WebServer *ws, AsyncEventSource *es) : web_server_(ws), events_(es) {}
-#endif
 ListEntitiesIterator::~ListEntitiesIterator() {}
 
 #ifdef USE_BINARY_SENSOR

esphome/components/web_server/list_entities.h

@@ -5,25 +5,24 @@
 #include "esphome/core/component.h"
 #include "esphome/core/component_iterator.h"
 namespace esphome {
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 namespace web_server_idf {
 class AsyncEventSource;
 }
 #endif
 namespace web_server {
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
 class DeferredUpdateEventSource;
 #endif
 class WebServer;
 
 class ListEntitiesIterator : public ComponentIterator {
  public:
-#ifdef USE_ARDUINO
-  ListEntitiesIterator(const WebServer *ws, DeferredUpdateEventSource *es);
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   ListEntitiesIterator(const WebServer *ws, esphome::web_server_idf::AsyncEventSource *es);
+#elif defined(USE_ARDUINO)
+  ListEntitiesIterator(const WebServer *ws, DeferredUpdateEventSource *es);
 #endif
   virtual ~ListEntitiesIterator();
 #ifdef USE_BINARY_SENSOR
@@ -90,11 +89,10 @@ class ListEntitiesIterator : public ComponentIterator {
 
  protected:
   const WebServer *web_server_;
-#ifdef USE_ARDUINO
-  DeferredUpdateEventSource *events_;
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   esphome::web_server_idf::AsyncEventSource *events_;
+#elif USE_ARDUINO
+  DeferredUpdateEventSource *events_;
 #endif
 };
 

esphome/components/web_server/ota/__init__.py

@@ -29,5 +29,5 @@ async def to_code(config):
     await ota_to_code(var, config)
     await cg.register_component(var, config)
     cg.add_define("USE_WEBSERVER_OTA")
-    if CORE.using_esp_idf:
+    if CORE.is_esp32:
         add_idf_component(name="zorxx/multipart-parser", ref="1.0.1")

esphome/components/web_server/ota/ota_web_server.cpp

@@ -17,6 +17,12 @@
 #endif
 #endif  // USE_ARDUINO
 
+#if USE_ESP32
+using PlatformString = std::string;
+#elif USE_ARDUINO
+using PlatformString = String;
+#endif
+
 namespace esphome {
 namespace web_server {
 
@@ -26,8 +32,8 @@ class OTARequestHandler : public AsyncWebHandler {
  public:
   OTARequestHandler(WebServerOTAComponent *parent) : parent_(parent) {}
   void handleRequest(AsyncWebServerRequest *request) override;
-  void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len,
-                    bool final) override;
+  void handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index, uint8_t *data,
+                    size_t len, bool final) override;
   bool canHandle(AsyncWebServerRequest *request) const override {
     // Check if this is an OTA update request
     bool is_ota_request = request->url() == "/update" && request->method() == HTTP_POST;
@@ -100,7 +106,7 @@ void OTARequestHandler::ota_init_(const char *filename) {
   this->ota_success_ = false;
 }
 
-void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index,
+void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index,
                                      uint8_t *data, size_t len, bool final) {
   ota::OTAResponseTypes error_code = ota::OTA_RESPONSE_OK;
 

esphome/components/web_server/web_server.cpp

@@ -8,7 +8,7 @@
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
 #include "StreamString.h"
 #endif
 
@@ -103,7 +103,7 @@ static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain)
   return match;
 }
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
 // helper for allowing only unique entries in the queue
 void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_generator_t *message_generator) {
   DeferredEvent item(source, message_generator);
@@ -127,6 +127,10 @@ void DeferredUpdateEventSource::process_deferred_queue_() {
       deferred_queue_.erase(deferred_queue_.begin());
       this->consecutive_send_failures_ = 0;  // Reset failure count on successful send
     } else {
+      // NOTE: Similar logic exists in web_server_idf/web_server_idf.cpp in AsyncEventSourceResponse::process_buffer_()
+      // The implementations differ due to platform-specific APIs (DISCARDED vs HTTPD_SOCK_ERR_TIMEOUT, close() vs
+      // fd_.store(0)), but the failure counting and timeout logic should be kept in sync. If you change this logic,
+      // also update the ESP-IDF implementation.
       this->consecutive_send_failures_++;
       if (this->consecutive_send_failures_ >= MAX_CONSECUTIVE_SEND_FAILURES) {
         // Too many failures, connection is likely dead
@@ -297,7 +301,7 @@ void WebServer::setup() {
   }
 #endif
 
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   this->base_->add_handler(&this->events_);
 #endif
   this->base_->add_handler(this);
@@ -1262,7 +1266,7 @@ std::string WebServer::select_json(select::Select *obj, const std::string &value
 #endif
 
 // Longest: HORIZONTAL
-#define PSTR_LOCAL(mode_s) strncpy_P(buf, (PGM_P) ((mode_s)), 15)
+#define PSTR_LOCAL(mode_s) ESPHOME_strncpy_P(buf, (ESPHOME_PGM_P) ((mode_s)), 15)
 
 #ifdef USE_CLIMATE
 void WebServer::on_climate_update(climate::Climate *obj) {
@@ -1772,15 +1776,15 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
 
   // Static URL checks
   static const char *const STATIC_URLS[] = {
-      "/",
-#ifdef USE_ARDUINO
-      "/events",
+    "/",
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
+    "/events",
 #endif
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-      "/0.css",
+    "/0.css",
 #endif
 #ifdef USE_WEBSERVER_JS_INCLUDE
-      "/0.js",
+    "/0.js",
 #endif
   };
 
@@ -1901,7 +1905,7 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
     return;
   }
 
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
   if (url == "/events") {
     this->events_.add_new_client(this, request);
     return;

esphome/components/web_server/web_server.h

@@ -81,7 +81,7 @@ enum JsonDetail { DETAIL_ALL, DETAIL_STATE };
   implemented in a more straightforward way for ESP-IDF. Arduino platform will eventually go away and this workaround
   can be forgotten.
 */
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
 using message_generator_t = std::string(WebServer *, void *);
 
 class DeferredUpdateEventSourceList;
@@ -164,7 +164,7 @@ class DeferredUpdateEventSourceList : public std::list<DeferredUpdateEventSource
  * can be found under https://esphome.io/web-api/index.html.
  */
 class WebServer : public Controller, public Component, public AsyncWebHandler {
-#ifdef USE_ARDUINO
+#if !defined(USE_ESP32) && defined(USE_ARDUINO)
   friend class DeferredUpdateEventSourceList;
 #endif
 
@@ -559,11 +559,10 @@ class WebServer : public Controller, public Component, public AsyncWebHandler {
   }
 
   web_server_base::WebServerBase *base_;
-#ifdef USE_ARDUINO
-  DeferredUpdateEventSourceList events_;
-#endif
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
   AsyncEventSource events_{"/events", this};
+#elif USE_ARDUINO
+  DeferredUpdateEventSourceList events_;
 #endif
 
 #if USE_WEBSERVER_VERSION == 1

esphome/components/web_server/web_server_v1.cpp

@@ -34,23 +34,23 @@ void WebServer::set_js_url(const char *js_url) { this->js_url_ = js_url; }
 void WebServer::handle_index_request(AsyncWebServerRequest *request) {
   AsyncResponseStream *stream = request->beginResponseStream("text/html");
   const std::string &title = App.get_name();
-  stream->print(F("<!DOCTYPE html><html lang=\"en\"><head><meta charset=UTF-8><meta "
-                  "name=viewport content=\"width=device-width, initial-scale=1,user-scalable=no\"><title>"));
+  stream->print(ESPHOME_F("<!DOCTYPE html><html lang=\"en\"><head><meta charset=UTF-8><meta "
+                          "name=viewport content=\"width=device-width, initial-scale=1,user-scalable=no\"><title>"));
   stream->print(title.c_str());
-  stream->print(F("</title>"));
+  stream->print(ESPHOME_F("</title>"));
 #ifdef USE_WEBSERVER_CSS_INCLUDE
-  stream->print(F("<link rel=\"stylesheet\" href=\"/0.css\">"));
+  stream->print(ESPHOME_F("<link rel=\"stylesheet\" href=\"/0.css\">"));
 #endif
   if (strlen(this->css_url_) > 0) {
-    stream->print(F(R"(<link rel="stylesheet" href=")"));
+    stream->print(ESPHOME_F(R"(<link rel="stylesheet" href=")"));
     stream->print(this->css_url_);
-    stream->print(F("\">"));
+    stream->print(ESPHOME_F("\">"));
   }
-  stream->print(F("</head><body>"));
-  stream->print(F("<article class=\"markdown-body\"><h1>"));
+  stream->print(ESPHOME_F("</head><body>"));
+  stream->print(ESPHOME_F("<article class=\"markdown-body\"><h1>"));
   stream->print(title.c_str());
-  stream->print(F("</h1>"));
-  stream->print(F("<h2>States</h2><table id=\"states\"><thead><tr><th>Name<th>State<th>Actions<tbody>"));
+  stream->print(ESPHOME_F("</h1>"));
+  stream->print(ESPHOME_F("<h2>States</h2><table id=\"states\"><thead><tr><th>Name<th>State<th>Actions<tbody>"));
 
 #ifdef USE_SENSOR
   for (auto *obj : App.get_sensors()) {
@@ -190,26 +190,28 @@ void WebServer::handle_index_request(AsyncWebServerRequest *request) {
   }
 #endif
 
-  stream->print(F("</tbody></table><p>See <a href=\"https://esphome.io/web-api/index.html\">ESPHome Web API</a> for "
-                  "REST API documentation.</p>"));
+  stream->print(
+      ESPHOME_F("</tbody></table><p>See <a href=\"https://esphome.io/web-api/index.html\">ESPHome Web API</a> for "
+                "REST API documentation.</p>"));
 #if defined(USE_WEBSERVER_OTA) && !defined(USE_WEBSERVER_OTA_DISABLED)
   // Show OTA form only if web_server OTA is not explicitly disabled
   // Note: USE_WEBSERVER_OTA_DISABLED only affects web_server, not captive_portal
-  stream->print(F("<h2>OTA Update</h2><form method=\"POST\" action=\"/update\" enctype=\"multipart/form-data\"><input "
-                  "type=\"file\" name=\"update\"><input type=\"submit\" value=\"Update\"></form>"));
+  stream->print(
+      ESPHOME_F("<h2>OTA Update</h2><form method=\"POST\" action=\"/update\" enctype=\"multipart/form-data\"><input "
+                "type=\"file\" name=\"update\"><input type=\"submit\" value=\"Update\"></form>"));
 #endif
-  stream->print(F("<h2>Debug Log</h2><pre id=\"log\"></pre>"));
+  stream->print(ESPHOME_F("<h2>Debug Log</h2><pre id=\"log\"></pre>"));
 #ifdef USE_WEBSERVER_JS_INCLUDE
   if (this->js_include_ != nullptr) {
-    stream->print(F("<script type=\"module\" src=\"/0.js\"></script>"));
+    stream->print(ESPHOME_F("<script type=\"module\" src=\"/0.js\"></script>"));
   }
 #endif
   if (strlen(this->js_url_) > 0) {
-    stream->print(F("<script src=\""));
+    stream->print(ESPHOME_F("<script src=\""));
     stream->print(this->js_url_);
-    stream->print(F("\"></script>"));
+    stream->print(ESPHOME_F("\"></script>"));
   }
-  stream->print(F("</article></body></html>"));
+  stream->print(ESPHOME_F("</article></body></html>"));
   request->send(stream);
 }
 

esphome/components/web_server_base/__init__.py

@@ -9,10 +9,10 @@ DEPENDENCIES = ["network"]
 
 
 def AUTO_LOAD():
+    if CORE.is_esp32:
+        return ["web_server_idf"]
     if CORE.using_arduino:
         return ["async_tcp"]
-    if CORE.using_esp_idf:
-        return ["web_server_idf"]
     return []
 
 
@@ -33,6 +33,9 @@ async def to_code(config):
     await cg.register_component(var, config)
     cg.add(cg.RawExpression(f"{web_server_base_ns}::global_web_server_base = {var}"))
 
+    if CORE.is_esp32:
+        return
+
     if CORE.using_arduino:
         if CORE.is_esp32:
             cg.add_library("WiFi", None)

esphome/components/web_server_base/web_server_base.h

@@ -7,11 +7,31 @@
 
 #include "esphome/core/component.h"
 
-#ifdef USE_ARDUINO
-#include <ESPAsyncWebServer.h>
-#elif USE_ESP_IDF
+// Platform-agnostic macros for web server components
+// On ESP32 (both Arduino and IDF): Use plain strings (no PROGMEM)
+// On ESP8266: Use Arduino's F() macro for PROGMEM strings
+#ifdef USE_ESP32
+#define ESPHOME_F(string_literal) (string_literal)
+#define ESPHOME_PGM_P const char *
+#define ESPHOME_strncpy_P strncpy
+#else
+// ESP8266 uses Arduino macros
+#define ESPHOME_F(string_literal) F(string_literal)
+#define ESPHOME_PGM_P PGM_P
+#define ESPHOME_strncpy_P strncpy_P
+#endif
+
+#if USE_ESP32
 #include "esphome/core/hal.h"
 #include "esphome/components/web_server_idf/web_server_idf.h"
+#else
+#include <ESPAsyncWebServer.h>
+#endif
+
+#if USE_ESP32
+using PlatformString = std::string;
+#elif USE_ARDUINO
+using PlatformString = String;
 #endif
 
 namespace esphome {
@@ -28,8 +48,8 @@ class MiddlewareHandler : public AsyncWebHandler {
 
   bool canHandle(AsyncWebServerRequest *request) const override { return next_->canHandle(request); }
   void handleRequest(AsyncWebServerRequest *request) override { next_->handleRequest(request); }
-  void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len,
-                    bool final) override {
+  void handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index, uint8_t *data,
+                    size_t len, bool final) override {
     next_->handleUpload(request, filename, index, data, len, final);
   }
   void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override {
@@ -65,8 +85,8 @@ class AuthMiddlewareHandler : public MiddlewareHandler {
       return;
     MiddlewareHandler::handleRequest(request);
   }
-  void handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index, uint8_t *data, size_t len,
-                    bool final) override {
+  void handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index, uint8_t *data,
+                    size_t len, bool final) override {
     if (!check_auth(request))
       return;
     MiddlewareHandler::handleUpload(request, filename, index, data, len, final);

esphome/components/web_server_idf/__init__.py

@@ -5,7 +5,7 @@ CODEOWNERS = ["@dentra"]
 
 CONFIG_SCHEMA = cv.All(
     cv.Schema({}),
-    cv.only_with_esp_idf,
+    cv.only_on_esp32,
 )
 
 

esphome/components/web_server_idf/multipart.cpp

@@ -1,5 +1,5 @@
 #include "esphome/core/defines.h"
-#if defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+#if defined(USE_ESP32) && defined(USE_WEBSERVER_OTA)
 #include "multipart.h"
 #include "utils.h"
 #include "esphome/core/log.h"
@@ -251,4 +251,4 @@ std::string str_trim(const std::string &str) {
 
 }  // namespace web_server_idf
 }  // namespace esphome
-#endif  // defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+#endif  // defined(USE_ESP32) && defined(USE_WEBSERVER_OTA)

esphome/components/web_server_idf/multipart.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "esphome/core/defines.h"
-#if defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+#if defined(USE_ESP32) && defined(USE_WEBSERVER_OTA)
 
 #include <cctype>
 #include <cstring>
@@ -83,4 +83,4 @@ std::string str_trim(const std::string &str);
 
 }  // namespace web_server_idf
 }  // namespace esphome
-#endif  // defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+#endif  // defined(USE_ESP32) && defined(USE_WEBSERVER_OTA)

esphome/components/web_server_idf/utils.cpp

@@ -1,4 +1,4 @@
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 #include <memory>
 #include <cstring>
 #include <cctype>
@@ -122,4 +122,4 @@ const char *stristr(const char *haystack, const char *needle) {
 
 }  // namespace web_server_idf
 }  // namespace esphome
-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32

esphome/components/web_server_idf/utils.h

@@ -1,5 +1,5 @@
 #pragma once
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include <esp_http_server.h>
 #include <string>
@@ -24,4 +24,4 @@ const char *stristr(const char *haystack, const char *needle);
 
 }  // namespace web_server_idf
 }  // namespace esphome
-#endif  // USE_ESP_IDF
+#endif  // USE_ESP32

esphome/components/web_server_idf/web_server_idf.cpp

@@ -1,4 +1,4 @@
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include <cstdarg>
 #include <memory>
@@ -25,6 +25,10 @@
 #include "esphome/components/web_server/list_entities.h"
 #endif  // USE_WEBSERVER
 
+// Include socket headers after Arduino headers to avoid IPADDR_NONE/INADDR_NONE macro conflicts
+#include <cerrno>
+#include <sys/socket.h>
+
 namespace esphome {
 namespace web_server_idf {
 
@@ -46,6 +50,28 @@ DefaultHeaders default_headers_instance;
 
 DefaultHeaders &DefaultHeaders::Instance() { return default_headers_instance; }
 
+namespace {
+// Non-blocking send function to prevent watchdog timeouts when TCP buffers are full
+int nonblocking_send(httpd_handle_t hd, int sockfd, const char *buf, size_t buf_len, int flags) {
+  if (buf == nullptr) {
+    return HTTPD_SOCK_ERR_INVALID;
+  }
+
+  // Use MSG_DONTWAIT to prevent blocking when TCP send buffer is full
+  int ret = send(sockfd, buf, buf_len, flags | MSG_DONTWAIT);
+  if (ret < 0) {
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      // Buffer full - retry later
+      return HTTPD_SOCK_ERR_TIMEOUT;
+    }
+    // Real error
+    ESP_LOGD(TAG, "send error: errno %d", errno);
+    return HTTPD_SOCK_ERR_FAIL;
+  }
+  return ret;
+}
+}  // namespace
+
 void AsyncWebServer::end() {
   if (this->server_) {
     httpd_stop(this->server_);
@@ -164,8 +190,8 @@ esp_err_t AsyncWebServer::request_handler_(AsyncWebServerRequest *request) const
 
 AsyncWebServerRequest::~AsyncWebServerRequest() {
   delete this->rsp_;
-  for (const auto &pair : this->params_) {
-    delete pair.second;  // NOLINT(cppcoreguidelines-owning-memory)
+  for (auto *param : this->params_) {
+    delete param;  // NOLINT(cppcoreguidelines-owning-memory)
   }
 }
 
@@ -205,10 +231,22 @@ void AsyncWebServerRequest::redirect(const std::string &url) {
 }
 
 void AsyncWebServerRequest::init_response_(AsyncWebServerResponse *rsp, int code, const char *content_type) {
-  httpd_resp_set_status(*this, code == 200   ? HTTPD_200
-                               : code == 404 ? HTTPD_404
-                               : code == 409 ? HTTPD_409
-                                             : to_string(code).c_str());
+  // Set status code - use constants for common codes to avoid string allocation
+  const char *status = nullptr;
+  switch (code) {
+    case 200:
+      status = HTTPD_200;
+      break;
+    case 404:
+      status = HTTPD_404;
+      break;
+    case 409:
+      status = HTTPD_409;
+      break;
+    default:
+      break;
+  }
+  httpd_resp_set_status(*this, status == nullptr ? to_string(code).c_str() : status);
 
   if (content_type && *content_type) {
     httpd_resp_set_type(*this, content_type);
@@ -265,11 +303,14 @@ void AsyncWebServerRequest::requestAuthentication(const char *realm) const {
 #endif
 
 AsyncWebParameter *AsyncWebServerRequest::getParam(const std::string &name) {
-  auto find = this->params_.find(name);
-  if (find != this->params_.end()) {
-    return find->second;
+  // Check cache first - only successful lookups are cached
+  for (auto *param : this->params_) {
+    if (param->name() == name) {
+      return param;
+    }
   }
 
+  // Look up value from query strings
   optional<std::string> val = query_key_value(this->post_query_, name);
   if (!val.has_value()) {
     auto url_query = request_get_url_query(*this);
@@ -278,11 +319,14 @@ AsyncWebParameter *AsyncWebServerRequest::getParam(const std::string &name) {
     }
   }
 
-  AsyncWebParameter *param = nullptr;
-  if (val.has_value()) {
-    param = new AsyncWebParameter(val.value());  // NOLINT(cppcoreguidelines-owning-memory)
+  // Don't cache misses to prevent memory exhaustion from malicious requests
+  // with thousands of non-existent parameter lookups
+  if (!val.has_value()) {
+    return nullptr;
   }
-  this->params_.insert({name, param});
+
+  auto *param = new AsyncWebParameter(name, val.value());  // NOLINT(cppcoreguidelines-owning-memory)
+  this->params_.push_back(param);
   return param;
 }
 
@@ -384,6 +428,9 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
   this->hd_ = req->handle;
   this->fd_.store(httpd_req_to_sockfd(req));
 
+  // Use non-blocking send to prevent watchdog timeouts when TCP buffers are full
+  httpd_sess_set_send_override(this->hd_, this->fd_.load(), nonblocking_send);
+
   // Configure reconnect timeout and send config
   // this should always go through since the tcp send buffer is empty on connect
   std::string message = ws->get_config_json();
@@ -459,15 +506,45 @@ void AsyncEventSourceResponse::process_buffer_() {
     return;
   }
 
-  int bytes_sent = httpd_socket_send(this->hd_, this->fd_.load(), event_buffer_.c_str() + event_bytes_sent_,
-                                     event_buffer_.size() - event_bytes_sent_, 0);
-  if (bytes_sent == HTTPD_SOCK_ERR_TIMEOUT || bytes_sent == HTTPD_SOCK_ERR_FAIL) {
-    // Socket error - just return, the connection will be closed by httpd
-    // and our destroy callback will be called
+  size_t remaining = event_buffer_.size() - event_bytes_sent_;
+  int bytes_sent =
+      httpd_socket_send(this->hd_, this->fd_.load(), event_buffer_.c_str() + event_bytes_sent_, remaining, 0);
+  if (bytes_sent == HTTPD_SOCK_ERR_TIMEOUT) {
+    // EAGAIN/EWOULDBLOCK - socket buffer full, try again later
+    // NOTE: Similar logic exists in web_server/web_server.cpp in DeferredUpdateEventSource::process_deferred_queue_()
+    // The implementations differ due to platform-specific APIs (HTTPD_SOCK_ERR_TIMEOUT vs DISCARDED, fd_.store(0) vs
+    // close()), but the failure counting and timeout logic should be kept in sync. If you change this logic, also
+    // update the Arduino implementation.
+    this->consecutive_send_failures_++;
+    if (this->consecutive_send_failures_ >= MAX_CONSECUTIVE_SEND_FAILURES) {
+      // Too many failures, connection is likely dead
+      ESP_LOGW(TAG, "Closing stuck EventSource connection after %" PRIu16 " failed sends",
+               this->consecutive_send_failures_);
+      this->fd_.store(0);  // Mark for cleanup
+      this->deferred_queue_.clear();
+    }
     return;
   }
+  if (bytes_sent == HTTPD_SOCK_ERR_FAIL) {
+    // Real socket error - connection will be closed by httpd and destroy callback will be called
+    return;
+  }
+  if (bytes_sent <= 0) {
+    // Unexpected error or zero bytes sent
+    ESP_LOGW(TAG, "Unexpected send result: %d", bytes_sent);
+    return;
+  }
+
+  // Successful send - reset failure counter
+  this->consecutive_send_failures_ = 0;
   event_bytes_sent_ += bytes_sent;
 
+  // Log partial sends for debugging
+  if (event_bytes_sent_ < event_buffer_.size()) {
+    ESP_LOGV(TAG, "Partial send: %d/%zu bytes (total: %zu/%zu)", bytes_sent, remaining, event_bytes_sent_,
+             event_buffer_.size());
+  }
+
   if (event_bytes_sent_ == event_buffer_.size()) {
     event_buffer_.resize(0);
     event_bytes_sent_ = 0;
@@ -670,4 +747,4 @@ esp_err_t AsyncWebServer::handle_multipart_upload_(httpd_req_t *r, const char *c
 }  // namespace web_server_idf
 }  // namespace esphome
 
-#endif  // !defined(USE_ESP_IDF)
+#endif  // !defined(USE_ESP32)

esphome/components/web_server_idf/web_server_idf.h

@@ -1,5 +1,5 @@
 #pragma once
-#ifdef USE_ESP_IDF
+#ifdef USE_ESP32
 
 #include "esphome/core/defines.h"
 #include <esp_http_server.h>
@@ -22,18 +22,14 @@ class ListEntitiesIterator;
 #endif
 namespace web_server_idf {
 
-#define F(string_literal) (string_literal)
-#define PGM_P const char *
-#define strncpy_P strncpy
-
-using String = std::string;
-
 class AsyncWebParameter {
  public:
-  AsyncWebParameter(std::string value) : value_(std::move(value)) {}
+  AsyncWebParameter(std::string name, std::string value) : name_(std::move(name)), value_(std::move(value)) {}
+  const std::string &name() const { return this->name_; }
   const std::string &value() const { return this->value_; }
 
  protected:
+  std::string name_;
   std::string value_;
 };
 
@@ -174,7 +170,10 @@ class AsyncWebServerRequest {
  protected:
   httpd_req_t *req_;
   AsyncWebServerResponse *rsp_{};
-  std::map<std::string, AsyncWebParameter *> params_;
+  // Use vector instead of map/unordered_map: most requests have 0-3 params, so linear search
+  // is faster than tree/hash overhead. AsyncWebParameter stores both name and value to avoid
+  // duplicate storage. Only successful lookups are cached to prevent memory exhaustion attacks.
+  std::vector<AsyncWebParameter *> params_;
   std::string post_query_;
   AsyncWebServerRequest(httpd_req_t *req) : req_(req) {}
   AsyncWebServerRequest(httpd_req_t *req, std::string post_query) : req_(req), post_query_(std::move(post_query)) {}
@@ -283,6 +282,8 @@ class AsyncEventSourceResponse {
   std::unique_ptr<esphome::web_server::ListEntitiesIterator> entities_iterator_;
   std::string event_buffer_{""};
   size_t event_bytes_sent_;
+  uint16_t consecutive_send_failures_{0};
+  static constexpr uint16_t MAX_CONSECUTIVE_SEND_FAILURES = 2500;  // ~20 seconds at 125Hz loop rate
 };
 
 using AsyncEventSourceClient = AsyncEventSourceResponse;
@@ -341,4 +342,4 @@ class DefaultHeaders {
 
 using namespace esphome::web_server_idf;  // NOLINT(google-global-names-in-headers)
 
-#endif  // !defined(USE_ESP_IDF)
+#endif  // !defined(USE_ESP32)

esphome/components/wifi/wifi_component.cpp

@@ -1,7 +1,6 @@
 #include "wifi_component.h"
 #ifdef USE_WIFI
 #include <cinttypes>
-#include <map>
 
 #ifdef USE_ESP32
 #if (ESP_IDF_VERSION_MAJOR >= 5 && ESP_IDF_VERSION_MINOR >= 1)
@@ -42,6 +41,25 @@ namespace wifi {
 
 static const char *const TAG = "wifi";
 
+#if defined(USE_ESP32) && defined(USE_WIFI_WPA2_EAP) && ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+static const char *eap_phase2_to_str(esp_eap_ttls_phase2_types type) {
+  switch (type) {
+    case ESP_EAP_TTLS_PHASE2_PAP:
+      return "pap";
+    case ESP_EAP_TTLS_PHASE2_CHAP:
+      return "chap";
+    case ESP_EAP_TTLS_PHASE2_MSCHAP:
+      return "mschap";
+    case ESP_EAP_TTLS_PHASE2_MSCHAPV2:
+      return "mschapv2";
+    case ESP_EAP_TTLS_PHASE2_EAP:
+      return "eap";
+    default:
+      return "unknown";
+  }
+}
+#endif
+
 float WiFiComponent::get_setup_priority() const { return setup_priority::WIFI; }
 
 void WiFiComponent::setup() {
@@ -344,15 +362,8 @@ void WiFiComponent::start_connecting(const WiFiAP &ap, bool two) {
     ESP_LOGV(TAG, "    Identity: " LOG_SECRET("'%s'"), eap_config.identity.c_str());
     ESP_LOGV(TAG, "    Username: " LOG_SECRET("'%s'"), eap_config.username.c_str());
     ESP_LOGV(TAG, "    Password: " LOG_SECRET("'%s'"), eap_config.password.c_str());
-#ifdef USE_ESP32
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-    std::map<esp_eap_ttls_phase2_types, std::string> phase2types = {{ESP_EAP_TTLS_PHASE2_PAP, "pap"},
-                                                                    {ESP_EAP_TTLS_PHASE2_CHAP, "chap"},
-                                                                    {ESP_EAP_TTLS_PHASE2_MSCHAP, "mschap"},
-                                                                    {ESP_EAP_TTLS_PHASE2_MSCHAPV2, "mschapv2"},
-                                                                    {ESP_EAP_TTLS_PHASE2_EAP, "eap"}};
-    ESP_LOGV(TAG, "    TTLS Phase 2: " LOG_SECRET("'%s'"), phase2types[eap_config.ttls_phase_2].c_str());
-#endif
+#if defined(USE_ESP32) && ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+    ESP_LOGV(TAG, "    TTLS Phase 2: " LOG_SECRET("'%s'"), eap_phase2_to_str(eap_config.ttls_phase_2));
 #endif
     bool ca_cert_present = eap_config.ca_cert != nullptr && strlen(eap_config.ca_cert);
     bool client_cert_present = eap_config.client_cert != nullptr && strlen(eap_config.client_cert);

esphome/const.py

@@ -542,6 +542,7 @@ CONF_MANUAL_IP = "manual_ip"
 CONF_MANUFACTURER_ID = "manufacturer_id"
 CONF_MASK_DISTURBER = "mask_disturber"
 CONF_MAX_BRIGHTNESS = "max_brightness"
+CONF_MAX_CONNECTIONS = "max_connections"
 CONF_MAX_COOLING_RUN_TIME = "max_cooling_run_time"
 CONF_MAX_CURRENT = "max_current"
 CONF_MAX_DURATION = "max_duration"
@@ -1169,7 +1170,7 @@ UNIT_KILOMETER = "km"
 UNIT_KILOMETER_PER_HOUR = "km/h"
 UNIT_KILOVOLT_AMPS = "kVA"
 UNIT_KILOVOLT_AMPS_HOURS = "kVAh"
-UNIT_KILOVOLT_AMPS_REACTIVE = "kVAR"
+UNIT_KILOVOLT_AMPS_REACTIVE = "kvar"
 UNIT_KILOVOLT_AMPS_REACTIVE_HOURS = "kvarh"
 UNIT_KILOWATT = "kW"
 UNIT_KILOWATT_HOURS = "kWh"

esphome/core/__init__.py

@@ -703,6 +703,15 @@ class EsphomeCore:
     def relative_piolibdeps_path(self, *path: str | Path) -> Path:
         return self.relative_build_path(".piolibdeps", *path)
 
+    @property
+    def platformio_cache_dir(self) -> str:
+        """Get the PlatformIO cache directory path."""
+        # Check if running in Docker/HA addon with custom cache dir
+        if (cache_dir := os.environ.get("PLATFORMIO_CACHE_DIR")) and cache_dir.strip():
+            return cache_dir
+        # Default PlatformIO cache location
+        return os.path.expanduser("~/.platformio/.cache")
+
     @property
     def firmware_bin(self) -> Path:
         if self.is_libretiny:

esphome/core/defines.h

@@ -48,6 +48,7 @@
 #define USE_LIGHT
 #define USE_LOCK
 #define USE_LOGGER
+#define USE_LOGGER_RUNTIME_TAG_LEVELS
 #define USE_LVGL
 #define USE_LVGL_ANIMIMG
 #define USE_LVGL_ARC
@@ -82,6 +83,7 @@
 #define USE_LVGL_TILEVIEW
 #define USE_LVGL_TOUCHSCREEN
 #define USE_MDNS
+#define MDNS_SERVICE_COUNT 3
 #define USE_MEDIA_PLAYER
 #define USE_NEXTION_TFT_UPLOAD
 #define USE_NUMBER
@@ -115,6 +117,7 @@
 #define USE_API_NOISE
 #define USE_API_PLAINTEXT
 #define USE_API_SERVICES
+#define API_MAX_SEND_QUEUE 8
 #define USE_MD5
 #define USE_SHA256
 #define USE_MQTT
@@ -156,6 +159,7 @@
 #define BLUETOOTH_PROXY_ADVERTISEMENT_BATCH_SIZE 16
 #define USE_CAPTIVE_PORTAL
 #define USE_ESP32_BLE
+#define USE_ESP32_BLE_MAX_CONNECTIONS 3
 #define USE_ESP32_BLE_CLIENT
 #define USE_ESP32_BLE_DEVICE
 #define USE_ESP32_BLE_SERVER

esphome/core/hash_base.h

@@ -39,7 +39,7 @@ class HashBase {
 
   /// Compare the hash against a provided hex-encoded hash
   bool equals_hex(const char *expected) {
-    uint8_t parsed[this->get_size()];
+    uint8_t parsed[32];  // Fixed size for max hash (SHA256 = 32 bytes)
     if (!parse_hex(expected, parsed, this->get_size())) {
       return false;
     }

esphome/core/helpers.cpp

@@ -390,10 +390,8 @@ int8_t step_to_accuracy_decimals(float step) {
   return str.length() - dot_pos - 1;
 }
 
-// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
-static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                            "abcdefghijklmnopqrstuvwxyz"
-                                            "0123456789+/";
+// Store BASE64 characters as array - automatically placed in flash/ROM on embedded platforms
+static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 // Helper function to find the index of a base64 character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.
@@ -403,8 +401,8 @@ static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 // stops processing at the first invalid character due to the is_base64() check in its
 // while loop condition, making this edge case harmless in practice.
 static inline uint8_t base64_find_char(char c) {
-  const char *pos = strchr(BASE64_CHARS, c);
-  return pos ? (pos - BASE64_CHARS) : 0;
+  const void *ptr = memchr(BASE64_CHARS, c, sizeof(BASE64_CHARS));
+  return ptr ? (static_cast<const char *>(ptr) - BASE64_CHARS) : 0;
 }
 
 static inline bool is_base64(char c) { return (isalnum(c) || (c == '+') || (c == '/')); }

esphome/core/helpers.h

@@ -133,6 +133,9 @@ template<typename T, size_t N> class StaticVector {
   size_t size() const { return count_; }
   bool empty() const { return count_ == 0; }
 
+  // Direct access to size counter for efficient in-place construction
+  size_t &count() { return count_; }
+
   T &operator[](size_t i) { return data_[i]; }
   const T &operator[](size_t i) const { return data_[i]; }
 

esphome/platformio_api.py

@@ -5,6 +5,7 @@ import os
 from pathlib import Path
 import re
 import subprocess
+from typing import Any
 
 from esphome.const import CONF_COMPILE_PROCESS_LIMIT, CONF_ESPHOME, KEY_CORE
 from esphome.core import CORE, EsphomeError
@@ -111,7 +112,16 @@ def run_compile(config, verbose):
     args = []
     if CONF_COMPILE_PROCESS_LIMIT in config[CONF_ESPHOME]:
         args += [f"-j{config[CONF_ESPHOME][CONF_COMPILE_PROCESS_LIMIT]}"]
-    return run_platformio_cli_run(config, verbose, *args)
+    result = run_platformio_cli_run(config, verbose, *args)
+
+    # Run memory analysis if enabled
+    if config.get(CONF_ESPHOME, {}).get("analyze_memory", False):
+        try:
+            analyze_memory_usage(config)
+        except Exception as e:
+            _LOGGER.warning("Failed to analyze memory usage: %s", e)
+
+    return result
 
 
 def _run_idedata(config):
@@ -340,3 +350,93 @@ class IDEData:
             return f"{self.cc_path[:-7]}addr2line.exe"
 
         return f"{self.cc_path[:-3]}addr2line"
+
+    @property
+    def objdump_path(self) -> str:
+        # replace gcc at end with objdump
+
+        # Windows
+        if self.cc_path.endswith(".exe"):
+            return f"{self.cc_path[:-7]}objdump.exe"
+
+        return f"{self.cc_path[:-3]}objdump"
+
+    @property
+    def readelf_path(self) -> str:
+        # replace gcc at end with readelf
+
+        # Windows
+        if self.cc_path.endswith(".exe"):
+            return f"{self.cc_path[:-7]}readelf.exe"
+
+        return f"{self.cc_path[:-3]}readelf"
+
+
+def analyze_memory_usage(config: dict[str, Any]) -> None:
+    """Analyze memory usage by component after compilation."""
+    # Lazy import to avoid overhead when not needed
+    from esphome.analyze_memory import MemoryAnalyzer
+
+    idedata = get_idedata(config)
+
+    # Get paths to tools
+    elf_path = idedata.firmware_elf_path
+    objdump_path = idedata.objdump_path
+    readelf_path = idedata.readelf_path
+
+    # Debug logging
+    _LOGGER.debug("ELF path from idedata: %s", elf_path)
+
+    # Check if file exists
+    if not Path(elf_path).exists():
+        # Try alternate path
+        alt_path = Path(CORE.relative_build_path(".pioenvs", CORE.name, "firmware.elf"))
+        if alt_path.exists():
+            elf_path = str(alt_path)
+            _LOGGER.debug("Using alternate ELF path: %s", elf_path)
+        else:
+            _LOGGER.warning("ELF file not found at %s or %s", elf_path, alt_path)
+            return
+
+    # Extract external components from config
+    external_components = set()
+
+    # Get the list of built-in ESPHome components
+    from esphome.analyze_memory import get_esphome_components
+
+    builtin_components = get_esphome_components()
+
+    # Special non-component keys that appear in configs
+    NON_COMPONENT_KEYS = {
+        CONF_ESPHOME,
+        "substitutions",
+        "packages",
+        "globals",
+        "<<",
+    }
+
+    # Check all top-level keys in config
+    for key in config:
+        if key not in builtin_components and key not in NON_COMPONENT_KEYS:
+            # This is an external component
+            external_components.add(key)
+
+    _LOGGER.debug("Detected external components: %s", external_components)
+
+    # Create analyzer and run analysis
+    analyzer = MemoryAnalyzer(elf_path, objdump_path, readelf_path, external_components)
+    analyzer.analyze()
+
+    # Generate and print report
+    report = analyzer.generate_report()
+    _LOGGER.info("\n%s", report)
+
+    # Optionally save to file
+    if config.get(CONF_ESPHOME, {}).get("memory_report_file"):
+        report_file = Path(config[CONF_ESPHOME]["memory_report_file"])
+        if report_file.suffix == ".json":
+            report_file.write_text(analyzer.to_json())
+            _LOGGER.info("Memory report saved to %s", report_file)
+        else:
+            report_file.write_text(report)
+            _LOGGER.info("Memory report saved to %s", report_file)

platformio.ini

@@ -72,7 +72,6 @@ lib_deps =
     SPI                                                   ; spi (Arduino built-in)
     Wire                                                  ; i2c (Arduino built-int)
     heman/AsyncMqttClient-esphome@1.0.0                   ; mqtt
-    ESP32Async/ESPAsyncWebServer@3.7.8                    ; web_server_base
     fastled/FastLED@3.9.16                                ; fastled_base
     freekode/TM1651@1.0.1                                 ; tm1651
     glmnet/Dsmr@0.7                                       ; dsmr
@@ -107,6 +106,7 @@ lib_deps =
     ESP8266WiFi                           ; wifi (Arduino built-in)
     Update                                ; ota (Arduino built-in)
     ESP32Async/ESPAsyncTCP@2.0.0          ; async_tcp
+    ESP32Async/ESPAsyncWebServer@3.7.8    ; web_server_base
     makuna/NeoPixelBus@2.7.3              ; neopixelbus
     ESP8266HTTPClient                     ; http_request (Arduino built-in)
     ESP8266mDNS                           ; mdns (Arduino built-in)
@@ -129,7 +129,7 @@ platform = https://github.com/pioarduino/platform-espressif32/releases/download/
 platform_packages =
     pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/3.2.1/esp32-3.2.1.zip
 
-framework = arduino
+framework = arduino, espidf  ; Arduino as an ESP-IDF component
 lib_deps =
     ; order matters with lib-deps; some of the libs in common:arduino.lib_deps
     ; don't declare built-in libraries as dependencies, so they have to be declared first
@@ -193,6 +193,7 @@ platform_packages =
 framework = arduino
 lib_deps =
     ${common:arduino.lib_deps}
+    ESP32Async/ESPAsyncWebServer@3.7.8    ; web_server_base
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_RP2040
@@ -207,7 +208,8 @@ platform = libretiny@1.9.1
 framework = arduino
 lib_compat_mode = soft
 lib_deps =
-    droscy/esp_wireguard@0.4.2    ; wireguard
+    ESP32Async/ESPAsyncWebServer@3.7.8    ; web_server_base
+    droscy/esp_wireguard@0.4.2            ; wireguard
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_LIBRETINY
@@ -274,6 +276,7 @@ build_unflags =
 [env:esp32-arduino-tidy]
 extends = common:esp32-arduino
 board = esp32dev
+board_build.esp-idf.sdkconfig_path = .temp/sdkconfig-esp32-arduino-tidy
 build_flags =
     ${common:esp32-arduino.build_flags}
     ${flags:clangtidy.build_flags}

requirements_test.txt

@@ -1,6 +1,6 @@
 pylint==3.3.8
 flake8==7.3.0  # also change in .pre-commit-config.yaml when updating
-ruff==0.13.2  # also change in .pre-commit-config.yaml when updating
+ruff==0.13.3  # also change in .pre-commit-config.yaml when updating
 pyupgrade==3.20.0  # also change in .pre-commit-config.yaml when updating
 pre-commit
 

tests/components/esp32_can/test.esp32-c6-idf.yaml

@@ -0,0 +1,89 @@
+esphome:
+  on_boot:
+    then:
+      - canbus.send:
+          # Extended ID explicit
+          canbus_id: esp32_internal_can
+          use_extended_id: true
+          can_id: 0x100
+          data: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
+      - canbus.send:
+          # Standard ID by default
+          canbus_id: esp32_internal_can
+          can_id: 0x100
+          data: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
+      - canbus.send:
+          # Extended ID explicit
+          canbus_id: esp32_internal_can_2
+          use_extended_id: true
+          can_id: 0x100
+          data: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
+      - canbus.send:
+          # Standard ID by default
+          canbus_id: esp32_internal_can_2
+          can_id: 0x100
+          data: [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
+
+canbus:
+  - platform: esp32_can
+    id: esp32_internal_can
+    rx_pin: GPIO8
+    tx_pin: GPIO7
+    can_id: 4
+    bit_rate: 50kbps
+    on_frame:
+      - can_id: 500
+        then:
+          - lambda: |-
+              std::string b(x.begin(), x.end());
+              ESP_LOGD("canbus1", "canid 500 %s", b.c_str() );
+      - can_id: 0b00000000000000000000001000000
+        can_id_mask: 0b11111000000000011111111000000
+        use_extended_id: true
+        then:
+          - lambda: |-
+              auto pdo_id = can_id >> 14;
+              switch (pdo_id)
+              {
+                case 117:
+                  ESP_LOGD("canbus1", "exhaust_fan_duty");
+                  break;
+                case 118:
+                  ESP_LOGD("canbus1", "supply_fan_duty");
+                  break;
+                case 119:
+                  ESP_LOGD("canbus1", "supply_fan_flow");
+                  break;
+                // to be continued...
+              }
+  - platform: esp32_can
+    id: esp32_internal_can_2
+    rx_pin: GPIO10
+    tx_pin: GPIO9
+    can_id: 4
+    bit_rate: 50kbps
+    on_frame:
+      - can_id: 500
+        then:
+          - lambda: |-
+              std::string b(x.begin(), x.end());
+              ESP_LOGD("canbus2", "canid 500 %s", b.c_str() );
+      - can_id: 0b00000000000000000000001000000
+        can_id_mask: 0b11111000000000011111111000000
+        use_extended_id: true
+        then:
+          - lambda: |-
+              auto pdo_id = can_id >> 14;
+              switch (pdo_id)
+              {
+                case 117:
+                  ESP_LOGD("canbus2", "exhaust_fan_duty");
+                  break;
+                case 118:
+                  ESP_LOGD("canbus2", "supply_fan_duty");
+                  break;
+                case 119:
+                  ESP_LOGD("canbus2", "supply_fan_flow");
+                  break;
+                // to be continued...
+              }

tests/components/logger/common-default_uart.yaml

@@ -6,11 +6,16 @@ esphome:
           format: "Warning: Logger level is %d"
           args: [id(logger_id).get_log_level()]
       - logger.set_level: WARN
+      - logger.set_level:
+          level: ERROR
+          tag: mqtt.client
 
 logger:
   id: logger_id
   level: DEBUG
   initial_level: INFO
+  logs:
+    mqtt.component: WARN
 
 select:
   - platform: logger

tests/integration/test_oversized_payloads.py

@@ -15,7 +15,7 @@ async def test_oversized_payload_plaintext(
     run_compiled: RunCompiledFunction,
     api_client_connected_with_disconnect: APIClientConnectedWithDisconnectFactory,
 ) -> None:
-    """Test that oversized payloads (>100KiB) from client cause disconnection without crashing."""
+    """Test that oversized payloads (>2304 bytes) from client cause disconnection without crashing."""
     process_exited = False
     helper_log_found = False
 
@@ -39,8 +39,8 @@ async def test_oversized_payload_plaintext(
             assert device_info is not None
             assert device_info.name == "oversized-plaintext"
 
-            # Create an oversized payload (>100KiB)
-            oversized_data = b"X" * (100 * 1024 + 1)  # 100KiB + 1 byte
+            # Create an oversized payload (>2304 bytes which is our new limit)
+            oversized_data = b"X" * 3000  # ~3KiB, exceeds the 2304 byte limit
 
             # Access the internal connection to send raw data
             frame_helper = client._connection._frame_helper
@@ -132,22 +132,24 @@ async def test_oversized_payload_noise(
     run_compiled: RunCompiledFunction,
     api_client_connected_with_disconnect: APIClientConnectedWithDisconnectFactory,
 ) -> None:
-    """Test that oversized payloads (>100KiB) from client cause disconnection without crashing with noise encryption."""
+    """Test that oversized payloads from client cause disconnection without crashing with noise encryption."""
     noise_key = "N4Yle5YirwZhPiHHsdZLdOA73ndj/84veVaLhTvxCuU="
     process_exited = False
-    cipherstate_failed = False
+    helper_log_found = False
 
     def check_logs(line: str) -> None:
-        nonlocal process_exited, cipherstate_failed
+        nonlocal process_exited, helper_log_found
         # Check for signs that the process exited/crashed
         if "Segmentation fault" in line or "core dumped" in line:
             process_exited = True
-        # Check for the expected warning about decryption failure
+        # Check for HELPER_LOG message about message size exceeding maximum
+        # With our new protection, oversized messages are rejected at frame level
         if (
-            "[W][api.connection" in line
-            and "Reading failed CIPHERSTATE_DECRYPT_FAILED" in line
+            "[VV]" in line
+            and "Bad packet: message size" in line
+            and "exceeds maximum" in line
         ):
-            cipherstate_failed = True
+            helper_log_found = True
 
     async with run_compiled(yaml_config, line_callback=check_logs):
         async with api_client_connected_with_disconnect(noise_psk=noise_key) as (
@@ -159,8 +161,8 @@ async def test_oversized_payload_noise(
             assert device_info is not None
             assert device_info.name == "oversized-noise"
 
-            # Create an oversized payload (>100KiB)
-            oversized_data = b"Y" * (100 * 1024 + 1)  # 100KiB + 1 byte
+            # Create an oversized payload (>2304 bytes which is our new limit)
+            oversized_data = b"Y" * 3000  # ~3KiB, exceeds the 2304 byte limit
 
             # Access the internal connection to send raw data
             frame_helper = client._connection._frame_helper
@@ -175,9 +177,9 @@ async def test_oversized_payload_noise(
 
         # After disconnection, verify process didn't crash
         assert not process_exited, "ESPHome process should not crash"
-        # Verify we saw the expected warning message
-        assert cipherstate_failed, (
-            "Expected to see warning about CIPHERSTATE_DECRYPT_FAILED"
+        # Verify we saw the expected HELPER_LOG message
+        assert helper_log_found, (
+            "Expected to see HELPER_LOG about message size exceeding maximum"
         )
 
         # Try to reconnect to verify the process is still running

tests/unit_tests/test_core.py

@@ -661,3 +661,45 @@ class TestEsphomeCore:
             os.environ.pop("ESPHOME_IS_HA_ADDON", None)
             os.environ.pop("ESPHOME_DATA_DIR", None)
             assert target.data_dir == Path(expected_default)
+
+    def test_platformio_cache_dir_with_env_var(self):
+        """Test platformio_cache_dir when PLATFORMIO_CACHE_DIR env var is set."""
+        target = core.EsphomeCore()
+        test_cache_dir = "/custom/cache/dir"
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": test_cache_dir}):
+            assert target.platformio_cache_dir == test_cache_dir
+
+    def test_platformio_cache_dir_without_env_var(self):
+        """Test platformio_cache_dir defaults to ~/.platformio/.cache."""
+        target = core.EsphomeCore()
+
+        with patch.dict(os.environ, {}, clear=True):
+            # Ensure env var is not set
+            os.environ.pop("PLATFORMIO_CACHE_DIR", None)
+            expected = os.path.expanduser("~/.platformio/.cache")
+            assert target.platformio_cache_dir == expected
+
+    def test_platformio_cache_dir_empty_env_var(self):
+        """Test platformio_cache_dir with empty env var falls back to default."""
+        target = core.EsphomeCore()
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": ""}):
+            expected = os.path.expanduser("~/.platformio/.cache")
+            assert target.platformio_cache_dir == expected
+
+    def test_platformio_cache_dir_whitespace_env_var(self):
+        """Test platformio_cache_dir with whitespace-only env var falls back to default."""
+        target = core.EsphomeCore()
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": "   "}):
+            expected = os.path.expanduser("~/.platformio/.cache")
+            assert target.platformio_cache_dir == expected
+
+    def test_platformio_cache_dir_docker_addon_path(self):
+        """Test platformio_cache_dir in Docker/HA addon environment."""
+        target = core.EsphomeCore()
+        addon_cache = "/data/cache/platformio"
+
+        with patch.dict(os.environ, {"PLATFORMIO_CACHE_DIR": addon_cache}):
+            assert target.platformio_cache_dir == addon_cache

tests/unit_tests/test_writer.py

@@ -355,6 +355,7 @@ def test_clean_build(
     mock_core.relative_pioenvs_path.return_value = pioenvs_dir
     mock_core.relative_piolibdeps_path.return_value = piolibdeps_dir
     mock_core.relative_build_path.return_value = dependencies_lock
+    mock_core.platformio_cache_dir = str(platformio_cache_dir)
 
     # Verify all exist before
     assert pioenvs_dir.exists()