sonic-ws 1.0.6 → 1.1.1-patch

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2025 Lily (liwybloc)
+Copyright 2026 Lily (liwybloc)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 You may not use this software except in compliance with the License.

package/README.md

@@ -18,9 +18,11 @@ Developer Friendly:
 
 Security:
 - Tamper-proof; any invalid packet instantly causes closure, and tampering becomes incredibly difficult
+- Basic but immensely effective anti-tampering for browser clients
 - Built-in ability for handshake packets, preventing repetitive initiation checks in listeners (for example, removes if(!init) everywhere)
 - Built-in rate limiting for packets; ability for global send & receive, alongside per-packet rate limiting
 - Built-in disabling & enabling of packets to prevent abuse
+- Prevents any race conditions; your callbacks will not be called until they finish.
 
 Performance & Scaling:
 - Can handle very large packets in microseconds
@@ -35,7 +37,7 @@ Developer Experience:
 - Many data types to maximize speed, clarity, bandwidth, and security
 - Debug tools for socket ids, byte size, data logging, etc. for troubleshooting
 - Very minimal learning curve, easy to work in
-- JSDoc's for understanding
+- JSDoc's for understanding; immensely intuitive (personally, I took a break for half a year and came back and snapped right back in)
 
 Whether you're making a real-time game, a dashboard, a distributed system, or anything else, SonicWS gets you safe, structured packets, fast.
 
