CODEOWNERS

.clang-tidy.hash

@@ -1 +1 @@
-ce05c28e9dc0b12c4f6e7454986ffea5123ac974a949da841be698c535f2083e
+74867fc82764102ce1275ea2bc43e3aeee7619679537c6db61114a33342bb4c7

.github/workflows/ci.yml

@@ -115,7 +115,6 @@ jobs:
         python-version:
           - "3.11"
           - "3.13"
-          - "3.14"
         os:
           - ubuntu-latest
           - macOS-latest

CODEOWNERS

@@ -429,6 +429,7 @@ esphome/components/sen21231/* @shreyaskarnik
 esphome/components/sen5x/* @martgras
 esphome/components/sensirion_common/* @martgras
 esphome/components/sensor/* @esphome/core
+esphome/components/serial_proxy/* @kbx81
 esphome/components/sfa30/* @ghsensdev
 esphome/components/sgp40/* @SenexCrenshaw
 esphome/components/sgp4x/* @martgras @SenexCrenshaw

Doxyfile

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

esphome/analyze_memory/cli.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Callable
 import heapq
-import json
 from operator import itemgetter
 import sys
 from typing import TYPE_CHECKING
@@ -541,28 +540,6 @@ class MemoryAnalyzerCLI(MemoryAnalyzer):
 
         return "\n".join(lines)
 
-    def to_json(self) -> str:
-        """Export analysis results as JSON."""
-        data = {
-            "components": {
-                name: {
-                    "text": mem.text_size,
-                    "rodata": mem.rodata_size,
-                    "data": mem.data_size,
-                    "bss": mem.bss_size,
-                    "flash_total": mem.flash_total,
-                    "ram_total": mem.ram_total,
-                    "symbol_count": mem.symbol_count,
-                }
-                for name, mem in self.components.items()
-            },
-            "totals": {
-                "flash": sum(c.flash_total for c in self.components.values()),
-                "ram": sum(c.ram_total for c in self.components.values()),
-            },
-        }
-        return json.dumps(data, indent=2)
-
     def dump_uncategorized_symbols(self, output_file: str | None = None) -> None:
         """Dump uncategorized symbols for analysis."""
         # Sort by size descending

esphome/analyze_memory/const.py

@@ -256,7 +256,7 @@ SYMBOL_PATTERNS = {
     "ipv6_stack": ["nd6_", "ip6_", "mld6_", "icmp6_", "icmp6_input"],
     # Order matters! More specific categories must come before general ones.
     # mdns must come before bluetooth to avoid "_mdns_disable_pcb" matching "ble_" pattern
-    "mdns_lib": ["mdns", "packet$"],
+    "mdns_lib": ["mdns"],
     # memory_mgmt must come before wifi_stack to catch mmu_hal_* symbols
     "memory_mgmt": [
         "mem_",
@@ -794,6 +794,7 @@ SYMBOL_PATTERNS = {
         "s_dp",
         "s_ni",
         "s_reg_dump",
+        "packet$",
         "d_mult_table",
         "K",
         "fcstab",

esphome/codegen.py

@@ -11,7 +11,6 @@
 from esphome.cpp_generator import (  # noqa: F401
     ArrayInitializer,
     Expression,
-    FlashStringLiteral,
     LineComment,
     LogStringLiteral,
     MockObj,

esphome/components/api/__init__.py

@@ -524,24 +524,24 @@ async def homeassistant_service_to_code(
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, False)
-    templ = await cg.templatable(config[CONF_ACTION], args, cg.std_string)
+    templ = await cg.templatable(config[CONF_ACTION], args, None)
     cg.add(var.set_service(templ))
 
     # Initialize FixedVectors with exact sizes from config
     cg.add(var.init_data(len(config[CONF_DATA])))
     for key, value in config[CONF_DATA].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data(key, templ))
 
     cg.add(var.init_data_template(len(config[CONF_DATA_TEMPLATE])))
     for key, value in config[CONF_DATA_TEMPLATE].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data_template(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data_template(key, templ))
 
     cg.add(var.init_variables(len(config[CONF_VARIABLES])))
     for key, value in config[CONF_VARIABLES].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_variable(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_variable(key, templ))
 
     if on_error := config.get(CONF_ON_ERROR):
         cg.add_define("USE_API_HOMEASSISTANT_ACTION_RESPONSES")
@@ -609,24 +609,24 @@ async def homeassistant_event_to_code(config, action_id, template_arg, args):
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    templ = await cg.templatable(config[CONF_EVENT], args, cg.std_string)
+    templ = await cg.templatable(config[CONF_EVENT], args, None)
     cg.add(var.set_service(templ))
 
     # Initialize FixedVectors with exact sizes from config
     cg.add(var.init_data(len(config[CONF_DATA])))
     for key, value in config[CONF_DATA].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data(key, templ))
 
     cg.add(var.init_data_template(len(config[CONF_DATA_TEMPLATE])))
     for key, value in config[CONF_DATA_TEMPLATE].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_data_template(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_data_template(key, templ))
 
     cg.add(var.init_variables(len(config[CONF_VARIABLES])))
     for key, value in config[CONF_VARIABLES].items():
-        templ = await cg.templatable(value, args, cg.std_string)
-        cg.add(var.add_variable(cg.FlashStringLiteral(key), templ))
+        templ = await cg.templatable(value, args, None)
+        cg.add(var.add_variable(key, templ))
 
     return var
 
@@ -649,11 +649,11 @@ async def homeassistant_tag_scanned_to_code(config, action_id, template_arg, arg
     cg.add_define("USE_API_HOMEASSISTANT_SERVICES")
     serv = await cg.get_variable(config[CONF_ID])
     var = cg.new_Pvariable(action_id, template_arg, serv, True)
-    cg.add(var.set_service(cg.FlashStringLiteral("esphome.tag_scanned")))
+    cg.add(var.set_service("esphome.tag_scanned"))
     # Initialize FixedVector with exact size (1 data field)
     cg.add(var.init_data(1))
     templ = await cg.templatable(config[CONF_TAG], args, cg.std_string)
-    cg.add(var.add_data(cg.FlashStringLiteral("tag_id"), templ))
+    cg.add(var.add_data("tag_id", templ))
     return var
 
 

esphome/components/api/api.proto

@@ -69,6 +69,12 @@ service APIConnection {
   rpc zwave_proxy_request(ZWaveProxyRequest) returns (void) {}
 
   rpc infrared_rf_transmit_raw_timings(InfraredRFTransmitRawTimingsRequest) returns (void) {}
+
+  rpc serial_proxy_configure(SerialProxyConfigureRequest) returns (void) {}
+  rpc serial_proxy_write(SerialProxyWriteRequest) returns (void) {}
+  rpc serial_proxy_set_modem_pins(SerialProxySetModemPinsRequest) returns (void) {}
+  rpc serial_proxy_get_modem_pins(SerialProxyGetModemPinsRequest) returns (void) {}
+  rpc serial_proxy_flush(SerialProxyFlushRequest) returns (void) {}
 }
 
 
@@ -260,6 +266,9 @@ message DeviceInfoResponse {
   // Indicates if Z-Wave proxy support is available and features supported
   uint32 zwave_proxy_feature_flags = 23 [(field_ifdef) = "USE_ZWAVE_PROXY"];
   uint32 zwave_home_id = 24 [(field_ifdef) = "USE_ZWAVE_PROXY"];
+
+  // Number of serial proxy instances available on the device
+  uint32 serial_proxy_count = 25 [(field_ifdef) = "USE_SERIAL_PROXY"];
 }
 
 message ListEntitiesRequest {
@@ -2488,3 +2497,87 @@ message InfraredRFReceiveEvent {
   fixed32 key = 2;                                    // Key identifying the receiver instance
   repeated sint32 timings = 3 [packed = true, (container_pointer_no_template) = "std::vector<int32_t>"];  // Raw timings in microseconds (zigzag-encoded): alternating mark/space periods
 }
+
+// ==================== SERIAL PROXY ====================
+
+enum SerialProxyParity {
+  SERIAL_PROXY_PARITY_NONE = 0;
+  SERIAL_PROXY_PARITY_EVEN = 1;
+  SERIAL_PROXY_PARITY_ODD = 2;
+}
+
+// Configure UART parameters for a serial proxy instance
+message SerialProxyConfigureRequest {
+  option (id) = 138;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;          // Instance index (0-based)
+  uint32 baudrate = 2;          // Baud rate in bits per second
+  bool flow_control = 3;        // Enable hardware flow control
+  SerialProxyParity parity = 4; // Parity setting
+  uint32 stop_bits = 5;         // Number of stop bits (1 or 2)
+  uint32 data_size = 6;         // Number of data bits (5-8)
+}
+
+// Data received from a serial device, forwarded to clients
+message SerialProxyDataReceived {
+  option (id) = 139;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SERIAL_PROXY";
+  option (no_delay) = true;
+
+  uint32 instance = 1;          // Instance index (0-based)
+  bytes data = 2;               // Raw data received from the serial device
+}
+
+// Write data to a serial device
+message SerialProxyWriteRequest {
+  option (id) = 140;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+  option (no_delay) = true;
+
+  uint32 instance = 1;          // Instance index (0-based)
+  bytes data = 2;               // Raw data to write to the serial device
+}
+
+// Set modem control pin states (RTS and DTR)
+message SerialProxySetModemPinsRequest {
+  option (id) = 141;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;          // Instance index (0-based)
+  bool rts = 2;                 // Desired RTS pin state
+  bool dtr = 3;                 // Desired DTR pin state
+}
+
+// Request current modem control pin states
+message SerialProxyGetModemPinsRequest {
+  option (id) = 142;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;          // Instance index (0-based)
+}
+
+// Response with current modem control pin states
+message SerialProxyGetModemPinsResponse {
+  option (id) = 143;
+  option (source) = SOURCE_SERVER;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;          // Instance index (0-based)
+  bool rts = 2;                 // Current RTS pin state
+  bool dtr = 3;                 // Current DTR pin state
+}
+
+// Flush the serial port (block until all TX data is sent)
+message SerialProxyFlushRequest {
+  option (id) = 144;
+  option (source) = SOURCE_CLIENT;
+  option (ifdef) = "USE_SERIAL_PROXY";
+
+  uint32 instance = 1;          // Instance index (0-based)
+}

esphome/components/api/api_connection.cpp

@@ -1413,6 +1413,66 @@ void APIConnection::send_infrared_rf_receive_event(const InfraredRFReceiveEvent
 }
 #endif
 
+#ifdef USE_SERIAL_PROXY
+void APIConnection::on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %u out of range (max %u)", msg.instance,
+             static_cast<uint32_t>(proxies.size()));
+    return;
+  }
+  proxies[msg.instance]->configure(msg.baudrate, msg.flow_control, static_cast<uint8_t>(msg.parity), msg.stop_bits,
+                                   msg.data_size);
+}
+
+void APIConnection::on_serial_proxy_write_request(const SerialProxyWriteRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
+    return;
+  }
+  proxies[msg.instance]->write(msg.data, msg.data_len);
+}
+
+void APIConnection::on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
+    return;
+  }
+  proxies[msg.instance]->set_modem_pins(msg.rts, msg.dtr);
+}
+
+void APIConnection::on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
+    return;
+  }
+  bool rts, dtr;
+  proxies[msg.instance]->get_modem_pins(rts, dtr);
+
+  SerialProxyGetModemPinsResponse resp{};
+  resp.instance = msg.instance;
+  resp.rts = rts;
+  resp.dtr = dtr;
+  this->send_message(resp, SerialProxyGetModemPinsResponse::MESSAGE_TYPE);
+}
+
+void APIConnection::on_serial_proxy_flush_request(const SerialProxyFlushRequest &msg) {
+  auto &proxies = App.get_serial_proxies();
+  if (msg.instance >= proxies.size()) {
+    ESP_LOGW(TAG, "Serial proxy instance %u out of range", msg.instance);
+    return;
+  }
+  proxies[msg.instance]->flush_port();
+}
+
+void APIConnection::send_serial_proxy_data(const SerialProxyDataReceived &msg) {
+  this->send_message(msg, SerialProxyDataReceived::MESSAGE_TYPE);
+}
+#endif
+
 #ifdef USE_INFRARED
 uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size) {
   auto *infrared = static_cast<infrared::Infrared *>(entity);
@@ -1627,6 +1687,9 @@ bool APIConnection::send_device_info_response_() {
   resp.zwave_proxy_feature_flags = zwave_proxy::global_zwave_proxy->get_feature_flags();
   resp.zwave_home_id = zwave_proxy::global_zwave_proxy->get_home_id();
 #endif
+#ifdef USE_SERIAL_PROXY
+  resp.serial_proxy_count = App.get_serial_proxies().size();
+#endif
 #ifdef USE_API_NOISE
   resp.api_encryption_supported = true;
 #endif

esphome/components/api/api_connection.h

@@ -182,6 +182,15 @@ class APIConnection final : public APIServerConnectionBase {
   void send_infrared_rf_receive_event(const InfraredRFReceiveEvent &msg);
 #endif
 
+#ifdef USE_SERIAL_PROXY
+  void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &msg) override;
+  void on_serial_proxy_write_request(const SerialProxyWriteRequest &msg) override;
+  void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &msg) override;
+  void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &msg) override;
+  void on_serial_proxy_flush_request(const SerialProxyFlushRequest &msg) override;
+  void send_serial_proxy_data(const SerialProxyDataReceived &msg);
+#endif
+
 #ifdef USE_EVENT
   void send_event(event::Event *event);
 #endif

esphome/components/api/api_pb2.cpp

@@ -119,6 +119,9 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
 #ifdef USE_ZWAVE_PROXY
   buffer.encode_uint32(24, this->zwave_home_id);
 #endif
+#ifdef USE_SERIAL_PROXY
+  buffer.encode_uint32(25, this->serial_proxy_count);
+#endif
 }
 void DeviceInfoResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->name.size());
@@ -174,6 +177,9 @@ void DeviceInfoResponse::calculate_size(ProtoSize &size) const {
 #ifdef USE_ZWAVE_PROXY
   size.add_uint32(2, this->zwave_home_id);
 #endif
+#ifdef USE_SERIAL_PROXY
+  size.add_uint32(2, this->serial_proxy_count);
+#endif
 }
 #ifdef USE_BINARY_SENSOR
 void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
@@ -3440,5 +3446,108 @@ void InfraredRFReceiveEvent::calculate_size(ProtoSize &size) const {
   }
 }
 #endif
+#ifdef USE_SERIAL_PROXY
+bool SerialProxyConfigureRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value.as_uint32();
+      break;
+    case 2:
+      this->baudrate = value.as_uint32();
+      break;
+    case 3:
+      this->flow_control = value.as_bool();
+      break;
+    case 4:
+      this->parity = static_cast<enums::SerialProxyParity>(value.as_uint32());
+      break;
+    case 5:
+      this->stop_bits = value.as_uint32();
+      break;
+    case 6:
+      this->data_size = value.as_uint32();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+void SerialProxyDataReceived::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_uint32(1, this->instance);
+  buffer.encode_bytes(2, this->data_ptr_, this->data_len_);
+}
+void SerialProxyDataReceived::calculate_size(ProtoSize &size) const {
+  size.add_uint32(1, this->instance);
+  size.add_length(1, this->data_len_);
+}
+bool SerialProxyWriteRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value.as_uint32();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+bool SerialProxyWriteRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
+  switch (field_id) {
+    case 2: {
+      this->data = value.data();
+      this->data_len = value.size();
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+bool SerialProxySetModemPinsRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value.as_uint32();
+      break;
+    case 2:
+      this->rts = value.as_bool();
+      break;
+    case 3:
+      this->dtr = value.as_bool();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+bool SerialProxyGetModemPinsRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value.as_uint32();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+void SerialProxyGetModemPinsResponse::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_uint32(1, this->instance);
+  buffer.encode_bool(2, this->rts);
+  buffer.encode_bool(3, this->dtr);
+}
+void SerialProxyGetModemPinsResponse::calculate_size(ProtoSize &size) const {
+  size.add_uint32(1, this->instance);
+  size.add_bool(1, this->rts);
+  size.add_bool(1, this->dtr);
+}
+bool SerialProxyFlushRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
+  switch (field_id) {
+    case 1:
+      this->instance = value.as_uint32();
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2.h

@@ -311,6 +311,13 @@ enum ZWaveProxyRequestType : uint32_t {
   ZWAVE_PROXY_REQUEST_TYPE_HOME_ID_CHANGE = 2,
 };
 #endif
+#ifdef USE_SERIAL_PROXY
+enum SerialProxyParity : uint32_t {
+  SERIAL_PROXY_PARITY_NONE = 0,
+  SERIAL_PROXY_PARITY_EVEN = 1,
+  SERIAL_PROXY_PARITY_ODD = 2,
+};
+#endif
 
 }  // namespace enums
 
@@ -474,7 +481,7 @@ class DeviceInfo final : public ProtoMessage {
 class DeviceInfoResponse final : public ProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 10;
-  static constexpr uint8_t ESTIMATED_SIZE = 255;
+  static constexpr uint16_t ESTIMATED_SIZE = 260;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "device_info_response"; }
 #endif
@@ -526,6 +533,9 @@ class DeviceInfoResponse final : public ProtoMessage {
 #endif
 #ifdef USE_ZWAVE_PROXY
   uint32_t zwave_home_id{0};
+#endif
+#ifdef USE_SERIAL_PROXY
+  uint32_t serial_proxy_count{0};
 #endif
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -3025,5 +3035,132 @@ class InfraredRFReceiveEvent final : public ProtoMessage {
  protected:
 };
 #endif
+#ifdef USE_SERIAL_PROXY
+class SerialProxyConfigureRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 138;
+  static constexpr uint8_t ESTIMATED_SIZE = 20;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_configure_request"; }
+#endif
+  uint32_t instance{0};
+  uint32_t baudrate{0};
+  bool flow_control{false};
+  enums::SerialProxyParity parity{};
+  uint32_t stop_bits{0};
+  uint32_t data_size{0};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SerialProxyDataReceived final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 139;
+  static constexpr uint8_t ESTIMATED_SIZE = 23;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_data_received"; }
+#endif
+  uint32_t instance{0};
+  const uint8_t *data_ptr_{nullptr};
+  size_t data_len_{0};
+  void set_data(const uint8_t *data, size_t len) {
+    this->data_ptr_ = data;
+    this->data_len_ = len;
+  }
+  void encode(ProtoWriteBuffer buffer) const override;
+  void calculate_size(ProtoSize &size) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
+class SerialProxyWriteRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 140;
+  static constexpr uint8_t ESTIMATED_SIZE = 23;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_write_request"; }
+#endif
+  uint32_t instance{0};
+  const uint8_t *data{nullptr};
+  uint16_t data_len{0};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_length(uint32_t field_id, ProtoLengthDelimited value) override;
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SerialProxySetModemPinsRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 141;
+  static constexpr uint8_t ESTIMATED_SIZE = 8;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_set_modem_pins_request"; }
+#endif
+  uint32_t instance{0};
+  bool rts{false};
+  bool dtr{false};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SerialProxyGetModemPinsRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 142;
+  static constexpr uint8_t ESTIMATED_SIZE = 4;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_get_modem_pins_request"; }
+#endif
+  uint32_t instance{0};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+class SerialProxyGetModemPinsResponse final : public ProtoMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 143;
+  static constexpr uint8_t ESTIMATED_SIZE = 8;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_get_modem_pins_response"; }
+#endif
+  uint32_t instance{0};
+  bool rts{false};
+  bool dtr{false};
+  void encode(ProtoWriteBuffer buffer) const override;
+  void calculate_size(ProtoSize &size) const override;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+};
+class SerialProxyFlushRequest final : public ProtoDecodableMessage {
+ public:
+  static constexpr uint8_t MESSAGE_TYPE = 144;
+  static constexpr uint8_t ESTIMATED_SIZE = 4;
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *message_name() const override { return "serial_proxy_flush_request"; }
+#endif
+  uint32_t instance{0};
+#ifdef HAS_PROTO_MESSAGE_DUMP
+  const char *dump_to(DumpBuffer &out) const override;
+#endif
+
+ protected:
+  bool decode_varint(uint32_t field_id, ProtoVarInt value) override;
+};
+#endif
 
 }  // namespace esphome::api

esphome/components/api/api_pb2_dump.cpp

@@ -736,6 +736,20 @@ template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums:
   }
 }
 #endif
+#ifdef USE_SERIAL_PROXY
+template<> const char *proto_enum_to_string<enums::SerialProxyParity>(enums::SerialProxyParity value) {
+  switch (value) {
+    case enums::SERIAL_PROXY_PARITY_NONE:
+      return "SERIAL_PROXY_PARITY_NONE";
+    case enums::SERIAL_PROXY_PARITY_EVEN:
+      return "SERIAL_PROXY_PARITY_EVEN";
+    case enums::SERIAL_PROXY_PARITY_ODD:
+      return "SERIAL_PROXY_PARITY_ODD";
+    default:
+      return "UNKNOWN";
+  }
+}
+#endif
 
 const char *HelloRequest::dump_to(DumpBuffer &out) const {
   MessageDumpHelper helper(out, "HelloRequest");
@@ -845,6 +859,9 @@ const char *DeviceInfoResponse::dump_to(DumpBuffer &out) const {
 #endif
 #ifdef USE_ZWAVE_PROXY
   dump_field(out, "zwave_home_id", this->zwave_home_id);
+#endif
+#ifdef USE_SERIAL_PROXY
+  dump_field(out, "serial_proxy_count", this->serial_proxy_count);
 #endif
   return out.c_str();
 }
@@ -2469,6 +2486,54 @@ const char *InfraredRFReceiveEvent::dump_to(DumpBuffer &out) const {
   return out.c_str();
 }
 #endif
+#ifdef USE_SERIAL_PROXY
+const char *SerialProxyConfigureRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxyConfigureRequest");
+  dump_field(out, "instance", this->instance);
+  dump_field(out, "baudrate", this->baudrate);
+  dump_field(out, "flow_control", this->flow_control);
+  dump_field(out, "parity", static_cast<enums::SerialProxyParity>(this->parity));
+  dump_field(out, "stop_bits", this->stop_bits);
+  dump_field(out, "data_size", this->data_size);
+  return out.c_str();
+}
+const char *SerialProxyDataReceived::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxyDataReceived");
+  dump_field(out, "instance", this->instance);
+  dump_bytes_field(out, "data", this->data_ptr_, this->data_len_);
+  return out.c_str();
+}
+const char *SerialProxyWriteRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxyWriteRequest");
+  dump_field(out, "instance", this->instance);
+  dump_bytes_field(out, "data", this->data, this->data_len);
+  return out.c_str();
+}
+const char *SerialProxySetModemPinsRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxySetModemPinsRequest");
+  dump_field(out, "instance", this->instance);
+  dump_field(out, "rts", this->rts);
+  dump_field(out, "dtr", this->dtr);
+  return out.c_str();
+}
+const char *SerialProxyGetModemPinsRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxyGetModemPinsRequest");
+  dump_field(out, "instance", this->instance);
+  return out.c_str();
+}
+const char *SerialProxyGetModemPinsResponse::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxyGetModemPinsResponse");
+  dump_field(out, "instance", this->instance);
+  dump_field(out, "rts", this->rts);
+  dump_field(out, "dtr", this->dtr);
+  return out.c_str();
+}
+const char *SerialProxyFlushRequest::dump_to(DumpBuffer &out) const {
+  MessageDumpHelper helper(out, "SerialProxyFlushRequest");
+  dump_field(out, "instance", this->instance);
+  return out.c_str();
+}
+#endif
 
 }  // namespace esphome::api
 

esphome/components/api/api_pb2_service.cpp

@@ -634,6 +634,61 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_infrared_rf_transmit_raw_timings_request(msg);
       break;
     }
+#endif
+#ifdef USE_SERIAL_PROXY
+    case SerialProxyConfigureRequest::MESSAGE_TYPE: {
+      SerialProxyConfigureRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_configure_request"), msg);
+#endif
+      this->on_serial_proxy_configure_request(msg);
+      break;
+    }
+#endif
+#ifdef USE_SERIAL_PROXY
+    case SerialProxyWriteRequest::MESSAGE_TYPE: {
+      SerialProxyWriteRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_write_request"), msg);
+#endif
+      this->on_serial_proxy_write_request(msg);
+      break;
+    }
+#endif
+#ifdef USE_SERIAL_PROXY
+    case SerialProxySetModemPinsRequest::MESSAGE_TYPE: {
+      SerialProxySetModemPinsRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_set_modem_pins_request"), msg);
+#endif
+      this->on_serial_proxy_set_modem_pins_request(msg);
+      break;
+    }
+#endif
+#ifdef USE_SERIAL_PROXY
+    case SerialProxyGetModemPinsRequest::MESSAGE_TYPE: {
+      SerialProxyGetModemPinsRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_get_modem_pins_request"), msg);
+#endif
+      this->on_serial_proxy_get_modem_pins_request(msg);
+      break;
+    }
+#endif
+#ifdef USE_SERIAL_PROXY
+    case SerialProxyFlushRequest::MESSAGE_TYPE: {
+      SerialProxyFlushRequest msg;
+      msg.decode(msg_data, msg_size);
+#ifdef HAS_PROTO_MESSAGE_DUMP
+      this->log_receive_message_(LOG_STR("on_serial_proxy_flush_request"), msg);
+#endif
+      this->on_serial_proxy_flush_request(msg);
+      break;
+    }
 #endif
     default:
       break;

esphome/components/api/api_pb2_service.h

@@ -224,6 +224,23 @@ class APIServerConnectionBase : public ProtoService {
   virtual void on_infrared_rf_transmit_raw_timings_request(const InfraredRFTransmitRawTimingsRequest &value){};
 #endif
 
+#ifdef USE_SERIAL_PROXY
+  virtual void on_serial_proxy_configure_request(const SerialProxyConfigureRequest &value){};
+#endif
+
+#ifdef USE_SERIAL_PROXY
+  virtual void on_serial_proxy_write_request(const SerialProxyWriteRequest &value){};
+#endif
+#ifdef USE_SERIAL_PROXY
+  virtual void on_serial_proxy_set_modem_pins_request(const SerialProxySetModemPinsRequest &value){};
+#endif
+#ifdef USE_SERIAL_PROXY
+  virtual void on_serial_proxy_get_modem_pins_request(const SerialProxyGetModemPinsRequest &value){};
+#endif
+
+#ifdef USE_SERIAL_PROXY
+  virtual void on_serial_proxy_flush_request(const SerialProxyFlushRequest &value){};
+#endif
  protected:
   void read_message(uint32_t msg_size, uint32_t msg_type, const uint8_t *msg_data) override;
 };

esphome/components/api/api_server.cpp

@@ -117,7 +117,37 @@ void APIServer::setup() {
 void APIServer::loop() {
   // Accept new clients only if the socket exists and has incoming connections
   if (this->socket_ && this->socket_->ready()) {
-    this->accept_new_connections_();
+    while (true) {
+      struct sockaddr_storage source_addr;
+      socklen_t addr_len = sizeof(source_addr);
+
+      auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
+      if (!sock)
+        break;
+
+      char peername[socket::SOCKADDR_STR_LEN];
+      sock->getpeername_to(peername);
+
+      // Check if we're at the connection limit
+      if (this->clients_.size() >= this->max_connections_) {
+        ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
+        // Immediately close - socket destructor will handle cleanup
+        sock.reset();
+        continue;
+      }
+
+      ESP_LOGD(TAG, "Accept %s", peername);
+
+      auto *conn = new APIConnection(std::move(sock), this);
+      this->clients_.emplace_back(conn);
+      conn->start();
+
+      // First client connected - clear warning and update timestamp
+      if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
+        this->status_clear_warning();
+        this->last_connected_ = App.get_loop_component_start_time();
+      }
+    }
   }
 
   if (this->clients_.empty()) {
@@ -148,84 +178,46 @@ void APIServer::loop() {
   while (client_index < this->clients_.size()) {
     auto &client = this->clients_[client_index];
 
-    if (client->flags_.remove) {
-      // Rare case: handle disconnection (don't increment - swapped element needs processing)
-      this->remove_client_(client_index);
-    } else {
+    if (!client->flags_.remove) {
       // Common case: process active client
       client->loop();
       client_index++;
-    }
-  }
-}
-
-void APIServer::remove_client_(size_t client_index) {
-  auto &client = this->clients_[client_index];
-
-#ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  this->unregister_active_action_calls_for_connection(client.get());
-#endif
-  ESP_LOGV(TAG, "Remove connection %s", client->get_name());
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  // Save client info before closing socket and removal for the trigger
-  char peername_buf[socket::SOCKADDR_STR_LEN];
-  std::string client_name(client->get_name());
-  std::string client_peername(client->get_peername_to(peername_buf));
-#endif
-
-  // Close socket now (was deferred from on_fatal_error to allow getpeername)
-  client->helper_->close();
-
-  // Swap with the last element and pop (avoids expensive vector shifts)
-  if (client_index < this->clients_.size() - 1) {
-    std::swap(this->clients_[client_index], this->clients_.back());
-  }
-  this->clients_.pop_back();
-
-  // Last client disconnected - set warning and start tracking for reboot timeout
-  if (this->clients_.empty() && this->reboot_timeout_ != 0) {
-    this->status_set_warning();
-    this->last_connected_ = App.get_loop_component_start_time();
-  }
-
-#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
-  // Fire trigger after client is removed so api.connected reflects the true state
-  this->client_disconnected_trigger_.trigger(client_name, client_peername);
-#endif
-}
-
-void APIServer::accept_new_connections_() {
-  while (true) {
-    struct sockaddr_storage source_addr;
-    socklen_t addr_len = sizeof(source_addr);
-
-    auto sock = this->socket_->accept_loop_monitored((struct sockaddr *) &source_addr, &addr_len);
-    if (!sock)
-      break;
-
-    char peername[socket::SOCKADDR_STR_LEN];
-    sock->getpeername_to(peername);
-
-    // Check if we're at the connection limit
-    if (this->clients_.size() >= this->max_connections_) {
-      ESP_LOGW(TAG, "Max connections (%d), rejecting %s", this->max_connections_, peername);
-      // Immediately close - socket destructor will handle cleanup
-      sock.reset();
       continue;
     }
 
-    ESP_LOGD(TAG, "Accept %s", peername);
+    // Rare case: handle disconnection
+#ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
+    this->unregister_active_action_calls_for_connection(client.get());
+#endif
+    ESP_LOGV(TAG, "Remove connection %s", client->get_name());
 
-    auto *conn = new APIConnection(std::move(sock), this);
-    this->clients_.emplace_back(conn);
-    conn->start();
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+    // Save client info before closing socket and removal for the trigger
+    char peername_buf[socket::SOCKADDR_STR_LEN];
+    std::string client_name(client->get_name());
+    std::string client_peername(client->get_peername_to(peername_buf));
+#endif
 
-    // First client connected - clear warning and update timestamp
-    if (this->clients_.size() == 1 && this->reboot_timeout_ != 0) {
-      this->status_clear_warning();
+    // Close socket now (was deferred from on_fatal_error to allow getpeername)
+    client->helper_->close();
+
+    // Swap with the last element and pop (avoids expensive vector shifts)
+    if (client_index < this->clients_.size() - 1) {
+      std::swap(this->clients_[client_index], this->clients_.back());
+    }
+    this->clients_.pop_back();
+
+    // Last client disconnected - set warning and start tracking for reboot timeout
+    if (this->clients_.empty() && this->reboot_timeout_ != 0) {
+      this->status_set_warning();
       this->last_connected_ = App.get_loop_component_start_time();
     }
+
+#ifdef USE_API_CLIENT_DISCONNECTED_TRIGGER
+    // Fire trigger after client is removed so api.connected reflects the true state
+    this->client_disconnected_trigger_.trigger(client_name, client_peername);
+#endif
+    // Don't increment client_index since we need to process the swapped element
   }
 }
 
@@ -378,6 +370,17 @@ void APIServer::send_infrared_rf_receive_event([[maybe_unused]] uint32_t device_
 }
 #endif
 
+#ifdef USE_SERIAL_PROXY
+void APIServer::send_serial_proxy_data(uint32_t instance, const uint8_t *data, size_t len) {
+  SerialProxyDataReceived msg{};
+  msg.instance = instance;
+  msg.set_data(data, len);
+
+  for (auto &c : this->clients_)
+    c->send_serial_proxy_data(msg);
+}
+#endif
+
 #ifdef USE_ALARM_CONTROL_PANEL
 API_DISPATCH_UPDATE(alarm_control_panel::AlarmControlPanel, alarm_control_panel)
 #endif

esphome/components/api/api_server.h

@@ -189,6 +189,10 @@ class APIServer : public Component,
   void send_infrared_rf_receive_event(uint32_t device_id, uint32_t key, const std::vector<int32_t> *timings);
 #endif
 
+#ifdef USE_SERIAL_PROXY
+  void send_serial_proxy_data(uint32_t instance, const uint8_t *data, size_t len);
+#endif
+
   bool is_connected(bool state_subscription_only = false) const;
 
 #ifdef USE_API_HOMEASSISTANT_STATES
@@ -234,11 +238,6 @@ class APIServer : public Component,
 #endif
 
  protected:
-  // Accept incoming socket connections. Only called when socket has pending connections.
-  void __attribute__((noinline)) accept_new_connections_();
-  // Remove a disconnected client by index. Swaps with last element and pops.
-  void __attribute__((noinline)) remove_client_(size_t client_index);
-
 #ifdef USE_API_NOISE
   bool update_noise_psk_(const SavedNoisePsk &new_psk, const LogString *save_log_msg, const LogString *fail_log_msg,
                          const psk_t &active_psk, bool make_active);

esphome/components/api/homeassistant_service.h

@@ -128,20 +128,6 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
     this->add_kv_(this->variables_, key, std::forward<V>(value));
   }
 
-#ifdef USE_ESP8266
-  // On ESP8266, ESPHOME_F() returns __FlashStringHelper* (PROGMEM pointer).
-  // Store as const char* — populate_service_map copies from PROGMEM at play() time.
-  template<typename V> void add_data(const __FlashStringHelper *key, V &&value) {
-    this->add_kv_(this->data_, reinterpret_cast<const char *>(key), std::forward<V>(value));
-  }
-  template<typename V> void add_data_template(const __FlashStringHelper *key, V &&value) {
-    this->add_kv_(this->data_template_, reinterpret_cast<const char *>(key), std::forward<V>(value));
-  }
-  template<typename V> void add_variable(const __FlashStringHelper *key, V &&value) {
-    this->add_kv_(this->variables_, reinterpret_cast<const char *>(key), std::forward<V>(value));
-  }
-#endif
-
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
   template<typename T> void set_response_template(T response_template) {
     this->response_template_ = response_template;
@@ -233,31 +219,7 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
                                    Ts... x) {
     dest.init(source.size());
 
-#ifdef USE_ESP8266
-    // On ESP8266, keys may be in PROGMEM (from ESPHOME_F in codegen) and
-    // FLASH_STRING values need copying via _P functions.
-    // Allocate storage for all keys + all values (2 entries per source item).
-    // strlen_P/memcpy_P handle both RAM and PROGMEM pointers safely.
-    value_storage.init(source.size() * 2);
-
-    for (auto &it : source) {
-      auto &kv = dest.emplace_back();
-
-      // Key: copy from possible PROGMEM
-      {
-        size_t key_len = strlen_P(it.key);
-        value_storage.push_back(std::string(key_len, '\0'));
-        memcpy_P(value_storage.back().data(), it.key, key_len);
-        kv.key = StringRef(value_storage.back());
-      }
-
-      // Value: value() handles FLASH_STRING via _P functions internally
-      value_storage.push_back(it.value.value(x...));
-      kv.value = StringRef(value_storage.back());
-    }
-#else
-    // On non-ESP8266, strings are directly readable from flash-mapped memory.
-    // Count non-static strings to allocate exact storage needed.
+    // Count non-static strings to allocate exact storage needed
     size_t lambda_count = 0;
     for (const auto &it : source) {
       if (!it.value.is_static_string()) {
@@ -271,15 +233,14 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
       kv.key = StringRef(it.key);
 
       if (it.value.is_static_string()) {
-        // Static string — pointer directly readable, zero allocation
+        // Static string from YAML - zero allocation
         kv.value = StringRef(it.value.get_static_string());
       } else {
-        // Lambda — evaluate and store result
+        // Lambda evaluation - store result, reference it
         value_storage.push_back(it.value.value(x...));
         kv.value = StringRef(value_storage.back());
       }
     }
-#endif
   }
 
   APIServer *parent_;

esphome/components/api/user_services.h

@@ -264,9 +264,9 @@ template<typename... Ts> class APIRespondAction : public Action<Ts...> {
       // Build and send JSON response
       json::JsonBuilder builder;
       this->json_builder_(x..., builder.root());
-      auto json_buf = builder.serialize();
+      std::string json_str = builder.serialize();
       this->parent_->send_action_response(call_id, success, StringRef(error_message),
-                                          reinterpret_cast<const uint8_t *>(json_buf.data()), json_buf.size());
+                                          reinterpret_cast<const uint8_t *>(json_str.data()), json_str.size());
       return;
     }
 #endif

esphome/components/bedjet/bedjet_hub.cpp

@@ -3,7 +3,6 @@
 #include "bedjet_hub.h"
 #include "bedjet_child.h"
 #include "bedjet_const.h"
-#include "esphome/components/esp32_ble/ble_uuid.h"
 #include "esphome/core/application.h"
 #include <cinttypes>
 

esphome/components/captive_portal/captive_portal.cpp

@@ -47,8 +47,8 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
   request->send(stream);
 }
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
-  const auto &ssid = request->arg("ssid");
-  const auto &psk = request->arg("psk");
+  std::string ssid = request->arg("ssid").c_str();  // NOLINT(readability-redundant-string-cstr)
+  std::string psk = request->arg("psk").c_str();    // NOLINT(readability-redundant-string-cstr)
   ESP_LOGI(TAG,
            "Requested WiFi Settings Change:\n"
            "  SSID='%s'\n"
@@ -56,10 +56,10 @@ void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
            ssid.c_str(), psk.c_str());
 #ifdef USE_ESP8266
   // ESP8266 is single-threaded, call directly
-  wifi::global_wifi_component->save_wifi_sta(ssid.c_str(), psk.c_str());
+  wifi::global_wifi_component->save_wifi_sta(ssid, psk);
 #else
   // Defer save to main loop thread to avoid NVS operations from HTTP thread
-  this->defer([ssid, psk]() { wifi::global_wifi_component->save_wifi_sta(ssid.c_str(), psk.c_str()); });
+  this->defer([ssid, psk]() { wifi::global_wifi_component->save_wifi_sta(ssid, psk); });
 #endif
   request->redirect(ESPHOME_F("/?save"));
 }

esphome/components/display/__init__.py

@@ -63,13 +63,11 @@ def validate_auto_clear(value):
     return cv.boolean(value)
 
 
-def basic_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a basic display schema with configurable default update interval."""
-    return cv.Schema(
-        {
-            cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
-        }
-    ).extend(cv.polling_component_schema(default_update_interval))
+BASIC_DISPLAY_SCHEMA = cv.Schema(
+    {
+        cv.Exclusive(CONF_LAMBDA, CONF_LAMBDA): cv.lambda_,
+    }
+).extend(cv.polling_component_schema("1s"))
 
 
 def _validate_test_card(config):
@@ -83,41 +81,34 @@ def _validate_test_card(config):
     return config
 
 
-def full_display_schema(default_update_interval: str = "1s") -> cv.Schema:
-    """Create a full display schema with configurable default update interval."""
-    schema = basic_display_schema(default_update_interval).extend(
-        {
-            cv.Optional(CONF_ROTATION): validate_rotation,
-            cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
-                cv.ensure_list(
-                    {
-                        cv.GenerateID(): cv.declare_id(DisplayPage),
-                        cv.Required(CONF_LAMBDA): cv.lambda_,
-                    }
-                ),
-                cv.Length(min=1),
-            ),
-            cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+FULL_DISPLAY_SCHEMA = BASIC_DISPLAY_SCHEMA.extend(
+    {
+        cv.Optional(CONF_ROTATION): validate_rotation,
+        cv.Exclusive(CONF_PAGES, CONF_LAMBDA): cv.All(
+            cv.ensure_list(
                 {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        DisplayOnPageChangeTrigger
-                    ),
-                    cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
-                    cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+                    cv.GenerateID(): cv.declare_id(DisplayPage),
+                    cv.Required(CONF_LAMBDA): cv.lambda_,
                 }
             ),
-            cv.Optional(
-                CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
-            ): validate_auto_clear,
-            cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
-        }
-    )
-    schema.add_extra(_validate_test_card)
-    return schema
-
-
-BASIC_DISPLAY_SCHEMA = basic_display_schema("1s")
-FULL_DISPLAY_SCHEMA = full_display_schema("1s")
+            cv.Length(min=1),
+        ),
+        cv.Optional(CONF_ON_PAGE_CHANGE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    DisplayOnPageChangeTrigger
+                ),
+                cv.Optional(CONF_FROM): cv.use_id(DisplayPage),
+                cv.Optional(CONF_TO): cv.use_id(DisplayPage),
+            }
+        ),
+        cv.Optional(
+            CONF_AUTO_CLEAR_ENABLED, default=CONF_UNSPECIFIED
+        ): validate_auto_clear,
+        cv.Optional(CONF_SHOW_TEST_CARD): cv.boolean,
+    }
+)
+FULL_DISPLAY_SCHEMA.add_extra(_validate_test_card)
 
 
 async def setup_display_core_(var, config):

esphome/components/esp32/__init__.py

@@ -645,12 +645,11 @@ def _is_framework_url(source: str) -> bool:
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
 ARDUINO_FRAMEWORK_VERSION_LOOKUP = {
-    "recommended": cv.Version(3, 3, 7),
-    "latest": cv.Version(3, 3, 7),
-    "dev": cv.Version(3, 3, 7),
+    "recommended": cv.Version(3, 3, 6),
+    "latest": cv.Version(3, 3, 6),
+    "dev": cv.Version(3, 3, 6),
 }
 ARDUINO_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(3, 3, 7): cv.Version(55, 3, 37),
     cv.Version(3, 3, 6): cv.Version(55, 3, 36),
     cv.Version(3, 3, 5): cv.Version(55, 3, 35),
     cv.Version(3, 3, 4): cv.Version(55, 3, 31, "2"),
@@ -669,7 +668,6 @@ ARDUINO_PLATFORM_VERSION_LOOKUP = {
 # These versions correspond to pioarduino/esp-idf releases
 # See: https://github.com/pioarduino/esp-idf/releases
 ARDUINO_IDF_VERSION_LOOKUP = {
-    cv.Version(3, 3, 7): cv.Version(5, 5, 2),
     cv.Version(3, 3, 6): cv.Version(5, 5, 2),
     cv.Version(3, 3, 5): cv.Version(5, 5, 2),
     cv.Version(3, 3, 4): cv.Version(5, 5, 1),
@@ -693,7 +691,7 @@ ESP_IDF_FRAMEWORK_VERSION_LOOKUP = {
     "dev": cv.Version(5, 5, 2),
 }
 ESP_IDF_PLATFORM_VERSION_LOOKUP = {
-    cv.Version(5, 5, 2): cv.Version(55, 3, 37),
+    cv.Version(5, 5, 2): cv.Version(55, 3, 36),
     cv.Version(5, 5, 1): cv.Version(55, 3, 31, "2"),
     cv.Version(5, 5, 0): cv.Version(55, 3, 31, "2"),
     cv.Version(5, 4, 3): cv.Version(55, 3, 32),
@@ -710,8 +708,8 @@ ESP_IDF_PLATFORM_VERSION_LOOKUP = {
 # The platform-espressif32 version
 #  - https://github.com/pioarduino/platform-espressif32/releases
 PLATFORM_VERSION_LOOKUP = {
-    "recommended": cv.Version(55, 3, 37),
-    "latest": cv.Version(55, 3, 37),
+    "recommended": cv.Version(55, 3, 36),
+    "latest": cv.Version(55, 3, 36),
     "dev": "https://github.com/pioarduino/platform-espressif32.git#develop",
 }
 

esphome/components/esp32/boards.py

@@ -1686,10 +1686,6 @@ BOARDS = {
         "name": "Espressif ESP32-C6-DevKitM-1",
         "variant": VARIANT_ESP32C6,
     },
-    "esp32-c61-devkitc1": {
-        "name": "Espressif ESP32-C61-DevKitC-1 (4 MB Flash)",
-        "variant": VARIANT_ESP32C61,
-    },
     "esp32-c61-devkitc1-n8r2": {
         "name": "Espressif ESP32-C61-DevKitC-1 N8R2 (8 MB Flash Quad, 2 MB PSRAM Quad)",
         "variant": VARIANT_ESP32C61,
@@ -1722,10 +1718,6 @@ BOARDS = {
         "name": "Espressif ESP32-P4 rev.300 generic",
         "variant": VARIANT_ESP32P4,
     },
-    "esp32-p4_r3-evboard": {
-        "name": "Espressif ESP32-P4 Function EV Board v1.6 (rev.301)",
-        "variant": VARIANT_ESP32P4,
-    },
     "esp32-pico-devkitm-2": {
         "name": "Espressif ESP32-PICO-DevKitM-2",
         "variant": VARIANT_ESP32,
@@ -2562,10 +2554,6 @@ BOARDS = {
         "name": "XinaBox CW02",
         "variant": VARIANT_ESP32,
     },
-    "yb_esp32s3_amp": {
-        "name": "YelloByte YB-ESP32-S3-AMP",
-        "variant": VARIANT_ESP32S3,
-    },
     "yb_esp32s3_amp_v2": {
         "name": "YelloByte YB-ESP32-S3-AMP (Rev.2)",
         "variant": VARIANT_ESP32S3,
@@ -2574,10 +2562,6 @@ BOARDS = {
         "name": "YelloByte YB-ESP32-S3-AMP (Rev.3)",
         "variant": VARIANT_ESP32S3,
     },
-    "yb_esp32s3_dac": {
-        "name": "YelloByte YB-ESP32-S3-DAC",
-        "variant": VARIANT_ESP32S3,
-    },
     "yb_esp32s3_drv": {
         "name": "YelloByte YB-ESP32-S3-DRV",
         "variant": VARIANT_ESP32S3,

esphome/components/esp32/gpio.cpp

@@ -85,6 +85,7 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
       break;
   }
   gpio_set_intr_type(this->get_pin_num(), idf_type);
+  gpio_intr_enable(this->get_pin_num());
   if (!isr_service_installed) {
     auto res = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL3);
     if (res != ESP_OK) {
@@ -94,7 +95,6 @@ void ESP32InternalGPIOPin::attach_interrupt(void (*func)(void *), void *arg, gpi
     isr_service_installed = true;
   }
   gpio_isr_handler_add(this->get_pin_num(), func, arg);
-  gpio_intr_enable(this->get_pin_num());
 }
 
 size_t ESP32InternalGPIOPin::dump_summary(char *buffer, size_t len) const {

esphome/components/esp32/preferences.cpp

@@ -19,7 +19,16 @@ static constexpr size_t KEY_BUFFER_SIZE = 12;
 
 struct NVSData {
   uint32_t key;
-  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
+  std::unique_ptr<uint8_t[]> data;
+  size_t len;
+
+  void set_data(const uint8_t *src, size_t size) {
+    if (!this->data || this->len != size) {
+      this->data = std::make_unique<uint8_t[]>(size);
+      this->len = size;
+    }
+    memcpy(this->data.get(), src, size);
+  }
 };
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -32,14 +41,14 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        obj.data.set(data, len);
+        obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
     save.key = this->key;
-    save.data.set(data, len);
-    s_pending_save.push_back(std::move(save));
+    save.set_data(data, len);
+    s_pending_save.emplace_back(std::move(save));
     ESP_LOGVV(TAG, "s_pending_save: key: %" PRIu32 ", len: %zu", this->key, len);
     return true;
   }
@@ -47,11 +56,11 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        if (obj.data.size() != len) {
+        if (obj.len != len) {
           // size mismatch
           return false;
         }
-        memcpy(data, obj.data.data(), len);
+        memcpy(data, obj.data.get(), len);
         return true;
       }
     }
@@ -124,10 +133,10 @@ class ESP32Preferences : public ESPPreferences {
       snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
       ESP_LOGVV(TAG, "Checking if NVS data %s has changed", key_str);
       if (this->is_changed_(this->nvs_handle, save, key_str)) {
-        esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.data(), save.data.size());
-        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.data.size());
+        esp_err_t err = nvs_set_blob(this->nvs_handle, key_str, save.data.get(), save.len);
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.len);
         if (err != 0) {
-          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", key_str, save.data.size(), esp_err_to_name(err));
+          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", key_str, save.len, esp_err_to_name(err));
           failed++;
           last_err = err;
           last_key = save.key;
@@ -135,7 +144,7 @@ class ESP32Preferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGV(TAG, "NVS data not changed skipping %" PRIu32 "  len=%zu", save.key, save.data.size());
+        ESP_LOGV(TAG, "NVS data not changed skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
     }
@@ -167,7 +176,7 @@ class ESP32Preferences : public ESPPreferences {
       return true;
     }
     // Check size first before allocating memory
-    if (actual_len != to_save.data.size()) {
+    if (actual_len != to_save.len) {
       return true;
     }
     // Most preferences are small, use stack buffer with heap fallback for large ones
@@ -177,7 +186,7 @@ class ESP32Preferences : public ESPPreferences {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key_str, esp_err_to_name(err));
       return true;
     }
-    return memcmp(to_save.data.data(), stored_data.get(), to_save.data.size()) != 0;
+    return memcmp(to_save.data.get(), stored_data.get(), to_save.len) != 0;
   }
 
   bool reset() override {

esphome/components/esp32_ble/ble.cpp

@@ -98,10 +98,6 @@ void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->advertising_set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void ESP32BLE::advertising_set_manufacturer_data(std::span<const uint8_t> data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
   this->advertising_start();

esphome/components/esp32_ble/ble.h

@@ -118,7 +118,6 @@ class ESP32BLE : public Component {
   void advertising_start();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
-  void advertising_set_manufacturer_data(std::span<const uint8_t> data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
   void advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name);
   void advertising_add_service_uuid(ESPBTUUID uuid);

esphome/components/esp32_ble/ble_advertising.cpp

@@ -59,10 +59,6 @@ void BLEAdvertising::set_service_data(const std::vector<uint8_t> &data) {
 }
 
 void BLEAdvertising::set_manufacturer_data(const std::vector<uint8_t> &data) {
-  this->set_manufacturer_data(std::span<const uint8_t>(data));
-}
-
-void BLEAdvertising::set_manufacturer_data(std::span<const uint8_t> data) {
   delete[] this->advertising_data_.p_manufacturer_data;
   this->advertising_data_.p_manufacturer_data = nullptr;
   this->advertising_data_.manufacturer_len = data.size();

esphome/components/esp32_ble/ble_advertising.h

@@ -28,7 +28,6 @@ class BLEAdvertising {
   void set_scan_response(bool scan_response) { this->scan_response_ = scan_response; }
   void set_min_preferred_interval(uint16_t interval) { this->advertising_data_.min_interval = interval; }
   void set_manufacturer_data(const std::vector<uint8_t> &data);
-  void set_manufacturer_data(std::span<const uint8_t> data);
   void set_appearance(uint16_t appearance) { this->advertising_data_.appearance = appearance; }
   void set_service_data(const std::vector<uint8_t> &data);
   void set_service_data(std::span<const uint8_t> data);

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

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

esphome/components/esp32_ble_server/ble_server_automations.cpp

@@ -15,10 +15,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_characteristic_on_w
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   characteristic->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;
@@ -30,10 +27,7 @@ Trigger<std::vector<uint8_t>, uint16_t> *BLETriggers::create_descriptor_on_write
   Trigger<std::vector<uint8_t>, uint16_t> *on_write_trigger =  // NOLINT(cppcoreguidelines-owning-memory)
       new Trigger<std::vector<uint8_t>, uint16_t>();
   descriptor->on_write([on_write_trigger](std::span<const uint8_t> data, uint16_t id) {
-    // Convert span to vector for trigger - copy is necessary because:
-    // 1. Trigger stores the data for use in automation actions that execute later
-    // 2. The span is only valid during this callback (points to temporary BLE stack data)
-    // 3. User lambdas in automations need persistent data they can access asynchronously
+    // Convert span to vector for trigger
     on_write_trigger->trigger(std::vector<uint8_t>(data.begin(), data.end()), id);
   });
   return on_write_trigger;

esphome/components/ethernet/__init__.py

@@ -130,16 +130,11 @@ ETHERNET_TYPES = {
 }
 
 # PHY types that need compile-time defines for conditional compilation
-# Each RMII PHY type gets a define so unused PHY drivers are excluded by the linker
 _PHY_TYPE_TO_DEFINE = {
-    "LAN8720": "USE_ETHERNET_LAN8720",
-    "RTL8201": "USE_ETHERNET_RTL8201",
-    "DP83848": "USE_ETHERNET_DP83848",
-    "IP101": "USE_ETHERNET_IP101",
-    "JL1101": "USE_ETHERNET_JL1101",
     "KSZ8081": "USE_ETHERNET_KSZ8081",
     "KSZ8081RNA": "USE_ETHERNET_KSZ8081",
     "LAN8670": "USE_ETHERNET_LAN8670",
+    # Add other PHY types here only if they need conditional compilation
 }
 
 SPI_ETHERNET_TYPES = ["W5500", "DM9051"]

esphome/components/ethernet/ethernet_component.cpp

@@ -186,43 +186,31 @@ void EthernetComponent::setup() {
     }
 #endif
 #if CONFIG_ETH_USE_ESP32_EMAC
-#ifdef USE_ETHERNET_LAN8720
     case ETHERNET_TYPE_LAN8720: {
       this->phy_ = esp_eth_phy_new_lan87xx(&phy_config);
       break;
     }
-#endif
-#ifdef USE_ETHERNET_RTL8201
     case ETHERNET_TYPE_RTL8201: {
       this->phy_ = esp_eth_phy_new_rtl8201(&phy_config);
       break;
     }
-#endif
-#ifdef USE_ETHERNET_DP83848
     case ETHERNET_TYPE_DP83848: {
       this->phy_ = esp_eth_phy_new_dp83848(&phy_config);
       break;
     }
-#endif
-#ifdef USE_ETHERNET_IP101
     case ETHERNET_TYPE_IP101: {
       this->phy_ = esp_eth_phy_new_ip101(&phy_config);
       break;
     }
-#endif
-#ifdef USE_ETHERNET_JL1101
     case ETHERNET_TYPE_JL1101: {
       this->phy_ = esp_eth_phy_new_jl1101(&phy_config);
       break;
     }
-#endif
-#ifdef USE_ETHERNET_KSZ8081
     case ETHERNET_TYPE_KSZ8081:
     case ETHERNET_TYPE_KSZ8081RNA: {
       this->phy_ = esp_eth_phy_new_ksz80xx(&phy_config);
       break;
     }
-#endif
 #ifdef USE_ETHERNET_LAN8670
     case ETHERNET_TYPE_LAN8670: {
       this->phy_ = esp_eth_phy_new_lan867x(&phy_config);
@@ -355,32 +343,26 @@ void EthernetComponent::loop() {
 void EthernetComponent::dump_config() {
   const char *eth_type;
   switch (this->type_) {
-#ifdef USE_ETHERNET_LAN8720
     case ETHERNET_TYPE_LAN8720:
       eth_type = "LAN8720";
       break;
-#endif
-#ifdef USE_ETHERNET_RTL8201
+
     case ETHERNET_TYPE_RTL8201:
       eth_type = "RTL8201";
       break;
-#endif
-#ifdef USE_ETHERNET_DP83848
+
     case ETHERNET_TYPE_DP83848:
       eth_type = "DP83848";
       break;
-#endif
-#ifdef USE_ETHERNET_IP101
+
     case ETHERNET_TYPE_IP101:
       eth_type = "IP101";
       break;
-#endif
-#ifdef USE_ETHERNET_JL1101
+
     case ETHERNET_TYPE_JL1101:
       eth_type = "JL1101";
       break;
-#endif
-#ifdef USE_ETHERNET_KSZ8081
+
     case ETHERNET_TYPE_KSZ8081:
       eth_type = "KSZ8081";
       break;
@@ -388,22 +370,19 @@ void EthernetComponent::dump_config() {
     case ETHERNET_TYPE_KSZ8081RNA:
       eth_type = "KSZ8081RNA";
       break;
-#endif
-#if CONFIG_ETH_SPI_ETHERNET_W5500
+
     case ETHERNET_TYPE_W5500:
       eth_type = "W5500";
       break;
-#endif
-#if CONFIG_ETH_SPI_ETHERNET_DM9051
-    case ETHERNET_TYPE_DM9051:
-      eth_type = "DM9051";
-      break;
-#endif
-#ifdef USE_ETHERNET_OPENETH
+
     case ETHERNET_TYPE_OPENETH:
       eth_type = "OPENETH";
       break;
-#endif
+
+    case ETHERNET_TYPE_DM9051:
+      eth_type = "DM9051";
+      break;
+
 #ifdef USE_ETHERNET_LAN8670
     case ETHERNET_TYPE_LAN8670:
       eth_type = "LAN8670";
@@ -707,22 +686,16 @@ void EthernetComponent::dump_connect_params_() {
   char gateway_buf[network::IP_ADDRESS_BUFFER_SIZE];
   char dns1_buf[network::IP_ADDRESS_BUFFER_SIZE];
   char dns2_buf[network::IP_ADDRESS_BUFFER_SIZE];
-  char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
   ESP_LOGCONFIG(TAG,
                 "  IP Address: %s\n"
                 "  Hostname: '%s'\n"
                 "  Subnet: %s\n"
                 "  Gateway: %s\n"
                 "  DNS1: %s\n"
-                "  DNS2: %s\n"
-                "  MAC Address: %s\n"
-                "  Is Full Duplex: %s\n"
-                "  Link Speed: %u",
+                "  DNS2: %s",
                 network::IPAddress(&ip.ip).str_to(ip_buf), App.get_name().c_str(),
                 network::IPAddress(&ip.netmask).str_to(subnet_buf), network::IPAddress(&ip.gw).str_to(gateway_buf),
-                network::IPAddress(dns_ip1).str_to(dns1_buf), network::IPAddress(dns_ip2).str_to(dns2_buf),
-                this->get_eth_mac_address_pretty_into_buffer(mac_buf),
-                YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL), this->get_link_speed() == ETH_SPEED_100M ? 100 : 10);
+                network::IPAddress(dns_ip1).str_to(dns1_buf), network::IPAddress(dns_ip2).str_to(dns2_buf));
 
 #if USE_NETWORK_IPV6
   struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
@@ -733,6 +706,14 @@ void EthernetComponent::dump_connect_params_() {
     ESP_LOGCONFIG(TAG, "  IPv6: " IPV6STR, IPV62STR(if_ip6s[i]));
   }
 #endif /* USE_NETWORK_IPV6 */
