@colyseus/sdk 0.17.41 → 0.17.42

package/dist/debug.js

@@ -3,7 +3,7 @@
 // This software is released under the MIT License.
 // https://opensource.org/license/MIT
 //
-// colyseus.js@0.17.41
+// colyseus.js@0.17.42
 (function (Client_ts, sharedTypes) {
   'use strict';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/sdk",
-  "version": "0.17.41",
+  "version": "0.17.42",
   "description": "Colyseus Multiplayer SDK for JavaScript/TypeScript",
   "author": "Endel Dreyer",
   "license": "MIT",
@@ -82,7 +82,7 @@
     "typescript": "^5.9.3",
     "vite": "^5.0.11",
     "vitest": "^2.1.1",
-    "@colyseus/core": "^0.17.41"
+    "@colyseus/core": "^0.17.42"
   },
   "peerDependencies": {
     "@colyseus/core": "0.17.x"

package/src/transport/H3Transport.ts

@@ -1,6 +1,69 @@
 import { encode, decode, type Iterator } from '@colyseus/schema';
 import type { ITransport, ITransportEventMap } from "./ITransport.ts";
 
+// 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.
+ */
+export class FrameReassembler {
+    private pending: Uint8Array = new Uint8Array(0);
+
+    push(chunk: Uint8Array | undefined): Uint8Array[] {
+        if (!chunk || chunk.byteLength === 0) { return []; }
+
+        const bytes = (this.pending.byteLength === 0)
+            ? chunk
+            : concatBytes(this.pending, chunk);
+
+        const frames: Uint8Array[] = [];
+        let offset = 0;
+
+        while (offset < bytes.byteLength) {
+            const it: Iterator = { offset };
+            let length: number;
+
+            try {
+                length = decode.number(bytes as any, 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: Uint8Array, b: Uint8Array): Uint8Array {
+    const out = new Uint8Array(a.byteLength + b.byteLength);
+    out.set(a, 0);
+    out.set(b, a.byteLength);
+    return out;
+}
+
 export class H3TransportTransport implements ITransport {
     wt: WebTransport;
     isOpen: boolean = false;
@@ -14,6 +77,9 @@ export class H3TransportTransport implements ITransport {
 
     private lengthPrefixBuffer = new Uint8Array(9); // 9 bytes is the maximum length of a length prefix
 
+    private reliableReassembler = new FrameReassembler();
+    private unreliableReassembler = new FrameReassembler();
+
     constructor(events: ITransportEventMap) {
         this.events = events;
     }
@@ -110,19 +176,11 @@ export class H3TransportTransport implements ITransport {
                 //
                 // 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: Iterator = { offset: 0 };
-                do {
-                    //
-                    // QUESTION: should we buffer the message in case it's not fully read?
-                    //
-
-                    const length = decode.number(messages as any, 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) {
@@ -147,19 +205,11 @@ export class H3TransportTransport implements ITransport {
                 //
                 // 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: Iterator = { offset: 0 };
-                do {
-                    //
-                    // QUESTION: should we buffer the message in case it's not fully read?
-                    //
-
-                    const length = decode.number(messages as any, 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) {