@sanctumterra/raknet 1.3.61 → 1.3.64

package/dist/client/client-events.d.ts

@@ -1,4 +1,5 @@
-import type { Ack, ConnectedPing, ConnectionRequest, NewIncomingConnection, OpenConnectionReplyOne, OpenConnectionReplyTwo, OpenConnectionRequestOne, OpenConnectionRequestTwo, UnconnectedPing, UnconnectedPong, Frameset, Nack, ConnectedPong, ConnectionRequestAccepted } from "../proto";
+import type { Ack, ConnectedPing, ConnectionRequest, NewIncomingConnection, OpenConnectionReplyOne, OpenConnectionReplyTwo, OpenConnectionRequestOne, OpenConnectionRequestTwo, UnconnectedPing, UnconnectedPong } from "../proto";
+import type { Frameset } from "../proto/packets/frameset";
 export interface ClientEvents {
     "open-connection-reply-one": [OpenConnectionReplyOne];
     "open-connection-reply-two": [OpenConnectionReplyTwo];
@@ -10,11 +11,8 @@ export interface ClientEvents {
     "connected-ping": [ConnectedPing];
     "connection-request": [ConnectionRequest];
     "new-incoming-connection": [NewIncomingConnection];
-    "connection-request-accepted": [ConnectionRequestAccepted];
-    "connected-pong": [ConnectedPong];
     encapsulated: [Buffer];
     ack: [Ack];
-    nack: [Nack];
     error: [Error];
     close: [];
     connect: [];

package/dist/client/client-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-events.d.ts","sourceRoot":"","sources":["../../src/client/client-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,GAAG,EACH,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,QAAQ,EACR,IAAI,EACJ,aAAa,EACb,yBAAyB,EACzB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,YAAY;IAC5B,2BAA2B,EAAE,CAAC,sBAAsB,CAAC,CAAC;IACtD,2BAA2B,EAAE,CAAC,sBAAsB,CAAC,CAAC;IACtD,6BAA6B,EAAE,CAAC,wBAAwB,CAAC,CAAC;IAC1D,6BAA6B,EAAE,CAAC,wBAAwB,CAAC,CAAC;IAC1D,kBAAkB,EAAE,CAAC,eAAe,CAAC,CAAC;IACtC,kBAAkB,EAAE,CAAC,eAAe,CAAC,CAAC;IACtC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC;IACrB,gBAAgB,EAAE,CAAC,aAAa,CAAC,CAAC;IAClC,oBAAoB,EAAE,CAAC,iBAAiB,CAAC,CAAC;IAC1C,yBAAyB,EAAE,CAAC,qBAAqB,CAAC,CAAC;IACnD,6BAA6B,EAAE,CAAC,yBAAyB,CAAC,CAAC;IAC3D,gBAAgB,EAAE,CAAC,aAAa,CAAC,CAAC;IAClC,YAAY,EAAE,CAAC,MAAM,CAAC,CAAC;IACvB,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACX,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC;IACb,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;IACf,KAAK,EAAE,EAAE,CAAC;IACV,OAAO,EAAE,EAAE,CAAC;IACZ,IAAI,EAAE,EAAE,CAAC;CACT"}
+{"version":3,"file":"client-events.d.ts","sourceRoot":"","sources":["../../src/client/client-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,GAAG,EACH,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAE1D,MAAM,WAAW,YAAY;IAC5B,2BAA2B,EAAE,CAAC,sBAAsB,CAAC,CAAC;IACtD,2BAA2B,EAAE,CAAC,sBAAsB,CAAC,CAAC;IACtD,6BAA6B,EAAE,CAAC,wBAAwB,CAAC,CAAC;IAC1D,6BAA6B,EAAE,CAAC,wBAAwB,CAAC,CAAC;IAC1D,kBAAkB,EAAE,CAAC,eAAe,CAAC,CAAC;IACtC,kBAAkB,EAAE,CAAC,eAAe,CAAC,CAAC;IACtC,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC;IACrB,gBAAgB,EAAE,CAAC,aAAa,CAAC,CAAC;IAClC,oBAAoB,EAAE,CAAC,iBAAiB,CAAC,CAAC;IAC1C,yBAAyB,EAAE,CAAC,qBAAqB,CAAC,CAAC;IACnD,YAAY,EAAE,CAAC,MAAM,CAAC,CAAC;IACvB,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACX,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;IACf,KAAK,EAAE,EAAE,CAAC;IACV,OAAO,EAAE,EAAE,CAAC;IACZ,IAAI,EAAE,EAAE,CAAC;CACT"}

package/dist/client/client-options.d.ts

@@ -0,0 +1,23 @@
+type ClientOptions = {
+    address: string;
+    port: number;
+    protocolVersion: number;
+    mtuSize: number;
+    clientId: bigint;
+    debug: boolean;
+    timeout: number;
+    maxFrameQueueSize: number;
+    fragmentTimeout: number;
+    enableBufferPooling: boolean;
+    gcInterval: number;
+    socketBufferMultiplier: number;
+    tickInterval: number;
+    connectionRetryInterval: number;
+    initialConnectionTimeout: number;
+    batchSize: number;
+    maxPipelineStages: number;
+    fastPathEnabled: boolean;
+};
+declare const defaultClientOptions: ClientOptions;
+export { type ClientOptions, defaultClientOptions };
+//# sourceMappingURL=client-options.d.ts.map

package/dist/client/client-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-options.d.ts","sourceRoot":"","sources":["../../src/client/client-options.ts"],"names":[],"mappings":"AAAA,KAAK,aAAa,GAAG;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,uBAAuB,EAAE,MAAM,CAAC;IAChC,wBAAwB,EAAE,MAAM,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,QAAA,MAAM,oBAAoB,EAAE,aAmB3B,CAAC;AAEF,OAAO,EAAE,KAAK,aAAa,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/client/client-options.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultClientOptions = void 0;
+const defaultClientOptions = {
+    address: "127.0.0.1",
+    port: 19132,
+    protocolVersion: 11,
+    mtuSize: 1492,
+    clientId: BigInt(Math.floor(Math.random() * 1000000000000000000)),
+    debug: false,
+    timeout: 3000,
+    maxFrameQueueSize: 1000,
+    fragmentTimeout: 10000,
+    enableBufferPooling: true,
+    gcInterval: 60000,
+    socketBufferMultiplier: 2048,
+    tickInterval: 8,
+    connectionRetryInterval: 100,
+    initialConnectionTimeout: 800,
+    batchSize: 16,
+    maxPipelineStages: 2,
+    fastPathEnabled: true,
+};
+exports.defaultClientOptions = defaultClientOptions;

package/dist/client/client.d.ts

@@ -1,17 +1,32 @@
-import Emitter from "@serenityjs/emitter";
-import { type ClientOptions } from "./client_options";
+import { Emitter } from "@serenityjs/emitter";
 import type { ClientEvents } from "./client-events";
-import { type Advertisement } from "../proto";
+import { type Socket } from "node:dgram";
+import { Framer } from "./framer";
+import { Address, type Advertisement, type Frame, Priority } from "../proto";
+import { type ClientOptions } from "./client-options";
 export declare class Client extends Emitter<ClientEvents> {
-    private rakSocket;
+    socket: Socket;
+    framer: Framer;
     options: ClientOptions;
-    ticker: NodeJS.Timeout;
-    tick: number;
-    private advertisement;
-    constructor(options: Partial<ClientOptions>);
+    private timer;
+    private timeout;
+    serverAddress: Address;
+    private isConnecting;
+    private packetHandlers;
+    private fastPathPackets;
+    constructor(options?: Partial<ClientOptions>);
+    initSocket(): void;
+    ping(): Promise<Advertisement | null>;
     connect(): Promise<Advertisement>;
-    ping(): Promise<Advertisement>;
-    frameAndSend(buffer: Buffer): void;
-    private handleData;
+    private setupConnection;
+    sendFrame(frame: Frame, priority: Priority): void;
+    send(buffer: Buffer): void;
+    private onMessage;
+    private cleanup;
+    private handleAck;
+    private handleUnconnectedPong;
+    private handleOpenConnectionReplyOne;
+    private handleOpenConnectionReplyTwo;
+    private handleFrameSet;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/client/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,qBAAqB,CAAC;AAC1C,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,EAaN,KAAK,aAAa,EAClB,MAAM,UAAU,CAAC;AAElB,qBAAa,MAAO,SAAQ,OAAO,CAAC,YAAY,CAAC;IAChD,OAAO,CAAC,SAAS,CAAY;IAEtB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAG,MAAM,CAAC,OAAO,CAAC;IACxB,IAAI,SAAK;IAChB,OAAO,CAAC,aAAa,CAAiB;gBAE1B,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAW9B,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;IAoBjC,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC;IAwBpC,YAAY,CAAC,MAAM,EAAE,MAAM;IAIlC,OAAO,CAAC,UAAU;CAqElB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAmB,KAAK,MAAM,EAAgB,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAEN,OAAO,EACP,KAAK,aAAa,EAElB,KAAK,KAAK,EAOV,QAAQ,EAGR,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,kBAAkB,CAAC;AAK5E,qBAAa,MAAO,SAAQ,OAAO,CAAC,YAAY,CAAC;IACzC,MAAM,EAAG,MAAM,CAAC;IAChB,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAE,aAAa,CAAC;IAC9B,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,OAAO,CAAkB;IAC1B,aAAa,EAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,cAAc,CAAwD;IAC9E,OAAO,CAAC,eAAe,CAKpB;gBAES,OAAO,GAAE,OAAO,CAAC,aAAa,CAAwB;IAmB3D,UAAU;IAaJ,IAAI,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IA2BrC,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;YAmBhC,eAAe;IAyDtB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAIjD,IAAI,CAAC,MAAM,EAAE,MAAM;IAe1B,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,4BAA4B;IAkBpC,OAAO,CAAC,4BAA4B;IAuCpC,OAAO,CAAC,cAAc;CAKtB"}

package/dist/client/client.js

@@ -1,129 +1,249 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
-const emitter_1 = __importDefault(require("@serenityjs/emitter"));
-const client_options_1 = require("./client_options");
-const rs_rak_client_1 = require("@sanctumterra/rs-rak-client");
+const emitter_1 = require("@serenityjs/emitter");
+const node_dgram_1 = require("node:dgram");
+const framer_1 = require("./framer");
 const proto_1 = require("../proto");
-class Client extends emitter_1.default {
-    rakSocket;
+const client_options_1 = require("./client-options");
+const utils_1 = require("../utils");
+const frameset_1 = require("../proto/packets/frameset");
+const decorators_1 = require("../utils/decorators");
+class Client extends emitter_1.Emitter {
+    socket;
+    framer;
     options;
-    ticker;
-    tick = 0;
-    advertisement;
-    constructor(options) {
+    timer;
+    timeout;
+    serverAddress;
+    isConnecting = false;
+    packetHandlers;
+    fastPathPackets = new Set([
+        proto_1.Packet.Ack,
+        proto_1.Packet.Nack,
+        proto_1.Packet.ConnectedPing,
+        proto_1.Packet.ConnectedPong,
+    ]);
+    constructor(options = client_options_1.defaultClientOptions) {
         super();
         this.options = { ...client_options_1.defaultClientOptions, ...options };
-        this.rakSocket = new rs_rak_client_1.RaknetClient(this.options.address, this.options.port);
+        this.maxListeners = 20;
+        this.packetHandlers = new Map([
+            [proto_1.Packet.Ack, this.handleAck.bind(this)],
+            [proto_1.Packet.UnconnectedPong, this.handleUnconnectedPong.bind(this)],
+            [
+                proto_1.Packet.OpenConnectionReplyOne,
+                this.handleOpenConnectionReplyOne.bind(this),
+            ],
+            [
+                proto_1.Packet.OpenConnectionReplyTwo,
+                this.handleOpenConnectionReplyTwo.bind(this),
+            ],
+            [proto_1.Packet.FrameSet, this.handleFrameSet.bind(this)],
+        ]);
     }
-    async connect() {
-        this.ticker = setInterval(() => {
-            this.rakSocket.receive();
-            this.rakSocket.tick();
-            const data = this.rakSocket.onEvent();
-            if (data) {
-                this.handleData(Buffer.from(data.data));
-            }
-            this.tick++;
-        }, 20);
-        await this.ping();
-        this.rakSocket.connect();
+    initSocket() {
+        try {
+            this.socket = (0, node_dgram_1.createSocket)("udp4");
+            this.framer = new framer_1.Framer(this);
+            this.remove("tick", () => this.framer.tick());
+            this.on("tick", () => this.framer.tick());
+            this.socket.removeAllListeners("message");
+            this.socket.on("message", this.onMessage.bind(this));
+        }
+        catch (error) {
+            utils_1.Logger.error(`Failed to create socket: ${error}`);
+        }
+    }
+    async ping() {
         return new Promise((resolve, reject) => {
-            this.once("ack", () => {
-                this.emit("connect");
-                resolve(this.advertisement);
+            const timeoutId = setTimeout(() => {
+                this.removeAll("unconnected-pong");
+                reject(new Error("Ping timed out"));
+            }, this.options.initialConnectionTimeout);
+            const sendPing = () => {
+                const unconnectedPing = new proto_1.UnconnectedPing();
+                unconnectedPing.guid = this.options.clientId;
+                unconnectedPing.clientTimestamp = BigInt(Date.now());
+                this.send(unconnectedPing.serialize());
+            };
+            sendPing();
+            const pingInterval = setInterval(sendPing, 50);
+            this.once("unconnected-pong", (packet) => {
+                clearTimeout(timeoutId);
+                clearInterval(pingInterval);
+                resolve((0, proto_1.fromString)(packet.message));
             });
         });
     }
-    async ping() {
+    async connect() {
+        if (this.isConnecting)
+            throw new Error("Connection attempt already in progress");
+        try {
+            this.isConnecting = true;
+            this.initSocket();
+            const [advertisement] = await Promise.all([
+                this.ping(),
+                this.setupConnection(),
+            ]);
+            if (!advertisement)
+                throw new Error("Failed to get server advertisement");
+            return advertisement;
+        }
+        catch (error) {
+            this.isConnecting = false;
+            throw error;
+        }
+    }
+    async setupConnection() {
+        this.timer = setInterval(() => this.emit("tick"), this.options.tickInterval);
+        const request = new proto_1.OpenConnectionRequestOne();
+        request.mtu = this.options.mtuSize;
+        request.protocol = this.options.protocolVersion;
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                cleanup();
-                reject(new Error("Ping timeout"));
-            }, 5000);
-            const pongHandler = (pong) => {
-                this.advertisement = (0, proto_1.fromString)(pong.message);
-                cleanup();
-                resolve((0, proto_1.fromString)(pong.message));
-            };
+            let connectionAttempts = 0;
+            const maxAttempts = 3;
+            let isResolved = false;
+            let timeoutId;
             const cleanup = () => {
-                clearTimeout(timeout);
-                this.remove("unconnected-pong", pongHandler);
+                clearTimeout(timeoutId);
+                this.removeAll("open-connection-reply-one");
+                this.removeAll("new-incoming-connection");
+            };
+            const attemptConnection = () => {
+                if (isResolved)
+                    return;
+                if (connectionAttempts >= maxAttempts) {
+                    cleanup();
+                    reject(new Error("Connection timed out"));
+                    return;
+                }
+                connectionAttempts++;
+                this.emit("open-connection-request-one", request);
+                this.send(request.serialize());
+                const delay = connectionAttempts === 1
+                    ? 50
+                    : Math.min(75 * 1.5 ** (connectionAttempts - 1), 200);
+                timeoutId = setTimeout(attemptConnection, delay);
             };
-            this.rakSocket.ping();
-            this.once("unconnected-pong", pongHandler);
+            // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+            this.once("open-connection-reply-one", () => (connectionAttempts = 0));
+            this.onceAfter("new-incoming-connection", () => {
+                if (!isResolved) {
+                    isResolved = true;
+                    cleanup();
+                    this.emit("connect");
+                    this.isConnecting = false;
+                    resolve();
+                }
+            });
+            attemptConnection();
         });
     }
-    frameAndSend(buffer) {
-        this.rakSocket.frameAndSend(buffer);
+    sendFrame(frame, priority) {
+        this.framer.sendFrame(frame, priority);
     }
-    handleData(data) {
-        if (!data || data.length === 0) {
-            // console.log("Received empty data buffer");
-            return;
+    send(buffer) {
+        if (this.options.debug) {
+            utils_1.Logger.debug(`Sending ${buffer[0]}, ${buffer.length} bytes to ${this.options.address}:${this.options.port}`);
         }
-        let packetId = data[0];
-        if ((packetId & 0xf0) === 0x80)
-            packetId = 0x80;
-        switch (packetId) {
-            case 254: {
-                this.emit("encapsulated", data);
-                break;
-            }
-            case proto_1.Packet.Ack: {
-                const ack = new proto_1.Ack(data).deserialize();
-                this.emit("ack", ack);
-                break;
-            }
-            case proto_1.Packet.FrameSet: {
-                const frameset = new proto_1.Frameset(data).deserialize();
-                this.emit("frameset", frameset);
-                break;
-            }
-            case proto_1.Packet.ConnectedPing: {
-                const connectedPing = new proto_1.ConnectedPing(data).deserialize();
-                this.emit("connected-ping", connectedPing);
-                break;
-            }
-            case proto_1.Packet.ConnectionRequest: {
-                const connectionRequest = new proto_1.ConnectionRequest(data).deserialize();
-                this.emit("connection-request", connectionRequest);
-                break;
-            }
-            case proto_1.Packet.NewIncomingConnection: {
-                const newIncomingConnection = new proto_1.NewIncomingConnection(data).deserialize();
-                this.emit("new-incoming-connection", newIncomingConnection);
-                break;
-            }
-            case proto_1.Packet.UnconnectedPing: {
-                const unconnectedPing = new proto_1.UnconnectedPing(data).deserialize();
-                this.emit("unconnected-ping", unconnectedPing);
-                break;
-            }
-            case proto_1.Packet.UnconnectedPong: {
-                const unconnectedPong = new proto_1.UnconnectedPong(data).deserialize();
-                this.emit("unconnected-pong", unconnectedPong);
-                break;
-            }
-            case proto_1.Packet.Nack: {
-                const nack = new proto_1.Nack(data).deserialize();
-                this.emit("nack", nack);
-                break;
+        this.socket.send(buffer, 0, buffer.length, this.options.port, this.options.address);
+    }
+    onMessage(msg, rinfo) {
+        try {
+            const packetId = (msg[0] & 0xf0) === 0x80 ? 0x80 : msg[0];
+            if (this.fastPathPackets.has(packetId)) {
+                this.packetHandlers.get(packetId)?.(msg, rinfo);
+                return;
             }
-            case proto_1.Packet.ConnectedPong: {
-                const connectedPong = new proto_1.ConnectedPong(data).deserialize();
-                this.emit("connected-pong", connectedPong);
-                break;
+            const handler = this.packetHandlers.get(packetId);
+            if (handler) {
+                handler(msg, rinfo);
+                return;
             }
-            case proto_1.Packet.ConnectionRequestAccepted: {
-                const connectionRequestAccepted = new proto_1.ConnectionRequestAccepted(data).deserialize();
-                this.emit("connection-request-accepted", connectionRequestAccepted);
-                break;
+            if (this.options.debug) {
+                utils_1.Logger.debug(`Unhandled packet ${packetId} from ${rinfo.address}:${rinfo.port}`);
             }
         }
+        catch (error) {
+            utils_1.Logger.error("Failed to handle packet", { error: error });
+        }
+    }
+    cleanup() {
+        this.removeAll();
+        this.socket.removeAllListeners();
+        this.socket.close();
+        clearInterval(this.timer);
+        clearTimeout(this.timeout);
+        this.isConnecting = false;
+    }
+    handleAck(msg, _rinfo) {
+        this.emit("ack", new proto_1.Ack(msg).deserialize());
+    }
+    handleUnconnectedPong(msg, _rinfo) {
+        this.emit("unconnected-pong", new proto_1.UnconnectedPong(msg).deserialize());
+    }
+    handleOpenConnectionReplyOne(msg, rinfo) {
+        const packet = new proto_1.OpenConnectionReplyOne(msg).deserialize();
+        this.emit("open-connection-reply-one", packet);
+        this.serverAddress = new proto_1.Address(rinfo.address, rinfo.port, rinfo.family === "IPv4" ? 4 : 6);
+        const request = new proto_1.OpenConnectionRequestTwo();
+        request.mtu = packet.mtu;
+        request.address = this.serverAddress;
+        request.clientGuid = this.options.clientId;
+        this.emit("open-connection-request-two", request);
+        this.send(request.serialize());
+    }
+    handleOpenConnectionReplyTwo(msg, _rinfo) {
+        const packet = new proto_1.OpenConnectionReplyTwo(msg).deserialize();
+        this.emit("open-connection-reply-two", packet);
+        this.options.mtuSize = packet.mtu;
+        const conReq = new proto_1.ConnectionRequest();
+        conReq.clientGuid = this.options.clientId;
+        conReq.timestamp = BigInt(Date.now());
+        conReq.useSecurity = false;
+        let connectionAttempts = 0;
+        let lastAttemptTime = 0;
+        this.emit("connection-request", conReq);
+        this.framer.frameAndSend(conReq.serialize(), proto_1.Priority.Immediate);
+        lastAttemptTime = Date.now();
+        const connectionInterval = setInterval(() => {
+            const now = Date.now();
+            if (now - lastAttemptTime < 100)
+                return;
+            if (connectionAttempts >= 3) {
+                clearInterval(connectionInterval);
+                this.cleanup();
+                this.emit("error", new Error("Connection request timed out"));
+                return;
+            }
+            lastAttemptTime = now;
+            connectionAttempts++;
+            this.emit("connection-request", conReq);
+            this.framer.frameAndSend(conReq.serialize(), proto_1.Priority.Immediate);
+        }, 100);
+        this.once("new-incoming-connection", () => clearInterval(connectionInterval));
+    }
+    handleFrameSet(msg, _rinfo) {
+        const frameset = new frameset_1.Frameset(msg).deserialize();
+        this.emit("frameset", frameset);
+        this.framer.handle(frameset);
     }
 }
 exports.Client = Client;
+__decorate([
+    decorators_1.measureExecutionTime,
+    decorators_1.optimizeConnection,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], Client.prototype, "connect", null);

package/dist/client/framer.d.ts

@@ -0,0 +1,49 @@
+import { Frame, Priority } from "../proto";
+import { Frameset } from "../proto";
+import type { Client } from "./client";
+interface FragmentInfo {
+    frame: Frame;
+    timestamp: number;
+}
+export declare class Framer {
+    private static readonly BUFFER_SIZES;
+    private bufferPools;
+    private client;
+    private lastInputSequence;
+    private receivedFrameSequences;
+    private lostFrameSequences;
+    private inputHighestSequenceIndex;
+    private inputOrderIndex;
+    protected inputOrderingQueue: Map<number, Map<number, Frame>>;
+    protected readonly fragmentsQueue: Map<number, Map<number, FragmentInfo>>;
+    outputOrderIndex: number[];
+    outputSequenceIndex: number[];
+    outputFrameQueue: Frameset;
+    protected outputSequence: number;
+    protected outputSplitIndex: number;
+    protected outputReliableIndex: number;
+    protected outputFrames: Frame[];
+    outputBackup: Map<number, Frame[]>;
+    constructor(client: Client);
+    tick(): void;
+    private processFrame;
+    private processBatch;
+    handle(frameSet: Frameset): void;
+    private handleFrame;
+    private handleOrdered;
+    private processOrderedFrames;
+    private handleSequenced;
+    private handleSplit;
+    private reassembleAndProcessFragment;
+    frameAndSend(payload: Buffer, priority?: Priority): void;
+    sendFrame(frame: Frame, priority: Priority): void;
+    private handleLargePayload;
+    private createSplitFrame;
+    private queueFrame;
+    sendQueue(amount: number): void;
+    private cleanupStaleFragments;
+    private getOptimalBuffer;
+    private releaseBuffer;
+}
+export {};
+//# sourceMappingURL=framer.d.ts.map

package/dist/client/framer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framer.d.ts","sourceRoot":"","sources":["../../src/client/framer.ts"],"names":[],"mappings":"AACA,OAAO,EAIN,KAAK,EAGL,QAAQ,EAIR,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGvC,UAAU,YAAY;IACrB,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,MAAM;IAClB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAA4B;IAChE,OAAO,CAAC,WAAW,CAAoC;IAEvD,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,iBAAiB,CAAM;IAC/B,OAAO,CAAC,sBAAsB,CAA0B;IACxD,OAAO,CAAC,kBAAkB,CAA0B;IACpD,OAAO,CAAC,yBAAyB,CAAmC;IACpE,OAAO,CAAC,eAAe,CAAmC;IAC1D,SAAS,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAa;IAC1E,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAC9D;IAEJ,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,gBAAgB,EAAE,QAAQ,CAAC;IAClC,SAAS,CAAC,cAAc,SAAK;IAC7B,SAAS,CAAC,gBAAgB,SAAK;IAC/B,SAAS,CAAC,mBAAmB,SAAK;IAClC,SAAS,CAAC,YAAY,EAAE,KAAK,EAAE,CAAM;IAC9B,YAAY,uBAA8B;gBAErC,MAAM,EAAE,MAAM;IAmBnB,IAAI;IAqBX,OAAO,CAAC,YAAY;IAuDpB,OAAO,CAAC,YAAY;IAcb,MAAM,CAAC,QAAQ,EAAE,QAAQ;IAyChC,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,oBAAoB;IAkB5B,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,WAAW;IAkBnB,OAAO,CAAC,4BAA4B;IA8C7B,YAAY,CAClB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,QAA0B,GAClC,IAAI;IAQA,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAuBxD,OAAO,CAAC,kBAAkB;IAkB1B,OAAO,CAAC,gBAAgB;IAwBxB,OAAO,CAAC,UAAU;IAuBX,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAatC,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,aAAa;CAUrB"}