Add TODO for std::trivially_relocatable when available

- Add #include <type_traits> to both .cpp and .h for static_asserts
- Clarify CompactString comment: explicitly note it is not trivially
  copyable, and that memcpy safety relies on validated layout property
- Use memcpy_fn indirection to suppress both GCC -Wclass-memaccess
  and clang-tidy bugprone-undefined-memory-manipulation without
  platform-specific pragma guards

.github/actions/build-image/action.yaml

@@ -47,7 +47,7 @@ runs:
 
     - name: Build and push to ghcr by digest
       id: build-ghcr
-      uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
+      uses: docker/build-push-action@601a80b39c9405e50806ae38af30926f9d957c47 # v6.19.1
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false
@@ -73,7 +73,7 @@ runs:
 
     - name: Build and push to dockerhub by digest
       id: build-dockerhub
-      uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
+      uses: docker/build-push-action@601a80b39c9405e50806ae38af30926f9d957c47 # v6.19.1
       env:
         DOCKER_BUILD_SUMMARY: false
         DOCKER_BUILD_RECORD_UPLOAD: false

docker/Dockerfile

@@ -9,8 +9,7 @@ FROM ghcr.io/esphome/docker-base:${BUILD_OS}-ha-addon-${BUILD_BASE_VERSION} AS b
 ARG BUILD_TYPE
 FROM base-source-${BUILD_TYPE} AS base
 
-RUN git config --system --add safe.directory "*" \
-    && git config --system advice.detachedHead false
+RUN git config --system --add safe.directory "*"
 
 # Install build tools for Python packages that require compilation
 # (e.g., ruamel.yaml.clibz used by ESP-IDF's idf-component-manager)

esphome/automation.py

@@ -57,14 +57,8 @@ def maybe_conf(conf, *validators):
     return validate
 
 
-def register_action(
-    name: str,
-    action_type: MockObjClass,
-    schema: cv.Schema,
-    *,
-    deferred: bool = False,
-):
-    return ACTION_REGISTRY.register(name, action_type, schema, deferred=deferred)
+def register_action(name: str, action_type: MockObjClass, schema: cv.Schema):
+    return ACTION_REGISTRY.register(name, action_type, schema)
 
 
 def register_condition(name: str, condition_type: MockObjClass, schema: cv.Schema):