@@ -109,6 +111,10 @@ ws.on_close((event) => {
 
 ## KNOWN ISSUES
 
+Some weird error messages when invalid inputs are in like CreatePacket() and stuff
+
 ## PLANNED FEATURES
 
-Better error handling
+Better error handling
+
+ZLib/gzip compression

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/version.d.ts

@@ -1,5 +1,5 @@
 /** Current protocol version */
-export declare const VERSION = 13;
+export declare const VERSION = 15;
 /** Server data suffix */
 export declare const SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

package/dist/version.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SERVER_SUFFIX_NUMS = exports.SERVER_SUFFIX = exports.VERSION = void 0;
 const StringUtil_1 = require("./ws/util/StringUtil");
 /** Current protocol version */
-exports.VERSION = 13;
+exports.VERSION = 15;
 /** Server data suffix */
 exports.SERVER_SUFFIX = "SWS";
 /** Server data suffix in array */

package/dist/ws/Connection.d.ts

@@ -3,17 +3,18 @@
  */
 export interface Connection {
     /**
-     * List of timers, in object just for efficiency.
+     * List of timers.
      * For internal use only.
      */
-    _timers: Record<number, number>;
+    _timers: Record<number, [number, (closed: boolean) => void, boolean]>;
     /**
      * 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)
+     * @param callOnClose If the callback should be fired anyways when the socket closes
      * @returns The timeout id to be used with socket.clearInterval(id)
      */
-    setTimeout(call: () => void, time: number): number;
+    setTimeout(call: () => void, time: number, callOnClose: boolean): number;
     /**
      * Sets an interval that will automatically end when the socket closes
      * @param call The function to call

package/dist/ws/Connection.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/client/core/ClientCore.d.ts

@@ -21,12 +21,18 @@ export declare abstract class SonicWSCore implements Connection {
     private batcher;
     private bufferHandler;
     id: number;
-    _timers: Record<number, number>;
+    _timers: Record<number, [number, (closed: boolean) => void, boolean]>;
+    private asyncData;
+    private asyncMap;
     constructor(ws: WebSocket, bufferHandler: (val: MessageEvent) => Promise<Uint8Array>);
     private reading;
     private serverKeyHandler;
     private invalidPacket;
-    private listenPacket;
+    private listenLock;
+    private packetQueue;
+    listenPacket(data: string | [any[], boolean], code: number): void;
+    private isAsync;
+    private enqueuePacket;
     private messageHandler;
     protected listen(key: string, listener: (data: any[]) => void): void;
     /**
@@ -62,9 +68,8 @@ export declare abstract class SonicWSCore implements Connection {
      */
     on(tag: string, listener: (value: any[]) => void): void;
     raw_send(data: Uint8Array): void;
-    setTimeout(call: () => void, time: number): number;
-    setInterval(call: () => void, time: number): number;
-    private setTimer;
+    setTimeout(call: () => void, time: number, callOnClose?: boolean): number;
+    setInterval(call: () => void, time: number, callOnClose?: boolean): number;
     clearTimeout(id: number): void;
     clearInterval(id: number): void;
     close(code?: number, reason?: string): void;

package/dist/ws/client/core/ClientCore.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,6 +36,8 @@ class SonicWSCore {
     bufferHandler;
     id = -1;
     _timers = {};
+    asyncData = {};
+    asyncMap = {};
     constructor(ws, bufferHandler) {
         this.socket = ws;
         this.listeners = {
@@ -52,7 +54,11 @@ class SonicWSCore {
         this.socket.addEventListener('message', this.serverKeyHandler);
         this.socket.addEventListener('close', (event) => {
             this.listeners.close.forEach(listener => listener(event));
-            Object.values(this._timers).forEach(clearTimeout);
+            for (const [id, callback, shouldCall] of Object.values(this._timers)) {
+                this.clearTimeout(id);
+                if (shouldCall)
+                    callback(true);
+            }
         });
         this.bufferHandler = bufferHandler;
     }
@@ -80,6 +86,13 @@ class SonicWSCore {
         const skData = data.slice(valuesOff + ckLength, data.length);
         this.serverPackets.holdPackets(Packets_1.Packet.deserializeAll(skData, true));
         this.batcher.registerSendPackets(this.clientPackets, this);
+        for (const p of this.serverPackets.getPackets()) {
+            const key = this.serverPackets.getKey(p.tag);
+            this.asyncMap[key] = p.async;
+            if (p.async) {
+                this.asyncData[key] = [false, []];
+            }
+        }
         Object.keys(this.preListen).forEach(tag => this.preListen[tag].forEach(listener => {
             // print the error to console without halting execution
             if (!this.serverPackets.hasTag(tag))
@@ -97,11 +110,51 @@ class SonicWSCore {
         console.error(listened);
         throw new Error("An error occured with data from the server!! This is probably my fault.. make an issue at https://github.com/liwybloc/sonic-ws");
     }
+    listenLock = false;
+    packetQueue = [];
     listenPacket(data, code) {
         const listeners = this.listeners.event[code];
         if (!listeners)
-            return console.warn("Warn: No listener for packet " + this.serverPackets.getTag(code));
-        (0, PacketUtils_1.listenPacket)(data, listeners, this.invalidPacket);
+            return console.warn("Warn: No listener for packet " + code);
+        this.enqueuePacket(data, code, listeners);
+    }
+    isAsync(code) {
+        return this.asyncMap[code];
+    }
+    async enqueuePacket(data, code, listeners) {
+        const isAsync = this.isAsync(code);
+        let locked;
+        let packetQueue;
+        let asyncData;
+        if (isAsync) {
+            asyncData = this.asyncData[code];
+            locked = asyncData[0];
+            packetQueue = asyncData[1];
+        }
+        else {
+            locked = this.listenLock;
+            packetQueue = this.packetQueue;
+        }
+        if (locked) {
+            packetQueue.push([data, code]);
+            return;
+        }
+        if (isAsync)
+            asyncData[0] = true;
+        else
+            this.listenLock = true;
+        let currentData = data;
+        let currentCode = code;
+        while (true) {
+            await (0, PacketUtils_1.listenPacket)(currentData, listeners, this.invalidPacket);
+            if (packetQueue.length === 0)
+                break;
+            [currentData, currentCode] = packetQueue.shift();
+        }
+        if (isAsync)
+            asyncData[0] = false;
+        else
+            this.listenLock = false;
     }
     async messageHandler(event) {
         const data = await this.bufferHandler(event);
@@ -192,22 +245,19 @@ class SonicWSCore {
         this.listeners.send.forEach(d => d(data));
         this.socket.send(data);
     }
-    setTimeout(call, time) {
+    setTimeout(call, time, callOnClose = false) {
         const timeout = setTimeout(() => {
             call();
             this.clearTimeout(timeout);
         }, time);
-        this.setTimer(timeout);
+        this._timers[timeout] = [timeout, call, callOnClose];
         return timeout;
     }
-    setInterval(call, time) {
+    setInterval(call, time, callOnClose = false) {
         const interval = setInterval(call, time);
-        this.setTimer(interval);
+        this._timers[interval] = [interval, call, callOnClose];
         return interval;
     }
-    setTimer(id) {
-        this._timers[id] = id;
-    }
     clearTimeout(id) {
         clearTimeout(id);
         delete this._timers[id];

package/dist/ws/client/node/ClientNode.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/packets/PacketProcessors.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/packets/PacketType.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/packets/Packets.d.ts

@@ -5,8 +5,9 @@ export type ValidatorFunction = ((socket: SonicWSConnection, values: any) => boo
 export type ConvertType<T> = T extends EnumPackage ? PacketType.ENUMS : T;
 type ImpactType<T extends (PacketType | readonly PacketType[]), K> = T extends PacketType[] ? K[] : K;
 export declare class Packet<T extends (PacketType | readonly PacketType[])> {
-    readonly tag: string;
     defaultEnabled: boolean;
+    readonly tag: string;
+    readonly async: boolean;
     readonly maxSize: number;
     readonly minSize: number;
     readonly type: T;
@@ -24,7 +25,7 @@ export declare class Packet<T extends (PacketType | readonly PacketType[])> {
     private sendProcessor;
     private validator;
     processReceive: (data: Uint8Array, validationResult: any) => any;
-    processSend: (data: any[]) => number[];
+    processSend: (data: any[]) => Uint8Array;
     validate: (data: Uint8Array) => boolean;
     customValidator: ((socket: SonicWSConnection, ...values: any[]) => boolean) | null;
     constructor(tag: string, schema: PacketSchema<T>, customValidator: ValidatorFunction, enabled: boolean, client: boolean);
@@ -44,10 +45,11 @@ export declare class PacketSchema<T extends (PacketType | readonly PacketType[])
     enumData: EnumPackage[];
     dontSpread: boolean;
     autoFlatten: boolean;
+    async: boolean;
     object: boolean;
     constructor(object: boolean);
     testObject(): this is PacketSchema<PacketType[]>;
-    static single<T extends PacketType | EnumPackage>(type: T, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema<ConvertType<T>>;
-    static object<T extends readonly (PacketType | EnumPackage)[]>(types: T, dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number): PacketSchema<ConvertType<T[number]>[]>;
+    static single<T extends PacketType | EnumPackage>(type: T, dataMax: number, dataMin: number, dontSpread: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number, async: boolean): PacketSchema<ConvertType<T>>;
+    static object<T extends readonly (PacketType | EnumPackage)[]>(types: T, dataMaxes: number[], dataMins: number[], dontSpread: boolean, autoFlatten: boolean, dataBatching: number, maxBatchSize: number, rateLimit: number, async: boolean): PacketSchema<ConvertType<T[number]>[]>;
 }
 export {};

package/dist/ws/packets/Packets.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,8 +25,9 @@ const PacketType_1 = require("./PacketType");
 const BufferUtil_1 = require("../util/BufferUtil");
 const StringUtil_1 = require("../util/StringUtil");
 class Packet {
-    tag;
     defaultEnabled;
+    tag;
+    async;
     maxSize;
     minSize;
     type;
@@ -51,6 +52,7 @@ class Packet {
         this.tag = tag;
         this.defaultEnabled = enabled;
         this.client = client;
+        this.async = schema.async;
         this.enumData = schema.enumData;
         this.rateLimit = schema.rateLimit;
         this.dontSpread = schema.dontSpread;
@@ -85,7 +87,7 @@ class Packet {
             this.sendProcessor = (0, PacketProcessors_1.createSendProcessor)(this.type);
         }
         this.processReceive = (data, validationResult) => this.receiveProcessor(data, validationResult, 0);
-        this.processSend = (data) => this.sendProcessor(data);
+        this.processSend = (data) => new Uint8Array(this.sendProcessor(data));
         this.validate = (data) => this.validator(data, 0);
         this.customValidator = customValidator;
     }
@@ -119,6 +121,7 @@ class Packet {
         const sharedData = [
             this.tag.length, ...(0, StringUtil_1.processCharCodes)(this.tag),
             this.dontSpread ? 1 : 0,
+            this.async ? 1 : 0,
             this.dataBatching,
             this.enumData.length, ...this.enumData.map(x => x.serialize()).flat(),
         ];
@@ -160,6 +163,8 @@ class Packet {
         const tag = (0, BufferUtil_1.as8String)(data.slice(offset, offset += tagLength));
         // then read dont spread, go up 1
         const dontSpread = data[offset++] == 1;
+        // read async
+        const async = data[offset++] == 1;
         // read batching, up 1
         const dataBatching = data[offset++];
         // read enum length, up 1
@@ -205,7 +210,7 @@ class Packet {
             let index = 0;
             const finalTypes = types.map(x => x == PacketType_1.PacketType.ENUMS ? enums[index++] : x); // convert enums to their enum packages
             // make schema
-            const schema = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, -1, -1);
+            const schema = PacketSchema.object(finalTypes, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, -1, -1, async);
             return [
                 new Packet(tag, schema, null, false, client),
                 // +1 to go next
@@ -224,7 +229,7 @@ class Packet {
         // do enum stuff
         const finalType = type == PacketType_1.PacketType.ENUMS ? enums[0] : type; // convert enum to enum package
         // make schema
-        const schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, -1, -1);
+        const schema = PacketSchema.single(finalType, dataMax, dataMin, dontSpread, dataBatching, -1, -1, async);
         return [
             new Packet(tag, schema, null, false, client),
             // +1 to go next
@@ -253,6 +258,7 @@ class PacketSchema {
     enumData = [];
     dontSpread = false;
     autoFlatten = false;
+    async = false;
     object;
     constructor(object) {
         this.object = object;
@@ -260,7 +266,7 @@ class PacketSchema {
     testObject() {
         return this.object;
     }
-    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit) {
+    static single(type, dataMax, dataMin, dontSpread, dataBatching, maxBatchSize, rateLimit, async) {
         const schema = new PacketSchema(false);
         if (typeof type == 'number') {
             schema.type = type;
@@ -277,9 +283,10 @@ class PacketSchema {
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
         schema.rateLimit = rateLimit;
+        schema.async = async;
         return schema;
     }
-    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit) {
+    static object(types, dataMaxes, dataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async) {
         if (types.length != dataMaxes.length || types.length != dataMins.length)
             throw new Error("There is an inbalance between the amount of types, data maxes, and data mins!");
         const schema = new PacketSchema(true);
@@ -300,6 +307,7 @@ class PacketSchema {
         schema.dataBatching = dataBatching;
         schema.maxBatchSize = maxBatchSize;
         schema.rateLimit = rateLimit;
+        schema.async = async;
         return schema;
     }
 }

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

@@ -19,11 +19,17 @@ export declare class SonicWSConnection implements Connection {
     handshakeComplete: boolean;
     /** The index of the connection; unique for all connected, recycles old disconnected ids. Should be safe for INTS_C unless you have more than 27,647 connected at once. */
     id: number;
-    _timers: Record<number, number>;
+    _timers: Record<number, [number, (closed: boolean) => void, boolean]>;
+    private asyncMap;
+    private asyncData;
+    private closed;
     constructor(socket: WS.WebSocket, host: SonicWSServer, id: number, handshakePacket: string | null, clientRateLimit: number, serverRateLimit: number);
     private parseData;
     private handshakeHandler;
     private invalidPacket;
+    private isAsync;
+    private listenLock;
+    private packetQueue;
     private listenPacket;
     private messageHandler;
     /**
@@ -55,7 +61,7 @@ export declare class SonicWSConnection implements Connection {
     /**
      * For internal use.
      */
-    send_processed(code: number, data: number[], packet: Packet<any>): void;
+    send_processed(code: number, data: Uint8Array, packet: Packet<any>): void;
     /**
      * Sends a packet with the tag and values
      * @param tag The tag to send
@@ -80,8 +86,8 @@ export declare class SonicWSConnection implements Connection {
     togglePrint(): void;
     raw_send(data: Uint8Array): void;
     close(code?: number, reason?: string | Buffer): void;
-    setTimeout(call: () => void, time: number): number;
-    setInterval(call: () => void, time: number): number;
+    setTimeout(call: () => void, time: number, callOnClose?: boolean): number;
+    setInterval(call: () => void, time: number, callOnClose?: boolean): number;
     clearTimeout(id: number): void;
     clearInterval(id: number): void;
     /**

package/dist/ws/server/SonicWSConnection.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -80,15 +80,22 @@ class SonicWSConnection {
     /** The index of the connection; unique for all connected, recycles old disconnected ids. Should be safe for INTS_C unless you have more than 27,647 connected at once. */
     id;
     _timers = {};
+    asyncMap = {};
+    asyncData = {};
+    closed = false;
     constructor(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
         this.socket = socket;
         this.host = host;
         this.id = id;
         this.handshakePacket = handshakePacket;
         this.listeners = {};
-        for (const key of host.clientPackets.getTags()) {
-            this.listeners[key] = [];
-            this.enabledPackets[key] = host.clientPackets.getPacket(key).defaultEnabled;
+        for (const tag of host.clientPackets.getTags()) {
+            this.listeners[tag] = [];
+            const pack = host.clientPackets.getPacket(tag);
+            this.enabledPackets[tag] = pack.defaultEnabled;
+            this.asyncMap[tag] = pack.async;
+            if (pack.async)
+                this.asyncData[tag] = [false, []];
         }
         this.setInterval = this.setInterval.bind(this);
         this.batcher = new BatchHelper_1.BatchHelper();
@@ -108,7 +115,12 @@ class SonicWSConnection {
             this.socket.addEventListener('message', this.handshakeLambda);
         }
         this.socket.on('close', () => {
-            Object.values(this._timers).forEach(clearTimeout);
+            this.closed = true;
+            for (const [id, callback, shouldCall] of Object.values(this._timers)) {
+                this.clearTimeout(id);
+                if (shouldCall)
+                    callback(true);
+            }
         });
     }
     parseData(event) {
@@ -157,8 +169,45 @@ class SonicWSConnection {
         console.log("Closure cause", listened);
         this.socket.close(4003, listened);
     }
-    listenPacket(data, tag) {
-        (0, PacketUtils_1.listenPacket)(data, this.listeners[tag], this.invalidPacket);
+    isAsync(tag) {
+        return this.asyncMap[tag];
+    }
+    listenLock = false;
+    packetQueue = [];
+    async listenPacket(data, tag) {
+        if (this.closed)
+            return;
+        const isAsync = this.isAsync(tag);
+        let locked, packetQueue, asyncData;
+        if (isAsync) {
+            asyncData = this.asyncData[tag];
+            locked = asyncData[0];
+            packetQueue = asyncData[1];
+        }
+        else {
+            locked = this.listenLock;
+            packetQueue = this.packetQueue;
+        }
+        if (locked) {
+            packetQueue.push([data, tag]);
+            return;
+        }
+        if (isAsync)
+            asyncData[0] = true;
+        else
+            this.listenLock = true;
+        let currentData = data;
+        let currentTag = tag;
+        while (true) {
+            await (0, PacketUtils_1.listenPacket)(currentData, this.listeners[currentTag], this.invalidPacket);
+            if (packetQueue.length === 0)
+                break;
+            [currentData, currentTag] = packetQueue.shift();
+        }
+        if (isAsync)
+            asyncData[0] = false;
+        else
+            this.listenLock = false;
     }
     messageHandler(data) {
         if (data == null)
@@ -196,7 +245,7 @@ class SonicWSConnection {
      * @returns If it's closed or not
      */
     isClosed() {
-        return this.socket.readyState == WS.CLOSED;
+        return this.closed || this.socket.readyState == WS.CLOSED;
     }
     /**
      * Listens for when the connection closes
@@ -270,19 +319,20 @@ class SonicWSConnection {
         this.socket.send(data);
     }
     close(code = 1000, reason) {
+        this.closed = true;
         this.socket.close(code, reason);
     }
-    setTimeout(call, time) {
+    setTimeout(call, time, callOnClose = false) {
         const timeout = setTimeout(() => {
             call();
             this.clearTimeout(timeout);
         }, time);
-        this._timers[timeout] = timeout;
+        this._timers[timeout] = [timeout, call, callOnClose];
         return timeout;
     }
-    setInterval(call, time) {
+    setInterval(call, time, callOnClose = false) {
         const interval = setInterval(call, time);
-        this._timers[interval] = interval;
+        this._timers[interval] = [interval, call, callOnClose];
         return interval;
     }
     clearTimeout(id) {

package/dist/ws/server/SonicWSServer.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -94,6 +94,11 @@ class SonicWSServer {
                 this.connections.splice(this.connections.indexOf(sonicConnection), 1);
                 delete this.connectionMap[sonicConnection.id];
                 this.availableIds.push(sonicConnection.id);
+                if (this.tags.has(sonicConnection)) {
+                    for (const tag of this.tags.get(sonicConnection))
+                        this.tagsInv.get(tag)?.delete(sonicConnection);
+                    this.tags.delete(sonicConnection);
+                }
             });
         });
         fetch('https://raw.githubusercontent.com/liwybloc/sonic-ws/refs/heads/main/release/version')

package/dist/ws/util/ArrayUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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

@@ -1,4 +1,4 @@
-export declare function toPacketBuffer(code: number, data: number[]): Uint8Array;
+export declare function toPacketBuffer(code: number, data: Uint8Array): 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

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/StringUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/enums/EnumHandler.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/enums/EnumType.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/packets/BatchHelper.d.ts

@@ -10,6 +10,6 @@ export declare class BatchHelper {
     registerSendPackets(packetHolder: PacketHolder, conn: Connection): void;
     private initiateBatch;
     private startBatch;
-    batchPacket(code: number, data: number[]): void;
+    batchPacket(code: number, data: Uint8Array): void;
     static unravelBatch(packet: Packet<any>, data: Uint8Array, socket: SonicWSConnection | null): any[] | string;
 }

package/dist/ws/util/packets/BatchHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,10 +39,10 @@ class BatchHelper {
     }
     startBatch(code) {
         this.batchTimeouts[code] = this.conn.setTimeout(() => {
-            this.conn.raw_send((0, BufferUtil_1.toPacketBuffer)(code, this.batchedData[code]));
+            this.conn.raw_send((0, BufferUtil_1.toPacketBuffer)(code, new Uint8Array(this.batchedData[code])));
             this.batchedData[code] = [];
             delete this.batchTimeouts[code];
-        }, this.batchTimes[code]);
+        }, this.batchTimes[code], false);
     }
     batchPacket(code, data) {
         const batch = this.batchedData[code];

package/dist/ws/util/packets/CompressionUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/packets/PacketHolder.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 Lily (liwybloc)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,7 +43,6 @@ class PacketHolder {
         this.packetMap = {};
         if (!packets)
             return;
-        this.packets = packets;
         this.holdPackets(packets);
     }
     /** Assigns a new unique key to a tag */
@@ -57,6 +56,7 @@ class PacketHolder {
      * @param packets Array of packets to register
      */
     holdPackets(packets) {
+        this.packets = packets;
         for (const packet of packets)
             this.createKey(packet.tag), this.packetMap[packet.tag] = packet;
     }

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

@@ -9,14 +9,14 @@ import { EnumPackage } from "../enums/EnumType";
  * @param values The values
  * @returns The indexed code, the data, and the packet schema
  */
-export declare function processPacket(packets: PacketHolder, tag: string, values: any[]): [code: number, data: number[], packet: Packet<any>];
+export declare function processPacket(packets: PacketHolder, tag: string, values: any[]): [code: number, data: Uint8Array, packet: Packet<any>];
 /**
  * Calls the listener for a packet with error callback
  * @param listened The listened data
  * @param listeners The listeners to run
  * @param errorCB The callback if something goes wrong
  */
-export declare function listenPacket(listened: string | [any[], boolean], listeners: ((...values: any) => void)[], errorCB: (data: string) => void): void;
+export declare function listenPacket(listened: string | [any[], boolean], listeners: ((...values: any) => void | Promise<void>)[], errorCB: (data: string) => void): Promise<void>;
 /** Valid packet type */
 export type ArguableType = PacketType | EnumPackage;
 /** Shared packet setting types */
@@ -47,6 +47,8 @@ export type SharedPacketSettings = {
     enabled?: boolean;
     /** A validation function that is called whenever data is received. Return true for success, return false to kick socket. */
     validator?: ValidatorFunction;
+    /** If this is true, other packets will be processed even if this one isn't finished; it'll still prevent it from calling twice before this finishes though. Defaults to false. */
+    async?: boolean;
 };
 /** Settings for single-typed packets */
 export type SinglePacketSettings = SharedPacketSettings & {

package/dist/ws/util/packets/PacketUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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 @@ function processPacket(packets, tag, values) {
             }
         }
     }
-    return [code, values.length > 0 ? packet.processSend(values) : [], packet];
+    return [code, values.length > 0 ? packet.processSend(values) : new Uint8Array([]), packet];
 }
 /**
  * Calls the listener for a packet with error callback
@@ -73,16 +73,21 @@ function processPacket(packets, tag, values) {
  * @param listeners The listeners to run
  * @param errorCB The callback if something goes wrong
  */
-function listenPacket(listened, listeners, errorCB) {
-    // if invalid then ignore it and call back
-    if (typeof listened == 'string')
+async function listenPacket(listened, listeners, errorCB) {
+    if (typeof listened === 'string')
         return errorCB(listened);
     const [processed, flatten] = listened;
     try {
-        if (flatten && Array.isArray(processed))
-            listeners.forEach(l => l(...processed));
-        else
-            listeners.forEach(l => l(processed));
+        if (flatten && Array.isArray(processed)) {
+            for (const l of listeners) {
+                await l(...processed);
+            }
+        }
+        else {
+            for (const l of listeners) {
+                await l(processed);
+            }
+        }
     }
     catch (err) {
         errorCB(err);
@@ -127,7 +132,9 @@ function clampDataMin(dataMin, dataMax) {
  * @throws {Error} If the `type` is invalid.
  */
 function CreatePacket(settings) {
-    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true } = settings;
+    let { tag, type = PacketType_1.PacketType.NONE, dataMax = 1, dataMin = 1, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
+    if (!tag)
+        throw new Error("Tag not selected!");
     if (noDataRange) {
         dataMin = 0;
         dataMax = MAX_DATA_MAX;
@@ -137,7 +144,7 @@ function CreatePacket(settings) {
     if (isInvalidType(type)) {
         throw new Error(`Invalid packet type: ${type}`);
     }
-    const schema = Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread, dataBatching, maxBatchSize, rateLimit);
+    const schema = Packets_1.PacketSchema.single(type, clampDataMax(dataMax), clampDataMin(dataMin, dataMax), dontSpread, dataBatching, maxBatchSize, rateLimit, async);
     return new Packets_1.Packet(tag, schema, validator, enabled, false);
 }
 /**
@@ -148,7 +155,11 @@ function CreatePacket(settings) {
  * @throws {Error} If any type in `types` is invalid.
  */
 function CreateObjPacket(settings) {
-    let { tag, types, dataMaxes, dataMins, noDataRange = false, dontSpread = false, autoFlatten = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true } = settings;
+    let { tag, types = [], dataMaxes, dataMins, noDataRange = false, dontSpread = false, autoFlatten = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
+    if (!tag)
+        throw new Error("Tag not selected!");
+    if (types.length == 0)
+        throw new Error("Types is set to 0 length");
     for (const type of types) {
         if (!isInvalidType(type))
             continue;
@@ -170,7 +181,7 @@ function CreateObjPacket(settings) {
     }
     const clampedDataMaxes = dataMaxes.map(clampDataMax);
     const clampedDataMins = dataMins.map((m, i) => types[i] == PacketType_1.PacketType.NONE ? 0 : clampDataMin(m, clampedDataMaxes[i]));
-    const schema = Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit);
+    const schema = Packets_1.PacketSchema.object(types, clampedDataMaxes, clampedDataMins, dontSpread, autoFlatten, dataBatching, maxBatchSize, rateLimit, async);
     return new Packets_1.Packet(tag, schema, validator, enabled, false);
 }
 /**
@@ -180,7 +191,7 @@ function CreateObjPacket(settings) {
  * @returns The constructed packet structure data.
  */
 function CreateEnumPacket(settings) {
-    const { tag, enumData, dataMax = 1, dataMin = 0, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true } = settings;
+    const { tag, enumData, dataMax = 1, dataMin = 0, noDataRange = false, dontSpread = false, validator = null, dataBatching = 0, maxBatchSize = 10, rateLimit = 0, enabled = true, async = false } = settings;
     return CreatePacket({
         tag: tag,
         type: enumData,
@@ -193,6 +204,7 @@ function CreateEnumPacket(settings) {
         maxBatchSize,
         rateLimit,
         enabled,
+        async,
     });
 }
 /**

package/dist/ws/util/packets/RateHandler.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- * Copyright 2025 Lily (liwybloc)
+ * Copyright 2026 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonic-ws",
-  "version": "1.0.6",
+  "version": "1.1.1-patch",
   "description": "Ultra-lightweight, high-performance, and bandwidth efficient websocket library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,8 @@
   "author": "lily",
   "license": "Apache-2.0",
   "dependencies": {
-    "ws": "^8.18.2"
+    "ws": "^8.18.2",
+    "zstd-codec": "^0.1.5"
   },
   "devDependencies": {
     "@types/node": "^24.2.1",