esphome 2025.6.2__py3-none-any.whl → 2025.7.0__py3-none-any.whl

esphome/components/api/api_frame_helper.cpp

@@ -5,7 +5,6 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "proto.h"
-#include "api_pb2_size.h"
 #include <cstring>
 #include <cinttypes>
 
@@ -66,6 +65,17 @@ const char *api_error_to_str(APIError err) {
   return "UNKNOWN";
 }
 
+// Default implementation for loop - handles sending buffered data
+APIError APIFrameHelper::loop() {
+  if (!this->tx_buf_.empty()) {
+    APIError err = try_send_tx_buf_();
+    if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
+      return err;
+    }
+  }
+  return APIError::OK;  // Convert WOULD_BLOCK to OK to avoid connection termination
+}
+
 // Helper method to buffer data from IOVs
 void APIFrameHelper::buffer_data_from_iov_(const struct iovec *iov, int iovcnt, uint16_t total_write_len) {
   SendBuffer buffer;
@@ -214,6 +224,22 @@ APIError APIFrameHelper::init_common_() {
 }
 
 #define HELPER_LOG(msg, ...) ESP_LOGVV(TAG, "%s: " msg, this->info_.c_str(), ##__VA_ARGS__)
+
+APIError APIFrameHelper::handle_socket_read_result_(ssize_t received) {
+  if (received == -1) {
+    if (errno == EWOULDBLOCK || errno == EAGAIN) {
+      return APIError::WOULD_BLOCK;
+    }
+    state_ = State::FAILED;
+    HELPER_LOG("Socket read failed with errno %d", errno);
+    return APIError::SOCKET_READ_FAILED;
+  } else if (received == 0) {
+    state_ = State::FAILED;
+    HELPER_LOG("Connection closed");
+    return APIError::CONNECTION_CLOSED;
+  }
+  return APIError::OK;
+}
 // uncomment to log raw packets
 //#define HELPER_LOG_PACKETS
 
@@ -274,17 +300,21 @@ APIError APINoiseFrameHelper::init() {
 }
 /// Run through handshake messages (if in that phase)
 APIError APINoiseFrameHelper::loop() {
-  APIError err = state_action_();
-  if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
-    return err;
-  }
-  if (!this->tx_buf_.empty()) {
-    err = try_send_tx_buf_();
+  // 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::OK && err != APIError::WOULD_BLOCK) {
       return err;
     }
+    if (err == APIError::WOULD_BLOCK) {
+      break;
+    }
   }
