@colyseus/sdk 0.17.40 → 0.17.42

package/dist/colyseus.js

@@ -3,7 +3,7 @@
 // This software is released under the MIT License.
 // https://opensource.org/license/MIT
 //
-// colyseus.js@0.17.40 - @colyseus/schema 4.0.13
+// colyseus.js@0.17.42 - @colyseus/schema 4.0.13
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define('@colyseus/sdk', ['exports'], factory) :
@@ -8154,10 +8154,70 @@
     const RESET_BUFFER_MODE = 1024;
     const RESERVE_START_SPACE = 2048;
 
+    // 9 bytes is the maximum length of a variable-length integer prefix
+    const MAX_LENGTH_PREFIX_BYTES = 9;
+    /**
+     * Reassembles length-prefixed frames from arbitrary byte chunks.
+     *
+     * A single WebTransport `reader.read()` may:
+     *   - deliver multiple whole frames in one chunk
+     *   - split a frame (or its length prefix) across multiple chunks
+     *
+     * This reassembler buffers partial data across reads so each dispatched
+     * frame is exactly one complete message.
+     */
+    class FrameReassembler {
+        constructor() {
+            this.pending = new Uint8Array(0);
+        }
+        push(chunk) {
+            if (!chunk || chunk.byteLength === 0) {
+                return [];
+            }
+            const bytes = (this.pending.byteLength === 0)
+                ? chunk
+                : concatBytes(this.pending, chunk);
+            const frames = [];
+            let offset = 0;
+            while (offset < bytes.byteLength) {
+                const it = { offset };
+                let length;
+                try {
+                    length = buildExports.decode.number(bytes, it);
+                }
+                catch (e) {
+                    // length prefix is incomplete — wait for more bytes
+                    if (bytes.byteLength - offset <= MAX_LENGTH_PREFIX_BYTES) {
+                        break;
+                    }
+                    throw e;
+                }
+                const frameEnd = it.offset + length;
+                if (frameEnd > bytes.byteLength) {
+                    // payload is incomplete — wait for more bytes
+                    break;
+                }
+                frames.push(bytes.subarray(it.offset, frameEnd));
+                offset = frameEnd;
+            }
+            this.pending = (offset < bytes.byteLength)
+                ? bytes.slice(offset)
+                : new Uint8Array(0);
+            return frames;
+        }
+    }
+    function concatBytes(a, b) {
+        const out = new Uint8Array(a.byteLength + b.byteLength);
+        out.set(a, 0);
+        out.set(b, a.byteLength);
+        return out;
+    }
     class H3TransportTransport {
         constructor(events) {
             this.isOpen = false;
             this.lengthPrefixBuffer = new Uint8Array(9); // 9 bytes is the maximum length of a length prefix
+            this.reliableReassembler = new FrameReassembler();
+            this.unreliableReassembler = new FrameReassembler();
             this.events = events;
         }
         connect(url, options = {}) {
@@ -8237,17 +8297,11 @@
                         //
                         // a single read may contain multiple messages
                         // each message is prefixed with its length
+                        // a read may also deliver a partial frame; buffer across reads
                         //
-                        const messages = result.value;
-                        const it = { offset: 0 };
-                        do {
-                            //
-                            // QUESTION: should we buffer the message in case it's not fully read?
-                            //
-                            const length = buildExports.decode.number(messages, it);
-                            this.events.onmessage({ data: messages.subarray(it.offset, it.offset + length) });
-                            it.offset += length;
-                        } while (it.offset < messages.length);
+                        for (const frame of this.reliableReassembler.push(result.value)) {
+                            this.events.onmessage({ data: frame });
+                        }
                     }
                     catch (e) {
                         if (e.message.indexOf("session is closed") === -1) {
@@ -8270,17 +8324,11 @@
                         //
                         // a single read may contain multiple messages
                         // each message is prefixed with its length
+                        // a read may also deliver a partial frame; buffer across reads
                         //
-                        const messages = result.value;
-                        const it = { offset: 0 };
-                        do {
-                            //
-                            // QUESTION: should we buffer the message in case it's not fully read?
-                            //
-                            const length = buildExports.decode.number(messages, it);
-                            this.events.onmessage({ data: messages.subarray(it.offset, it.offset + length) });
-                            it.offset += length;
-                        } while (it.offset < messages.length);
+                        for (const frame of this.unreliableReassembler.push(result.value)) {
+                            this.events.onmessage({ data: frame });
+                        }
                     }
                     catch (e) {
                         if (e.message.indexOf("session is closed") === -1) {