@colyseus/sdk 0.17.42 → 0.18.0

package/src/input/InputHandle.ts

@@ -0,0 +1,115 @@
+import { InputEncoder, type InputEncoderOptions, type InputMode } from '@colyseus/schema/input';
+import { Protocol } from '@colyseus/shared-types';
+
+import type { Connection } from '../Connection.ts';
+
+/**
+ * Minimal structural type the input handle needs from its host (Room). Lets
+ * us decouple from the full `Room` class so this module stays import-cycle
+ * free, while still picking up the latest `connection` after a reconnect.
+ *
+ * @internal
+ */
+export interface InputHandleHost {
+  connection?: Connection;
+}
+
+/**
+ * Options accepted by `Room.input()`. Extends {@link InputEncoderOptions}
+ * (mode / historySize / delta / buffer) with a `type` field for the schema
+ * constructor.
+ *
+ * Recommended for rollback netcode: `{ mode: "unreliable", delta: true,
+ * historySize: 4 }` — small redundant deltas, idempotent across drops via
+ * absolute-value wire ops.
+ *
+ * `I` is intentionally unconstrained: pinning it to `Schema` from this
+ * SDK's copy of `@colyseus/schema` would reject user-side schemas coming
+ * from a different copy of the package (npm hoisting, multi-version
+ * installs). Runtime calls duck-type via the encoder, so a structural
+ * match is enough.
+ */
+export interface ClientInputOptions<I = any> extends InputEncoderOptions {
+  /**
+   * Schema constructor for the input. Required when server-sent reflection
+   * isn't available (which is the default today). Once handshake-time input
+   * reflection lands, `type` becomes optional.
+   */
+  type?: new () => I;
+}
+
+/**
+ * Per-room input handle returned by `Room.input()`. Mutate {@link data}
+ * to stage the next input, then call {@link send} to encode and transmit on
+ * the channel chosen at construction (reliable or unreliable).
+ *
+ * @example
+ * ```typescript
+ * const input = conn.input({ type: MoveInput, mode: "unreliable" });
+ * input.data.vx = 10;
+ * input.data.vy = 20;
+ * input.send();
+ * ```
+ */
+export interface ClientInputHandle<I = any> {
+  /** Mutable schema instance — mutate, then call {@link send}. */
+  readonly data: I;
+  /** Wire mode this handle was constructed with. */
+  readonly mode: InputMode;
+  /**
+   * Encode the staged input and send it. Routes to the reliable or
+   * unreliable channel based on {@link mode}.
+   *
+   * No-op when the connection isn't open, or — in reliable + delta mode —
+   * when nothing changed since the last send.
+   */
+  send(): void;
+  /**
+   * Reset encoder state. Drops the unreliable ring buffer; re-marks every
+   * populated field as dirty in delta mode (next send emits a full
+   * snapshot). Useful on scene transitions or after reconnection.
+   */
+  reset(): void;
+}
+
+/** @internal */
+export class ClientInputHandleImpl<I = any> implements ClientInputHandle<I> {
+  public readonly data: I;
+  private _host: InputHandleHost;
+  private _encoder: InputEncoder<any>;
+  private _scratch: Uint8Array = new Uint8Array(2048);
+
+  constructor(host: InputHandleHost, data: I, encoder: InputEncoder<any>) {
+    this._host = host;
+    this.data = data;
+    this._encoder = encoder;
+  }
+
+  get mode(): InputMode { return this._encoder.mode; }
+
+  reset(): void { this._encoder.reset(); }
+
+  send(): void {
+    const conn = this._host.connection;
+    if (!conn?.isOpen) return;
+
+    const bytes = this._encoder.encode();
+    if (bytes.length === 0) return;
+
+    const total = 1 + bytes.length;
+    if (total > this._scratch.byteLength) {
+      this._scratch = new Uint8Array(Math.max(total, this._scratch.byteLength * 2));
+    }
+    this._scratch[0] = this._encoder.mode === "reliable"
+      ? Protocol.ROOM_INPUT_RELIABLE
+      : Protocol.ROOM_INPUT_UNRELIABLE;
+    this._scratch.set(bytes, 1);
+
+    const framed = this._scratch.subarray(0, total);
+    if (this._encoder.mode === "reliable") {
+      conn.send(framed);
+    } else {
+      conn.sendUnreliable(framed);
+    }
+  }
+}

package/src/transport/H3Transport.ts

@@ -1,69 +1,6 @@
 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;
@@ -77,9 +14,6 @@ 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;
     }
@@ -176,13 +110,21 @@ 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
                 //
-                for (const frame of this.reliableReassembler.push(result.value)) {
-                    this.events.onmessage({ data: frame });
-                }
 
-            } catch (e) {
+                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);
+
+            } catch (e: any) {
                 if (e.message.indexOf("session is closed") === -1) {
                     console.error("H3Transport: failed to read incoming data", e);
                 }
@@ -205,13 +147,21 @@ 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
                 //
-                for (const frame of this.unreliableReassembler.push(result.value)) {
-                    this.events.onmessage({ data: frame });
-                }
 
-            } catch (e) {
+                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);
+
+            } catch (e: any) {
                 if (e.message.indexOf("session is closed") === -1) {
                     console.error("H3Transport: failed to read incoming data", e);
                 }

package/src/serializer/FossilDeltaSerializer.ts

@@ -1,39 +0,0 @@
-/*
-
-// Dependencies:
-// "@gamestdio/state-listener": "^3.1.0",
-// "fossil-delta": "^1.0.0",
-
-import { Serializer } from "./Serializer";
-
-import { StateContainer } from '@gamestdio/state-listener';
-import * as fossilDelta from 'fossil-delta';
-import * as msgpack from '../msgpack';
-
-export class FossilDeltaSerializer<State= any> implements Serializer<State> {
-    api: StateContainer<State> = new StateContainer<State>({} as State);
-    protected previousState: any;
-
-    getState(): State {
-        return this.api.state;
-    }
-
-    setState(encodedState: any): void {
-        this.previousState = new Uint8Array(encodedState);
-        this.api.set(msgpack.decode(this.previousState));
-    }
-
-    patch(binaryPatch) {
-        // apply patch
-        this.previousState = new Uint8Array(fossilDelta.apply(this.previousState, binaryPatch));
-
-        // trigger update callbacks
-        this.api.set(msgpack.decode(this.previousState));
-    }
-
-    teardown() {
-        this.api.removeAllListeners();
-    }
-}
-
-*/