+
+  char mac_buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
+  ESP_LOGCONFIG(TAG,
+                "  MAC Address: %s\n"
+                "  Is Full Duplex: %s\n"
+                "  Link Speed: %u",
+                this->get_eth_mac_address_pretty_into_buffer(mac_buf),
+                YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL), this->get_link_speed() == ETH_SPEED_100M ? 100 : 10);
 }
 
 #ifdef USE_ETHERNET_SPI
@@ -856,15 +837,13 @@ void EthernetComponent::ksz8081_set_clock_reference_(esp_eth_mac_t *mac) {
 
 void EthernetComponent::write_phy_register_(esp_eth_mac_t *mac, PHYRegister register_data) {
   esp_err_t err;
-
-#ifdef USE_ETHERNET_RTL8201
   constexpr uint8_t eth_phy_psr_reg_addr = 0x1F;
+
   if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
     ESP_LOGD(TAG, "Select PHY Register Page: 0x%02" PRIX32, register_data.page);
     err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, register_data.page);
     ESPHL_ERROR_CHECK(err, "Select PHY Register page failed");
   }
-#endif
 
   ESP_LOGD(TAG,
            "Writing to PHY Register Address: 0x%02" PRIX32 "\n"
@@ -873,13 +852,11 @@ void EthernetComponent::write_phy_register_(esp_eth_mac_t *mac, PHYRegister regi
   err = mac->write_phy_reg(mac, this->phy_addr_, register_data.address, register_data.value);
   ESPHL_ERROR_CHECK(err, "Writing PHY Register failed");
 
-#ifdef USE_ETHERNET_RTL8201
   if (this->type_ == ETHERNET_TYPE_RTL8201 && register_data.page) {
     ESP_LOGD(TAG, "Select PHY Register Page 0x00");
     err = mac->write_phy_reg(mac, this->phy_addr_, eth_phy_psr_reg_addr, 0x0);
     ESPHL_ERROR_CHECK(err, "Select PHY Register Page 0 failed");
   }
-#endif
 }
 
 #endif

esphome/components/ethernet/ethernet_component.h

@@ -110,8 +110,6 @@ class EthernetComponent : public Component {
   const char *get_use_address() const;
   void set_use_address(const char *use_address);
   void get_eth_mac_address_raw(uint8_t *mac);
-  // Remove before 2026.9.0
-  ESPDEPRECATED("Use get_eth_mac_address_pretty_into_buffer() instead. Removed in 2026.9.0", "2026.3.0")
   std::string get_eth_mac_address_pretty();
   const char *get_eth_mac_address_pretty_into_buffer(std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf);
   eth_duplex_t get_duplex_mode();

esphome/components/fan/fan.cpp

@@ -68,7 +68,7 @@ void FanCall::validate_() {
   auto traits = this->parent_.get_traits();
 
   if (this->speed_.has_value()) {
-    this->speed_ = clamp(*this->speed_, 1, static_cast<int>(traits.supported_speed_count()));
+    this->speed_ = clamp(*this->speed_, 1, traits.supported_speed_count());
 
     // https://developers.home-assistant.io/docs/core/entity/fan/#preset-modes
     // "Manually setting a speed must disable any set preset mode"

esphome/components/fan/fan_traits.h

@@ -11,7 +11,7 @@ namespace fan {
 class FanTraits {
  public:
   FanTraits() = default;
-  FanTraits(bool oscillation, bool speed, bool direction, uint8_t speed_count)
+  FanTraits(bool oscillation, bool speed, bool direction, int speed_count)
       : oscillation_(oscillation), speed_(speed), direction_(direction), speed_count_(speed_count) {}
 
   /// Return if this fan supports oscillation.
@@ -23,9 +23,9 @@ class FanTraits {
   /// Set whether this fan supports speed levels.
   void set_speed(bool speed) { this->speed_ = speed; }
   /// Return how many speed levels the fan has
-  uint8_t supported_speed_count() const { return this->speed_count_; }
+  int supported_speed_count() const { return this->speed_count_; }
   /// Set how many speed levels this fan has.
-  void set_supported_speed_count(uint8_t speed_count) { this->speed_count_ = speed_count; }
+  void set_supported_speed_count(int speed_count) { this->speed_count_ = speed_count; }
   /// Return if this fan supports changing direction
   bool supports_direction() const { return this->direction_; }
   /// Set whether this fan supports changing direction
@@ -64,7 +64,7 @@ class FanTraits {
   bool oscillation_{false};
   bool speed_{false};
   bool direction_{false};
-  uint8_t speed_count_{};
+  int speed_count_{};
   std::vector<const char *> preset_modes_{};
 };
 

esphome/components/hbridge/fan/__init__.py

@@ -39,7 +39,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_DECAY_MODE, default="SLOW"): cv.enum(
                 DECAY_MODE_OPTIONS, upper=True
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_ENABLE_PIN): cv.use_id(output.FloatOutput),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }

esphome/components/hbridge/fan/hbridge_fan.h

@@ -15,7 +15,7 @@ enum DecayMode {
 
 class HBridgeFan : public Component, public fan::Fan {
  public:
-  HBridgeFan(uint8_t speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
+  HBridgeFan(int speed_count, DecayMode decay_mode) : speed_count_(speed_count), decay_mode_(decay_mode) {}
 
   void set_pin_a(output::FloatOutput *pin_a) { pin_a_ = pin_a; }
   void set_pin_b(output::FloatOutput *pin_b) { pin_b_ = pin_b; }
@@ -33,7 +33,7 @@ class HBridgeFan : public Component, public fan::Fan {
   output::FloatOutput *pin_b_;
   output::FloatOutput *enable_{nullptr};
   output::BinaryOutput *oscillating_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   DecayMode decay_mode_{DECAY_MODE_SLOW};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};

esphome/components/i2c/i2c_bus_esp_idf.cpp

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

esphome/components/json/json_util.cpp

@@ -15,7 +15,7 @@ static const char *const TAG = "json";
 static SpiRamAllocator global_json_allocator;
 #endif
 
-SerializationBuffer<> build_json(const json_build_t &f) {
+std::string build_json(const json_build_t &f) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   JsonBuilder builder;
   JsonObject root = builder.root();
@@ -66,62 +66,14 @@ JsonDocument parse_json(const uint8_t *data, size_t len) {
   // NOLINTEND(clang-analyzer-cplusplus.NewDeleteLeaks)
 }
 
-SerializationBuffer<> JsonBuilder::serialize() {
-  // ===========================================================================================
-  // CRITICAL: NRVO (Named Return Value Optimization) - DO NOT REFACTOR WITHOUT UNDERSTANDING
-  // ===========================================================================================
-  //
-  // This function is carefully structured to enable NRVO. The compiler constructs `result`
-  // directly in the caller's stack frame, eliminating the move constructor call entirely.
-  //
-  // WITHOUT NRVO: Each return would trigger SerializationBuffer's move constructor, which
-  // must memcpy up to 512 bytes of stack buffer content. This happens on EVERY JSON
-  // serialization (sensor updates, web server responses, MQTT publishes, etc.).
-  //
-  // WITH NRVO: Zero memcpy, zero move constructor overhead. The buffer lives directly
-  // where the caller needs it.
-  //
-  // Requirements for NRVO to work:
-  //   1. Single named variable (`result`) returned from ALL paths
-  //   2. All paths must return the SAME variable (not different variables)
-  //   3. No std::move() on the return statement
-  //
-  // If you must modify this function:
-  //   - Keep a single `result` variable declared at the top
-  //   - All code paths must return `result` (not a different variable)
-  //   - Verify NRVO still works by checking the disassembly for move constructor calls
-  //   - Test: objdump -d -C firmware.elf | grep "SerializationBuffer.*SerializationBuffer"
-  //     Should show only destructor, NOT move constructor
-  //
-  // Why we avoid measureJson(): It instantiates DummyWriter templates adding ~1KB flash.
-  // Instead, try stack buffer first. 512 bytes covers 99.9% of JSON payloads (sensors ~200B,
-  // lights ~170B, climate ~700B). Only entities with 40+ options exceed this.
-  //
-  // ===========================================================================================
-  constexpr size_t buf_size = SerializationBuffer<>::BUFFER_SIZE;
-  SerializationBuffer<> result(buf_size - 1);  // Max content size (reserve 1 for null)
-
+std::string JsonBuilder::serialize() {
   if (doc_.overflowed()) {
     ESP_LOGE(TAG, "JSON document overflow");
-    auto *buf = result.data_writable_();
-    buf[0] = '{';
-    buf[1] = '}';
-    buf[2] = '\0';
-    result.set_size_(2);
-    return result;
+    return "{}";
   }
-
-  size_t size = serializeJson(doc_, result.data_writable_(), buf_size);
-  if (size < buf_size) {
-    // Fits in stack buffer - update size to actual length
-    result.set_size_(size);
-    return result;
-  }
-
-  // Needs heap allocation - reallocate and serialize again with exact size
-  result.reallocate_heap_(size);
-  serializeJson(doc_, result.data_writable_(), size + 1);
-  return result;
+  std::string output;
+  serializeJson(doc_, output);
+  return output;
 }
 
 }  // namespace json

esphome/components/json/json_util.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cstring>
-#include <string>
 #include <vector>
 
 #include "esphome/core/defines.h"
@@ -16,108 +14,6 @@
 namespace esphome {
 namespace json {
 
-/// Buffer for JSON serialization that uses stack allocation for small payloads.
-/// Template parameter STACK_SIZE specifies the stack buffer size (default 512 bytes).
-/// Supports move semantics for efficient return-by-value.
-template<size_t STACK_SIZE = 512> class SerializationBuffer {
- public:
-  static constexpr size_t BUFFER_SIZE = STACK_SIZE;  ///< Stack buffer size for this instantiation
-
-  /// Construct with known size (typically from measureJson)
-  explicit SerializationBuffer(size_t size) : size_(size) {
-    if (size + 1 <= STACK_SIZE) {
-      buffer_ = stack_buffer_;
-    } else {
-      heap_buffer_ = new char[size + 1];
-      buffer_ = heap_buffer_;
-    }
-    buffer_[0] = '\0';
-  }
-
-  ~SerializationBuffer() { delete[] heap_buffer_; }
-
-  // Move constructor - works with same template instantiation
-  SerializationBuffer(SerializationBuffer &&other) noexcept : heap_buffer_(other.heap_buffer_), size_(other.size_) {
-    if (other.buffer_ == other.stack_buffer_) {
-      // Stack buffer - must copy content
-      std::memcpy(stack_buffer_, other.stack_buffer_, size_ + 1);
-      buffer_ = stack_buffer_;
-    } else {
-      // Heap buffer - steal ownership
-      buffer_ = heap_buffer_;
-      other.heap_buffer_ = nullptr;
-    }
-    // Leave moved-from object in valid empty state
-    other.stack_buffer_[0] = '\0';
-    other.buffer_ = other.stack_buffer_;
-    other.size_ = 0;
-  }
-
-  // Move assignment
-  SerializationBuffer &operator=(SerializationBuffer &&other) noexcept {
-    if (this != &other) {
-      delete[] heap_buffer_;
-      heap_buffer_ = other.heap_buffer_;
-      size_ = other.size_;
-      if (other.buffer_ == other.stack_buffer_) {
-        std::memcpy(stack_buffer_, other.stack_buffer_, size_ + 1);
-        buffer_ = stack_buffer_;
-      } else {
-        buffer_ = heap_buffer_;
-        other.heap_buffer_ = nullptr;
-      }
-      // Leave moved-from object in valid empty state
-      other.stack_buffer_[0] = '\0';
-      other.buffer_ = other.stack_buffer_;
-      other.size_ = 0;
-    }
-    return *this;
-  }
-
-  // Delete copy operations
-  SerializationBuffer(const SerializationBuffer &) = delete;
-  SerializationBuffer &operator=(const SerializationBuffer &) = delete;
-
-  /// Get null-terminated C string
-  const char *c_str() const { return buffer_; }
-  /// Get data pointer
-  const char *data() const { return buffer_; }
-  /// Get string length (excluding null terminator)
-  size_t size() const { return size_; }
-
-  /// Implicit conversion to std::string for backward compatibility
-  /// WARNING: This allocates a new std::string on the heap. Prefer using
-  /// c_str() or data()/size() directly when possible to avoid allocation.
-  operator std::string() const { return std::string(buffer_, size_); }  // NOLINT(google-explicit-constructor)
-
- private:
-  friend class JsonBuilder;  ///< Allows JsonBuilder::serialize() to call private methods
-
-  /// Get writable buffer (for serialization)
-  char *data_writable_() { return buffer_; }
-  /// Set actual size after serialization (must not exceed allocated size)
-  /// Also ensures null termination for c_str() safety
-  void set_size_(size_t size) {
-    size_ = size;
-    buffer_[size] = '\0';
-  }
-
-  /// Reallocate to heap buffer with new size (for when stack buffer is too small)
-  /// This invalidates any previous buffer content. Used by JsonBuilder::serialize().
-  void reallocate_heap_(size_t size) {
-    delete[] heap_buffer_;
-    heap_buffer_ = new char[size + 1];
-    buffer_ = heap_buffer_;
-    size_ = size;
-    buffer_[0] = '\0';
-  }
-
-  char stack_buffer_[STACK_SIZE];
-  char *heap_buffer_{nullptr};
-  char *buffer_;
-  size_t size_;
-};
-
 #ifdef USE_PSRAM
 // Build an allocator for the JSON Library using the RAMAllocator class
 // This is only compiled when PSRAM is enabled
@@ -150,8 +46,7 @@ using json_parse_t = std::function<bool(JsonObject)>;
 using json_build_t = std::function<void(JsonObject)>;
 
 /// Build a JSON string with the provided json build function.
-/// Returns SerializationBuffer for stack-first allocation; implicitly converts to std::string.
-SerializationBuffer<> build_json(const json_build_t &f);
+std::string build_json(const json_build_t &f);
 
 /// Parse a JSON string and run the provided json parse function if it's valid.
 bool parse_json(const std::string &data, const json_parse_t &f);
@@ -176,9 +71,7 @@ class JsonBuilder {
     return root_;
   }
 
-  /// Serialize the JSON document to a SerializationBuffer (stack-first allocation)
-  /// Uses 512-byte stack buffer by default, falls back to heap for larger JSON
-  SerializationBuffer<> serialize();
+  std::string serialize();
 
  private:
 #ifdef USE_PSRAM

esphome/components/kuntze/kuntze.cpp

@@ -11,7 +11,7 @@ static const char *const TAG = "kuntze";
 static const uint8_t CMD_READ_REG = 0x03;
 static const uint16_t REGISTER[] = {4136, 4160, 4680, 6000, 4688, 4728, 5832};
 
-// Maximum bytes to log for Modbus responses (2 registers = 4 bytes, plus byte count = 5 bytes)
+// Maximum bytes to log for Modbus responses (2 registers = 4, plus count = 5)
 static constexpr size_t KUNTZE_MAX_LOG_BYTES = 8;
 
 void Kuntze::on_modbus_data(const std::vector<uint8_t> &data) {

esphome/components/libretiny/preferences.cpp

@@ -18,7 +18,16 @@ static constexpr size_t KEY_BUFFER_SIZE = 12;
 
 struct NVSData {
   uint32_t key;
-  SmallInlineBuffer<8> data;  // Most prefs fit in 8 bytes (covers fan, cover, select, etc.)
+  std::unique_ptr<uint8_t[]> data;
+  size_t len;
+
+  void set_data(const uint8_t *src, size_t size) {
+    if (!this->data || this->len != size) {
+      this->data = std::make_unique<uint8_t[]>(size);
+      this->len = size;
+    }
+    memcpy(this->data.get(), src, size);
+  }
 };
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -33,14 +42,14 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        obj.data.set(data, len);
+        obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
     save.key = this->key;
-    save.data.set(data, len);
-    s_pending_save.push_back(std::move(save));
+    save.set_data(data, len);
+    s_pending_save.emplace_back(std::move(save));
     ESP_LOGVV(TAG, "s_pending_save: key: %" PRIu32 ", len: %zu", this->key, len);
     return true;
   }
@@ -49,11 +58,11 @@ class LibreTinyPreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
       if (obj.key == this->key) {
-        if (obj.data.size() != len) {
+        if (obj.len != len) {
           // size mismatch
           return false;
         }
-        memcpy(data, obj.data.data(), len);
+        memcpy(data, obj.data.get(), len);
         return true;
       }
     }
@@ -114,11 +123,11 @@ class LibreTinyPreferences : public ESPPreferences {
       snprintf(key_str, sizeof(key_str), "%" PRIu32, save.key);
       ESP_LOGVV(TAG, "Checking if FDB data %s has changed", key_str);
       if (this->is_changed_(&this->db, save, key_str)) {
-        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.data.size());
-        fdb_blob_make(&this->blob, save.data.data(), save.data.size());
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", key_str, save.len);
+        fdb_blob_make(&this->blob, save.data.get(), save.len);
         fdb_err_t err = fdb_kv_set_blob(&this->db, key_str, &this->blob);
         if (err != FDB_NO_ERR) {
-          ESP_LOGV(TAG, "fdb_kv_set_blob('%s', len=%zu) failed: %d", key_str, save.data.size(), err);
+          ESP_LOGV(TAG, "fdb_kv_set_blob('%s', len=%zu) failed: %d", key_str, save.len, err);
           failed++;
           last_err = err;
           last_key = save.key;
@@ -126,7 +135,7 @@ class LibreTinyPreferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGD(TAG, "FDB data not changed; skipping %" PRIu32 "  len=%zu", save.key, save.data.size());
+        ESP_LOGD(TAG, "FDB data not changed; skipping %" PRIu32 "  len=%zu", save.key, save.len);
         cached++;
       }
     }
@@ -151,7 +160,7 @@ class LibreTinyPreferences : public ESPPreferences {
     }
 
     // Check size first - if different, data has changed
-    if (kv.value_len != to_save.data.size()) {
+    if (kv.value_len != to_save.len) {
       return true;
     }
 
@@ -165,7 +174,7 @@ class LibreTinyPreferences : public ESPPreferences {
     }
 
     // Compare the actual data
-    return memcmp(to_save.data.data(), stored_data.get(), kv.value_len) != 0;
+    return memcmp(to_save.data.get(), stored_data.get(), kv.value_len) != 0;
   }
 
   bool reset() override {

esphome/components/logger/logger_esp8266.cpp.bak

@@ -1,51 +0,0 @@
-#ifdef USE_ESP8266
-#include "logger.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-      case UART_SELECTION_UART0_SWAP:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        if (this->uart_ == UART_SELECTION_UART0_SWAP) {
-          Serial.swap();
-        }
-        Serial.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-        break;
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        Serial1.setDebugOutput(ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE);
-        break;
-    }
-  } else {
-    uart_set_debug(UART_NO);
-  }
-
-  global_logger = this;
-
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-    case UART_SELECTION_UART0_SWAP:
-    default:
-      return LOG_STR("UART0_SWAP");
-  }
-}
-
-}  // namespace esphome::logger
-#endif

esphome/components/logger/logger_host.cpp.bak

@@ -1,22 +0,0 @@
-#if defined(USE_HOST)
-#include "logger.h"
-
-namespace esphome::logger {
-
-void HOT Logger::write_msg_(const char *msg) {
-  time_t rawtime;
-  struct tm *timeinfo;
-  char buffer[80];
-
-  time(&rawtime);
-  timeinfo = localtime(&rawtime);
-  strftime(buffer, sizeof buffer, "[%H:%M:%S]", timeinfo);
-  fputs(buffer, stdout);
-  puts(msg);
-}
-
-void Logger::pre_setup() { global_logger = this; }
-
-}  // namespace esphome::logger
-
-#endif

esphome/components/logger/logger_libretiny.cpp.bak

@@ -1,70 +0,0 @@
-#ifdef USE_LIBRETINY
-#include "logger.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-#if LT_HW_UART0
-      case UART_SELECTION_UART0:
-        this->hw_serial_ = &Serial0;
-        Serial0.begin(this->baud_rate_);
-        break;
-#endif
-#if LT_HW_UART1
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        break;
-#endif
-#if LT_HW_UART2
-      case UART_SELECTION_UART2:
-        this->hw_serial_ = &Serial2;
-        Serial2.begin(this->baud_rate_);
-        break;
-#endif
-      default:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        if (this->uart_ != UART_SELECTION_DEFAULT) {
-          ESP_LOGW(TAG, "  The chosen logger UART port is not available on this board."
-                        "The default port was used instead.");
-        }
-        break;
-    }
-
-    // change lt_log() port to match default Serial
-    if (this->uart_ == UART_SELECTION_DEFAULT) {
-      this->uart_ = (UARTSelection) (LT_UART_DEFAULT_SERIAL + 1);
-      lt_log_set_port(LT_UART_DEFAULT_SERIAL);
-    } else {
-      lt_log_set_port(this->uart_ - 1);
-    }
-  }
-
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_DEFAULT:
-      return LOG_STR("DEFAULT");
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-    case UART_SELECTION_UART2:
-    default:
-      return LOG_STR("UART2");
-  }
-}
-
-}  // namespace esphome::logger
-
-#endif  // USE_LIBRETINY

esphome/components/logger/logger_rp2040.cpp.bak

@@ -1,48 +0,0 @@
-#ifdef USE_RP2040
-#include "logger.h"
-#include "esphome/core/log.h"
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-        this->hw_serial_ = &Serial1;
-        Serial1.begin(this->baud_rate_);
-        break;
-      case UART_SELECTION_UART1:
-        this->hw_serial_ = &Serial2;
-        Serial2.begin(this->baud_rate_);
-        break;
-      case UART_SELECTION_USB_CDC:
-        this->hw_serial_ = &Serial;
-        Serial.begin(this->baud_rate_);
-        break;
-    }
-  }
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) { this->hw_serial_->println(msg); }
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-#ifdef USE_LOGGER_USB_CDC
-    case UART_SELECTION_USB_CDC:
-      return LOG_STR("USB_CDC");
-#endif
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-}  // namespace esphome::logger
-#endif  // USE_RP2040

