sonic-ws 1.3.2 → 1.3.3

package/dist/ws/packets/Packets.js

@@ -1,6 +1,277 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * 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:!0}),exports.PacketSchema=exports.Packet=void 0;const t=require("../util/enums/EnumHandler"),e=require("../util/enums/EnumType"),a=require("../util/packets/CompressionUtil"),s=require("../util/packets/PacketUtils"),i=require("./PacketProcessors"),r=require("./PacketType"),n=require("../util/StringUtil");class o{defaultEnabled;tag;maxSize;minSize;type;enumData;dataMax;dataMin;dataBatching;maxBatchSize;dontSpread;autoFlatten;rateLimit;async;rereference;gzipCompression;object;client;receiveProcessor;sendProcessor;validator;processReceive;processSend;validate;customValidator;lastReceived={};lastSent={};constructor(t,e,a,s,n){if(this.tag=t,this.defaultEnabled=s,this.client=n,this.async=e.async,this.enumData=e.enumData,this.rateLimit=e.rateLimit,this.dontSpread=e.dontSpread,this.autoFlatten=e.autoFlatten,this.rereference=e.rereference,this.dataBatching=e.dataBatching,this.maxBatchSize=n?1/0:e.maxBatchSize,this.gzipCompression=e.gzipCompression,this.object=e.object,this.type=e.type,this.dataMax=e.dataMax,this.dataMin=e.dataMin,e.testObject(this)){this.maxSize=this.minSize=this.type.length;for(let t=0;t<this.type.length;t++)this.type[t]==r.PacketType.NONE&&(this.dataMax[t]=this.dataMin[t]=0);this.receiveProcessor=(0,i.createObjReceiveProcessor)(this),this.sendProcessor=(0,i.createObjSendProcessor)(this),this.validator=(0,i.createObjValidator)(this)}else this.maxSize=this.dataMax,this.minSize=this.dataMin,this.type==r.PacketType.NONE&&(this.dataMax=this.dataMin=0),this.receiveProcessor=(0,i.createReceiveProcessor)(this.type,this.enumData,this.dataMax),this.sendProcessor=(0,i.createSendProcessor)(this.type,this.gzipCompression,0!=this.dataBatching),this.validator=(0,i.createValidator)(this.type,this.dataMax,this.dataMin,this,this.gzipCompression);this.processReceive=(t,e)=>this.receiveProcessor(t,e,0),this.processSend=async e=>new Uint8Array(await this.sendProcessor(t,e)),this.validate=t=>this.validator(t,0),this.customValidator=a}async listen(t,e){try{const[a,i]=await this.validate(t);if(!this.client&&!1===i)return"Invalid packet";const r=this.processReceive(a,i),n=this.autoFlatten?(0,s.UnFlattenData)(r):r;if(null!=this.customValidator)if(this.dontSpread){if(!this.customValidator(e,n))return"Didn't pass custom validator"}else if(!this.customValidator(e,...n))return"Didn't pass custom validator";return[n,!this.dontSpread]}catch(t){return console.error("There was an error processing the packet! This is probably my fault... report at https://github.com/liwybloc/sonic-ws",t),"Error: "+t}}serialize(){const t=[this.tag.length,...(0,n.processCharCodes)(this.tag),(0,a.compressBools)([this.dontSpread,this.async,this.object,this.autoFlatten,this.gzipCompression,this.rereference]),this.dataBatching,this.enumData.length,...this.enumData.map(t=>t.serialize()).flat()];return this.object?[...t,this.maxSize,...this.dataMax.map(a.convertVarInt).flat(),...this.dataMin.map(a.convertVarInt).flat(),...this.type]:[...t,...(0,a.convertVarInt)(this.dataMax),...(0,a.convertVarInt)(this.dataMin),this.type]}static readVarInts(t,e,s){const i=[];for(let r=0;r<s;r++){const[s,r]=(0,a.readVarInt)(t,e);e=s,i.push(r)}return[i,e]}static deserialize(s,i,c){const d=i,l=s[i++],p=(0,n.as8String)(s.slice(i,i+=l)),[u,m,y,S,g,P]=(0,a.decompressBools)(s[i++]),f=s[i++],M=s[i++],v=[];for(let a=0;a<M;a++){const a=s[i++],r=(0,n.as8String)(s.slice(i,i+=a)),o=s[i++],c=[];for(let t=0;t<o;t++){const t=s[i++],a=s[i++],r=(0,n.as8String)(s.slice(i,i+=t));c.push(e.TYPE_CONVERSION_MAP[a](r))}v.push((0,t.DefineEnum)(r,c))}if(y){const t=s[i++],[e,a]=this.readVarInts(s,i,t);i=a;const[n,l]=this.readVarInts(s,i,t);i=l;const y=Array.from(s.slice(i,i+=t));let P=0;const M=y.map(t=>t==r.PacketType.ENUMS?v[P++]:t),x=new h(!0,M,m,n,e,-1,u,S,!1,f,-1,g);return[new o(p,x,null,!1,c),i-d]}const[x,z]=(0,a.readVarInt)(s,i);i=x;const[b,V]=(0,a.readVarInt)(s,i);i=b;const k=s[i++],j=k==r.PacketType.ENUMS?v[0]:k,B=new h(!1,j,m,V,z,-1,u,!1,P,f,-1,g);return[new o(p,B,null,!1,c),i-d]}static deserializeAll(t,e){const a=[];let s=0;for(;s<t.length;){const[i,r]=this.deserialize(t,s,e);a.push(i),s+=r}return a}}exports.Packet=o;const c=(t,a)=>t instanceof e.EnumPackage?(a.push(t),r.PacketType.ENUMS):t;class h{type;enumData=[];dataMax;dataMin;dataBatching;maxBatchSize;rateLimit;dontSpread=!1;autoFlatten=!1;async=!1;rereference=!1;gzipCompression=!1;object;constructor(t,e,a,s,i,r,n,o,h,d,l,p){this.object=t,this.async=a,this.dataMin=s,this.dataMax=i,this.rateLimit=r,this.dontSpread=n,this.autoFlatten=o,this.rereference=h,this.dataBatching=d,this.maxBatchSize=l,this.gzipCompression=p,this.type=t?e.map(t=>c(t,this.enumData)):c(e,this.enumData)}testObject(t){return this.object}}exports.PacketSchema=h;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PacketSchema = exports.Packet = void 0;
+const EnumHandler_1 = require("../util/enums/EnumHandler");
+const EnumType_1 = require("../util/enums/EnumType");
+const CompressionUtil_1 = require("../util/packets/CompressionUtil");
+const PacketUtils_1 = require("../util/packets/PacketUtils");
+const PacketProcessors_1 = require("./PacketProcessors");
+const PacketType_1 = require("./PacketType");
+const StringUtil_1 = require("../util/StringUtil");
+class Packet {
+    defaultEnabled;
+    tag;
+    maxSize;
+    minSize;
+    type;
+    enumData;
+    dataMax;
+    dataMin;
+    dataBatching;
+    maxBatchSize;
+    dontSpread;
+    autoFlatten;
+    rateLimit;
+    async;
+    rereference;
+    gzipCompression;
+    object;
+    client;
+    receiveProcessor;
+    sendProcessor;
+    validator;
+    processReceive;
+    processSend;
+    validate;
+    customValidator;
+    lastReceived = {};
+    lastSent = {};
+    constructor(tag, schema, customValidator, enabled, client) {
+        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;
+        this.autoFlatten = schema.autoFlatten;
+        this.rereference = schema.rereference;
+        this.dataBatching = schema.dataBatching;
+        this.maxBatchSize = client ? Infinity : schema.maxBatchSize;
+        this.gzipCompression = schema.gzipCompression;
+        this.object = schema.object;
+        this.type = schema.type;
+        this.dataMax = schema.dataMax;
+        this.dataMin = schema.dataMin;
+        if (schema.testObject(this)) {
+            this.maxSize = this.minSize = this.type.length;
+            for (let i = 0; i < this.type.length; i++)
+                if (this.type[i] == PacketType_1.PacketType.NONE)
+                    this.dataMax[i] = this.dataMin[i] = 0;
+            this.receiveProcessor = (0, PacketProcessors_1.createObjReceiveProcessor)(this);
+            this.sendProcessor = (0, PacketProcessors_1.createObjSendProcessor)(this);
+            this.validator = (0, PacketProcessors_1.createObjValidator)(this);
+        }
+        else if (((_) => true)(this)) {
+            this.maxSize = this.dataMax;
+            this.minSize = this.dataMin;
+            if (this.type == PacketType_1.PacketType.NONE)
+                this.dataMax = this.dataMin = 0;
+            this.receiveProcessor = (0, PacketProcessors_1.createReceiveProcessor)(this.type, this.enumData, this.dataMax);
+            this.sendProcessor = (0, PacketProcessors_1.createSendProcessor)(this.type, this.gzipCompression, this.dataBatching != 0);
+            this.validator = (0, PacketProcessors_1.createValidator)(this.type, this.dataMax, this.dataMin, this, this.gzipCompression);
+        }
+        else
+            throw '';
+        this.processReceive = (data, validationResult) => this.receiveProcessor(data, validationResult, 0);
+        this.processSend = async (data) => new Uint8Array(await this.sendProcessor(tag, data));
+        this.validate = (data) => this.validator(data, 0);
+        this.customValidator = customValidator;
+    }
+    async listen(value, socket) {
+        try {
+            const [dcData, validationResult] = await this.validate(value);
+            // holy shit i used === to fix another bug
+            if (!this.client && validationResult === false)
+                return "Invalid packet";
+            const processed = this.processReceive(dcData, validationResult);
+            const useableData = this.autoFlatten ? (0, PacketUtils_1.UnFlattenData)(processed) : processed;
+            if (this.customValidator != null) {
+                if (!this.dontSpread) {
+                    if (!this.customValidator(socket, ...useableData))
+                        return "Didn't pass custom validator";
+                }
+                else {
+                    if (!this.customValidator(socket, useableData))
+                        return "Didn't pass custom validator";
+                }
+            }
+            return [useableData, !this.dontSpread];
+        }
+        catch (err) {
+            console.error("There was an error processing the packet! This is probably my fault... report at https://github.com/liwybloc/sonic-ws", err);
+            return "Error: " + err;
+        }
+    }
+    serialize() {
+        // shared values for both
+        const sharedData = [
+            this.tag.length, ...(0, StringUtil_1.processCharCodes)(this.tag),
+            (0, CompressionUtil_1.compressBools)([this.dontSpread, this.async, this.object, this.autoFlatten, this.gzipCompression, this.rereference]),
+            this.dataBatching,
+            this.enumData.length, ...this.enumData.map(x => x.serialize()).flat(),
+        ];
+        // single-value packet (not an object schema)
+        if (!this.object) {
+            return [
+                ...sharedData, // shared
+                ...(0, CompressionUtil_1.convertVarInt)(this.dataMax), // the data max
+                ...(0, CompressionUtil_1.convertVarInt)(this.dataMin), // the data min
+                this.type,
+            ];
+        }
+        // object packet
+        return [
+            ...sharedData,
+            this.maxSize, // size
+            ...this.dataMax.map(CompressionUtil_1.convertVarInt).flat(), // all data maxes, serialized
+            ...this.dataMin.map(CompressionUtil_1.convertVarInt).flat(), // all data mins, serialized
+            ...this.type, // all types
+        ];
+    }
+    static readVarInts(data, offset, size) {
+        const res = [];
+        for (let i = 0; i < size; i++) {
+            const [off, varint] = (0, CompressionUtil_1.readVarInt)(data, offset);
+            offset = off;
+            res.push(varint);
+        }
+        return [res, offset];
+    }
+    static deserialize(data, offset, client) {
+        const beginningOffset = offset;
+        // read length, go up 1
+        const tagLength = data[offset++];
+        // read tag as it's up 1, and add offset
+        const tag = (0, StringUtil_1.as8String)(data.slice(offset, offset += tagLength));
+        // then read dontSpread and async
+        const [dontSpread, async, isObject, autoFlatten, gzipCompression, rereference] = (0, CompressionUtil_1.decompressBools)(data[offset++]);
+        // read batching, up 1
+        const dataBatching = data[offset++];
+        // read enum length, up 1
+        const enumLength = data[offset++];
+        const enums = [];
+        for (let i = 0; i < enumLength; i++) {
+            // read tag length, go up 1
+            const enumTagLength = data[offset++];
+            // up 1 so read offset -> offset += tag length, to add tag length and skip over it
+            const enumTag = (0, StringUtil_1.as8String)(data.slice(offset, offset += enumTagLength));
+            // read amount of values
+            const valueCount = data[offset++];
+            const values = [];
+            for (let j = 0; j < valueCount; j++) {
+                // read the length of the value, go up 1
+                const valueLength = data[offset++];
+                // then read the type of value, up 1
+                const valueType = data[offset++];
+                // now can just read the values, increase offset for later use
+                const value = (0, StringUtil_1.as8String)(data.slice(offset, offset += valueLength));
+                // process it
+                values.push(EnumType_1.TYPE_CONVERSION_MAP[valueType](value));
+            }
+            // define the enum with the values
+            enums.push((0, EnumHandler_1.DefineEnum)(enumTag, values));
+        }
+        // objects
+        if (isObject) {
+            // read size
+            const size = data[offset++];
+            // read var ints for the datamaxes
+            const [dataMaxes, o1] = this.readVarInts(data, offset, size);
+            offset = o1;
+            // read var ints for the datamins
+            const [dataMins, o2] = this.readVarInts(data, offset, size);
+            offset = o2;
+            // get types, skip past size since there'll be size of these
+            const types = Array.from(data.slice(offset, offset += size));
+            // convert any enums into their indexed form for best bandwidth
+            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 = new PacketSchema(true, finalTypes, async, dataMins, dataMaxes, -1, dontSpread, autoFlatten, false, dataBatching, -1, gzipCompression);
+            return [
+                new Packet(tag, schema, null, false, client),
+                // +1 to go next
+                (offset - beginningOffset),
+            ];
+        }
+        // single packet
+        // read varint for datamax
+        const [o1, dataMax] = (0, CompressionUtil_1.readVarInt)(data, offset);
+        offset = o1;
+        // read varint for datamin
+        const [o2, dataMin] = (0, CompressionUtil_1.readVarInt)(data, offset);
+        offset = o2;
+        // read type
+        const type = data[offset++];
+        // do enum stuff
+        const finalType = type == PacketType_1.PacketType.ENUMS ? enums[0] : type; // convert enum to enum package
+        // make schema
+        const schema = new PacketSchema(false, finalType, async, dataMin, dataMax, -1, dontSpread, false, rereference, dataBatching, -1, gzipCompression);
+        return [
+            new Packet(tag, schema, null, false, client),
+            (offset - beginningOffset),
+        ];
+    }
+    static deserializeAll(data, client) {
+        const arr = [];
+        let offset = 0;
+        while (offset < data.length) {
+            const [packet, len] = this.deserialize(data, offset, client);
+            arr.push(packet);
+            offset += len;
+        }
+        return arr;
+    }
+}
+exports.Packet = Packet;
+const convertType = (type, ed) => (type instanceof EnumType_1.EnumPackage ? (ed.push(type), PacketType_1.PacketType.ENUMS) : type);
+class PacketSchema {
+    type;
+    enumData = [];
+    dataMax;
+    dataMin;
+    dataBatching;
+    maxBatchSize;
+    rateLimit;
+    dontSpread = false;
+    autoFlatten = false;
+    async = false;
+    rereference = false;
+    gzipCompression = false;
+    object;
+    constructor(object, type, async, dataMin, dataMax, rateLimit, dontSpread, autoFlatten, rereference, dataBatching, maxBatchSize, gzipCompression) {
+        // todo add rereference to objects
+        this.object = object;
+        this.async = async;
+        this.dataMin = dataMin;
+        this.dataMax = dataMax;
+        this.rateLimit = rateLimit;
+        this.dontSpread = dontSpread;
+        this.autoFlatten = autoFlatten;
+        this.rereference = rereference;
+        this.dataBatching = dataBatching;
+        this.maxBatchSize = maxBatchSize;
+        this.gzipCompression = gzipCompression;
+        this.type = (object ? type.map(t => convertType(t, this.enumData)) : convertType(type, this.enumData));
+    }
+    testObject(packet) {
+        return this.object;
+    }
+}
+exports.PacketSchema = PacketSchema;

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

