[wifi] Use wifi_ssid_to() to avoid heap allocations in automation and connection checks

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

esphome/components/alarm_control_panel/alarm_control_panel.cpp

@@ -8,8 +8,7 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 static const char *const TAG = "alarm_control_panel";
 
@@ -115,5 +114,4 @@ void AlarmControlPanel::disarm(optional<std::string> code) {
   call.perform();
 }
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <map>
-
 #include "alarm_control_panel_call.h"
 #include "alarm_control_panel_state.h"
 
@@ -9,8 +7,7 @@
 #include "esphome/core/entity_base.h"
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 enum AlarmControlPanelFeature : uint8_t {
   // Matches Home Assistant values
@@ -141,5 +138,4 @@ class AlarmControlPanel : public EntityBase {
   LazyCallbackManager<void()> ready_callback_{};
 };
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_call.cpp

@@ -4,8 +4,7 @@
 
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 static const char *const TAG = "alarm_control_panel";
 
@@ -99,5 +98,4 @@ void AlarmControlPanelCall::perform() {
   }
 }
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_call.h

@@ -6,8 +6,7 @@
 
 #include "esphome/core/helpers.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 class AlarmControlPanel;
 
@@ -36,5 +35,4 @@ class AlarmControlPanelCall {
   void validate_();
 };
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_state.cpp

@@ -1,7 +1,6 @@
 #include "alarm_control_panel_state.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState state) {
   switch (state) {
@@ -30,5 +29,4 @@ const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState stat
   }
 }
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/alarm_control_panel_state.h

@@ -3,8 +3,7 @@
 #include <cstdint>
 #include "esphome/core/log.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 enum AlarmControlPanelState : uint8_t {
   ACP_STATE_DISARMED = 0,