esphome/components/logger/logger_zephyr.cpp.bak

@@ -1,96 +0,0 @@
-#ifdef USE_ZEPHYR
-
-#include "esphome/core/application.h"
-#include "esphome/core/log.h"
-#include "logger.h"
-
-#include <zephyr/device.h>
-#include <zephyr/drivers/uart.h>
-#include <zephyr/usb/usb_device.h>
-
-namespace esphome::logger {
-
-static const char *const TAG = "logger";
-
-#ifdef USE_LOGGER_USB_CDC
-void Logger::loop() {
-  if (this->uart_ != UART_SELECTION_USB_CDC || nullptr == this->uart_dev_) {
-    return;
-  }
-  static bool opened = false;
-  uint32_t dtr = 0;
-  uart_line_ctrl_get(this->uart_dev_, UART_LINE_CTRL_DTR, &dtr);
-
-  /* Poll if the DTR flag was set, optional */
-  if (opened == dtr) {
-    return;
-  }
-
-  if (!opened) {
-    App.schedule_dump_config();
-  }
-  opened = !opened;
-}
-#endif
-
-void Logger::pre_setup() {
-  if (this->baud_rate_ > 0) {
-    static const struct device *uart_dev = nullptr;
-    switch (this->uart_) {
-      case UART_SELECTION_UART0:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(uart0));
-        break;
-      case UART_SELECTION_UART1:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(uart1));
-        break;
-#ifdef USE_LOGGER_USB_CDC
-      case UART_SELECTION_USB_CDC:
-        uart_dev = DEVICE_DT_GET_OR_NULL(DT_NODELABEL(cdc_acm_uart0));
-        if (device_is_ready(uart_dev)) {
-          usb_enable(nullptr);
-        }
-        break;
-#endif
-    }
-    if (!device_is_ready(uart_dev)) {
-      ESP_LOGE(TAG, "%s is not ready.", LOG_STR_ARG(get_uart_selection_()));
-    } else {
-      this->uart_dev_ = uart_dev;
-    }
-  }
-  global_logger = this;
-  ESP_LOGI(TAG, "Log initialized");
-}
-
-void HOT Logger::write_msg_(const char *msg) {
-#ifdef CONFIG_PRINTK
-  printk("%s\n", msg);
-#endif
-  if (nullptr == this->uart_dev_) {
-    return;
-  }
-  while (*msg) {
-    uart_poll_out(this->uart_dev_, *msg);
-    ++msg;
-  }
-  uart_poll_out(this->uart_dev_, '\n');
-}
-
-const LogString *Logger::get_uart_selection_() {
-  switch (this->uart_) {
-    case UART_SELECTION_UART0:
-      return LOG_STR("UART0");
-    case UART_SELECTION_UART1:
-      return LOG_STR("UART1");
-#ifdef USE_LOGGER_USB_CDC
-    case UART_SELECTION_USB_CDC:
-      return LOG_STR("USB_CDC");
-#endif
-    default:
-      return LOG_STR("UNKNOWN");
-  }
-}
-
-}  // namespace esphome::logger
-
-#endif

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::IO; }
+float MCP23016::get_setup_priority() const { return setup_priority::HARDWARE; }
 bool MCP23016::read_reg_(uint8_t reg, uint8_t *value) {
   if (this->is_failed())
     return false;

esphome/components/mipi_spi/models/waveshare.py

@@ -1,17 +1,4 @@
-from esphome.components.mipi import (
-    ETMOD,
-    FRMCTR2,
-    GMCTRN1,
-    GMCTRP1,
-    IFCTR,
-    MODE_RGB,
-    PWCTR1,
-    PWCTR3,
-    PWCTR4,
-    PWCTR5,
-    PWSET,
-    DriverChip,
-)
+from esphome.components.mipi import DriverChip
 import esphome.config_validation as cv
 
 from .amoled import CO5300
@@ -142,16 +129,6 @@ DriverChip(
         ),
     ),
 )
