sonic-ws 1.0.0-rc.7 → 1.0.0

package/dist/ws/server/SonicWSConnection.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -59,16 +59,15 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SonicWSConnection = void 0;
 var WS = __importStar(require("ws"));
-var CodePointUtil_1 = require("../util/packets/CodePointUtil");
 var PacketUtils_1 = require("../util/packets/PacketUtils");
 var BatchHelper_1 = require("../util/packets/BatchHelper");
 var RateHandler_1 = require("../util/packets/RateHandler");
+var BufferUtil_1 = require("../util/BufferUtil");
 var CLIENT_RATELIMIT_TAG = "C", SERVER_RATELIMIT_TAG = "S";
 var SonicWSConnection = /** @class */ (function () {
     function SonicWSConnection(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
         var _this = this;
         this.print = false;
-        this.timers = [];
         this.messageLambda = function (data) { return _this.messageHandler(_this.parseData(data)); };
         this.handshakedMessageLambda = function (data) {
             var parsed = _this.parseData(data);
@@ -78,17 +77,19 @@ var SonicWSConnection = /** @class */ (function () {
                 return _this.socket.close(4005);
             _this.messageHandler(parsed);
         };
+        this.enabledPackets = {};
         /** If the packet handshake has been completed; `wss.requireHandshake(packet)` */
         this.handshakeComplete = false;
+        this.timers = {};
         this.socket = socket;
         this.host = host;
         this.id = id;
-        this.code = String.fromCharCode(id);
         this.handshakePacket = handshakePacket;
         this.listeners = {};
-        for (var _i = 0, _a = Object.values(host.clientPackets.getTagMap()); _i < _a.length; _i++) {
+        for (var _i = 0, _a = host.clientPackets.getTags(); _i < _a.length; _i++) {
             var key = _a[_i];
             this.listeners[key] = [];
+            this.enabledPackets[key] = host.clientPackets.getPacket(key).defaultEnabled;
         }
         this.setInterval = this.setInterval.bind(this);
         this.batcher = new BatchHelper_1.BatchHelper();
@@ -108,29 +109,37 @@ var SonicWSConnection = /** @class */ (function () {
             this.socket.addEventListener('message', this.handshakeLambda);
         }
         this.socket.on('close', function () {
-            _this.timers.forEach(clearTimeout);
+            Object.values(_this.timers).forEach(clearTimeout);
         });
     }
     SonicWSConnection.prototype.parseData = function (event) {
         if (this.rater.trigger(CLIENT_RATELIMIT_TAG))
             return null;
-        var message = event.data.toString();
+        if (!(event.data instanceof Buffer))
+            return null;
+        var message = new Uint8Array(event.data);
         if (this.print)
-            console.log("\u001B[31m\u2B07 \u001B[38;5;245m(".concat(this.id, ",").concat((0, CodePointUtil_1.getStringBytes)(message), ")\u001B[0m ").concat(this.hideNewLines(message)));
-        if (message.length < 1) {
+            console.log("\u001B[31m\u2B07 \u001B[38;5;245m(".concat(this.id, ",").concat(message.byteLength, ")\u001B[0m ").concat(this.hideNewLines(message)));
+        if (message.byteLength < 1) {
             this.socket.close(4001);
             return null;
         }
         var key = message[0];
-        var value = message.substring(1);
+        var value = message.slice(1);
         // not a key, bye bye
-        if (!this.host.clientPackets.has(key)) {
+        if (!this.host.clientPackets.hasKey(key)) {
             this.socket.close(4002);
             return null;
         }
+        var tag = this.host.clientPackets.getTag(key);
+        // disabled, bye bye
+        if (!this.enabledPackets[tag]) {
+            this.socket.close(4006);
+            return null;
+        }
         if (this.rater.trigger("client" + key))
             return null;
-        return [this.host.clientPackets.getTag(key), value];
+        return [tag, value];
     };
     SonicWSConnection.prototype.handshakeHandler = function (data) {
         var parsed = this.parseData(data);
@@ -175,7 +184,7 @@ var SonicWSConnection = /** @class */ (function () {
         }
     };
     SonicWSConnection.prototype.hideNewLines = function (str) {
-        return str.split("\n").join("☺");
+        return Array.from((0, BufferUtil_1.as8String)(str)).map(function (x) { return x == "\n" ? "☺" : x; }).join("");
     };
     /** Sends raw data to the user; will likely fail validity checks if used externally */
     SonicWSConnection.prototype.raw_send = function (data) {
@@ -184,9 +193,23 @@ var SonicWSConnection = /** @class */ (function () {
         if (this.rater.trigger(SERVER_RATELIMIT_TAG))
             return;
         if (this.print)
-            console.log("\u001B[32m\u2B06 \u001B[38;5;245m(".concat(this.id, ",").concat((0, CodePointUtil_1.getStringBytes)(data), ")\u001B[0m ").concat(this.hideNewLines(data)));
+            console.log("\u001B[32m\u2B06 \u001B[38;5;245m(".concat(this.id, ",").concat(data.byteLength, ")\u001B[0m ").concat(this.hideNewLines(data)));
         this.socket.send(data);
     };
+    /**
+     * Enables a packet for the client.
+     * @param tag The tag of the packet
+     */
+    SonicWSConnection.prototype.enablePacket = function (tag) {
+        this.enabledPackets[tag] = true;
+    };
+    /**
+     * Disables a packet for the client.
+     * @param tag The tag of the packet
+     */
+    SonicWSConnection.prototype.disablePacket = function (tag) {
+        this.enabledPackets[tag] = false;
+    };
     /**
      * Checks if the connection is closed
      * @returns If it's closed or not
@@ -207,8 +230,7 @@ var SonicWSConnection = /** @class */ (function () {
      * @param listener A function to listen for it
      */
     SonicWSConnection.prototype.on = function (tag, listener) {
-        var code = this.host.clientPackets.getChar(tag);
-        if (code == null)
+        if (!this.host.clientPackets.hasTag(tag))
             throw new Error("Tag \"".concat(tag, "\" has not been created!"));
         if (!this.listeners[tag])
             this.listeners[tag] = [];
@@ -218,10 +240,10 @@ var SonicWSConnection = /** @class */ (function () {
      * For internal use.
      */
     SonicWSConnection.prototype.send_processed = function (code, data, packet) {
-        if (this.rater.trigger("client" + code))
+        if (this.rater.trigger("server" + code))
             return;
         if (packet.dataBatching == 0)
-            this.raw_send(code + data);
+            this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
         else
             this.batcher.batchPacket(code, data);
     };
@@ -270,32 +292,52 @@ var SonicWSConnection = /** @class */ (function () {
         this.print = !this.print;
     };
     /**
-     * Closes the socket
+     * Closes the connection
      */
-    SonicWSConnection.prototype.close = function (code) {
-        if (code === void 0) { code = 1000; }
-        this.socket.close(code);
+    SonicWSConnection.prototype.close = function (code, reason) {
+        this.socket.close(code, reason);
     };
     /**
      * Sets a timeout that will automatically end when the socket closes
      * @param call The function to call
      * @param time The time between now and the call (ms)
+     * @returns The timeout id to be used with socket.clearInterval(id)
      */
     SonicWSConnection.prototype.setTimeout = function (call, time) {
-        var timeout = setTimeout(call, time);
-        this.timers.push(timeout);
+        var _this = this;
+        var timeout = setTimeout(function () {
+            call();
+            _this.clearTimeout(timeout);
+        }, time);
+        this.timers[timeout] = timeout;
         return timeout;
     };
     /**
      * Sets an interval that will automatically end when the socket closes
      * @param call The function to call
      * @param time The time between calls (ms)
+     * @returns The interval id to be used with socket.clearInterval(id)
      */
     SonicWSConnection.prototype.setInterval = function (call, time) {
         var interval = setInterval(call, time);
-        this.timers.push(interval);
+        this.timers[interval] = interval;
         return interval;
     };
+    /**
+     * Clears a timeout
+     * @param id The timeout id
+     */
+    SonicWSConnection.prototype.clearTimeout = function (id) {
+        clearTimeout(id);
+        delete this.timers[id];
+    };
+    /**
+     * Clears an interval
+     * @param id The interval id
+     */
+    SonicWSConnection.prototype.clearInterval = function (id) {
+        this.clearTimeout(id);
+    };
     return SonicWSConnection;
 }());
 exports.SonicWSConnection = SonicWSConnection;

package/dist/ws/server/SonicWSServer.d.ts

@@ -25,6 +25,8 @@ export declare class SonicWSServer {
     private clientRateLimit;
     private serverRateLimit;
     private handshakePacket;
+    private maxConnections;
+    private queueTime;
     /**
      * Initializes and hosts a websocket with sonic protocol
      * Rate limits can be set with wss.setClientRateLimit(x) and wss.setServerRateLimit(x); it is defaulted at 500/second per both
@@ -63,6 +65,16 @@ export declare class SonicWSServer {
      * @param limit Amount of packets the server can send every second, or 0 for infinite
      */
     setServerRateLimit(limit: number): void;
+    /**
+     * Enables a packet for all current & new clients.
+     * @param tag The tag of the packet
+     */
+    enablePacket(tag: string): void;
+    /**
+     * Disables a packet for all current & new clients.
+     * @param tag The tag of the packet
+     */
+    disablePacket(tag: string): void;
     /**
      * Listens for whenever a client connects
      * @param runner Called when ready
@@ -91,6 +103,16 @@ export declare class SonicWSServer {
      * @param values The values to send
      */
     broadcast(tag: string, ...values: any): void;
+    /**
+     * Sets the maximum amount of users that can be connected; will tell about wss.setQueueTime(time). Defaults to unlimited
+     * @param amount The amount of users that can be connected
+     */
+    setMaxConnections(amount: number): void;
+    /**
+     * Sets the time in milliseconds for queued users to attempt to retry; applies for wss.setMaxConnections(amt). Defaults to 10,000ms
+     * @param time The requested reconnect time
+     */
+    setQueueTimeMs(time: number): void;
     /**
      * @returns All users connected to the socket
      */

package/dist/ws/server/SonicWSServer.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -65,7 +65,7 @@ var node_fetch_1 = __importDefault(require("node-fetch"));
 var WS = __importStar(require("ws"));
 var SonicWSConnection_1 = require("./SonicWSConnection");
 var PacketHolder_1 = require("../util/packets/PacketHolder");
-var CodePointUtil_1 = require("../util/packets/CodePointUtil");
+var CompressionUtil_1 = require("../util/packets/CompressionUtil");
 var version_1 = require("../../version");
 var PacketUtils_1 = require("../util/packets/PacketUtils");
 var SonicWSServer = /** @class */ (function () {
@@ -84,17 +84,25 @@ var SonicWSServer = /** @class */ (function () {
         this.clientRateLimit = 500;
         this.serverRateLimit = 500;
         this.handshakePacket = null;
+        this.maxConnections = 0;
+        this.queueTime = 10000;
         var _a = settings.clientPackets, clientPackets = _a === void 0 ? [] : _a, _b = settings.serverPackets, serverPackets = _b === void 0 ? [] : _b, _c = settings.websocketOptions, websocketOptions = _c === void 0 ? {} : _c;
         this.wss = new WS.WebSocketServer(websocketOptions);
         this.clientPackets = new PacketHolder_1.PacketHolder(clientPackets);
         this.serverPackets = new PacketHolder_1.PacketHolder(serverPackets);
         var s_clientPackets = this.clientPackets.serialize();
         var s_serverPackets = this.serverPackets.serialize();
-        var keyData = "SWS" + version_1.VERSION_CHAR + s_clientPackets + CodePointUtil_1.NULL + s_serverPackets;
+        var keyData = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], version_1.SERVER_SUFFIX_NUMS, true), [version_1.VERSION], false), (0, CompressionUtil_1.convertVarInt)(s_clientPackets.length, false), true), s_clientPackets, true), s_serverPackets, true);
+        var retryData = new Uint8Array(version_1.SERVER_SUFFIX_NUMS);
         this.wss.on('connection', function (socket) {
+            if (_this.maxConnections != 0 && _this.connections.length >= _this.maxConnections) {
+                socket.send(retryData);
+                socket.close(1013);
+                return;
+            }
             var sonicConnection = new SonicWSConnection_1.SonicWSConnection(socket, _this, _this.generateSocketID(), _this.handshakePacket, _this.clientRateLimit, _this.serverRateLimit);
             // send tags to the client so it doesn't have to hard code them in
-            socket.send(keyData + CodePointUtil_1.NULL + String.fromCharCode(_this.clientRateLimit) + sonicConnection.code);
+            socket.send(new Uint8Array(__spreadArray(__spreadArray([], keyData, true), [sonicConnection.id], false)));
             _this.connections.push(sonicConnection);
             _this.connectionMap[sonicConnection.id] = sonicConnection;
             _this.connectListeners.forEach(function (l) { return l(sonicConnection); });
@@ -155,9 +163,9 @@ var SonicWSServer = /** @class */ (function () {
      */
     SonicWSServer.prototype.setClientRateLimit = function (limit) {
         // so that i can store limits in 1 packet
-        if (limit > CodePointUtil_1.MAX_C) {
+        if (limit > CompressionUtil_1.MAX_BYTE) {
             limit = 0;
-            console.warn("A rate limit above ".concat(CodePointUtil_1.MAX_C, " is considered infinite."));
+            console.warn("A rate limit above ".concat(CompressionUtil_1.MAX_BYTE, " is considered infinite."));
         }
         this.clientRateLimit = limit;
     };
@@ -167,12 +175,28 @@ var SonicWSServer = /** @class */ (function () {
      */
     SonicWSServer.prototype.setServerRateLimit = function (limit) {
         // so that i can store limits in 1 packet
-        if (limit > CodePointUtil_1.MAX_C) {
+        if (limit > CompressionUtil_1.MAX_BYTE) {
             limit = 0;
-            console.warn("A rate limit above ".concat(CodePointUtil_1.MAX_C, " is considered infinite."));
+            console.warn("A rate limit above ".concat(CompressionUtil_1.MAX_BYTE, " is considered infinite."));
         }
         this.serverRateLimit = limit;
     };
+    /**
+     * Enables a packet for all current & new clients.
+     * @param tag The tag of the packet
+     */
+    SonicWSServer.prototype.enablePacket = function (tag) {
+        this.clientPackets.getPacket(tag).defaultEnabled = true;
+        this.connections.forEach(function (socket) { return socket.enablePacket(tag); });
+    };
+    /**
+     * Disables a packet for all current & new clients.
+     * @param tag The tag of the packet
+     */
+    SonicWSServer.prototype.disablePacket = function (tag) {
+        this.clientPackets.getPacket(tag).defaultEnabled = false;
+        this.connections.forEach(function (socket) { return socket.disablePacket(tag); });
+    };
     /**
      * Listens for whenever a client connects
      * @param runner Called when ready
@@ -220,6 +244,24 @@ var SonicWSServer = /** @class */ (function () {
         }
         this.broadcastFiltered.apply(this, __spreadArray([tag, function () { return true; }], values, false));
     };
+    /**
+     * Sets the maximum amount of users that can be connected; will tell about wss.setQueueTime(time). Defaults to unlimited
+     * @param amount The amount of users that can be connected
+     */
+    SonicWSServer.prototype.setMaxConnections = function (amount) {
+        if (amount < 1)
+            throw new Error("Max connections must be at least 1: ".concat(amount));
+        this.maxConnections = amount;
+    };
+    /**
+     * Sets the time in milliseconds for queued users to attempt to retry; applies for wss.setMaxConnections(amt). Defaults to 10,000ms
+     * @param time The requested reconnect time
+     */
+    SonicWSServer.prototype.setQueueTimeMs = function (time) {
+        if (time < 1)
+            throw new Error("Queue time must be at least 1ms: ".concat(time, "ms"));
+        this.queueTime = time;
+    };
     /**
      * @returns All users connected to the socket
      */

package/dist/ws/util/ArrayUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/dist/ws/util/BufferUtil.d.ts

@@ -0,0 +1,4 @@
+export declare function toPacketBuffer(code: number, data: number[]): Uint8Array;
+export declare function splitBuffer(arr: Uint8Array, x: number): number[][];
+export declare function as8String(data: Uint8Array): string;
+export declare function as16String(data: Uint8Array): string;

package/dist/ws/util/BufferUtil.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Copyright 2025 Lily (liwybloc)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPacketBuffer = toPacketBuffer;
+exports.splitBuffer = splitBuffer;
+exports.as8String = as8String;
+exports.as16String = as16String;
+var ArrayUtil_1 = require("./ArrayUtil");
+var CompressionUtil_1 = require("./packets/CompressionUtil");
+var StringUtil_1 = require("./StringUtil");
+function toPacketBuffer(code, data) {
+    var buffer = new Uint8Array(1 + data.length);
+    buffer[0] = code;
+    buffer.set(data, 1);
+    return buffer;
+}
+function splitBuffer(arr, x) {
+    return (0, ArrayUtil_1.splitArray)(Array.from(arr), x);
+}
+function as8String(data) {
+    return (0, StringUtil_1.convertCharCodes)(Array.from(data));
+}
+function as16String(data) {
+    var codePoints = splitBuffer(data, 2).map(function (short) { return (0, CompressionUtil_1.fromShort)(short); });
+    return (0, StringUtil_1.convertCodePoints)(codePoints);
+}

package/dist/ws/util/StringUtil.d.ts

@@ -0,0 +1,6 @@
+export declare const SURROGATE_MIN = 55296, SURROGATE_MAX = 57343, MAX_UTF8 = 65535, MAX_UTF16 = 1114111;
+export declare function processCharCodes(text: string): number[];
+export declare function convertCharCodes(codes: number[]): string;
+export declare function splitCodePoint(codePoint: number): number[];
+export declare function pairToPoint(highSurrogate: number, lowSurrogate: number): number;
+export declare function convertCodePoints(codePoints: number[]): string;

package/dist/ws/util/StringUtil.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ * Copyright 2025 Lily (liwybloc)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_UTF16 = exports.MAX_UTF8 = exports.SURROGATE_MAX = exports.SURROGATE_MIN = void 0;
+exports.processCharCodes = processCharCodes;
+exports.convertCharCodes = convertCharCodes;
+exports.splitCodePoint = splitCodePoint;
+exports.pairToPoint = pairToPoint;
+exports.convertCodePoints = convertCodePoints;
+exports.SURROGATE_MIN = 0xD800, exports.SURROGATE_MAX = 0xDFFF, exports.MAX_UTF8 = 0xFFFF, exports.MAX_UTF16 = 0x10FFFF;
+function processCharCodes(text) {
+    return Array.from(text, function (char) { return char.codePointAt(0); });
+}
+function convertCharCodes(codes) {
+    return String.fromCodePoint.apply(String, codes);
+}
+function isSurrogate(x) {
+    return x >= exports.SURROGATE_MIN && x <= exports.SURROGATE_MAX;
+}
+function splitCodePoint(codePoint) {
+    if (codePoint <= exports.MAX_UTF8) {
+        if (isSurrogate(codePoint))
+            throw new Error("Cannot send code point ".concat(codePoint, "; must be out of range ").concat(exports.SURROGATE_MIN, " and ").concat(exports.SURROGATE_MAX));
+        return [codePoint];
+    }
+    if (codePoint > exports.MAX_UTF16)
+        throw new Error("Cannot send code ".concat(codePoint));
+    codePoint -= 0x10000;
+    var highSurrogate = (codePoint >> 10) + 0xD800;
+    var lowSurrogate = (codePoint & 0x3FF) + 0xDC00;
+    return [highSurrogate, lowSurrogate];
+}
+function pairToPoint(highSurrogate, lowSurrogate) {
+    return (highSurrogate - 0xD800) * 0x400 + (lowSurrogate - 0xDC00) + 0x10000;
+}
+function convertCodePoints(codePoints) {
+    var result = [];
+    for (var i = 0; i < codePoints.length; i++) {
+        var x = codePoints[i];
+        if (isSurrogate(x)) {
+            if (i == codePoints.length - 1)
+                throw new Error("Terminated surrogate pair; index ".concat(i, " value ").concat(x));
+            var pair = codePoints[++i];
+            if (!isSurrogate(pair))
+                throw new Error("Terminated surrogate pair; index ".concat(i, " value ").concat(x, " next value ").concat(pair));
+            result.push(pairToPoint(x, pair));
+            continue;
+        }
+        result.push(x);
+    }
+    return convertCharCodes(result);
+}

package/dist/ws/util/enums/EnumHandler.d.ts

@@ -1,5 +1,5 @@
 import { EnumPackage } from "./EnumType";
-export declare const MAX_ENUM_SIZE = 128;
+export declare const MAX_ENUM_SIZE = 255;
 export declare const ENUM_TAG_TO_KEY: Record<string, Record<any, number>>;
 export declare const ENUM_KEY_TO_TAG: Record<string, Record<number, any>>;
 /**
@@ -15,6 +15,5 @@ export declare function DefineEnum(tag: string, values: any[]): EnumPackage;
  * @param value The value to send
  * @returns A transmittable enum value
  */
-export declare function WrapEnum(tag: string, value: any): string;
+export declare function WrapEnum(tag: string, value: any): number;
 export declare function fromIndex(tag: string, index: number): string;
-export declare function fromEncoded(tag: string, encoded: string): string;

package/dist/ws/util/enums/EnumHandler.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,9 +19,9 @@ exports.ENUM_KEY_TO_TAG = exports.ENUM_TAG_TO_KEY = exports.MAX_ENUM_SIZE = void
 exports.DefineEnum = DefineEnum;
 exports.WrapEnum = WrapEnum;
 exports.fromIndex = fromIndex;
-exports.fromEncoded = fromEncoded;
+var CompressionUtil_1 = require("../packets/CompressionUtil");
 var EnumType_1 = require("./EnumType");
-exports.MAX_ENUM_SIZE = 0x80;
+exports.MAX_ENUM_SIZE = CompressionUtil_1.MAX_BYTE;
 exports.ENUM_TAG_TO_KEY = {};
 exports.ENUM_KEY_TO_TAG = {};
 /**
@@ -46,11 +46,8 @@ function DefineEnum(tag, values) {
 function WrapEnum(tag, value) {
     if (!(value in exports.ENUM_TAG_TO_KEY[tag]))
         throw new Error("Value \"".concat(value, "\" does not exist in enum \"").concat(tag, "\""));
-    return String.fromCharCode(exports.ENUM_TAG_TO_KEY[tag][value]);
+    return exports.ENUM_TAG_TO_KEY[tag][value];
 }
 function fromIndex(tag, index) {
     return exports.ENUM_KEY_TO_TAG[tag][index];
 }
-function fromEncoded(tag, encoded) {
-    return fromIndex(tag, encoded.charCodeAt(0));
-}

package/dist/ws/util/enums/EnumType.d.ts

@@ -1,7 +1,8 @@
 export declare const TYPE_CONVERSION_MAP: Record<number, (data: string) => string | number | boolean | undefined | null>;
+export type EnumValue = string | number | boolean | undefined | null;
 export declare class EnumPackage {
     tag: string;
-    values: any[];
+    values: EnumValue[];
     constructor(tag: string, values: any[]);
-    serialize(): string;
+    serialize(): number[];
 }

package/dist/ws/util/enums/EnumType.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (cutelittlelily)
+ * Copyright 2025 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,8 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumPackage = exports.TYPE_CONVERSION_MAP = void 0;
+var StringUtil_1 = require("../StringUtil");
 var TYPE_INDEX_MAP = {
     'string': 0,
     'number': 1,
@@ -42,15 +52,16 @@ var EnumPackage = /** @class */ (function () {
         this.values = values;
     }
     EnumPackage.prototype.serialize = function () {
-        return String.fromCharCode(this.tag.length + 1) + // tag length
-            this.tag + // tag
-            String.fromCharCode(this.values.length + 1) + // value count
-            this.values.map(function (v) {
-                return String.fromCharCode(String(v).length + 1) + // value length
-                    String.fromCharCode(getTypedIndex(v) + 1) + // value type
-                    v;
-            } // value
-            ).join("");
+        var tag = (0, StringUtil_1.processCharCodes)(this.tag);
+        return __spreadArray(__spreadArray(__spreadArray([
+            this.tag.length
+        ], tag, true), [
+            this.values.length
+        ], false), this.values.map(function (v) { return __spreadArray([
+            String(v).length, // value length
+            getTypedIndex(v)
+        ], (0, StringUtil_1.processCharCodes)(String(v)) // value
+        , true); }).flat(), true);
     };
     return EnumPackage;
 }());

package/dist/ws/util/packets/BatchHelper.d.ts

@@ -1,11 +1,15 @@
-import { SonicWSCore } from "../../client/core/ClientCore";
+import { Connection } from "../../Connection";
 import { Packet } from "../../packets/Packets";
 import { SonicWSConnection } from "../../server/SonicWSConnection";
 import { PacketHolder } from "./PacketHolder";
 export declare class BatchHelper {
-    batchedData: Record<string, string[]>;
-    registerSendPackets(packetHolder: PacketHolder, clazz: SonicWSCore | SonicWSConnection): void;
-    initiateBatch(code: string, time: number, clazz: SonicWSCore | SonicWSConnection): void;
-    batchPacket(code: string, data: string): void;
-    static unravelBatch(packet: Packet, data: string, socket: SonicWSConnection | null): any[] | string;
+    private batchTimes;
+    private batchTimeouts;
+    private batchedData;
+    private conn;
+    registerSendPackets(packetHolder: PacketHolder, conn: Connection): void;
+    private initiateBatch;
+    private startBatch;
+    batchPacket(code: number, data: number[]): void;
+    static unravelBatch(packet: Packet, data: Uint8Array, socket: SonicWSConnection | null): any[] | string;
 }