From f5a2892be999d2df4cd3e5f46e67163cb611520c Mon Sep 17 00:00:00 2001
From: Preetham Pemmasani <75422607+ppmpreetham@users.noreply.github.com>
Date: Sat, 28 Feb 2026 13:26:50 +0530
Subject: [PATCH 1/2] perf(frame): write buffer handling

avoids zero-filling the vec when resizing and simplifies the write logic.
---
 src/frame.rs | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/frame.rs b/src/frame.rs
index 9f7ec4d..cd37f88 100644
--- a/src/frame.rs
+++ b/src/frame.rs
@@ -334,17 +334,15 @@ impl<'f> Frame<'f> {
 
   /// Writes the frame to the buffer and returns a slice of the buffer containing the frame.
   pub fn write<'a>(&mut self, buf: &'a mut Vec<u8>) -> &'a [u8] {
-    fn reserve_enough(buf: &mut Vec<u8>, len: usize) {
-      if buf.len() < len {
-        buf.resize(len, 0);
-      }
-    }
     let len = self.payload.len();
-    reserve_enough(buf, len + MAX_HEAD_SIZE);
+    buf.clear();
+    buf.reserve(len + MAX_HEAD_SIZE);
 
-    let size = self.fmt_head(buf);
-    buf[size..size + len].copy_from_slice(&self.payload);
-    &buf[..size + len]
+    let mut head = [0u8; MAX_HEAD_SIZE];
+    let size = self.fmt_head(&mut head);
+    buf.extend_from_slice(&head[..size]);
+    buf.extend_from_slice(&self.payload);
+    &buf[..]
   }
 }
 

From 024aa9bff81e73dd19c80161a250c12cba6f655b Mon Sep 17 00:00:00 2001
From: Preetham Pemmasani <75422607+ppmpreetham@users.noreply.github.com>
Date: Sat, 28 Feb 2026 13:30:40 +0530
Subject: [PATCH 2/2] perf(fragment): avoid double copy

reduces allocations
---
 src/fragment.rs | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/fragment.rs b/src/fragment.rs
index b333e5d..892ab05 100644
--- a/src/fragment.rs
+++ b/src/fragment.rs
@@ -225,19 +225,23 @@ impl Fragments {
           return Ok(Some(Frame::new(true, frame.opcode, None, frame.payload)));
         } else {
           self.fragments = match frame.opcode {
-            OpCode::Text => match utf8::decode(&frame.payload) {
-              Ok(text) => Some(Fragment::Text(None, text.as_bytes().to_vec())),
-              Err(utf8::DecodeError::Incomplete {
-                valid_prefix,
-                incomplete_suffix,
-              }) => Some(Fragment::Text(
-                Some(incomplete_suffix),
-                valid_prefix.as_bytes().to_vec(),
-              )),
-              Err(utf8::DecodeError::Invalid { .. }) => {
-                return Err(WebSocketError::InvalidUTF8);
+            OpCode::Text => {
+              let mut buf: Vec<u8> = frame.payload.into();
+              match utf8::decode(&buf) {
+                Ok(_) => Some(Fragment::Text(None, buf)),
+                Err(utf8::DecodeError::Incomplete {
+                  valid_prefix,
+                  incomplete_suffix,
+                }) => {
+                  let valid_len = valid_prefix.len();
+                  buf.truncate(valid_len);
+                  Some(Fragment::Text(Some(incomplete_suffix), buf))
+                }
+                Err(utf8::DecodeError::Invalid { .. }) => {
+                  return Err(WebSocketError::InvalidUTF8);
+                }
               }
-            },
+            }
             OpCode::Binary => Some(Fragment::Binary(frame.payload.into())),
             _ => unreachable!(),
           };