@@ -341,10 +335,7 @@ async def component_is_idle_condition_to_code(
 
 
 @register_action(
-    "delay",
-    DelayAction,
-    cv.templatable(cv.positive_time_period_milliseconds),
-    deferred=True,
+    "delay", DelayAction, cv.templatable(cv.positive_time_period_milliseconds)
 )
 async def delay_action_to_code(
     config: ConfigType,
@@ -454,7 +445,7 @@ _validate_wait_until = cv.maybe_simple_value(
 )
 
 
-@register_action("wait_until", WaitUntilAction, _validate_wait_until, deferred=True)
+@register_action("wait_until", WaitUntilAction, _validate_wait_until)
 async def wait_until_action_to_code(
     config: ConfigType,
     action_id: ID,
@@ -587,26 +578,6 @@ async def build_condition_list(
     return conditions
 
 
-def has_deferred_actions(actions: ConfigType) -> bool:
-    """Check if a validated action list contains any deferred actions.
-
-    Deferred actions (delay, wait_until, script.wait) store trigger args
-    for later execution, making non-owning types like StringRef unsafe.
-    """
-    if isinstance(actions, list):
-        return any(has_deferred_actions(item) for item in actions)
-    if isinstance(actions, dict):
-        for key in actions:
-            if key in ACTION_REGISTRY and ACTION_REGISTRY[key].deferred:
-                return True
-        return any(
-            has_deferred_actions(v)
-            for v in actions.values()
-            if isinstance(v, (list, dict))
-        )
-    return False
-
-
 async def build_automation(
     trigger: MockObj, args: TemplateArgsType, config: ConfigType
 ) -> MockObj:

esphome/components/api/__init__.py

@@ -76,7 +76,7 @@ SERVICE_ARG_NATIVE_TYPES: dict[str, MockObj] = {
     "bool": cg.bool_,
     "int": cg.int32,
     "float": cg.float_,
-    "string": cg.StringRef,
+    "string": cg.std_string,
     "bool[]": cg.FixedVector.template(cg.bool_).operator("const").operator("ref"),
     "int[]": cg.FixedVector.template(cg.int32).operator("const").operator("ref"),
     "float[]": cg.FixedVector.template(cg.float_).operator("const").operator("ref"),
@@ -380,16 +380,9 @@ async def to_code(config: ConfigType) -> None:
                 if is_optional:
                     func_args.append((cg.bool_, "return_response"))
 
-            # Check if action chain has deferred actions that would make
-            # non-owning StringRef dangle (rx_buf_ reused after delay)
-            has_deferred = automation.has_deferred_actions(conf.get(CONF_THEN, []))
-
             service_arg_names: list[str] = []
             for name, var_ in conf[CONF_VARIABLES].items():
                 native = SERVICE_ARG_NATIVE_TYPES[var_]
-                # Fall back to std::string for string args if deferred actions exist
-                if has_deferred and native is cg.StringRef:
-                    native = cg.std_string
                 service_template_args.append(native)
                 func_args.append((native, name))
                 service_arg_names.append(name)

esphome/components/api/api.proto

@@ -824,7 +824,7 @@ message HomeAssistantStateResponse {
   option (ifdef) = "USE_API_HOMEASSISTANT_STATES";
 
   string entity_id = 1;
-  string state = 2 [(null_terminate) = true];
+  string state = 2;
   string attribute = 3;
 }
 
@@ -882,7 +882,7 @@ message ExecuteServiceArgument {
   bool bool_ = 1;
   int32 legacy_int = 2;
   float float_ = 3;
-  string string_ = 4 [(null_terminate) = true];
+  string string_ = 4;
   // ESPHome 1.14 (api v1.3) make int a signed value
   sint32 int_ = 5;
   repeated bool bool_array = 6 [packed=false, (fixed_vector) = true];

esphome/components/api/api_connection.cpp

@@ -1683,18 +1683,31 @@ void APIConnection::on_home_assistant_state_response(const HomeAssistantStateRes
   }
 
   for (auto &it : this->parent_->get_state_subs()) {
-    if (msg.entity_id != it.entity_id) {
+    // 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.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
-    // it.attribute can be nullptr (meaning no attribute filter)
-    if (it.attribute != nullptr ? msg.attribute != it.attribute : !msg.attribute.empty()) {
+    size_t sub_attr_len = it.attribute != nullptr ? strlen(it.attribute) : 0;
+    if (sub_attr_len != msg.attribute.size() ||
+        (sub_attr_len > 0 && memcmp(it.attribute, msg.attribute.c_str(), sub_attr_len) != 0)) {
       continue;
     }
 
-    // msg.state is already null-terminated in-place after protobuf decode
-    it.callback(msg.state);
+    // Create null-terminated state for callback (parse_number needs null-termination)
+    // HA state max length is 255 characters, but attributes can be much longer
+    // Use stack buffer for common case (states), heap fallback for large attributes
+    size_t state_len = msg.state.size();
+    SmallBufferWithHeapFallback<MAX_STATE_LEN + 1> state_buf_alloc(state_len + 1);
+    char *state_buf = reinterpret_cast<char *>(state_buf_alloc.get());
+    if (state_len > 0) {
+      memcpy(state_buf, msg.state.c_str(), state_len);
+    }
+    state_buf[state_len] = '\0';
+    it.callback(StringRef(state_buf, state_len));
   }
 }
 #endif
@@ -1851,8 +1864,6 @@ void APIConnection::on_fatal_error() {
   this->flags_.remove = true;
 }
 
-void __attribute__((flatten)) APIConnection::DeferredBatch::push_item(const BatchItem &item) { items.push_back(item); }
-
 void APIConnection::DeferredBatch::add_item(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
                                             uint8_t aux_data_index) {
   // Check if we already have a message of this type for this entity
@@ -1869,7 +1880,7 @@ void APIConnection::DeferredBatch::add_item(EntityBase *entity, uint8_t message_
     }
   }
   // No existing item found (or event), add new one
-  this->push_item({entity, message_type, estimated_size, aux_data_index});
+  items.push_back({entity, message_type, estimated_size, aux_data_index});
 }
 
 void APIConnection::DeferredBatch::add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
@@ -1877,7 +1888,7 @@ void APIConnection::DeferredBatch::add_item_front(EntityBase *entity, uint8_t me
   // This avoids expensive vector::insert which shifts all elements
   // Note: We only ever have one high-priority message at a time (ping OR disconnect)
   // If we're disconnecting, pings are blocked, so this simple swap is sufficient
-  this->push_item({entity, message_type, estimated_size, AUX_DATA_UNUSED});
+  items.push_back({entity, message_type, estimated_size, AUX_DATA_UNUSED});
   if (items.size() > 1) {
     // Swap the new high-priority item to the front
     std::swap(items.front(), items.back());

esphome/components/api/api_connection.h

@@ -541,8 +541,6 @@ class APIConnection final : public APIServerConnectionBase {
                   uint8_t aux_data_index = AUX_DATA_UNUSED);
     // Add item to the front of the batch (for high priority messages like ping)
     void add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size);
-    // Single push_back site to avoid duplicate _M_realloc_insert instantiation
-    void push_item(const BatchItem &item);
 
     // Clear all items
     void clear() {

esphome/components/api/api_frame_helper_noise.cpp

@@ -138,12 +138,10 @@ APIError APINoiseFrameHelper::handle_noise_error_(int err, const LogString *func
 
 /// Run through handshake messages (if in that phase)
 APIError APINoiseFrameHelper::loop() {
-  // Cache ready() outside the loop. On ESP8266 LWIP raw TCP, ready() returns false once
-  // the rx buffer is consumed. Re-checking each iteration would block handshake writes
-  // that must follow reads, deadlocking the handshake. state_action() will return
-  // WOULD_BLOCK when no more data is available to read.
-  bool socket_ready = this->socket_->ready();
-  while (state_ != State::DATA && socket_ready) {
+  // During handshake phase, process as many actions as possible until we can't progress
+  // socket_->ready() stays true until next main loop, but state_action() will return
+  // WOULD_BLOCK when no more data is available to read
+  while (state_ != State::DATA && this->socket_->ready()) {
     APIError err = state_action_();
     if (err == APIError::WOULD_BLOCK) {
       break;
@@ -201,10 +199,9 @@ APIError APINoiseFrameHelper::try_read_frame_() {
     return (state_ == State::DATA) ? APIError::BAD_DATA_PACKET : APIError::BAD_HANDSHAKE_PACKET_LEN;
   }
 
-  // Reserve space for body (+1 for null terminator so protobuf StringRef fields
-  // can be safely null-terminated in-place after decode)
-  if (this->rx_buf_.size() != msg_size + 1) {
-    this->rx_buf_.resize(msg_size + 1);
+  // Reserve space for body
+  if (this->rx_buf_.size() != msg_size) {
+    this->rx_buf_.resize(msg_size);
   }
 
   if (rx_buf_len_ < msg_size) {

esphome/components/api/api_frame_helper_plaintext.cpp

@@ -163,10 +163,9 @@ APIError APIPlaintextFrameHelper::try_read_frame_() {
   }
   // header reading done
 
-  // Reserve space for body (+1 for null terminator so protobuf StringRef fields
-  // can be safely null-terminated in-place after decode)
-  if (this->rx_buf_.size() != this->rx_header_parsed_len_ + 1) {
-    this->rx_buf_.resize(this->rx_header_parsed_len_ + 1);
+  // Reserve space for body
+  if (this->rx_buf_.size() != this->rx_header_parsed_len_) {
+    this->rx_buf_.resize(this->rx_header_parsed_len_);
   }
 
   if (rx_buf_len_ < rx_header_parsed_len_) {

esphome/components/api/api_options.proto

@@ -90,13 +90,4 @@ extend google.protobuf.FieldOptions {
     //   - uint16_t <field>_length_{0};
     //   - uint16_t <field>_count_{0};
     optional bool packed_buffer = 50015 [default=false];
-
-    // null_terminate: Write a null byte after string data in the decode buffer.
-    // When set on a string field in a SOURCE_CLIENT (decodable) message, the
-    // generated decode() override writes '\0' at data[length] after decoding.
-    // This makes the StringRef safe for c_str() usage without copying.
-    // Safe because: (1) frame helpers reserve +1 byte in rx_buf_, and
-    // (2) the overwritten byte was already consumed during decode.
-    // Only mark fields that actually need null-terminated access.
-    optional bool null_terminate = 50016 [default=false];
 }

esphome/components/api/api_pb2.cpp

@@ -953,12 +953,6 @@ bool HomeAssistantStateResponse::decode_length(uint32_t field_id, ProtoLengthDel
   }
   return true;
 }
-void HomeAssistantStateResponse::decode(const uint8_t *buffer, size_t length) {
-  ProtoDecodableMessage::decode(buffer, length);
-  if (!this->state.empty()) {
-    const_cast<char *>(this->state.c_str())[this->state.size()] = '\0';
-  }
-}
 #endif
 bool GetTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelimited value) {
   switch (field_id) {
@@ -1063,9 +1057,6 @@ void ExecuteServiceArgument::decode(const uint8_t *buffer, size_t length) {
   uint32_t count_string_array = ProtoDecodableMessage::count_repeated_field(buffer, length, 9);
   this->string_array.init(count_string_array);
   ProtoDecodableMessage::decode(buffer, length);
-  if (!this->string_.empty()) {
-    const_cast<char *>(this->string_.c_str())[this->string_.size()] = '\0';
-  }
 }
 bool ExecuteServiceRequest::decode_varint(uint32_t field_id, ProtoVarInt value) {
   switch (field_id) {

esphome/components/api/api_pb2.h

@@ -1095,7 +1095,6 @@ class HomeAssistantStateResponse final : public ProtoDecodableMessage {
   StringRef entity_id{};
   StringRef state{};
   StringRef attribute{};
-  void decode(const uint8_t *buffer, size_t length) override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   const char *dump_to(DumpBuffer &out) const override;
 #endif

esphome/components/api/api_server.cpp

@@ -148,16 +148,12 @@ void APIServer::loop() {
   while (client_index < this->clients_.size()) {
     auto &client = this->clients_[client_index];
 
-    // Common case: process active client
-    if (!client->flags_.remove) {
-      client->loop();
-    }
-    // Handle disconnection promptly - close socket to free LWIP PCB
-    // resources and prevent retransmit crashes on ESP8266.
     if (client->flags_.remove) {
       // Rare case: handle disconnection (don't increment - swapped element needs processing)
       this->remove_client_(client_index);
     } else {
+      // Common case: process active client
+      client->loop();
       client_index++;
     }
   }
@@ -199,7 +195,7 @@ void APIServer::remove_client_(size_t client_index) {
 #endif
 }
 
-void __attribute__((flatten)) APIServer::accept_new_connections_() {
+void APIServer::accept_new_connections_() {
   while (true) {
     struct sockaddr_storage source_addr;
     socklen_t addr_len = sizeof(source_addr);

esphome/components/api/user_services.cpp

@@ -1,6 +1,5 @@
 #include "user_services.h"
 #include "esphome/core/log.h"
-#include "esphome/core/string_ref.h"
 
 namespace esphome::api {
 
@@ -12,8 +11,6 @@ template<> int32_t get_execute_arg_value<int32_t>(const ExecuteServiceArgument &
 }
 template<> float get_execute_arg_value<float>(const ExecuteServiceArgument &arg) { return arg.float_; }
 template<> std::string get_execute_arg_value<std::string>(const ExecuteServiceArgument &arg) { return arg.string_; }
-// Zero-copy StringRef version for YAML-generated services (string_ is null-terminated after decode)
-template<> StringRef get_execute_arg_value<StringRef>(const ExecuteServiceArgument &arg) { return arg.string_; }
 
 // Legacy std::vector versions for external components using custom_api_device.h - optimized with reserve
 template<> std::vector<bool> get_execute_arg_value<std::vector<bool>>(const ExecuteServiceArgument &arg) {
@@ -64,8 +61,6 @@ template<> enums::ServiceArgType to_service_arg_type<bool>() { return enums::SER
 template<> enums::ServiceArgType to_service_arg_type<int32_t>() { return enums::SERVICE_ARG_TYPE_INT; }
 template<> enums::ServiceArgType to_service_arg_type<float>() { return enums::SERVICE_ARG_TYPE_FLOAT; }
 template<> enums::ServiceArgType to_service_arg_type<std::string>() { return enums::SERVICE_ARG_TYPE_STRING; }
-// Zero-copy StringRef version for YAML-generated services
-template<> enums::ServiceArgType to_service_arg_type<StringRef>() { return enums::SERVICE_ARG_TYPE_STRING; }
 
 // Legacy std::vector versions for external components using custom_api_device.h
 template<> enums::ServiceArgType to_service_arg_type<std::vector<bool>>() { return enums::SERVICE_ARG_TYPE_BOOL_ARRAY; }

esphome/components/script/__init__.py

@@ -219,7 +219,6 @@ async def script_stop_action_to_code(config, action_id, template_arg, args):
     "script.wait",
     ScriptWaitAction,
     maybe_simple_id({cv.Required(CONF_ID): cv.use_id(Script)}),
-    deferred=True,
 )
 async def script_wait_action_to_code(config, action_id, template_arg, args):
     full_id, paren = await cg.get_variable_with_full_id(config[CONF_ID])

esphome/components/web_server/web_server.cpp

@@ -198,8 +198,7 @@ EntityMatchResult UrlMatch::match_entity(EntityBase *entity) const {
 
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
 // helper for allowing only unique entries in the queue
-void __attribute__((flatten))
-DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_generator_t *message_generator) {
+void DeferredUpdateEventSource::deq_push_back_with_dedup_(void *source, message_generator_t *message_generator) {
   DeferredEvent item(source, message_generator);
 
   // Use range-based for loop instead of std::find_if to reduce template instantiation overhead and binary size

esphome/components/wifi/wifi_component.cpp

@@ -3,6 +3,7 @@
 #include <cassert>
 #include <cinttypes>
 #include <cmath>
+#include <type_traits>
 
 #ifdef USE_ESP32
 #if (ESP_IDF_VERSION_MAJOR >= 5 && ESP_IDF_VERSION_MINOR >= 1)
@@ -487,19 +488,6 @@ bool WiFiComponent::matches_configured_network_(const char *ssid, const uint8_t
   return false;
 }
 
-void __attribute__((flatten)) WiFiComponent::set_sta_priority(bssid_t bssid, int8_t priority) {
-  for (auto &it : this->sta_priorities_) {
-    if (it.bssid == bssid) {
-      it.priority = priority;
-      return;
-    }
-  }
-  this->sta_priorities_.push_back(WiFiSTAPriority{
-      .bssid = bssid,
-      .priority = priority,
-  });
-}
-
 void WiFiComponent::log_discarded_scan_result_(const char *ssid, const uint8_t *bssid, int8_t rssi, uint8_t channel) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   // Skip logging during roaming scans to avoid log buffer overflow
@@ -1332,20 +1320,61 @@ void WiFiComponent::start_scanning() {
 // Using insertion sort instead of std::stable_sort saves flash memory
 // by avoiding template instantiations (std::rotate, std::stable_sort, lambdas)
 // IMPORTANT: This sort is stable (preserves relative order of equal elements)
+//
+// Uses raw memcpy instead of copy assignment to avoid CompactString's
+// destructor/constructor overhead (heap delete[]/new[] for long SSIDs).
+// Copy assignment calls ~CompactString() then placement-new for every shift,
+// which means delete[]/new[] per shift for heap-allocated SSIDs. With 70+
+// networks (e.g., captive portal showing full scan results), this caused
+// event loop blocking from hundreds of heap operations in a tight loop.
+//
+// This is safe because we're permuting elements within the same array —
+// each slot is overwritten exactly once, so no ownership duplication occurs.
+// All members of WiFiScanResult are either trivially copyable (bssid, channel,
+// rssi, priority, flags) or CompactString, which stores either inline data or
+// a heap pointer — never a self-referential pointer (unlike std::string's SSO
+// on some implementations). This was not possible before PR#13472 replaced
+// std::string with CompactString, since std::string's internal layout is
+// implementation-defined and may use self-referential pointers.
+//
+// TODO: If C++ standardizes std::trivially_relocatable, add the assertion for
+// WiFiScanResult/CompactString here to formally express the memcpy safety guarantee.
 template<typename VectorType> static void insertion_sort_scan_results(VectorType &results) {
+  // memcpy-based sort requires no self-referential pointers or virtual dispatch.
+  // These static_asserts guard the assumptions. If any fire, the memcpy sort
+  // must be reviewed for safety before updating the expected values.
+  //
+  // No vtable pointers (memcpy would corrupt vptr)
+  static_assert(!std::is_polymorphic<WiFiScanResult>::value, "WiFiScanResult must not have vtable");
+  static_assert(!std::is_polymorphic<CompactString>::value, "CompactString must not have vtable");
+  // Standard layout ensures predictable memory layout with no virtual bases
+  // and no mixed-access-specifier reordering
+  static_assert(std::is_standard_layout<WiFiScanResult>::value, "WiFiScanResult must be standard layout");
+  static_assert(std::is_standard_layout<CompactString>::value, "CompactString must be standard layout");
+  // Size checks catch added/removed fields that may need safety review
+  static_assert(sizeof(WiFiScanResult) == 32, "WiFiScanResult size changed - verify memcpy sort is still safe");
+  static_assert(sizeof(CompactString) == 20, "CompactString size changed - verify memcpy sort is still safe");
+  // Alignment must match for reinterpret_cast of key_buf to be valid
+  static_assert(alignof(WiFiScanResult) <= alignof(std::max_align_t), "WiFiScanResult alignment exceeds max_align_t");
   const size_t size = results.size();
+  constexpr size_t elem_size = sizeof(WiFiScanResult);
+  // Suppress warnings for intentional memcpy on non-trivially-copyable type.
+  // Safety is guaranteed by the static_asserts above and the permutation invariant.
+  // NOLINTNEXTLINE(bugprone-undefined-memory-manipulation)
+  auto *memcpy_fn = &memcpy;
   for (size_t i = 1; i < size; i++) {
-    // Make a copy to avoid issues with move semantics during comparison
-    WiFiScanResult key = results[i];
+    alignas(WiFiScanResult) uint8_t key_buf[elem_size];
+    memcpy_fn(key_buf, &results[i], elem_size);
+    const auto &key = *reinterpret_cast<const WiFiScanResult *>(key_buf);
     int32_t j = i - 1;
 
     // Move elements that are worse than key to the right
     // For stability, we only move if key is strictly better than results[j]
     while (j >= 0 && wifi_scan_result_is_better(key, results[j])) {
-      results[j + 1] = results[j];
+      memcpy_fn(&results[j + 1], &results[j], elem_size);
       j--;
     }
-    results[j + 1] = key;
+    memcpy_fn(&results[j + 1], key_buf, elem_size);
   }
 }
 

esphome/components/wifi/wifi_component.h

@@ -10,6 +10,7 @@
 
 #include <span>
 #include <string>
+#include <type_traits>
 #include <vector>
 
 #ifdef USE_LIBRETINY
@@ -219,6 +220,14 @@ class CompactString {
 };
 
 static_assert(sizeof(CompactString) == 20, "CompactString must be exactly 20 bytes");
+// CompactString is not trivially copyable (non-trivial destructor/copy for heap case).
+// However, its layout has no self-referential pointers: storage_[] contains either inline
+// data or an external heap pointer — never a pointer to itself. This is unlike libstdc++
+// std::string SSO where _M_p points to _M_local_buf within the same object.
+// This property allows memcpy-based permutation sorting where each element ends up in
+// exactly one slot (no ownership duplication). These asserts document that layout property.
+static_assert(std::is_standard_layout<CompactString>::value, "CompactString must be standard layout");
+static_assert(!std::is_polymorphic<CompactString>::value, "CompactString must not have vtable");
 
 class WiFiAP {
   friend class WiFiComponent;
@@ -488,7 +497,18 @@ class WiFiComponent : public Component {
     }
     return 0;
   }
-  void set_sta_priority(bssid_t bssid, int8_t priority);
+  void set_sta_priority(const bssid_t bssid, int8_t priority) {
+    for (auto &it : this->sta_priorities_) {
+      if (it.bssid == bssid) {
+        it.priority = priority;
+        return;
+      }
+    }
+    this->sta_priorities_.push_back(WiFiSTAPriority{
+        .bssid = bssid,
+        .priority = priority,
+    });
+  }
 
   network::IPAddresses wifi_sta_ip_addresses();
   // Remove before 2026.9.0

esphome/core/string_ref.h

@@ -81,19 +81,6 @@ class StringRef {
 
   operator std::string() const { return str(); }
 
-  /// Compare with a null-terminated C string (compatible with std::string::compare)
-  int compare(const char *s) const {
-    size_t s_len = std::strlen(s);
-    int result = std::memcmp(base_, s, std::min(len_, s_len));
-    if (result != 0)
-      return result;
-    if (len_ < s_len)
-      return -1;
-    if (len_ > s_len)
-      return 1;
-    return 0;
-  }
-
   /// Find first occurrence of substring, returns std::string::npos if not found.
   /// Note: Requires the underlying string to be null-terminated.
   size_type find(const char *s, size_type pos = 0) const {

esphome/util.py

@@ -24,14 +24,11 @@ class RegistryEntry:
         fun: Callable[..., Any],
         type_id: "MockObjClass",
         schema: "Schema",
-        *,
-        deferred: bool = False,
     ):
         self.name = name
         self.fun = fun
         self.type_id = type_id
         self.raw_schema = schema
-        self.deferred = deferred
 
     @property
     def coroutine_fun(self):
@@ -52,16 +49,9 @@ class Registry(dict[str, RegistryEntry]):
         self.base_schema = base_schema or {}
         self.type_id_key = type_id_key
 
-    def register(
-        self,
-        name: str,
-        type_id: "MockObjClass",
-        schema: "Schema",
-        *,
-        deferred: bool = False,
-    ):
+    def register(self, name: str, type_id: "MockObjClass", schema: "Schema"):
         def decorator(fun: Callable[..., Any]):
-            self[name] = RegistryEntry(name, fun, type_id, schema, deferred=deferred)
+            self[name] = RegistryEntry(name, fun, type_id, schema)
             return fun
 
         return decorator

script/api_protobuf/api_protobuf.py

@@ -2020,8 +2020,6 @@ def build_message_type(
 
     # Collect fixed_vector fields for custom decode generation
     fixed_vector_fields = []
-    # Collect fields with (null_terminate) = true option
-    null_terminate_fields = []
 
     for field in desc.field:
         # Skip deprecated fields completely
@@ -2064,10 +2062,6 @@ def build_message_type(
 
         ti = create_field_type_info(field, needs_decode, needs_encode)
 
-        # Collect fields with (null_terminate) = true for post-decode null-termination
-        if needs_decode and get_field_opt(field, pb.null_terminate, False):
-            null_terminate_fields.append(ti.field_name)
-
         # Skip field declarations for fields that are in the base class
         # but include their encode/decode logic
         if field.name not in common_field_names:
@@ -2174,8 +2168,8 @@ def build_message_type(
         prot = "bool decode_64bit(uint32_t field_id, Proto64Bit value) override;"
         protected_content.insert(0, prot)
 
-    # Generate custom decode() override for messages with FixedVector or null_terminate fields
-    if fixed_vector_fields or null_terminate_fields:
+    # Generate custom decode() override for messages with FixedVector fields
+    if fixed_vector_fields:
         # Generate the decode() implementation in cpp
         o = f"void {desc.name}::decode(const uint8_t *buffer, size_t length) {{\n"
         # Count and init each FixedVector field
@@ -2184,13 +2178,6 @@ def build_message_type(
             o += f"  this->{field_name}.init(count_{field_name});\n"
         # Call parent decode to populate the fields
         o += "  ProtoDecodableMessage::decode(buffer, length);\n"
-        # Null-terminate fields marked with (null_terminate) = true in-place.
-        # Safe: decode is complete, byte after string was already parsed (next field tag)
-        # or is the +1 reserved byte at end of rx_buf_.
-        for field_name in null_terminate_fields:
-            o += f"  if (!this->{field_name}.empty()) {{\n"
-            o += f"    const_cast<char *>(this->{field_name}.c_str())[this->{field_name}.size()] = '\\0';\n"
-            o += "  }\n"
         o += "}\n"
         cpp += o
         # Generate the decode() declaration in header (public method)

tests/integration/test_alarm_control_panel_state_transitions.py

@@ -270,14 +270,6 @@ async def test_alarm_control_panel_state_transitions(
         # The chime_sensor has chime: true, so opening it while disarmed
         # should trigger on_chime callback
 
-        # Set up future for the on_ready from opening the chime sensor
-        # (alarm becomes "not ready" when chime sensor opens).
-        # We must wait for this BEFORE creating the close future, otherwise
-        # the open event's log can arrive late and resolve the close future,
-        # causing the test to proceed before the chime close is processed.
-        ready_after_chime_open: asyncio.Future[bool] = loop.create_future()
-        ready_futures.append(ready_after_chime_open)
-
         # We're currently DISARMED - open the chime sensor
         client.switch_command(chime_switch_info.key, True)
 
@@ -287,18 +279,11 @@ async def test_alarm_control_panel_state_transitions(
         except TimeoutError:
             pytest.fail(f"on_chime callback not fired. Log lines: {log_lines[-20:]}")
 
-        # Wait for the on_ready from the chime sensor opening
-        try:
-            await asyncio.wait_for(ready_after_chime_open, timeout=2.0)
-        except TimeoutError:
-            pytest.fail(
-                f"on_ready callback not fired when chime sensor opened. "
-                f"Log lines: {log_lines[-20:]}"
-            )
-
-        # Now create the future for the close event and close the sensor.
-        # Since we waited for the open event above, the close event's
-        # on_ready log cannot be confused with the open event's.
+        # Close the chime sensor and wait for alarm to become ready again
+        # We need to wait for this transition before testing door sensor,
+        # otherwise there's a race where the door sensor state change could
+        # arrive before the chime sensor state change, leaving the alarm in
+        # a continuous "not ready" state with no on_ready callback fired.
         ready_after_chime_close: asyncio.Future[bool] = loop.create_future()
         ready_futures.append(ready_after_chime_close)