@colyseus/sdk 0.17.41 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colyseus/sdk",
-  "version": "0.17.41",
+  "version": "0.18.0",
   "description": "Colyseus Multiplayer SDK for JavaScript/TypeScript",
   "author": "Endel Dreyer",
   "license": "MIT",
@@ -51,12 +51,12 @@
     "node": ">= 12.x"
   },
   "dependencies": {
-    "@colyseus/msgpackr": "^1.11.2",
-    "@colyseus/schema": "^4.0.7",
+    "@colyseus/schema": "^5.0.3",
+    "msgpackr": "^2.0.1",
     "tslib": "^2.1.0",
     "ws": "^8.13.0",
-    "@colyseus/shared-types": "^0.17.6",
-    "@colyseus/better-call": "^1.3.1"
+    "@colyseus/better-call": "^1.3.1",
+    "@colyseus/shared-types": "^0.18.0"
   },
   "devDependencies": {
     "@rollup/plugin-alias": "^5.1.1",
@@ -79,13 +79,13 @@
     "ts-loader": "^6.2.1",
     "ts-node": "^6.0.3",
     "tslint": "^5.9.1",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vite": "^5.0.11",
     "vitest": "^2.1.1",
-    "@colyseus/core": "^0.17.41"
+    "@colyseus/core": "^0.18.0"
   },
   "peerDependencies": {
-    "@colyseus/core": "0.17.x"
+    "@colyseus/core": "0.18.x"
   },
   "peerDependenciesMeta": {
     "@colyseus/core": {
@@ -95,6 +95,9 @@
       "optional": true
     }
   },