@@ -1,7 +1,3 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 import * as WS from 'ws';
 import { SonicWSServer } from "./SonicWSServer";
 import { Packet } from "../packets/Packets";

package/dist/ws/server/SonicWSConnection.js

@@ -1,6 +1,298 @@
-/**
+"use strict";
+/*
  * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
+ *
+ * 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:!0}),exports.SonicWSConnection=void 0;const e=require("../util/packets/PacketUtils"),t=require("../util/packets/BatchHelper"),s=require("../util/packets/RateHandler"),a=require("../util/BufferUtil"),i=require("../Connection");class n extends i.Connection{host;print=!1;handshakePacket;handshakeLambda;messageLambda=e=>this.messageHandler(this.parseData(e));handshakedMessageLambda=e=>{const t=this.parseData(e);return null==t?this.socket.close(i.CloseCodes.INVALID_DATA):t[0]==this.handshakePacket?this.socket.close(i.CloseCodes.REPEATED_HANDSHAKE):void this.messageHandler(t)};rater;enabledPackets={};handshakeComplete=!1;asyncMap={};asyncData={};constructor(e,t,a,i,n,r){super(e,a,"Socket "+a,e.on,e.removeEventListener),this.host=t,this.handshakePacket=i;for(const e of t.clientPackets.getPackets()){const t=e.tag;this.listeners[t]=[],e.lastReceived[this.id]=void 0,this.enabledPackets[t]=e.defaultEnabled,this.asyncMap[t]=e.async,e.async&&(this.asyncData[t]=[!1,[]])}this.setInterval=this.setInterval.bind(this),this.batcher.registerSendPackets(this.host.serverPackets,this),this.invalidPacket=this.invalidPacket.bind(this),this.rater=new s.RateHandler(this),this.rater.registerRate("C",n),this.rater.registerRate("S",r),this.rater.registerAll(t.clientPackets,"client"),this.rater.registerAll(t.serverPackets,"server"),this.rater.start(),null==this.handshakePacket?this.socket.addEventListener("message",this.messageLambda):(this.handshakeLambda=e=>this.handshakeHandler(e),this.socket.addEventListener("message",this.handshakeLambda)),this.socket.on("close",()=>{for(const e of t.clientPackets.getPackets())delete e.lastReceived[this.id];for(const e of t.serverPackets.getPackets())delete e.lastSent[this.id]})}parseData(e){if(this.rater.trigger("C"))return null;if(!(e.data instanceof Buffer))return null;const t=new Uint8Array(e.data);if(this.print&&console.log(`⬇ (${this.id},${t.byteLength})`,t.length>0&&this.host.clientPackets.getTag(t[0])||"<INVALID>",(0,a.stringifyBuffer)(t)),t.byteLength<1)return this.socket.close(i.CloseCodes.SMALL),null;const s=t[0],n=t.slice(1);if(!this.host.clientPackets.hasKey(s))return this.socket.close(i.CloseCodes.INVALID_KEY),null;const r=this.host.clientPackets.getTag(s);return this.enabledPackets[r]?this.rater.trigger("client"+s)?null:[r,n]:(this.socket.close(i.CloseCodes.DISABLED_PACKET),null)}handshakeHandler(e){const t=this.parseData(e);if(null==t)return this.socket.close(i.CloseCodes.INVALID_DATA);t[0]==this.handshakePacket?(this.messageHandler(t),this.socket.removeEventListener("message",this.handshakeLambda),this.socket.addEventListener("message",this.handshakedMessageLambda),this.handshakeComplete=!0):this.socket.close(i.CloseCodes.INVALID_DATA)}invalidPacket(e){console.log("Closure cause",e),this.socket.close(i.CloseCodes.INVALID_PACKET,e)}isAsync(e){return this.asyncMap[e]}listenLock=!1;packetQueue=[];async listenPacket(t,s,a,i,n){this.closed||(await(0,e.listenPacket)(t,this.listeners[s],this.invalidPacket),await this.callMiddleware("onReceive_post",s,"string"==typeof t?[t]:t[0]),i?n[0]=!1:this.listenLock=!1,0==a.length||this.messageHandler(a.shift()))}async messageHandler(e,s=!1){if(null==e)return;const[a,i]=e,n=this.isAsync(a);let r,h,c;if(n?(c=this.asyncData[a],r=c[0],h=c[1]):(r=this.listenLock,h=this.packetQueue),r)return void h.push(e);n?c[0]=!0:this.listenLock=!0;const o=this.host.clientPackets.getPacket(a);if(!s&&await this.callMiddleware("onReceive_pre",o.tag,i,i.length))return;if(o.rereference&&0==i.length){const e=o.lastReceived[this.id];return void 0===e?this.invalidPacket("No previous value to rereference"):void await this.listenPacket(e,a,h,n,c)}if(0==o.dataBatching){const e=await o.listen(i,this);return o.lastReceived[this.id]=e,void await this.listenPacket(e,a,h,n,c)}const l=await t.BatchHelper.unravelBatch(o,i,this);if("string"==typeof l)return this.invalidPacket(l);for(const e of l)n?c[0]=!0:this.listenLock=!0,await this.listenPacket(e,a,h,n,c)}enablePacket(e){this.enabledPackets[e]=!0}disablePacket(e){this.enabledPackets[e]=!1}on_close(e){this.socket.on("close",(t,s)=>e(t,String(s)))}on(e,t){if(!this.host.clientPackets.hasTag(e))throw new Error(`Tag "${String(e)}" has not been created!`);this.listeners[e]??=[],this.listeners[e].push(t)}send_processed(e,t,s){this.rater.trigger("server"+e)||(0==s.dataBatching?this.raw_send((0,a.toPacketBuffer)(e,t)):this.batcher.batchPacket(e,t))}sendQueue=[!1,[],void 0];async send(t,...s){if(await this.callMiddleware("onSend_pre",t,s,Date.now(),performance.now()))return;const[a,i,n]=await(0,e.processPacket)(this.host.serverPackets,t,s,this.sendQueue,this.id);await this.callMiddleware("onSend_post",t,i,i.length)||this.send_processed(a,i,n)}broadcastFiltered(e,t,...s){this.host.broadcastFiltered(e,e=>e!=this&&t(e),...s)}broadcast(e,...t){this.broadcastFiltered(e,()=>!0,...t)}togglePrint(){this.print=!this.print}raw_send(e){this.isClosed()?console.warn("WARN! Connection already closed when trying to send message!",this.id,(0,a.stringifyBuffer)(e)):this.rater.trigger("S")||(this.print&&console.log(`⬆ (${this.id},${e.byteLength})`,e.length>0&&this.host.serverPackets.getTag(e[0])||"<INVALID>",(0,a.stringifyBuffer)(e)),super.raw_send(e))}tag(e,t=!0){this.host.tag(this,e,t)}}exports.SonicWSConnection=n;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSConnection = void 0;
+const PacketUtils_1 = require("../util/packets/PacketUtils");
+const BatchHelper_1 = require("../util/packets/BatchHelper");
+const RateHandler_1 = require("../util/packets/RateHandler");
+const BufferUtil_1 = require("../util/BufferUtil");
+const Connection_1 = require("../Connection");
+const CLIENT_RATELIMIT_TAG = "C", SERVER_RATELIMIT_TAG = "S";
+class SonicWSConnection extends Connection_1.Connection {
+    host;
+    print = false;
+    handshakePacket;
+    handshakeLambda;
+    messageLambda = (data) => this.messageHandler(this.parseData(data));
+    handshakedMessageLambda = (data) => {
+        const parsed = this.parseData(data);
+        if (parsed == null)
+            return this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
+        if (parsed[0] == this.handshakePacket)
+            return this.socket.close(Connection_1.CloseCodes.REPEATED_HANDSHAKE);
+        this.messageHandler(parsed);
+    };
+    rater;
+    enabledPackets = {};
+    /** If the packet handshake has been completed; `wss.requireHandshake(packet)` */
+    handshakeComplete = false;
+    asyncMap = {};
+    asyncData = {};
+    constructor(socket, host, id, handshakePacket, clientRateLimit, serverRateLimit) {
+        super(socket, id, "Socket " + id, socket.addEventListener.bind(socket), socket.removeEventListener.bind(socket));
+        this.host = host;
+        this.handshakePacket = handshakePacket;
+        for (const pack of host.clientPackets.getPackets()) {
+            const tag = pack.tag;
+            this.listeners[tag] = [];
+            pack.lastReceived[this.id] = undefined;
+            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.registerSendPackets(this.host.serverPackets, this);
+        this.invalidPacket = this.invalidPacket.bind(this);
+        this.rater = new RateHandler_1.RateHandler(this);
+        this.rater.registerRate(CLIENT_RATELIMIT_TAG, clientRateLimit);
+        this.rater.registerRate(SERVER_RATELIMIT_TAG, serverRateLimit);
+        this.rater.registerAll(host.clientPackets, "client");
+        this.rater.registerAll(host.serverPackets, "server");
+        this.rater.start();
+        if (this.handshakePacket == null) {
+            this.socket.addEventListener('message', this.messageLambda);
+        }
+        else {
+            this.handshakeLambda = (data) => this.handshakeHandler(data);
+            this.socket.addEventListener('message', this.handshakeLambda);
+        }
+        this.socket.on('close', () => {
+            for (const packet of host.clientPackets.getPackets()) {
+                delete packet.lastReceived[this.id];
+            }
+            for (const packet of host.serverPackets.getPackets()) {
+                delete packet.lastSent[this.id];
+            }
+        });
+    }
+    parseData(event) {
+        if (this.rater.trigger(CLIENT_RATELIMIT_TAG))
+            return null;
+        if (!(event.data instanceof Buffer))
+            return null;
+        const message = new Uint8Array(event.data);
+        if (this.print)
+            console.log(`\x1b[31m⬇ \x1b[38;5;245m(${this.id},${message.byteLength})\x1b[0m`, (message.length > 0 && this.host.clientPackets.getTag(message[0])) || "<INVALID>", (0, BufferUtil_1.stringifyBuffer)(message));
+        if (message.byteLength < 1) {
+            this.socket.close(Connection_1.CloseCodes.SMALL);
+            return null;
+        }
+        const key = message[0];
+        const value = message.slice(1);
+        // not a key, bye bye
+        if (!this.host.clientPackets.hasKey(key)) {
+            this.socket.close(Connection_1.CloseCodes.INVALID_KEY);
+            return null;
+        }
+        const tag = this.host.clientPackets.getTag(key);
+        // disabled, bye bye
+        if (!this.enabledPackets[tag]) {
+            this.socket.close(Connection_1.CloseCodes.DISABLED_PACKET);
+            return null;
+        }
+        if (this.rater.trigger("client" + key))
+            return null;
+        return [tag, value];
+    }
+    handshakeHandler(data) {
+        const parsed = this.parseData(data);
+        if (parsed == null)
+            return this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
+        if (parsed[0] != this.handshakePacket) {
+            this.socket.close(Connection_1.CloseCodes.INVALID_DATA);
+            return;
+        }
+        this.messageHandler(parsed);
+        this.socket.removeEventListener('message', this.handshakeLambda);
+        this.socket.addEventListener('message', this.handshakedMessageLambda);
+        this.handshakeComplete = true;
+    }
+    invalidPacket(listened) {
+        console.log("Closure cause", listened);
+        this.socket.close(Connection_1.CloseCodes.INVALID_PACKET, listened);
+    }
+    isAsync(tag) {
+        return this.asyncMap[tag];
+    }
+    listenLock = false;
+    packetQueue = [];
+    async listenPacket(data, tag, packetQueue, isAsync, asyncData) {
+        if (this.closed)
+            return;
+        await (0, PacketUtils_1.listenPacket)(data, this.listeners[tag], this.invalidPacket);
+        await this.callMiddleware('onReceive_post', tag, typeof data == 'string' ? [data] : data[0]);
+        if (isAsync)
+            asyncData[0] = false;
+        else
+            this.listenLock = false;
+        if (packetQueue.length != 0) {
+            this.messageHandler(packetQueue.shift());
+            return;
+        }
+    }
+    async messageHandler(data, recall = false) {
+        if (data == null)
+            return;
+        const [tag, value] = data;
+        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);
+            return;
+        }
+        if (isAsync)
+            asyncData[0] = true;
+        else
+            this.listenLock = true;
+        const packet = this.host.clientPackets.getPacket(tag);
+        if (!recall && await this.callMiddleware('onReceive_pre', packet.tag, value, value.length))
+            return;
+        if (packet.rereference && value.length == 0) {
+            const lastRecv = packet.lastReceived[this.id];
+            if (lastRecv === undefined)
+                return this.invalidPacket("No previous value to rereference");
+            await this.listenPacket(lastRecv, tag, packetQueue, isAsync, asyncData);
+            return;
+        }
+        if (packet.dataBatching == 0) {
+            const res = await packet.listen(value, this);
+            packet.lastReceived[this.id] = res;
+            await this.listenPacket(res, tag, packetQueue, isAsync, asyncData);
+            return;
+        }
+        const batchData = await BatchHelper_1.BatchHelper.unravelBatch(packet, value, this);
+        if (typeof batchData == 'string')
+            return this.invalidPacket(batchData);
+        for (const data of batchData) {
+            if (isAsync)
+                asyncData[0] = true;
+            else
+                this.listenLock = true;
+            await this.listenPacket(data, tag, packetQueue, isAsync, asyncData);
+        }
+    }
+    /**
+     * Enables a packet for the client.
+     * @param tag The tag of the packet
+     */
+    enablePacket(tag) {
+        this.enabledPackets[tag] = true;
+    }
+    /**
+     * Disables a packet for the client.
+     * @param tag The tag of the packet
+     */
+    disablePacket(tag) {
+        this.enabledPackets[tag] = false;
+    }
+    /**
+     * Listens for when the connection closes
+     * @param listener Called when it closes
+     */
+    on_close(listener) {
+        this.socket.on('close', (code, reason) => listener(code, String(reason)));
+    }
+    /**
+     * Listens for a packet
+     * @param tag The tag of the key to listen for
+     * @param listener A function to listen for it
+     */
+    on(tag, listener) {
+        if (!this.host.clientPackets.hasTag(tag))
+            throw new Error(`Tag "${String(tag)}" has not been created!`);
+        this.listeners[tag] ??= [];
+        this.listeners[tag].push(listener);
+    }
+    /**
+     * For internal use.
+     */
+    send_processed(code, data, packet) {
+        if (this.rater.trigger("server" + code))
+            return;
+        if (packet.dataBatching == 0)
+            this.raw_send((0, BufferUtil_1.toPacketBuffer)(code, data));
+        else
+            this.batcher.batchPacket(code, data);
+    }
+    sendQueue = [false, [], undefined];
+    /**
+     * Sends a packet with the tag and values
+     * @param tag The tag to send
+     * @param values The values to send
+     */
+    async send(tag, ...values) {
+        if (await this.callMiddleware('onSend_pre', tag, values, Date.now(), performance.now()))
+            return;
+        const [code, data, packet] = await (0, PacketUtils_1.processPacket)(this.host.serverPackets, tag, values, this.sendQueue, this.id);
+        if (await this.callMiddleware('onSend_post', tag, data, data.length))
+            return;
+        this.send_processed(code, data, packet);
+    }
+    /**
+     * Broadcasts a packet to all other users connected
+     * @param tag The tag to send
+     * @param values The values to send
+     */
+    broadcastFiltered(tag, filter, ...values) {
+        this.host.broadcastFiltered(tag, (socket) => socket != this && filter(socket), ...values);
+    }
+    /**
+     * Broadcasts a packet to all other users connected
+     * @param tag The tag to send
+     * @param values The values to send
+     */
+    broadcast(tag, ...values) {
+        this.broadcastFiltered(tag, () => true, ...values);
+    }
+    /**
+     * Toggles printing all sent and received messages
+     */
+    togglePrint() {
+        this.print = !this.print;
+    }
+    /* JSDocs in Connection.ts class */
+    raw_send(data) {
+        if (this.isClosed()) {
+            console.warn("WARN! Connection already closed when trying to send message!", this.id, (0, BufferUtil_1.stringifyBuffer)(data));
+            return;
+        }
+        if (this.rater.trigger(SERVER_RATELIMIT_TAG))
+            return;
+        if (this.print)
+            console.log(`\x1b[32m⬆ \x1b[38;5;245m(${this.id},${data.byteLength})\x1b[0m`, (data.length > 0 && this.host.serverPackets.getTag(data[0])) || "<INVALID>", (0, BufferUtil_1.stringifyBuffer)(data));
+        super.raw_send(data);
+    }
+    /**
+     * Tags the socket with a key
+     * @param tag The tag to add
+     * @param replace If it should replace a previous tag; defaults to true. If using false, you can add multiple tags.
+     */
+    tag(tag, replace = true) {
+        this.host.tag(this, tag, replace);
+    }
+}
+exports.SonicWSConnection = SonicWSConnection;

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

@@ -1,7 +1,3 @@
-/**
- * Copyright 2026 Lily (liwybloc)
- * Licensed under the Apache License, Version 2.0.
- */
 import * as WS from 'ws';
 import { SonicWSConnection } from "./SonicWSConnection";
 import { PacketHolder } from "../util/packets/PacketHolder";
@@ -136,7 +132,7 @@ export declare class SonicWSServer extends MiddlewareHolder<ServerMiddleware> {
      * @param port Port of the server/http, defaults to 0 which finds an open port
      * @param password Toggles the requirement of a password to access the server. Defaults to empty, which doesn't ask for a password.
      */
-    OpenDebug(data: {
+    OpenDebug(data?: {
         port?: number;
         password?: string;
     }): void;