-  return APIError::OK;  // Convert WOULD_BLOCK to OK to avoid connection termination
+
+  // Use base class implementation for buffer sending
+  return APIFrameHelper::loop();
 }
 
 /** Read a packet into the rx_buf_. If successful, stores frame data in the frame parameter
@@ -312,17 +342,9 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // no header information yet
     uint8_t to_read = 3 - rx_header_buf_len_;
     ssize_t received = this->socket_->read(&rx_header_buf_[rx_header_buf_len_], to_read);
-    if (received == -1) {
-      if (errno == EWOULDBLOCK || errno == EAGAIN) {
-        return APIError::WOULD_BLOCK;
-      }
-      state_ = State::FAILED;
-      HELPER_LOG("Socket read failed with errno %d", errno);
-      return APIError::SOCKET_READ_FAILED;
-    } else if (received == 0) {
-      state_ = State::FAILED;
-      HELPER_LOG("Connection closed");
-      return APIError::CONNECTION_CLOSED;
+    APIError err = handle_socket_read_result_(received);
+    if (err != APIError::OK) {
+      return err;
     }
     rx_header_buf_len_ += static_cast<uint8_t>(received);
     if (static_cast<uint8_t>(received) != to_read) {
@@ -330,17 +352,15 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
       return APIError::WOULD_BLOCK;
     }
 
+    if (rx_header_buf_[0] != 0x01) {
+      state_ = State::FAILED;
+      HELPER_LOG("Bad indicator byte %u", rx_header_buf_[0]);
+      return APIError::BAD_INDICATOR;
+    }
     // header reading done
   }
 
   // read body
-  uint8_t indicator = rx_header_buf_[0];
-  if (indicator != 0x01) {
-    state_ = State::FAILED;
-    HELPER_LOG("Bad indicator byte %u", indicator);
-    return APIError::BAD_INDICATOR;
-  }
-
   uint16_t msg_size = (((uint16_t) rx_header_buf_[1]) << 8) | rx_header_buf_[2];
 
   if (state_ != State::DATA && msg_size > 128) {
@@ -359,17 +379,9 @@ APIError APINoiseFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // more data to read
     uint16_t to_read = msg_size - rx_buf_len_;
     ssize_t received = this->socket_->read(&rx_buf_[rx_buf_len_], to_read);
-    if (received == -1) {
-      if (errno == EWOULDBLOCK || errno == EAGAIN) {
-        return APIError::WOULD_BLOCK;
-      }
-      state_ = State::FAILED;
-      HELPER_LOG("Socket read failed with errno %d", errno);
-      return APIError::SOCKET_READ_FAILED;
-    } else if (received == 0) {
-      state_ = State::FAILED;
-      HELPER_LOG("Connection closed");
-      return APIError::CONNECTION_CLOSED;
+    APIError err = handle_socket_read_result_(received);
+    if (err != APIError::OK) {
+      return err;
     }
     rx_buf_len_ += static_cast<uint16_t>(received);
     if (static_cast<uint16_t>(received) != to_read) {
@@ -586,10 +598,6 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
     return APIError::BAD_DATA_PACKET;
   }
 
-  // uint16_t type;
-  // uint16_t data_len;
-  // uint8_t *data;
-  // uint8_t *padding;  zero or more bytes to fill up the rest of the packet
   uint16_t type = (((uint16_t) msg_data[0]) << 8) | msg_data[1];
   uint16_t data_len = (((uint16_t) msg_data[2]) << 8) | msg_data[3];
   if (data_len > msg_size - 4) {
@@ -604,21 +612,15 @@ APIError APINoiseFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   buffer->type = type;
   return APIError::OK;
 }
-APIError APINoiseFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
-  std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
-  uint16_t payload_len = static_cast<uint16_t>(raw_buffer->size() - frame_header_padding_);
-
+APIError APINoiseFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
   // Resize to include MAC space (required for Noise encryption)
-  raw_buffer->resize(raw_buffer->size() + frame_footer_size_);
-
-  // Use write_protobuf_packets with a single packet
-  std::vector<PacketInfo> packets;
-  packets.emplace_back(type, 0, payload_len);
-
-  return write_protobuf_packets(buffer, packets);
+  buffer.get_buffer()->resize(buffer.get_buffer()->size() + frame_footer_size_);
+  PacketInfo packet{type, 0,
+                    static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_ - frame_footer_size_)};
+  return write_protobuf_packets(buffer, std::span<const PacketInfo>(&packet, 1));
 }
 
-APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) {
+APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) {
   APIError aerr = state_action_();
   if (aerr != APIError::OK) {
     return aerr;
@@ -633,18 +635,15 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, co
   }
 
   std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
+  uint8_t *buffer_data = raw_buffer->data();  // Cache buffer pointer
+
   this->reusable_iovs_.clear();
   this->reusable_iovs_.reserve(packets.size());
 
   // We need to encrypt each packet in place
   for (const auto &packet : packets) {
-    uint16_t type = packet.message_type;
-    uint16_t offset = packet.offset;
-    uint16_t payload_len = packet.payload_size;
-    uint16_t msg_len = 4 + payload_len;  // type(2) + data_len(2) + payload
-
     // The buffer already has padding at offset
-    uint8_t *buf_start = raw_buffer->data() + offset;
+    uint8_t *buf_start = buffer_data + packet.offset;
 
     // Write noise header
     buf_start[0] = 0x01;  // indicator
@@ -652,10 +651,10 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, co
 
     // Write message header (to be encrypted)
     const uint8_t msg_offset = 3;
-    buf_start[msg_offset + 0] = (uint8_t) (type >> 8);         // type high byte
-    buf_start[msg_offset + 1] = (uint8_t) type;                // type low byte
-    buf_start[msg_offset + 2] = (uint8_t) (payload_len >> 8);  // data_len high byte
-    buf_start[msg_offset + 3] = (uint8_t) payload_len;         // data_len low byte
+    buf_start[msg_offset] = static_cast<uint8_t>(packet.message_type >> 8);      // type high byte
+    buf_start[msg_offset + 1] = static_cast<uint8_t>(packet.message_type);       // type low byte
+    buf_start[msg_offset + 2] = static_cast<uint8_t>(packet.payload_size >> 8);  // data_len high byte
+    buf_start[msg_offset + 3] = static_cast<uint8_t>(packet.payload_size);       // data_len low byte
     // payload data is already in the buffer starting at offset + 7
 
     // Make sure we have space for MAC
@@ -664,7 +663,8 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, co
     // Encrypt the message in place
     NoiseBuffer mbuf;
     noise_buffer_init(mbuf);
-    noise_buffer_set_inout(mbuf, buf_start + msg_offset, msg_len, msg_len + frame_footer_size_);
+    noise_buffer_set_inout(mbuf, buf_start + msg_offset, 4 + packet.payload_size,
+                           4 + packet.payload_size + frame_footer_size_);
 
     int err = noise_cipherstate_encrypt(send_cipher_, &mbuf);
     if (err != 0) {
@@ -674,14 +674,12 @@ APIError APINoiseFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, co
     }
 
     // Fill in the encrypted size
-    buf_start[1] = (uint8_t) (mbuf.size >> 8);
-    buf_start[2] = (uint8_t) mbuf.size;
+    buf_start[1] = static_cast<uint8_t>(mbuf.size >> 8);
+    buf_start[2] = static_cast<uint8_t>(mbuf.size);
 
     // Add iovec for this encrypted packet
-    struct iovec iov;
-    iov.iov_base = buf_start;
-    iov.iov_len = 3 + mbuf.size;  // indicator + size + encrypted data
-    this->reusable_iovs_.push_back(iov);
+    this->reusable_iovs_.push_back(
+        {buf_start, static_cast<size_t>(3 + mbuf.size)});  // indicator + size + encrypted data
   }
 
   // Send all encrypted packets in one writev call
@@ -822,18 +820,12 @@ APIError APIPlaintextFrameHelper::init() {
   state_ = State::DATA;
   return APIError::OK;
 }
-/// Not used for plaintext
 APIError APIPlaintextFrameHelper::loop() {
   if (state_ != State::DATA) {
     return APIError::BAD_STATE;
   }
-  if (!this->tx_buf_.empty()) {
-    APIError err = try_send_tx_buf_();
-    if (err != APIError::OK && err != APIError::WOULD_BLOCK) {
-      return err;
-    }
-  }
-  return APIError::OK;  // Convert WOULD_BLOCK to OK to avoid connection termination
+  // Use base class implementation for buffer sending
+  return APIFrameHelper::loop();
 }
 
 /** Read a packet into the rx_buf_. If successful, stores frame data in the frame parameter
@@ -862,17 +854,9 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // Try to get to at least 3 bytes total (indicator + 2 varint bytes), then read one byte at a time
     ssize_t received =
         this->socket_->read(&rx_header_buf_[rx_header_buf_pos_], rx_header_buf_pos_ < 3 ? 3 - rx_header_buf_pos_ : 1);
-    if (received == -1) {
-      if (errno == EWOULDBLOCK || errno == EAGAIN) {
-        return APIError::WOULD_BLOCK;
-      }
-      state_ = State::FAILED;
-      HELPER_LOG("Socket read failed with errno %d", errno);
-      return APIError::SOCKET_READ_FAILED;
-    } else if (received == 0) {
-      state_ = State::FAILED;
-      HELPER_LOG("Connection closed");
-      return APIError::CONNECTION_CLOSED;
+    APIError err = handle_socket_read_result_(received);
+    if (err != APIError::OK) {
+      return err;
     }
 
     // If this was the first read, validate the indicator byte
@@ -956,17 +940,9 @@ APIError APIPlaintextFrameHelper::try_read_frame_(ParsedFrame *frame) {
     // more data to read
     uint16_t to_read = rx_header_parsed_len_ - rx_buf_len_;
     ssize_t received = this->socket_->read(&rx_buf_[rx_buf_len_], to_read);
-    if (received == -1) {
-      if (errno == EWOULDBLOCK || errno == EAGAIN) {
-        return APIError::WOULD_BLOCK;
-      }
-      state_ = State::FAILED;
-      HELPER_LOG("Socket read failed with errno %d", errno);
-      return APIError::SOCKET_READ_FAILED;
-    } else if (received == 0) {
-      state_ = State::FAILED;
-      HELPER_LOG("Connection closed");
-      return APIError::CONNECTION_CLOSED;
+    APIError err = handle_socket_read_result_(received);
+    if (err != APIError::OK) {
+      return err;
     }
     rx_buf_len_ += static_cast<uint16_t>(received);
     if (static_cast<uint16_t>(received) != to_read) {
@@ -1025,19 +1001,12 @@ APIError APIPlaintextFrameHelper::read_packet(ReadPacketBuffer *buffer) {
   buffer->type = rx_header_parsed_type_;
   return APIError::OK;
 }
-APIError APIPlaintextFrameHelper::write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) {
-  std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
-  uint16_t payload_len = static_cast<uint16_t>(raw_buffer->size() - frame_header_padding_);
-
-  // Use write_protobuf_packets with a single packet
-  std::vector<PacketInfo> packets;
-  packets.emplace_back(type, 0, payload_len);
-
-  return write_protobuf_packets(buffer, packets);
+APIError APIPlaintextFrameHelper::write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) {
+  PacketInfo packet{type, 0, static_cast<uint16_t>(buffer.get_buffer()->size() - frame_header_padding_)};
+  return write_protobuf_packets(buffer, std::span<const PacketInfo>(&packet, 1));
 }
 
-APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer,
-                                                         const std::vector<PacketInfo> &packets) {
+APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) {
   if (state_ != State::DATA) {
     return APIError::BAD_STATE;
   }
@@ -1047,17 +1016,15 @@ APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer
   }
 
   std::vector<uint8_t> *raw_buffer = buffer.get_buffer();
+  uint8_t *buffer_data = raw_buffer->data();  // Cache buffer pointer
+
   this->reusable_iovs_.clear();
   this->reusable_iovs_.reserve(packets.size());
 
   for (const auto &packet : packets) {
-    uint16_t type = packet.message_type;
-    uint16_t offset = packet.offset;
-    uint16_t payload_len = packet.payload_size;
-
     // Calculate varint sizes for header layout
-    uint8_t size_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(payload_len));
-    uint8_t type_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(type));
+    uint8_t size_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(packet.payload_size));
+    uint8_t type_varint_len = api::ProtoSize::varint(static_cast<uint32_t>(packet.message_type));
     uint8_t total_header_len = 1 + size_varint_len + type_varint_len;
 
     // Calculate where to start writing the header
@@ -1085,23 +1052,20 @@ APIError APIPlaintextFrameHelper::write_protobuf_packets(ProtoWriteBuffer buffer
     //
     // The message starts at offset + frame_header_padding_
     // So we write the header starting at offset + frame_header_padding_ - total_header_len
-    uint8_t *buf_start = raw_buffer->data() + offset;
+    uint8_t *buf_start = buffer_data + packet.offset;
     uint32_t header_offset = frame_header_padding_ - total_header_len;
 
     // Write the plaintext header
     buf_start[header_offset] = 0x00;  // indicator
 
-    // Encode size varint directly into buffer
-    ProtoVarInt(payload_len).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
-
-    // Encode type varint directly into buffer
-    ProtoVarInt(type).encode_to_buffer_unchecked(buf_start + header_offset + 1 + size_varint_len, type_varint_len);
+    // Encode varints directly into buffer
+    ProtoVarInt(packet.payload_size).encode_to_buffer_unchecked(buf_start + header_offset + 1, size_varint_len);
+    ProtoVarInt(packet.message_type)
+        .encode_to_buffer_unchecked(buf_start + header_offset + 1 + size_varint_len, type_varint_len);
 
     // Add iovec for this packet (header + payload)
-    struct iovec iov;
-    iov.iov_base = buf_start + header_offset;
-    iov.iov_len = total_header_len + payload_len;
-    this->reusable_iovs_.push_back(iov);
+    this->reusable_iovs_.push_back(
+        {buf_start + header_offset, static_cast<size_t>(total_header_len + packet.payload_size)});
   }
 
   // Send all packets in one writev call

esphome/components/api/api_frame_helper.h

@@ -2,6 +2,7 @@
 #include <cstdint>
 #include <deque>
 #include <limits>
+#include <span>
 #include <utility>
 #include <vector>
 
@@ -29,16 +30,14 @@ struct ReadPacketBuffer {
 
 // Packed packet info structure to minimize memory usage
 struct PacketInfo {
-  uint16_t message_type;  // 2 bytes
-  uint16_t offset;        // 2 bytes (sufficient for packet size ~1460 bytes)
-  uint16_t payload_size;  // 2 bytes (up to 65535 bytes)
-  uint16_t padding;       // 2 byte (for alignment)
+  uint16_t offset;        // Offset in buffer where message starts
+  uint16_t payload_size;  // Size of the message payload
+  uint8_t message_type;   // Message type (0-255)
 
-  PacketInfo(uint16_t type, uint16_t off, uint16_t size)
-      : message_type(type), offset(off), payload_size(size), padding(0) {}
+  PacketInfo(uint8_t type, uint16_t off, uint16_t size) : offset(off), payload_size(size), message_type(type) {}
 };
 
-enum class APIError : int {
+enum class APIError : uint16_t {
   OK = 0,
   WOULD_BLOCK = 1001,
   BAD_HANDSHAKE_PACKET_LEN = 1002,
@@ -74,7 +73,7 @@ class APIFrameHelper {
   }
   virtual ~APIFrameHelper() = default;
   virtual APIError init() = 0;
-  virtual APIError loop() = 0;
+  virtual APIError loop();
   virtual APIError read_packet(ReadPacketBuffer *buffer) = 0;
   bool can_write_without_blocking() { return state_ == State::DATA && tx_buf_.empty(); }
   std::string getpeername() { return socket_->getpeername(); }
@@ -97,11 +96,11 @@ class APIFrameHelper {
   }
   // Give this helper a name for logging
   void set_log_info(std::string info) { info_ = std::move(info); }
-  virtual APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) = 0;
+  virtual APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) = 0;
   // Write multiple protobuf packets in a single operation
   // packets contains (message_type, offset, length) for each message in the buffer
   // The buffer contains all messages with appropriate padding before each
-  virtual APIError write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) = 0;
+  virtual APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) = 0;
   // Get the frame header padding required by this protocol
   virtual uint8_t frame_header_padding() = 0;
   // Get the frame footer size required by this protocol
@@ -125,8 +124,21 @@ class APIFrameHelper {
     const uint8_t *current_data() const { return data.data() + offset; }
   };
 
-  // Queue of data buffers to be sent
-  std::deque<SendBuffer> tx_buf_;
+  // Common implementation for writing raw data to socket
+  APIError write_raw_(const struct iovec *iov, int iovcnt);
+
+  // Try to send data from the tx buffer
+  APIError try_send_tx_buf_();
+
+  // Helper method to buffer data from IOVs
+  void buffer_data_from_iov_(const struct iovec *iov, int iovcnt, uint16_t total_write_len);
+  template<typename StateEnum>
+  APIError write_raw_(const struct iovec *iov, int iovcnt, socket::Socket *socket, std::vector<uint8_t> &tx_buf,
+                      const std::string &info, StateEnum &state, StateEnum failed_state);
+
+  // Pointers first (4 bytes each)
+  socket::Socket *socket_{nullptr};
+  std::unique_ptr<socket::Socket> socket_owned_;
 
   // Common state enum for all frame helpers
   // Note: Not all states are used by all implementations
@@ -136,7 +148,7 @@ class APIFrameHelper {
   // - CLOSED: Used by both Noise and Plaintext
   // - FAILED: Used by both Noise and Plaintext
   // - EXPLICIT_REJECT: Only used by Noise protocol
-  enum class State {
+  enum class State : uint8_t {
     INITIALIZE = 1,
     CLIENT_HELLO = 2,  // Noise only
     SERVER_HELLO = 3,  // Noise only
@@ -147,40 +159,24 @@ class APIFrameHelper {
     EXPLICIT_REJECT = 8,  // Noise only
   };
 
-  // Current state of the frame helper
-  State state_{State::INITIALIZE};
-
-  // Helper name for logging
+  // Containers (size varies, but typically 12+ bytes on 32-bit)
+  std::deque<SendBuffer> tx_buf_;
   std::string info_;
-
-  // Socket for communication
-  socket::Socket *socket_{nullptr};
-  std::unique_ptr<socket::Socket> socket_owned_;
-
-  // Common implementation for writing raw data to socket
-  APIError write_raw_(const struct iovec *iov, int iovcnt);
-
-  // Try to send data from the tx buffer
-  APIError try_send_tx_buf_();
-
-  // Helper method to buffer data from IOVs
-  void buffer_data_from_iov_(const struct iovec *iov, int iovcnt, uint16_t total_write_len);
-  template<typename StateEnum>
-  APIError write_raw_(const struct iovec *iov, int iovcnt, socket::Socket *socket, std::vector<uint8_t> &tx_buf,
-                      const std::string &info, StateEnum &state, StateEnum failed_state);
-
-  uint8_t frame_header_padding_{0};
-  uint8_t frame_footer_size_{0};
-
-  // Reusable IOV array for write_protobuf_packets to avoid repeated allocations
   std::vector<struct iovec> reusable_iovs_;
-
-  // Receive buffer for reading frame data
   std::vector<uint8_t> rx_buf_;
+
+  // Group smaller types together
   uint16_t rx_buf_len_ = 0;
+  State state_{State::INITIALIZE};
+  uint8_t frame_header_padding_{0};
+  uint8_t frame_footer_size_{0};
+  // 5 bytes total, 3 bytes padding
 
   // Common initialization for both plaintext and noise protocols
   APIError init_common_();
+
+  // Helper method to handle socket read results
+  APIError handle_socket_read_result_(ssize_t received);
 };
 
 #ifdef USE_API_NOISE
@@ -199,8 +195,8 @@ class APINoiseFrameHelper : public APIFrameHelper {
   APIError init() override;
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
-  APIError write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) override;
+  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
   // Get the frame header padding required by this protocol
   uint8_t frame_header_padding() override { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
@@ -213,19 +209,28 @@ class APINoiseFrameHelper : public APIFrameHelper {
   APIError init_handshake_();
   APIError check_handshake_finished_();
   void send_explicit_handshake_reject_(const std::string &reason);
-  // Fixed-size header buffer for noise protocol:
-  // 1 byte for indicator + 2 bytes for message size (16-bit value, not varint)
-  // Note: Maximum message size is UINT16_MAX (65535), with a limit of 128 bytes during handshake phase
-  uint8_t rx_header_buf_[3];
-  uint8_t rx_header_buf_len_ = 0;
-
-  std::vector<uint8_t> prologue_;
 
-  std::shared_ptr<APINoiseContext> ctx_;
+  // Pointers first (4 bytes each)
   NoiseHandshakeState *handshake_{nullptr};
   NoiseCipherState *send_cipher_{nullptr};
   NoiseCipherState *recv_cipher_{nullptr};
+
+  // Shared pointer (8 bytes on 32-bit = 4 bytes control block pointer + 4 bytes object pointer)
+  std::shared_ptr<APINoiseContext> ctx_;
+
+  // Vector (12 bytes on 32-bit)
+  std::vector<uint8_t> prologue_;
+
+  // NoiseProtocolId (size depends on implementation)
   NoiseProtocolId nid_;
+
+  // Group small types together
+  // Fixed-size header buffer for noise protocol:
+  // 1 byte for indicator + 2 bytes for message size (16-bit value, not varint)
+  // Note: Maximum message size is UINT16_MAX (65535), with a limit of 128 bytes during handshake phase
+  uint8_t rx_header_buf_[3];
+  uint8_t rx_header_buf_len_ = 0;
+  // 4 bytes total, no padding
 };
 #endif  // USE_API_NOISE
 
@@ -244,14 +249,20 @@ class APIPlaintextFrameHelper : public APIFrameHelper {
   APIError init() override;
   APIError loop() override;
   APIError read_packet(ReadPacketBuffer *buffer) override;
-  APIError write_protobuf_packet(uint16_t type, ProtoWriteBuffer buffer) override;
-  APIError write_protobuf_packets(ProtoWriteBuffer buffer, const std::vector<PacketInfo> &packets) override;
+  APIError write_protobuf_packet(uint8_t type, ProtoWriteBuffer buffer) override;
+  APIError write_protobuf_packets(ProtoWriteBuffer buffer, std::span<const PacketInfo> packets) override;
   uint8_t frame_header_padding() override { return frame_header_padding_; }
   // Get the frame footer size required by this protocol
   uint8_t frame_footer_size() override { return frame_footer_size_; }
 
  protected:
   APIError try_read_frame_(ParsedFrame *frame);
+
+  // Group 2-byte aligned types
+  uint16_t rx_header_parsed_type_ = 0;
+  uint16_t rx_header_parsed_len_ = 0;
+
+  // Group 1-byte types together
   // Fixed-size header buffer for plaintext protocol:
   // We now store the indicator byte + the two varints.
   // To match noise protocol's maximum message size (UINT16_MAX = 65535), we need:
@@ -263,8 +274,7 @@ class APIPlaintextFrameHelper : public APIFrameHelper {
   uint8_t rx_header_buf_[6];  // 1 byte indicator + 5 bytes for varints (3 for size + 2 for type)
   uint8_t rx_header_buf_pos_ = 0;
   bool rx_header_parsed_ = false;
-  uint16_t rx_header_parsed_type_ = 0;
-  uint16_t rx_header_parsed_len_ = 0;
+  // 8 bytes total, no padding needed
 };
 #endif