+  "publishConfig": {
+    "tag": "next"
+  },
   "scripts": {
     "test": "vitest run --dir test --reporter verbose",
     "start": "vite --config example/vite.config.ts",

package/src/Auth.ts

@@ -165,7 +165,17 @@ export class Auth<UserData = any> {
                 window.removeEventListener("message", onMessage);
 
                 if (event.data.error !== undefined) {
-                    reject(event.data.error);
+                    // Reject with an Error so consumers' `catch (e) {
+                    // ... e.message }` reads as expected. Attach the
+                    // structured payload (reason / until / etc.) as
+                    // properties so callers that want to render a
+                    // richer message (e.g. "banned until X for Y")
+                    // can pull them off without re-parsing.
+                    const err: any = new Error(String(event.data.error));
+                    err.code = event.data.error;
+                    if (event.data.reason !== undefined) { err.reason = event.data.reason; }
+                    if (event.data.until !== undefined) { err.until = event.data.until; }
+                    reject(err);
 
                 } else {
                     resolve(event.data);

package/src/Room.ts

@@ -1,7 +1,11 @@
-import { CloseCode, Protocol, type InferState, type NormalizeRoomType, type ExtractRoomMessages, type ExtractRoomClientMessages, type ExtractMessageType } from '@colyseus/shared-types';
-import { decode, Decoder, encode, Iterator, Schema } from '@colyseus/schema';
+import { CloseCode, HandshakeSection, Protocol, ResponseStatus, type InferState, type InferInput, type NormalizeRoomType, type ExtractRoomMessages, type ExtractRoomClientMessages, type ExtractMessageType, type ExtractResponseType } from '@colyseus/shared-types';
+import { decode, Decoder, encode, Iterator, Reflection, Schema } from '@colyseus/schema';
+import { InputEncoder } from '@colyseus/schema/input';
 
-import { Packr, unpack } from '@colyseus/msgpackr';
+import { ClientInputHandleImpl, type ClientInputHandle, type ClientInputOptions } from './input/InputHandle.ts';
+export { type ClientInputHandle, type ClientInputOptions } from './input/InputHandle.ts';
+
+import { Packr, unpack, RESERVE_START_SPACE } from 'msgpackr';
 
 import { Connection } from './Connection.ts';
 import { getSerializer, Serializer } from './serializer/Serializer.ts';
@@ -135,17 +139,48 @@ export class Room<
     protected onMessageHandlers = createNanoEvents();
 
     protected packr: Packr;
+    protected sharedBuffer: Uint8Array;
 
     #lastPingTime: number = 0;
     #pingCallback?: (ms: number) => void = undefined;
 
+    /**
+     * Default time (ms) a `room.request()` / `room.send(..., callback)` waits
+     * for a reply before rejecting. Override per-call with the `timeout`
+     * option. Tune globally by assigning to this field after joining.
+     */
+    public requestTimeout: number = 10000;
+
+    /** Monotonic id correlating a {@link Protocol.ROOM_REQUEST} with its reply. @internal */
+    #nextRequestId: number = 0;
+
+    /** In-flight requests awaiting a {@link Protocol.ROOM_RESPONSE}. @internal */
+    #pendingRequests = new Map<number, {
+        resolve: (value: any) => void;
+        reject: (reason: any) => void;
+        timer: ReturnType<typeof setTimeout>;
+    }>();
+
+    #inputHandle?: ClientInputHandle<any>;
+    /**
+     * Schema constructor recovered via Reflection from the server's
+     * handshake (the `INPUT_REFLECTION` tagged section). Populated on JOIN
+     * when the server room called `defineInput()`; falls back to `undefined`
+     * otherwise. Survives reconnects that skip the handshake — the field is
+     * set on the original join and never cleared.
+     *
+     * Typed as `new () => any` (not `Schema`) on purpose — pinning to this
+     * SDK's Schema type would clash with user instances coming from a
+     * different copy of `@colyseus/schema` under multi-version installs.
+     * @internal
+     */
+    #inputCtorFromReflection?: new () => any;
+
     constructor(name: string, rootSchema?: SchemaConstructor<State>) {
         this.name = name;
 
         this.packr = new Packr();
-
-        // msgpackr workaround: force buffer to be created.
-        this.packr.encode(undefined);
+        this.sharedBuffer = new Uint8Array(8192);
 
         if (rootSchema) {
             const serializer: SchemaSerializer = new (getSerializer("schema"));
@@ -166,6 +201,9 @@ export class Room<
         this.connection = new Connection(options.protocol);
         this.connection.events.onmessage = this.onMessageCallback.bind(this);
         this.connection.events.onclose = (e: CloseEvent) => {
+            // the in-flight requests can't be answered on a closed socket
+            this.#rejectAllPending("connection closed before a response was received.");
+
             if (this.joinedAtTime === 0) {
                 console.warn?.(`Room connection was closed unexpectedly (${e.code}): ${e.reason}`);
                 this.onError.invoke(e.code, e.reason);
@@ -213,8 +251,8 @@ export class Room<
 
             if (this.connection) {
                 if (consented) {
-                    this.packr.buffer[0] = Protocol.LEAVE_ROOM;
-                    this.connection.send(this.packr.buffer.subarray(0, 1));
+                    this.sharedBuffer[0] = Protocol.LEAVE_ROOM;
+                    this.connection.send(this.sharedBuffer.subarray(0, 1));
 
                 } else {
                     this.connection.close();
@@ -248,36 +286,63 @@ export class Room<
 
         this.#lastPingTime = now();
         this.#pingCallback = callback;
-        this.packr.buffer[0] = Protocol.PING;
-        this.connection.send(this.packr.buffer.subarray(0, 1));
+        this.sharedBuffer[0] = Protocol.PING;
+        this.connection.send(this.sharedBuffer.subarray(0, 1));
     }
 
     public send<MessageType extends keyof ExtractRoomMessages<NormalizeRoomType<T>>>(
         messageType: MessageType,
         payload?: ExtractMessageType<ExtractRoomMessages<NormalizeRoomType<T>>[MessageType]>
     ): void
+    // Request overload: passing a callback turns this into a request/response —
+    // the callback receives the value the server handler returns (or an Error).
+    public send<MessageType extends keyof ExtractRoomMessages<NormalizeRoomType<T>>>(
+        messageType: MessageType,
+        payload: ExtractMessageType<ExtractRoomMessages<NormalizeRoomType<T>>[MessageType]>,
+        callback: (response: ExtractResponseType<ExtractRoomMessages<NormalizeRoomType<T>>[MessageType]>, error?: Error) => void
+    ): void
     // Fallback overload: only available when no typed messages are defined
     public send<Payload = any>(
         messageType: [keyof ExtractRoomMessages<NormalizeRoomType<T>>] extends [never] ? (string | number) : never,
         payload?: Payload
     ): void
-    public send(messageType: string | number, payload?: any): void {
+    // Fallback request overload
+    public send<Payload = any, Response = any>(
+        messageType: [keyof ExtractRoomMessages<NormalizeRoomType<T>>] extends [never] ? (string | number) : never,
+        payload: Payload,
+        callback: (response: Response, error?: Error) => void
+    ): void
+    public send(messageType: string | number, payload?: any, callback?: (response: any, error?: Error) => void): void {
+        // Request/response form: defer to `request()` and adapt to a
+        // (response, error) callback.
+        if (callback !== undefined) {
+            this.#request(messageType, payload, this.requestTimeout).then(
+                (response) => callback(response, undefined),
+                (error) => callback(undefined, error),
+            );
+            return;
+        }
+
         const it: Iterator = { offset: 1 };
-        this.packr.buffer[0] = Protocol.ROOM_DATA;
+        this.sharedBuffer[0] = Protocol.ROOM_DATA;
 
         if (typeof(messageType) === "string") {
-            encode.string(this.packr.buffer as Buffer, messageType, it);
+            encode.string(this.sharedBuffer, messageType, it);
 
         } else {
-            encode.number(this.packr.buffer as Buffer, messageType, it);
+            encode.number(this.sharedBuffer, messageType, it);
+        }
+        const headerLength = it.offset;
+
+        let data: Uint8Array;
+        if (payload !== undefined) {
+            // Reserve `headerLength` writable bytes at the front of msgpackr's
+            // output and prepend the protocol header into them.
+            data = this.packr.pack(payload, RESERVE_START_SPACE | headerLength);
+            data.set(this.sharedBuffer.subarray(0, headerLength), 0);
+        } else {
+            data = this.sharedBuffer.subarray(0, headerLength);
         }
-
-        // force packr to use beginning of the buffer
-        this.packr.position = 0;
-
-        const data = (payload !== undefined)
-            ? this.packr.pack(payload, 2048 + it.offset) // 2048 = RESERVE_START_SPACE
-            : this.packr.buffer.subarray(0, it.offset);
 
         // If connection is not open, buffer the message
         if (!this.connection.isOpen) {
@@ -287,58 +352,186 @@ export class Room<
         }
     }
 
+    /**
+     * Send a message and await the server's reply. The server answers by
+     * returning a value from its matching `onMessage(type, ...)` handler.
+     *
+     * Rejects if the handler throws, if no handler is registered, if the
+     * connection closes first, or if no reply arrives within `timeout`
+     * (defaults to {@link Room.requestTimeout}).
+     *
+     * @example
+     * ```typescript
+     * const profile = await room.request("get-profile", { id: 42 });
+     * ```
+     */
+    public request<MessageType extends keyof ExtractRoomMessages<NormalizeRoomType<T>>>(
+        messageType: MessageType,
+        payload?: ExtractMessageType<ExtractRoomMessages<NormalizeRoomType<T>>[MessageType]>,
+        options?: { timeout?: number }
+    ): Promise<ExtractResponseType<ExtractRoomMessages<NormalizeRoomType<T>>[MessageType]>>
+    public request<Payload = any, Response = any>(
+        messageType: [keyof ExtractRoomMessages<NormalizeRoomType<T>>] extends [never] ? (string | number) : never,
+        payload?: Payload,
+        options?: { timeout?: number }
+    ): Promise<Response>
+    public request(messageType: string | number, payload?: any, options?: { timeout?: number }): Promise<any> {
+        return this.#request(messageType, payload, options?.timeout ?? this.requestTimeout);
+    }
+
+    #request(messageType: string | number, payload: any, timeoutMs: number): Promise<any> {
+        return new Promise((resolve, reject) => {
+            if (!this.connection.isOpen) {
+                reject(new Error(`cannot send request "${messageType}": connection is not open.`));
+                return;
+            }
+
+            const requestId = this.#nextRequestId;
+            this.#nextRequestId = (this.#nextRequestId + 1) >>> 0; // keep within uint32
+
+            const it: Iterator = { offset: 1 };
+            this.sharedBuffer[0] = Protocol.ROOM_REQUEST;
+            encode.number(this.sharedBuffer, requestId, it);
+
+            if (typeof(messageType) === "string") {
+                encode.string(this.sharedBuffer, messageType, it);
+            } else {
+                encode.number(this.sharedBuffer, messageType, it);
+            }
+            const headerLength = it.offset;
+
+            let data: Uint8Array;
+            if (payload !== undefined) {
+                data = this.packr.pack(payload, RESERVE_START_SPACE | headerLength);
+                data.set(this.sharedBuffer.subarray(0, headerLength), 0);
+            } else {
+                data = this.sharedBuffer.subarray(0, headerLength);
+            }
+
+            const timer = setTimeout(() => {
+                this.#pendingRequests.delete(requestId);
+                reject(new Error(`request "${messageType}" timed out after ${timeoutMs}ms.`));
+            }, timeoutMs);
+
+            this.#pendingRequests.set(requestId, { resolve, reject, timer });
+            this.connection.send(data);
+        });
+    }
+
+    #rejectAllPending(reason: string) {
+        if (this.#pendingRequests.size === 0) { return; }
+        const error = new Error(reason);
+        for (const pending of this.#pendingRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.#pendingRequests.clear();
+    }
+
     public sendUnreliable<T = any>(type: string | number, message?: T): void {
         // If connection is not open, skip
         if (!this.connection.isOpen) { return; }
 
         const it: Iterator = { offset: 1 };
-        this.packr.buffer[0] = Protocol.ROOM_DATA;
+        this.sharedBuffer[0] = Protocol.ROOM_DATA;
 
         if (typeof(type) === "string") {
-            encode.string(this.packr.buffer as Buffer, type, it);
+            encode.string(this.sharedBuffer, type, it);
 
         } else {
-            encode.number(this.packr.buffer as Buffer, type, it);
+            encode.number(this.sharedBuffer, type, it);
         }
+        const headerLength = it.offset;
 
-        // force packr to use beginning of the buffer
-        this.packr.position = 0;
-
-        const data = (message !== undefined)
-            ? this.packr.pack(message, 2048 + it.offset) // 2048 = RESERVE_START_SPACE
-            : this.packr.buffer.subarray(0, it.offset);
+        let data: Uint8Array;
+        if (message !== undefined) {
+            data = this.packr.pack(message, RESERVE_START_SPACE | headerLength);
+            data.set(this.sharedBuffer.subarray(0, headerLength), 0);
+        } else {
+            data = this.sharedBuffer.subarray(0, headerLength);
+        }
 
         this.connection.sendUnreliable(data);
     }
 
     public sendBytes(type: string | number, bytes: Uint8Array) {
         const it: Iterator = { offset: 1 };
-        this.packr.buffer[0] = Protocol.ROOM_DATA_BYTES;
+        this.sharedBuffer[0] = Protocol.ROOM_DATA_BYTES;
 
         if (typeof(type) === "string") {
-            encode.string(this.packr.buffer as Buffer, type, it);
+            encode.string(this.sharedBuffer, type, it);
 
         } else {
-            encode.number(this.packr.buffer as Buffer, type, it);
+            encode.number(this.sharedBuffer, type, it);
         }
+        const headerLength = it.offset;
 
-        // check if buffer needs to be resized
-        // TODO: can we avoid this?
-        if (bytes.byteLength + it.offset > this.packr.buffer.byteLength) {
-            const newBuffer = new Uint8Array(it.offset + bytes.byteLength);
-            newBuffer.set(this.packr.buffer);
-            this.packr.useBuffer(newBuffer);
+        // grow the scratch buffer if needed, preserving the header bytes
+        if (headerLength + bytes.byteLength > this.sharedBuffer.byteLength) {
+            const newBuffer = new Uint8Array(headerLength + bytes.byteLength);
+            newBuffer.set(this.sharedBuffer.subarray(0, headerLength));
+            this.sharedBuffer = newBuffer;
         }
 
-        this.packr.buffer.set(bytes, it.offset);
+        this.sharedBuffer.set(bytes, headerLength);
 
         // If connection is not open, buffer the message
         if (!this.connection.isOpen) {
-            enqueueMessage(this, this.packr.buffer.subarray(0, it.offset + bytes.byteLength));
+            enqueueMessage(this, this.sharedBuffer.subarray(0, headerLength + bytes.byteLength));
         } else {
-            this.connection.send(this.packr.buffer.subarray(0, it.offset + bytes.byteLength));
+            this.connection.send(this.sharedBuffer.subarray(0, headerLength + bytes.byteLength));
+        }
+
+    }
+
+    /**
+     * Get the per-room input handle. Lazily created on first call and cached;
+     * subsequent calls return the same handle (options on later calls are
+     * ignored).
+     *
+     * Schema discovery, in order:
+     * 1. `options.type` — explicit constructor (overrides everything).
+     * 2. Server-sent reflection from the JOIN handshake — populated when the
+     *    server room called `defineInput()`. The synthesized class has the
+     *    same fields as the server's input schema; `instanceof YourInput`
+     *    won't pass on it.
+     *
+     * Throws if neither source has produced a constructor.
+     *
+     * For rollback netcode, prefer `{ mode: "unreliable", delta: true,
+     * historySize: 4 }`: tiny per-tick payloads, redundancy across drops,
+     * idempotent under reordering.
+     *
+     * @example
+     * ```typescript
+     * const conn = await client.joinOrCreate<typeof FpsRoom>("fps");
+     * const input = conn.input({ mode: "unreliable" });   // type from server
+     * // each simulation tick:
+     * input.data.seq++;
+     * input.data.vx = vx;
+     * input.data.vy = vy;
+     * input.send();
+     * ```
+     */
+    public input<
+        I = ([InferInput<T>] extends [never] ? any : InferInput<T>),
+    >(options?: ClientInputOptions<I>): ClientInputHandle<I> {
+        if (this.#inputHandle) {
+            return this.#inputHandle as ClientInputHandle<I>;
         }
 
+        const Ctor = (options?.type ?? this.#inputCtorFromReflection) as (new () => I) | undefined;
+        if (!Ctor) {
+            throw new Error(
+                "conn.input(): no input schema available. The server room must call " +
+                "`defineInput(YourInput)`, or you can pass `{ type: YourInput }` explicitly."
+            );
+        }
+
+        const instance = new Ctor();
+        const encoder = new InputEncoder(instance as any, options);
+        this.#inputHandle = new ClientInputHandleImpl(this, instance, encoder);
+        return this.#inputHandle as ClientInputHandle<I>;
     }
 
     public get state (): State {
@@ -376,9 +569,34 @@ export class Room<
                 this.serializer = new serializer();
             }
 
-            // apply handshake on first join (no need to do this on reconnect)
-            if (buffer.byteLength > it.offset && this.serializer.handshake) {
-                this.serializer.handshake(buffer, it);
+            // State reflection is length-prefixed (varint). The schema decoder
+            // runs `while (offset < bytes.byteLength)` so without a boundary
+            // it would read past the state reflection into the trailing
+            // tagged-section bytes — see Protocol.ts for the wire layout.
+            const stateReflectionLen = decode.number(buffer as Buffer, it);
+            if (stateReflectionLen > 0 && this.serializer.handshake) {
+                const stateReflectionEnd = it.offset + stateReflectionLen;
+                this.serializer.handshake(buffer.subarray(0, stateReflectionEnd), it);
+                it.offset = stateReflectionEnd;
+            }
+
+            // Parse trailing tagged sections (forward-compatible: unknown tags
+            // are skipped via length). See HandshakeSection in shared-types.
+            while (it.offset < buffer.byteLength) {
+                const tag = buffer[it.offset++];
+                const sectionLen = decode.number(buffer as Buffer, it);
+                const sectionEnd = it.offset + sectionLen;
+
+                if (tag === HandshakeSection.INPUT_REFLECTION) {
+                    const inputDecoder = Reflection.decode(buffer.subarray(0, sectionEnd) as any, it);
+                    // Install schema-builder field descriptors on the
+                    // reconstructed class so `InputEncoder` can read its
+                    // `$values` and emit non-empty packets.
+                    Reflection.makeEncodable(inputDecoder.state.constructor as any);
+                    this.#inputCtorFromReflection = inputDecoder.state.constructor as new () => any;
+                }
+
+                it.offset = sectionEnd;
             }
 
             if (this.joinedAtTime === 0) {
@@ -394,8 +612,8 @@ export class Room<
             this.reconnectionToken = `${this.roomId}:${reconnectionToken}`;
 
             // acknowledge successfull JOIN_ROOM
-            this.packr.buffer[0] = Protocol.JOIN_ROOM;
-            this.connection.send(this.packr.buffer.subarray(0, 1));
+            this.sharedBuffer[0] = Protocol.JOIN_ROOM;
+            this.connection.send(this.sharedBuffer.subarray(0, 1));
 
             // Send any enqueued messages that were buffered while disconnected
             if (this.reconnection.enqueuedMessages.length > 0) {
@@ -441,6 +659,32 @@ export class Room<
 
             this.dispatchMessage(type, buffer.subarray(it.offset));
 
+        } else if (code === Protocol.ROOM_RESPONSE) {
+            // reply to a pending `request()` / `send(..., callback)`
+            const requestId = decode.number(buffer as Buffer, it);
+            const status = buffer[it.offset++];
+
+            const pending = this.#pendingRequests.get(requestId);
+            // already settled (e.g. timed out) or unknown id — ignore
+            if (pending !== undefined) {
+                this.#pendingRequests.delete(requestId);
+                clearTimeout(pending.timer);
+
+                const payload = (buffer.byteLength > it.offset)
+                    ? unpack(buffer as Buffer, { start: it.offset })
+                    : undefined;
+
+                if (status === ResponseStatus.OK) {
+                    pending.resolve(payload);
+                } else {
+                    // payload carries { name, message, code } from the server
+                    const error: any = new Error(payload?.message ?? "request failed");
+                    if (payload?.name) { error.name = payload.name; }
+                    if (payload?.code !== undefined) { error.code = payload.code; }
+                    pending.reject(error);
+                }
+            }
+
         } else if (code === Protocol.PING) {
             this.#pingCallback?.(Math.round(now() - this.#lastPingTime));
             this.#pingCallback = undefined;
@@ -538,4 +782,6 @@ function enqueueMessage(room: Room, message: Uint8Array) {
     if (room.reconnection.enqueuedMessages.length > room.reconnection.maxEnqueuedMessages) {
         room.reconnection.enqueuedMessages.shift();
     }
-}
+}
+
+

package/src/core/signal.ts

@@ -47,7 +47,7 @@ export function createSignal<CallbackSignature extends (...args: any[]) => void
   };
 
   register.once = (cb: CallbackSignature) => {
-    const callback: any = function (...args: any[]) {
+    const callback: any = function (this: any, ...args: any[]) {
       cb.apply(this, args);
       emitter.remove(callback);
     }

package/src/debug.ts

@@ -1434,7 +1434,7 @@ function openSendMessagesModal(uniquePanelId) {
                 sendButton.style.cursor = 'pointer';
             }, 800);
 
-        } catch (e) {
+        } catch (e: any) {
             errorContainer.textContent = 'Error: ' + e.message;
             errorContainer.style.display = 'block';
         }
@@ -1740,7 +1740,7 @@ function openStateInspectorModal(uniquePanelId) {
                         html += renderKeyValue(key, value, depth + 1, currentPath, keyStr, typeof key === 'string');
                     }
                 });
-            } catch (e) {
+            } catch (e: any) {
                 var errorIndent = (depth + 1) * 6;
                 html += '<div style="margin-left: ' + errorIndent + 'px; color: #e74856;">Error iterating: ' + escapeHtml(e.message) + '</div>';
             }
@@ -1843,7 +1843,7 @@ function openStateInspectorModal(uniquePanelId) {
             contentContainer.innerHTML = '<div style="font-family: \'Consolas\', \'Monaco\', \'Courier New\', monospace; font-size: 12px; line-height: 1.5; color: #d4d4d4; padding: 8px;">' + renderState(state) + '</div>';
 
             // Event delegation: single click listener handles all expand buttons
-        } catch (e) {
+        } catch (e: any) {
             contentContainer.innerHTML = '<div style="color: #e74856; padding: 20px;">Error accessing room state: ' + escapeHtml(e.message) + '</div>';
         }
     }
@@ -1853,7 +1853,7 @@ function openStateInspectorModal(uniquePanelId) {
     function throttle(func, wait) {
         var timeout;
         var previous = 0;
-        return function executedFunction() {
+        return function executedFunction(this: any) {
             var context = this;
             var args = arguments;
             var now = Date.now();
@@ -2804,7 +2804,7 @@ function applyMonkeyPatches() {
                     originalOnMessage.call(event.target, syntheticEvent);
                 }, preferences.latencySimulation.delay);
             } else {
-                return originalOnMessage.apply(this, arguments);
+                return originalOnMessage.apply(this, arguments as any);
             }
         };
 
@@ -2815,11 +2815,11 @@ function applyMonkeyPatches() {
         const originalOnClose = transport.events.onclose;
         transport.events.onclose = function(event) {
             if (preferences.latencySimulation.enabled && preferences.latencySimulation.delay > 0) {
-                setTimeout(function() {
+                setTimeout(function(this: any) {
                     if (originalOnClose) originalOnClose.call(this, event);
                 }, preferences.latencySimulation.delay + 1);
             } else {
-                if (originalOnClose) return originalOnClose.apply(this, arguments);
+                if (originalOnClose) return originalOnClose.apply(this, arguments as any);
             }
         };
 
@@ -2879,7 +2879,7 @@ function applyMonkeyPatches() {
     // Patch consumeSeatReservation to intercept all room connections
     var originalConsumeSeatReservation = Client.prototype.consumeSeatReservation;
     Client.prototype.consumeSeatReservation = function() {
-        var promise = originalConsumeSeatReservation.apply(this, arguments);
+        var promise = originalConsumeSeatReservation.apply(this, arguments as any);
         return promise.then((room) => patchRoom(room));
     };
 

package/src/index.ts

@@ -1,4 +1,4 @@
-import './legacy';
+import './legacy.ts';
 
 export { ColyseusSDK, Client, type JoinOptions, type EndpointSettings, type ClientOptions, type ISeatReservation as SeatReservation } from './Client.ts';
 export { type FetchFn } from './HTTP.ts';