-ST7789P = DriverChip(
-    "ST7789P",
-    # Max supported dimensions
-    width=240,
-    height=320,
-    # SPI: RGB layout
-    color_order=MODE_RGB,
-    invert_colors=True,
-    draw_rounding=1,
-)
 
 ILI9488_A.extend(
     "PICO-RESTOUCH-LCD-3.5",
@@ -185,61 +162,3 @@ AXS15231.extend(
     cs_pin=9,
     reset_pin=21,
 )
-
-# Waveshare 1.83-v2
-#
-# Do not use on 1.83-v1: Vendor warning on different chip!
-ST7789P.extend(
-    "WAVESHARE-1.83-V2",
-    # Panel size smaller than ST7789 max allowed
-    width=240,
-    height=284,
-    # Vendor specific init derived from vendor sample code
-    # "LCD_1.83_Code_Rev2/ESP32/LCD_1in83/LCD_Driver.cpp"
-    # Compatible MIT license, see esphome/LICENSE file.
-    initsequence=(
-        (FRMCTR2, 0x0C, 0x0C, 0x00, 0x33, 0x33),
-        (ETMOD, 0x35),
-        (0xBB, 0x19),
-        (PWCTR1, 0x2C),
-        (PWCTR3, 0x01),
-        (PWCTR4, 0x12),
-        (PWCTR5, 0x20),
-        (IFCTR, 0x0F),
-        (PWSET, 0xA4, 0xA1),
-        (
-            GMCTRP1,
-            0xD0,
-            0x04,
-            0x0D,
-            0x11,
-            0x13,
-            0x2B,
-            0x3F,
-            0x54,
-            0x4C,
-            0x18,
-            0x0D,
-            0x0B,
-            0x1F,
-            0x23,
-        ),
-        (
-            GMCTRN1,
-            0xD0,
-            0x04,
-            0x0C,
-            0x11,
-            0x13,
-            0x2C,
-            0x3F,
-            0x44,
-            0x51,
-            0x2F,
-            0x1F,
-            0x1F,
-            0x20,
-            0x23,
-        ),
-    ),
-)

esphome/components/mqtt/mqtt_client.cpp

@@ -540,8 +540,8 @@ bool MQTTClientComponent::publish(const char *topic, const char *payload, size_t
 }
 
 bool MQTTClientComponent::publish_json(const char *topic, const json::json_build_t &f, uint8_t qos, bool retain) {
-  auto message = json::build_json(f);
-  return this->publish(topic, message.c_str(), message.size(), qos, retain);
+  std::string message = json::build_json(f);
+  return this->publish(topic, message.c_str(), message.length(), qos, retain);
 }
 
 void MQTTClientComponent::enable() {

esphome/components/pulse_meter/pulse_meter_sensor.cpp

@@ -38,7 +38,8 @@ void PulseMeterSensor::setup() {
 }
 
 void PulseMeterSensor::loop() {
-  State state;
+  // Reset the count in get before we pass it back to the ISR as set
+  this->get_->count_ = 0;
 
   {
     // Lock the interrupt so the interrupt code doesn't interfere with itself
@@ -57,35 +58,31 @@ void PulseMeterSensor::loop() {
     }
     this->last_pin_val_ = current;
 
-    // Get the latest state from the ISR and reset the count in the ISR
-    state.last_detected_edge_us_ = this->state_.last_detected_edge_us_;
-    state.last_rising_edge_us_ = this->state_.last_rising_edge_us_;
-    state.count_ = this->state_.count_;
-    this->state_.count_ = 0;
+    // Swap out set and get to get the latest state from the ISR
+    std::swap(this->set_, this->get_);
   }
 
   const uint32_t now = micros();
 
   // If an edge was peeked, repay the debt
-  if (this->peeked_edge_ && state.count_ > 0) {
+  if (this->peeked_edge_ && this->get_->count_ > 0) {
     this->peeked_edge_ = false;
-    state.count_--;
+    this->get_->count_--;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
-  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early.
-  // Wait for the debt to be repaid before counting another unprocessed edge early.
-  if (!this->peeked_edge_ && state.last_rising_edge_us_ != state.last_detected_edge_us_ &&
-      now - state.last_rising_edge_us_ >= this->filter_us_) {
+  // If there is an unprocessed edge, and filter_us_ has passed since, count this edge early
+  if (this->get_->last_rising_edge_us_ != this->get_->last_detected_edge_us_ &&
+      now - this->get_->last_rising_edge_us_ >= this->filter_us_) {
     this->peeked_edge_ = true;
-    state.last_detected_edge_us_ = state.last_rising_edge_us_;
-    state.count_++;
+    this->get_->last_detected_edge_us_ = this->get_->last_rising_edge_us_;
+    this->get_->count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Check if we detected a pulse this loop
-  if (state.count_ > 0) {
+  if (this->get_->count_ > 0) {
     // Keep a running total of pulses if a total sensor is configured
     if (this->total_sensor_ != nullptr) {
-      this->total_pulses_ += state.count_;
+      this->total_pulses_ += this->get_->count_;
       const uint32_t total = this->total_pulses_;
       this->total_sensor_->publish_state(total);
     }
@@ -97,15 +94,15 @@ void PulseMeterSensor::loop() {
         this->meter_state_ = MeterState::RUNNING;
       } break;
       case MeterState::RUNNING: {
-        uint32_t delta_us = state.last_detected_edge_us_ - this->last_processed_edge_us_;
-        float pulse_width_us = delta_us / float(state.count_);
-        ESP_LOGV(TAG, "New pulse, delta: %" PRIu32 " µs, count: %" PRIu32 ", width: %.5f µs", delta_us, state.count_,
-                 pulse_width_us);
+        uint32_t delta_us = this->get_->last_detected_edge_us_ - this->last_processed_edge_us_;
+        float pulse_width_us = delta_us / float(this->get_->count_);
+        ESP_LOGV(TAG, "New pulse, delta: %" PRIu32 " µs, count: %" PRIu32 ", width: %.5f µs", delta_us,
+                 this->get_->count_, pulse_width_us);
         this->publish_state((60.0f * 1000000.0f) / pulse_width_us);
       } break;
     }
 
-    this->last_processed_edge_us_ = state.last_detected_edge_us_;
+    this->last_processed_edge_us_ = this->get_->last_detected_edge_us_;
   }
   // No detected edges this loop
   else {
@@ -144,14 +141,14 @@ void IRAM_ATTR PulseMeterSensor::edge_intr(PulseMeterSensor *sensor) {
   // This is an interrupt handler - we can't call any virtual method from this method
   // Get the current time before we do anything else so the measurements are consistent
   const uint32_t now = micros();
-  auto &edge_state = sensor->edge_state_;
-  auto &state = sensor->state_;
+  auto &state = sensor->edge_state_;
+  auto &set = *sensor->set_;
 
-  if ((now - edge_state.last_sent_edge_us_) >= sensor->filter_us_) {
-    edge_state.last_sent_edge_us_ = now;
-    state.last_detected_edge_us_ = now;
-    state.last_rising_edge_us_ = now;
-    state.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  if ((now - state.last_sent_edge_us_) >= sensor->filter_us_) {
+    state.last_sent_edge_us_ = now;
+    set.last_detected_edge_us_ = now;
+    set.last_rising_edge_us_ = now;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // This ISR is bound to rising edges, so the pin is high
@@ -163,26 +160,26 @@ void IRAM_ATTR PulseMeterSensor::pulse_intr(PulseMeterSensor *sensor) {
   // Get the current time before we do anything else so the measurements are consistent
   const uint32_t now = micros();
   const bool pin_val = sensor->isr_pin_.digital_read();
-  auto &pulse_state = sensor->pulse_state_;
-  auto &state = sensor->state_;
+  auto &state = sensor->pulse_state_;
+  auto &set = *sensor->set_;
 
   // Filter length has passed since the last interrupt
-  const bool length = now - pulse_state.last_intr_ >= sensor->filter_us_;
+  const bool length = now - state.last_intr_ >= sensor->filter_us_;
 
-  if (length && pulse_state.latched_ && !sensor->last_pin_val_) {  // Long enough low edge
-    pulse_state.latched_ = false;
-  } else if (length && !pulse_state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
-    pulse_state.latched_ = true;
-    state.last_detected_edge_us_ = pulse_state.last_intr_;
-    state.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
+  if (length && state.latched_ && !sensor->last_pin_val_) {  // Long enough low edge
+    state.latched_ = false;
+  } else if (length && !state.latched_ && sensor->last_pin_val_) {  // Long enough high edge
+    state.latched_ = true;
+    set.last_detected_edge_us_ = state.last_intr_;
+    set.count_++;  // NOLINT(clang-diagnostic-deprecated-volatile)
   }
 
   // Due to order of operations this includes
   //    length && latched && rising   (just reset from a long low edge)
   //    !latched && (rising || high)  (noise on the line resetting the potential rising edge)
-  state.last_rising_edge_us_ = !pulse_state.latched_ && pin_val ? now : state.last_detected_edge_us_;
+  set.last_rising_edge_us_ = !state.latched_ && pin_val ? now : set.last_detected_edge_us_;
 
-  pulse_state.last_intr_ = now;
+  state.last_intr_ = now;
   sensor->last_pin_val_ = pin_val;
 }
 

esphome/components/pulse_meter/pulse_meter_sensor.h

@@ -46,16 +46,17 @@ class PulseMeterSensor : public sensor::Sensor, public Component {
   uint32_t total_pulses_ = 0;
   uint32_t last_processed_edge_us_ = 0;
 
-  // This struct and variable are used to pass data between the ISR and loop.
-  // The data from state_ is read and then count_ in state_ is reset in each loop.
-  // This must be done while guarded by an InterruptLock. Use this variable to send data
-  // from the ISR to the loop not the other way around (except for resetting count_).
+  // This struct (and the two pointers) are used to pass data between the ISR and loop.
+  // These two pointers are exchanged each loop.
+  // Use these to send data from the ISR to the loop not the other way around (except for resetting the values).
   struct State {
     uint32_t last_detected_edge_us_ = 0;
     uint32_t last_rising_edge_us_ = 0;
     uint32_t count_ = 0;
   };
-  volatile State state_{};
+  State state_[2];
+  volatile State *set_ = state_;
+  volatile State *get_ = state_ + 1;
 
   // Only use the following variables in the ISR or while guarded by an InterruptLock
   ISRInternalGPIOPin isr_pin_;

esphome/components/select/select.h

@@ -78,21 +78,23 @@ class Select : public EntityBase {
 
   void add_on_state_callback(std::function<void(size_t)> &&callback);
 
-  /** Set the value of the select by index, this is an optional virtual method.
-   *
-   * This method is called by the SelectCall when the index is already known.
-   * Default implementation converts to string and calls control().
-   * Override this to work directly with indices and avoid string conversions.
-   *
-   * @param index The index as validated by the SelectCall.
-   */
-  virtual void control(size_t index) { this->control(this->option_at(index)); }
-
  protected:
   friend class SelectCall;
 
   size_t active_index_{0};
 
+  /** Set the value of the select by index, this is an optional virtual method.
+   *
+   * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.
+   * Overriding this index-based version is PREFERRED as it avoids string conversions.
+   *
+   * This method is called by the SelectCall when the index is already known.
+   * Default implementation converts to string and calls control(const std::string&).
+   *
+   * @param index The index as validated by the SelectCall.
+   */
+  virtual void control(size_t index) { this->control(this->option_at(index)); }
+
   /** Set the value of the select, this is a virtual method that each select integration can implement.
    *
    * IMPORTANT: At least ONE of the two control() methods must be overridden by derived classes.

esphome/components/serial_proxy/__init__.py

@@ -0,0 +1,62 @@
+"""
+Serial Proxy component for ESPHome.
+
+WARNING: This component is EXPERIMENTAL. The API (both Python configuration
+and C++ interfaces) may change at any time without following the normal
+breaking changes policy. Use at your own risk.
+
+Once the API is considered stable, this warning will be removed.
+
+Provides a proxy to/from a serial interface on the ESPHome device, allowing
+Home Assistant to connect to the serial port and send/receive data to/from
+an arbitrary serial device.
+"""
+
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import uart
+import esphome.config_validation as cv
+from esphome.const import CONF_ID
+
+CODEOWNERS = ["@kbx81"]
+DEPENDENCIES = ["api", "uart"]
+
+MULTI_CONF = True
+
+serial_proxy_ns = cg.esphome_ns.namespace("serial_proxy")
+SerialProxy = serial_proxy_ns.class_("SerialProxy", cg.Component, uart.UARTDevice)
+
+CONF_RTS_PIN = "rts_pin"
+CONF_DTR_PIN = "dtr_pin"
+
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(SerialProxy),
+            cv.Optional(CONF_RTS_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_DTR_PIN): pins.gpio_output_pin_schema,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(uart.UART_DEVICE_SCHEMA)
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await uart.register_uart_device(var, config)
+    cg.add(cg.App.register_serial_proxy(var))
+    cg.add_define("USE_SERIAL_PROXY")
+
+    if CONF_RTS_PIN in config:
+        rts_pin = await cg.gpio_pin_expression(config[CONF_RTS_PIN])
+        cg.add(var.set_rts_pin(rts_pin))
+
+    if CONF_DTR_PIN in config:
+        dtr_pin = await cg.gpio_pin_expression(config[CONF_DTR_PIN])
+        cg.add(var.set_dtr_pin(dtr_pin))
+
+    # Request UART to wake the main loop when data arrives for low-latency processing
+    uart.request_wake_loop_on_rx()

esphome/components/serial_proxy/serial_proxy.cpp

@@ -0,0 +1,131 @@
+#include "serial_proxy.h"
+
+#ifdef USE_SERIAL_PROXY
+
+#include "esphome/core/log.h"
+
+#ifdef USE_API
+#include "esphome/components/api/api_server.h"
+#endif
+
+namespace esphome::serial_proxy {
+
+static const char *const TAG = "serial_proxy";
+
+void SerialProxy::setup() {
+  // Set up modem control pins if configured
+  if (this->rts_pin_ != nullptr) {
+    this->rts_pin_->setup();
+    this->rts_pin_->digital_write(this->rts_state_);
+  }
+  if (this->dtr_pin_ != nullptr) {
+    this->dtr_pin_->setup();
+    this->dtr_pin_->digital_write(this->dtr_state_);
+  }
+}
+
+void SerialProxy::loop() {
+  // Read available data from UART and forward to API clients
+  size_t available = this->available();
+  if (available == 0)
+    return;
+
+  // Read in chunks up to SERIAL_PROXY_MAX_READ_SIZE
+  uint8_t buffer[SERIAL_PROXY_MAX_READ_SIZE];
+  size_t to_read = std::min(available, sizeof(buffer));
+
+  if (!this->read_array(buffer, to_read))
+    return;
+
+#ifdef USE_API
+  if (api::global_api_server != nullptr) {
+    api::global_api_server->send_serial_proxy_data(this->instance_index_, buffer, to_read);
+  }
+#endif
+}
+
+void SerialProxy::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "Serial Proxy [%u]:\n"
+                "  RTS Pin: %s\n"
+                "  DTR Pin: %s",
+                this->instance_index_, this->rts_pin_ != nullptr ? "configured" : "not configured",
+                this->dtr_pin_ != nullptr ? "configured" : "not configured");
+}
+
+void SerialProxy::configure(uint32_t baudrate, bool flow_control, uint8_t parity, uint8_t stop_bits,
+                            uint8_t data_size) {
+  ESP_LOGD(TAG, "Configuring serial proxy [%u]: baud=%u, flow_ctrl=%s, parity=%u, stop=%u, data=%u",
+           this->instance_index_, baudrate, YESNO(flow_control), parity, stop_bits, data_size);
+
+  auto *uart_comp = this->parent_;
+  if (uart_comp == nullptr) {
+    ESP_LOGE(TAG, "UART component not available");
+    return;
+  }
+
+  // Apply UART parameters
+  uart_comp->set_baud_rate(baudrate);
+  uart_comp->set_stop_bits(stop_bits);
+  uart_comp->set_data_bits(data_size);
+
+  // Map parity enum to UARTParityOptions
+  switch (parity) {
+    case 0:
+      uart_comp->set_parity(uart::UART_CONFIG_PARITY_NONE);
+      break;
+    case 1:
+      uart_comp->set_parity(uart::UART_CONFIG_PARITY_EVEN);
+      break;
+    case 2:
+      uart_comp->set_parity(uart::UART_CONFIG_PARITY_ODD);
+      break;
+    default:
+      ESP_LOGW(TAG, "Unknown parity value: %u, using NONE", parity);
+      uart_comp->set_parity(uart::UART_CONFIG_PARITY_NONE);
+      break;
+  }
+
+    // Apply the new settings
+    // load_settings() is available on ESP8266 and ESP32 platforms
+#if defined(USE_ESP8266) || defined(USE_ESP32)
+  uart_comp->load_settings(true);
+#endif
+
+  // Note: Hardware flow control configuration is stored but not yet applied
+  // to the UART hardware - this requires additional platform support
+  (void) flow_control;
+}
+
+void SerialProxy::write(const uint8_t *data, size_t len) {
+  if (data == nullptr || len == 0)
+    return;
+  this->write_array(data, len);
+}
+
+void SerialProxy::set_modem_pins(bool rts, bool dtr) {
+  ESP_LOGV(TAG, "Setting modem pins [%u]: RTS=%s, DTR=%s", this->instance_index_, ONOFF(rts), ONOFF(dtr));
+
+  if (this->rts_pin_ != nullptr) {
+    this->rts_state_ = rts;
+    this->rts_pin_->digital_write(rts);
+  }
+  if (this->dtr_pin_ != nullptr) {
+    this->dtr_state_ = dtr;
+    this->dtr_pin_->digital_write(dtr);
+  }
+}
+
+void SerialProxy::get_modem_pins(bool &rts, bool &dtr) const {
+  rts = this->rts_state_;
+  dtr = this->dtr_state_;
+}
+
+void SerialProxy::flush_port() {
+  ESP_LOGV(TAG, "Flushing serial proxy [%u]", this->instance_index_);
+  this->flush();
+}
+
+}  // namespace esphome::serial_proxy
+
+#endif  // USE_SERIAL_PROXY

esphome/components/serial_proxy/serial_proxy.h

@@ -0,0 +1,80 @@
+#pragma once
+
+// WARNING: This component is EXPERIMENTAL. The API may change at any time
+// without following the normal breaking changes policy. Use at your own risk.
+// Once the API is considered stable, this warning will be removed.
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_SERIAL_PROXY
+
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/components/uart/uart.h"
+
+namespace esphome::serial_proxy {
+
+/// Maximum bytes to read from UART in a single loop iteration
+static constexpr size_t SERIAL_PROXY_MAX_READ_SIZE = 256;
+
+class SerialProxy : public uart::UARTDevice, public Component {
+ public:
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
+
+  /// Get the instance index (position in Application's serial_proxies_ vector)
+  uint32_t get_instance_index() const { return this->instance_index_; }
+
+  /// Set the instance index (called by Application::register_serial_proxy)
+  void set_instance_index(uint32_t index) { this->instance_index_ = index; }
+
+  /// Configure UART parameters and apply them
+  /// @param baudrate Baud rate in bits per second
+  /// @param flow_control True to enable hardware flow control
+  /// @param parity Parity setting (0=none, 1=even, 2=odd)
+  /// @param stop_bits Number of stop bits (1 or 2)
+  /// @param data_size Number of data bits (5-8)
+  void configure(uint32_t baudrate, bool flow_control, uint8_t parity, uint8_t stop_bits, uint8_t data_size);
+
+  /// Write data to the serial device
+  /// @param data Pointer to data buffer
+  /// @param len Number of bytes to write
+  void write(const uint8_t *data, size_t len);
+
+  /// Set modem pin states (RTS and DTR)
+  /// @param rts Desired RTS pin state
+  /// @param dtr Desired DTR pin state
+  void set_modem_pins(bool rts, bool dtr);
+
+  /// Get current modem pin states
+  /// @param[out] rts Current RTS pin state
+  /// @param[out] dtr Current DTR pin state
+  void get_modem_pins(bool &rts, bool &dtr) const;
+
+  /// Flush the serial port (block until all TX data is sent)
+  void flush_port();
+
+  /// Set the RTS GPIO pin (from YAML configuration)
+  void set_rts_pin(GPIOPin *pin) { this->rts_pin_ = pin; }
+
+  /// Set the DTR GPIO pin (from YAML configuration)
+  void set_dtr_pin(GPIOPin *pin) { this->dtr_pin_ = pin; }
+
+ protected:
+  /// Instance index for identifying this proxy in API messages
+  uint32_t instance_index_{0};
+
+  /// Optional GPIO pins for modem control
+  GPIOPin *rts_pin_{nullptr};
+  GPIOPin *dtr_pin_{nullptr};
+
+  /// Current modem pin states
+  bool rts_state_{false};
+  bool dtr_state_{false};
+};
+
+}  // namespace esphome::serial_proxy
+
+#endif  // USE_SERIAL_PROXY

esphome/components/speed/fan/__init__.py

@@ -25,7 +25,7 @@ CONFIG_SCHEMA = (
             cv.Optional(CONF_SPEED): cv.invalid(
                 "Configuring individual speeds is deprecated."
             ),
-            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=100): cv.int_range(min=1),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
     )

esphome/components/speed/fan/speed_fan.h

@@ -10,7 +10,7 @@ namespace speed {
 
 class SpeedFan : public Component, public fan::Fan {
  public:
-  SpeedFan(uint8_t speed_count) : speed_count_(speed_count) {}
+  SpeedFan(int speed_count) : speed_count_(speed_count) {}
   void setup() override;
   void dump_config() override;
   void set_output(output::FloatOutput *output) { this->output_ = output; }
@@ -26,7 +26,7 @@ class SpeedFan : public Component, public fan::Fan {
   output::FloatOutput *output_;
   output::BinaryOutput *oscillating_{nullptr};
   output::BinaryOutput *direction_{nullptr};
-  uint8_t speed_count_{};
+  int speed_count_{};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};
 };

esphome/components/template/fan/__init__.py

@@ -19,7 +19,7 @@ CONFIG_SCHEMA = (
         {
             cv.Optional(CONF_HAS_DIRECTION, default=False): cv.boolean,
             cv.Optional(CONF_HAS_OSCILLATING, default=False): cv.boolean,
-            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT): cv.int_range(min=1),
             cv.Optional(CONF_PRESET_MODES): validate_preset_modes,
         }
     )

esphome/components/template/fan/template_fan.h

@@ -12,7 +12,7 @@ class TemplateFan final : public Component, public fan::Fan {
   void dump_config() override;
   void set_has_direction(bool has_direction) { this->has_direction_ = has_direction; }
   void set_has_oscillating(bool has_oscillating) { this->has_oscillating_ = has_oscillating; }
-  void set_speed_count(uint8_t count) { this->speed_count_ = count; }
+  void set_speed_count(int count) { this->speed_count_ = count; }
   void set_preset_modes(std::initializer_list<const char *> presets) { this->preset_modes_ = presets; }
   fan::FanTraits get_traits() override { return this->traits_; }
 
@@ -21,7 +21,7 @@ class TemplateFan final : public Component, public fan::Fan {
 
   bool has_oscillating_{false};
   bool has_direction_{false};
-  uint8_t speed_count_{0};
+  int speed_count_{0};
   fan::FanTraits traits_;
   std::vector<const char *> preset_modes_{};
 };

esphome/components/time/posix_tz.cpp

@@ -1,481 +0,0 @@
-#include "esphome/core/defines.h"
-
-#ifdef USE_TIME_TIMEZONE
-
-#include "posix_tz.h"
-#include <cctype>
-
-namespace esphome::time {
-
-// Global timezone - set once at startup, rarely changes
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - intentional mutable state
-static ParsedTimezone global_tz_{};
-
-void set_global_tz(const ParsedTimezone &tz) { global_tz_ = tz; }
-
-const ParsedTimezone &get_global_tz() { return global_tz_; }
-
-namespace internal {
-
-// Helper to parse an unsigned integer from string, updating pointer
-static uint32_t parse_uint(const char *&p) {
-  uint32_t value = 0;
-  while (std::isdigit(static_cast<unsigned char>(*p))) {
-    value = value * 10 + (*p - '0');
-    p++;
-  }
-  return value;
-}
-
-bool is_leap_year(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }
-
-// Get days in year (avoids duplicate is_leap_year calls)
-static inline int days_in_year(int year) { return is_leap_year(year) ? 366 : 365; }
-
-// Convert days since epoch to year, updating days to remainder
-static int __attribute__((noinline)) days_to_year(int64_t &days) {
-  int year = 1970;
-  int diy;
-  while (days >= (diy = days_in_year(year))) {
-    days -= diy;
-    year++;
-  }
-  while (days < 0) {
-    year--;
-    days += days_in_year(year);
-  }
-  return year;
-}
-
-// Extract just the year from a UTC epoch
-static int epoch_to_year(time_t epoch) {
-  int64_t days = epoch / 86400;
-  if (epoch < 0 && epoch % 86400 != 0)
-    days--;
-  return days_to_year(days);
-}
-
-int days_in_month(int year, int month) {
-  switch (month) {
-    case 2:
-      return is_leap_year(year) ? 29 : 28;
-    case 4:
-    case 6:
-    case 9:
-    case 11:
-      return 30;
-    default:
-      return 31;
-  }
-}
-
-// Zeller-like algorithm for day of week (0 = Sunday)
-int __attribute__((noinline)) day_of_week(int year, int month, int day) {
-  // Adjust for January/February
-  if (month < 3) {
-    month += 12;
-    year--;
-  }
-  int k = year % 100;
-  int j = year / 100;
-  int h = (day + (13 * (month + 1)) / 5 + k + k / 4 + j / 4 - 2 * j) % 7;
-  // Convert from Zeller (0=Sat) to standard (0=Sun)
-  return ((h + 6) % 7);
-}
-
-void __attribute__((noinline)) epoch_to_tm_utc(time_t epoch, struct tm *out_tm) {
-  // Days since epoch
-  int64_t days = epoch / 86400;
-  int32_t remaining_secs = epoch % 86400;
-  if (remaining_secs < 0) {
-    days--;
-    remaining_secs += 86400;
-  }
-
-  out_tm->tm_sec = remaining_secs % 60;
-  remaining_secs /= 60;
-  out_tm->tm_min = remaining_secs % 60;
-  out_tm->tm_hour = remaining_secs / 60;
-
-  // Day of week (Jan 1, 1970 was Thursday = 4)
-  out_tm->tm_wday = static_cast<int>((days + 4) % 7);
-  if (out_tm->tm_wday < 0)
-    out_tm->tm_wday += 7;
-
-  // Calculate year (updates days to day-of-year)
-  int year = days_to_year(days);
-  out_tm->tm_year = year - 1900;
-  out_tm->tm_yday = static_cast<int>(days);
-
-  // Calculate month and day
-  int month = 1;
-  int dim;
-  while (days >= (dim = days_in_month(year, month))) {
-    days -= dim;
-    month++;
-  }
-
-  out_tm->tm_mon = month - 1;
-  out_tm->tm_mday = static_cast<int>(days) + 1;
-  out_tm->tm_isdst = 0;
-}
-
-bool skip_tz_name(const char *&p) {
-  if (*p == '<') {
-    // Angle-bracket quoted name: <+07>, <-03>, <AEST>
-    p++;  // skip '<'
-    while (*p && *p != '>') {
-      p++;
-    }
-    if (*p == '>') {
-      p++;  // skip '>'
-      return true;
-    }
-    return false;  // Unterminated
-  }
-
-  // Standard name: 3+ letters
-  const char *start = p;
-  while (*p && std::isalpha(static_cast<unsigned char>(*p))) {
-    p++;
-  }
-  return (p - start) >= 3;
-}
-
-int32_t __attribute__((noinline)) parse_offset(const char *&p) {
-  int sign = 1;
-  if (*p == '-') {
-    sign = -1;
-    p++;
-  } else if (*p == '+') {
-    p++;
-  }
-
-  int hours = parse_uint(p);
-  int minutes = 0;
-  int seconds = 0;
-
-  if (*p == ':') {
-    p++;
-    minutes = parse_uint(p);
-    if (*p == ':') {
-      p++;
-      seconds = parse_uint(p);
-    }
-  }
-
-  return sign * (hours * 3600 + minutes * 60 + seconds);
-}
-
-// Helper to parse the optional /time suffix (reuses parse_offset logic)
-static void parse_transition_time(const char *&p, DSTRule &rule) {
-  rule.time_seconds = 2 * 3600;  // Default 02:00
-  if (*p == '/') {
-    p++;
-    rule.time_seconds = parse_offset(p);
-  }
-}
-
-void __attribute__((noinline)) julian_to_month_day(int julian_day, int &out_month, int &out_day) {
-  // J format: day 1-365, Feb 29 is NOT counted even in leap years
-  // So day 60 is always March 1
-  // Iterate forward through months (no array needed)
-  int remaining = julian_day;
-  out_month = 1;
-  while (out_month <= 12) {
-    // Days in month for non-leap year (J format ignores leap years)
-    int dim = days_in_month(2001, out_month);  // 2001 is non-leap year
-    if (remaining <= dim) {
-      out_day = remaining;
-      return;
-    }
-    remaining -= dim;
-    out_month++;
-  }
-  out_day = remaining;
-}
-
-void __attribute__((noinline)) day_of_year_to_month_day(int day_of_year, int year, int &out_month, int &out_day) {
-  // Plain format: day 0-365, Feb 29 IS counted in leap years
-  // Day 0 = Jan 1
-  int remaining = day_of_year;
-  out_month = 1;
-
-  while (out_month <= 12) {
-    int days_this_month = days_in_month(year, out_month);
-    if (remaining < days_this_month) {
-      out_day = remaining + 1;
-      return;
-    }
-    remaining -= days_this_month;
-    out_month++;
-  }
-
-  // Shouldn't reach here with valid input
-  out_month = 12;
-  out_day = 31;
-}
-
-bool parse_dst_rule(const char *&p, DSTRule &rule) {
-  rule = {};  // Zero initialize
-
-  if (*p == 'M' || *p == 'm') {
-    // M format: Mm.w.d (month.week.day)
-    rule.type = DSTRuleType::MONTH_WEEK_DAY;
-    p++;
-
-    rule.month = parse_uint(p);
-    if (rule.month < 1 || rule.month > 12)
-      return false;
-
-    if (*p++ != '.')
-      return false;
-
-    rule.week = parse_uint(p);
-    if (rule.week < 1 || rule.week > 5)
-      return false;
-
-    if (*p++ != '.')
-      return false;
-
-    rule.day_of_week = parse_uint(p);
-    if (rule.day_of_week > 6)
-      return false;
-
-  } else if (*p == 'J' || *p == 'j') {
-    // J format: Jn (Julian day 1-365, not counting Feb 29)
-    rule.type = DSTRuleType::JULIAN_NO_LEAP;
-    p++;
-
-    rule.day = parse_uint(p);
-    if (rule.day < 1 || rule.day > 365)
-      return false;
-
-  } else if (std::isdigit(static_cast<unsigned char>(*p))) {
-    // Plain number format: n (day 0-365, counting Feb 29)
-    rule.type = DSTRuleType::DAY_OF_YEAR;
-
-    rule.day = parse_uint(p);
-    if (rule.day > 365)
-      return false;
-
-  } else {
-    return false;
-  }
-
-  // Parse optional /time suffix
-  parse_transition_time(p, rule);
-
-  return true;
-}
-
-// Calculate days from Jan 1 of given year to given month/day
-static int __attribute__((noinline)) days_from_year_start(int year, int month, int day) {
-  int days = day - 1;
-  for (int m = 1; m < month; m++) {
-    days += days_in_month(year, m);
-  }
-  return days;
-}
-
-// Calculate days from epoch to Jan 1 of given year (for DST transition calculations)
-// Only supports years >= 1970. Timezone is either compiled in from YAML or set by
-// Home Assistant, so pre-1970 dates are not a concern.
-static int64_t __attribute__((noinline)) days_to_year_start(int year) {
-  int64_t days = 0;
-  for (int y = 1970; y < year; y++) {
-    days += days_in_year(y);
-  }
-  return days;
-}
-
-time_t __attribute__((noinline)) calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds) {
-  int month, day;
-
-  switch (rule.type) {
-    case DSTRuleType::MONTH_WEEK_DAY: {
-      // Find the nth occurrence of day_of_week in the given month
-      int first_dow = day_of_week(year, rule.month, 1);
-
-      // Days until first occurrence of target day
-      int days_until_first = (rule.day_of_week - first_dow + 7) % 7;
-      int first_occurrence = 1 + days_until_first;
-
-      if (rule.week == 5) {
-        // "Last" occurrence - find the last one in the month
-        int dim = days_in_month(year, rule.month);
-        day = first_occurrence;
-        while (day + 7 <= dim) {
-          day += 7;
-        }
-      } else {
-        // nth occurrence
-        day = first_occurrence + (rule.week - 1) * 7;
-      }
-      month = rule.month;
-      break;
-    }
-
-    case DSTRuleType::JULIAN_NO_LEAP:
-      // J format: day 1-365, Feb 29 not counted
-      julian_to_month_day(rule.day, month, day);
-      break;
-
-    case DSTRuleType::DAY_OF_YEAR:
-      // Plain format: day 0-365, Feb 29 counted
-      day_of_year_to_month_day(rule.day, year, month, day);
-      break;
-
-    case DSTRuleType::NONE:
-      // Should never be called with NONE, but handle it gracefully
-      month = 1;
-      day = 1;
-      break;
-  }
-
-  // Calculate days from epoch to this date
-  int64_t days = days_to_year_start(year) + days_from_year_start(year, month, day);
-
-  // Convert to epoch and add transition time and base offset
-  return days * 86400 + rule.time_seconds + base_offset_seconds;
-}
-
-}  // namespace internal
-
-bool __attribute__((noinline)) is_in_dst(time_t utc_epoch, const ParsedTimezone &tz) {
-  if (!tz.has_dst()) {
-    return false;
-  }
-
-  int year = internal::epoch_to_year(utc_epoch);
-
-  // Calculate DST start and end for this year
-  // DST start transition happens in standard time
-  time_t dst_start = internal::calculate_dst_transition(year, tz.dst_start, tz.std_offset_seconds);
-  // DST end transition happens in daylight time
-  time_t dst_end = internal::calculate_dst_transition(year, tz.dst_end, tz.dst_offset_seconds);
-
-  if (dst_start < dst_end) {
-    // Northern hemisphere: DST is between start and end
-    return (utc_epoch >= dst_start && utc_epoch < dst_end);
-  } else {
-    // Southern hemisphere: DST is outside the range (wraps around year)
-    return (utc_epoch >= dst_start || utc_epoch < dst_end);
-  }
-}
-
-bool parse_posix_tz(const char *tz_string, ParsedTimezone &result) {
-  if (!tz_string || !*tz_string) {
-    return false;
-  }
-
-  const char *p = tz_string;
-
-  // Initialize result (dst_start/dst_end default to type=NONE, so has_dst() returns false)
-  result.std_offset_seconds = 0;
-  result.dst_offset_seconds = 0;
-  result.dst_start = {};
-  result.dst_end = {};
-
-  // Skip standard timezone name
-  if (!internal::skip_tz_name(p)) {
-    return false;
-  }
-
-  // Parse standard offset (required)
-  if (!*p || (!std::isdigit(static_cast<unsigned char>(*p)) && *p != '+' && *p != '-')) {
-    return false;
-  }
-  result.std_offset_seconds = internal::parse_offset(p);
-
-  // Check for DST name
-  if (!*p) {
-    return true;  // No DST
-  }
-
-  // If next char is comma, there's no DST name but there are rules (invalid)
-  if (*p == ',') {
-    return false;
-  }
-
-  // Check if there's something that looks like a DST name start
-  // (letter or angle bracket). If not, treat as trailing garbage and return success.
-  if (!std::isalpha(static_cast<unsigned char>(*p)) && *p != '<') {
-    return true;  // No DST, trailing characters ignored
-  }
-
-  if (!internal::skip_tz_name(p)) {
-    return false;  // Invalid DST name (started but malformed)
-  }
-
-  // Optional DST offset (default is std - 1 hour)
-  if (*p && *p != ',' && (std::isdigit(static_cast<unsigned char>(*p)) || *p == '+' || *p == '-')) {
-    result.dst_offset_seconds = internal::parse_offset(p);
-  } else {
-    result.dst_offset_seconds = result.std_offset_seconds - 3600;
-  }
-
-  // Parse DST rules (required when DST name is present)
-  if (*p != ',') {
-    // DST name without rules - treat as no DST since we can't determine transitions
-    return true;
-  }
-
-  p++;
-  if (!internal::parse_dst_rule(p, result.dst_start)) {
-    return false;
-  }
-
-  // Second rule is required per POSIX
-  if (*p != ',') {
-    return false;
-  }
-  p++;
-  // has_dst() now returns true since dst_start.type was set by parse_dst_rule
-  return internal::parse_dst_rule(p, result.dst_end);
-}
-
-bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm) {
-  if (!out_tm) {
-    return false;
-  }
-
-  // Determine DST status once (avoids duplicate is_in_dst calculation)
-  bool in_dst = is_in_dst(utc_epoch, tz);
-  int32_t offset = in_dst ? tz.dst_offset_seconds : tz.std_offset_seconds;
-
-  // Apply offset (POSIX offset is positive west, so subtract to get local)
-  time_t local_epoch = utc_epoch - offset;
-
-  internal::epoch_to_tm_utc(local_epoch, out_tm);
-  out_tm->tm_isdst = in_dst ? 1 : 0;
-
-  return true;
-}
-
-}  // namespace esphome::time
-
-#ifndef USE_HOST
-// Override libc's localtime functions to use our timezone on embedded platforms.
-// This allows user lambdas calling ::localtime() to get correct local time
-// without needing the TZ environment variable (which pulls in scanf bloat).
-// On host, we use the normal TZ mechanism since there's no memory constraint.
-
-// Thread-safe version
-extern "C" struct tm *localtime_r(const time_t *timer, struct tm *result) {
-  if (timer == nullptr || result == nullptr) {
-    return nullptr;
-  }
-  esphome::time::epoch_to_local_tm(*timer, esphome::time::get_global_tz(), result);
-  return result;
-}
-
-// Non-thread-safe version (uses static buffer, standard libc behavior)
-extern "C" struct tm *localtime(const time_t *timer) {
-  // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-  static struct tm localtime_buf;
-  return localtime_r(timer, &localtime_buf);
-}
-#endif  // !USE_HOST
-
-#endif  // USE_TIME_TIMEZONE

esphome/components/time/posix_tz.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#ifdef USE_TIME_TIMEZONE
-
-#include <cstdint>
-#include <ctime>
-
-namespace esphome::time {
-
-/// Type of DST transition rule
-enum class DSTRuleType : uint8_t {
-  NONE = 0,        ///< No DST rule (used to indicate no DST)
-  MONTH_WEEK_DAY,  ///< M format: Mm.w.d (e.g., M3.2.0 = 2nd Sunday of March)
-  JULIAN_NO_LEAP,  ///< J format: Jn (day 1-365, Feb 29 not counted)
-  DAY_OF_YEAR,     ///< Plain number: n (day 0-365, Feb 29 counted in leap years)
-};
-
-/// Rule for DST transition (packed for 32-bit: 12 bytes)
-struct DSTRule {
-  int32_t time_seconds;  ///< Seconds after midnight (default 7200 = 2:00 AM)
-  uint16_t day;          ///< Day of year (for JULIAN_NO_LEAP and DAY_OF_YEAR)
-  DSTRuleType type;      ///< Type of rule
-  uint8_t month;         ///< Month 1-12 (for MONTH_WEEK_DAY)
-  uint8_t week;          ///< Week 1-5, 5 = last (for MONTH_WEEK_DAY)
-  uint8_t day_of_week;   ///< Day 0-6, 0 = Sunday (for MONTH_WEEK_DAY)
-};
-
-/// Parsed POSIX timezone information (packed for 32-bit: 32 bytes)
-struct ParsedTimezone {
-  int32_t std_offset_seconds;  ///< Standard time offset from UTC in seconds (positive = west)
-  int32_t dst_offset_seconds;  ///< DST offset from UTC in seconds
-  DSTRule dst_start;           ///< When DST starts
-  DSTRule dst_end;             ///< When DST ends
-
-  /// Check if this timezone has DST rules
-  bool has_dst() const { return this->dst_start.type != DSTRuleType::NONE; }
-};
-
-/// Parse a POSIX TZ string into a ParsedTimezone struct.
-/// Supports formats like:
-///   - "EST5" (simple offset, no DST)
-///   - "EST5EDT,M3.2.0,M11.1.0" (with DST, M-format rules)
-///   - "CST6CDT,M3.2.0/2,M11.1.0/2" (with transition times)
-///   - "<+07>-7" (angle-bracket notation for special names)
-///   - "IST-5:30" (half-hour offsets)
-///   - "EST5EDT,J60,J300" (J-format: Julian day without leap day)
-///   - "EST5EDT,60,300" (plain day number: day of year with leap day)
-/// @param tz_string The POSIX TZ string to parse
-/// @param result Output: the parsed timezone data
-/// @return true if parsing succeeded, false on error
-bool parse_posix_tz(const char *tz_string, ParsedTimezone &result);
-
-/// Convert a UTC epoch to local time using the parsed timezone.
-/// This replaces libc's localtime() to avoid scanf dependency.
-/// @param utc_epoch Unix timestamp in UTC
-/// @param tz The parsed timezone
-/// @param[out] out_tm Output tm struct with local time
-/// @return true on success
-bool epoch_to_local_tm(time_t utc_epoch, const ParsedTimezone &tz, struct tm *out_tm);
-
-/// Set the global timezone used by epoch_to_local_tm() when called without a timezone.
-/// This is called by RealTimeClock::apply_timezone_() to enable ESPTime::from_epoch_local()
-/// to work without libc's localtime().
-void set_global_tz(const ParsedTimezone &tz);
-
-/// Get the global timezone.
-const ParsedTimezone &get_global_tz();
-
-/// Check if a given UTC epoch falls within DST for the parsed timezone.
-/// @param utc_epoch Unix timestamp in UTC
-/// @param tz The parsed timezone
-/// @return true if DST is in effect at the given time
-bool is_in_dst(time_t utc_epoch, const ParsedTimezone &tz);
-
-// Internal helper functions exposed for testing
-
-namespace internal {
-
-/// Skip a timezone name (letters or <...> quoted format)
-/// @param p Pointer to current position, updated on return
-/// @return true if a valid name was found
-bool skip_tz_name(const char *&p);
-
-/// Parse an offset in format [-]hh[:mm[:ss]]
-/// @param p Pointer to current position, updated on return
-/// @return Offset in seconds
-int32_t parse_offset(const char *&p);
-
-/// Parse a DST rule in format Mm.w.d[/time], Jn[/time], or n[/time]
-/// @param p Pointer to current position, updated on return
-/// @param rule Output: the parsed rule
-/// @return true if parsing succeeded
-bool parse_dst_rule(const char *&p, DSTRule &rule);
-
-/// Convert Julian day (J format, 1-365 not counting Feb 29) to month/day
-/// @param julian_day Day number 1-365
-/// @param[out] month Output: month 1-12
-/// @param[out] day Output: day of month
-void julian_to_month_day(int julian_day, int &month, int &day);
-
-/// Convert day of year (plain format, 0-365 counting Feb 29) to month/day
-/// @param day_of_year Day number 0-365
-/// @param year The year (for leap year calculation)
-/// @param[out] month Output: month 1-12
-/// @param[out] day Output: day of month
-void day_of_year_to_month_day(int day_of_year, int year, int &month, int &day);
-
-/// Calculate day of week for any date (0 = Sunday)
-/// Uses a simplified algorithm that works for years 1970-2099
-int day_of_week(int year, int month, int day);
-
-/// Get the number of days in a month
-int days_in_month(int year, int month);
-
-/// Check if a year is a leap year
-bool is_leap_year(int year);
-
-/// Convert epoch to year/month/day/hour/min/sec (UTC)
-void epoch_to_tm_utc(time_t epoch, struct tm *out_tm);
-
-/// Calculate the epoch timestamp for a DST transition in a given year.
-/// @param year The year (e.g., 2026)
-/// @param rule The DST rule (month, week, day_of_week, time)
-/// @param base_offset_seconds The timezone offset to apply (std or dst depending on context)
-/// @return Unix epoch timestamp of the transition
-time_t calculate_dst_transition(int year, const DSTRule &rule, int32_t base_offset_seconds);
-
-}  // namespace internal
-
-}  // namespace esphome::time
-
-#endif  // USE_TIME_TIMEZONE

esphome/components/time/real_time_clock.cpp

@@ -14,8 +14,8 @@
 #include <sys/time.h>
 #endif
 #include <cerrno>
+
 #include <cinttypes>
-#include <cstdlib>
 
 namespace esphome::time {
 
@@ -23,33 +23,9 @@ static const char *const TAG = "time";
 
 RealTimeClock::RealTimeClock() = default;
 
-ESPTime __attribute__((noinline)) RealTimeClock::now() {
-#ifdef USE_TIME_TIMEZONE
-  time_t epoch = this->timestamp_now();
-  struct tm local_tm;
-  if (epoch_to_local_tm(epoch, get_global_tz(), &local_tm)) {
-    return ESPTime::from_c_tm(&local_tm, epoch);
-  }
-  // Fallback to UTC if parsing failed
-  return ESPTime::from_epoch_utc(epoch);
-#else
-  return ESPTime::from_epoch_local(this->timestamp_now());
-#endif
-}
-
 void RealTimeClock::dump_config() {
 #ifdef USE_TIME_TIMEZONE
-  const auto &tz = get_global_tz();
-  // POSIX offset is positive west, negate for conventional UTC+X display
-  int std_h = -tz.std_offset_seconds / 3600;
-  int std_m = (std::abs(tz.std_offset_seconds) % 3600) / 60;
-  if (tz.has_dst()) {
-    int dst_h = -tz.dst_offset_seconds / 3600;
-    int dst_m = (std::abs(tz.dst_offset_seconds) % 3600) / 60;
-    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d (DST UTC%+d:%02d)", std_h, std_m, dst_h, dst_m);
-  } else {
-    ESP_LOGCONFIG(TAG, "Timezone: UTC%+d:%02d", std_h, std_m);
-  }
+  ESP_LOGCONFIG(TAG, "Timezone: '%s'", this->timezone_.c_str());
 #endif
   auto time = this->now();
   ESP_LOGCONFIG(TAG, "Current time: %04d-%02d-%02d %02d:%02d:%02d", time.year, time.month, time.day_of_month, time.hour,
@@ -96,6 +72,11 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
     ret = settimeofday(&timev, nullptr);
   }
 
+#ifdef USE_TIME_TIMEZONE
+  // Move timezone back to local timezone.
+  this->apply_timezone_();
+#endif
+
   if (ret != 0) {
     ESP_LOGW(TAG, "setimeofday() failed with code %d", ret);
   }
@@ -108,29 +89,9 @@ void RealTimeClock::synchronize_epoch_(uint32_t epoch) {
 }
 
 #ifdef USE_TIME_TIMEZONE
-void RealTimeClock::apply_timezone_(const char *tz) {
-  ParsedTimezone parsed{};
-
-  // Handle null or empty input - use UTC
-  if (tz == nullptr || *tz == '\0') {
-    set_global_tz(parsed);
-    return;
-  }
-
-#ifdef USE_HOST
-  // On host platform, also set TZ environment variable for libc compatibility
-  setenv("TZ", tz, 1);
+void RealTimeClock::apply_timezone_() {
+  setenv("TZ", this->timezone_.c_str(), 1);
   tzset();
-#endif
-
-  // Parse the POSIX TZ string using our custom parser
-  if (!parse_posix_tz(tz, parsed)) {
-    ESP_LOGW(TAG, "Failed to parse timezone: %s", tz);
-    // parsed stays as default (UTC) on failure
-  }
-
-  // Set global timezone for all time conversions
-  set_global_tz(parsed);
 }
 #endif
 

esphome/components/time/real_time_clock.h

@@ -6,9 +6,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/time.h"
-#ifdef USE_TIME_TIMEZONE
-#include "posix_tz.h"
-#endif
 
 namespace esphome::time {
 
@@ -23,31 +20,26 @@ class RealTimeClock : public PollingComponent {
   explicit RealTimeClock();
 
 #ifdef USE_TIME_TIMEZONE
-  /// Set the time zone from a POSIX TZ string.
-  void set_timezone(const char *tz) { this->apply_timezone_(tz); }
-
-  /// Set the time zone from a character buffer with known length.
-  /// The buffer does not need to be null-terminated.
-  void set_timezone(const char *tz, size_t len) {
-    if (tz == nullptr) {
-      this->apply_timezone_(nullptr);
-      return;
-    }
-    // Stack buffer - TZ strings from tzdata are typically short (< 50 chars)
-    char buf[128];
-    if (len >= sizeof(buf))
-      len = sizeof(buf) - 1;
-    memcpy(buf, tz, len);
-    buf[len] = '\0';
-    this->apply_timezone_(buf);
+  /// Set the time zone.
+  void set_timezone(const std::string &tz) {
+    this->timezone_ = tz;
+    this->apply_timezone_();
   }
 
-  /// Set the time zone from a std::string.
-  void set_timezone(const std::string &tz) { this->apply_timezone_(tz.c_str()); }
+  /// Set the time zone from raw buffer, only if it differs from the current one.
+  void set_timezone(const char *tz, size_t len) {
+    if (this->timezone_.length() != len || memcmp(this->timezone_.c_str(), tz, len) != 0) {
+      this->timezone_.assign(tz, len);
+      this->apply_timezone_();
+    }
+  }
+
+  /// Get the time zone currently in use.
+  std::string get_timezone() { return this->timezone_; }
 #endif
 
   /// Get the time in the currently defined timezone.
-  ESPTime now();
+  ESPTime now() { return ESPTime::from_epoch_local(this->timestamp_now()); }
 
   /// Get the time without any time zone or DST corrections.
   ESPTime utcnow() { return ESPTime::from_epoch_utc(this->timestamp_now()); }
@@ -66,7 +58,8 @@ class RealTimeClock : public PollingComponent {
   void synchronize_epoch_(uint32_t epoch);
 
 #ifdef USE_TIME_TIMEZONE
-  void apply_timezone_(const char *tz);
+  std::string timezone_{};
+  void apply_timezone_();
 #endif
 
   LazyCallbackManager<void()> time_sync_callback_;

esphome/components/tuya/fan/__init__.py

@@ -22,7 +22,7 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_SPEED_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_SWITCH_DATAPOINT): cv.uint8_t,
             cv.Optional(CONF_DIRECTION_DATAPOINT): cv.uint8_t,
-            cv.Optional(CONF_SPEED_COUNT, default=3): cv.int_range(min=1, max=255),
+            cv.Optional(CONF_SPEED_COUNT, default=3): cv.int_range(min=1, max=256),
         }
     )
     .extend(cv.COMPONENT_SCHEMA),

esphome/components/tuya/fan/tuya_fan.h

@@ -9,7 +9,7 @@ namespace tuya {
 
 class TuyaFan : public Component, public fan::Fan {
  public:
-  TuyaFan(Tuya *parent, uint8_t speed_count) : parent_(parent), speed_count_(speed_count) {}
+  TuyaFan(Tuya *parent, int speed_count) : parent_(parent), speed_count_(speed_count) {}
   void setup() override;
   void dump_config() override;
   void set_speed_id(uint8_t speed_id) { this->speed_id_ = speed_id; }
@@ -27,7 +27,7 @@ class TuyaFan : public Component, public fan::Fan {
   optional<uint8_t> switch_id_{};
   optional<uint8_t> oscillation_id_{};
   optional<uint8_t> direction_id_{};
-  uint8_t speed_count_{};
+  int speed_count_{};
   TuyaDatapointType speed_type_{};
   TuyaDatapointType oscillation_type_{};
 };

esphome/components/uart/uart_component_esp_idf.cpp

@@ -90,6 +90,7 @@ void IDFUARTComponent::setup() {
     return;
   }
   this->uart_num_ = static_cast<uart_port_t>(next_uart_num++);
+  this->lock_ = xSemaphoreCreateMutex();
 
 #if (SOC_UART_LP_NUM >= 1)
   size_t fifo_len = ((this->uart_num_ < SOC_UART_HP_NUM) ? SOC_UART_FIFO_LEN : SOC_LP_UART_FIFO_LEN);
@@ -101,7 +102,11 @@ void IDFUARTComponent::setup() {
     this->rx_buffer_size_ = fifo_len * 2;
   }
 
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
+
   this->load_settings(false);
+
+  xSemaphoreGive(this->lock_);
 }
 
 void IDFUARTComponent::load_settings(bool dump_config) {
@@ -121,20 +126,13 @@ void IDFUARTComponent::load_settings(bool dump_config) {
       return;
     }
   }
-#ifdef USE_UART_WAKE_LOOP_ON_RX
-  constexpr int event_queue_size = 20;
-  QueueHandle_t *event_queue_ptr = &this->uart_event_queue_;
-#else
-  constexpr int event_queue_size = 0;
-  QueueHandle_t *event_queue_ptr = nullptr;
-#endif
   err = uart_driver_install(this->uart_num_,        // UART number
                             this->rx_buffer_size_,  // RX ring buffer size
-                            0,  // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
-                                // block task until all data has been sent out
-                            event_queue_size,  // event queue size/depth
-                            event_queue_ptr,   // event queue
-                            0                  // Flags used to allocate the interrupt
+                            0,   // TX ring buffer size. If zero, driver will not use a TX buffer and TX function will
+                                 // block task until all data has been sent out
+                            20,  // event queue size/depth
+                            &this->uart_event_queue_,  // event queue
+                            0                          // Flags used to allocate the interrupt
   );
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_driver_install failed: %s", esp_err_to_name(err));
@@ -284,7 +282,9 @@ void IDFUARTComponent::set_rx_timeout(size_t rx_timeout) {
 }
 
 void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   int32_t write_len = uart_write_bytes(this->uart_num_, data, len);
+  xSemaphoreGive(this->lock_);
   if (write_len != (int32_t) len) {
     ESP_LOGW(TAG, "uart_write_bytes failed: %d != %zu", write_len, len);
     this->mark_failed();
@@ -299,6 +299,7 @@ void IDFUARTComponent::write_array(const uint8_t *data, size_t len) {
 bool IDFUARTComponent::peek_byte(uint8_t *data) {
   if (!this->check_read_timeout_())
     return false;
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   if (this->has_peek_) {
     *data = this->peek_byte_;
   } else {
@@ -310,6 +311,7 @@ bool IDFUARTComponent::peek_byte(uint8_t *data) {
       this->peek_byte_ = *data;
     }
   }
+  xSemaphoreGive(this->lock_);
   return true;
 }
 
@@ -318,6 +320,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   int32_t read_len = 0;
   if (!this->check_read_timeout_(len))
     return false;
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   if (this->has_peek_) {
     length_to_read--;
     *data = this->peek_byte_;
@@ -326,6 +329,7 @@ bool IDFUARTComponent::read_array(uint8_t *data, size_t len) {
   }
   if (length_to_read > 0)
     read_len = uart_read_bytes(this->uart_num_, data, length_to_read, 20 / portTICK_PERIOD_MS);
+  xSemaphoreGive(this->lock_);
 #ifdef USE_UART_DEBUGGER
   for (size_t i = 0; i < len; i++) {
     this->debug_callback_.call(UART_DIRECTION_RX, data[i]);
@@ -338,7 +342,9 @@ size_t IDFUARTComponent::available() {
   size_t available = 0;
   esp_err_t err;
 
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   err = uart_get_buffered_data_len(this->uart_num_, &available);
+  xSemaphoreGive(this->lock_);
 
   if (err != ESP_OK) {
     ESP_LOGW(TAG, "uart_get_buffered_data_len failed: %s", esp_err_to_name(err));
@@ -352,7 +358,9 @@ size_t IDFUARTComponent::available() {
 
 void IDFUARTComponent::flush() {
   ESP_LOGVV(TAG, "    Flushing");
+  xSemaphoreTake(this->lock_, portMAX_DELAY);
   uart_wait_tx_done(this->uart_num_, portMAX_DELAY);
+  xSemaphoreGive(this->lock_);
 }
 
 void IDFUARTComponent::check_logger_conflict() {}
@@ -376,13 +384,6 @@ void IDFUARTComponent::start_rx_event_task_() {
   ESP_LOGV(TAG, "RX event task started");
 }
 
-// FreeRTOS task that relays UART ISR events to the main loop.
-// This task exists because wake_loop_threadsafe() is not ISR-safe (it uses a
-// UDP loopback socket), so we need a task as an ISR-to-main-loop trampoline.
-// IMPORTANT: This task must NOT call any UART wrapper methods (read_array,
-// write_array, peek_byte, etc.) or touch has_peek_/peek_byte_ — all reading
-// is done by the main loop. This task only reads from the event queue and
-// calls App.wake_loop_threadsafe().
 void IDFUARTComponent::rx_event_task_func(void *param) {
   auto *self = static_cast<IDFUARTComponent *>(param);
   uart_event_t event;
@@ -404,14 +405,8 @@ void IDFUARTComponent::rx_event_task_func(void *param) {
 
         case UART_FIFO_OVF:
         case UART_BUFFER_FULL:
-          // Don't call uart_flush_input() here — this task does not own the read side.
-          // ESP-IDF examples flush on overflow because the same task handles both events
-          // and reads, so flush and read are serialized. Here, reads happen on the main
-          // loop, so flushing from this task races with read_array() and can destroy data
-          // mid-read. The driver self-heals without an explicit flush: uart_read_bytes()
-          // calls uart_check_buf_full() after each chunk, which moves stashed FIFO bytes
-          // into the ring buffer and re-enables RX interrupts once space is freed.
-          ESP_LOGW(TAG, "FIFO overflow or ring buffer full");
+          ESP_LOGW(TAG, "FIFO overflow or ring buffer full - clearing");
+          uart_flush_input(self->uart_num_);
 #if defined(USE_SOCKET_SELECT_SUPPORT) && defined(USE_WAKE_LOOP_THREADSAFE)
           App.wake_loop_threadsafe();
 #endif

esphome/components/uart/uart_component_esp_idf.h

@@ -8,13 +8,6 @@
 
 namespace esphome::uart {
 
-/// ESP-IDF UART driver wrapper.
-///
-/// Thread safety: All public methods must only be called from the main loop.
-/// The ESP-IDF UART driver API does not guarantee thread safety, and ESPHome's
-/// peek byte state (has_peek_/peek_byte_) is not synchronized. The rx_event_task
-/// (when enabled) must not call any of these methods — it communicates with the
-/// main loop exclusively via App.wake_loop_threadsafe().
 class IDFUARTComponent : public UARTComponent, public Component {
  public:
   void setup() override;
@@ -33,9 +26,7 @@ class IDFUARTComponent : public UARTComponent, public Component {
   void flush() override;
 
   uint8_t get_hw_serial_number() { return this->uart_num_; }
-#ifdef USE_UART_WAKE_LOOP_ON_RX
   QueueHandle_t *get_uart_event_queue() { return &this->uart_event_queue_; }
-#endif
 
   /**
    * Load the UART with the current settings.
@@ -55,20 +46,18 @@ class IDFUARTComponent : public UARTComponent, public Component {
  protected:
   void check_logger_conflict() override;
   uart_port_t uart_num_;
+  QueueHandle_t uart_event_queue_;
   uart_config_t get_config_();
+  SemaphoreHandle_t lock_;
 
   bool has_peek_{false};
   uint8_t peek_byte_;
 
 #ifdef USE_UART_WAKE_LOOP_ON_RX
-  // RX notification support — runs on a separate FreeRTOS task.
-  // IMPORTANT: rx_event_task_func must NOT call any UART wrapper methods (read_array,
-  // write_array, etc.) or touch has_peek_/peek_byte_. It must only read from the
-  // event queue and call App.wake_loop_threadsafe().
+  // RX notification support
   void start_rx_event_task_();
   static void rx_event_task_func(void *param);
 
-  QueueHandle_t uart_event_queue_;
   TaskHandle_t rx_event_task_handle_{nullptr};
 #endif  // USE_UART_WAKE_LOOP_ON_RX
 };

esphome/components/usb_host/usb_host.h

@@ -148,7 +148,6 @@ class USBClient : public Component {
   EventPool<UsbEvent, USB_EVENT_QUEUE_SIZE> event_pool;
 
  protected:
-  void handle_open_state_();
   TransferRequest *get_trq_();  // Lock-free allocation using atomic bitmask (multi-consumer safe)
   virtual void disconnect();
   virtual void on_connected() {}

esphome/components/usb_host/usb_host_client.cpp

@@ -9,7 +9,6 @@
 #include <cinttypes>
 #include <cstring>
 #include <atomic>
-#include <span>
 namespace esphome {
 namespace usb_host {
 
@@ -143,23 +142,18 @@ static void usb_client_print_config_descriptor(const usb_config_desc_t *cfg_desc
   } while (next_desc != NULL);
 }
 #endif
-// USB string descriptors: bLength (uint8_t, max 255) includes 2-byte header (bLength + bDescriptorType).
-// Character count = (bLength - 2) / 2, max 126 chars + null terminator.
-static constexpr size_t DESC_STRING_BUF_SIZE = 128;
-
-static const char *get_descriptor_string(const usb_str_desc_t *desc, std::span<char, DESC_STRING_BUF_SIZE> buffer) {
-  if (desc == nullptr || desc->bLength < 2)
+static std::string get_descriptor_string(const usb_str_desc_t *desc) {
+  char buffer[256];
+  if (desc == nullptr)
     return "(unspecified)";
-  int char_count = (desc->bLength - 2) / 2;
-  char *p = buffer.data();
-  char *end = p + buffer.size() - 1;
-  for (int i = 0; i != char_count && p < end; i++) {
+  char *p = buffer;
+  for (int i = 0; i != desc->bLength / 2; i++) {
     auto c = desc->wData[i];
     if (c < 0x100)
       *p++ = static_cast<char>(c);
   }
   *p = '\0';
-  return buffer.data();
+  return {buffer};
 }
 
 // CALLBACK CONTEXT: USB task (called from usb_host_client_handle_events in USB task)
@@ -265,63 +259,60 @@ void USBClient::loop() {
     ESP_LOGW(TAG, "Dropped %u USB events due to queue overflow", dropped);
   }
 
-  if (this->state_ == USB_CLIENT_OPEN) {
-    this->handle_open_state_();
-  }
-}
-
-void USBClient::handle_open_state_() {
-  int err;
-  ESP_LOGD(TAG, "Open device %d", this->device_addr_);
-  err = usb_host_device_open(this->handle_, this->device_addr_, &this->device_handle_);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Device open failed: %s", esp_err_to_name(err));
-    this->state_ = USB_CLIENT_INIT;
-    return;
-  }
-  ESP_LOGD(TAG, "Get descriptor device %d", this->device_addr_);
-  const usb_device_desc_t *desc;
-  err = usb_host_get_device_descriptor(this->device_handle_, &desc);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Device get_desc failed: %s", esp_err_to_name(err));
-    this->disconnect();
-    return;
-  }
-  ESP_LOGD(TAG, "Device descriptor: vid %X pid %X", desc->idVendor, desc->idProduct);
-  if (desc->idVendor != this->vid_ || desc->idProduct != this->pid_) {
-    if (this->vid_ != 0 || this->pid_ != 0) {
-      ESP_LOGD(TAG, "Not our device, closing");
-      this->disconnect();
-      return;
-    }
-  }
-  usb_device_info_t dev_info;
-  err = usb_host_device_info(this->device_handle_, &dev_info);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Device info failed: %s", esp_err_to_name(err));
-    this->disconnect();
-    return;
-  }
-  this->state_ = USB_CLIENT_CONNECTED;
-  char buf_manuf[DESC_STRING_BUF_SIZE];
-  char buf_product[DESC_STRING_BUF_SIZE];
-  char buf_serial[DESC_STRING_BUF_SIZE];
-  ESP_LOGD(TAG, "Device connected: Manuf: %s; Prod: %s; Serial: %s",
-           get_descriptor_string(dev_info.str_desc_manufacturer, buf_manuf),
-           get_descriptor_string(dev_info.str_desc_product, buf_product),
-           get_descriptor_string(dev_info.str_desc_serial_num, buf_serial));
+  switch (this->state_) {
+    case USB_CLIENT_OPEN: {
+      int err;
+      ESP_LOGD(TAG, "Open device %d", this->device_addr_);
+      err = usb_host_device_open(this->handle_, this->device_addr_, &this->device_handle_);
+      if (err != ESP_OK) {
+        ESP_LOGW(TAG, "Device open failed: %s", esp_err_to_name(err));
+        this->state_ = USB_CLIENT_INIT;
+        break;
+      }
+      ESP_LOGD(TAG, "Get descriptor device %d", this->device_addr_);
+      const usb_device_desc_t *desc;
+      err = usb_host_get_device_descriptor(this->device_handle_, &desc);
+      if (err != ESP_OK) {
+        ESP_LOGW(TAG, "Device get_desc failed: %s", esp_err_to_name(err));
+        this->disconnect();
+      } else {
+        ESP_LOGD(TAG, "Device descriptor: vid %X pid %X", desc->idVendor, desc->idProduct);
+        if (desc->idVendor == this->vid_ && desc->idProduct == this->pid_ || this->vid_ == 0 && this->pid_ == 0) {
+          usb_device_info_t dev_info;
+          err = usb_host_device_info(this->device_handle_, &dev_info);
+          if (err != ESP_OK) {
+            ESP_LOGW(TAG, "Device info failed: %s", esp_err_to_name(err));
+            this->disconnect();
+            break;
+          }
+          this->state_ = USB_CLIENT_CONNECTED;
+          ESP_LOGD(TAG, "Device connected: Manuf: %s; Prod: %s; Serial: %s",
+                   get_descriptor_string(dev_info.str_desc_manufacturer).c_str(),
+                   get_descriptor_string(dev_info.str_desc_product).c_str(),
+                   get_descriptor_string(dev_info.str_desc_serial_num).c_str());
 
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
-  const usb_device_desc_t *device_desc;
-  err = usb_host_get_device_descriptor(this->device_handle_, &device_desc);
-  if (err == ESP_OK)
-    usb_client_print_device_descriptor(device_desc);
-  const usb_config_desc_t *config_desc;
-  err = usb_host_get_active_config_descriptor(this->device_handle_, &config_desc);
-  if (err == ESP_OK)
-    usb_client_print_config_descriptor(config_desc, nullptr);
+          const usb_device_desc_t *device_desc;
+          err = usb_host_get_device_descriptor(this->device_handle_, &device_desc);
+          if (err == ESP_OK)
+            usb_client_print_device_descriptor(device_desc);
+          const usb_config_desc_t *config_desc;
+          err = usb_host_get_active_config_descriptor(this->device_handle_, &config_desc);
+          if (err == ESP_OK)
+            usb_client_print_config_descriptor(config_desc, nullptr);
 #endif
-  this->on_connected();
+          this->on_connected();
+        } else {
+          ESP_LOGD(TAG, "Not our device, closing");
+          this->disconnect();
+        }
+      }
+      break;
+    }
+
+    default:
+      break;
+  }
 }
 
 void USBClient::on_opened(uint8_t addr) {

esphome/components/web_server/web_server.cpp

@@ -1,4 +1,3 @@
-// Trigger CI memory impact (uses updated ESPAsyncWebServer from web_server_base)
 #include "web_server.h"
 #ifdef USE_WEBSERVER
 #include "esphome/components/json/json_util.h"
@@ -214,7 +213,7 @@ void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_
 void DeferredUpdateEventSource::process_deferred_queue_() {
   while (!deferred_queue_.empty()) {
     DeferredEvent &de = deferred_queue_.front();
-    auto message = de.message_generator_(web_server_, de.source_);
+    std::string message = de.message_generator_(web_server_, de.source_);
     if (this->send(message.c_str(), "state") != DISCARDED) {
       // O(n) but memory efficiency is more important than speed here which is why std::vector was chosen
       deferred_queue_.erase(deferred_queue_.begin());
@@ -271,7 +270,7 @@ void DeferredUpdateEventSource::deferrable_send_state(void *source, const char *
     // deferred queue still not empty which means downstream event queue full, no point trying to send first
     deq_push_back_with_dedup_(source, message_generator);
   } else {
-    auto message = message_generator(web_server_, source);
+    std::string message = message_generator(web_server_, source);
     if (this->send(message.c_str(), "state") == DISCARDED) {
       deq_push_back_with_dedup_(source, message_generator);
     } else {
@@ -325,7 +324,7 @@ void DeferredUpdateEventSourceList::on_client_connect_(DeferredUpdateEventSource
   ws->defer([ws, source]() {
     // Configure reconnect timeout and send config
     // this should always go through since the AsyncEventSourceClient event queue is empty on connect
-    auto message = ws->get_config_json();
+    std::string message = ws->get_config_json();
     source->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
 
 #ifdef USE_WEBSERVER_SORTING
@@ -334,10 +333,10 @@ void DeferredUpdateEventSourceList::on_client_connect_(DeferredUpdateEventSource
       JsonObject root = builder.root();
       root[ESPHOME_F("name")] = group.second.name;
       root[ESPHOME_F("sorting_weight")] = group.second.weight;
-      auto group_msg = builder.serialize();
+      message = builder.serialize();
 
       // up to 31 groups should be able to be queued initially without defer
-      source->try_send_nodefer(group_msg.c_str(), "sorting_group");
+      source->try_send_nodefer(message.c_str(), "sorting_group");
     }
 #endif
 
@@ -370,7 +369,7 @@ void WebServer::set_css_include(const char *css_include) { this->css_include_ =
 void WebServer::set_js_include(const char *js_include) { this->js_include_ = js_include; }
 #endif
 
-json::SerializationBuffer<> WebServer::get_config_json() {
+std::string WebServer::get_config_json() {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -558,9 +557,7 @@ static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, J
       root[ESPHOME_F("device")] = device_name;
     }
 #endif
-#ifdef USE_ENTITY_ICON
     root[ESPHOME_F("icon")] = obj->get_icon_ref();
-#endif
     root[ESPHOME_F("entity_category")] = obj->get_entity_category();
     bool is_disabled = obj->is_disabled_by_default();
     if (is_disabled)
@@ -586,7 +583,8 @@ static void set_json_icon_state_value(JsonObject &root, EntityBase *obj, const c
 
 // Helper to get request detail parameter
 static JsonDetail get_request_detail(AsyncWebServerRequest *request) {
-  return request->arg(ESPHOME_F("detail")) == "all" ? DETAIL_ALL : DETAIL_STATE;
+  auto *param = request->getParam(ESPHOME_F("detail"));
+  return (param && param->value() == "all") ? DETAIL_ALL : DETAIL_STATE;
 }
 
 #ifdef USE_SENSOR
@@ -603,20 +601,20 @@ void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlM
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->sensor_json_(obj, obj->state, detail);
+      std::string data = this->sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::sensor_state_json_generator(WebServer *web_server, void *source) {
   return web_server->sensor_json_((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::sensor_all_json_generator(WebServer *web_server, void *source) {
   return web_server->sensor_json_((sensor::Sensor *) (source), ((sensor::Sensor *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config) {
+std::string WebServer::sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -650,23 +648,23 @@ void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->text_sensor_json_(obj, obj->state, detail);
+      std::string data = this->text_sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::text_sensor_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_sensor_state_json_generator(WebServer *web_server, void *source) {
   return web_server->text_sensor_json_((text_sensor::TextSensor *) (source),
                                        ((text_sensor::TextSensor *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::text_sensor_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_sensor_all_json_generator(WebServer *web_server, void *source) {
   return web_server->text_sensor_json_((text_sensor::TextSensor *) (source),
                                        ((text_sensor::TextSensor *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
-                                                         JsonDetail start_config) {
+std::string WebServer::text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
+                                         JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -711,7 +709,7 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->switch_json_(obj, obj->state, detail);
+      std::string data = this->switch_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -736,13 +734,13 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::switch_state_json_generator(WebServer *web_server, void *source) {
   return web_server->switch_json_((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::switch_all_json_generator(WebServer *web_server, void *source) {
   return web_server->switch_json_((switch_::Switch *) (source), ((switch_::Switch *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config) {
+std::string WebServer::switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -764,7 +762,7 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->button_json_(obj, detail);
+      std::string data = this->button_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("press"))) {
       DEFER_ACTION(obj, obj->press());
@@ -777,10 +775,10 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::button_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::button_all_json_generator(WebServer *web_server, void *source) {
   return web_server->button_json_((button::Button *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::button_json_(button::Button *obj, JsonDetail start_config) {
+std::string WebServer::button_json_(button::Button *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -807,23 +805,22 @@ void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, con
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->binary_sensor_json_(obj, obj->state, detail);
+      std::string data = this->binary_sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::binary_sensor_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::binary_sensor_state_json_generator(WebServer *web_server, void *source) {
   return web_server->binary_sensor_json_((binary_sensor::BinarySensor *) (source),
                                          ((binary_sensor::BinarySensor *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::binary_sensor_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::binary_sensor_all_json_generator(WebServer *web_server, void *source) {
   return web_server->binary_sensor_json_((binary_sensor::BinarySensor *) (source),
                                          ((binary_sensor::BinarySensor *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value,
-                                                           JsonDetail start_config) {
+std::string WebServer::binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -850,7 +847,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->fan_json_(obj, detail);
+      std::string data = this->fan_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
       DEFER_ACTION(obj, obj->toggle().perform());
@@ -864,10 +861,10 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       }
       auto call = is_on ? obj->turn_on() : obj->turn_off();
 
-      parse_num_param_(request, ESPHOME_F("speed_level"), call, &decltype(call)::set_speed);
+      parse_int_param_(request, ESPHOME_F("speed_level"), call, &decltype(call)::set_speed);
 
-      if (request->hasArg(ESPHOME_F("oscillation"))) {
-        auto speed = request->arg(ESPHOME_F("oscillation"));
+      if (request->hasParam(ESPHOME_F("oscillation"))) {
+        auto speed = request->getParam(ESPHOME_F("oscillation"))->value();
         auto val = parse_on_off(speed.c_str());
         switch (val) {
           case PARSE_ON:
@@ -891,13 +888,13 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::fan_state_json_generator(WebServer *web_server, void *source) {
   return web_server->fan_json_((fan::Fan *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::fan_all_json_generator(WebServer *web_server, void *source) {
   return web_server->fan_json_((fan::Fan *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::fan_json_(fan::Fan *obj, JsonDetail start_config) {
+std::string WebServer::fan_json_(fan::Fan *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -931,7 +928,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->light_json_(obj, detail);
+      std::string data = this->light_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method_equals(ESPHOME_F("toggle"))) {
       DEFER_ACTION(obj, obj->toggle().perform());
@@ -970,13 +967,13 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::light_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::light_state_json_generator(WebServer *web_server, void *source) {
   return web_server->light_json_((light::LightState *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::light_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::light_all_json_generator(WebServer *web_server, void *source) {
   return web_server->light_json_((light::LightState *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::light_json_(light::LightState *obj, JsonDetail start_config) {
+std::string WebServer::light_json_(light::LightState *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1010,7 +1007,7 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->cover_json_(obj, detail);
+      std::string data = this->cover_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1043,14 +1040,14 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
     }
 
     auto traits = obj->get_traits();
-    if ((request->hasArg(ESPHOME_F("position")) && !traits.get_supports_position()) ||
-        (request->hasArg(ESPHOME_F("tilt")) && !traits.get_supports_tilt())) {
+    if ((request->hasParam(ESPHOME_F("position")) && !traits.get_supports_position()) ||
+        (request->hasParam(ESPHOME_F("tilt")) && !traits.get_supports_tilt())) {
       request->send(409);
       return;
     }
 
-    parse_num_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
-    parse_num_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);
+    parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
+    parse_float_param_(request, ESPHOME_F("tilt"), call, &decltype(call)::set_tilt);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1058,13 +1055,13 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::cover_state_json_generator(WebServer *web_server, void *source) {
   return web_server->cover_json_((cover::Cover *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::cover_all_json_generator(WebServer *web_server, void *source) {
   return web_server->cover_json_((cover::Cover *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::cover_json_(cover::Cover *obj, JsonDetail start_config) {
+std::string WebServer::cover_json_(cover::Cover *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1099,7 +1096,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->number_json_(obj, obj->state, detail);
+      std::string data = this->number_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1109,7 +1106,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
     }
 
     auto call = obj->make_call();
-    parse_num_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
+    parse_float_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_value);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1118,13 +1115,13 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::number_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::number_state_json_generator(WebServer *web_server, void *source) {
   return web_server->number_json_((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::number_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::number_all_json_generator(WebServer *web_server, void *source) {
   return web_server->number_json_((number::Number *) (source), ((number::Number *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::number_json_(number::Number *obj, float value, JsonDetail start_config) {
+std::string WebServer::number_json_(number::Number *obj, float value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1166,7 +1163,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->date_json_(obj, detail);
+      std::string data = this->date_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1177,13 +1174,12 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
 
     auto call = obj->make_call();
 
-    const auto &value = request->arg(ESPHOME_F("value"));
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (value.length() == 0) {  // NOLINT(readability-container-size-empty)
+    if (!request->hasParam(ESPHOME_F("value"))) {
       request->send(409);
       return;
     }
-    call.set_date(value.c_str(), value.length());
+
+    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_date);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1192,13 +1188,13 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::date_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::date_state_json_generator(WebServer *web_server, void *source) {
   return web_server->date_json_((datetime::DateEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::date_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::date_all_json_generator(WebServer *web_server, void *source) {
   return web_server->date_json_((datetime::DateEntity *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_config) {
+std::string WebServer::date_json_(datetime::DateEntity *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1227,7 +1223,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->time_json_(obj, detail);
+      std::string data = this->time_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1238,13 +1234,12 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
 
     auto call = obj->make_call();
 
-    const auto &value = request->arg(ESPHOME_F("value"));
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (value.length() == 0) {  // NOLINT(readability-container-size-empty)
+    if (!request->hasParam(ESPHOME_F("value"))) {
       request->send(409);
       return;
     }
-    call.set_time(value.c_str(), value.length());
+
+    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_time);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1252,13 +1247,13 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::time_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::time_state_json_generator(WebServer *web_server, void *source) {
   return web_server->time_json_((datetime::TimeEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::time_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::time_all_json_generator(WebServer *web_server, void *source) {
   return web_server->time_json_((datetime::TimeEntity *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_config) {
+std::string WebServer::time_json_(datetime::TimeEntity *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1287,7 +1282,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
       continue;
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->datetime_json_(obj, detail);
+      std::string data = this->datetime_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1298,13 +1293,12 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
 
     auto call = obj->make_call();
 
-    const auto &value = request->arg(ESPHOME_F("value"));
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (value.length() == 0) {  // NOLINT(readability-container-size-empty)
+    if (!request->hasParam(ESPHOME_F("value"))) {
       request->send(409);
       return;
     }
-    call.set_datetime(value.c_str(), value.length());
+
+    parse_string_param_(request, ESPHOME_F("value"), call, &decltype(call)::set_datetime);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1312,13 +1306,13 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::datetime_state_json_generator(WebServer *web_server, void *source) {
   return web_server->datetime_json_((datetime::DateTimeEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::datetime_all_json_generator(WebServer *web_server, void *source) {
   return web_server->datetime_json_((datetime::DateTimeEntity *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config) {
+std::string WebServer::datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1349,7 +1343,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->text_json_(obj, obj->state, detail);
+      std::string data = this->text_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1368,13 +1362,13 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::text_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_state_json_generator(WebServer *web_server, void *source) {
   return web_server->text_json_((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::text_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::text_all_json_generator(WebServer *web_server, void *source) {
   return web_server->text_json_((text::Text *) (source), ((text::Text *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::text_json_(text::Text *obj, const std::string &value, JsonDetail start_config) {
+std::string WebServer::text_json_(text::Text *obj, const std::string &value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1406,7 +1400,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), detail);
+      std::string data = this->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1425,15 +1419,15 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::select_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::select_state_json_generator(WebServer *web_server, void *source) {
   auto *obj = (select::Select *) (source);
   return web_server->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::select_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::select_all_json_generator(WebServer *web_server, void *source) {
   auto *obj = (select::Select *) (source);
   return web_server->select_json_(obj, obj->has_state() ? obj->current_option() : StringRef(), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::select_json_(select::Select *obj, StringRef value, JsonDetail start_config) {
+std::string WebServer::select_json_(select::Select *obj, StringRef value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1465,7 +1459,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->climate_json_(obj, detail);
+      std::string data = this->climate_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1483,14 +1477,10 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
     parse_string_param_(request, ESPHOME_F("swing_mode"), call, &decltype(call)::set_swing_mode);
 
     // Parse temperature parameters
-    // static_cast needed to disambiguate overloaded setters (float vs optional<float>)
-    using ClimateCall = decltype(call);
-    parse_num_param_(request, ESPHOME_F("target_temperature_high"), call,
-                     static_cast<ClimateCall &(ClimateCall::*) (float)>(&ClimateCall::set_target_temperature_high));
-    parse_num_param_(request, ESPHOME_F("target_temperature_low"), call,
-                     static_cast<ClimateCall &(ClimateCall::*) (float)>(&ClimateCall::set_target_temperature_low));
-    parse_num_param_(request, ESPHOME_F("target_temperature"), call,
-                     static_cast<ClimateCall &(ClimateCall::*) (float)>(&ClimateCall::set_target_temperature));
+    parse_float_param_(request, ESPHOME_F("target_temperature_high"), call,
+                       &decltype(call)::set_target_temperature_high);
+    parse_float_param_(request, ESPHOME_F("target_temperature_low"), call, &decltype(call)::set_target_temperature_low);
+    parse_float_param_(request, ESPHOME_F("target_temperature"), call, &decltype(call)::set_target_temperature);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1498,15 +1488,15 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::climate_state_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->climate_json_((climate::Climate *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::climate_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->climate_json_((climate::Climate *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::climate_json_(climate::Climate *obj, JsonDetail start_config) {
+std::string WebServer::climate_json_(climate::Climate *obj, JsonDetail start_config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   json::JsonBuilder builder;
   JsonObject root = builder.root();
@@ -1639,7 +1629,7 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->lock_json_(obj, obj->state, detail);
+      std::string data = this->lock_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1664,13 +1654,13 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::lock_state_json_generator(WebServer *web_server, void *source) {
   return web_server->lock_json_((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::lock_all_json_generator(WebServer *web_server, void *source) {
   return web_server->lock_json_((lock::Lock *) (source), ((lock::Lock *) (source))->state, DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
+std::string WebServer::lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1698,7 +1688,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->valve_json_(obj, detail);
+      std::string data = this->valve_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1731,12 +1721,12 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
     }
 
     auto traits = obj->get_traits();
-    if (request->hasArg(ESPHOME_F("position")) && !traits.get_supports_position()) {
+    if (request->hasParam(ESPHOME_F("position")) && !traits.get_supports_position()) {
       request->send(409);
       return;
     }
 
-    parse_num_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
+    parse_float_param_(request, ESPHOME_F("position"), call, &decltype(call)::set_position);
 
     DEFER_ACTION(call, call.perform());
     request->send(200);
@@ -1744,13 +1734,13 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::valve_state_json_generator(WebServer *web_server, void *source) {
   return web_server->valve_json_((valve::Valve *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::valve_all_json_generator(WebServer *web_server, void *source) {
   return web_server->valve_json_((valve::Valve *) (source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::valve_json_(valve::Valve *obj, JsonDetail start_config) {
+std::string WebServer::valve_json_(valve::Valve *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1783,7 +1773,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
+      std::string data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1823,19 +1813,19 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::alarm_control_panel_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::alarm_control_panel_state_json_generator(WebServer *web_server, void *source) {
   return web_server->alarm_control_panel_json_((alarm_control_panel::AlarmControlPanel *) (source),
                                                ((alarm_control_panel::AlarmControlPanel *) (source))->get_state(),
                                                DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::alarm_control_panel_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::alarm_control_panel_all_json_generator(WebServer *web_server, void *source) {
   return web_server->alarm_control_panel_json_((alarm_control_panel::AlarmControlPanel *) (source),
                                                ((alarm_control_panel::AlarmControlPanel *) (source))->get_state(),
                                                DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
-                                                                 alarm_control_panel::AlarmControlPanelState value,
-                                                                 JsonDetail start_config) {
+std::string WebServer::alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
+                                                 alarm_control_panel::AlarmControlPanelState value,
+                                                 JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -1864,7 +1854,7 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->water_heater_json_(obj, detail);
+      std::string data = this->water_heater_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -1880,12 +1870,12 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
     parse_string_param_(request, ESPHOME_F("mode"), base_call, &water_heater::WaterHeaterCall::set_mode);
 
     // Parse temperature parameters
-    parse_num_param_(request, ESPHOME_F("target_temperature"), base_call,
-                     &water_heater::WaterHeaterCall::set_target_temperature);
-    parse_num_param_(request, ESPHOME_F("target_temperature_low"), base_call,
-                     &water_heater::WaterHeaterCall::set_target_temperature_low);
-    parse_num_param_(request, ESPHOME_F("target_temperature_high"), base_call,
-                     &water_heater::WaterHeaterCall::set_target_temperature_high);
+    parse_float_param_(request, ESPHOME_F("target_temperature"), base_call,
+                       &water_heater::WaterHeaterCall::set_target_temperature);
+    parse_float_param_(request, ESPHOME_F("target_temperature_low"), base_call,
+                       &water_heater::WaterHeaterCall::set_target_temperature_low);
+    parse_float_param_(request, ESPHOME_F("target_temperature_high"), base_call,
+                       &water_heater::WaterHeaterCall::set_target_temperature_high);
 
     // Parse away mode parameter
     parse_bool_param_(request, ESPHOME_F("away"), base_call, &water_heater::WaterHeaterCall::set_away);
@@ -1900,14 +1890,14 @@ void WebServer::handle_water_heater_request(AsyncWebServerRequest *request, cons
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::water_heater_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::water_heater_state_json_generator(WebServer *web_server, void *source) {
   return web_server->water_heater_json_(static_cast<water_heater::WaterHeater *>(source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::water_heater_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::water_heater_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->water_heater_json_(static_cast<water_heater::WaterHeater *>(source), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config) {
+std::string WebServer::water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
   char buf[PSTR_LOCAL_SIZE];
@@ -1970,7 +1960,7 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->infrared_json_(obj, detail);
+      std::string data = this->infrared_json_(obj, detail);
       request->send(200, ESPHOME_F("application/json"), data.c_str());
       return;
     }
@@ -1989,16 +1979,16 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
     auto call = obj->make_call();
 
     // Parse carrier frequency (optional)
-    {
-      auto value = parse_number<uint32_t>(request->arg(ESPHOME_F("carrier_frequency")).c_str());
+    if (request->hasParam(ESPHOME_F("carrier_frequency"))) {
+      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("carrier_frequency"))->value().c_str());
       if (value.has_value()) {
         call.set_carrier_frequency(*value);
       }
     }
 
     // Parse repeat count (optional, defaults to 1)
-    {
-      auto value = parse_number<uint32_t>(request->arg(ESPHOME_F("repeat_count")).c_str());
+    if (request->hasParam(ESPHOME_F("repeat_count"))) {
+      auto value = parse_number<uint32_t>(request->getParam(ESPHOME_F("repeat_count"))->value().c_str());
       if (value.has_value()) {
         call.set_repeat_count(*value);
       }
@@ -2006,12 +1996,18 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
 
     // Parse base64url-encoded raw timings (required)
     // Base64url is URL-safe: uses A-Za-z0-9-_ (no special characters needing escaping)
-    const auto &data_arg = request->arg(ESPHOME_F("data"));
+    if (!request->hasParam(ESPHOME_F("data"))) {
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Missing 'data' parameter"));
+      return;
+    }
 
-    // Validate base64url is not empty (also catches missing parameter since arg() returns empty string)
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (data_arg.length() == 0) {  // NOLINT(readability-container-size-empty)
-      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Missing or empty 'data' parameter"));
+    // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
+    std::string encoded =
+        request->getParam(ESPHOME_F("data"))->value().c_str();  // NOLINT(readability-redundant-string-cstr)
+
+    // Validate base64url is not empty
+    if (encoded.empty()) {
+      request->send(400, ESPHOME_F("text/plain"), ESPHOME_F("Empty 'data' parameter"));
       return;
     }
 
@@ -2019,7 +2015,7 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
     // it outlives the call - set_raw_timings_base64url stores a pointer, so the string
     // must remain valid until perform() completes.
     // ESP8266 also needs this because ESPAsyncWebServer callbacks run in "sys" context.
-    this->defer([call, encoded = std::string(data_arg.c_str(), data_arg.length())]() mutable {
+    this->defer([call, encoded = std::move(encoded)]() mutable {
       call.set_raw_timings_base64url(encoded);
       call.perform();
     });
@@ -2030,12 +2026,12 @@ void WebServer::handle_infrared_request(AsyncWebServerRequest *request, const Ur
   request->send(404);
 }
 
-json::SerializationBuffer<> WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::infrared_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->infrared_json_(static_cast<infrared::Infrared *>(source), DETAIL_ALL);
 }
 
-json::SerializationBuffer<> WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
+std::string WebServer::infrared_json_(infrared::Infrared *obj, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -2070,7 +2066,7 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
     if (entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->event_json_(obj, StringRef(), detail);
+      std::string data = this->event_json_(obj, StringRef(), detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -2080,16 +2076,16 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
 
 static StringRef get_event_type(event::Event *event) { return event ? event->get_last_event_type() : StringRef(); }
 
-json::SerializationBuffer<> WebServer::event_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::event_state_json_generator(WebServer *web_server, void *source) {
   auto *event = static_cast<event::Event *>(source);
   return web_server->event_json_(event, get_event_type(event), DETAIL_STATE);
 }
 // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
-json::SerializationBuffer<> WebServer::event_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::event_all_json_generator(WebServer *web_server, void *source) {
   auto *event = static_cast<event::Event *>(source);
   return web_server->event_json_(event, get_event_type(event), DETAIL_ALL);
 }
-json::SerializationBuffer<> WebServer::event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config) {
+std::string WebServer::event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config) {
   json::JsonBuilder builder;
   JsonObject root = builder.root();
 
@@ -2123,7 +2119,7 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
 
     if (request->method() == HTTP_GET && entity_match.action_is_empty) {
       auto detail = get_request_detail(request);
-      auto data = this->update_json_(obj, detail);
+      std::string data = this->update_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
     }
@@ -2139,15 +2135,15 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
   }
   request->send(404);
 }
-json::SerializationBuffer<> WebServer::update_state_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::update_state_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->update_json_((update::UpdateEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::update_all_json_generator(WebServer *web_server, void *source) {
+std::string WebServer::update_all_json_generator(WebServer *web_server, void *source) {
   // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   return web_server->update_json_((update::UpdateEntity *) (source), DETAIL_STATE);
 }
-json::SerializationBuffer<> WebServer::update_json_(update::UpdateEntity *obj, JsonDetail start_config) {
+std::string WebServer::update_json_(update::UpdateEntity *obj, JsonDetail start_config) {
   // NOLINTBEGIN(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
   json::JsonBuilder builder;
   JsonObject root = builder.root();

esphome/components/web_server/web_server.h

@@ -2,7 +2,6 @@
 
 #include "list_entities.h"
 
-#include "esphome/components/json/json_util.h"
 #include "esphome/components/web_server_base/web_server_base.h"
 #ifdef USE_WEBSERVER
 #include "esphome/core/component.h"
@@ -104,7 +103,7 @@ enum JsonDetail { DETAIL_ALL, DETAIL_STATE };
   can be forgotten.
 */
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
-using message_generator_t = json::SerializationBuffer<>(WebServer *, void *);
+using message_generator_t = std::string(WebServer *, void *);
 
 class DeferredUpdateEventSourceList;
 class DeferredUpdateEventSource : public AsyncEventSource {
@@ -265,7 +264,7 @@ class WebServer : public Controller,
   void handle_index_request(AsyncWebServerRequest *request);
 
   /// Return the webserver configuration as JSON.
-  json::SerializationBuffer<> get_config_json();
+  std::string get_config_json();
 
 #ifdef USE_WEBSERVER_CSS_INCLUDE
   /// Handle included css request under '/0.css'.
@@ -287,8 +286,8 @@ class WebServer : public Controller,
   /// Handle a sensor request under '/sensor/<id>'.
   void handle_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> sensor_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> sensor_all_json_generator(WebServer *web_server, void *source);
+  static std::string sensor_state_json_generator(WebServer *web_server, void *source);
+  static std::string sensor_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_SWITCH
@@ -297,8 +296,8 @@ class WebServer : public Controller,
   /// Handle a switch request under '/switch/<id>/</turn_on/turn_off/toggle>'.
   void handle_switch_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> switch_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> switch_all_json_generator(WebServer *web_server, void *source);
+  static std::string switch_state_json_generator(WebServer *web_server, void *source);
+  static std::string switch_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_BUTTON
@@ -306,7 +305,7 @@ class WebServer : public Controller,
   void handle_button_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
   // Buttons are stateless, so there is no button_state_json_generator
-  static json::SerializationBuffer<> button_all_json_generator(WebServer *web_server, void *source);
+  static std::string button_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_BINARY_SENSOR
@@ -315,8 +314,8 @@ class WebServer : public Controller,
   /// Handle a binary sensor request under '/binary_sensor/<id>'.
   void handle_binary_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> binary_sensor_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> binary_sensor_all_json_generator(WebServer *web_server, void *source);
+  static std::string binary_sensor_state_json_generator(WebServer *web_server, void *source);
+  static std::string binary_sensor_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_FAN
@@ -325,8 +324,8 @@ class WebServer : public Controller,
   /// Handle a fan request under '/fan/<id>/</turn_on/turn_off/toggle>'.
   void handle_fan_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> fan_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> fan_all_json_generator(WebServer *web_server, void *source);
+  static std::string fan_state_json_generator(WebServer *web_server, void *source);
+  static std::string fan_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_LIGHT
@@ -335,8 +334,8 @@ class WebServer : public Controller,
   /// Handle a light request under '/light/<id>/</turn_on/turn_off/toggle>'.
   void handle_light_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> light_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> light_all_json_generator(WebServer *web_server, void *source);
+  static std::string light_state_json_generator(WebServer *web_server, void *source);
+  static std::string light_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_TEXT_SENSOR
@@ -345,8 +344,8 @@ class WebServer : public Controller,
   /// Handle a text sensor request under '/text_sensor/<id>'.
   void handle_text_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> text_sensor_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> text_sensor_all_json_generator(WebServer *web_server, void *source);
+  static std::string text_sensor_state_json_generator(WebServer *web_server, void *source);
+  static std::string text_sensor_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_COVER
@@ -355,8 +354,8 @@ class WebServer : public Controller,
   /// Handle a cover request under '/cover/<id>/<open/close/stop/set>'.
   void handle_cover_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> cover_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> cover_all_json_generator(WebServer *web_server, void *source);
+  static std::string cover_state_json_generator(WebServer *web_server, void *source);
+  static std::string cover_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_NUMBER
@@ -364,8 +363,8 @@ class WebServer : public Controller,
   /// Handle a number request under '/number/<id>'.
   void handle_number_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> number_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> number_all_json_generator(WebServer *web_server, void *source);
+  static std::string number_state_json_generator(WebServer *web_server, void *source);
+  static std::string number_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_DATETIME_DATE
@@ -373,8 +372,8 @@ class WebServer : public Controller,
   /// Handle a date request under '/date/<id>'.
   void handle_date_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> date_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> date_all_json_generator(WebServer *web_server, void *source);
+  static std::string date_state_json_generator(WebServer *web_server, void *source);
+  static std::string date_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_DATETIME_TIME
@@ -382,8 +381,8 @@ class WebServer : public Controller,
   /// Handle a time request under '/time/<id>'.
   void handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> time_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> time_all_json_generator(WebServer *web_server, void *source);
+  static std::string time_state_json_generator(WebServer *web_server, void *source);
+  static std::string time_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_DATETIME_DATETIME
@@ -391,8 +390,8 @@ class WebServer : public Controller,
   /// Handle a datetime request under '/datetime/<id>'.
   void handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> datetime_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> datetime_all_json_generator(WebServer *web_server, void *source);
+  static std::string datetime_state_json_generator(WebServer *web_server, void *source);
+  static std::string datetime_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_TEXT
@@ -400,8 +399,8 @@ class WebServer : public Controller,
   /// Handle a text input request under '/text/<id>'.
   void handle_text_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> text_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> text_all_json_generator(WebServer *web_server, void *source);
+  static std::string text_state_json_generator(WebServer *web_server, void *source);
+  static std::string text_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_SELECT
@@ -409,8 +408,8 @@ class WebServer : public Controller,
   /// Handle a select request under '/select/<id>'.
   void handle_select_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> select_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> select_all_json_generator(WebServer *web_server, void *source);
+  static std::string select_state_json_generator(WebServer *web_server, void *source);
+  static std::string select_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_CLIMATE
@@ -418,8 +417,8 @@ class WebServer : public Controller,
   /// Handle a climate request under '/climate/<id>'.
   void handle_climate_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> climate_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> climate_all_json_generator(WebServer *web_server, void *source);
+  static std::string climate_state_json_generator(WebServer *web_server, void *source);
+  static std::string climate_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_LOCK
@@ -428,8 +427,8 @@ class WebServer : public Controller,
   /// Handle a lock request under '/lock/<id>/</lock/unlock/open>'.
   void handle_lock_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> lock_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> lock_all_json_generator(WebServer *web_server, void *source);
+  static std::string lock_state_json_generator(WebServer *web_server, void *source);
+  static std::string lock_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_VALVE
@@ -438,8 +437,8 @@ class WebServer : public Controller,
   /// Handle a valve request under '/valve/<id>/<open/close/stop/set>'.
   void handle_valve_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> valve_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> valve_all_json_generator(WebServer *web_server, void *source);
+  static std::string valve_state_json_generator(WebServer *web_server, void *source);
+  static std::string valve_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
@@ -448,8 +447,8 @@ class WebServer : public Controller,
   /// Handle a alarm_control_panel request under '/alarm_control_panel/<id>'.
   void handle_alarm_control_panel_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> alarm_control_panel_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> alarm_control_panel_all_json_generator(WebServer *web_server, void *source);
+  static std::string alarm_control_panel_state_json_generator(WebServer *web_server, void *source);
+  static std::string alarm_control_panel_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_WATER_HEATER
@@ -458,22 +457,22 @@ class WebServer : public Controller,
   /// Handle a water_heater request under '/water_heater/<id>/<mode/set>'.
   void handle_water_heater_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> water_heater_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> water_heater_all_json_generator(WebServer *web_server, void *source);
+  static std::string water_heater_state_json_generator(WebServer *web_server, void *source);
+  static std::string water_heater_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_INFRARED
   /// Handle an infrared request under '/infrared/<id>/transmit'.
   void handle_infrared_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> infrared_all_json_generator(WebServer *web_server, void *source);
+  static std::string infrared_all_json_generator(WebServer *web_server, void *source);
 #endif
 
 #ifdef USE_EVENT
   void on_event(event::Event *obj) override;
 
-  static json::SerializationBuffer<> event_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> event_all_json_generator(WebServer *web_server, void *source);
+  static std::string event_state_json_generator(WebServer *web_server, void *source);
+  static std::string event_all_json_generator(WebServer *web_server, void *source);
 
   /// Handle a event request under '/event<id>'.
   void handle_event_request(AsyncWebServerRequest *request, const UrlMatch &match);
@@ -485,8 +484,8 @@ class WebServer : public Controller,
   /// Handle a update request under '/update/<id>'.
   void handle_update_request(AsyncWebServerRequest *request, const UrlMatch &match);
 
-  static json::SerializationBuffer<> update_state_json_generator(WebServer *web_server, void *source);
-  static json::SerializationBuffer<> update_all_json_generator(WebServer *web_server, void *source);
+  static std::string update_state_json_generator(WebServer *web_server, void *source);
+  static std::string update_all_json_generator(WebServer *web_server, void *source);
 #endif
 
   /// Override the web handler's canHandle method.
@@ -514,9 +513,11 @@ class WebServer : public Controller,
   template<typename T, typename Ret>
   void parse_light_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(float),
                           float scale = 1.0f) {
-    auto value = parse_number<float>(request->arg(param_name).c_str());
-    if (value.has_value()) {
-      (call.*setter)(*value / scale);
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<float>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value / scale);
+      }
     }
   }
 
@@ -524,19 +525,34 @@ class WebServer : public Controller,
   template<typename T, typename Ret>
   void parse_light_param_uint_(AsyncWebServerRequest *request, ParamNameType param_name, T &call,
                                Ret (T::*setter)(uint32_t), uint32_t scale = 1) {
-    auto value = parse_number<uint32_t>(request->arg(param_name).c_str());
-    if (value.has_value()) {
-      (call.*setter)(*value * scale);
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<uint32_t>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value * scale);
+      }
     }
   }
 #endif
 
-  // Generic helper to parse and apply a numeric parameter
-  template<typename NumT, typename T, typename Ret>
-  void parse_num_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(NumT)) {
-    auto value = parse_number<NumT>(request->arg(param_name).c_str());
-    if (value.has_value()) {
-      (call.*setter)(*value);
+  // Generic helper to parse and apply a float parameter
+  template<typename T, typename Ret>
+  void parse_float_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(float)) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<float>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value);
+      }
+    }
+  }
+
+  // Generic helper to parse and apply an int parameter
+  template<typename T, typename Ret>
+  void parse_int_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(int)) {
+    if (request->hasParam(param_name)) {
+      auto value = parse_number<int>(request->getParam(param_name)->value().c_str());
+      if (value.has_value()) {
+        (call.*setter)(*value);
+      }
     }
   }
 
@@ -544,9 +560,10 @@ class WebServer : public Controller,
   template<typename T, typename Ret>
   void parse_string_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call,
                            Ret (T::*setter)(const std::string &)) {
-    if (request->hasArg(param_name)) {
-      const auto &value = request->arg(param_name);
-      (call.*setter)(std::string(value.c_str(), value.length()));
+    if (request->hasParam(param_name)) {
+      // .c_str() is required for Arduino framework where value() returns Arduino String instead of std::string
+      std::string value = request->getParam(param_name)->value().c_str();  // NOLINT(readability-redundant-string-cstr)
+      (call.*setter)(value);
     }
   }
 
@@ -556,9 +573,8 @@ class WebServer : public Controller,
   // Invalid values are ignored (setter not called)
   template<typename T, typename Ret>
   void parse_bool_param_(AsyncWebServerRequest *request, ParamNameType param_name, T &call, Ret (T::*setter)(bool)) {
-    const auto &param_value = request->arg(param_name);
-    // Arduino String has isEmpty() not empty(), use length() for cross-platform compatibility
-    if (param_value.length() > 0) {  // NOLINT(readability-container-size-empty)
+    if (request->hasParam(param_name)) {
+      auto param_value = request->getParam(param_name)->value();
       // First check on/off (default), then true/false (custom)
       auto val = parse_on_off(param_value.c_str());
       if (val == PARSE_NONE) {
@@ -594,74 +610,71 @@ class WebServer : public Controller,
 
  private:
 #ifdef USE_SENSOR
-  json::SerializationBuffer<> sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config);
+  std::string sensor_json_(sensor::Sensor *obj, float value, JsonDetail start_config);
 #endif
 #ifdef USE_SWITCH
-  json::SerializationBuffer<> switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config);
+  std::string switch_json_(switch_::Switch *obj, bool value, JsonDetail start_config);
 #endif
 #ifdef USE_BUTTON
-  json::SerializationBuffer<> button_json_(button::Button *obj, JsonDetail start_config);
+  std::string button_json_(button::Button *obj, JsonDetail start_config);
 #endif
 #ifdef USE_BINARY_SENSOR
-  json::SerializationBuffer<> binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value,
-                                                  JsonDetail start_config);
+  std::string binary_sensor_json_(binary_sensor::BinarySensor *obj, bool value, JsonDetail start_config);
 #endif
 #ifdef USE_FAN
-  json::SerializationBuffer<> fan_json_(fan::Fan *obj, JsonDetail start_config);
+  std::string fan_json_(fan::Fan *obj, JsonDetail start_config);
 #endif
 #ifdef USE_LIGHT
-  json::SerializationBuffer<> light_json_(light::LightState *obj, JsonDetail start_config);
+  std::string light_json_(light::LightState *obj, JsonDetail start_config);
 #endif
 #ifdef USE_TEXT_SENSOR
-  json::SerializationBuffer<> text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value,
-                                                JsonDetail start_config);
+  std::string text_sensor_json_(text_sensor::TextSensor *obj, const std::string &value, JsonDetail start_config);
 #endif
 #ifdef USE_COVER
-  json::SerializationBuffer<> cover_json_(cover::Cover *obj, JsonDetail start_config);
+  std::string cover_json_(cover::Cover *obj, JsonDetail start_config);
 #endif
 #ifdef USE_NUMBER
-  json::SerializationBuffer<> number_json_(number::Number *obj, float value, JsonDetail start_config);
+  std::string number_json_(number::Number *obj, float value, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_DATE
-  json::SerializationBuffer<> date_json_(datetime::DateEntity *obj, JsonDetail start_config);
+  std::string date_json_(datetime::DateEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_TIME
-  json::SerializationBuffer<> time_json_(datetime::TimeEntity *obj, JsonDetail start_config);
+  std::string time_json_(datetime::TimeEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_DATETIME_DATETIME
-  json::SerializationBuffer<> datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config);
+  std::string datetime_json_(datetime::DateTimeEntity *obj, JsonDetail start_config);
 #endif
 #ifdef USE_TEXT
-  json::SerializationBuffer<> text_json_(text::Text *obj, const std::string &value, JsonDetail start_config);
+  std::string text_json_(text::Text *obj, const std::string &value, JsonDetail start_config);
 #endif
 #ifdef USE_SELECT
-  json::SerializationBuffer<> select_json_(select::Select *obj, StringRef value, JsonDetail start_config);
+  std::string select_json_(select::Select *obj, StringRef value, JsonDetail start_config);
 #endif
 #ifdef USE_CLIMATE
-  json::SerializationBuffer<> climate_json_(climate::Climate *obj, JsonDetail start_config);
+  std::string climate_json_(climate::Climate *obj, JsonDetail start_config);
 #endif
 #ifdef USE_LOCK
-  json::SerializationBuffer<> lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config);
+  std::string lock_json_(lock::Lock *obj, lock::LockState value, JsonDetail start_config);
 #endif
 #ifdef USE_VALVE
-  json::SerializationBuffer<> valve_json_(valve::Valve *obj, JsonDetail start_config);
+  std::string valve_json_(valve::Valve *obj, JsonDetail start_config);
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-  json::SerializationBuffer<> alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
-                                                        alarm_control_panel::AlarmControlPanelState value,
-                                                        JsonDetail start_config);
+  std::string alarm_control_panel_json_(alarm_control_panel::AlarmControlPanel *obj,
+                                        alarm_control_panel::AlarmControlPanelState value, JsonDetail start_config);
 #endif
 #ifdef USE_EVENT
-  json::SerializationBuffer<> event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config);
+  std::string event_json_(event::Event *obj, StringRef event_type, JsonDetail start_config);
 #endif
 #ifdef USE_WATER_HEATER
-  json::SerializationBuffer<> water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
+  std::string water_heater_json_(water_heater::WaterHeater *obj, JsonDetail start_config);
 #endif
 #ifdef USE_INFRARED
-  json::SerializationBuffer<> infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
+  std::string infrared_json_(infrared::Infrared *obj, JsonDetail start_config);
 #endif
 #ifdef USE_UPDATE
-  json::SerializationBuffer<> update_json_(update::UpdateEntity *obj, JsonDetail start_config);
+  std::string update_json_(update::UpdateEntity *obj, JsonDetail start_config);
 #endif
 };
 

esphome/components/web_server_idf/utils.cpp

@@ -1,13 +1,17 @@
 #ifdef USE_ESP32
+#include <memory>
 #include <cstring>
 #include <cctype>
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "http_parser.h"
 
 #include "utils.h"
 
 namespace esphome::web_server_idf {
 
+static const char *const TAG = "web_server_idf_utils";
+
 size_t url_decode(char *str) {
   char *start = str;
   char *ptr = str, buf;
@@ -50,15 +54,32 @@ optional<std::string> request_get_header(httpd_req_t *req, const char *name) {
   return {str};
 }
 
+optional<std::string> request_get_url_query(httpd_req_t *req) {
+  auto len = httpd_req_get_url_query_len(req);
+  if (len == 0) {
+    return {};
+  }
+
+  std::string str;
+  str.resize(len);
+
+  auto res = httpd_req_get_url_query_str(req, &str[0], len + 1);
+  if (res != ESP_OK) {
+    ESP_LOGW(TAG, "Can't get query for request: %s", esp_err_to_name(res));
+    return {};
+  }
+
+  return {str};
+}
+
 optional<std::string> query_key_value(const char *query_url, size_t query_len, const char *key) {
   if (query_url == nullptr || query_len == 0) {
     return {};
   }
 
-  // Value can't exceed query_len. Use small stack buffer for typical values,
-  // heap fallback for long ones (e.g. base64 IR data) to limit stack usage
-  // since callers may also have stack buffers for the query string.
-  SmallBufferWithHeapFallback<128, char> val(query_len);
+  // Use stack buffer for typical query strings, heap fallback for large ones
+  SmallBufferWithHeapFallback<256, char> val(query_len);
+
   if (httpd_query_key_value(query_url, key, val.get(), query_len) != ESP_OK) {
     return {};
   }
@@ -67,18 +88,6 @@ optional<std::string> query_key_value(const char *query_url, size_t query_len, c
   return {val.get()};
 }
 
-bool query_has_key(const char *query_url, size_t query_len, const char *key) {
-  if (query_url == nullptr || query_len == 0) {
-    return false;
-  }
-  // Minimal buffer — we only care if the key exists, not the value
-  char buf[1];
-  // httpd_query_key_value returns ESP_OK if found, ESP_ERR_HTTPD_RESULT_TRUNC if found
-  // but value truncated (expected with 1-byte buffer), or other errors for invalid input
-  auto err = httpd_query_key_value(query_url, key, buf, sizeof(buf));
-  return err == ESP_OK || err == ESP_ERR_HTTPD_RESULT_TRUNC;
-}
-
 // Helper function for case-insensitive string region comparison
 bool str_ncmp_ci(const char *s1, const char *s2, size_t n) {
   for (size_t i = 0; i < n; i++) {

esphome/components/web_server_idf/utils.h

@@ -13,8 +13,11 @@ size_t url_decode(char *str);
 
 bool request_has_header(httpd_req_t *req, const char *name);
 optional<std::string> request_get_header(httpd_req_t *req, const char *name);
+optional<std::string> request_get_url_query(httpd_req_t *req);
 optional<std::string> query_key_value(const char *query_url, size_t query_len, const char *key);
-bool query_has_key(const char *query_url, size_t query_len, const char *key);
+inline optional<std::string> query_key_value(const std::string &query_url, const std::string &key) {
+  return query_key_value(query_url.c_str(), query_url.size(), key.c_str());
+}
 
 // Helper function for case-insensitive character comparison
 inline bool char_equals_ci(char a, char b) { return ::tolower(a) == ::tolower(b); }

esphome/components/web_server_idf/web_server_idf.cpp

@@ -393,7 +393,13 @@ AsyncWebParameter *AsyncWebServerRequest::getParam(const char *name) {
   }
 
   // Look up value from query strings
-  auto val = this->find_query_value_(name);
+  optional<std::string> val = query_key_value(this->post_query_.c_str(), this->post_query_.size(), name);
+  if (!val.has_value()) {
+    auto url_query = request_get_url_query(*this);
+    if (url_query.has_value()) {
+      val = query_key_value(url_query.value().c_str(), url_query.value().size(), name);
+    }
+  }
 
   // Don't cache misses to avoid wasting memory when handlers check for
   // optional parameters that don't exist in the request
@@ -406,50 +412,6 @@ AsyncWebParameter *AsyncWebServerRequest::getParam(const char *name) {
   return param;
 }
 
-/// Search post_query then URL query with a callback.
-/// Returns first truthy result, or value-initialized default.
-/// URL query is accessed directly from req->uri (same pattern as url_to()).
-template<typename Func>
-static auto search_query_sources(httpd_req_t *req, const std::string &post_query, const char *name, Func func)
-    -> decltype(func(nullptr, size_t{0}, name)) {
-  if (!post_query.empty()) {
-    auto result = func(post_query.c_str(), post_query.size(), name);
-    if (result) {
-      return result;
-    }
-  }
-  // Use httpd API for query length, then access string directly from URI.
-  // http_parser identifies components by offset/length without modifying the URI string.
-  // This is the same pattern used by url_to().
-  auto len = httpd_req_get_url_query_len(req);
-  if (len == 0) {
-    return {};
-  }
-  const char *query = strchr(req->uri, '?');
-  if (query == nullptr) {
-    return {};
-  }
-  query++;  // skip '?'
-  return func(query, len, name);
-}
-
-optional<std::string> AsyncWebServerRequest::find_query_value_(const char *name) const {
-  return search_query_sources(this->req_, this->post_query_, name,
-                              [](const char *q, size_t len, const char *k) { return query_key_value(q, len, k); });
-}
-
-bool AsyncWebServerRequest::hasArg(const char *name) {
-  return search_query_sources(this->req_, this->post_query_, name, query_has_key);
-}
-
-std::string AsyncWebServerRequest::arg(const char *name) {
-  auto val = this->find_query_value_(name);
-  if (val.has_value()) {
-    return std::move(val.value());
-  }
-  return {};
-}
-
 void AsyncWebServerResponse::addHeader(const char *name, const char *value) {
   httpd_resp_set_hdr(*this->req_, name, value);
 }
@@ -457,9 +419,8 @@ void AsyncWebServerResponse::addHeader(const char *name, const char *value) {
 void AsyncResponseStream::print(float value) {
   // Use stack buffer to avoid temporary string allocation
   // Size: sign (1) + digits (10) + decimal (1) + precision (6) + exponent (5) + null (1) = 24, use 32 for safety
-  constexpr size_t float_buf_size = 32;
-  char buf[float_buf_size];
-  int len = snprintf(buf, float_buf_size, "%f", value);
+  char buf[32];
+  int len = snprintf(buf, sizeof(buf), "%f", value);
   this->content_.append(buf, len);
 }
 
@@ -564,7 +525,7 @@ AsyncEventSourceResponse::AsyncEventSourceResponse(const AsyncWebServerRequest *
 
   // Configure reconnect timeout and send config
   // this should always go through since the tcp send buffer is empty on connect
-  auto message = ws->get_config_json();
+  std::string message = ws->get_config_json();
   this->try_send_nodefer(message.c_str(), "ping", millis(), 30000);
 
 #ifdef USE_WEBSERVER_SORTING
@@ -618,7 +579,7 @@ void AsyncEventSourceResponse::deq_push_back_with_dedup_(void *source, message_g
 void AsyncEventSourceResponse::process_deferred_queue_() {
   while (!deferred_queue_.empty()) {
     DeferredEvent &de = deferred_queue_.front();
-    auto message = de.message_generator_(web_server_, de.source_);
+    std::string message = de.message_generator_(web_server_, de.source_);
     if (this->try_send_nodefer(message.c_str(), "state")) {
       // O(n) but memory efficiency is more important than speed here which is why std::vector was chosen
       deferred_queue_.erase(deferred_queue_.begin());
@@ -855,7 +816,7 @@ void AsyncEventSourceResponse::deferrable_send_state(void *source, const char *e
     // trying to send first
     deq_push_back_with_dedup_(source, message_generator);
   } else {
-    auto message = message_generator(web_server_, source);
+    std::string message = message_generator(web_server_, source);
     if (!this->try_send_nodefer(message.c_str(), "state")) {
       deq_push_back_with_dedup_(source, message_generator);
     }

esphome/components/web_server_idf/web_server_idf.h

@@ -16,7 +16,6 @@
 #include <vector>
 
 #ifdef USE_WEBSERVER
-#include "esphome/components/json/json_util.h"
 #include "esphome/components/web_server/list_entities.h"
 #endif
 
@@ -117,8 +116,7 @@ class AsyncWebServerRequest {
   /// Write URL (without query string) to buffer, returns StringRef pointing to buffer.
   /// URL is decoded (e.g., %20 -> space).
   StringRef url_to(std::span<char, URL_BUF_SIZE> buffer) const;
-  // Remove before 2026.9.0
-  ESPDEPRECATED("Use url_to() instead. Removed in 2026.9.0", "2026.3.0")
+  /// Get URL as std::string. Prefer url_to() to avoid heap allocation.
   std::string url() const {
     char buffer[URL_BUF_SIZE];
     return std::string(this->url_to(buffer));
@@ -172,8 +170,14 @@ class AsyncWebServerRequest {
   AsyncWebParameter *getParam(const std::string &name) { return this->getParam(name.c_str()); }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
-  bool hasArg(const char *name);
-  std::string arg(const char *name);
+  bool hasArg(const char *name) { return this->hasParam(name); }
+  std::string arg(const char *name) {
+    auto *param = this->getParam(name);
+    if (param) {
+      return param->value();
+    }
+    return {};
+  }
   std::string arg(const std::string &name) { return this->arg(name.c_str()); }
 
   operator httpd_req_t *() const { return this->req_; }
@@ -188,7 +192,6 @@ class AsyncWebServerRequest {
   // is faster than tree/hash overhead. AsyncWebParameter stores both name and value to avoid
   // duplicate storage. Only successful lookups are cached to prevent cache pollution when
   // handlers check for optional parameters that don't exist.
-  optional<std::string> find_query_value_(const char *name) const;
   std::vector<AsyncWebParameter *> params_;
   std::string post_query_;
   AsyncWebServerRequest(httpd_req_t *req) : req_(req) {}
@@ -251,7 +254,7 @@ class AsyncWebHandler {
 class AsyncEventSource;
 class AsyncEventSourceResponse;
 
-using message_generator_t = json::SerializationBuffer<>(esphome::web_server::WebServer *, void *);
+using message_generator_t = std::string(esphome::web_server::WebServer *, void *);
 
 /*
   This class holds a pointer to the source component that wants to publish a state event, and a pointer to a function

esphome/components/wifi/__init__.py

@@ -288,6 +288,11 @@ def _validate(config):
         config = config.copy()
         config[CONF_NETWORKS] = []
 
+    if config.get(CONF_FAST_CONNECT, False):
+        networks = config.get(CONF_NETWORKS, [])
+        if not networks:
+            raise cv.Invalid("At least one network required for fast_connect!")
+
     if CONF_USE_ADDRESS not in config:
         use_address = CORE.name + config[CONF_DOMAIN]
         if CONF_MANUAL_IP in config:

esphome/components/wifi/wifi_component.cpp

@@ -3,7 +3,6 @@
 #include <cassert>
 #include <cinttypes>
 #include <cmath>
-#include <type_traits>
 
 #ifdef USE_ESP32
 #if (ESP_IDF_VERSION_MAJOR >= 5 && ESP_IDF_VERSION_MINOR >= 1)
@@ -706,7 +705,7 @@ void WiFiComponent::restart_adapter() {
   // through start_connecting() first. Without this clear, stale errors would
   // trigger spurious "failed (callback)" logs. The canonical clear location
   // is in start_connecting(); this is the only exception to that pattern.
-  this->error_from_callback_ = 0;
+  this->error_from_callback_ = false;
 }
 
 void WiFiComponent::loop() {
@@ -1136,7 +1135,7 @@ void WiFiComponent::start_connecting(const WiFiAP &ap) {
   // This is the canonical location for clearing the flag since all connection
   // attempts go through start_connecting(). The only other clear is in
   // restart_adapter() which enters COOLDOWN without calling start_connecting().
-  this->error_from_callback_ = 0;
+  this->error_from_callback_ = false;
 
   if (!this->wifi_sta_connect_(ap)) {
     ESP_LOGE(TAG, "wifi_sta_connect_ failed");
@@ -1320,61 +1319,20 @@ void WiFiComponent::start_scanning() {
 // Using insertion sort instead of std::stable_sort saves flash memory
 // by avoiding template instantiations (std::rotate, std::stable_sort, lambdas)
 // IMPORTANT: This sort is stable (preserves relative order of equal elements)
-//
-// Uses raw memcpy instead of copy assignment to avoid CompactString's
-// destructor/constructor overhead (heap delete[]/new[] for long SSIDs).
-// Copy assignment calls ~CompactString() then placement-new for every shift,
-// which means delete[]/new[] per shift for heap-allocated SSIDs. With 70+
-// networks (e.g., captive portal showing full scan results), this caused
-// event loop blocking from hundreds of heap operations in a tight loop.
-//
-// This is safe because we're permuting elements within the same array —
-// each slot is overwritten exactly once, so no ownership duplication occurs.
-// All members of WiFiScanResult are either trivially copyable (bssid, channel,
-// rssi, priority, flags) or CompactString, which stores either inline data or
-// a heap pointer — never a self-referential pointer (unlike std::string's SSO
-// on some implementations). This was not possible before PR#13472 replaced
-// std::string with CompactString, since std::string's internal layout is
-// implementation-defined and may use self-referential pointers.
-//
-// TODO: If C++ standardizes std::trivially_relocatable, add the assertion for
-// WiFiScanResult/CompactString here to formally express the memcpy safety guarantee.
 template<typename VectorType> static void insertion_sort_scan_results(VectorType &results) {
-  // memcpy-based sort requires no self-referential pointers or virtual dispatch.
-  // These static_asserts guard the assumptions. If any fire, the memcpy sort
-  // must be reviewed for safety before updating the expected values.
-  //
-  // No vtable pointers (memcpy would corrupt vptr)
-  static_assert(!std::is_polymorphic<WiFiScanResult>::value, "WiFiScanResult must not have vtable");
-  static_assert(!std::is_polymorphic<CompactString>::value, "CompactString must not have vtable");
-  // Standard layout ensures predictable memory layout with no virtual bases
-  // and no mixed-access-specifier reordering
-  static_assert(std::is_standard_layout<WiFiScanResult>::value, "WiFiScanResult must be standard layout");
-  static_assert(std::is_standard_layout<CompactString>::value, "CompactString must be standard layout");
-  // Size checks catch added/removed fields that may need safety review
-  static_assert(sizeof(WiFiScanResult) == 32, "WiFiScanResult size changed - verify memcpy sort is still safe");
-  static_assert(sizeof(CompactString) == 20, "CompactString size changed - verify memcpy sort is still safe");
-  // Alignment must match for reinterpret_cast of key_buf to be valid
-  static_assert(alignof(WiFiScanResult) <= alignof(std::max_align_t), "WiFiScanResult alignment exceeds max_align_t");
   const size_t size = results.size();
-  constexpr size_t elem_size = sizeof(WiFiScanResult);
-  // Suppress warnings for intentional memcpy on non-trivially-copyable type.
-  // Safety is guaranteed by the static_asserts above and the permutation invariant.
-  // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
-  auto *memcpy_fn = &memcpy;
   for (size_t i = 1; i < size; i++) {
-    alignas(WiFiScanResult) uint8_t key_buf[elem_size];
-    memcpy_fn(key_buf, &results[i], elem_size);
-    const auto &key = *reinterpret_cast<const WiFiScanResult *>(key_buf);
+    // Make a copy to avoid issues with move semantics during comparison
+    WiFiScanResult key = results[i];
     int32_t j = i - 1;
 
     // Move elements that are worse than key to the right
     // For stability, we only move if key is strictly better than results[j]
     while (j >= 0 && wifi_scan_result_is_better(key, results[j])) {
-      memcpy_fn(&results[j + 1], &results[j], elem_size);
+      results[j + 1] = results[j];
       j--;
     }
-    memcpy_fn(&results[j + 1], key_buf, elem_size);
+    results[j + 1] = key;
   }
 }
 
@@ -1956,7 +1914,6 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
         (old_priority > std::numeric_limits<int8_t>::min()) ? (old_priority - 1) : std::numeric_limits<int8_t>::min();
     this->set_sta_priority(failed_bssid.value(), new_priority);
   }
-
   char bssid_s[18];
   format_mac_addr_upper(failed_bssid.value().data(), bssid_s);
   ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d", ssid != nullptr ? ssid : "",

esphome/components/wifi/wifi_component.h

@@ -10,7 +10,6 @@
 
 #include <span>
 #include <string>
-#include <type_traits>
 #include <vector>
 
 #ifdef USE_LIBRETINY
@@ -220,14 +219,6 @@ class CompactString {
 };
 
 static_assert(sizeof(CompactString) == 20, "CompactString must be exactly 20 bytes");
-// CompactString is not trivially copyable (non-trivial destructor/copy for heap case).
-// However, its layout has no self-referential pointers: storage_[] contains either inline
-// data or an external heap pointer — never a pointer to itself. This is unlike libstdc++
-// std::string SSO where _M_p points to _M_local_buf within the same object.
-// This property allows memcpy-based permutation sorting where each element ends up in
-// exactly one slot (no ownership duplication). These asserts document that layout property.
-static_assert(std::is_standard_layout<CompactString>::value, "CompactString must be standard layout");
-static_assert(!std::is_polymorphic<CompactString>::value, "CompactString must not have vtable");
 
 class WiFiAP {
   friend class WiFiComponent;
@@ -511,8 +502,6 @@ class WiFiComponent : public Component {
   }
 
   network::IPAddresses wifi_sta_ip_addresses();
-  // Remove before 2026.9.0
-  ESPDEPRECATED("Use wifi_ssid_to() instead. Removed in 2026.9.0", "2026.3.0")
   std::string wifi_ssid();
   /// Write SSID to buffer without heap allocation.
   /// Returns pointer to buffer, or empty string if not connected.

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -775,7 +775,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     }
     s_sta_connected = false;
     s_sta_connecting = false;
-    error_from_callback_ = 1;
+    error_from_callback_ = true;
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
     this->notify_disconnect_state_listeners_();
 #endif

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -495,7 +495,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
                    s_ignored_disconnect_count, get_disconnect_reason_str(it.reason));
           s_sta_state = LTWiFiSTAState::ERROR_FAILED;
           WiFi.disconnect();
-          this->error_from_callback_ = 1;
+          this->error_from_callback_ = true;
           // Don't break - fall through to notify listeners
         } else {
           ESP_LOGV(TAG, "Ignoring disconnect event with empty ssid while connecting (reason=%s, count=%u)",
@@ -521,7 +521,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
           reason == WIFI_REASON_NO_AP_FOUND || reason == WIFI_REASON_ASSOC_FAIL ||
           reason == WIFI_REASON_HANDSHAKE_TIMEOUT) {
         WiFi.disconnect();
-        this->error_from_callback_ = 1;
+        this->error_from_callback_ = true;
       }
 
 #ifdef USE_WIFI_CONNECT_STATE_LISTENERS
@@ -537,7 +537,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
       if (it.old_mode != WIFI_AUTH_OPEN && it.new_mode == WIFI_AUTH_OPEN) {
         ESP_LOGW(TAG, "Potential Authmode downgrade detected, disconnecting");
         WiFi.disconnect();
-        this->error_from_callback_ = 1;
+        this->error_from_callback_ = true;
         s_sta_state = LTWiFiSTAState::ERROR_FAILED;
       }
       break;

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.3.0-dev"
+__version__ = "2026.2.0-dev"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/__init__.py

@@ -766,15 +766,6 @@ 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:
         # Check if using native ESP-IDF build (--native-idf)

esphome/core/application.h

@@ -94,6 +94,9 @@
 #ifdef USE_INFRARED
 #include "esphome/components/infrared/infrared.h"
 #endif
+#ifdef USE_SERIAL_PROXY
+#include "esphome/components/serial_proxy/serial_proxy.h"
+#endif
 #ifdef USE_EVENT
 #include "esphome/components/event/event.h"
 #endif
@@ -234,6 +237,13 @@ class Application {
   void register_infrared(infrared::Infrared *infrared) { this->infrareds_.push_back(infrared); }
 #endif
 
+#ifdef USE_SERIAL_PROXY
+  void register_serial_proxy(serial_proxy::SerialProxy *proxy) {
+    proxy->set_instance_index(this->serial_proxies_.size());
+    this->serial_proxies_.push_back(proxy);
+  }
+#endif
+
 #ifdef USE_EVENT
   void register_event(event::Event *event) { this->events_.push_back(event); }
 #endif
@@ -473,6 +483,10 @@ class Application {
   GET_ENTITY_METHOD(infrared::Infrared, infrared, infrareds)
 #endif
 
+#ifdef USE_SERIAL_PROXY
+  auto &get_serial_proxies() const { return this->serial_proxies_; }
+#endif
+
 #ifdef USE_EVENT
   auto &get_events() const { return this->events_; }
   GET_ENTITY_METHOD(event::Event, event, events)
@@ -690,6 +704,9 @@ class Application {
 #ifdef USE_INFRARED
   StaticVector<infrared::Infrared *, ESPHOME_ENTITY_INFRARED_COUNT> infrareds_{};
 #endif
+#ifdef USE_SERIAL_PROXY
+  std::vector<serial_proxy::SerialProxy *> serial_proxies_{};
+#endif
 #ifdef USE_UPDATE
   StaticVector<update::UpdateEntity *, ESPHOME_ENTITY_UPDATE_COUNT> updates_{};
 #endif

esphome/core/automation.h

@@ -4,7 +4,6 @@
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"
 #include <concepts>
 #include <functional>
@@ -57,16 +56,6 @@ template<typename T, typename... X> class TemplatableValue {
     this->static_str_ = str;
   }
 
-#ifdef USE_ESP8266
-  // On ESP8266, __FlashStringHelper* is a distinct type from const char*.
-  // ESPHOME_F(s) expands to F(s) which returns __FlashStringHelper* pointing to PROGMEM.
-  // Store as FLASH_STRING — value()/is_empty()/ref_or_copy_to() use _P functions
-  // to access the PROGMEM pointer safely.
-  TemplatableValue(const __FlashStringHelper *str) requires std::same_as<T, std::string> : type_(FLASH_STRING) {
-    this->static_str_ = reinterpret_cast<const char *>(str);
-  }
-#endif
-
   template<typename F> TemplatableValue(F value) requires(!std::invocable<F, X...>) : type_(VALUE) {
     if constexpr (USE_HEAP_STORAGE) {
       this->value_ = new T(std::move(value));
@@ -100,7 +89,7 @@ template<typename T, typename... X> class TemplatableValue {
       this->f_ = new std::function<T(X...)>(*other.f_);
     } else if (this->type_ == STATELESS_LAMBDA) {
       this->stateless_f_ = other.stateless_f_;
-    } else if (this->type_ == STATIC_STRING || this->type_ == FLASH_STRING) {
+    } else if (this->type_ == STATIC_STRING) {
       this->static_str_ = other.static_str_;
     }
   }
@@ -119,7 +108,7 @@ template<typename T, typename... X> class TemplatableValue {
       other.f_ = nullptr;
     } else if (this->type_ == STATELESS_LAMBDA) {
       this->stateless_f_ = other.stateless_f_;
-    } else if (this->type_ == STATIC_STRING || this->type_ == FLASH_STRING) {
+    } else if (this->type_ == STATIC_STRING) {
       this->static_str_ = other.static_str_;
     }
     other.type_ = NONE;
@@ -152,7 +141,7 @@ template<typename T, typename... X> class TemplatableValue {
     } else if (this->type_ == LAMBDA) {
       delete this->f_;
     }
-    // STATELESS_LAMBDA/STATIC_STRING/FLASH_STRING/NONE: no cleanup needed (pointers, not heap-allocated)
+    // STATELESS_LAMBDA/STATIC_STRING/NONE: no cleanup needed (pointers, not heap-allocated)
   }
 
   bool has_value() const { return this->type_ != NONE; }
@@ -176,17 +165,6 @@ template<typename T, typename... X> class TemplatableValue {
           return std::string(this->static_str_);
         }
         __builtin_unreachable();
-#ifdef USE_ESP8266
-      case FLASH_STRING:
-        // PROGMEM pointer — must use _P functions to access on ESP8266
-        if constexpr (std::same_as<T, std::string>) {
-          size_t len = strlen_P(this->static_str_);
-          std::string result(len, '\0');
-          memcpy_P(result.data(), this->static_str_, len);
-          return result;
-        }
-        __builtin_unreachable();
-#endif
       case NONE:
       default:
         return T{};
@@ -208,12 +186,9 @@ template<typename T, typename... X> class TemplatableValue {
   }
 
   /// Check if this holds a static string (const char* stored without allocation)
-  /// The pointer is always directly readable (RAM or flash-mapped).
-  /// Returns false for FLASH_STRING (PROGMEM on ESP8266, requires _P functions).
   bool is_static_string() const { return this->type_ == STATIC_STRING; }
 
   /// Get the static string pointer (only valid if is_static_string() returns true)
-  /// The pointer is always directly readable — FLASH_STRING uses a separate type.
   const char *get_static_string() const { return this->static_str_; }
 
   /// Check if the string value is empty without allocating (for std::string specialization).
@@ -225,12 +200,6 @@ template<typename T, typename... X> class TemplatableValue {
         return true;
       case STATIC_STRING:
         return this->static_str_ == nullptr || this->static_str_[0] == '\0';
-#ifdef USE_ESP8266
-      case FLASH_STRING:
-        // PROGMEM pointer — must use progmem_read_byte on ESP8266
-        return this->static_str_ == nullptr ||
-               progmem_read_byte(reinterpret_cast<const uint8_t *>(this->static_str_)) == '\0';
-#endif
       case VALUE:
         return this->value_->empty();
       default:  // LAMBDA/STATELESS_LAMBDA - must call value()
@@ -240,9 +209,8 @@ template<typename T, typename... X> class TemplatableValue {
 
   /// Get a StringRef to the string value without heap allocation when possible.
   /// For STATIC_STRING/VALUE, returns reference to existing data (no allocation).
-  /// For FLASH_STRING (ESP8266 PROGMEM), copies to provided buffer via _P functions.
   /// For LAMBDA/STATELESS_LAMBDA, calls value(), copies to provided buffer, returns ref to buffer.
-  /// @param lambda_buf Buffer used only for copy cases (must remain valid while StringRef is used).
+  /// @param lambda_buf Buffer used only for lambda case (must remain valid while StringRef is used).
   /// @param lambda_buf_size Size of the buffer.
   /// @return StringRef pointing to the string data.
   StringRef ref_or_copy_to(char *lambda_buf, size_t lambda_buf_size) const requires std::same_as<T, std::string> {
@@ -253,19 +221,6 @@ template<typename T, typename... X> class TemplatableValue {
         if (this->static_str_ == nullptr)
           return StringRef();
         return StringRef(this->static_str_, strlen(this->static_str_));
-#ifdef USE_ESP8266
-      case FLASH_STRING:
-        if (this->static_str_ == nullptr)
-          return StringRef();
-        {
-          // PROGMEM pointer — copy to buffer via _P functions
-          size_t len = strlen_P(this->static_str_);
-          size_t copy_len = std::min(len, lambda_buf_size - 1);
-          memcpy_P(lambda_buf, this->static_str_, copy_len);
-          lambda_buf[copy_len] = '\0';
-          return StringRef(lambda_buf, copy_len);
-        }
-#endif
       case VALUE:
         return StringRef(this->value_->data(), this->value_->size());
       default: {  // LAMBDA/STATELESS_LAMBDA - must call value() and copy
@@ -284,7 +239,6 @@ template<typename T, typename... X> class TemplatableValue {
    LAMBDA,
    STATELESS_LAMBDA,
    STATIC_STRING,  // For const char* when T is std::string - avoids heap allocation
-   FLASH_STRING,   // PROGMEM pointer on ESP8266; never set on other platforms
  } type_;
   // For std::string, use heap pointer to minimize union size (4 bytes vs 12+).
   // For other types, store value inline as before.
@@ -293,7 +247,7 @@ template<typename T, typename... X> class TemplatableValue {
     ValueStorage value_;  // T for inline storage, T* for heap storage
     std::function<T(X...)> *f_;
     T (*stateless_f_)(X...);
-    const char *static_str_;  // For STATIC_STRING and FLASH_STRING types
+    const char *static_str_;  // For STATIC_STRING type
   };
 };
 

esphome/core/defines.h

@@ -109,6 +109,7 @@
 #define USE_SAFE_MODE_CALLBACK
 #define USE_SELECT
 #define USE_SENSOR
+#define USE_SERIAL_PROXY
 #define USE_STATUS_LED
 #define USE_STATUS_SENSOR
 #define USE_SWITCH
@@ -239,15 +240,9 @@
 #define USB_HOST_MAX_REQUESTS 16
 
 #ifdef USE_ARDUINO
-#define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 3, 7)
+#define USE_ARDUINO_VERSION_CODE VERSION_CODE(3, 3, 6)
 #define USE_ETHERNET
-#define USE_ETHERNET_LAN8720
-#define USE_ETHERNET_RTL8201
-#define USE_ETHERNET_DP83848
-#define USE_ETHERNET_IP101
-#define USE_ETHERNET_JL1101
 #define USE_ETHERNET_KSZ8081
-#define USE_ETHERNET_LAN8670
 #define USE_ETHERNET_MANUAL_IP
 #define USE_ETHERNET_IP_STATE_LISTENERS
 #define USE_ETHERNET_CONNECT_TRIGGER

esphome/core/helpers.cpp

@@ -348,10 +348,7 @@ std::string format_hex(const uint8_t *data, size_t length) {
   format_hex_to(&ret[0], length * 2 + 1, data, length);
   return ret;
 }
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 std::string format_hex(const std::vector<uint8_t> &data) { return format_hex(data.data(), data.size()); }
-#pragma GCC diagnostic pop
 
 char *format_hex_pretty_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator) {
   return format_hex_internal(buffer, buffer_size, data, length, separator, 'A');
@@ -520,8 +517,10 @@ int8_t step_to_accuracy_decimals(float step) {
   return str.length() - dot_pos - 1;
 }
 
-// Store BASE64 characters as array - automatically placed in flash/ROM on embedded platforms
-static const char BASE64_CHARS[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+// Use C-style string constant to store in ROM instead of RAM (saves 24 bytes)
+static constexpr const char *BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                            "abcdefghijklmnopqrstuvwxyz"
+                                            "0123456789+/";
 
 // Helper function to find the index of a base64/base64url character in the lookup table.
 // Returns the character's position (0-63) if found, or 0 if not found.

esphome/core/helpers.h

@@ -133,78 +133,6 @@ template<typename T> class ConstVector {
   size_t size_;
 };
 
-/// Small buffer optimization - stores data inline when small, heap-allocates for large data
-/// This avoids heap fragmentation for common small allocations while supporting arbitrary sizes.
-/// Memory management is encapsulated - callers just use set() and data().
-template<size_t InlineSize = 8> class SmallInlineBuffer {
- public:
-  SmallInlineBuffer() = default;
-  ~SmallInlineBuffer() {
-    if (!this->is_inline_())
-      delete[] this->heap_;
-  }
-
-  // Move constructor
-  SmallInlineBuffer(SmallInlineBuffer &&other) noexcept : len_(other.len_) {
-    if (other.is_inline_()) {
-      memcpy(this->inline_, other.inline_, this->len_);
-    } else {
-      this->heap_ = other.heap_;
-      other.heap_ = nullptr;
-    }
-    other.len_ = 0;
-  }
-
-  // Move assignment
-  SmallInlineBuffer &operator=(SmallInlineBuffer &&other) noexcept {
-    if (this != &other) {
-      if (!this->is_inline_())
-        delete[] this->heap_;
-      this->len_ = other.len_;
-      if (other.is_inline_()) {
-        memcpy(this->inline_, other.inline_, this->len_);
-      } else {
-        this->heap_ = other.heap_;
-        other.heap_ = nullptr;
-      }
-      other.len_ = 0;
-    }
-    return *this;
-  }
-
-  // Disable copy (would need deep copy of heap data)
-  SmallInlineBuffer(const SmallInlineBuffer &) = delete;
-  SmallInlineBuffer &operator=(const SmallInlineBuffer &) = delete;
-
-  /// Set buffer contents, allocating heap if needed
-  void set(const uint8_t *src, size_t size) {
-    // Free existing heap allocation if switching from heap to inline or different heap size
-    if (!this->is_inline_() && (size <= InlineSize || size != this->len_)) {
-      delete[] this->heap_;
-      this->heap_ = nullptr;  // Defensive: prevent use-after-free if logic changes
-    }
-    // Allocate new heap buffer if needed
-    if (size > InlineSize && (this->is_inline_() || size != this->len_)) {
-      this->heap_ = new uint8_t[size];  // NOLINT(cppcoreguidelines-owning-memory)
-    }
-    this->len_ = size;
-    memcpy(this->data(), src, size);
-  }
-
-  uint8_t *data() { return this->is_inline_() ? this->inline_ : this->heap_; }
-  const uint8_t *data() const { return this->is_inline_() ? this->inline_ : this->heap_; }
-  size_t size() const { return this->len_; }
-
- protected:
-  bool is_inline_() const { return this->len_ <= InlineSize; }
-
-  size_t len_{0};
-  union {
-    uint8_t inline_[InlineSize]{};  // Zero-init ensures clean initial state
-    uint8_t *heap_;
-  };
-};
-
 /// Minimal static vector - saves memory by avoiding std::vector overhead
 template<typename T, size_t N> class StaticVector {
  public:
@@ -269,9 +197,6 @@ 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_; }
-
   // Direct access to underlying data
   T *data() { return data_.data(); }
   const T *data() const { return data_.data(); }
@@ -1143,17 +1068,13 @@ std::string format_hex(const std::vector<uint8_t> &data);
 /// Causes heap fragmentation on long-running devices.
 template<typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0> std::string format_hex(T val) {
   val = convert_big_endian(val);
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
   return format_hex(reinterpret_cast<uint8_t *>(&val), sizeof(T));
-#pragma GCC diagnostic pop
 }
 /// Format the std::array \p data in lowercased hex.
 /// @warning Allocates heap memory. Use format_hex_to() with a stack buffer instead.
 /// Causes heap fragmentation on long-running devices.
 template<std::size_t N> std::string format_hex(const std::array<uint8_t, N> &data) {
   return format_hex(data.data(), data.size());
-#pragma GCC diagnostic pop
 }
 
 /** Format a byte array in pretty-printed, human-readable hex format.
@@ -1162,9 +1083,6 @@ template<std::size_t N> std::string format_hex(const std::array<uint8_t, N> &dat
  * Each byte is displayed as a two-digit uppercase hex value, separated by the specified separator.
  * Optionally includes the total byte count in parentheses at the end.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Pointer to the byte array to format.
  * @param length Number of bytes in the array.
  * @param separator Character to use between hex bytes (default: '.').
@@ -1190,9 +1108,6 @@ std::string format_hex_pretty(const uint8_t *data, size_t length, char separator
  *
  * Similar to the byte array version, but formats 16-bit words as 4-digit hex values.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Pointer to the 16-bit word array to format.
  * @param length Number of 16-bit words in the array.
  * @param separator Character to use between hex words (default: '.').
@@ -1216,9 +1131,6 @@ std::string format_hex_pretty(const uint16_t *data, size_t length, char separato
  * Convenience overload for std::vector<uint8_t>. Formats each byte as a two-digit
  * uppercase hex value with customizable separator.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Vector of bytes to format.
  * @param separator Character to use between hex bytes (default: '.').
  * @param show_length Whether to append the byte count in parentheses (default: true).
@@ -1242,9 +1154,6 @@ std::string format_hex_pretty(const std::vector<uint8_t> &data, char separator =
  * Convenience overload for std::vector<uint16_t>. Each 16-bit word is formatted
  * as a 4-digit uppercase hex value in big-endian order.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data Vector of 16-bit words to format.
  * @param separator Character to use between hex words (default: '.').
  * @param show_length Whether to append the word count in parentheses (default: true).
@@ -1267,9 +1176,6 @@ std::string format_hex_pretty(const std::vector<uint16_t> &data, char separator
  * Treats each character in the string as a byte and formats it in hex.
  * Useful for debugging binary data stored in std::string containers.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @param data String whose bytes should be formatted as hex.
  * @param separator Character to use between hex bytes (default: '.').
  * @param show_length Whether to append the byte count in parentheses (default: true).
@@ -1292,9 +1198,6 @@ std::string format_hex_pretty(const std::string &data, char separator = '.', boo
  * Converts the integer to big-endian byte order and formats each byte as hex.
  * The most significant byte appears first in the output string.
  *
- * @warning Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.
- * Causes heap fragmentation on long-running devices.
- *
  * @tparam T Unsigned integer type (uint8_t, uint16_t, uint32_t, uint64_t, etc.).
  * @param val The unsigned integer value to format.
  * @param separator Character to use between hex bytes (default: '.').

esphome/core/scheduler.h

@@ -149,9 +149,10 @@ class Scheduler {
     } name_;
     uint32_t interval;
     // Split time to handle millis() rollover. The scheduler combines the 32-bit millis()
-    // with a 16-bit rollover counter to create a 48-bit time space (stored as 64-bit
-    // for compatibility). With 49.7 days per 32-bit rollover, the 16-bit counter
-    // supports 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
+    // with a 16-bit rollover counter to create a 48-bit time space (using 32+16 bits).
+    // This is intentionally limited to 48 bits, not stored as a full 64-bit value.
+    // With 49.7 days per 32-bit rollover, the 16-bit counter supports
+    // 49.7 days × 65536 = ~8900 years. This ensures correct scheduling
     // even when devices run for months. Split into two fields for better memory
     // alignment on 32-bit systems.
     uint32_t next_execution_low_;  // Lower 32 bits of execution time (millis value)

esphome/core/time.cpp

@@ -2,6 +2,7 @@
 #include "helpers.h"
 
 #include <algorithm>
+#include <cinttypes>
 
 namespace esphome {
 
@@ -66,121 +67,56 @@ std::string ESPTime::strftime(const char *format) {
 
 std::string ESPTime::strftime(const std::string &format) { return this->strftime(format.c_str()); }
 
-// Helper to parse exactly N digits, returns false if not enough digits
-static bool parse_digits(const char *&p, const char *end, int count, uint16_t &value) {
-  value = 0;
-  for (int i = 0; i < count; i++) {
-    if (p >= end || *p < '0' || *p > '9')
-      return false;
-    value = value * 10 + (*p - '0');
-    p++;
-  }
-  return true;
-}
-
-// Helper to check for expected character
-static bool expect_char(const char *&p, const char *end, char expected) {
-  if (p >= end || *p != expected)
-    return false;
-  p++;
-  return true;
-}
-
 bool ESPTime::strptime(const char *time_to_parse, size_t len, ESPTime &esp_time) {
-  // Supported formats:
-  //   YYYY-MM-DD HH:MM:SS (19 chars)
-  //   YYYY-MM-DD HH:MM    (16 chars)
-  //   YYYY-MM-DD          (10 chars)
-  //   HH:MM:SS            (8 chars)
-  //   HH:MM               (5 chars)
+  uint16_t year;
+  uint8_t month;
+  uint8_t day;
+  uint8_t hour;
+  uint8_t minute;
+  uint8_t second;
+  int num;
+  const int ilen = static_cast<int>(len);
 
-  if (time_to_parse == nullptr || len == 0)
+  if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+             &hour,                                                                              // NOLINT
+             &minute,                                                                            // NOLINT
+             &second, &num) == 6 &&                                                              // NOLINT
+      num == ilen) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = second;
+  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %02hhu:%02hhu %n", &year, &month, &day,  // NOLINT
+                    &hour,                                                                       // NOLINT
+                    &minute, &num) == 5 &&                                                       // NOLINT
+             num == ilen) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = 0;
+  } else if (sscanf(time_to_parse, "%02hhu:%02hhu:%02hhu %n", &hour, &minute, &second, &num) == 3 &&  // NOLINT
+             num == ilen) {
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = second;
+  } else if (sscanf(time_to_parse, "%02hhu:%02hhu %n", &hour, &minute, &num) == 2 &&  // NOLINT
+             num == ilen) {
+    esp_time.hour = hour;
+    esp_time.minute = minute;
+    esp_time.second = 0;
+  } else if (sscanf(time_to_parse, "%04hu-%02hhu-%02hhu %n", &year, &month, &day, &num) == 3 &&  // NOLINT
+             num == ilen) {
+    esp_time.year = year;
+    esp_time.month = month;
+    esp_time.day_of_month = day;
+  } else {
     return false;
-
-  const char *p = time_to_parse;
-  const char *end = time_to_parse + len;
-  uint16_t v1, v2, v3, v4, v5, v6;
-
-  // Try date formats first (start with 4-digit year)
-  if (len >= 10 && time_to_parse[4] == '-') {
-    // YYYY-MM-DD...
-    if (!parse_digits(p, end, 4, v1))
-      return false;
-    if (!expect_char(p, end, '-'))
-      return false;
-    if (!parse_digits(p, end, 2, v2))
-      return false;
-    if (!expect_char(p, end, '-'))
-      return false;
-    if (!parse_digits(p, end, 2, v3))
-      return false;
-
-    esp_time.year = v1;
-    esp_time.month = v2;
-    esp_time.day_of_month = v3;
-
-    if (p == end) {
-      // YYYY-MM-DD (date only)
-      return true;
-    }
-
-    if (!expect_char(p, end, ' '))
-      return false;
-
-    // Continue with time part: HH:MM[:SS]
-    if (!parse_digits(p, end, 2, v4))
-      return false;
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v5))
-      return false;
-
-    esp_time.hour = v4;
-    esp_time.minute = v5;
-
-    if (p == end) {
-      // YYYY-MM-DD HH:MM
-      esp_time.second = 0;
-      return true;
-    }
-
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v6))
-      return false;
-
-    esp_time.second = v6;
-    return p == end;  // YYYY-MM-DD HH:MM:SS
   }
-
-  // Try time-only formats (HH:MM[:SS])
-  if (len >= 5 && time_to_parse[2] == ':') {
-    if (!parse_digits(p, end, 2, v1))
-      return false;
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v2))
-      return false;
-
-    esp_time.hour = v1;
-    esp_time.minute = v2;
-
-    if (p == end) {
-      // HH:MM
-      esp_time.second = 0;
-      return true;
-    }
-
-    if (!expect_char(p, end, ':'))
-      return false;
-    if (!parse_digits(p, end, 2, v3))
-      return false;
-
-    esp_time.second = v3;
-    return p == end;  // HH:MM:SS
-  }
-
-  return false;
+  return true;
 }
 
 void ESPTime::increment_second() {
@@ -257,67 +193,27 @@ void ESPTime::recalc_timestamp_utc(bool use_day_of_year) {
 }
 
 void ESPTime::recalc_timestamp_local() {
-#ifdef USE_TIME_TIMEZONE
-  // Calculate timestamp as if fields were UTC
-  this->recalc_timestamp_utc(false);
-  if (this->timestamp == -1) {
-    return;  // Invalid time
-  }
+  struct tm tm;
 
-  // Now convert from local to UTC by adding the offset
-  // POSIX: local = utc - offset, so utc = local + offset
-  const auto &tz = time::get_global_tz();
+  tm.tm_year = this->year - 1900;
+  tm.tm_mon = this->month - 1;
+  tm.tm_mday = this->day_of_month;
+  tm.tm_hour = this->hour;
+  tm.tm_min = this->minute;
+  tm.tm_sec = this->second;
+  tm.tm_isdst = -1;
 
-  if (!tz.has_dst()) {
-    // No DST - just apply standard offset
-    this->timestamp += tz.std_offset_seconds;
-    return;
-  }
-
-  // Try both interpretations to match libc mktime() with tm_isdst=-1
-  // For ambiguous times (fall-back repeated hour), prefer standard time
-  // For invalid times (spring-forward skipped hour), libc normalizes forward
-  time_t utc_if_dst = this->timestamp + tz.dst_offset_seconds;
-  time_t utc_if_std = this->timestamp + tz.std_offset_seconds;
-
-  bool dst_valid = time::is_in_dst(utc_if_dst, tz);
-  bool std_valid = !time::is_in_dst(utc_if_std, tz);
-
-  if (dst_valid && std_valid) {
-    // Ambiguous time (repeated hour during fall-back) - prefer standard time
-    this->timestamp = utc_if_std;
-  } else if (dst_valid) {
-    // Only DST interpretation is valid
-    this->timestamp = utc_if_dst;
-  } else if (std_valid) {
-    // Only standard interpretation is valid
-    this->timestamp = utc_if_std;
-  } else {
-    // Invalid time (skipped hour during spring-forward)
-    // libc normalizes forward: 02:30 CST -> 08:30 UTC -> 03:30 CDT
-    // Using std offset achieves this since the UTC result falls during DST
-    this->timestamp = utc_if_std;
-  }
-#else
-  // No timezone support - treat as UTC
-  this->recalc_timestamp_utc(false);
-#endif
+  this->timestamp = mktime(&tm);
 }
 
 int32_t ESPTime::timezone_offset() {
-#ifdef USE_TIME_TIMEZONE
   time_t now = ::time(nullptr);
-  const auto &tz = time::get_global_tz();
-  // POSIX offset is positive west, but we return offset to add to UTC to get local
-  // So we negate the POSIX offset
-  if (time::is_in_dst(now, tz)) {
-    return -tz.dst_offset_seconds;
-  }
-  return -tz.std_offset_seconds;
-#else
-  // No timezone support - no offset
-  return 0;
-#endif
+  struct tm local_tm = *::localtime(&now);
+  local_tm.tm_isdst = 0;  // Cause mktime to ignore daylight saving time because we want to include it in the offset.
+  time_t local_time = mktime(&local_tm);
+  struct tm utc_tm = *::gmtime(&now);
+  time_t utc_time = mktime(&utc_tm);
+  return static_cast<int32_t>(local_time - utc_time);
 }
 
 bool ESPTime::operator<(const ESPTime &other) const { return this->timestamp < other.timestamp; }

esphome/core/time.h

@@ -7,10 +7,6 @@
 #include <span>
 #include <string>
 
-#ifdef USE_TIME_TIMEZONE
-#include "esphome/components/time/posix_tz.h"
-#endif
-
 namespace esphome {
 
 template<typename T> bool increment_time_value(T &current, uint16_t begin, uint16_t end);
@@ -109,17 +105,11 @@ struct ESPTime {
    * @return The generated ESPTime
    */
   static ESPTime from_epoch_local(time_t epoch) {
-#ifdef USE_TIME_TIMEZONE
-    struct tm local_tm;
-    if (time::epoch_to_local_tm(epoch, time::get_global_tz(), &local_tm)) {
-      return ESPTime::from_c_tm(&local_tm, epoch);
+    struct tm *c_tm = ::localtime(&epoch);
+    if (c_tm == nullptr) {
+      return ESPTime{};  // Return an invalid ESPTime
     }
-    // Fallback to UTC if conversion failed
-    return ESPTime::from_epoch_utc(epoch);
-#else
-    // No timezone support - return UTC (no TZ configured, localtime would return UTC anyway)
-    return ESPTime::from_epoch_utc(epoch);
-#endif
+    return ESPTime::from_c_tm(c_tm, epoch);
   }
   /** Convert an UTC epoch timestamp to a UTC time ESPTime instance.
    *

esphome/cpp_generator.py

@@ -247,23 +247,6 @@ class LogStringLiteral(Literal):
         return f"LOG_STR({cpp_string_escape(self.string)})"
 
 
-class FlashStringLiteral(Literal):
-    """A string literal wrapped in ESPHOME_F() for PROGMEM storage on ESP8266.
-
-    On ESP8266, ESPHOME_F(s) expands to F(s) which stores the string in flash (PROGMEM).
-    On other platforms, ESPHOME_F(s) expands to plain s (no-op).
-    """
-
-    __slots__ = ("string",)
-
-    def __init__(self, string: str) -> None:
-        super().__init__()
-        self.string = string
-
-    def __str__(self) -> str:
-        return f"ESPHOME_F({cpp_string_escape(self.string)})"
-
-
 class IntLiteral(Literal):
     __slots__ = ("i",)
 
@@ -778,10 +761,6 @@ async def templatable(
     if is_template(value):
         return await process_lambda(value, args, return_type=output_type)
     if to_exp is None:
-        # Automatically wrap static strings in ESPHOME_F() for PROGMEM storage on ESP8266.
-        # On other platforms ESPHOME_F() is a no-op returning const char*.
-        if isinstance(value, str) and str(output_type) == "std::string":
-            return FlashStringLiteral(value)
         return value
     if isinstance(to_exp, dict):
         return to_exp[value]

esphome/platformio_api.py

@@ -173,16 +173,7 @@ 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]}"]
-    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
+    return run_platformio_cli_run(config, verbose, *args)
 
 
 def _run_idedata(config):
@@ -436,74 +427,3 @@ class IDEData:
     def defines(self) -> list[str]:
         """Return the list of preprocessor defines from idedata."""
         return self.raw.get("defines", [])
-
-
-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.cli import MemoryAnalyzerCLI
-    from esphome.analyze_memory.helpers import get_esphome_components
-
-    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
-    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 = MemoryAnalyzerCLI(
-        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

@@ -133,9 +133,9 @@ extra_scripts = post:esphome/components/esp8266/post_build.py.script
 ; This are common settings for the ESP32 (all variants) using Arduino.
 [common:esp32-arduino]
 extends = common:arduino
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip
 platform_packages =
-    pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/3.3.7/esp32-core-3.3.7.tar.xz
+    pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/3.3.6/esp32-core-3.3.6.tar.xz
     pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.2/esp-idf-v5.5.2.tar.xz
 
 framework = arduino, espidf  ; Arduino as an ESP-IDF component
@@ -169,7 +169,7 @@ extra_scripts = post:esphome/components/esp32/post_build.py.script
 ; This are common settings for the ESP32 (all variants) using IDF.
 [common:esp32-idf]
 extends = common:idf
-platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.37/platform-espressif32.zip
+platform = https://github.com/pioarduino/platform-espressif32/releases/download/55.03.36/platform-espressif32.zip
 platform_packages =
     pioarduino/framework-espidf@https://github.com/pioarduino/esp-idf/releases/download/v5.5.2/esp-idf-v5.5.2.tar.xz
 

pyproject.toml

@@ -20,8 +20,8 @@ classifiers = [
     "Topic :: Home Automation",
 ]
 
-# Python 3.14 is not supported on Windows, see https://github.com/zephyrproject-rtos/windows-curses/issues/76
-requires-python = ">=3.11.0,<3.15"
+# Python 3.14 is currently not supported by IDF <= 5.5.1, see https://github.com/esphome/esphome/issues/11502
+requires-python = ">=3.11.0,<3.14"
 
 dynamic = ["dependencies", "optional-dependencies", "version"]
 

script/build_language_schema.py

@@ -369,7 +369,7 @@ def get_logger_tags():
         "api.service",
     ]
     for file in CORE_COMPONENTS_PATH.rglob("*.cpp"):
-        data = file.read_text(encoding="utf-8")
+        data = file.read_text()
         match = pattern.search(data)
         if match:
             tags.append(match.group(1))

script/cpp_unit_test.py

@@ -66,7 +66,6 @@ def create_test_config(config_name: str, includes: list[str]) -> dict:
                 ],
                 "build_flags": [
                     "-Og",  # optimize for debug
-                    "-DUSE_TIME_TIMEZONE",  # enable timezone code paths for testing
                 ],
                 "debug_build_flags": [  # only for debug builds
                     "-g3",  # max debug info