jetstream: handle partial message reads

src/jetstream.zig

···
         conn: *stda.tls.Client,
     },
 
+    buffer: std.ArrayListUnmanaged(u8) = .empty,
+
     const hosts = [_][]const u8{
         "jetstream1.us-east.bsky.network",
         "jetstream2.us-east.bsky.network",
···
     pub fn deinit(self: *Stream) void {
         self.gpa.free(self.query);
         self.gpa.free(self.challenge);
+        self.buffer.deinit(self.gpa);
         switch (self.state) {
             .dns => {},
             .connect => {},
···
                 const n = try result.recv;
                 const buf = self.state.conn.read_buf[0..n];
                 try self.decodeFrames(io, buf);
-                @panic("here");
             },
 
             .write => {
···
     }
 
     fn decodeFrames(self: *Stream, io: *ourio.Ring, bytes: []const u8) !void {
-        var iter: FrameIterator = .{ .bytes = bytes };
+        try self.buffer.appendSlice(self.gpa, bytes);
+        var iter: FrameIterator = .{ .bytes = self.buffer.items };
         while (try iter.next()) |data| {
             switch (data) {
                 .text => |s| {
···
                 else => return error.UnsupportedOp,
             }
         }
+
+        self.buffer.replaceRangeAssumeCapacity(0, iter.idx, "");
     }
 };
 
···
         if (byte2.mask) return error.MaskNotSupported;
 
         const len: usize, const data_start: usize = switch (byte2.len) {
-            126 => .{ std.mem.readInt(u16, self.bytes[self.idx..][0..2], .big), self.idx + 2 },
-            127 => .{ std.mem.readInt(u64, self.bytes[self.idx..][0..8], .big), self.idx + 8 },
+            126 => blk: {
+                if (self.idx + 2 > self.bytes.len) {
+                    self.idx -= 2;
+                    return null;
+                }
+                break :blk .{
+                    std.mem.readInt(u16, self.bytes[self.idx..][0..2], .big),
+                    self.idx + 2,
+                };
+            },
+            127 => blk: {
+                if (self.idx + 8 > self.bytes.len) {
+                    self.idx -= 2;
+                    return null;
+                }
+                break :blk .{ std.mem.readInt(u64, self.bytes[self.idx..][0..8], .big), self.idx + 8 };
+            },
             else => .{ byte2.len, self.idx },
         };
 
         const end = data_start + len;
+        if (data_start >= self.bytes.len or end > self.bytes.len) {
+            self.idx -|= 2;
+            return null;
+        }
         defer self.idx = end;
 
         switch (byte1.opcode) {

src/root.zig

···
 const std = @import("std");
 const testing = std.testing;
 
+const jetstream = @import("jetstream.zig");
+
+pub const Jetstream = jetstream.Stream;
+
 test {
     _ = @import("jetstream.zig");
 }