fix(firehose_demo_lwt): handle WebSocket message fragmentation

The websocket-lwt-unix library delivers individual WebSocket frames,
not complete messages. Large messages can be split across multiple
frames (Binary/Text followed by Continuation frames until final=true).

This fix:
- Adds frag_buf buffer to accumulate fragmented message data
- Tracks message type (Binary/Text) via frag_opcode
- Only returns complete binary messages when final frame received
- Properly handles fragmented text messages (skipped)

Without this fix, partial binary data was passed to the CBOR decoder
causing 'invalid payload CBOR' errors after ~1-2 seconds of operation.

examples/firehose_demo/firehose_demo_lwt.ml

···
             >|= fun conn -> Ok conn)
       (fun exn -> Lwt.return (Error (Printexc.to_string exn)))
 
+  (* Buffer for accumulating fragmented messages *)
+  let frag_buf = Buffer.create 65536
+  let frag_opcode = ref Websocket.Frame.Opcode.Continuation
+
   let recv conn : (string, string) result Lwt.t =
     let open Websocket in
     let rec read_binary () =
···
         (fun () ->
           Websocket_lwt_unix.read conn >>= fun frame ->
           match frame.Frame.opcode with
-          | Frame.Opcode.Binary -> Lwt.return (Ok frame.Frame.content)
-          | Frame.Opcode.Text -> read_binary () (* Skip text frames *)
+          | Frame.Opcode.Binary ->
+              if frame.Frame.final then
+                (* Complete message in single frame *)
+                Lwt.return (Ok frame.Frame.content)
+              else begin
+                (* Start of fragmented binary message *)
+                Buffer.clear frag_buf;
+                Buffer.add_string frag_buf frame.Frame.content;
+                frag_opcode := Frame.Opcode.Binary;
+                read_binary ()
+              end
+          | Frame.Opcode.Continuation ->
+              (* Continuation of fragmented message *)
+              Buffer.add_string frag_buf frame.Frame.content;
+              if frame.Frame.final then begin
+                (* Fragmented message complete *)
+                let data = Buffer.contents frag_buf in
+                Buffer.clear frag_buf;
+                if !frag_opcode = Frame.Opcode.Binary then Lwt.return (Ok data)
+                else
+                  (* Was a text message, skip it *)
+                  read_binary ()
+              end
+              else read_binary ()
+          | Frame.Opcode.Text ->
+              if frame.Frame.final then
+                (* Skip complete text frames *)
+                read_binary ()
+              else begin
+                (* Start of fragmented text message - track but skip *)
+                Buffer.clear frag_buf;
+                Buffer.add_string frag_buf frame.Frame.content;
+                frag_opcode := Frame.Opcode.Text;
+                read_binary ()
+              end
           | Frame.Opcode.Close -> Lwt.return (Error "Connection closed")
           | Frame.Opcode.Ping ->
               (* Respond to ping with pong *)
···
           | Firehose.Ws_recv _ws ->
               Some
                 (fun k ->
-                  if !interrupted then continue k (Error "Interrupted")
-                  else
-                    match !ws_conn with
-                    | None -> continue k (Error "Not connected")
-                    | Some conn ->
-                        let result = Lwt_main.run (Ws.recv conn) in
-                        if !interrupted then continue k (Error "Interrupted")
-                        else continue k result)
+                  match !ws_conn with
+                  | None -> continue k (Error "Not connected")
+                  | Some conn ->
+                      let result = Lwt_main.run (Ws.recv conn) in
+                      continue k result)
           | Firehose.Ws_close _ws ->
               Some
                 (fun k ->
···
       stats.matched <- stats.matched + 1;
       match config.limit with
       | Some max when stats.matched >= max -> false
-      | _ -> not !interrupted
+      | _ -> true (* Always continue - interrupt handled via WebSocket error *)
     end
-    else not !interrupted
+    else true (* Always continue processing *)
   in
   with_websocket_lwt (fun () ->
       if not config.json then Printf.printf "Connected!\n\n%!";
       match Firehose.subscribe cfg ~handler with
-      | Ok () -> ()
-      | Error _ -> () (* Errors on exit are expected - just exit cleanly *))
+      | Ok () ->
+          if not config.json then
+            Printf.printf "Subscribe completed normally\n%!"
+      | Error e ->
+          if not config.json then
+            Printf.printf "Subscribe ended: %s\n%!" (Firehose.error_to_string e))
 
 let () =
   let config =