@@ -25,5 +24,4 @@ enum AlarmControlPanelState : uint8_t {
  */
 const LogString *alarm_control_panel_state_to_string(AlarmControlPanelState state);
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/alarm_control_panel/automation.h

@@ -3,8 +3,7 @@
 #include "esphome/core/automation.h"
 #include "alarm_control_panel.h"
 
-namespace esphome {
-namespace alarm_control_panel {
+namespace esphome::alarm_control_panel {
 
 /// Trigger on any state change
 class StateTrigger : public Trigger<> {
@@ -165,5 +164,4 @@ template<typename... Ts> class AlarmControlPanelCondition : public Condition<Ts.
   AlarmControlPanel *parent_;
 };
 
-}  // namespace alarm_control_panel
-}  // namespace esphome
+}  // namespace esphome::alarm_control_panel

esphome/components/api/api.proto

@@ -102,7 +102,7 @@ message HelloRequest {
   // For example "Home Assistant"
   // Not strictly necessary to send but nice for debugging
   // purposes.
-  string client_info = 1 [(pointer_to_buffer) = true];
+  string client_info = 1;
   uint32 api_version_major = 2;
   uint32 api_version_minor = 3;
 }
@@ -139,7 +139,7 @@ message AuthenticationRequest {
   option (ifdef) = "USE_API_PASSWORD";
 
   // The password to log in with
-  string password = 1 [(pointer_to_buffer) = true];
+  string password = 1;
 }
 
 // Confirmation of successful connection. After this the connection is available for all traffic.
@@ -477,7 +477,7 @@ message FanCommandRequest {
   bool has_speed_level = 10;
   int32 speed_level = 11;
   bool has_preset_mode = 12;
-  string preset_mode = 13 [(pointer_to_buffer) = true];
+  string preset_mode = 13;
   uint32 device_id = 14 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -579,7 +579,7 @@ message LightCommandRequest {
   bool has_flash_length = 16;
   uint32 flash_length = 17;
   bool has_effect = 18;
-  string effect = 19 [(pointer_to_buffer) = true];
+  string effect = 19;
   uint32 device_id = 28 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -747,7 +747,7 @@ message NoiseEncryptionSetKeyRequest {
   option (source) = SOURCE_CLIENT;
   option (ifdef) = "USE_API_NOISE";
 
-  bytes key = 1 [(pointer_to_buffer) = true];
+  bytes key = 1;
 }
 
 message NoiseEncryptionSetKeyResponse {
@@ -796,7 +796,7 @@ message HomeassistantActionResponse {
   uint32 call_id = 1; // Matches the call_id from HomeassistantActionRequest
   bool success = 2; // Whether the service call succeeded
   string error_message = 3; // Error message if success = false
-  bytes response_data = 4 [(pointer_to_buffer) = true, (field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
+  bytes response_data = 4 [(field_ifdef) = "USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON"];
 }
 
 // ==================== IMPORT HOME ASSISTANT STATES ====================
@@ -824,9 +824,9 @@ message HomeAssistantStateResponse {
   option (no_delay) = true;
   option (ifdef) = "USE_API_HOMEASSISTANT_STATES";
 
-  string entity_id = 1 [(pointer_to_buffer) = true];
-  string state = 2 [(pointer_to_buffer) = true];
-  string attribute = 3 [(pointer_to_buffer) = true];
+  string entity_id = 1;
+  string state = 2;
+  string attribute = 3;
 }
 
 // ==================== IMPORT TIME ====================
@@ -841,7 +841,7 @@ message GetTimeResponse {
   option (no_delay) = true;
 
   fixed32 epoch_seconds = 1;
-  string timezone = 2 [(pointer_to_buffer) = true];
+  string timezone = 2;
 }
 
 // ==================== USER-DEFINES SERVICES ====================
@@ -1091,11 +1091,11 @@ message ClimateCommandRequest {
   bool has_swing_mode = 14;
   ClimateSwingMode swing_mode = 15;
   bool has_custom_fan_mode = 16;
-  string custom_fan_mode = 17 [(pointer_to_buffer) = true];
+  string custom_fan_mode = 17;
   bool has_preset = 18;
   ClimatePreset preset = 19;
   bool has_custom_preset = 20;
-  string custom_preset = 21 [(pointer_to_buffer) = true];
+  string custom_preset = 21;
   bool has_target_humidity = 22;
   float target_humidity = 23;
   uint32 device_id = 24 [(field_ifdef) = "USE_DEVICES"];
@@ -1274,7 +1274,7 @@ message SelectCommandRequest {
   option (base_class) = "CommandProtoMessage";
 
   fixed32 key = 1;
-  string state = 2 [(pointer_to_buffer) = true];
+  string state = 2;
   uint32 device_id = 3 [(field_ifdef) = "USE_DEVICES"];
 }
 
@@ -1292,7 +1292,7 @@ message ListEntitiesSirenResponse {
 
   string icon = 5 [(field_ifdef) = "USE_ENTITY_ICON"];
   bool disabled_by_default = 6;
-  repeated string tones = 7;
+  repeated string tones = 7 [(container_pointer_no_template) = "FixedVector<const char *>"];
   bool supports_duration = 8;
   bool supports_volume = 9;
   EntityCategory entity_category = 10;
@@ -1692,7 +1692,7 @@ message BluetoothGATTWriteRequest {
   uint32 handle = 2;
   bool response = 3;
 
-  bytes data = 4 [(pointer_to_buffer) = true];
+  bytes data = 4;
 }
 
 message BluetoothGATTReadDescriptorRequest {
@@ -1712,7 +1712,7 @@ message BluetoothGATTWriteDescriptorRequest {
   uint64 address = 1;
   uint32 handle = 2;
 
-  bytes data = 3 [(pointer_to_buffer) = true];
+  bytes data = 3;
 }
 
 message BluetoothGATTNotifyRequest {
@@ -1937,7 +1937,7 @@ message VoiceAssistantAudio {
   option (source) = SOURCE_BOTH;
   option (ifdef) = "USE_VOICE_ASSISTANT";
 
-  bytes data = 1;
+  bytes data = 1 [(pointer_to_buffer) = true];
   bool end = 2;
 }
 

esphome/components/api/api_connection.cpp

@@ -474,7 +474,7 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
   if (msg.has_direction)
     call.set_direction(static_cast<fan::FanDirection>(msg.direction));
   if (msg.has_preset_mode)
-    call.set_preset_mode(reinterpret_cast<const char *>(msg.preset_mode), msg.preset_mode_len);
+    call.set_preset_mode(msg.preset_mode.c_str(), msg.preset_mode.size());
   call.perform();
 }
 #endif
@@ -560,7 +560,7 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
   if (msg.has_flash_length)
     call.set_flash_length(msg.flash_length);
   if (msg.has_effect)
-    call.set_effect(reinterpret_cast<const char *>(msg.effect), msg.effect_len);
+    call.set_effect(msg.effect.c_str(), msg.effect.size());
   call.perform();
 }
 #endif
@@ -739,11 +739,11 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
   if (msg.has_fan_mode)
     call.set_fan_mode(static_cast<climate::ClimateFanMode>(msg.fan_mode));
   if (msg.has_custom_fan_mode)
-    call.set_fan_mode(reinterpret_cast<const char *>(msg.custom_fan_mode), msg.custom_fan_mode_len);
+    call.set_fan_mode(msg.custom_fan_mode.c_str(), msg.custom_fan_mode.size());
   if (msg.has_preset)
     call.set_preset(static_cast<climate::ClimatePreset>(msg.preset));
   if (msg.has_custom_preset)
-    call.set_preset(reinterpret_cast<const char *>(msg.custom_preset), msg.custom_preset_len);
+    call.set_preset(msg.custom_preset.c_str(), msg.custom_preset.size());
   if (msg.has_swing_mode)
     call.set_swing_mode(static_cast<climate::ClimateSwingMode>(msg.swing_mode));
   call.perform();
@@ -932,7 +932,7 @@ uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *
 }
 void APIConnection::select_command(const SelectCommandRequest &msg) {
   ENTITY_COMMAND_MAKE_CALL(select::Select, select, select)
-  call.set_option(reinterpret_cast<const char *>(msg.state), msg.state_len);
+  call.set_option(msg.state.c_str(), msg.state.size());
   call.perform();
 }
 #endif
@@ -1154,9 +1154,8 @@ void APIConnection::on_get_time_response(const GetTimeResponse &value) {
   if (homeassistant::global_homeassistant_time != nullptr) {
     homeassistant::global_homeassistant_time->set_epoch_time(value.epoch_seconds);
 #ifdef USE_TIME_TIMEZONE
-    if (value.timezone_len > 0) {
-      homeassistant::global_homeassistant_time->set_timezone(reinterpret_cast<const char *>(value.timezone),
-                                                             value.timezone_len);
+    if (!value.timezone.empty()) {
+      homeassistant::global_homeassistant_time->set_timezone(value.timezone.c_str(), value.timezone.size());
     }
 #endif
   }
@@ -1524,7 +1523,7 @@ void APIConnection::complete_authentication_() {
 }
 
 bool APIConnection::send_hello_response(const HelloRequest &msg) {
-  this->client_info_.name.assign(reinterpret_cast<const char *>(msg.client_info), msg.client_info_len);
+  this->client_info_.name.assign(msg.client_info.c_str(), msg.client_info.size());
   this->client_api_version_major_ = msg.api_version_major;
   this->client_api_version_minor_ = msg.api_version_minor;
   char peername[socket::PEERNAME_MAX_LEN];
@@ -1553,7 +1552,7 @@ bool APIConnection::send_hello_response(const HelloRequest &msg) {
 bool APIConnection::send_authenticate_response(const AuthenticationRequest &msg) {
   AuthenticationResponse resp;
   // bool invalid_password = 1;
-  resp.invalid_password = !this->parent_->check_password(msg.password, msg.password_len);
+  resp.invalid_password = !this->parent_->check_password(msg.password.byte(), msg.password.size());
   if (!resp.invalid_password) {
     this->complete_authentication_();
   }
@@ -1696,27 +1695,28 @@ bool APIConnection::send_device_info_response(const DeviceInfoRequest &msg) {
 #ifdef USE_API_HOMEASSISTANT_STATES
 void APIConnection::on_home_assistant_state_response(const HomeAssistantStateResponse &msg) {
   // Skip if entity_id is empty (invalid message)
-  if (msg.entity_id_len == 0) {
+  if (msg.entity_id.empty()) {
     return;
   }
 
   for (auto &it : this->parent_->get_state_subs()) {
     // Compare entity_id: check length matches and content matches
     size_t entity_id_len = strlen(it.entity_id);
-    if (entity_id_len != msg.entity_id_len || memcmp(it.entity_id, msg.entity_id, msg.entity_id_len) != 0) {
+    if (entity_id_len != msg.entity_id.size() ||
+        memcmp(it.entity_id, msg.entity_id.c_str(), msg.entity_id.size()) != 0) {
       continue;
     }
 
     // Compare attribute: either both have matching attribute, or both have none
     size_t sub_attr_len = it.attribute != nullptr ? strlen(it.attribute) : 0;
-    if (sub_attr_len != msg.attribute_len ||
-        (sub_attr_len > 0 && memcmp(it.attribute, msg.attribute, sub_attr_len) != 0)) {
+    if (sub_attr_len != msg.attribute.size() ||
+        (sub_attr_len > 0 && memcmp(it.attribute, msg.attribute.c_str(), sub_attr_len) != 0)) {
       continue;
     }
 
     // Create temporary string for callback (callback takes const std::string &)
-    // Handle empty state (nullptr with len=0)
-    std::string state(msg.state_len > 0 ? reinterpret_cast<const char *>(msg.state) : "", msg.state_len);
+    // Handle empty state
+    std::string state(!msg.state.empty() ? msg.state.c_str() : "", msg.state.size());
     it.callback(state);
   }
 }
@@ -1752,20 +1752,20 @@ void APIConnection::execute_service(const ExecuteServiceRequest &msg) {
   // the action list. This ensures async actions (delays, waits) complete first.
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-void APIConnection::send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message) {
+void APIConnection::send_execute_service_response(uint32_t call_id, bool success, StringRef error_message) {
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.set_error_message(StringRef(error_message));
+  resp.set_error_message(error_message);
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-void APIConnection::send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message,
+void APIConnection::send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
                                                   const uint8_t *response_data, size_t response_data_len) {
   ExecuteServiceResponse resp;
   resp.call_id = call_id;
   resp.success = success;
-  resp.set_error_message(StringRef(error_message));
+  resp.set_error_message(error_message);
   resp.response_data = response_data;
   resp.response_data_len = response_data_len;
   this->send_message(resp, ExecuteServiceResponse::MESSAGE_TYPE);

esphome/components/api/api_connection.h

@@ -234,9 +234,9 @@ class APIConnection final : public APIServerConnection {
 #ifdef USE_API_USER_DEFINED_ACTIONS
   void execute_service(const ExecuteServiceRequest &msg) override;
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
-  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message);
+  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_execute_service_response(uint32_t call_id, bool success, const std::string &error_message,
+  void send_execute_service_response(uint32_t call_id, bool success, StringRef error_message,
                                      const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES

esphome/components/api/api_pb2.cpp

@@ -23,9 +23,7 @@ bool HelloRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool HelloRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
-      this->client_info = value.data();
-      this->client_info_len = value.size();
+      this->client_info = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -49,9 +47,7 @@ void HelloResponse::calculate_size(ProtoSize &size) const {
 bool AuthenticationRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
-      this->password = value.data();
-      this->password_len = value.size();
+      this->password = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -448,9 +444,7 @@ bool FanCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool FanCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 13: {
-      // Use raw data directly to avoid allocation
-      this->preset_mode = value.data();
-      this->preset_mode_len = value.size();
+      this->preset_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -615,9 +609,7 @@ bool LightCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool LightCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 19: {
-      // Use raw data directly to avoid allocation
-      this->effect = value.data();
-      this->effect_len = value.size();
+      this->effect = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -859,7 +851,6 @@ void SubscribeLogsResponse::calculate_size(ProtoSize &size) const {
 bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
       this->key = value.data();
       this->key_len = value.size();
       break;
@@ -936,12 +927,12 @@ bool HomeassistantActionResponse::decode_varint(uint32_t field_id, ProtoVarInt v
 }
 bool HomeassistantActionResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 3:
-      this->error_message = value.as_string();
+    case 3: {
+      this->error_message = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
     case 4: {
-      // Use raw data directly to avoid allocation
       this->response_data = value.data();
       this->response_data_len = value.size();
       break;
@@ -967,21 +958,15 @@ void SubscribeHomeAssistantStateResponse::calculate_size(ProtoSize &size) const
 bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
-      this->entity_id = value.data();
-      this->entity_id_len = value.size();
+      this->entity_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     case 2: {
-      // Use raw data directly to avoid allocation
-      this->state = value.data();
-      this->state_len = value.size();
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     case 3: {
-      // Use raw data directly to avoid allocation
-      this->attribute = value.data();
-      this->attribute_len = value.size();
+      this->attribute = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -993,9 +978,7 @@ bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDel
 bool GetTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-      // Use raw data directly to avoid allocation
-      this->timezone = value.data();
-      this->timezone_len = value.size();
+      this->timezone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -1060,9 +1043,10 @@ bool ExecuteServiceArgument::decode_varint(uint32_t field_id, ProtoVarInt value)
 }
 bool ExecuteServiceArgument::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 4:
-      this->string_ = value.as_string();
+    case 4: {
+      this->string_ = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     case 9:
       this->string_array.push_back(value.as_string());
       break;
@@ -1153,7 +1137,7 @@ void ExecuteServiceResponse::calculate_size(ProtoSize &size) const {
   size.add_bool(1, this->success);
   size.add_length(1, this->error_message_ref_.size());
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  size.add_length(4, this->response_data_len);
+  size.add_length(1, this->response_data_len);
 #endif
 }
 #endif
@@ -1408,15 +1392,11 @@ bool ClimateCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value)
 bool ClimateCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 17: {
-      // Use raw data directly to avoid allocation
-      this->custom_fan_mode = value.data();
-      this->custom_fan_mode_len = value.size();
+      this->custom_fan_mode = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     case 21: {
-      // Use raw data directly to avoid allocation
-      this->custom_preset = value.data();
-      this->custom_preset_len = value.size();
+      this->custom_preset = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -1702,9 +1682,7 @@ bool SelectCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool SelectCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-      // Use raw data directly to avoid allocation
-      this->state = value.data();
-      this->state_len = value.size();
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
     }
     default:
@@ -1732,8 +1710,8 @@ void ListEntitiesSirenResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(5, this->icon_ref_);
 #endif
   buffer.encode_bool(6, this->disabled_by_default);
-  for (auto &it : this->tones) {
-    buffer.encode_string(7, it, true);
+  for (const char *it : *this->tones) {
+    buffer.encode_string(7, it, strlen(it), true);
   }
   buffer.encode_bool(8, this->supports_duration);
   buffer.encode_bool(9, this->supports_volume);
@@ -1750,9 +1728,9 @@ void ListEntitiesSirenResponse::calculate_size(ProtoSize &size) const {
   size.add_length(1, this->icon_ref_.size());
 #endif
   size.add_bool(1, this->disabled_by_default);
-  if (!this->tones.empty()) {
-    for (const auto &it : this->tones) {
-      size.add_length_force(1, it.size());
+  if (!this->tones->empty()) {
+    for (const char *it : *this->tones) {
+      size.add_length_force(1, strlen(it));
     }
   }
   size.add_bool(1, this->supports_duration);
@@ -1808,9 +1786,10 @@ bool SirenCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool SirenCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 5:
-      this->tone = value.as_string();
+    case 5: {
+      this->tone = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -1899,9 +1878,10 @@ bool LockCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool LockCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 4:
-      this->code = value.as_string();
+    case 4: {
+      this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2069,9 +2049,10 @@ bool MediaPlayerCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt val
 }
 bool MediaPlayerCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 7:
-      this->media_url = value.as_string();
+    case 7: {
+      this->media_url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2279,7 +2260,6 @@ bool BluetoothGATTWriteRequest::decode_varint(uint32_t field_id, ProtoVarInt val
 bool BluetoothGATTWriteRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 4: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -2318,7 +2298,6 @@ bool BluetoothGATTWriteDescriptorRequest::decode_varint(uint32_t field_id, Proto
 bool BluetoothGATTWriteDescriptorRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 3: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -2502,12 +2481,14 @@ bool VoiceAssistantResponse::decode_varint(uint32_t field_id, ProtoVarInt value)
 }
 bool VoiceAssistantEventData::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->name = value.as_string();
+    case 1: {
+      this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->value = value.as_string();
+    }
+    case 2: {
+      this->value = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2546,20 +2527,22 @@ bool VoiceAssistantAudio::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->data = value.as_string();
+    case 1: {
+      this->data = value.data();
+      this->data_len = value.size();
       break;
+    }
     default:
       return false;
   }
   return true;
 }
 void VoiceAssistantAudio::encode(ProtoWriteBuffer buffer) const {
-  buffer.encode_bytes(1, this->data_ptr_, this->data_len_);
+  buffer.encode_bytes(1, this->data, this->data_len);
   buffer.encode_bool(2, this->end);
 }
 void VoiceAssistantAudio::calculate_size(ProtoSize &size) const {
-  size.add_length(1, this->data_len_);
+  size.add_length(1, this->data_len);
   size.add_bool(1, this->end);
 }
 bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, ProtoVarInt value) {
@@ -2583,12 +2566,14 @@ bool VoiceAssistantTimerEventResponse::decode_varint(uint32_t field_id, ProtoVar
 }
 bool VoiceAssistantTimerEventResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2:
-      this->timer_id = value.as_string();
+    case 2: {
+      this->timer_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 3:
-      this->name = value.as_string();
+    }
+    case 3: {
+      this->name = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2606,15 +2591,18 @@ bool VoiceAssistantAnnounceRequest::decode_varint(uint32_t field_id, ProtoVarInt
 }
 bool VoiceAssistantAnnounceRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->media_id = value.as_string();
+    case 1: {
+      this->media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->text = value.as_string();
+    }
+    case 2: {
+      this->text = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 3:
-      this->preannounce_media_id = value.as_string();
+    }
+    case 3: {
+      this->preannounce_media_id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2650,24 +2638,29 @@ bool VoiceAssistantExternalWakeWord::decode_varint(uint32_t field_id, ProtoVarIn
 }
 bool VoiceAssistantExternalWakeWord::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 1:
-      this->id = value.as_string();
+    case 1: {
+      this->id = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 2:
-      this->wake_word = value.as_string();
+    }
+    case 2: {
+      this->wake_word = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     case 3:
       this->trained_languages.push_back(value.as_string());
       break;
-    case 4:
-      this->model_type = value.as_string();
+    case 4: {
+      this->model_type = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 6:
-      this->model_hash = value.as_string();
+    }
+    case 6: {
+      this->model_hash = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
-    case 7:
-      this->url = value.as_string();
+    }
+    case 7: {
+      this->url = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2777,9 +2770,10 @@ bool AlarmControlPanelCommandRequest::decode_varint(uint32_t field_id, ProtoVarI
 }
 bool AlarmControlPanelCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 3:
-      this->code = value.as_string();
+    case 3: {
+      this->code = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -2861,9 +2855,10 @@ bool TextCommandRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 }
 bool TextCommandRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
-    case 2:
-      this->state = value.as_string();
+    case 2: {
+      this->state = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
       break;
+    }
     default:
       return false;
   }
@@ -3331,7 +3326,6 @@ bool UpdateCommandRequest::decode_32bit(uint32_t field_id, Proto32Bit value) {
 bool ZWaveProxyFrame::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 1: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -3356,7 +3350,6 @@ bool ZWaveProxyRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
 bool ZWaveProxyRequest::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
     case 2: {
-      // Use raw data directly to avoid allocation
       this->data = value.data();
       this->data_len = value.size();
       break;
@@ -3372,7 +3365,7 @@ void ZWaveProxyRequest::encode(ProtoWriteBuffer buffer) const {
 }
 void ZWaveProxyRequest::calculate_size(ProtoSize &size) const {
   size.add_uint32(1, static_cast<uint32_t>(this->type));
-  size.add_length(2, this->data_len);
+  size.add_length(1, this->data_len);
 }
 #endif
 

esphome/components/api/api_pb2.h

@@ -357,12 +357,11 @@ class CommandProtoMessage : public ProtoDecodableMessage {
 class HelloRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 1;
-  static constexpr uint8_t ESTIMATED_SIZE = 27;
+  static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "hello_request"; }
 #endif
-  const uint8_t *client_info{nullptr};
-  uint16_t client_info_len{0};
+  StringRef client_info{};
   uint32_t api_version_major{0};
   uint32_t api_version_minor{0};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -398,12 +397,11 @@ class HelloResponse final : public ProtoMessage {
 class AuthenticationRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 3;
-  static constexpr uint8_t ESTIMATED_SIZE = 19;
+  static constexpr uint8_t ESTIMATED_SIZE = 9;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "authentication_request"; }
 #endif
-  const uint8_t *password{nullptr};
-  uint16_t password_len{0};
+  StringRef password{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -784,7 +782,7 @@ class FanStateResponse final : public StateResponseProtoMessage {
 class FanCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 31;
-  static constexpr uint8_t ESTIMATED_SIZE = 48;
+  static constexpr uint8_t ESTIMATED_SIZE = 38;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "fan_command_request"; }
 #endif
@@ -797,8 +795,7 @@ class FanCommandRequest final : public CommandProtoMessage {
   bool has_speed_level{false};
   int32_t speed_level{0};
   bool has_preset_mode{false};
-  const uint8_t *preset_mode{nullptr};
-  uint16_t preset_mode_len{0};
+  StringRef preset_mode{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -860,7 +857,7 @@ class LightStateResponse final : public StateResponseProtoMessage {
 class LightCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 32;
-  static constexpr uint8_t ESTIMATED_SIZE = 122;
+  static constexpr uint8_t ESTIMATED_SIZE = 112;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "light_command_request"; }
 #endif
@@ -889,8 +886,7 @@ class LightCommandRequest final : public CommandProtoMessage {
   bool has_flash_length{false};
   uint32_t flash_length{0};
   bool has_effect{false};
-  const uint8_t *effect{nullptr};
-  uint16_t effect_len{0};
+  StringRef effect{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1073,7 +1069,7 @@ class SubscribeLogsResponse final : public ProtoMessage {
 class NoiseEncryptionSetKeyRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 124;
-  static constexpr uint8_t ESTIMATED_SIZE = 19;
+  static constexpr uint8_t ESTIMATED_SIZE = 9;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "noise_encryption_set_key_request"; }
 #endif
@@ -1165,13 +1161,13 @@ class HomeassistantActionRequest final : public ProtoMessage {
 class HomeassistantActionResponse final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 130;
-  static constexpr uint8_t ESTIMATED_SIZE = 34;
+  static constexpr uint8_t ESTIMATED_SIZE = 24;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "homeassistant_action_response"; }
 #endif
   uint32_t call_id{0};
   bool success{false};
-  std::string error_message{};
+  StringRef error_message{};
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   const uint8_t *response_data{nullptr};
   uint16_t response_data_len{0};
@@ -1222,16 +1218,13 @@ class SubscribeHomeAssistantStateResponse final : public ProtoMessage {
 class HomeAssistantStateResponse final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 40;
-  static constexpr uint8_t ESTIMATED_SIZE = 57;
+  static constexpr uint8_t ESTIMATED_SIZE = 27;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "home_assistant_state_response"; }
 #endif
-  const uint8_t *entity_id{nullptr};
-  uint16_t entity_id_len{0};
-  const uint8_t *state{nullptr};
-  uint16_t state_len{0};
-  const uint8_t *attribute{nullptr};
-  uint16_t attribute_len{0};
+  StringRef entity_id{};
+  StringRef state{};
+  StringRef attribute{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1256,13 +1249,12 @@ class GetTimeRequest final : public ProtoMessage {
 class GetTimeResponse final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 37;
-  static constexpr uint8_t ESTIMATED_SIZE = 24;
+  static constexpr uint8_t ESTIMATED_SIZE = 14;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "get_time_response"; }
 #endif
   uint32_t epoch_seconds{0};
-  const uint8_t *timezone{nullptr};
-  uint16_t timezone_len{0};
+  StringRef timezone{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1310,7 +1302,7 @@ class ExecuteServiceArgument final : public ProtoDecodableMessage {
   bool bool_{false};
   int32_t legacy_int{0};
   float float_{0.0f};
-  std::string string_{};
+  StringRef string_{};
   int32_t int_{0};
   FixedVector<bool> bool_array{};
   FixedVector<int32_t> int_array{};
@@ -1499,7 +1491,7 @@ class ClimateStateResponse final : public StateResponseProtoMessage {
 class ClimateCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 48;
-  static constexpr uint8_t ESTIMATED_SIZE = 104;
+  static constexpr uint8_t ESTIMATED_SIZE = 84;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "climate_command_request"; }
 #endif
@@ -1516,13 +1508,11 @@ class ClimateCommandRequest final : public CommandProtoMessage {
   bool has_swing_mode{false};
   enums::ClimateSwingMode swing_mode{};
   bool has_custom_fan_mode{false};
-  const uint8_t *custom_fan_mode{nullptr};
-  uint16_t custom_fan_mode_len{0};
+  StringRef custom_fan_mode{};
   bool has_preset{false};
   enums::ClimatePreset preset{};
   bool has_custom_preset{false};
-  const uint8_t *custom_preset{nullptr};
-  uint16_t custom_preset_len{0};
+  StringRef custom_preset{};
   bool has_target_humidity{false};
   float target_humidity{0.0f};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -1695,12 +1685,11 @@ class SelectStateResponse final : public StateResponseProtoMessage {
 class SelectCommandRequest final : public CommandProtoMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 54;
-  static constexpr uint8_t ESTIMATED_SIZE = 28;
+  static constexpr uint8_t ESTIMATED_SIZE = 18;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "select_command_request"; }
 #endif
-  const uint8_t *state{nullptr};
-  uint16_t state_len{0};
+  StringRef state{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1719,7 +1708,7 @@ class ListEntitiesSirenResponse final : public InfoResponseProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "list_entities_siren_response"; }
 #endif
-  std::vector<std::string> tones{};
+  const FixedVector<const char *> *tones{};
   bool supports_duration{false};
   bool supports_volume{false};
   void encode(ProtoWriteBuffer buffer) const override;
@@ -1756,7 +1745,7 @@ class SirenCommandRequest final : public CommandProtoMessage {
   bool has_state{false};
   bool state{false};
   bool has_tone{false};
-  std::string tone{};
+  StringRef tone{};
   bool has_duration{false};
   uint32_t duration{0};
   bool has_volume{false};
@@ -1817,7 +1806,7 @@ class LockCommandRequest final : public CommandProtoMessage {
 #endif
   enums::LockCommand command{};
   bool has_code{false};
-  std::string code{};
+  StringRef code{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -1927,7 +1916,7 @@ class MediaPlayerCommandRequest final : public CommandProtoMessage {
   bool has_volume{false};
   float volume{0.0f};
   bool has_media_url{false};
-  std::string media_url{};
+  StringRef media_url{};
   bool has_announcement{false};
   bool announcement{false};
 #ifdef HAS_PROTO_MESSAGE_DUMP
@@ -2157,7 +2146,7 @@ class BluetoothGATTReadResponse final : public ProtoMessage {
 class BluetoothGATTWriteRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 75;
-  static constexpr uint8_t ESTIMATED_SIZE = 29;
+  static constexpr uint8_t ESTIMATED_SIZE = 19;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_write_request"; }
 #endif
@@ -2193,7 +2182,7 @@ class BluetoothGATTReadDescriptorRequest final : public ProtoDecodableMessage {
 class BluetoothGATTWriteDescriptorRequest final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 77;
-  static constexpr uint8_t ESTIMATED_SIZE = 27;
+  static constexpr uint8_t ESTIMATED_SIZE = 17;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "bluetooth_gatt_write_descriptor_request"; }
 #endif
@@ -2503,8 +2492,8 @@ class VoiceAssistantResponse final : public ProtoDecodableMessage {
 };
 class VoiceAssistantEventData final : public ProtoDecodableMessage {
  public:
-  std::string name{};
-  std::string value{};
+  StringRef name{};
+  StringRef value{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -2532,17 +2521,12 @@ class VoiceAssistantEventResponse final : public ProtoDecodableMessage {
 class VoiceAssistantAudio final : public ProtoDecodableMessage {
  public:
   static constexpr uint8_t MESSAGE_TYPE = 106;
-  static constexpr uint8_t ESTIMATED_SIZE = 11;
+  static constexpr uint8_t ESTIMATED_SIZE = 21;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "voice_assistant_audio"; }
 #endif
-  std::string data{};
-  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;
-  }
+  const uint8_t *data{nullptr};
+  uint16_t data_len{0};
   bool end{false};
   void encode(ProtoWriteBuffer buffer) const override;
   void calculate_size(ProtoSize &size) const override;
@@ -2562,8 +2546,8 @@ class VoiceAssistantTimerEventResponse final : public ProtoDecodableMessage {
   const char *message_name() const override { return "voice_assistant_timer_event_response"; }
 #endif
   enums::VoiceAssistantTimerEvent event_type{};
-  std::string timer_id{};
-  std::string name{};
+  StringRef timer_id{};
+  StringRef name{};
   uint32_t total_seconds{0};
   uint32_t seconds_left{0};
   bool is_active{false};
@@ -2582,9 +2566,9 @@ class VoiceAssistantAnnounceRequest final : public ProtoDecodableMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "voice_assistant_announce_request"; }
 #endif
-  std::string media_id{};
-  std::string text{};
-  std::string preannounce_media_id{};
+  StringRef media_id{};
+  StringRef text{};
+  StringRef preannounce_media_id{};
   bool start_conversation{false};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
@@ -2627,13 +2611,13 @@ class VoiceAssistantWakeWord final : public ProtoMessage {
 };
 class VoiceAssistantExternalWakeWord final : public ProtoDecodableMessage {
  public:
-  std::string id{};
-  std::string wake_word{};
+  StringRef id{};
+  StringRef wake_word{};
   std::vector<std::string> trained_languages{};
-  std::string model_type{};
+  StringRef model_type{};
   uint32_t model_size{0};
-  std::string model_hash{};
-  std::string url{};
+  StringRef model_hash{};
+  StringRef url{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -2734,7 +2718,7 @@ class AlarmControlPanelCommandRequest final : public CommandProtoMessage {
   const char *message_name() const override { return "alarm_control_panel_command_request"; }
 #endif
   enums::AlarmControlPanelStateCommand command{};
-  std::string code{};
+  StringRef code{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif
@@ -2791,7 +2775,7 @@ class TextCommandRequest final : public CommandProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *message_name() const override { return "text_command_request"; }
 #endif
-  std::string state{};
+  StringRef state{};
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;
 #endif

esphome/components/api/api_pb2_dump.cpp

@@ -736,7 +736,7 @@ template<> const char *proto_enum_to_string<enums::ZWaveProxyRequestType>(enums:
 void HelloRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "HelloRequest");
   out.append("  client_info: ");
-  out.append(format_hex_pretty(this->client_info, this->client_info_len));
+  out.append("'").append(this->client_info.c_str(), this->client_info.size()).append("'");
   out.append("\n");
   dump_field(out, "api_version_major", this->api_version_major);
   dump_field(out, "api_version_minor", this->api_version_minor);
@@ -752,7 +752,7 @@ void HelloResponse::dump_to(std::string &out) const {
 void AuthenticationRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "AuthenticationRequest");
   out.append("  password: ");
-  out.append(format_hex_pretty(this->password, this->password_len));
+  out.append("'").append(this->password.c_str(), this->password.size()).append("'");
   out.append("\n");
 }
 void AuthenticationResponse::dump_to(std::string &out) const {
@@ -965,7 +965,7 @@ void FanCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "speed_level", this->speed_level);
   dump_field(out, "has_preset_mode", this->has_preset_mode);
   out.append("  preset_mode: ");
-  out.append(format_hex_pretty(this->preset_mode, this->preset_mode_len));
+  out.append("'").append(this->preset_mode.c_str(), this->preset_mode.size()).append("'");
   out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
@@ -1043,7 +1043,7 @@ void LightCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "flash_length", this->flash_length);
   dump_field(out, "has_effect", this->has_effect);
   out.append("  effect: ");
-  out.append(format_hex_pretty(this->effect, this->effect_len));
+  out.append("'").append(this->effect.c_str(), this->effect.size()).append("'");
   out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
@@ -1205,7 +1205,9 @@ void HomeassistantActionResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "HomeassistantActionResponse");
   dump_field(out, "call_id", this->call_id);
   dump_field(out, "success", this->success);
-  dump_field(out, "error_message", this->error_message);
+  out.append("  error_message: ");
+  out.append("'").append(this->error_message.c_str(), this->error_message.size()).append("'");
+  out.append("\n");
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
   out.append("  response_data: ");
   out.append(format_hex_pretty(this->response_data, this->response_data_len));
@@ -1226,13 +1228,13 @@ void SubscribeHomeAssistantStateResponse::dump_to(std::string &out) const {
 void HomeAssistantStateResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "HomeAssistantStateResponse");
   out.append("  entity_id: ");
-  out.append(format_hex_pretty(this->entity_id, this->entity_id_len));
+  out.append("'").append(this->entity_id.c_str(), this->entity_id.size()).append("'");
   out.append("\n");
   out.append("  state: ");
-  out.append(format_hex_pretty(this->state, this->state_len));
+  out.append("'").append(this->state.c_str(), this->state.size()).append("'");
   out.append("\n");
   out.append("  attribute: ");
-  out.append(format_hex_pretty(this->attribute, this->attribute_len));
+  out.append("'").append(this->attribute.c_str(), this->attribute.size()).append("'");
   out.append("\n");
 }
 #endif
@@ -1241,7 +1243,7 @@ void GetTimeResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "GetTimeResponse");
   dump_field(out, "epoch_seconds", this->epoch_seconds);
   out.append("  timezone: ");
-  out.append(format_hex_pretty(this->timezone, this->timezone_len));
+  out.append("'").append(this->timezone.c_str(), this->timezone.size()).append("'");
   out.append("\n");
 }
 #ifdef USE_API_USER_DEFINED_ACTIONS
@@ -1266,7 +1268,9 @@ void ExecuteServiceArgument::dump_to(std::string &out) const {
   dump_field(out, "bool_", this->bool_);
   dump_field(out, "legacy_int", this->legacy_int);
   dump_field(out, "float_", this->float_);
-  dump_field(out, "string_", this->string_);
+  out.append("  string_: ");
+  out.append("'").append(this->string_.c_str(), this->string_.size()).append("'");
+  out.append("\n");
   dump_field(out, "int_", this->int_);
   for (const auto it : this->bool_array) {
     dump_field(out, "bool_array", static_cast<bool>(it), 4);
@@ -1424,13 +1428,13 @@ void ClimateCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "swing_mode", static_cast<enums::ClimateSwingMode>(this->swing_mode));
   dump_field(out, "has_custom_fan_mode", this->has_custom_fan_mode);
   out.append("  custom_fan_mode: ");
-  out.append(format_hex_pretty(this->custom_fan_mode, this->custom_fan_mode_len));
+  out.append("'").append(this->custom_fan_mode.c_str(), this->custom_fan_mode.size()).append("'");
   out.append("\n");
   dump_field(out, "has_preset", this->has_preset);
   dump_field(out, "preset", static_cast<enums::ClimatePreset>(this->preset));
   dump_field(out, "has_custom_preset", this->has_custom_preset);
   out.append("  custom_preset: ");
-  out.append(format_hex_pretty(this->custom_preset, this->custom_preset_len));
+  out.append("'").append(this->custom_preset.c_str(), this->custom_preset.size()).append("'");
   out.append("\n");
   dump_field(out, "has_target_humidity", this->has_target_humidity);
   dump_field(out, "target_humidity", this->target_humidity);
@@ -1558,7 +1562,7 @@ void SelectCommandRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "SelectCommandRequest");
   dump_field(out, "key", this->key);
   out.append("  state: ");
-  out.append(format_hex_pretty(this->state, this->state_len));
+  out.append("'").append(this->state.c_str(), this->state.size()).append("'");
   out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
@@ -1575,7 +1579,7 @@ void ListEntitiesSirenResponse::dump_to(std::string &out) const {
   dump_field(out, "icon", this->icon_ref_);
 #endif
   dump_field(out, "disabled_by_default", this->disabled_by_default);
-  for (const auto &it : this->tones) {
+  for (const auto &it : *this->tones) {
     dump_field(out, "tones", it, 4);
   }
   dump_field(out, "supports_duration", this->supports_duration);
@@ -1599,7 +1603,9 @@ void SirenCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "has_state", this->has_state);
   dump_field(out, "state", this->state);
   dump_field(out, "has_tone", this->has_tone);
-  dump_field(out, "tone", this->tone);
+  out.append("  tone: ");
+  out.append("'").append(this->tone.c_str(), this->tone.size()).append("'");
+  out.append("\n");
   dump_field(out, "has_duration", this->has_duration);
   dump_field(out, "duration", this->duration);
   dump_field(out, "has_volume", this->has_volume);
@@ -1641,7 +1647,9 @@ void LockCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "key", this->key);
   dump_field(out, "command", static_cast<enums::LockCommand>(this->command));
   dump_field(out, "has_code", this->has_code);
-  dump_field(out, "code", this->code);
+  out.append("  code: ");
+  out.append("'").append(this->code.c_str(), this->code.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif
@@ -1719,7 +1727,9 @@ void MediaPlayerCommandRequest::dump_to(std::string &out) const {
   dump_field(out, "has_volume", this->has_volume);
   dump_field(out, "volume", this->volume);
   dump_field(out, "has_media_url", this->has_media_url);
-  dump_field(out, "media_url", this->media_url);
+  out.append("  media_url: ");
+  out.append("'").append(this->media_url.c_str(), this->media_url.size()).append("'");
+  out.append("\n");
   dump_field(out, "has_announcement", this->has_announcement);
   dump_field(out, "announcement", this->announcement);
 #ifdef USE_DEVICES
@@ -1949,8 +1959,12 @@ void VoiceAssistantResponse::dump_to(std::string &out) const {
 }
 void VoiceAssistantEventData::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantEventData");
-  dump_field(out, "name", this->name);
-  dump_field(out, "value", this->value);
+  out.append("  name: ");
+  out.append("'").append(this->name.c_str(), this->name.size()).append("'");
+  out.append("\n");
+  out.append("  value: ");
+  out.append("'").append(this->value.c_str(), this->value.size()).append("'");
+  out.append("\n");
 }
 void VoiceAssistantEventResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantEventResponse");
@@ -1964,28 +1978,34 @@ void VoiceAssistantEventResponse::dump_to(std::string &out) const {
 void VoiceAssistantAudio::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantAudio");
   out.append("  data: ");
-  if (this->data_ptr_ != nullptr) {
-    out.append(format_hex_pretty(this->data_ptr_, this->data_len_));
-  } else {
-    out.append(format_hex_pretty(reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size()));
-  }
+  out.append(format_hex_pretty(this->data, this->data_len));
   out.append("\n");
   dump_field(out, "end", this->end);
 }
 void VoiceAssistantTimerEventResponse::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantTimerEventResponse");
   dump_field(out, "event_type", static_cast<enums::VoiceAssistantTimerEvent>(this->event_type));
-  dump_field(out, "timer_id", this->timer_id);
-  dump_field(out, "name", this->name);
+  out.append("  timer_id: ");
+  out.append("'").append(this->timer_id.c_str(), this->timer_id.size()).append("'");
+  out.append("\n");
+  out.append("  name: ");
+  out.append("'").append(this->name.c_str(), this->name.size()).append("'");
+  out.append("\n");
   dump_field(out, "total_seconds", this->total_seconds);
   dump_field(out, "seconds_left", this->seconds_left);
   dump_field(out, "is_active", this->is_active);
 }
 void VoiceAssistantAnnounceRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantAnnounceRequest");
-  dump_field(out, "media_id", this->media_id);
-  dump_field(out, "text", this->text);
-  dump_field(out, "preannounce_media_id", this->preannounce_media_id);
+  out.append("  media_id: ");
+  out.append("'").append(this->media_id.c_str(), this->media_id.size()).append("'");
+  out.append("\n");
+  out.append("  text: ");
+  out.append("'").append(this->text.c_str(), this->text.size()).append("'");
+  out.append("\n");
+  out.append("  preannounce_media_id: ");
+  out.append("'").append(this->preannounce_media_id.c_str(), this->preannounce_media_id.size()).append("'");
+  out.append("\n");
   dump_field(out, "start_conversation", this->start_conversation);
 }
 void VoiceAssistantAnnounceFinished::dump_to(std::string &out) const { dump_field(out, "success", this->success); }
@@ -1999,15 +2019,25 @@ void VoiceAssistantWakeWord::dump_to(std::string &out) const {
 }
 void VoiceAssistantExternalWakeWord::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantExternalWakeWord");
-  dump_field(out, "id", this->id);
-  dump_field(out, "wake_word", this->wake_word);
+  out.append("  id: ");
+  out.append("'").append(this->id.c_str(), this->id.size()).append("'");
+  out.append("\n");
+  out.append("  wake_word: ");
+  out.append("'").append(this->wake_word.c_str(), this->wake_word.size()).append("'");
+  out.append("\n");
   for (const auto &it : this->trained_languages) {
     dump_field(out, "trained_languages", it, 4);
   }
-  dump_field(out, "model_type", this->model_type);
+  out.append("  model_type: ");
+  out.append("'").append(this->model_type.c_str(), this->model_type.size()).append("'");
+  out.append("\n");
   dump_field(out, "model_size", this->model_size);
-  dump_field(out, "model_hash", this->model_hash);
-  dump_field(out, "url", this->url);
+  out.append("  model_hash: ");
+  out.append("'").append(this->model_hash.c_str(), this->model_hash.size()).append("'");
+  out.append("\n");
+  out.append("  url: ");
+  out.append("'").append(this->url.c_str(), this->url.size()).append("'");
+  out.append("\n");
 }
 void VoiceAssistantConfigurationRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "VoiceAssistantConfigurationRequest");
@@ -2066,7 +2096,9 @@ void AlarmControlPanelCommandRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "AlarmControlPanelCommandRequest");
   dump_field(out, "key", this->key);
   dump_field(out, "command", static_cast<enums::AlarmControlPanelStateCommand>(this->command));
-  dump_field(out, "code", this->code);
+  out.append("  code: ");
+  out.append("'").append(this->code.c_str(), this->code.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif
@@ -2103,7 +2135,9 @@ void TextStateResponse::dump_to(std::string &out) const {
 void TextCommandRequest::dump_to(std::string &out) const {
   MessageDumpHelper helper(out, "TextCommandRequest");
   dump_field(out, "key", this->key);
-  dump_field(out, "state", this->state);
+  out.append("  state: ");
+  out.append("'").append(this->state.c_str(), this->state.size()).append("'");
+  out.append("\n");
 #ifdef USE_DEVICES
   dump_field(out, "device_id", this->device_id);
 #endif

esphome/components/api/api_server.cpp

@@ -397,7 +397,7 @@ void APIServer::register_action_response_callback(uint32_t call_id, ActionRespon
   this->action_response_callbacks_.push_back({call_id, std::move(callback)});
 }
 
-void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message) {
+void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message) {
   for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
     if (it->call_id == call_id) {
       auto callback = std::move(it->callback);
@@ -409,7 +409,7 @@ void APIServer::handle_action_response(uint32_t call_id, bool success, const std
   }
 }
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-void APIServer::handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
+void APIServer::handle_action_response(uint32_t call_id, bool success, StringRef error_message,
                                        const uint8_t *response_data, size_t response_data_len) {
   for (auto it = this->action_response_callbacks_.begin(); it != this->action_response_callbacks_.end(); ++it) {
     if (it->call_id == call_id) {
@@ -681,7 +681,7 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   }
 }
 
-void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &error_message) {
+void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message) {
   for (auto &call : this->active_action_calls_) {
     if (call.action_call_id == action_call_id) {
       call.connection->send_execute_service_response(call.client_call_id, success, error_message);
@@ -691,7 +691,7 @@ void APIServer::send_action_response(uint32_t action_call_id, bool success, cons
   ESP_LOGW(TAG, "Cannot send response: no active call found for action_call_id %u", action_call_id);
 }
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-void APIServer::send_action_response(uint32_t action_call_id, bool success, const std::string &error_message,
+void APIServer::send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
                                      const uint8_t *response_data, size_t response_data_len) {
   for (auto &call : this->active_action_calls_) {
     if (call.action_call_id == action_call_id) {

esphome/components/api/api_server.h

@@ -143,10 +143,10 @@ class APIServer : public Component,
   // Action response handling
   using ActionResponseCallback = std::function<void(const class ActionResponse &)>;
   void register_action_response_callback(uint32_t call_id, ActionResponseCallback callback);
-  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message);
+  void handle_action_response(uint32_t call_id, bool success, StringRef error_message);
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
-                              const uint8_t *response_data, size_t response_data_len);
+  void handle_action_response(uint32_t call_id, bool success, StringRef error_message, const uint8_t *response_data,
+                              size_t response_data_len);
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
 #endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
 #endif  // USE_API_HOMEASSISTANT_SERVICES
@@ -165,9 +165,9 @@ class APIServer : public Component,
   void unregister_active_action_call(uint32_t action_call_id);
   void unregister_active_action_calls_for_connection(APIConnection *conn);
   // Send response for a specific action call (uses action_call_id, sends client_call_id in response)
-  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message);
+  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message);
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
-  void send_action_response(uint32_t action_call_id, bool success, const std::string &error_message,
+  void send_action_response(uint32_t action_call_id, bool success, StringRef error_message,
                             const uint8_t *response_data, size_t response_data_len);
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES_JSON
 #endif  // USE_API_USER_DEFINED_ACTION_RESPONSES

esphome/components/api/homeassistant_service.h

@@ -67,10 +67,10 @@ template<typename... Ts> class TemplatableKeyValuePair {
 // the callback is invoked synchronously while the message is on the stack).
 class ActionResponse {
  public:
-  ActionResponse(bool success, const std::string &error_message) : success_(success), error_message_(error_message) {}
+  ActionResponse(bool success, StringRef error_message) : success_(success), error_message_(error_message) {}
 
 #ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
-  ActionResponse(bool success, const std::string &error_message, const uint8_t *data, size_t data_len)
+  ActionResponse(bool success, StringRef error_message, const uint8_t *data, size_t data_len)
       : success_(success), error_message_(error_message) {
     if (data == nullptr || data_len == 0)
       return;

esphome/components/cc1101/cc1101.cpp

@@ -169,14 +169,16 @@ void CC1101Component::loop() {
   }
 
   // Read packet
-  uint8_t payload_length;
+  uint8_t payload_length, expected_rx;
   if (this->state_.LENGTH_CONFIG == static_cast<uint8_t>(LengthConfig::LENGTH_CONFIG_VARIABLE)) {
     this->read_(Register::FIFO, &payload_length, 1);
+    expected_rx = payload_length + 1;
   } else {
     payload_length = this->state_.PKTLEN;
+    expected_rx = payload_length;
   }
-  if (payload_length == 0 || payload_length > 64) {
-    ESP_LOGW(TAG, "Invalid payload length: %u", payload_length);
+  if (payload_length == 0 || payload_length > 64 || rx_bytes != expected_rx) {
+    ESP_LOGW(TAG, "Invalid packet: rx_bytes %u, payload_length %u", rx_bytes, payload_length);
     this->enter_idle_();
     this->strobe_(Command::FRX);
     this->strobe_(Command::RX);
@@ -186,13 +188,12 @@ void CC1101Component::loop() {
   this->packet_.resize(payload_length);
   this->read_(Register::FIFO, this->packet_.data(), payload_length);
 
-  // Read status and trigger
-  uint8_t status[2];
-  this->read_(Register::FIFO, status, 2);
-  int8_t rssi_raw = static_cast<int8_t>(status[0]);
-  float rssi = (rssi_raw * RSSI_STEP) - RSSI_OFFSET;
-  bool crc_ok = (status[1] & STATUS_CRC_OK_MASK) != 0;
-  uint8_t lqi = status[1] & STATUS_LQI_MASK;
+  // Read status from registers (more reliable than FIFO status bytes due to timing issues)
+  this->read_(Register::RSSI);
+  this->read_(Register::LQI);
+  float rssi = (this->state_.RSSI * RSSI_STEP) - RSSI_OFFSET;
+  bool crc_ok = (this->state_.LQI & STATUS_CRC_OK_MASK) != 0;
+  uint8_t lqi = this->state_.LQI & STATUS_LQI_MASK;
   if (this->state_.CRC_EN == 0 || crc_ok) {
     this->packet_trigger_->trigger(this->packet_, rssi, lqi);
   }
@@ -616,12 +617,15 @@ void CC1101Component::set_packet_mode(bool value) {
     this->state_.GDO0_CFG = 0x01;
     // Set max RX FIFO threshold to ensure we only trigger on end-of-packet
     this->state_.FIFO_THR = 15;
+    // Don't append status bytes to FIFO - we read from registers instead
+    this->state_.APPEND_STATUS = 0;
   } else {
     // Configure GDO0 for serial data (async serial mode)
     this->state_.GDO0_CFG = 0x0D;
   }
   if (this->initialized_) {
     this->write_(Register::PKTCTRL0);
+    this->write_(Register::PKTCTRL1);
     this->write_(Register::IOCFG0);
     this->write_(Register::FIFOTHR);
   }

esphome/components/esp8266/__init__.py

@@ -191,7 +191,8 @@ async def to_code(config):
     cg.add_define(ThreadModel.SINGLE)
 
     cg.add_platformio_option(
-        "extra_scripts", ["pre:testing_mode.py", "post:post_build.py"]
+        "extra_scripts",
+        ["pre:testing_mode.py", "pre:exclude_updater.py", "post:post_build.py"],
     )
 
     conf = config[CONF_FRAMEWORK]
@@ -278,3 +279,8 @@ def copy_files():
         testing_mode_file,
         CORE.relative_build_path("testing_mode.py"),
     )
+    exclude_updater_file = dir / "exclude_updater.py.script"
+    copy_file_if_changed(
+        exclude_updater_file,
+        CORE.relative_build_path("exclude_updater.py"),
+    )

esphome/components/esp8266/exclude_updater.py.script

@@ -0,0 +1,21 @@
+# pylint: disable=E0602
+Import("env")  # noqa
+
+import os
+
+# Filter out Updater.cpp from the Arduino core build
+# This saves 228 bytes of .bss by not instantiating the global Update object
+# ESPHome uses its own native OTA backend instead
+
+
+def filter_updater_from_core(env, node):
+    """Filter callback to exclude Updater.cpp from framework build."""
+    path = node.get_path()
+    if path.endswith("Updater.cpp"):
+        print(f"ESPHome: Excluding {os.path.basename(path)} from build (using native OTA backend)")
+        return None
+    return node
+
+
+# Apply the filter to framework sources
+env.AddBuildMiddleware(filter_updater_from_core, "**/cores/esp8266/Updater.cpp")

esphome/components/esphome/ota/ota_esphome.cpp

@@ -10,7 +10,7 @@
 #endif
 #include "esphome/components/network/util.h"
 #include "esphome/components/ota/ota_backend.h"
-#include "esphome/components/ota/ota_backend_arduino_esp8266.h"
+#include "esphome/components/ota/ota_backend_esp8266.h"
 #include "esphome/components/ota/ota_backend_arduino_libretiny.h"
 #include "esphome/components/ota/ota_backend_arduino_rp2040.h"
 #include "esphome/components/ota/ota_backend_esp_idf.h"

esphome/components/ethernet/ethernet_component.cpp

@@ -644,6 +644,12 @@ void EthernetComponent::dump_connect_params_() {
     dns_ip2 = dns_getserver(1);
   }
 
+  // Use stack buffers for IP address formatting to avoid heap allocations
+  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char subnet_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char gateway_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char dns1_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char dns2_buf[network::IP_ADDRESS_BUFFER_SIZE];
   ESP_LOGCONFIG(TAG,
                 "  IP Address: %s\n"
                 "  Hostname: '%s'\n"
@@ -651,9 +657,9 @@ void EthernetComponent::dump_connect_params_() {
                 "  Gateway: %s\n"
                 "  DNS1: %s\n"
                 "  DNS2: %s",
-                network::IPAddress(&ip.ip).str().c_str(), App.get_name().c_str(),
-                network::IPAddress(&ip.netmask).str().c_str(), network::IPAddress(&ip.gw).str().c_str(),
-                network::IPAddress(dns_ip1).str().c_str(), network::IPAddress(dns_ip2).str().c_str());
+                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));
 
 #if USE_NETWORK_IPV6
   struct esp_ip6_addr if_ip6s[CONFIG_LWIP_IPV6_NUM_ADDRESSES];
@@ -665,12 +671,13 @@ void EthernetComponent::dump_connect_params_() {
   }
 #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().c_str(), YESNO(this->get_duplex_mode() == ETH_DUPLEX_FULL),
-                this->get_link_speed() == ETH_SPEED_100M ? 100 : 10);
+                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
@@ -711,11 +718,16 @@ void EthernetComponent::get_eth_mac_address_raw(uint8_t *mac) {
 }
 
 std::string EthernetComponent::get_eth_mac_address_pretty() {
+  char buf[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
+  return std::string(this->get_eth_mac_address_pretty_into_buffer(buf));
+}
+
+const char *EthernetComponent::get_eth_mac_address_pretty_into_buffer(
+    std::span<char, MAC_ADDRESS_PRETTY_BUFFER_SIZE> buf) {
   uint8_t mac[6];
   get_eth_mac_address_raw(mac);
-  char buf[18];
-  format_mac_addr_upper(mac, buf);
-  return std::string(buf);
+  format_mac_addr_upper(mac, buf.data());
+  return buf.data();
 }
 
 eth_duplex_t EthernetComponent::get_duplex_mode() {

esphome/components/ethernet/ethernet_component.h

@@ -3,6 +3,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 #include "esphome/components/network/ip_address.h"
 
 #ifdef USE_ESP32
@@ -93,6 +94,7 @@ class EthernetComponent : public Component {
   void set_use_address(const char *use_address);
   void get_eth_mac_address_raw(uint8_t *mac);
   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();
   eth_speed_t get_link_speed();
   bool powerdown();

esphome/components/http_request/ota/ota_http_request.cpp

@@ -7,7 +7,7 @@
 #include "esphome/components/md5/md5.h"
 #include "esphome/components/watchdog/watchdog.h"
 #include "esphome/components/ota/ota_backend.h"
-#include "esphome/components/ota/ota_backend_arduino_esp8266.h"
+#include "esphome/components/ota/ota_backend_esp8266.h"
 #include "esphome/components/ota/ota_backend_arduino_rp2040.h"
 #include "esphome/components/ota/ota_backend_esp_idf.h"
 

esphome/components/logger/logger.cpp

@@ -65,8 +65,8 @@ void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const ch
     uint16_t buffer_at = 0;                         // Initialize buffer position
     this->format_log_to_buffer_with_terminator_(level, tag, line, format, args, console_buffer, &buffer_at,
                                                 MAX_CONSOLE_LOG_MSG_SIZE);
-    // Add newline if platform needs it (ESP32 doesn't add via write_msg_)
-    this->add_newline_to_buffer_if_needed_(console_buffer, &buffer_at, MAX_CONSOLE_LOG_MSG_SIZE);
+    // Add newline before writing to console
+    this->add_newline_to_buffer_(console_buffer, &buffer_at, MAX_CONSOLE_LOG_MSG_SIZE);
     this->write_msg_(console_buffer, buffer_at);
   }
 

esphome/components/logger/logger.h

@@ -117,17 +117,6 @@ static constexpr uint16_t MAX_HEADER_SIZE = 128;
 // "0x" + 2 hex digits per byte + '\0'
 static constexpr size_t MAX_POINTER_REPRESENTATION = 2 + sizeof(void *) * 2 + 1;
 
-// Platform-specific: does write_msg_ add its own newline?
-// false: Caller must add newline to buffer before calling write_msg_ (ESP32, ESP8266, RP2040, LibreTiny, Zephyr)
-//        Allows single write call with newline included for efficiency
-// true:  write_msg_ adds newline itself via puts()/println() (other platforms)
-//        Newline should NOT be added to buffer
-#if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
-static constexpr bool WRITE_MSG_ADDS_NEWLINE = false;
-#else
-static constexpr bool WRITE_MSG_ADDS_NEWLINE = true;
-#endif
-
 #if defined(USE_ESP32) || defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
 /** Enum for logging UART selection
  *
@@ -259,22 +248,20 @@ class Logger : public Component {
     }
   }
 
-  // Helper to add newline to buffer for platforms that need it
+  // Helper to add newline to buffer before writing to console
   // Modifies buffer_at to include the newline
-  inline void HOT add_newline_to_buffer_if_needed_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
-    if constexpr (!WRITE_MSG_ADDS_NEWLINE) {
-      // Add newline - don't need to maintain null termination
-      // write_msg_ now always receives explicit length, so we can safely overwrite the null terminator
-      // This is safe because:
-      // 1. Callbacks already received the message (before we add newline)
-      // 2. write_msg_ receives the length explicitly (doesn't need null terminator)
-      if (*buffer_at < buffer_size) {
-        buffer[(*buffer_at)++] = '\n';
-      } else if (buffer_size > 0) {
-        // Buffer was full - replace last char with newline to ensure it's visible
-        buffer[buffer_size - 1] = '\n';
-        *buffer_at = buffer_size;
-      }
+  inline void HOT add_newline_to_buffer_(char *buffer, uint16_t *buffer_at, uint16_t buffer_size) {
+    // Add newline - don't need to maintain null termination
+    // write_msg_ receives explicit length, so we can safely overwrite the null terminator
+    // This is safe because:
+    // 1. Callbacks already received the message (before we add newline)
+    // 2. write_msg_ receives the length explicitly (doesn't need null terminator)
+    if (*buffer_at < buffer_size) {
+      buffer[(*buffer_at)++] = '\n';
+    } else if (buffer_size > 0) {
+      // Buffer was full - replace last char with newline to ensure it's visible
+      buffer[buffer_size - 1] = '\n';
+      *buffer_at = buffer_size;
     }
   }
 
@@ -283,7 +270,7 @@ class Logger : public Component {
   inline void HOT write_tx_buffer_to_console_(uint16_t offset = 0, uint16_t *length = nullptr) {
     if (this->baud_rate_ > 0) {
       uint16_t *len_ptr = length ? length : &this->tx_buffer_at_;
-      this->add_newline_to_buffer_if_needed_(this->tx_buffer_ + offset, len_ptr, this->tx_buffer_size_ - offset);
+      this->add_newline_to_buffer_(this->tx_buffer_ + offset, len_ptr, this->tx_buffer_size_ - offset);
       this->write_msg_(this->tx_buffer_ + offset, *len_ptr);
     }
   }

esphome/components/logger/logger_host.cpp

@@ -3,16 +3,23 @@
 
 namespace esphome::logger {
 
-void HOT Logger::write_msg_(const char *msg, size_t) {
-  time_t rawtime;
-  struct tm *timeinfo;
-  char buffer[80];
+void HOT Logger::write_msg_(const char *msg, size_t len) {
+  static constexpr size_t TIMESTAMP_LEN = 10;  // "[HH:MM:SS]"
+  // tx_buffer_size_ defaults to 512, so 768 covers default + headroom
+  char buffer[TIMESTAMP_LEN + 768];
 
+  time_t rawtime;
   time(&rawtime);
-  timeinfo = localtime(&rawtime);
-  strftime(buffer, sizeof buffer, "[%H:%M:%S]", timeinfo);
-  fputs(buffer, stdout);
-  puts(msg);
+  struct tm *timeinfo = localtime(&rawtime);
+  size_t pos = strftime(buffer, TIMESTAMP_LEN + 1, "[%H:%M:%S]", timeinfo);
+
+  // Copy message (with newline already included by caller)
+  size_t copy_len = std::min(len, sizeof(buffer) - pos);
+  memcpy(buffer + pos, msg, copy_len);
+  pos += copy_len;
+
+  // Single write for everything
+  fwrite(buffer, 1, pos, stdout);
 }
 
 void Logger::pre_setup() { global_logger = this; }

esphome/components/lvgl/defines.py

@@ -5,7 +5,7 @@ Constants already defined in esphome.const are not duplicated here and must be i
 """
 
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from esphome import codegen as cg, config_validation as cv
 from esphome.const import CONF_ITEMS
@@ -96,13 +96,9 @@ class LValidator:
             return None
         if isinstance(value, Lambda):
             # Local import to avoid circular import
-            from .lvcode import CodeContext, LambdaContext
+            from .lvcode import get_lambda_context_args
 
-            if TYPE_CHECKING:
-                # CodeContext does not have get_automation_parameters
-                # so we need to assert the type here
-                assert isinstance(CodeContext.code_context, LambdaContext)
-            args = args or CodeContext.code_context.get_automation_parameters()
+            args = args or get_lambda_context_args()
             return cg.RawExpression(
                 call_lambda(
                     await cg.process_lambda(value, args, return_type=self.rtype)

esphome/components/lvgl/lv_validation.py

@@ -1,5 +1,5 @@
 import re
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import esphome.codegen as cg
 from esphome.components import image
@@ -404,14 +404,9 @@ class TextValidator(LValidator):
         self, value: Any, args: list[tuple[SafeExpType, str]] | None = None
     ) -> Expression:
         # Local import to avoid circular import at module level
+        from .lvcode import get_lambda_context_args
 
-        from .lvcode import CodeContext, LambdaContext
-
-        if TYPE_CHECKING:
-            # CodeContext does not have get_automation_parameters
-            # so we need to assert the type here
-            assert isinstance(CodeContext.code_context, LambdaContext)
-        args = args or CodeContext.code_context.get_automation_parameters()
+        args = args or get_lambda_context_args()
 
         if isinstance(value, dict):
             if format_str := value.get(CONF_FORMAT):

esphome/components/lvgl/lvcode.py

@@ -1,4 +1,5 @@
 import abc
+from typing import TYPE_CHECKING
 
 from esphome import codegen as cg
 from esphome.config import Config
@@ -200,6 +201,21 @@ class LvContext(LambdaContext):
         return self.add(*args)
 
 
+def get_lambda_context_args() -> list[tuple[SafeExpType, str]]:
+    """Get automation parameters from the current lambda context if available.
+
+    When called from outside LVGL's context (e.g., from interval),
+    CodeContext.code_context will be None, so return empty args.
+    """
+    if CodeContext.code_context is None:
+        return []
+    if TYPE_CHECKING:
+        # CodeContext base class doesn't define get_automation_parameters(),
+        # but LambdaContext and LvContext (the concrete implementations) do.
+        assert isinstance(CodeContext.code_context, LambdaContext)
+    return CodeContext.code_context.get_automation_parameters()
+
+
 class LocalVariable(MockObj):
     """
     Create a local variable and enclose the code using it within a block.

esphome/components/network/ip_address.h

@@ -40,6 +40,9 @@ using ip4_addr_t = in_addr;
 namespace esphome {
 namespace network {
 
+/// Buffer size for IP address string (IPv6 max: 39 chars + null)
+static constexpr size_t IP_ADDRESS_BUFFER_SIZE = 40;
+
 struct IPAddress {
  public:
 #ifdef USE_HOST
@@ -50,6 +53,10 @@ struct IPAddress {
   IPAddress(const std::string &in_address) { inet_aton(in_address.c_str(), &ip_addr_); }
   IPAddress(const ip_addr_t *other_ip) { ip_addr_ = *other_ip; }
   std::string str() const { return str_lower_case(inet_ntoa(ip_addr_)); }
+  /// Write IP address to buffer. Buffer must be at least IP_ADDRESS_BUFFER_SIZE bytes.
+  char *str_to(char *buf) const {
+    return const_cast<char *>(inet_ntop(AF_INET, &ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE));
+  }
 #else
   IPAddress() { ip_addr_set_zero(&ip_addr_); }
   IPAddress(uint8_t first, uint8_t second, uint8_t third, uint8_t fourth) {
@@ -128,6 +135,8 @@ struct IPAddress {
   bool is_ip6() const { return IP_IS_V6(&ip_addr_); }
   bool is_multicast() const { return ip_addr_ismulticast(&ip_addr_); }
   std::string str() const { return str_lower_case(ipaddr_ntoa(&ip_addr_)); }
+  /// Write IP address to buffer. Buffer must be at least IP_ADDRESS_BUFFER_SIZE bytes.
+  char *str_to(char *buf) const { return ipaddr_ntoa_r(&ip_addr_, buf, IP_ADDRESS_BUFFER_SIZE); }
   bool operator==(const IPAddress &other) const { return ip_addr_cmp(&ip_addr_, &other.ip_addr_); }
   bool operator!=(const IPAddress &other) const { return !ip_addr_cmp(&ip_addr_, &other.ip_addr_); }
   IPAddress &operator+=(uint8_t increase) {

esphome/components/one_wire/one_wire_bus.cpp

@@ -49,7 +49,8 @@ void OneWireBus::search() {
       break;
     auto *address8 = reinterpret_cast<uint8_t *>(&address);
     if (crc8(address8, 7) != address8[7]) {
-      ESP_LOGW(TAG, "Dallas device 0x%s has invalid CRC.", format_hex(address).c_str());
+      char hex_buf[17];
+      ESP_LOGW(TAG, "Dallas device 0x%s has invalid CRC.", format_hex_to(hex_buf, address));
     } else {
       this->devices_.push_back(address);
     }
@@ -82,8 +83,9 @@ void OneWireBus::dump_devices_(const char *tag) {
     ESP_LOGW(tag, "  Found no devices!");
   } else {
     ESP_LOGCONFIG(tag, "  Found devices:");
+    char hex_buf[17];  // uint64_t = 16 hex chars + null
     for (auto &address : this->devices_) {
-      ESP_LOGCONFIG(tag, "    0x%s (%s)", format_hex(address).c_str(), LOG_STR_ARG(get_model_str(address & 0xff)));
+      ESP_LOGCONFIG(tag, "    0x%s (%s)", format_hex_to(hex_buf, address), LOG_STR_ARG(get_model_str(address & 0xff)));
     }
   }
 }

esphome/components/ota/__init__.py

@@ -148,7 +148,7 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
         },
-        "ota_backend_arduino_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
+        "ota_backend_esp8266.cpp": {PlatformFramework.ESP8266_ARDUINO},
         "ota_backend_arduino_rp2040.cpp": {PlatformFramework.RP2040_ARDUINO},
         "ota_backend_arduino_libretiny.cpp": {
             PlatformFramework.BK72XX_ARDUINO,

esphome/components/ota/ota_backend_arduino_esp8266.cpp

@@ -1,89 +0,0 @@
-#ifdef USE_ARDUINO
-#ifdef USE_ESP8266
-#include "ota_backend_arduino_esp8266.h"
-#include "ota_backend.h"
-
-#include "esphome/components/esp8266/preferences.h"
-#include "esphome/core/defines.h"
-#include "esphome/core/log.h"
-
-#include <Updater.h>
-
-namespace esphome {
-namespace ota {
-
-static const char *const TAG = "ota.arduino_esp8266";
-
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP8266OTABackend>(); }
-
-OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
-  // Handle UPDATE_SIZE_UNKNOWN (0) by calculating available space
-  if (image_size == 0) {
-    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
-    image_size = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
-  }
-  bool ret = Update.begin(image_size, U_FLASH);
-  if (ret) {
-    esp8266::preferences_prevent_write(true);
-    return OTA_RESPONSE_OK;
-  }
-
-  uint8_t error = Update.getError();
-  if (error == UPDATE_ERROR_BOOTSTRAP)
-    return OTA_RESPONSE_ERROR_INVALID_BOOTSTRAPPING;
-  if (error == UPDATE_ERROR_NEW_FLASH_CONFIG)
-    return OTA_RESPONSE_ERROR_WRONG_NEW_FLASH_CONFIG;
-  if (error == UPDATE_ERROR_FLASH_CONFIG)
-    return OTA_RESPONSE_ERROR_WRONG_CURRENT_FLASH_CONFIG;
-  if (error == UPDATE_ERROR_SPACE)
-    return OTA_RESPONSE_ERROR_ESP8266_NOT_ENOUGH_SPACE;
-
-  ESP_LOGE(TAG, "Begin error: %d", error);
-
-  return OTA_RESPONSE_ERROR_UNKNOWN;
-}
-
-void ArduinoESP8266OTABackend::set_update_md5(const char *md5) {
-  Update.setMD5(md5);
-  this->md5_set_ = true;
-}
-
-OTAResponseTypes ArduinoESP8266OTABackend::write(uint8_t *data, size_t len) {
-  size_t written = Update.write(data, len);
-  if (written == len) {
-    return OTA_RESPONSE_OK;
-  }
-
-  uint8_t error = Update.getError();
-  ESP_LOGE(TAG, "Write error: %d", error);
-
-  return OTA_RESPONSE_ERROR_WRITING_FLASH;
-}
-
-OTAResponseTypes ArduinoESP8266OTABackend::end() {
-  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
-  // This matches the behavior of the old web_server OTA implementation
-  bool success = Update.end(!this->md5_set_);
-
-  // On ESP8266, Update.end() might return false even with error code 0
-  // Check the actual error code to determine success
-  uint8_t error = Update.getError();
-
-  if (success || error == UPDATE_ERROR_OK) {
-    return OTA_RESPONSE_OK;
-  }
-
-  ESP_LOGE(TAG, "End error: %d", error);
-  return OTA_RESPONSE_ERROR_UPDATE_END;
-}
-
-void ArduinoESP8266OTABackend::abort() {
-  Update.end();
-  esp8266::preferences_prevent_write(false);
-}
-
-}  // namespace ota
-}  // namespace esphome
-
-#endif
-#endif

esphome/components/ota/ota_backend_arduino_esp8266.h

@@ -1,33 +0,0 @@
-#pragma once
-#ifdef USE_ARDUINO
-#ifdef USE_ESP8266
-#include "ota_backend.h"
-
-#include "esphome/core/defines.h"
-#include "esphome/core/macros.h"
-
-namespace esphome {
-namespace ota {
-
-class ArduinoESP8266OTABackend : public OTABackend {
- public:
-  OTAResponseTypes begin(size_t image_size) override;
-  void set_update_md5(const char *md5) override;
-  OTAResponseTypes write(uint8_t *data, size_t len) override;
-  OTAResponseTypes end() override;
-  void abort() override;
-#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
-  bool supports_compression() override { return true; }
-#else
-  bool supports_compression() override { return false; }
-#endif
-
- private:
-  bool md5_set_{false};
-};
-
-}  // namespace ota
-}  // namespace esphome
-
-#endif
-#endif

esphome/components/ota/ota_backend_esp8266.cpp

@@ -0,0 +1,356 @@
+#ifdef USE_ESP8266
+#include "ota_backend_esp8266.h"
+#include "ota_backend.h"
+
+#include "esphome/components/esp8266/preferences.h"
+#include "esphome/core/application.h"
+#include "esphome/core/defines.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+#include <Esp.h>
+#include <esp8266_peri.h>
+
+#include <cinttypes>
+
+extern "C" {
+#include <c_types.h>
+#include <eboot_command.h>
+#include <flash_hal.h>
+#include <spi_flash.h>
+#include <user_interface.h>
+}
+
+// Note: FLASH_SECTOR_SIZE (0x1000) is already defined in spi_flash_geometry.h
+
+// Flash header offsets
+static constexpr uint8_t FLASH_MODE_OFFSET = 2;
+
+// Firmware magic bytes
+static constexpr uint8_t FIRMWARE_MAGIC = 0xE9;
+static constexpr uint8_t GZIP_MAGIC_1 = 0x1F;
+static constexpr uint8_t GZIP_MAGIC_2 = 0x8B;
+
+// ESP8266 flash memory base address (memory-mapped flash starts here)
+static constexpr uint32_t FLASH_BASE_ADDRESS = 0x40200000;
+
+// Boot mode extraction from GPI register (bits 16-19 contain boot mode)
+static constexpr int BOOT_MODE_SHIFT = 16;
+static constexpr int BOOT_MODE_MASK = 0xf;
+
+// Boot mode indicating UART download mode (OTA not possible)
+static constexpr int BOOT_MODE_UART_DOWNLOAD = 1;
+
+// Minimum buffer size when memory is constrained
+static constexpr size_t MIN_BUFFER_SIZE = 256;
+
+namespace esphome::ota {
+
+static const char *const TAG = "ota.esp8266";
+
+std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ESP8266OTABackend>(); }
+
+OTAResponseTypes ESP8266OTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) by calculating available space
+  if (image_size == 0) {
+    // Round down to sector boundary: subtract one sector, then mask to sector alignment
+    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+    image_size = (ESP.getFreeSketchSpace() - FLASH_SECTOR_SIZE) & ~(FLASH_SECTOR_SIZE - 1);
+  }
+
+  // Check boot mode - if boot mode is UART download mode,
+  // we will not be able to reset into normal mode once update is done
+  int boot_mode = (GPI >> BOOT_MODE_SHIFT) & BOOT_MODE_MASK;
+  if (boot_mode == BOOT_MODE_UART_DOWNLOAD) {
+    return OTA_RESPONSE_ERROR_INVALID_BOOTSTRAPPING;
+  }
+
+  // Check flash configuration - real size must be >= configured size
+  // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+  if (!ESP.checkFlashConfig(false)) {
+    return OTA_RESPONSE_ERROR_WRONG_CURRENT_FLASH_CONFIG;
+  }
+
+  // Get current sketch size
+  // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+  uint32_t sketch_size = ESP.getSketchSize();
+
+  // Size of current sketch rounded to sector boundary
+  uint32_t current_sketch_size = (sketch_size + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
+
+  // Size of update rounded to sector boundary
+  uint32_t rounded_size = (image_size + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
+
+  // End of available space for sketch and update (start of filesystem)
+  uint32_t update_end_address = FS_start - FLASH_BASE_ADDRESS;
+
+  // Calculate start address for the update (write from end backwards)
+  this->start_address_ = (update_end_address > rounded_size) ? (update_end_address - rounded_size) : 0;
+
+  // Check if there's enough space for both current sketch and update
+  if (this->start_address_ < current_sketch_size) {
+    return OTA_RESPONSE_ERROR_ESP8266_NOT_ENOUGH_SPACE;
+  }
+
+  // Allocate buffer for sector writes (use smaller buffer if memory constrained)
+  // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+  this->buffer_size_ = (ESP.getFreeHeap() > 2 * FLASH_SECTOR_SIZE) ? FLASH_SECTOR_SIZE : MIN_BUFFER_SIZE;
+
+  // ESP8266's umm_malloc guarantees 4-byte aligned allocations, which is required
+  // for spi_flash_write(). This is the same pattern used by Arduino's Updater class.
+  this->buffer_ = make_unique<uint8_t[]>(this->buffer_size_);
+  if (!this->buffer_) {
+    return OTA_RESPONSE_ERROR_UNKNOWN;
+  }
+
+  this->current_address_ = this->start_address_;
+  this->image_size_ = image_size;
+  this->buffer_len_ = 0;
+  this->md5_set_ = false;
+
+  // Disable WiFi sleep during update
+  wifi_set_sleep_type(NONE_SLEEP_T);
+
+  // Prevent preference writes during update
+  esp8266::preferences_prevent_write(true);
+
+  // Initialize MD5 computation
+  this->md5_.init();
+
+  ESP_LOGD(TAG, "OTA begin: start=0x%08" PRIX32 ", size=%zu", this->start_address_, image_size);
+
+  return OTA_RESPONSE_OK;
+}
+
+void ESP8266OTABackend::set_update_md5(const char *md5) {
+  // Parse hex string to bytes
+  if (parse_hex(md5, this->expected_md5_, 16)) {
+    this->md5_set_ = true;
+  }
+}
+
+OTAResponseTypes ESP8266OTABackend::write(uint8_t *data, size_t len) {
+  if (!this->buffer_) {
+    return OTA_RESPONSE_ERROR_UNKNOWN;
+  }
+
+  size_t written = 0;
+  while (written < len) {
+    // Calculate how much we can buffer
+    size_t to_buffer = std::min(len - written, this->buffer_size_ - this->buffer_len_);
+    memcpy(this->buffer_.get() + this->buffer_len_, data + written, to_buffer);
+    this->buffer_len_ += to_buffer;
+    written += to_buffer;
+
+    // If buffer is full, write to flash
+    if (this->buffer_len_ == this->buffer_size_ && !this->write_buffer_()) {
+      return OTA_RESPONSE_ERROR_WRITING_FLASH;
+    }
+  }
+
+  return OTA_RESPONSE_OK;
+}
+
+bool ESP8266OTABackend::erase_sector_if_needed_() {
+  if ((this->current_address_ % FLASH_SECTOR_SIZE) != 0) {
+    return true;  // Not at sector boundary
+  }
+
+  App.feed_wdt();
+  if (spi_flash_erase_sector(this->current_address_ / FLASH_SECTOR_SIZE) != SPI_FLASH_RESULT_OK) {
+    ESP_LOGE(TAG, "Flash erase failed at 0x%08" PRIX32, this->current_address_);
+    return false;
+  }
+  return true;
+}
+
+bool ESP8266OTABackend::flash_write_() {
+  App.feed_wdt();
+  if (spi_flash_write(this->current_address_, reinterpret_cast<uint32_t *>(this->buffer_.get()), this->buffer_len_) !=
+      SPI_FLASH_RESULT_OK) {
+    ESP_LOGE(TAG, "Flash write failed at 0x%08" PRIX32, this->current_address_);
+    return false;
+  }
+  return true;
+}
+
+bool ESP8266OTABackend::write_buffer_() {
+  if (this->buffer_len_ == 0) {
+    return true;
+  }
+
+  if (!this->erase_sector_if_needed_()) {
+    return false;
+  }
+
+  // Patch flash mode in first sector if needed
+  // This is analogous to what esptool.py does when it receives a --flash_mode argument
+  bool is_first_sector = (this->current_address_ == this->start_address_);
+  uint8_t original_flash_mode = 0;
+  bool patched_flash_mode = false;
+
+  // Only patch if we have enough bytes to access flash mode offset and it's not GZIP
+  if (is_first_sector && this->buffer_len_ > FLASH_MODE_OFFSET && this->buffer_[0] != GZIP_MAGIC_1) {
+    // Not GZIP compressed - check and patch flash mode
+    uint8_t current_flash_mode = this->get_flash_chip_mode_();
+    uint8_t buffer_flash_mode = this->buffer_[FLASH_MODE_OFFSET];
+
+    if (buffer_flash_mode != current_flash_mode) {
+      original_flash_mode = buffer_flash_mode;
+      this->buffer_[FLASH_MODE_OFFSET] = current_flash_mode;
+      patched_flash_mode = true;
+    }
+  }
+
+  if (!this->flash_write_()) {
+    return false;
+  }
+
+  // Restore original flash mode for MD5 calculation
+  if (patched_flash_mode) {
+    this->buffer_[FLASH_MODE_OFFSET] = original_flash_mode;
+  }
+
+  // Update MD5 with original (unpatched) data
+  this->md5_.add(this->buffer_.get(), this->buffer_len_);
+
+  this->current_address_ += this->buffer_len_;
+  this->buffer_len_ = 0;
+
+  return true;
+}
+
+bool ESP8266OTABackend::write_buffer_final_() {
+  // Similar to write_buffer_(), but without flash mode patching or MD5 update (for final padded write)
+  if (this->buffer_len_ == 0) {
+    return true;
+  }
+
+  if (!this->erase_sector_if_needed_() || !this->flash_write_()) {
+    return false;
+  }
+
+  this->current_address_ += this->buffer_len_;
+  this->buffer_len_ = 0;
+
+  return true;
+}
+
+OTAResponseTypes ESP8266OTABackend::end() {
+  // Write any remaining buffered data
+  if (this->buffer_len_ > 0) {
+    // Add actual data to MD5 before padding
+    this->md5_.add(this->buffer_.get(), this->buffer_len_);
+
+    // Pad to 4-byte alignment for flash write
+    while (this->buffer_len_ % 4 != 0) {
+      this->buffer_[this->buffer_len_++] = 0xFF;
+    }
+    if (!this->write_buffer_final_()) {
+      this->abort();
+      return OTA_RESPONSE_ERROR_WRITING_FLASH;
+    }
+  }
+
+  // Calculate actual bytes written
+  size_t actual_size = this->current_address_ - this->start_address_;
+
+  // Check if any data was written
+  if (actual_size == 0) {
+    ESP_LOGE(TAG, "No data written");
+    this->abort();
+    return OTA_RESPONSE_ERROR_UPDATE_END;
+  }
+
+  // Verify MD5 if set (strict mode), otherwise use lenient mode
+  // In lenient mode (no MD5), we accept whatever was written
+  if (this->md5_set_) {
+    this->md5_.calculate();
+    if (!this->md5_.equals_bytes(this->expected_md5_)) {
+      ESP_LOGE(TAG, "MD5 mismatch");
+      this->abort();
+      return OTA_RESPONSE_ERROR_MD5_MISMATCH;
+    }
+  } else {
+    // Lenient mode: adjust size to what was actually written
+    // This matches Arduino's Update.end(true) behavior
+    this->image_size_ = actual_size;
+  }
+
+  // Verify firmware header
+  if (!this->verify_end_()) {
+    this->abort();
+    return OTA_RESPONSE_ERROR_UPDATE_END;
+  }
+
+  // Write eboot command to copy firmware on next boot
+  eboot_command ebcmd;
+  ebcmd.action = ACTION_COPY_RAW;
+  ebcmd.args[0] = this->start_address_;
+  ebcmd.args[1] = 0x00000;  // Destination: start of flash
+  ebcmd.args[2] = this->image_size_;
+  eboot_command_write(&ebcmd);
+
+  ESP_LOGI(TAG, "OTA update staged: 0x%08" PRIX32 " -> 0x00000, size=%zu", this->start_address_, this->image_size_);
+
+  // Clean up
+  this->buffer_.reset();
+  esp8266::preferences_prevent_write(false);
+
+  return OTA_RESPONSE_OK;
+}
+
+void ESP8266OTABackend::abort() {
+  this->buffer_.reset();
+  this->buffer_len_ = 0;
+  this->image_size_ = 0;
+  esp8266::preferences_prevent_write(false);
+}
+
+bool ESP8266OTABackend::verify_end_() {
+  uint32_t buf;
+  if (spi_flash_read(this->start_address_, &buf, 4) != SPI_FLASH_RESULT_OK) {
+    ESP_LOGE(TAG, "Failed to read firmware header");
+    return false;
+  }
+
+  uint8_t *bytes = reinterpret_cast<uint8_t *>(&buf);
+
+  // Check for GZIP (compressed firmware)
+  if (bytes[0] == GZIP_MAGIC_1 && bytes[1] == GZIP_MAGIC_2) {
+    // GZIP compressed - can't verify further
+    return true;
+  }
+
+  // Check firmware magic byte
+  if (bytes[0] != FIRMWARE_MAGIC) {
+    ESP_LOGE(TAG, "Invalid firmware magic: 0x%02X (expected 0x%02X)", bytes[0], FIRMWARE_MAGIC);
+    return false;
+  }
+
+#if !FLASH_MAP_SUPPORT
+  // Check if new firmware's flash size fits (only when auto-detection is disabled)
+  // With FLASH_MAP_SUPPORT (modern cores), flash size is auto-detected from chip
+  // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+  uint32_t bin_flash_size = ESP.magicFlashChipSize((bytes[3] & 0xf0) >> 4);
+  // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+  if (bin_flash_size > ESP.getFlashChipRealSize()) {
+    ESP_LOGE(TAG, "Firmware flash size (%" PRIu32 ") exceeds chip size (%" PRIu32 ")", bin_flash_size,
+             ESP.getFlashChipRealSize());
+    return false;
+  }
+#endif
+
+  return true;
+}
+
+uint8_t ESP8266OTABackend::get_flash_chip_mode_() {
+  uint32_t data;
+  if (spi_flash_read(0x0000, &data, 4) != SPI_FLASH_RESULT_OK) {
+    return 0;  // Default to QIO
+  }
+  return (reinterpret_cast<uint8_t *>(&data))[FLASH_MODE_OFFSET];
+}
+
+}  // namespace esphome::ota
+#endif  // USE_ESP8266

esphome/components/ota/ota_backend_esp8266.h

@@ -0,0 +1,58 @@
+#pragma once
+#ifdef USE_ESP8266
+#include "ota_backend.h"
+
+#include "esphome/components/md5/md5.h"
+#include "esphome/core/defines.h"
+
+#include <memory>
+
+namespace esphome::ota {
+
+/// OTA backend for ESP8266 using native SDK functions.
+/// This implementation bypasses the Arduino Updater library to save ~228 bytes of RAM
+/// by not having a global Update object in .bss.
+class ESP8266OTABackend : public OTABackend {
+ public:
+  OTAResponseTypes begin(size_t image_size) override;
+  void set_update_md5(const char *md5) override;
+  OTAResponseTypes write(uint8_t *data, size_t len) override;
+  OTAResponseTypes end() override;
+  void abort() override;
+  // Compression supported in all ESP8266 Arduino versions ESPHome supports (>= 2.7.0)
+  bool supports_compression() override { return true; }
+
+ protected:
+  /// Erase flash sector if current address is at sector boundary
+  bool erase_sector_if_needed_();
+
+  /// Write buffer to flash (does not update address or clear buffer)
+  bool flash_write_();
+
+  /// Write buffered data to flash and update MD5
+  bool write_buffer_();
+
+  /// Write buffered data to flash without MD5 update (for final padded write)
+  bool write_buffer_final_();
+
+  /// Verify the firmware header is valid
+  bool verify_end_();
+
+  /// Get current flash chip mode from flash header
+  uint8_t get_flash_chip_mode_();
+
+  std::unique_ptr<uint8_t[]> buffer_;
+  size_t buffer_size_{0};
+  size_t buffer_len_{0};
+
+  uint32_t start_address_{0};
+  uint32_t current_address_{0};
+  size_t image_size_{0};
+
+  md5::MD5Digest md5_{};
+  uint8_t expected_md5_[16];  // Fixed-size buffer for 128-bit (16-byte) MD5 digest
+  bool md5_set_{false};
+};
+
+}  // namespace esphome::ota
+#endif  // USE_ESP8266

esphome/components/pid/pid_climate.cpp

@@ -1,5 +1,4 @@
 #include "pid_climate.h"
-#include "esphome/core/entity_base.h"
 #include "esphome/core/log.h"
 
 namespace esphome {
@@ -163,16 +162,14 @@ void PIDClimate::start_autotune(std::unique_ptr<PIDAutotuner> &&autotune) {
   float min_value = this->supports_cool_() ? -1.0f : 0.0f;
   float max_value = this->supports_heat_() ? 1.0f : 0.0f;
   this->autotuner_->config(min_value, max_value);
-  char object_id_buf[OBJECT_ID_MAX_LEN];
-  StringRef object_id = this->get_object_id_to(object_id_buf);
-  this->autotuner_->set_autotuner_id(std::string(object_id.c_str()));
+  this->autotuner_->set_autotuner_id(this->get_name());
 
   ESP_LOGI(TAG,
            "%s: Autotune has started. This can take a long time depending on the "
            "responsiveness of your system. Your system "
            "output will be altered to deliberately oscillate above and below the setpoint multiple times. "
            "Until your sensor provides a reading, the autotuner may display \'nan\'",
-           object_id.c_str());
+           this->get_name().c_str());
 
   this->set_interval("autotune-progress", 10000, [this]() {
     if (this->autotuner_ != nullptr && !this->autotuner_->is_finished())
@@ -180,7 +177,8 @@ void PIDClimate::start_autotune(std::unique_ptr<PIDAutotuner> &&autotune) {
   });
 
   if (mode != climate::CLIMATE_MODE_HEAT_COOL) {
-    ESP_LOGW(TAG, "%s: !!! For PID autotuner you need to set AUTO (also called heat/cool) mode!", object_id.c_str());
+    ESP_LOGW(TAG, "%s: !!! For PID autotuner you need to set AUTO (also called heat/cool) mode!",
+             this->get_name().c_str());
   }
 }
 

esphome/components/prometheus/prometheus_handler.cpp

@@ -116,8 +116,7 @@ std::string PrometheusHandler::relabel_id_(EntityBase *obj) {
     return item->second;
   }
   char object_id_buf[OBJECT_ID_MAX_LEN];
-  StringRef object_id = obj->get_object_id_to(object_id_buf);
-  return std::string(object_id.c_str());
+  return obj->get_object_id_to(object_id_buf).str();
 }
 
 std::string PrometheusHandler::relabel_name_(EntityBase *obj) {

esphome/components/sx126x/sx126x.cpp

@@ -527,7 +527,9 @@ void SX126x::dump_config() {
                   this->spreading_factor_, cr, this->preamble_size_);
   }
   if (!this->sync_value_.empty()) {
-    ESP_LOGCONFIG(TAG, "  Sync Value: 0x%s", format_hex(this->sync_value_).c_str());
+    char hex_buf[17];  // 8 bytes max = 16 hex chars + null
+    ESP_LOGCONFIG(TAG, "  Sync Value: 0x%s",
+                  format_hex_to(hex_buf, this->sync_value_.data(), this->sync_value_.size()));
   }
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Configuring SX126x failed");

esphome/components/sx127x/sx127x.cpp

@@ -476,7 +476,9 @@ void SX127x::dump_config() {
       ESP_LOGCONFIG(TAG, "  Payload Length: %" PRIu32, this->payload_length_);
     }
     if (!this->sync_value_.empty()) {
-      ESP_LOGCONFIG(TAG, "  Sync Value: 0x%s", format_hex(this->sync_value_).c_str());
+      char hex_buf[17];  // 8 bytes max = 16 hex chars + null
+      ESP_LOGCONFIG(TAG, "  Sync Value: 0x%s",
+                    format_hex_to(hex_buf, this->sync_value_.data(), this->sync_value_.size()));
     }
     if (this->preamble_size_ > 0 || this->preamble_detect_ > 0) {
       ESP_LOGCONFIG(TAG,

esphome/components/text_sensor/text_sensor.cpp

@@ -78,8 +78,8 @@ void TextSensor::add_on_raw_state_callback(std::function<void(const std::string
   this->raw_callback_.add(std::move(callback));
 }
 
-std::string TextSensor::get_state() const { return this->state; }
-std::string TextSensor::get_raw_state() const {
+const std::string &TextSensor::get_state() const { return this->state; }
+const std::string &TextSensor::get_raw_state() const {
 // Suppress deprecation warning - get_raw_state() is the replacement API
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"

esphome/components/text_sensor/text_sensor.h

@@ -37,9 +37,9 @@ class TextSensor : public EntityBase, public EntityBase_DeviceClass {
 #pragma GCC diagnostic pop
 
   /// Getter-syntax for .state.
-  std::string get_state() const;
+  const std::string &get_state() const;
   /// Getter-syntax for .raw_state
-  std::string get_raw_state() const;
+  const std::string &get_raw_state() const;
 
   void publish_state(const std::string &state);
 

esphome/components/udp/udp_component.cpp

@@ -130,7 +130,8 @@ void UDPComponent::dump_config() {
   for (const auto &address : this->addresses_)
     ESP_LOGCONFIG(TAG, "  Address: %s", address.c_str());
   if (this->listen_address_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Listen address: %s", this->listen_address_.value().str().c_str());
+    char addr_buf[network::IP_ADDRESS_BUFFER_SIZE];
+    ESP_LOGCONFIG(TAG, "  Listen address: %s", this->listen_address_.value().str_to(addr_buf));
   }
   ESP_LOGCONFIG(TAG,
                 "  Broadcasting: %s\n"

esphome/components/voice_assistant/voice_assistant.cpp

@@ -272,7 +272,8 @@ void VoiceAssistant::loop() {
         size_t read_bytes = this->ring_buffer_->read((void *) this->send_buffer_, SEND_BUFFER_SIZE, 0);
         if (this->audio_mode_ == AUDIO_MODE_API) {
           api::VoiceAssistantAudio msg;
-          msg.set_data(this->send_buffer_, read_bytes);
+          msg.data = this->send_buffer_;
+          msg.data_len = read_bytes;
           this->api_client_->send_message(msg, api::VoiceAssistantAudio::MESSAGE_TYPE);
         } else {
           if (!this->udp_socket_running_) {
@@ -627,9 +628,9 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       ESP_LOGD(TAG, "Assist Pipeline running");
 #ifdef USE_MEDIA_PLAYER
       this->started_streaming_tts_ = false;
-      for (auto arg : msg.data) {
+      for (const auto &arg : msg.data) {
         if (arg.name == "url") {
-          this->tts_response_url_ = std::move(arg.value);
+          this->tts_response_url_ = arg.value;
         }
       }
 #endif
@@ -648,9 +649,9 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       break;
     case api::enums::VOICE_ASSISTANT_STT_END: {
       std::string text;
-      for (auto arg : msg.data) {
+      for (const auto &arg : msg.data) {
         if (arg.name == "text") {
-          text = std::move(arg.value);
+          text = arg.value;
         }
       }
       if (text.empty()) {
@@ -693,9 +694,9 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
       break;
     }
     case api::enums::VOICE_ASSISTANT_INTENT_END: {
-      for (auto arg : msg.data) {
+      for (const auto &arg : msg.data) {
         if (arg.name == "conversation_id") {
-          this->conversation_id_ = std::move(arg.value);
+          this->conversation_id_ = arg.value;
         } else if (arg.name == "continue_conversation") {
           this->continue_conversation_ = (arg.value == "1");
         }
@@ -705,9 +706,9 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
     }
     case api::enums::VOICE_ASSISTANT_TTS_START: {
       std::string text;
-      for (auto arg : msg.data) {
+      for (const auto &arg : msg.data) {
         if (arg.name == "text") {
-          text = std::move(arg.value);
+          text = arg.value;
         }
       }
       if (text.empty()) {
@@ -731,9 +732,9 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
     }
     case api::enums::VOICE_ASSISTANT_TTS_END: {
       std::string url;
-      for (auto arg : msg.data) {
+      for (const auto &arg : msg.data) {
         if (arg.name == "url") {
-          url = std::move(arg.value);
+          url = arg.value;
         }
       }
       if (url.empty()) {
@@ -778,11 +779,11 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
     case api::enums::VOICE_ASSISTANT_ERROR: {
       std::string code = "";
       std::string message = "";
-      for (auto arg : msg.data) {
+      for (const auto &arg : msg.data) {
         if (arg.name == "code") {
-          code = std::move(arg.value);
+          code = arg.value;
         } else if (arg.name == "message") {
-          message = std::move(arg.value);
+          message = arg.value;
         }
       }
       if (code == "wake-word-timeout" || code == "wake_word_detection_aborted" || code == "no_wake_word") {
@@ -841,12 +842,12 @@ void VoiceAssistant::on_event(const api::VoiceAssistantEventResponse &msg) {
 void VoiceAssistant::on_audio(const api::VoiceAssistantAudio &msg) {
 #ifdef USE_SPEAKER  // We should never get to this function if there is no speaker anyway
   if ((this->speaker_ != nullptr) && (this->speaker_buffer_ != nullptr)) {
-    if (this->speaker_buffer_index_ + msg.data.length() < SPEAKER_BUFFER_SIZE) {
-      memcpy(this->speaker_buffer_ + this->speaker_buffer_index_, msg.data.data(), msg.data.length());
-      this->speaker_buffer_index_ += msg.data.length();
-      this->speaker_buffer_size_ += msg.data.length();
-      this->speaker_bytes_received_ += msg.data.length();
-      ESP_LOGV(TAG, "Received audio: %u bytes from API", msg.data.length());
+    if (this->speaker_buffer_index_ + msg.data_len < SPEAKER_BUFFER_SIZE) {
+      memcpy(this->speaker_buffer_ + this->speaker_buffer_index_, msg.data, msg.data_len);
+      this->speaker_buffer_index_ += msg.data_len;
+      this->speaker_buffer_size_ += msg.data_len;
+      this->speaker_bytes_received_ += msg.data_len;
+      ESP_LOGV(TAG, "Received audio: %u bytes from API", msg.data_len);
     } else {
       ESP_LOGE(TAG, "Cannot receive audio, buffer is full");
     }

esphome/components/web_server/list_entities.cpp

@@ -6,8 +6,7 @@
 
 #include "web_server.h"
 
-namespace esphome {
-namespace web_server {
+namespace esphome::web_server {
 
 #ifdef USE_ESP32
 ListEntitiesIterator::ListEntitiesIterator(const WebServer *ws, AsyncEventSource *es) : web_server_(ws), events_(es) {}
@@ -157,6 +156,5 @@ bool ListEntitiesIterator::on_update(update::UpdateEntity *obj) {
 }
 #endif
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 #endif

esphome/components/web_server/list_entities.h

@@ -4,13 +4,13 @@
 #ifdef USE_WEBSERVER
 #include "esphome/core/component.h"
 #include "esphome/core/component_iterator.h"
-namespace esphome {
+namespace esphome::web_server_idf {
 #ifdef USE_ESP32
-namespace web_server_idf {
 class AsyncEventSource;
-}
 #endif
-namespace web_server {
+}  // namespace esphome::web_server_idf
+
+namespace esphome::web_server {
 
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
 class DeferredUpdateEventSource;
@@ -99,6 +99,5 @@ class ListEntitiesIterator : public ComponentIterator {
 #endif
 };
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 #endif

esphome/components/web_server/ota/ota_web_server.cpp

@@ -10,9 +10,7 @@
 #endif
 
 #ifdef USE_ARDUINO
-#ifdef USE_ESP8266
-#include <Updater.h>
-#elif defined(USE_ESP32) || defined(USE_LIBRETINY)
+#if defined(USE_ESP32) || defined(USE_LIBRETINY)
 #include <Update.h>
 #endif
 #endif  // USE_ARDUINO
@@ -23,8 +21,7 @@ using PlatformString = std::string;
 using PlatformString = String;
 #endif
 
-namespace esphome {
-namespace web_server {
+namespace esphome::web_server {
 
 static const char *const TAG = "web_server.ota";
 
@@ -121,9 +118,6 @@ void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const Platf
 
     // Platform-specific pre-initialization
 #ifdef USE_ARDUINO
-#ifdef USE_ESP8266
-    Update.runAsync(true);
-#endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
     if (Update.isRunning()) {
       Update.abort();
@@ -236,7 +230,6 @@ void WebServerOTAComponent::setup() {
 
 void WebServerOTAComponent::dump_config() { ESP_LOGCONFIG(TAG, "Web Server OTA"); }
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 
 #endif  // USE_WEBSERVER_OTA

esphome/components/web_server/ota/ota_web_server.h

@@ -7,8 +7,7 @@
 #include "esphome/components/web_server_base/web_server_base.h"
 #include "esphome/core/component.h"
 
-namespace esphome {
-namespace web_server {
+namespace esphome::web_server {
 
 class WebServerOTAComponent : public ota::OTAComponent {
  public:
@@ -20,7 +19,6 @@ class WebServerOTAComponent : public ota::OTAComponent {
   friend class OTARequestHandler;
 };
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 
 #endif  // USE_WEBSERVER_OTA

esphome/components/web_server/server_index_v2.h

@@ -6,8 +6,7 @@
 
 #include "esphome/core/hal.h"
 
-namespace esphome {
-namespace web_server {
+namespace esphome::web_server {
 
 const uint8_t INDEX_GZ[] PROGMEM = {
     0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xcd, 0x7d, 0xdb, 0x72, 0xdb, 0xc6, 0xb6, 0xe0, 0xf3,
@@ -644,8 +643,7 @@ const uint8_t INDEX_GZ[] PROGMEM = {
     0x2b, 0x4d, 0x17, 0xb8, 0x87, 0x4c, 0xe9, 0x50, 0x19, 0x14, 0xba, 0x92, 0xde, 0x0a, 0xea, 0x97, 0xce, 0xad, 0x80,
     0x4f, 0xc7, 0xf5, 0xfe, 0x1f, 0xe7, 0xe0, 0x1c, 0x12, 0xcf, 0x89, 0x00, 0x00};
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 
 #endif
 #endif

esphome/components/web_server/server_index_v3.h

@@ -6,8 +6,7 @@
 
 #include "esphome/core/hal.h"
 
-namespace esphome {
-namespace web_server {
+namespace esphome::web_server {
 
 const uint8_t INDEX_GZ[] PROGMEM = {
     0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xcc, 0xbd, 0xeb, 0x7a, 0x1b, 0xb7, 0xb2, 0x20, 0xfa,
@@ -4048,8 +4047,7 @@ const uint8_t INDEX_GZ[] PROGMEM = {
     0x3b, 0x6c, 0x78, 0x02, 0xa6, 0xdc, 0xb4, 0xe8, 0xee, 0x6a, 0xc5, 0x97, 0x94, 0x7e, 0xd1, 0x9b, 0x83, 0x45, 0xb2,
     0xf4, 0x87, 0xff, 0x07, 0x52, 0xaf, 0x09, 0x6c, 0x30, 0x6a, 0x03, 0x00};
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 
 #endif
 #endif

esphome/components/web_server/web_server.cpp

@@ -36,8 +36,7 @@
 #endif
 #endif
 
-namespace esphome {
-namespace web_server {
+namespace esphome::web_server {
 
 static const char *const TAG = "web_server";
 
@@ -45,24 +44,9 @@ static const char *const TAG = "web_server";
 static constexpr size_t PSTR_LOCAL_SIZE = 18;
 #define PSTR_LOCAL(mode_s) ESPHOME_strncpy_P(buf, (ESPHOME_PGM_P) ((mode_s)), PSTR_LOCAL_SIZE - 1)
 
-#ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
-static const char *const HEADER_PNA_NAME = "Private-Network-Access-Name";
-static const char *const HEADER_PNA_ID = "Private-Network-Access-ID";
-static const char *const HEADER_CORS_REQ_PNA = "Access-Control-Request-Private-Network";
-static const char *const HEADER_CORS_ALLOW_PNA = "Access-Control-Allow-Private-Network";
-#endif
-
 // Parse URL and return match info
-// URL formats:
-//   /{domain}/{entity_name} - main device, no method
-//   /{domain}/{entity_name}/{method} - main device with method
-//   /{domain}/{device_name}/{entity_name}/{method} - sub-device with method (USE_DEVICES only)
 static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain) {
   UrlMatch match{};
-#ifdef USE_DEVICES
-  match.device_name = nullptr;
-  match.device_name_len = 0;
-#endif
 
   // URL must start with '/'
   if (url_len < 2 || url_ptr[0] != '/') {
@@ -89,139 +73,34 @@ static UrlMatch match_url(const char *url_ptr, size_t url_len, bool only_domain)
     return match;
   }
 
-  // Parse remaining segments
+  // Parse ID if present
   if (domain_end + 1 >= end) {
     return match;  // Nothing after domain slash
   }
 
-  // Find all remaining slashes to count segments
-  const char *seg1_start = domain_end + 1;
-  const char *seg1_end = (const char *) memchr(seg1_start, '/', end - seg1_start);
+  const char *id_start = domain_end + 1;
+  const char *id_end = (const char *) memchr(id_start, '/', end - id_start);
 
-  if (!seg1_end) {
-    // Only 1 segment after domain: /{domain}/{entity_name}
-    match.id = seg1_start;
-    match.id_len = end - seg1_start;
-    // Reject empty segment (e.g., "/sensor/")
-    if (match.id_len == 0) {
-      return UrlMatch{};
-    }
+  if (!id_end) {
+    // No more slashes, entire remaining string is ID
+    match.id = id_start;
+    match.id_len = end - id_start;
     return match;
   }
 
-  const char *seg2_start = seg1_end + 1;
-  const char *seg2_end = (seg2_start < end) ? (const char *) memchr(seg2_start, '/', end - seg2_start) : nullptr;
+  // Set ID
+  match.id = id_start;
+  match.id_len = id_end - id_start;
 
-  if (!seg2_end) {
-    // 2 segments after domain: /{domain}/{X}/{Y}
-    // This is /{domain}/{entity_name}/{method} for main device
-    match.id = seg1_start;
-    match.id_len = seg1_end - seg1_start;
-    match.method = seg2_start;
-    match.method_len = end - seg2_start;
-    // Reject empty segments (e.g., "/sensor//turn_on" or "/sensor/temp/")
-    if (match.id_len == 0 || match.method_len == 0) {
-      return UrlMatch{};
-    }
-    return match;
+  // Parse method if present
+  if (id_end + 1 < end) {
+    match.method = id_end + 1;
+    match.method_len = end - (id_end + 1);
   }
 
-#ifdef USE_DEVICES
-  // 3+ segments after domain: /{domain}/{device_name}/{entity_name}/{method}
-  const char *seg3_start = seg2_end + 1;
-  match.device_name = seg1_start;
-  match.device_name_len = seg1_end - seg1_start;
-  match.id = seg2_start;
-  match.id_len = seg2_end - seg2_start;
-  if (seg3_start < end) {
-    match.method = seg3_start;
-    match.method_len = end - seg3_start;
-  } else {
-    // No method segment - fields already zero-initialized by UrlMatch{}
-    match.method = nullptr;
-    match.method_len = 0;
-  }
-
-  // Reject empty segments (e.g., "/sensor//entity/turn_on" or "/sensor/device//turn_on")
-  if (match.device_name_len == 0 || match.id_len == 0 || (match.method != nullptr && match.method_len == 0)) {
-    return UrlMatch{};
-  }
-#else
-  // Without USE_DEVICES, reject URLs with 3+ segments (device paths not supported)
-  return UrlMatch{};
-#endif
-
   return match;
 }
 
-EntityMatchResult UrlMatch::match_entity(EntityBase *entity) const {
-  EntityMatchResult result{false, this->method_len == 0};
-
-#ifdef USE_DEVICES
-  Device *entity_device = entity->get_device();
-  bool url_has_device = (this->device_name_len > 0);
-  bool entity_has_device = (entity_device != nullptr);
-
-  if (url_has_device) {
-    // URL has explicit device segment (3+ segments) - must match device
-    if (!entity_has_device)
-      return result;
-    const char *entity_device_name = entity_device->get_name();
-    if (this->device_name_len != strlen(entity_device_name) ||
-        memcmp(this->device_name, entity_device_name, this->device_name_len) != 0)
-      return result;
-  } else if (entity_has_device) {
-    // Entity has device but URL has only 2 segments (id/method)
-    // Try interpreting as device/entity: id=device_name, method=entity_name
-    if (this->method_len == 0)
-      return result;  // Need 2 segments for this interpretation
-    const char *entity_device_name = entity_device->get_name();
-    if (this->id_len == strlen(entity_device_name) && memcmp(this->id, entity_device_name, this->id_len) == 0) {
-      const StringRef &name_ref = entity->get_name();
-      if (this->method_len == name_ref.size() && memcmp(this->method, name_ref.c_str(), this->method_len) == 0) {
-        // Matched: id=device, method=entity_name, so method is effectively empty
-        return {true, true};
-      }
-    }
-    return result;  // No match
-  }
-#endif
-
-  // Try matching by entity name (new format)
-  const StringRef &name_ref = entity->get_name();
-  if (this->id_matches(name_ref.c_str(), name_ref.size())) {
-    result.matched = true;
-    return result;
-  }
-
-  // Fall back to object_id (deprecated format)
-  char object_id_buf[OBJECT_ID_MAX_LEN];
-  StringRef object_id = entity->get_object_id_to(object_id_buf);
-  if (this->id_matches(object_id.c_str(), object_id.size())) {
-    result.matched = true;
-    // Log deprecation warning
-#ifdef USE_DEVICES
-    Device *device = entity->get_device();
-    if (device != nullptr) {
-      ESP_LOGW(TAG,
-               "Deprecated URL format: /%.*s/%.*s/%.*s - use entity name '/%.*s/%s/%s' instead. "
-               "Object ID URLs will be removed in 2026.7.0.",
-               this->domain_len, this->domain, this->device_name_len, this->device_name, this->id_len, this->id,
-               this->domain_len, this->domain, device->get_name(), entity->get_name().c_str());
-    } else
-#endif
-    {
-      ESP_LOGW(TAG,
-               "Deprecated URL format: /%.*s/%.*s - use entity name '/%.*s/%s' instead. "
-               "Object ID URLs will be removed in 2026.7.0.",
-               this->domain_len, this->domain, this->id_len, this->id, this->domain_len, this->domain,
-               entity->get_name().c_str());
-    }
-  }
-
-  return result;
-}
-
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
 // helper for allowing only unique entries in the queue
 void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_generator_t *message_generator) {
@@ -461,7 +340,7 @@ void WebServer::handle_index_request(AsyncWebServerRequest *request) {
 #else
   AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", INDEX_GZ, sizeof(INDEX_GZ));
 #endif
-  response->addHeader("Content-Encoding", "gzip");
+  response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("gzip"));
   request->send(response);
 }
 #elif USE_WEBSERVER_VERSION >= 2
@@ -481,10 +360,10 @@ void WebServer::handle_index_request(AsyncWebServerRequest *request) {
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
 void WebServer::handle_pna_cors_request(AsyncWebServerRequest *request) {
   AsyncWebServerResponse *response = request->beginResponse(200, "");
-  response->addHeader(HEADER_CORS_ALLOW_PNA, "true");
-  response->addHeader(HEADER_PNA_NAME, App.get_name().c_str());
+  response->addHeader(ESPHOME_F("Access-Control-Allow-Private-Network"), ESPHOME_F("true"));
+  response->addHeader(ESPHOME_F("Private-Network-Access-Name"), App.get_name().c_str());
   char mac_s[18];
-  response->addHeader(HEADER_PNA_ID, get_mac_address_pretty_into_buffer(mac_s));
+  response->addHeader(ESPHOME_F("Private-Network-Access-ID"), get_mac_address_pretty_into_buffer(mac_s));
   request->send(response);
 }
 #endif
@@ -498,7 +377,7 @@ void WebServer::handle_css_request(AsyncWebServerRequest *request) {
   AsyncWebServerResponse *response =
       request->beginResponse_P(200, "text/css", ESPHOME_WEBSERVER_CSS_INCLUDE, ESPHOME_WEBSERVER_CSS_INCLUDE_SIZE);
 #endif
-  response->addHeader("Content-Encoding", "gzip");
+  response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("gzip"));
   request->send(response);
 }
 #endif
@@ -512,59 +391,21 @@ void WebServer::handle_js_request(AsyncWebServerRequest *request) {
   AsyncWebServerResponse *response =
       request->beginResponse_P(200, "text/javascript", ESPHOME_WEBSERVER_JS_INCLUDE, ESPHOME_WEBSERVER_JS_INCLUDE_SIZE);
 #endif
-  response->addHeader("Content-Encoding", "gzip");
+  response->addHeader(ESPHOME_F("Content-Encoding"), ESPHOME_F("gzip"));
   request->send(response);
 }
 #endif
 
 // Helper functions to reduce code size by avoiding macro expansion
-// Build unique id as: {domain}/{device_name}/{entity_name} or {domain}/{entity_name}
-// Uses names (not object_id) to avoid UTF-8 collision issues
 static void set_json_id(JsonObject &root, EntityBase *obj, const char *prefix, JsonDetail start_config) {
-  const StringRef &name = obj->get_name();
-  size_t prefix_len = strlen(prefix);
-  size_t name_len = name.size();
-
-#ifdef USE_DEVICES
-  Device *device = obj->get_device();
-  const char *device_name = device ? device->get_name() : nullptr;
-  size_t device_len = device_name ? strlen(device_name) : 0;
-#endif
-
-  // Build id into stack buffer - ArduinoJson copies the string
-  // Format: {prefix}/{device?}/{name}
-  // Buffer size guaranteed by schema validation (NAME_MAX_LENGTH=120):
-  //   With devices: domain(20) + "/" + device(120) + "/" + name(120) + null = 263, rounded up to 280 for safety margin
-  //   Without devices: domain(20) + "/" + name(120) + null = 142, rounded up to 150 for safety margin
-#ifdef USE_DEVICES
-  char id_buf[280];
-#else
-  char id_buf[150];
-#endif
-  char *p = id_buf;
-  memcpy(p, prefix, prefix_len);
-  p += prefix_len;
-  *p++ = '/';
-#ifdef USE_DEVICES
-  if (device_name) {
-    memcpy(p, device_name, device_len);
-    p += device_len;
-    *p++ = '/';
-  }
-#endif
-  memcpy(p, name.c_str(), name_len);
-  p[name_len] = '\0';
-
+  char id_buf[160];  // prefix + dash + object_id (up to 128) + null
+  size_t len = strlen(prefix);
+  memcpy(id_buf, prefix, len);  // NOLINT(bugprone-not-null-terminated-result) - null added by write_object_id_to
+  id_buf[len++] = '-';
+  obj->write_object_id_to(id_buf + len, sizeof(id_buf) - len);
   root[ESPHOME_F("id")] = id_buf;
-
   if (start_config == DETAIL_ALL) {
-    root[ESPHOME_F("domain")] = prefix;
-    root[ESPHOME_F("name")] = name;
-#ifdef USE_DEVICES
-    if (device_name) {
-      root[ESPHOME_F("device")] = device_name;
-    }
-#endif
+    root[ESPHOME_F("name")] = obj->get_name();
     root[ESPHOME_F("icon")] = obj->get_icon_ref();
     root[ESPHOME_F("entity_category")] = obj->get_entity_category();
     bool is_disabled = obj->is_disabled_by_default();
@@ -603,11 +444,10 @@ void WebServer::on_sensor_update(sensor::Sensor *obj) {
 }
 void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (sensor::Sensor *obj : App.get_sensors()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
-    if (entity_match.action_is_empty) {
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -650,11 +490,10 @@ void WebServer::on_text_sensor_update(text_sensor::TextSensor *obj) {
 }
 void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (text_sensor::TextSensor *obj : App.get_text_sensors()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
-    if (entity_match.action_is_empty) {
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->text_sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -693,11 +532,10 @@ void WebServer::on_switch_update(switch_::Switch *obj) {
 }
 void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (switch_::Switch *obj : App.get_switches()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->switch_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -763,10 +601,9 @@ std::string WebServer::switch_json_(switch_::Switch *obj, bool value, JsonDetail
 #ifdef USE_BUTTON
 void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (button::Button *obj : App.get_buttons()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->button_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -808,11 +645,10 @@ void WebServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj) {
 }
 void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (binary_sensor::BinarySensor *obj : App.get_binary_sensors()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
-    if (entity_match.action_is_empty) {
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->binary_sensor_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -850,11 +686,10 @@ void WebServer::on_fan_update(fan::Fan *obj) {
 }
 void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (fan::Fan *obj : App.get_fans()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->fan_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -931,11 +766,10 @@ void WebServer::on_light_update(light::LightState *obj) {
 }
 void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (light::LightState *obj : App.get_lights()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->light_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1010,11 +844,10 @@ void WebServer::on_cover_update(cover::Cover *obj) {
 }
 void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (cover::Cover *obj : App.get_covers()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->cover_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1099,11 +932,10 @@ void WebServer::on_number_update(number::Number *obj) {
 }
 void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_numbers()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->number_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -1167,10 +999,9 @@ void WebServer::on_date_update(datetime::DateEntity *obj) {
 }
 void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_dates()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->date_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1231,10 +1062,9 @@ void WebServer::on_time_update(datetime::TimeEntity *obj) {
 }
 void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_times()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->time_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1294,10 +1124,9 @@ void WebServer::on_datetime_update(datetime::DateTimeEntity *obj) {
 }
 void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_datetimes()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->datetime_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1359,11 +1188,10 @@ void WebServer::on_text_update(text::Text *obj) {
 }
 void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_texts()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->text_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -1416,11 +1244,10 @@ void WebServer::on_select_update(select::Select *obj) {
 }
 void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_selects()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->select_json_(obj, obj->has_state() ? obj->current_option() : "", detail);
       request->send(200, "application/json", data.c_str());
@@ -1474,11 +1301,10 @@ void WebServer::on_climate_update(climate::Climate *obj) {
 }
 void WebServer::handle_climate_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (auto *obj : App.get_climates()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->climate_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1625,11 +1451,10 @@ void WebServer::on_lock_update(lock::Lock *obj) {
 }
 void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (lock::Lock *obj : App.get_locks()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->lock_json_(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
@@ -1700,11 +1525,10 @@ void WebServer::on_valve_update(valve::Valve *obj) {
 }
 void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (valve::Valve *obj : App.get_valves()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->valve_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -1785,11 +1609,10 @@ void WebServer::on_alarm_control_panel_update(alarm_control_panel::AlarmControlP
 }
 void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (alarm_control_panel::AlarmControlPanel *obj : App.get_alarm_control_panels()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->alarm_control_panel_json_(obj, obj->get_state(), detail);
       request->send(200, "application/json", data.c_str());
@@ -1867,12 +1690,11 @@ void WebServer::on_event(event::Event *obj) {
 
 void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (event::Event *obj : App.get_events()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
     // Note: request->method() is always HTTP_GET here (canHandle ensures this)
-    if (entity_match.action_is_empty) {
+    if (match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->event_json_(obj, "", detail);
       request->send(200, "application/json", data.c_str());
@@ -1937,11 +1759,10 @@ void WebServer::on_update(update::UpdateEntity *obj) {
 }
 void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlMatch &match) {
   for (update::UpdateEntity *obj : App.get_updates()) {
-    auto entity_match = match.match_entity(obj);
-    if (!entity_match.matched)
+    if (!match.id_equals_entity(obj))
       continue;
 
-    if (request->method() == HTTP_GET && entity_match.action_is_empty) {
+    if (request->method() == HTTP_GET && match.method_empty()) {
       auto detail = get_request_detail(request);
       std::string data = this->update_json_(obj, detail);
       request->send(200, "application/json", data.c_str());
@@ -2012,7 +1833,7 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   }
 
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
-  if (method == HTTP_OPTIONS && request->hasHeader(HEADER_CORS_REQ_PNA))
+  if (method == HTTP_OPTIONS && request->hasHeader(ESPHOME_F("Access-Control-Request-Private-Network")))
     return true;
 #endif
 
@@ -2145,7 +1966,7 @@ void WebServer::handleRequest(AsyncWebServerRequest *request) {
 #endif
 
 #ifdef USE_WEBSERVER_PRIVATE_NETWORK_ACCESS
-  if (request->method() == HTTP_OPTIONS && request->hasHeader(HEADER_CORS_REQ_PNA)) {
+  if (request->method() == HTTP_OPTIONS && request->hasHeader(ESPHOME_F("Access-Control-Request-Private-Network"))) {
     this->handle_pna_cors_request(request);
     return;
   }
@@ -2283,6 +2104,5 @@ void WebServer::add_sorting_group(uint64_t group_id, const std::string &group_na
 }
 #endif
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 #endif

esphome/components/web_server/web_server.h

@@ -33,47 +33,35 @@ extern const uint8_t ESPHOME_WEBSERVER_JS_INCLUDE[] PROGMEM;
 extern const size_t ESPHOME_WEBSERVER_JS_INCLUDE_SIZE;
 #endif
 
-namespace esphome {
-namespace web_server {
-
-/// Result of matching a URL against an entity
-struct EntityMatchResult {
-  bool matched;          ///< True if entity matched the URL
-  bool action_is_empty;  ///< True if no action in URL (or action field was used as entity name for 2-seg subdevice)
-};
+namespace esphome::web_server {
 
 /// Internal helper struct that is used to parse incoming URLs
-/// Note: Length fields use uint8_t, so NAME_MAX_LENGTH in config_validation.py must stay < 255
 struct UrlMatch {
   const char *domain;  ///< Pointer to domain within URL, for example "sensor"
-  const char *id;      ///< Pointer to entity name/id within URL, for example "Temperature"
+  const char *id;      ///< Pointer to id within URL, for example "living_room_fan"
   const char *method;  ///< Pointer to method within URL, for example "turn_on"
-#ifdef USE_DEVICES
-  const char *device_name;  ///< Pointer to device name within URL, or nullptr for main device
-#endif
   uint8_t domain_len;  ///< Length of domain string
-  uint8_t id_len;      ///< Length of id string (NAME_MAX_LENGTH must be < 255)
+  uint8_t id_len;      ///< Length of id string
   uint8_t method_len;  ///< Length of method string
-#ifdef USE_DEVICES
-  uint8_t device_name_len;  ///< Length of device name string (NAME_MAX_LENGTH must be < 255)
-#endif
-  bool valid;  ///< Whether this match is valid
+  bool valid;          ///< Whether this match is valid
 
   // Helper methods for string comparisons
   bool domain_equals(const char *str) const {
     return domain && domain_len == strlen(str) && memcmp(domain, str, domain_len) == 0;
   }
 
-  /// Check if URL id segment matches a string (by pointer and length)
-  bool id_matches(const char *str, size_t len) const { return id && id_len == len && memcmp(id, str, len) == 0; }
-
-  /// Match entity by name first, then fall back to object_id with deprecation warning
-  /// Returns EntityMatchResult with match status and whether method is effectively empty
-  EntityMatchResult match_entity(EntityBase *entity) const;
+  bool id_equals_entity(EntityBase *entity) const {
+    // Get object_id with zero heap allocation
+    char object_id_buf[OBJECT_ID_MAX_LEN];
+    StringRef object_id = entity->get_object_id_to(object_id_buf);
+    return id && id_len == object_id.size() && memcmp(id, object_id.c_str(), id_len) == 0;
+  }
 
   bool method_equals(const char *str) const {
     return method && method_len == strlen(str) && memcmp(method, str, method_len) == 0;
   }
+
+  bool method_empty() const { return method_len == 0; }
 };
 
 #ifdef USE_WEBSERVER_SORTING
@@ -627,6 +615,5 @@ class WebServer : public Controller,
 #endif
 };
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 #endif

esphome/components/web_server/web_server_v1.cpp

@@ -3,31 +3,7 @@
 
 #if USE_WEBSERVER_VERSION == 1
 
-namespace esphome {
-namespace web_server {
-
-// Write HTML-escaped text to stream (escapes ", &, <, >)
-static void write_html_escaped(AsyncResponseStream *stream, const char *text) {
-  for (const char *p = text; *p; ++p) {
-    switch (*p) {
-      case '"':
-        stream->print("&quot;");
-        break;
-      case '&':
-        stream->print("&amp;");
-        break;
-      case '<':
-        stream->print("&lt;");
-        break;
-      case '>':
-        stream->print("&gt;");
-        break;
-      default:
-        stream->write(*p);
-        break;
-    }
-  }
-}
+namespace esphome::web_server {
 
 void write_row(AsyncResponseStream *stream, EntityBase *obj, const std::string &klass, const std::string &action,
                const std::function<void(AsyncResponseStream &stream, EntityBase *obj)> &action_func = nullptr) {
@@ -40,27 +16,8 @@ void write_row(AsyncResponseStream *stream, EntityBase *obj, const std::string &
   stream->print("-");
   char object_id_buf[OBJECT_ID_MAX_LEN];
   stream->print(obj->get_object_id_to(object_id_buf).c_str());
-  // Add data attributes for hierarchical URL support
-  stream->print("\" data-domain=\"");
-  stream->print(klass.c_str());
-  stream->print("\" data-name=\"");
-  write_html_escaped(stream, obj->get_name().c_str());
-#ifdef USE_DEVICES
-  Device *device = obj->get_device();
-  if (device != nullptr) {
-    stream->print("\" data-device=\"");
-    write_html_escaped(stream, device->get_name());
-  }
-#endif
   stream->print("\"><td>");
-#ifdef USE_DEVICES
-  if (device != nullptr) {
-    stream->print("[");
-    write_html_escaped(stream, device->get_name());
-    stream->print("] ");
-  }
-#endif
-  write_html_escaped(stream, obj->get_name().c_str());
+  stream->print(obj->get_name().c_str());
   stream->print("</td><td></td><td>");
   stream->print(action.c_str());
   if (action_func) {
@@ -257,6 +214,5 @@ void WebServer::handle_index_request(AsyncWebServerRequest *request) {
   request->send(stream);
 }
 
-}  // namespace web_server
-}  // namespace esphome
+}  // namespace esphome::web_server
 #endif

esphome/components/web_server_base/web_server_base.h

@@ -100,7 +100,7 @@ class WebServerBase : public Component {
     }
     this->server_ = std::make_unique<AsyncWebServer>(this->port_);
     // All content is controlled and created by user - so allowing all origins is fine here.
-    DefaultHeaders::Instance().addHeader("Access-Control-Allow-Origin", "*");
+    DefaultHeaders::Instance().addHeader(ESPHOME_F("Access-Control-Allow-Origin"), ESPHOME_F("*"));
     this->server_->begin();
 
     for (auto *handler : this->handlers_)

esphome/components/web_server_idf/utils.cpp

@@ -13,8 +13,7 @@ namespace web_server_idf {
 
 static const char *const TAG = "web_server_idf_utils";
 
-size_t url_decode(char *str) {
-  char *start = str;
+void url_decode(char *str) {
   char *ptr = str, buf;
   for (; *str; str++, ptr++) {
     if (*str == '%') {
@@ -32,8 +31,7 @@ size_t url_decode(char *str) {
       *ptr = *str;
     }
   }
-  *ptr = '\0';
-  return ptr - start;
+  *ptr = *str;
 }
 
 bool request_has_header(httpd_req_t *req, const char *name) { return httpd_req_get_hdr_value_len(req, name); }

esphome/components/web_server_idf/utils.h

@@ -8,10 +8,6 @@
 namespace esphome {
 namespace web_server_idf {
 
-/// Decode URL-encoded string in-place (e.g., %20 -> space, + -> space)
-/// Returns the new length of the decoded string
-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);

esphome/components/web_server_idf/web_server_idf.cpp

@@ -247,20 +247,11 @@ optional<std::string> AsyncWebServerRequest::get_header(const char *name) const
 }
 
 std::string AsyncWebServerRequest::url() const {
-  auto *query_start = strchr(this->req_->uri, '?');
-  std::string result;
-  if (query_start == nullptr) {
-    result = this->req_->uri;
-  } else {
-    result = std::string(this->req_->uri, query_start - this->req_->uri);
+  auto *str = strchr(this->req_->uri, '?');
+  if (str == nullptr) {
+    return this->req_->uri;
   }
-  // Decode URL-encoded characters in-place (e.g., %20 -> space)
-  // This matches AsyncWebServer behavior on Arduino
-  if (!result.empty()) {
-    size_t new_len = url_decode(&result[0]);
-    result.resize(new_len);
-  }
-  return result;
+  return std::string(this->req_->uri, str - this->req_->uri);
 }
 
 std::string AsyncWebServerRequest::host() const { return this->get_header("Host").value(); }

esphome/components/wifi/automation.h

@@ -45,7 +45,8 @@ template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, publi
     if (this->connecting_)
       return;
     // If already connected to the same AP, do nothing
-    if (global_wifi_component->wifi_ssid() == ssid) {
+    char ssid_buf[SSID_BUFFER_SIZE];
+    if (strcmp(global_wifi_component->wifi_ssid_to(ssid_buf), ssid.c_str()) == 0) {
       // Callback to notify the user that the connection was successful
       this->connect_trigger_->trigger();
       return;
@@ -94,7 +95,8 @@ template<typename... Ts> class WiFiConfigureAction : public Action<Ts...>, publi
       this->cancel_timeout("wifi-connect-timeout");
       this->cancel_timeout("wifi-fallback-timeout");
       this->connecting_ = false;
-      if (global_wifi_component->wifi_ssid() == this->new_sta_.get_ssid()) {
+      char ssid_buf[SSID_BUFFER_SIZE];
+      if (strcmp(global_wifi_component->wifi_ssid_to(ssid_buf), this->new_sta_.get_ssid().c_str()) == 0) {
         // Callback to notify the user that the connection was successful
         this->connect_trigger_->trigger();
       } else {

esphome/components/wifi/wifi_component.cpp

@@ -899,12 +899,20 @@ void WiFiComponent::print_connect_params_() {
     ESP_LOGCONFIG(TAG, "  Disabled");
     return;
   }
+  // Use stack buffers for IP address formatting to avoid heap allocations
+  char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
   for (auto &ip : wifi_sta_ip_addresses()) {
     if (ip.is_set()) {
-      ESP_LOGCONFIG(TAG, "  IP Address: %s", ip.str().c_str());
+      ESP_LOGCONFIG(TAG, "  IP Address: %s", ip.str_to(ip_buf));
     }
   }
   int8_t rssi = wifi_rssi();
+  // Use stack buffers for SSID and all IP addresses to avoid heap allocations
+  char ssid_buf[SSID_BUFFER_SIZE];
+  char subnet_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char gateway_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char dns1_buf[network::IP_ADDRESS_BUFFER_SIZE];
+  char dns2_buf[network::IP_ADDRESS_BUFFER_SIZE];
   ESP_LOGCONFIG(TAG,
                 "  SSID: " LOG_SECRET("'%s'") "\n"
                                               "  BSSID: " LOG_SECRET("%s") "\n"
@@ -915,9 +923,9 @@ void WiFiComponent::print_connect_params_() {
                                                                            "  Gateway: %s\n"
                                                                            "  DNS1: %s\n"
                                                                            "  DNS2: %s",
-                wifi_ssid().c_str(), bssid_s, App.get_name().c_str(), rssi, LOG_STR_ARG(get_signal_bars(rssi)),
-                get_wifi_channel(), wifi_subnet_mask_().str().c_str(), wifi_gateway_ip_().str().c_str(),
-                wifi_dns_ip_(0).str().c_str(), wifi_dns_ip_(1).str().c_str());
+                wifi_ssid_to(ssid_buf), bssid_s, App.get_name().c_str(), rssi, LOG_STR_ARG(get_signal_bars(rssi)),
+                get_wifi_channel(), wifi_subnet_mask_().str_to(subnet_buf), wifi_gateway_ip_().str_to(gateway_buf),
+                wifi_dns_ip_(0).str_to(dns1_buf), wifi_dns_ip_(1).str_to(dns2_buf));
 #ifdef ESPHOME_LOG_HAS_VERBOSE
   if (const WiFiAP *config = this->get_selected_sta_(); config && config->has_bssid()) {
     ESP_LOGV(TAG, "  Priority: %d", this->get_sta_priority(config->get_bssid()));
@@ -1159,7 +1167,8 @@ void WiFiComponent::check_connecting_finished() {
   auto status = this->wifi_sta_connect_status_();
 
   if (status == WiFiSTAConnectStatus::CONNECTED) {
-    if (wifi_ssid().empty()) {
+    char ssid_buf[SSID_BUFFER_SIZE];
+    if (wifi_ssid_to(ssid_buf)[0] == '\0') {
       ESP_LOGW(TAG, "Connection incomplete");
       this->retry_connect();
       return;
@@ -1523,12 +1532,12 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
     return;  // No BSSID to penalize
   }
 
-  // Get SSID for logging
-  std::string ssid;
+  // Get SSID for logging (use pointer to avoid copy)
+  const std::string *ssid = nullptr;
   if (this->retry_phase_ == WiFiRetryPhase::SCAN_CONNECTING && !this->scan_result_.empty()) {
-    ssid = this->scan_result_[0].get_ssid();
+    ssid = &this->scan_result_[0].get_ssid();
   } else if (const WiFiAP *config = this->get_selected_sta_()) {
-    ssid = config->get_ssid();
+    ssid = &config->get_ssid();
   }
 
   // Only decrease priority on the last attempt for this phase
@@ -1549,8 +1558,8 @@ void WiFiComponent::log_and_adjust_priority_for_failed_connect_() {
 
   char bssid_s[18];
   format_mac_addr_upper(failed_bssid.value().data(), bssid_s);
-  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d", ssid.c_str(), bssid_s,
-           old_priority, new_priority);
+  ESP_LOGD(TAG, "Failed " LOG_SECRET("'%s'") " " LOG_SECRET("(%s)") ", priority %d → %d",
+           ssid != nullptr ? ssid->c_str() : "", bssid_s, old_priority, new_priority);
 
   // After adjusting priority, check if all priorities are now at minimum
   // If so, clear the vector to save memory and reset for fresh start

esphome/components/wifi/wifi_component.h

@@ -6,7 +6,9 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/string_ref.h"
 
+#include <span>
 #include <string>
 #include <vector>
 
@@ -59,6 +61,9 @@ namespace esphome::wifi {
 /// Sentinel value for RSSI when WiFi is not connected
 static constexpr int8_t WIFI_RSSI_DISCONNECTED = -127;
 
+/// Buffer size for SSID (IEEE 802.11 max 32 bytes + null terminator)
+static constexpr size_t SSID_BUFFER_SIZE = 33;
+
 struct SavedWifiSettings {
   char ssid[33];
   char password[65];
@@ -274,7 +279,7 @@ class WiFiScanResultsListener {
  */
 class WiFiConnectStateListener {
  public:
-  virtual void on_wifi_connect_state(const std::string &ssid, const bssid_t &bssid) = 0;
+  virtual void on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) = 0;
 };
 
 /** Listener interface for WiFi power save mode changes.
@@ -406,6 +411,9 @@ class WiFiComponent : public Component {
 
   network::IPAddresses wifi_sta_ip_addresses();
   std::string wifi_ssid();
+  /// Write SSID to buffer without heap allocation.
+  /// Returns pointer to buffer, or empty string if not connected.
+  const char *wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer);
   bssid_t wifi_bssid();
 
   int8_t wifi_rssi();

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -526,7 +526,7 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       s_sta_connected = true;
 #ifdef USE_WIFI_LISTENERS
       for (auto *listener : global_wifi_component->connect_state_listeners_) {
-        listener->on_wifi_connect_state(global_wifi_component->wifi_ssid(), global_wifi_component->wifi_bssid());
+        listener->on_wifi_connect_state(StringRef(buf, it.ssid_len), it.bssid);
       }
       // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
 #ifdef USE_WIFI_MANUAL_IP
@@ -559,8 +559,9 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       s_sta_connected = false;
       s_sta_connecting = false;
 #ifdef USE_WIFI_LISTENERS
+      static constexpr uint8_t EMPTY_BSSID[6] = {};
       for (auto *listener : global_wifi_component->connect_state_listeners_) {
-        listener->on_wifi_connect_state("", bssid_t({0, 0, 0, 0, 0, 0}));
+        listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
       }
 #endif
       break;
@@ -912,6 +913,18 @@ bssid_t WiFiComponent::wifi_bssid() {
   return bssid;
 }
 std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
+const char *WiFiComponent::wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer) {
+  struct station_config conf {};
+  if (!wifi_station_get_config(&conf)) {
+    buffer[0] = '\0';
+    return buffer.data();
+  }
+  // conf.ssid is uint8[32], not null-terminated if full
+  size_t len = strnlen(reinterpret_cast<const char *>(conf.ssid), sizeof(conf.ssid));
+  memcpy(buffer.data(), conf.ssid, len);
+  buffer[len] = '\0';
+  return buffer.data();
+}
 int8_t WiFiComponent::wifi_rssi() {
   if (WiFi.status() != WL_CONNECTED)
     return WIFI_RSSI_DISCONNECTED;

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -737,7 +737,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     s_sta_connected = true;
 #ifdef USE_WIFI_LISTENERS
     for (auto *listener : this->connect_state_listeners_) {
-      listener->on_wifi_connect_state(this->wifi_ssid(), this->wifi_bssid());
+      listener->on_wifi_connect_state(StringRef(buf, it.ssid_len), it.bssid);
     }
     // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
 #ifdef USE_WIFI_MANUAL_IP
@@ -772,8 +772,9 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     s_sta_connecting = false;
     error_from_callback_ = true;
 #ifdef USE_WIFI_LISTENERS
+    static constexpr uint8_t EMPTY_BSSID[6] = {};
     for (auto *listener : this->connect_state_listeners_) {
-      listener->on_wifi_connect_state("", bssid_t({0, 0, 0, 0, 0, 0}));
+      listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
     }
 #endif
 
@@ -1085,6 +1086,19 @@ std::string WiFiComponent::wifi_ssid() {
   size_t len = strnlen(ssid_s, sizeof(info.ssid));
   return {ssid_s, len};
 }
+const char *WiFiComponent::wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer) {
+  wifi_ap_record_t info{};
+  esp_err_t err = esp_wifi_sta_get_ap_info(&info);
+  if (err != ESP_OK) {
+    buffer[0] = '\0';
+    return buffer.data();
+  }
+  // info.ssid is uint8[33], but only 32 bytes are SSID data
+  size_t len = strnlen(reinterpret_cast<const char *>(info.ssid), 32);
+  memcpy(buffer.data(), info.ssid, len);
+  buffer[len] = '\0';
+  return buffer.data();
+}
 int8_t WiFiComponent::wifi_rssi() {
   wifi_ap_record_t info;
   esp_err_t err = esp_wifi_sta_get_ap_info(&info);

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -303,7 +303,7 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
                format_mac_address_pretty(it.bssid).c_str(), it.channel, get_auth_mode_str(it.authmode));
 #ifdef USE_WIFI_LISTENERS
       for (auto *listener : this->connect_state_listeners_) {
-        listener->on_wifi_connect_state(this->wifi_ssid(), this->wifi_bssid());
+        listener->on_wifi_connect_state(StringRef(buf, it.ssid_len), it.bssid);
       }
       // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
 #ifdef USE_WIFI_MANUAL_IP
@@ -357,8 +357,9 @@ void WiFiComponent::wifi_event_callback_(esphome_wifi_event_id_t event, esphome_
 
       s_sta_connecting = false;
 #ifdef USE_WIFI_LISTENERS
+      static constexpr uint8_t EMPTY_BSSID[6] = {};
       for (auto *listener : this->connect_state_listeners_) {
-        listener->on_wifi_connect_state("", bssid_t({0, 0, 0, 0, 0, 0}));
+        listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
       }
 #endif
       break;
@@ -553,6 +554,14 @@ bssid_t WiFiComponent::wifi_bssid() {
   return bssid;
 }
 std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
+const char *WiFiComponent::wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer) {
+  // TODO: Find direct LibreTiny API to avoid Arduino String allocation
+  String ssid = WiFi.SSID();
+  size_t len = std::min(static_cast<size_t>(ssid.length()), SSID_BUFFER_SIZE - 1);
+  memcpy(buffer.data(), ssid.c_str(), len);
+  buffer[len] = '\0';
+  return buffer.data();
+}
 int8_t WiFiComponent::wifi_rssi() { return WiFi.status() == WL_CONNECTED ? WiFi.RSSI() : WIFI_RSSI_DISCONNECTED; }
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {WiFi.subnetMask()}; }

esphome/components/wifi/wifi_component_pico_w.cpp

@@ -214,6 +214,14 @@ bssid_t WiFiComponent::wifi_bssid() {
   return bssid;
 }
 std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
+const char *WiFiComponent::wifi_ssid_to(std::span<char, SSID_BUFFER_SIZE> buffer) {
+  // TODO: Find direct CYW43 API to avoid Arduino String allocation
+  String ssid = WiFi.SSID();
+  size_t len = std::min(static_cast<size_t>(ssid.length()), SSID_BUFFER_SIZE - 1);
+  memcpy(buffer.data(), ssid.c_str(), len);
+  buffer[len] = '\0';
+  return buffer.data();
+}
 int8_t WiFiComponent::wifi_rssi() { return WiFi.status() == WL_CONNECTED ? WiFi.RSSI() : WIFI_RSSI_DISCONNECTED; }
 int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
 
@@ -256,8 +264,10 @@ void WiFiComponent::wifi_loop_() {
     s_sta_was_connected = true;
     ESP_LOGV(TAG, "Connected");
 #ifdef USE_WIFI_LISTENERS
+    String ssid = WiFi.SSID();
+    bssid_t bssid = this->wifi_bssid();
     for (auto *listener : this->connect_state_listeners_) {
-      listener->on_wifi_connect_state(this->wifi_ssid(), this->wifi_bssid());
+      listener->on_wifi_connect_state(StringRef(ssid.c_str(), ssid.length()), bssid);
     }
     // For static IP configurations, notify IP listeners immediately as the IP is already configured
 #ifdef USE_WIFI_MANUAL_IP
@@ -275,8 +285,9 @@ void WiFiComponent::wifi_loop_() {
     s_sta_had_ip = false;
     ESP_LOGV(TAG, "Disconnected");
 #ifdef USE_WIFI_LISTENERS
+    static constexpr uint8_t EMPTY_BSSID[6] = {};
     for (auto *listener : this->connect_state_listeners_) {
-      listener->on_wifi_connect_state("", bssid_t({0, 0, 0, 0, 0, 0}));
+      listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
     }
 #endif
   }

esphome/components/wifi_info/wifi_info_text_sensor.cpp

@@ -46,8 +46,13 @@ void DNSAddressWifiInfo::dump_config() { LOG_TEXT_SENSOR("", "DNS Address", this
 
 void DNSAddressWifiInfo::on_ip_state(const network::IPAddresses &ips, const network::IPAddress &dns1,
                                      const network::IPAddress &dns2) {
-  std::string dns_results = dns1.str() + " " + dns2.str();
-  this->publish_state(dns_results);
+  // IP_ADDRESS_BUFFER_SIZE (40) = max IP (39) + null; space reuses first null's slot
+  char buf[network::IP_ADDRESS_BUFFER_SIZE * 2];
+  dns1.str_to(buf);
+  size_t len1 = strlen(buf);
+  buf[len1] = ' ';
+  dns2.str_to(buf + len1 + 1);
+  this->publish_state(buf);
 }
 
 /**********************
@@ -58,22 +63,36 @@ void ScanResultsWiFiInfo::setup() { wifi::global_wifi_component->add_scan_result
 
 void ScanResultsWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "Scan Results", this); }
 
+// Format: "SSID: -XXdB\n" - caller must ensure ssid_len + 9 bytes available in buffer
+static char *format_scan_entry(char *buf, const char *ssid, size_t ssid_len, int8_t rssi) {
+  memcpy(buf, ssid, ssid_len);
+  buf += ssid_len;
+  *buf++ = ':';
+  *buf++ = ' ';
+  buf = int8_to_str(buf, rssi);
+  *buf++ = 'd';
+  *buf++ = 'B';
+  *buf++ = '\n';
+  return buf;
+}
+
 void ScanResultsWiFiInfo::on_wifi_scan_results(const wifi::wifi_scan_vector_t<wifi::WiFiScanResult> &results) {
-  std::string scan_results;
+  char buf[MAX_STATE_LENGTH + 1];
+  char *ptr = buf;
+  const char *end = buf + MAX_STATE_LENGTH;
+
   for (const auto &scan : results) {
     if (scan.get_is_hidden())
       continue;
+    const std::string &ssid = scan.get_ssid();
+    // Max space: ssid + ": " (2) + "-128" (4) + "dB\n" (3) = ssid + 9
+    if (ptr + ssid.size() + 9 > end)
+      break;
+    ptr = format_scan_entry(ptr, ssid.c_str(), ssid.size(), scan.get_rssi());
+  }
 
-    scan_results += scan.get_ssid();
-    scan_results += ": ";
-    scan_results += esphome::to_string(scan.get_rssi());
-    scan_results += "dB\n";
-  }
-  // There's a limit of 255 characters per state; longer states just don't get sent so we truncate it
-  if (scan_results.length() > MAX_STATE_LENGTH) {
-    scan_results.resize(MAX_STATE_LENGTH);
-  }
-  this->publish_state(scan_results);
+  *ptr = '\0';
+  this->publish_state(buf);
 }
 
 /***************
@@ -84,8 +103,8 @@ void SSIDWiFiInfo::setup() { wifi::global_wifi_component->add_connect_state_list
 
 void SSIDWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "SSID", this); }
 
-void SSIDWiFiInfo::on_wifi_connect_state(const std::string &ssid, const wifi::bssid_t &bssid) {
-  this->publish_state(ssid);
+void SSIDWiFiInfo::on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) {
+  this->publish_state(ssid.str());
 }
 
 /****************
@@ -96,7 +115,7 @@ void BSSIDWiFiInfo::setup() { wifi::global_wifi_component->add_connect_state_lis
 
 void BSSIDWiFiInfo::dump_config() { LOG_TEXT_SENSOR("", "BSSID", this); }
 
-void BSSIDWiFiInfo::on_wifi_connect_state(const std::string &ssid, const wifi::bssid_t &bssid) {
+void BSSIDWiFiInfo::on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) {
   char buf[18] = "unknown";
   if (mac_address_is_valid(bssid.data())) {
     format_mac_addr_upper(bssid.data(), buf);

esphome/components/wifi_info/wifi_info_text_sensor.h

@@ -2,10 +2,12 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/string_ref.h"
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "esphome/components/wifi/wifi_component.h"
 #ifdef USE_WIFI
 #include <array>
+#include <span>
 
 namespace esphome::wifi_info {
 
@@ -52,7 +54,7 @@ class SSIDWiFiInfo final : public Component, public text_sensor::TextSensor, pub
   void dump_config() override;
 
   // WiFiConnectStateListener interface
-  void on_wifi_connect_state(const std::string &ssid, const wifi::bssid_t &bssid) override;
+  void on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) override;
 };
 
 class BSSIDWiFiInfo final : public Component, public text_sensor::TextSensor, public wifi::WiFiConnectStateListener {
@@ -61,7 +63,7 @@ class BSSIDWiFiInfo final : public Component, public text_sensor::TextSensor, pu
   void dump_config() override;
 
   // WiFiConnectStateListener interface
-  void on_wifi_connect_state(const std::string &ssid, const wifi::bssid_t &bssid) override;
+  void on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) override;
 };
 
 class PowerSaveModeWiFiInfo final : public Component,

esphome/components/wifi_signal/wifi_signal_sensor.h

@@ -2,9 +2,11 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/string_ref.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/wifi/wifi_component.h"
 #ifdef USE_WIFI
+#include <span>
 namespace esphome::wifi_signal {
 
 #ifdef USE_WIFI_LISTENERS
@@ -28,7 +30,7 @@ class WiFiSignalSensor : public sensor::Sensor, public PollingComponent {
 
 #ifdef USE_WIFI_LISTENERS
   // WiFiConnectStateListener interface - update RSSI immediately on connect
-  void on_wifi_connect_state(const std::string &ssid, const wifi::bssid_t &bssid) override { this->update(); }
+  void on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) override { this->update(); }
 #endif
 };
 

esphome/config_validation.py

@@ -1972,26 +1972,6 @@ MQTT_COMMAND_COMPONENT_SCHEMA = MQTT_COMPONENT_SCHEMA.extend(
 )
 
 
-def _validate_no_slash(value):
-    """Validate that a name does not contain '/' characters.
-
-    The '/' character is used as a path separator in web server URLs,
-    so it cannot be used in entity or device names.
-    """
-    if "/" in value:
-        raise Invalid(
-            f"Name cannot contain '/' character (used as URL path separator): {value}"
-        )
-    return value
-
-
-# Maximum length for entity, device, and area names
-# This ensures web server URL IDs fit in a 280-byte buffer:
-# domain(20) + "/" + device(120) + "/" + name(120) + null = 263 bytes
-# Note: Must be < 255 because web_server UrlMatch uses uint8_t for length fields
-NAME_MAX_LENGTH = 120
-
-
 def _validate_entity_name(value):
     value = string(value)
     try:
@@ -2002,28 +1982,9 @@ def _validate_entity_name(value):
         requires_friendly_name(
             "Name cannot be None when esphome->friendly_name is not set!"
         )(value)
-    if value is not None:
-        # Validate length for web server URL compatibility
-        if len(value) > NAME_MAX_LENGTH:
-            raise Invalid(
-                f"Name is too long ({len(value)} chars). "
-                f"Maximum length is {NAME_MAX_LENGTH} characters."
-            )
-        # Validate no '/' in name for web server URL compatibility
-        _validate_no_slash(value)
     return value
 
 
-def string_no_slash(value):
-    """Validate a string that cannot contain '/' characters.
-
-    Used for device and area names where '/' is reserved as a URL path separator.
-    Use with cv.Length() to also enforce maximum length.
-    """
-    value = string(value)
-    return _validate_no_slash(value)
-
-
 ENTITY_BASE_SCHEMA = Schema(
     {
         Optional(CONF_NAME): _validate_entity_name,

esphome/core/config.py

@@ -186,14 +186,14 @@ else:
 AREA_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_ID): cv.declare_id(Area),
-        cv.Required(CONF_NAME): cv.All(cv.string_no_slash, cv.Length(max=120)),
+        cv.Required(CONF_NAME): cv.string,
     }
 )
 
 DEVICE_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_ID): cv.declare_id(Device),
-        cv.Required(CONF_NAME): cv.All(cv.string_no_slash, cv.Length(max=120)),
+        cv.Required(CONF_NAME): cv.string,
         cv.Optional(CONF_AREA_ID): cv.use_id(Area),
     }
 )
@@ -207,9 +207,7 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.Required(CONF_NAME): cv.valid_name,
-            cv.Optional(CONF_FRIENDLY_NAME, ""): cv.All(
-                cv.string_no_slash, cv.Length(max=120)
-            ),
+            cv.Optional(CONF_FRIENDLY_NAME, ""): cv.All(cv.string, cv.Length(max=120)),
             cv.Optional(CONF_AREA): validate_area_config,
             cv.Optional(CONF_COMMENT): cv.All(cv.string, cv.Length(max=255)),
             cv.Required(CONF_BUILD_PATH): cv.string,

esphome/core/entity_base.cpp

@@ -19,9 +19,17 @@ void EntityBase::set_name(const char *name, uint32_t object_id_hash) {
     } else
 #endif
     {
-      // Use friendly_name if available, otherwise fall back to device name
+      // Bug-for-bug compatibility with OLD behavior:
+      // - With MAC suffix: OLD code used App.get_friendly_name() directly (no fallback)
+      // - Without MAC suffix: OLD code used pre-computed object_id with fallback to device name
       const std::string &friendly = App.get_friendly_name();
-      this->name_ = StringRef(!friendly.empty() ? friendly : App.get_name());
+      if (App.is_name_add_mac_suffix_enabled()) {
+        // MAC suffix enabled - use friendly_name directly (even if empty) for compatibility
+        this->name_ = StringRef(friendly);
+      } else {
+        // No MAC suffix - fallback to device name if friendly_name is empty
+        this->name_ = StringRef(!friendly.empty() ? friendly : App.get_name());
+      }
     }
     this->flags_.has_own_name = false;
     // Dynamic name - must calculate hash at runtime

esphome/core/entity_base.h

@@ -99,8 +99,6 @@ class EntityBase {
     return this->device_->get_device_id();
   }
   void set_device(Device *device) { this->device_ = device; }
-  // Get the device this entity belongs to (nullptr if main device)
-  Device *get_device() const { return this->device_; }
 #endif
 
   // Check if this entity has state

esphome/core/entity_helpers.py

@@ -75,21 +75,18 @@ async def setup_entity(var: MockObj, config: ConfigType, platform: str) -> None:
         config: Configuration dictionary containing entity settings
         platform: The platform name (e.g., "sensor", "binary_sensor")
     """
-    # Set device if configured
-    device_id_obj: ID | None
+    # Get device info if configured
     if device_id_obj := config.get(CONF_DEVICE_ID):
         device: MockObj = await get_variable(device_id_obj)
         add(var.set_device(device))
 
     # Set the entity name with pre-computed object_id hash
-    # For entities with a name, we pre-compute the hash to avoid runtime calculation
-    # For empty names (use device friendly_name), pass 0 to compute at runtime
+    # For named entities: pre-compute hash from entity name
+    # For empty-name entities: pass 0, C++ calculates hash at runtime from
+    # device name, friendly_name, or app name (bug-for-bug compatibility)
     entity_name = config[CONF_NAME]
-    if entity_name:
-        object_id_hash = fnv1_hash_object_id(entity_name)
-        add(var.set_name(entity_name, object_id_hash))
-    else:
-        add(var.set_name(entity_name, 0))
+    object_id_hash = fnv1_hash_object_id(entity_name) if entity_name else 0
+    add(var.set_name(entity_name, object_id_hash))
     # Only set disabled_by_default if True (default is False)
     if config[CONF_DISABLED_BY_DEFAULT]:
         add(var.set_disabled_by_default(True))

esphome/core/helpers.cpp

@@ -297,6 +297,19 @@ std::string format_hex(const uint8_t *data, size_t length) {
 }
 std::string format_hex(const std::vector<uint8_t> &data) { return format_hex(data.data(), data.size()); }
 
+char *format_hex_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length) {
+  size_t max_bytes = (buffer_size - 1) / 2;
+  if (length > max_bytes) {
+    length = max_bytes;
+  }
+  for (size_t i = 0; i < length; i++) {
+    buffer[2 * i] = format_hex_char(data[i] >> 4);
+    buffer[2 * i + 1] = format_hex_char(data[i] & 0x0F);
+  }
+  buffer[length * 2] = '\0';
+  return buffer;
+}
+
 // Shared implementation for uint8_t and string hex formatting
 static std::string format_hex_pretty_uint8(const uint8_t *data, size_t length, char separator, bool show_length) {
   if (data == nullptr || length == 0)

esphome/core/helpers.h

@@ -701,6 +701,30 @@ inline char format_hex_char(uint8_t v) { return v >= 10 ? 'a' + (v - 10) : '0' +
 /// This always uses uppercase (A-F) for pretty/human-readable output
 inline char format_hex_pretty_char(uint8_t v) { return v >= 10 ? 'A' + (v - 10) : '0' + v; }
 
+/// Write int8 value to buffer without modulo operations.
+/// Buffer must have at least 4 bytes free. Returns pointer past last char written.
+inline char *int8_to_str(char *buf, int8_t val) {
+  int32_t v = val;
+  if (v < 0) {
+    *buf++ = '-';
+    v = -v;
+  }
+  if (v >= 100) {
+    *buf++ = '1';  // int8 max is 128, so hundreds digit is always 1
+    v -= 100;
+    // Must write tens digit (even if 0) after hundreds
+    int32_t tens = v / 10;
+    *buf++ = '0' + tens;
+    v -= tens * 10;
+  } else if (v >= 10) {
+    int32_t tens = v / 10;
+    *buf++ = '0' + tens;
+    v -= tens * 10;
+  }
+  *buf++ = '0' + v;
+  return buf;
+}
+
 /// Format MAC address as XX:XX:XX:XX:XX:XX (uppercase)
 inline void format_mac_addr_upper(const uint8_t *mac, char *output) {
   for (size_t i = 0; i < 6; i++) {
@@ -723,6 +747,24 @@ inline void format_mac_addr_lower_no_sep(const uint8_t *mac, char *output) {
   output[12] = '\0';
 }
 
+/// Format byte array as lowercase hex to buffer (base implementation).
+char *format_hex_to(char *buffer, size_t buffer_size, const uint8_t *data, size_t length);
+
+/// Format byte array as lowercase hex to buffer. Automatically deduces buffer size.
+/// Truncates output if data exceeds buffer capacity. Returns pointer to buffer.
+template<size_t N> inline char *format_hex_to(char (&buffer)[N], const uint8_t *data, size_t length) {
+  static_assert(N >= 3, "Buffer must hold at least one hex byte (3 chars)");
+  return format_hex_to(buffer, N, data, length);
+}
+
+/// Format an unsigned integer in lowercased hex to buffer, starting with the most significant byte.
+template<size_t N, typename T, enable_if_t<std::is_unsigned<T>::value, int> = 0>
+inline char *format_hex_to(char (&buffer)[N], T val) {
+  static_assert(N >= sizeof(T) * 2 + 1, "Buffer too small for type");
+  val = convert_big_endian(val);
+  return format_hex_to(buffer, reinterpret_cast<const uint8_t *>(&val), sizeof(T));
+}
+
 /// Format the six-byte array \p mac into a MAC address.
 std::string format_mac_address_pretty(const uint8_t mac[6]);
 /// Format the byte array \p data of length \p len in lowercased hex.

requirements.txt

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

script/api_protobuf/api_protobuf.py

@@ -354,40 +354,31 @@ def create_field_type_info(
             return FixedArrayRepeatedType(field, size_define)
         return RepeatedTypeInfo(field)
 
-    # Check for mutually exclusive options on bytes fields
-    if field.type == 12:
-        has_pointer_to_buffer = get_field_opt(field, pb.pointer_to_buffer, False)
-        fixed_size = get_field_opt(field, pb.fixed_array_size, None)
-
-        if has_pointer_to_buffer and fixed_size is not None:
-            raise ValueError(
-                f"Field '{field.name}' has both pointer_to_buffer and fixed_array_size. "
-                "These options are mutually exclusive. Use pointer_to_buffer for zero-copy "
-                "or fixed_array_size for traditional array storage."
-            )
-
-        if has_pointer_to_buffer:
-            # Zero-copy pointer approach - no size needed, will use size_t for length
-            return PointerToBytesBufferType(field, None)
-
-        if fixed_size is not None:
-            # Traditional fixed array approach with copy
-            return FixedArrayBytesType(field, fixed_size)
-
-    # Check for pointer_to_buffer option on string fields
-    if field.type == 9:
-        has_pointer_to_buffer = get_field_opt(field, pb.pointer_to_buffer, False)
-
-        if has_pointer_to_buffer:
-            # Zero-copy pointer approach for strings
-            return PointerToBytesBufferType(field, None)
-
     # Special handling for bytes fields
     if field.type == 12:
+        fixed_size = get_field_opt(field, pb.fixed_array_size, None)
+
+        if fixed_size is not None:
+            # Traditional fixed array approach with copy (takes priority)
+            return FixedArrayBytesType(field, fixed_size)
+
+        # For SOURCE_CLIENT only messages (decode but no encode), use pointer
+        # for zero-copy access to the receive buffer
+        if needs_decode and not needs_encode:
+            return PointerToBytesBufferType(field, None)
+
+        # For SOURCE_BOTH/SOURCE_SERVER, explicit annotation is still needed
+        if get_field_opt(field, pb.pointer_to_buffer, False):
+            return PointerToBytesBufferType(field, None)
+
         return BytesType(field, needs_decode, needs_encode)
 
     # Special handling for string fields
     if field.type == 9:
+        # For SOURCE_CLIENT only messages (decode but no encode), use StringRef
+        # for zero-copy access to the receive buffer
+        if needs_decode and not needs_encode:
+            return PointerToStringBufferType(field, None)
         return StringType(field, needs_decode, needs_encode)
 
     validate_field_type(field.type, field.name)
@@ -840,8 +831,8 @@ class BytesType(TypeInfo):
         return self.calculate_field_id_size() + 8  # field ID + 8 bytes typical bytes
 
 
-class PointerToBytesBufferType(TypeInfo):
-    """Type for bytes fields that use pointer_to_buffer option for zero-copy."""
+class PointerToBufferTypeBase(TypeInfo):
+    """Base class for pointer_to_buffer types (bytes and strings) for zero-copy decoding."""
 
     @classmethod
     def can_use_dump_field(cls) -> bool:
@@ -851,29 +842,34 @@ class PointerToBytesBufferType(TypeInfo):
         self, field: descriptor.FieldDescriptorProto, size: int | None = None
     ) -> None:
         super().__init__(field)
-        # Size is not used for pointer_to_buffer - we always use size_t for length
         self.array_size = 0
 
     @property
-    def cpp_type(self) -> str:
-        return "const uint8_t*"
+    def decode_length(self) -> str | None:
+        # This is handled in decode_length_content
+        return None
 
     @property
-    def default_value(self) -> str:
-        return "nullptr"
+    def wire_type(self) -> WireType:
+        """Get the wire type for this field."""
+        return WireType.LENGTH_DELIMITED  # Uses wire type 2
 
-    @property
-    def reference_type(self) -> str:
-        return "const uint8_t*"
+    def get_estimated_size(self) -> int:
+        # field ID + length varint + typical data (assume small for pointer fields)
+        return self.calculate_field_id_size() + 2 + 16
 
-    @property
-    def const_reference_type(self) -> str:
-        return "const uint8_t*"
+
+class PointerToBytesBufferType(PointerToBufferTypeBase):
+    """Type for bytes fields that use pointer_to_buffer option for zero-copy."""
+
+    cpp_type = "const uint8_t*"
+    default_value = "nullptr"
+    reference_type = "const uint8_t*"
+    const_reference_type = "const uint8_t*"
 
     @property
     def public_content(self) -> list[str]:
         # Use uint16_t for length - max packet size is well below 65535
-        # Add pointer and length fields
         return [
             f"const uint8_t* {self.field_name}{{nullptr}};",
             f"uint16_t {self.field_name}_len{{0}};",
@@ -885,24 +881,12 @@ class PointerToBytesBufferType(TypeInfo):
 
     @property
     def decode_length_content(self) -> str | None:
-        # Decode directly stores the pointer to avoid allocation
         return f"""case {self.number}: {{
-      // Use raw data directly to avoid allocation
       this->{self.field_name} = value.data();
       this->{self.field_name}_len = value.size();
       break;
     }}"""
 
-    @property
-    def decode_length(self) -> str | None:
-        # This is handled in decode_length_content
-        return None
-
-    @property
-    def wire_type(self) -> WireType:
-        """Get the wire type for this bytes field."""
-        return WireType.LENGTH_DELIMITED  # Uses wire type 2
-
     def dump(self, name: str) -> str:
         return (
             f"format_hex_pretty(this->{self.field_name}, this->{self.field_name}_len)"
@@ -910,7 +894,6 @@ class PointerToBytesBufferType(TypeInfo):
 
     @property
     def dump_content(self) -> str:
-        # Custom dump that doesn't use dump_field template
         return (
             f'out.append("  {self.name}: ");\n'
             + f"out.append({self.dump(self.field_name)});\n"
@@ -918,11 +901,48 @@ class PointerToBytesBufferType(TypeInfo):
         )
 
     def get_size_calculation(self, name: str, force: bool = False) -> str:
-        return f"size.add_length({self.number}, this->{self.field_name}_len);"
+        return f"size.add_length({self.calculate_field_id_size()}, this->{self.field_name}_len);"
 
-    def get_estimated_size(self) -> int:
-        # field ID + length varint + typical data (assume small for pointer fields)
-        return self.calculate_field_id_size() + 2 + 16
+
+class PointerToStringBufferType(PointerToBufferTypeBase):
+    """Type for string fields that use pointer_to_buffer option for zero-copy.
+
+    Uses StringRef instead of separate pointer and length fields.
+    """
+
+    cpp_type = "StringRef"
+    default_value = ""
+    reference_type = "StringRef &"
+    const_reference_type = "const StringRef &"
+
+    @property
+    def public_content(self) -> list[str]:
+        return [f"StringRef {self.field_name}{{}};"]
+
+    @property
+    def encode_content(self) -> str:
+        return f"buffer.encode_string({self.number}, this->{self.field_name});"
+
+    @property
+    def decode_length_content(self) -> str | None:
+        return f"""case {self.number}: {{
+      this->{self.field_name} = StringRef(reinterpret_cast<const char *>(value.data()), value.size());
+      break;
+    }}"""
+
+    def dump(self, name: str) -> str:
+        return f'out.append("\'").append(this->{self.field_name}.c_str(), this->{self.field_name}.size()).append("\'");'
+
+    @property
+    def dump_content(self) -> str:
+        return (
+            f'out.append("  {self.name}: ");\n'
+            + f"{self.dump(self.field_name)}\n"
+            + 'out.append("\\n");'
+        )
+
+    def get_size_calculation(self, name: str, force: bool = False) -> str:
+        return f"size.add_length({self.calculate_field_id_size()}, this->{self.field_name}.size());"
 
 
 class FixedArrayBytesType(TypeInfo):

tests/integration/conftest.py

@@ -51,6 +51,9 @@ if platform.system() == "Windows":
 
 import pty  # not available on Windows
 
+# Register assert rewrite for entity_utils so assertions have proper error messages
+pytest.register_assert_rewrite("tests.integration.entity_utils")
+
 
 def _get_platformio_env(cache_dir: Path) -> dict[str, str]:
     """Get environment variables for PlatformIO with shared cache."""

tests/integration/entity_utils.py

@@ -0,0 +1,144 @@
+"""Utilities for computing entity object_id in integration tests.
+
+This module contains the algorithm that aioesphomeapi will use to compute
+object_id client-side from API data.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from esphome.helpers import fnv1_hash_object_id, sanitize, snake_case
+
+if TYPE_CHECKING:
+    from aioesphomeapi import DeviceInfo, EntityInfo
+
+
+def compute_object_id(name: str) -> str:
+    """Compute object_id from name using snake_case + sanitize."""
+    return sanitize(snake_case(name))
+
+
+def infer_name_add_mac_suffix(device_info: DeviceInfo) -> bool:
+    """Infer name_add_mac_suffix from device name ending with MAC suffix."""
+    mac_suffix = device_info.mac_address.replace(":", "")[-6:].lower()
+    return device_info.name.endswith(f"-{mac_suffix}")
+
+
+def compute_entity_object_id(
+    entity: EntityInfo,
+    device_info: DeviceInfo,
+    device_id_to_name: dict[int, str],
+) -> str:
+    """Compute expected object_id for an entity using the algorithm from PR summary.
+
+    This is the algorithm that aioesphomeapi will use to compute object_id
+    client-side from API data.
+
+    Args:
+        entity: The entity to compute object_id for
+        device_info: Device info from the API
+        device_id_to_name: Mapping of device_id to device name for sub-devices
+
+    Returns:
+        The computed object_id string
+    """
+    name_add_mac_suffix = infer_name_add_mac_suffix(device_info)
+
+    if entity.name:
+        # Named entity: use entity name
+        name_for_id = entity.name
+    elif entity.device_id != 0:
+        # Empty name on sub-device: use sub-device name
+        name_for_id = device_id_to_name[entity.device_id]
+    elif name_add_mac_suffix:
+        # Empty name on main device with MAC suffix: use friendly_name directly
+        # (even if empty - this is bug-for-bug compatibility)
+        name_for_id = device_info.friendly_name
+    elif device_info.friendly_name:
+        # Empty name on main device with friendly_name set: use it
+        name_for_id = device_info.friendly_name
+    else:
+        # Empty name on main device, no friendly_name: use device name
+        name_for_id = device_info.name
+
+    return compute_object_id(name_for_id)
+
+
+def compute_entity_hash(
+    entity: EntityInfo,
+    device_info: DeviceInfo,
+    device_id_to_name: dict[int, str],
+) -> int:
+    """Compute expected object_id hash for an entity.
+
+    Args:
+        entity: The entity to compute hash for
+        device_info: Device info from the API
+        device_id_to_name: Mapping of device_id to device name for sub-devices
+
+    Returns:
+        The computed FNV-1 hash
+    """
+    name_add_mac_suffix = infer_name_add_mac_suffix(device_info)
+
+    if entity.name:
+        name_for_id = entity.name
+    elif entity.device_id != 0:
+        name_for_id = device_id_to_name[entity.device_id]
+    elif name_add_mac_suffix or device_info.friendly_name:
+        name_for_id = device_info.friendly_name
+    else:
+        name_for_id = device_info.name
+
+    return fnv1_hash_object_id(name_for_id)
+
+
+def verify_entity_object_id(
+    entity: EntityInfo,
+    device_info: DeviceInfo,
+    device_id_to_name: dict[int, str],
+) -> None:
+    """Verify an entity's object_id and hash match the expected values.
+
+    Args:
+        entity: The entity to verify
+        device_info: Device info from the API
+        device_id_to_name: Mapping of device_id to device name for sub-devices
+
+    Raises:
+        AssertionError: If object_id or hash doesn't match expected value
+    """
+    expected_object_id = compute_entity_object_id(
+        entity, device_info, device_id_to_name
+    )
+    assert entity.object_id == expected_object_id, (
+        f"object_id mismatch for entity '{entity.name}': "
+        f"expected '{expected_object_id}', got '{entity.object_id}'"
+    )
+
+    expected_hash = compute_entity_hash(entity, device_info, device_id_to_name)
+    assert entity.key == expected_hash, (
+        f"hash mismatch for entity '{entity.name}': "
+        f"expected {expected_hash:#x}, got {entity.key:#x}"
+    )
+
+
+def verify_all_entities(
+    entities: list[EntityInfo],
+    device_info: DeviceInfo,
+) -> None:
+    """Verify all entities have correct object_id and hash values.
+
+    Args:
+        entities: List of entities to verify
+        device_info: Device info from the API
+
+    Raises:
+        AssertionError: If any entity's object_id or hash doesn't match
+    """
+    # Build device_id -> name lookup from sub-devices
+    device_id_to_name = {d.device_id: d.name for d in device_info.devices}
+
+    for entity in entities:
+        verify_entity_object_id(entity, device_info, device_id_to_name)

tests/integration/fixtures/object_id_friendly_name_no_mac_suffix.yaml

@@ -0,0 +1,27 @@
+esphome:
+  name: test-device
+  # friendly_name set but NO MAC suffix
+  # Empty-name entity should use friendly_name for object_id
+  friendly_name: My Friendly Device
+
+host:
+
+api:
+
+logger:
+
+sensor:
+  # Empty name entity - should use friendly_name for object_id
+  # friendly_name = "My Friendly Device" -> object_id = "my_friendly_device"
+  - platform: template
+    name: ""
+    id: sensor_empty_name
+    lambda: return 42.0;
+    update_interval: 60s
+
+  # Named entity for comparison
+  - platform: template
+    name: "Temperature"
+    id: sensor_named
+    lambda: return 43.0;
+    update_interval: 60s

tests/integration/fixtures/object_id_no_friendly_name_no_mac_suffix.yaml

@@ -0,0 +1,25 @@
+esphome:
+  name: test-device
+  # No friendly_name set, no MAC suffix
+  # OLD behavior: object_id = device name because Python pre-computed with fallback
+
+host:
+
+api:
+
+logger:
+
+sensor:
+  # Empty name entity - OLD behavior used device name as fallback
+  - platform: template
+    name: ""
+    id: sensor_empty_name
+    lambda: return 42.0;
+    update_interval: 60s
+
+  # Named entity for comparison
+  - platform: template
+    name: "Temperature"
+    id: sensor_named
+    lambda: return 43.0;
+    update_interval: 60s

tests/integration/fixtures/object_id_no_friendly_name_with_mac_suffix.yaml

@@ -0,0 +1,26 @@
+esphome:
+  name: test-device
+  # No friendly_name set, MAC suffix enabled
+  # OLD behavior: object_id = "" (empty) because is_object_id_dynamic_() used App.get_friendly_name() directly
+  name_add_mac_suffix: true
+
+host:
+
+api:
+
+logger:
+
+sensor:
+  # Empty name entity - OLD behavior produced empty object_id when MAC suffix enabled
+  - platform: template
+    name: ""
+    id: sensor_empty_name
+    lambda: return 42.0;
+    update_interval: 60s
+
+  # Named entity for comparison
+  - platform: template
+    name: "Temperature"
+    id: sensor_named
+    lambda: return 43.0;
+    update_interval: 60s

tests/integration/test_object_id_api_verification.py

@@ -25,8 +25,9 @@ from __future__ import annotations
 
 import pytest
 
-from esphome.helpers import fnv1_hash_object_id, sanitize, snake_case
+from esphome.helpers import fnv1_hash_object_id
 
+from .entity_utils import compute_object_id, verify_all_entities
 from .types import APIClientConnectedFactory, RunCompiledFunction
 
 # Host platform default MAC: 98:35:69:ab:f6:79 -> suffix "abf679"
@@ -62,11 +63,6 @@ SUB_DEVICE_EMPTY_NAME_ENTITIES = [
 ]
 
 
-def compute_expected_object_id(name: str) -> str:
-    """Compute expected object_id from name using Python helpers."""
-    return sanitize(snake_case(name))
-
-
 @pytest.mark.asyncio
 async def test_object_id_api_verification(
     yaml_config: str,
@@ -120,7 +116,7 @@ async def test_object_id_api_verification(
             )
 
             # Verify Python computation matches
-            computed = compute_expected_object_id(entity_name)
+            computed = compute_object_id(entity_name)
             assert computed == expected_object_id, (
                 f"Entity '{entity_name}': Python computation mismatch. "
                 f"Computed '{computed}', expected '{expected_object_id}'"
@@ -160,7 +156,7 @@ async def test_object_id_api_verification(
                 )
                 expected_name = device_id_to_name[entity.device_id]
 
-            expected_object_id = compute_expected_object_id(expected_name)
+            expected_object_id = compute_object_id(expected_name)
             assert entity.object_id == expected_object_id, (
                 f"Empty-name entity (device_id={entity.device_id}): object_id mismatch. "
                 f"API: '{entity.object_id}', expected: '{expected_object_id}' "
@@ -174,33 +170,7 @@ async def test_object_id_api_verification(
                 f"API key: {entity.key:#x}, expected: {expected_hash:#x}"
             )
 
-        # === Test 3: Verify ALL entities can have object_id computed from API data ===
-        # This is the key property for removing object_id from the API protocol
-        for entity in entities:
-            if entity.name:
-                # Named entity - use entity name
-                name_for_object_id = entity.name
-            elif entity.device_id == 0:
-                # Empty name on main device - use friendly_name
-                name_for_object_id = device_info.friendly_name
-            else:
-                # Empty name on sub-device - use device name
-                name_for_object_id = device_id_to_name[entity.device_id]
-
-            # Compute object_id from the appropriate name
-            computed_object_id = compute_expected_object_id(name_for_object_id)
-
-            # Verify it matches what the API returned
-            assert entity.object_id == computed_object_id, (
-                f"Entity (name='{entity.name}', device_id={entity.device_id}): "
-                f"object_id cannot be computed. "
-                f"API: '{entity.object_id}', Computed from '{name_for_object_id}': '{computed_object_id}'"
-            )
-
-            # Verify hash can also be computed
-            computed_hash = fnv1_hash_object_id(name_for_object_id)
-            assert entity.key == computed_hash, (
-                f"Entity (name='{entity.name}', device_id={entity.device_id}): "
-                f"hash cannot be computed. "
-                f"API key: {entity.key:#x}, Computed: {computed_hash:#x}"
-            )
+        # === Test 3: Verify ALL entities using the algorithm from entity_utils ===
+        # This uses the algorithm that aioesphomeapi will use to compute object_id
+        # client-side from API data.
+        verify_all_entities(entities, device_info)

tests/integration/test_object_id_friendly_name_no_mac_suffix.py

@@ -0,0 +1,81 @@
+"""Integration test for object_id with friendly_name but no MAC suffix.
+
+This test covers Branch 4 of the algorithm:
+- Empty name on main device
+- NO MAC suffix enabled
+- friendly_name IS set
+- Result: use friendly_name for object_id
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from esphome.helpers import fnv1_hash_object_id
+
+from .entity_utils import (
+    compute_object_id,
+    infer_name_add_mac_suffix,
+    verify_all_entities,
+)
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+
+@pytest.mark.asyncio
+async def test_object_id_friendly_name_no_mac_suffix(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test object_id when friendly_name is set but no MAC suffix.
+
+    This covers Branch 4 of the algorithm:
+    - Empty name entity
+    - name_add_mac_suffix = false (or not set)
+    - friendly_name = "My Friendly Device"
+    - Expected: object_id = "my_friendly_device"
+    """
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        device_info = await client.device_info()
+        assert device_info is not None
+
+        # Device name should NOT include MAC suffix
+        assert device_info.name == "test-device"
+
+        # Friendly name should be set
+        assert device_info.friendly_name == "My Friendly Device"
+
+        entities, _ = await client.list_entities_services()
+
+        # Find the empty-name entity
+        empty_name_entities = [e for e in entities if e.name == ""]
+        assert len(empty_name_entities) == 1
+
+        entity = empty_name_entities[0]
+
+        # Should use friendly_name for object_id (Branch 4)
+        expected_object_id = compute_object_id("My Friendly Device")
+        assert expected_object_id == "my_friendly_device"  # Verify our expectation
+        assert entity.object_id == expected_object_id, (
+            f"Expected object_id '{expected_object_id}' from friendly_name, "
+            f"got '{entity.object_id}'"
+        )
+
+        # Hash should match friendly_name
+        expected_hash = fnv1_hash_object_id("My Friendly Device")
+        assert entity.key == expected_hash, (
+            f"Expected hash {expected_hash:#x}, got {entity.key:#x}"
+        )
+
+        # Named entity should work normally
+        named_entities = [e for e in entities if e.name == "Temperature"]
+        assert len(named_entities) == 1
+        assert named_entities[0].object_id == "temperature"
+
+        # Verify our inference: no MAC suffix in this test
+        assert not infer_name_add_mac_suffix(device_info), (
+            "Device name should NOT have MAC suffix"
+        )
+
+        # Verify the full algorithm from entity_utils works for ALL entities
+        verify_all_entities(entities, device_info)

tests/integration/test_object_id_no_friendly_name.py

@@ -0,0 +1,140 @@
+"""Integration tests for object_id when friendly_name is not set.
+
+These tests verify bug-for-bug compatibility with the old behavior:
+
+1. With MAC suffix enabled + no friendly_name:
+   - OLD: is_object_id_dynamic_() was true, used App.get_friendly_name() directly
+   - OLD: object_id = "" (empty) because friendly_name was empty
+   - NEW: Must maintain same behavior for compatibility
+
+2. Without MAC suffix + no friendly_name:
+   - OLD: is_object_id_dynamic_() was false, used pre-computed object_id_c_str_
+   - OLD: Python computed object_id with fallback to device name
+   - NEW: Must maintain same behavior (object_id = device name)
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from esphome.helpers import fnv1_hash_object_id
+
+from .entity_utils import compute_object_id, verify_all_entities
+from .types import APIClientConnectedFactory, RunCompiledFunction
+
+# Host platform default MAC: 98:35:69:ab:f6:79 -> suffix "abf679"
+MAC_SUFFIX = "abf679"
+
+# FNV1 offset basis - hash of empty string
+FNV1_OFFSET_BASIS = 2166136261
+
+
+@pytest.mark.asyncio
+async def test_object_id_no_friendly_name_with_mac_suffix(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test object_id when friendly_name not set but MAC suffix enabled.
+
+    OLD behavior (bug-for-bug compatibility):
+    - is_object_id_dynamic_() returned true (no own name AND mac suffix enabled)
+    - format_dynamic_object_id() used App.get_friendly_name() directly
+    - Since friendly_name was empty, object_id was empty
+
+    This was arguably a bug, but we maintain it for compatibility.
+    """
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        device_info = await client.device_info()
+        assert device_info is not None
+
+        # Device name should include MAC suffix
+        expected_device_name = f"test-device-{MAC_SUFFIX}"
+        assert device_info.name == expected_device_name
+
+        # Friendly name should be empty (not set in config)
+        assert device_info.friendly_name == ""
+
+        entities, _ = await client.list_entities_services()
+
+        # Find the empty-name entity
+        empty_name_entities = [e for e in entities if e.name == ""]
+        assert len(empty_name_entities) == 1
+
+        entity = empty_name_entities[0]
+
+        # OLD behavior: object_id was empty because App.get_friendly_name() was empty
+        # This is bug-for-bug compatibility
+        assert entity.object_id == "", (
+            f"Expected empty object_id for bug-for-bug compatibility, "
+            f"got '{entity.object_id}'"
+        )
+
+        # Hash should be FNV1_OFFSET_BASIS (hash of empty string)
+        assert entity.key == FNV1_OFFSET_BASIS, (
+            f"Expected hash of empty string ({FNV1_OFFSET_BASIS:#x}), "
+            f"got {entity.key:#x}"
+        )
+
+        # Named entity should work normally
+        named_entities = [e for e in entities if e.name == "Temperature"]
+        assert len(named_entities) == 1
+        assert named_entities[0].object_id == "temperature"
+
+        # Verify the full algorithm from entity_utils works for ALL entities
+        verify_all_entities(entities, device_info)
+
+
+@pytest.mark.asyncio
+async def test_object_id_no_friendly_name_no_mac_suffix(
+    yaml_config: str,
+    run_compiled: RunCompiledFunction,
+    api_client_connected: APIClientConnectedFactory,
+) -> None:
+    """Test object_id when friendly_name not set and no MAC suffix.
+
+    OLD behavior:
+    - is_object_id_dynamic_() returned false (mac suffix not enabled)
+    - Used object_id_c_str_ which was pre-computed in Python
+    - Python used get_base_entity_object_id() with fallback to CORE.name
+
+    Result: object_id = sanitize(snake_case(device_name))
+    """
+    async with run_compiled(yaml_config), api_client_connected() as client:
+        device_info = await client.device_info()
+        assert device_info is not None
+
+        # Device name should NOT include MAC suffix
+        assert device_info.name == "test-device"
+
+        # Friendly name should be empty (not set in config)
+        assert device_info.friendly_name == ""
+
+        entities, _ = await client.list_entities_services()
+
+        # Find the empty-name entity
+        empty_name_entities = [e for e in entities if e.name == ""]
+        assert len(empty_name_entities) == 1
+
+        entity = empty_name_entities[0]
+
+        # OLD behavior: object_id was computed from device name
+        expected_object_id = compute_object_id("test-device")
+        assert entity.object_id == expected_object_id, (
+            f"Expected object_id '{expected_object_id}' from device name, "
+            f"got '{entity.object_id}'"
+        )
+
+        # Hash should match device name
+        expected_hash = fnv1_hash_object_id("test-device")
+        assert entity.key == expected_hash, (
+            f"Expected hash {expected_hash:#x}, got {entity.key:#x}"
+        )
+
+        # Named entity should work normally
+        named_entities = [e for e in entities if e.name == "Temperature"]
+        assert len(named_entities) == 1
+        assert named_entities[0].object_id == "temperature"
+
+        # Verify the full algorithm from entity_utils works for ALL entities
+        verify_all_entities(entities, device_info)

tests/unit_tests/core/test_entity_helpers.py

@@ -760,3 +760,140 @@ def test_entity_duplicate_validator_same_name_no_enhanced_message() -> None:
         r"Each entity on a device must have a unique name within its platform\.$",
     ):
         validator(config2)
+
+
+@pytest.mark.asyncio
+async def test_setup_entity_empty_name_with_device(
+    setup_test_environment: list[str],
+) -> None:
+    """Test setup_entity with empty entity name on a sub-device.
+
+    For empty-name entities, Python passes 0 and C++ calculates the hash
+    at runtime from the device's actual name.
+    """
+    added_expressions = setup_test_environment
+
+    # Mock get_variable to return a mock device
+    original_get_variable = entity_helpers.get_variable
+
+    async def mock_get_variable(id_: ID) -> MockObj:
+        return MockObj("sub_device_1")
+
+    entity_helpers.get_variable = mock_get_variable
+
+    var = MockObj("sensor1")
+    device_id = ID("sub_device_1", type="Device")
+
+    config = {
+        CONF_NAME: "",
+        CONF_DISABLED_BY_DEFAULT: False,
+        CONF_DEVICE_ID: device_id,
+    }
+
+    await setup_entity(var, config, "sensor")
+
+    entity_helpers.get_variable = original_get_variable
+
+    # Check that set_device was called
+    assert any("sensor1.set_device" in expr for expr in added_expressions)
+
+    # For empty-name entities, Python passes 0 - C++ calculates hash at runtime
+    assert any('set_name("", 0)' in expr for expr in added_expressions), (
+        f"Expected set_name with hash 0, got {added_expressions}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_setup_entity_empty_name_with_mac_suffix(
+    setup_test_environment: list[str],
+) -> None:
+    """Test setup_entity with empty name and MAC suffix enabled.
+
+    For empty-name entities, Python passes 0 and C++ calculates the hash
+    at runtime from friendly_name (bug-for-bug compatibility).
+    """
+    added_expressions = setup_test_environment
+
+    # Set up CORE.config with name_add_mac_suffix enabled
+    CORE.config = {"name_add_mac_suffix": True}
+    # Set friendly_name to a specific value
+    CORE.friendly_name = "My Device"
+
+    var = MockObj("sensor1")
+
+    config = {
+        CONF_NAME: "",
+        CONF_DISABLED_BY_DEFAULT: False,
+    }
+
+    await setup_entity(var, config, "sensor")
+
+    # For empty-name entities, Python passes 0 - C++ calculates hash at runtime
+    assert any('set_name("", 0)' in expr for expr in added_expressions), (
+        f"Expected set_name with hash 0, got {added_expressions}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_setup_entity_empty_name_with_mac_suffix_no_friendly_name(
+    setup_test_environment: list[str],
+) -> None:
+    """Test setup_entity with empty name, MAC suffix enabled, but no friendly_name.
+
+    For empty-name entities, Python passes 0 and C++ calculates the hash
+    at runtime. In this case C++ will hash the empty friendly_name
+    (bug-for-bug compatibility).
+    """
+    added_expressions = setup_test_environment
+
+    # Set up CORE.config with name_add_mac_suffix enabled
+    CORE.config = {"name_add_mac_suffix": True}
+    # Set friendly_name to empty
+    CORE.friendly_name = ""
+
+    var = MockObj("sensor1")
+
+    config = {
+        CONF_NAME: "",
+        CONF_DISABLED_BY_DEFAULT: False,
+    }
+
+    await setup_entity(var, config, "sensor")
+
+    # For empty-name entities, Python passes 0 - C++ calculates hash at runtime
+    assert any('set_name("", 0)' in expr for expr in added_expressions), (
+        f"Expected set_name with hash 0, got {added_expressions}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_setup_entity_empty_name_no_mac_suffix_no_friendly_name(
+    setup_test_environment: list[str],
+) -> None:
+    """Test setup_entity with empty name, no MAC suffix, and no friendly_name.
+
+    For empty-name entities, Python passes 0 and C++ calculates the hash
+    at runtime from the device name.
+    """
+    added_expressions = setup_test_environment
+
+    # No MAC suffix (either not set or False)
+    CORE.config = {}
+    # No friendly_name
+    CORE.friendly_name = ""
+    # Device name is set
+    CORE.name = "my-test-device"
+
+    var = MockObj("sensor1")
+
+    config = {
+        CONF_NAME: "",
+        CONF_DISABLED_BY_DEFAULT: False,
+    }
+
+    await setup_entity(var, config, "sensor")
+
+    # For empty-name entities, Python passes 0 - C++ calculates hash at runtime
+    assert any('set_name("", 0)' in expr for expr in added_expressions), (
+        f"Expected set_name with hash 0, got {added_expressions}"
+    )

tests/unit_tests/test_config_validation.py

@@ -502,60 +502,3 @@ def test_only_with_user_value_overrides_default() -> None:
 
     result = schema({"mqtt_id": "custom_id"})
     assert result.get("mqtt_id") == "custom_id"
-
-
-@pytest.mark.parametrize("value", ("hello", "Hello World", "test_name", "温度"))
-def test_string_no_slash__valid(value: str) -> None:
-    actual = config_validation.string_no_slash(value)
-    assert actual == value
-
-
-@pytest.mark.parametrize("value", ("has/slash", "a/b/c", "/leading", "trailing/"))
-def test_string_no_slash__slash_rejected(value: str) -> None:
-    with pytest.raises(Invalid, match="cannot contain '/' character"):
-        config_validation.string_no_slash(value)
-
-
-def test_string_no_slash__long_string_allowed() -> None:
-    # string_no_slash doesn't enforce length - use cv.Length() separately
-    long_value = "x" * 200
-    assert config_validation.string_no_slash(long_value) == long_value
-
-
-def test_string_no_slash__empty() -> None:
-    assert config_validation.string_no_slash("") == ""
-
-
-@pytest.mark.parametrize("value", ("Temperature", "Living Room Light", "温度传感器"))
-def test_validate_entity_name__valid(value: str) -> None:
-    actual = config_validation._validate_entity_name(value)
-    assert actual == value
-
-
-def test_validate_entity_name__slash_rejected() -> None:
-    with pytest.raises(Invalid, match="cannot contain '/' character"):
-        config_validation._validate_entity_name("has/slash")
-
-
-def test_validate_entity_name__max_length() -> None:
-    # 120 chars should pass
-    assert config_validation._validate_entity_name("x" * 120) == "x" * 120
-
-    # 121 chars should fail
-    with pytest.raises(Invalid, match="too long.*121 chars.*Maximum.*120"):
-        config_validation._validate_entity_name("x" * 121)
-
-
-def test_validate_entity_name__none_without_friendly_name() -> None:
-    # When name is "None" and friendly_name is not set, it should fail
-    CORE.friendly_name = None
-    with pytest.raises(Invalid, match="friendly_name is not set"):
-        config_validation._validate_entity_name("None")
-
-
-def test_validate_entity_name__none_with_friendly_name() -> None:
-    # When name is "None" but friendly_name is set, it should return None
-    CORE.friendly_name = "My Device"
-    result = config_validation._validate_entity_name("None")
-    assert result is None
-    CORE.friendly_name = None  # Reset