@sanctumterra/raknet 1.1.10 → 1.2.0

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

@@ -0,0 +1,21 @@
+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];
+    "open-connection-request-one": [OpenConnectionRequestOne];
+    "open-connection-request-two": [OpenConnectionRequestTwo];
+    "unconnected-ping": [UnconnectedPing];
+    "unconnected-pong": [UnconnectedPong];
+    frameset: [Frameset];
+    "connected-ping": [ConnectedPing];
+    "connection-request": [ConnectionRequest];
+    "new-incoming-connection": [NewIncomingConnection];
+    encapsulated: [Buffer];
+    ack: [Ack];
+    error: [Error];
+    close: [];
+    connect: [];
+    tick: [];
+}
+//# sourceMappingURL=client-evens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client-evens.d.ts","sourceRoot":"","sources":["../../src/client/client-evens.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,12 @@
+type ClientOptions = {
+    address: string;
+    port: number;
+    protocolVersion: number;
+    mtuSize: number;
+    clientId: bigint;
+    debug: boolean;
+    timeout: number;
+};
+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;CAChB,CAAC;AAEF,QAAA,MAAM,oBAAoB,EAAE,aAQ3B,CAAC;AAEF,OAAO,EAAE,KAAK,aAAa,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/client/client-options.js

@@ -0,0 +1,13 @@
+"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: 5000,
+};
+exports.defaultClientOptions = defaultClientOptions;

package/dist/client/client.d.ts

@@ -1,26 +1,26 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { type Options } from "./options";
+import { Emitter } from "@serenityjs/emitter";
+import type { ClientEvents } from "./client-evens";
 import { type Socket } from "node:dgram";
-import { Sender } from "./sender";
-import Emitter from "@serenityjs/emitter";
-import type { ClientEvents } from "./client-events";
-import { Receiver } from "./receiver";
-import type { Advertisement } from "./types/Advertisement";
-import { Status } from "@serenityjs/raknet";
-declare class Client extends Emitter<ClientEvents> {
-    options: Options;
-    tick: number;
+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> {
     socket: Socket;
-    status: Status;
-    receiver: Receiver;
-    sender: Sender;
-    private ticker;
-    constructor(options?: Partial<Options>);
+    framer: Framer;
+    options: ClientOptions;
+    private timer;
+    private timeout;
+    serverAddress: Address;
+    private waitingForReplyTwo;
+    private waitingForReplyOne;
+    constructor(options?: Partial<ClientOptions>);
+    initSocket(): void;
+    ping(): Promise<Advertisement | null>;
     connect(): Promise<Advertisement>;
-    ping(): Promise<Advertisement>;
-    send(packet: Buffer): void;
-    close(): void;
-    disconnect(): void;
+    sendFrame(frame: Frame, priority: Priority): void;
+    send(buffer: Buffer): void;
+    private waitForReply2;
+    private onMessage;
+    private waitForReply1;
 }
-export { Client };
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1 @@
+{"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,gBAAgB,CAAC;AACnD,OAAO,EAAmB,KAAK,MAAM,EAAe,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAO,OAAO,EAAE,KAAK,aAAa,EAAqB,KAAK,KAAK,EAA0H,QAAQ,EAAoC,MAAM,UAAU,CAAC;AAC/P,OAAO,EAAE,KAAK,aAAa,EAAwB,MAAM,kBAAkB,CAAC;AAI5E,qBACM,MAAO,SAAQ,OAAO,CAAC,YAAY,CAAC;IAC/B,MAAM,EAAG,MAAM,CAAC;IAChB,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAE,aAAa,CAAC;IAC9B,OAAO,CAAC,KAAK,CAAkB;IAClC,OAAO,CAAC,OAAO,CAAkB;IACvB,aAAa,EAAG,OAAO,CAAC;IAE/B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,kBAAkB,CAAS;gBAEvB,OAAO,GAAE,OAAO,CAAC,aAAa,CAAwB;IAK3D,UAAU;IAUJ,IAAI,IAAK,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAgBtC,OAAO,IAAK,OAAO,CAAC,aAAa,CAAC;IA+BxC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAIjD,IAAI,CAAC,MAAM,EAAE,MAAM;IAK1B,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,SAAS;IAoDjB,OAAO,CAAC,aAAa;CAaxB"}

package/dist/client/client.js

@@ -1,54 +1,171 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
-const options_1 = require("./options");
+const emitter_1 = require("@serenityjs/emitter");
 const node_dgram_1 = require("node:dgram");
-const sender_1 = require("./sender");
-const emitter_1 = __importDefault(require("@serenityjs/emitter"));
-const receiver_1 = require("./receiver");
-const raknet_1 = require("@serenityjs/raknet");
-const packets_1 = require("../packets");
-class Client extends emitter_1.default {
-    constructor(options = {}) {
+const framer_1 = require("./framer");
+const proto_1 = require("../proto");
+const client_options_1 = require("./client-options");
+const utils_1 = require("../utils");
+const frameset_1 = require("../proto/packets/frameset");
+class Client extends emitter_1.Emitter {
+    socket;
+    framer;
+    options;
+    timer;
+    timeout;
+    serverAddress;
+    waitingForReplyTwo = false;
+    waitingForReplyOne = false;
+    constructor(options = client_options_1.defaultClientOptions) {
         super();
-        this.tick = 0;
-        this.status = raknet_1.Status.Disconnected;
-        this.options = { ...options_1.defaultOptions, ...options };
-        this.socket = options.socket ?? (0, node_dgram_1.createSocket)("udp4");
-        this.receiver = new receiver_1.Receiver(this);
-        this.sender = new sender_1.Sender(this);
+        this.options = { ...client_options_1.defaultClientOptions, ...options };
+    }
+    initSocket() {
+        try {
+            this.socket = (0, node_dgram_1.createSocket)("udp4");
+            this.framer = new framer_1.Framer(this);
+            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) => {
+            this.on("unconnected-pong", (packet) => {
+                resolve((0, proto_1.fromString)(packet.message));
+            });
+            setTimeout(() => {
+                resolve(null);
+            }, this.options.timeout);
+            const unconnectedPing = new proto_1.UnconnectedPing();
+            unconnectedPing.guid = this.options.clientId;
+            unconnectedPing.clientTimestamp = BigInt(Date.now());
+            this.send(unconnectedPing.serialize());
+        });
     }
     async connect() {
-        this.ticker = setInterval(() => {
-            this.tick++;
+        this.initSocket();
+        this.timer = setInterval(() => {
             this.emit("tick");
-        }, 50).unref();
-        this.tick++;
-        this.status = raknet_1.Status.Connecting;
+        }, 50);
+        const request = new proto_1.OpenConnectionRequestOne();
+        request.mtu = this.options.mtuSize;
+        request.protocol = this.options.protocolVersion;
+        this.emit("open-connection-request-one", request);
         const advertisement = await this.ping();
-        await sender_1.Sender.connect(this);
-        return advertisement;
-    }
-    ping() {
-        return sender_1.Sender.ping(this);
-    }
-    send(packet) {
-        this.socket.send([packet], this.options.port, this.options.host);
-    }
-    close() {
-        this.emit("close");
-        this.socket.close();
-        // @ts-ignore
-        clearInterval(this.ticker);
-    }
-    disconnect() {
-        const packet = new packets_1.Disconnect();
-        this.sender.frameAndSend(packet.serialize(), raknet_1.Priority.Immediate);
-        this.on("ack", () => {
-            this.close();
+        return new Promise((resolve, reject) => {
+            if (this.timeout)
+                clearInterval(this.timeout);
+            this.timeout = setTimeout(() => {
+                this.removeAll();
+                this.socket.removeAllListeners();
+                this.socket.close();
+                clearInterval(this.timer);
+                clearInterval(this.timeout);
+                reject(new Error("Failed to connect, timed out."));
+            }, this.options.timeout);
+            this.once("ack", (packet) => {
+                if (advertisement) {
+                    clearInterval(this.timeout);
+                    resolve(advertisement);
+                }
+            });
+            this.waitForReply1();
+            this.send(request.serialize());
+        });
+    }
+    sendFrame(frame, priority) {
+        this.framer.sendFrame(frame, priority);
+    }
+    send(buffer) {
+        if (this.options.debug)
+            utils_1.Logger.debug(`Sending ${buffer[0]}, ${buffer.length} bytes to ${this.options.address}:${this.options.port}`);
+        this.socket.send(buffer, 0, buffer.length, this.options.port, this.options.address);
+    }
+    waitForReply2() {
+        if (this.waitingForReplyTwo)
+            return;
+        this.waitingForReplyTwo = true;
+        const timeout = setTimeout(() => {
+            this.waitingForReplyTwo = false;
+            if (this.options.debug)
+                utils_1.Logger.debug("Failed to receive OpenConnectionReplyTwo");
+            this.connect();
+        }, 500);
+        this.on("open-connection-reply-two", () => {
+            clearTimeout(timeout);
+            this.waitingForReplyTwo = false;
+        });
+    }
+    onMessage(msg, rinfo) {
+        try {
+            let packetId = msg.readUint8();
+            if ((msg[0] & 0xf0) === 0x80)
+                packetId = 0x80;
+            if (this.options.debug)
+                utils_1.Logger.debug(`Received packet ${packetId} from ${rinfo.address}:${rinfo.port}`);
+            switch (packetId) {
+                case proto_1.Packet.Ack: {
+                    const packet = new proto_1.Ack(msg).deserialize();
+                    // this.emit("ack", packet);
+                    break;
+                }
+                case proto_1.Packet.UnconnectedPong: {
+                    const packet = new proto_1.UnconnectedPong(msg).deserialize();
+                    this.emit("unconnected-pong", packet);
+                    break;
+                }
+                case proto_1.Packet.OpenConnectionReplyOne: {
+                    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.waitForReply2();
+                    this.emit("open-connection-request-two", request);
+                    this.send(request.serialize());
+                    break;
+                }
+                case proto_1.Packet.OpenConnectionReplyTwo: {
+                    const packet = new proto_1.OpenConnectionReplyTwo(msg).deserialize();
+                    this.emit("open-connection-reply-two", packet);
+                    const conReq = new proto_1.ConnectionRequest();
+                    conReq.clientGuid = this.options.clientId;
+                    conReq.timestamp = BigInt(Date.now());
+                    conReq.useSecurity = false;
+                    this.emit("connection-request", conReq);
+                    this.framer.frameAndSend(conReq.serialize(), proto_1.Priority.Immediate);
+                    break;
+                }
+                case proto_1.Packet.FrameSet: {
+                    const frameset = new frameset_1.Frameset(msg).deserialize();
+                    this.emit("frameset", frameset);
+                    this.framer.handle(frameset);
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            utils_1.Logger.error(`Failed to handle packet: ${error}`);
+        }
+    }
+    waitForReply1() {
+        if (this.waitingForReplyOne)
+            return;
+        this.waitingForReplyOne = true;
+        const timeout = setTimeout(() => {
+            this.waitingForReplyOne = false;
+            if (this.options.debug)
+                utils_1.Logger.debug("Failed to receive OpenConnectionReplyOne");
+            this.connect();
+        }, 500);
+        this.once("open-connection-reply-one", () => {
+            clearTimeout(timeout);
+            this.waitingForReplyOne = false;
         });
     }
 }

package/dist/client/framer.d.ts

@@ -0,0 +1,38 @@
+import { Frame, Priority } from "../proto";
+import { Frameset } from "../proto";
+import type { Client } from "./client";
+export declare class Framer {
+    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, Frame>>;
+    outputOrderIndex: number[];
+    outputSequenceIndex: number[];
+    outputFrameQueue: Frameset;
+    protected outputSequence: number;
+    protected outputSplitIndex: number;
+    protected outputReliableIndex: number;
+    protected outputFrames: Set<Frame>;
+    outputBackup: Map<number, Frame[]>;
+    constructor(client: Client);
+    tick(): void;
+    private processFrame;
+    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;
+}
+//# 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,EAKN,KAAK,EAGL,QAAQ,EAER,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAIvC,qBAAa,MAAM;IAClB,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,KAAK,CAAC,CAAC,CAAa;IAExE,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,aAAoB;IACnC,YAAY,uBAA8B;gBAErC,MAAM,EAAE,MAAM;IAcnB,IAAI;IAIX,OAAO,CAAC,YAAY;IAkCb,MAAM,CAAC,QAAQ,EAAE,QAAQ;IAsChC,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,oBAAoB;IAoB5B,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,4BAA4B;IA6B7B,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;IAsBxB,OAAO,CAAC,UAAU;IAiBX,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAStC"}

package/dist/client/framer.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Framer = void 0;
+const proto_1 = require("../proto");
+const proto_2 = require("../proto");
+const utils_1 = require("../utils");
+const binarystream_1 = require("@serenityjs/binarystream");
+const connection_request_accepted_1 = require("../proto/packets/connection-request-accepted");
+class Framer {
+    client;
+    lastInputSequence = -1;
+    receivedFrameSequences = new Set();
+    lostFrameSequences = new Set();
+    inputHighestSequenceIndex = new Array(64).fill(0);
+    inputOrderIndex = new Array(64).fill(0);
+    inputOrderingQueue = new Map();
+    fragmentsQueue = new Map();
+    outputOrderIndex;
+    outputSequenceIndex;
+    outputFrameQueue;
+    outputSequence = 0;
+    outputSplitIndex = 0;
+    outputReliableIndex = 0;
+    outputFrames = new Set();
+    outputBackup = new Map();
+    constructor(client) {
+        this.client = client;
+        this.outputFrameQueue = new proto_2.Frameset();
+        this.outputFrameQueue.frames = [];
+        this.outputOrderIndex = Array.from({ length: 32 }).fill(0);
+        this.outputSequenceIndex = Array.from({ length: 32 }).fill(0);
+        for (let index = 0; index < 64; index++) {
+            this.inputOrderingQueue.set(index, new Map());
+        }
+        this.client.on("tick", () => this.tick());
+    }
+    tick() {
+        this.sendQueue(this.outputFrames.size);
+    }
+    processFrame(frame) {
+        const header = frame.payload[0];
+        if (this.client.options.debug)
+            utils_1.Logger.debug(`Received FrameSet Packet ${header}`);
+        switch (header) {
+            case proto_1.Packet.ConnectedPing: {
+                const packet = new proto_1.ConnectedPing(frame.payload).deserialize();
+                this.client.emit("connected-ping", packet);
+                const pong = new proto_1.ConnectedPong();
+                pong.pongTime = BigInt(Date.now());
+                pong.pingTime = packet.timestamp;
+                this.frameAndSend(pong.serialize(), proto_1.Priority.Immediate);
+                break;
+            }
+            case proto_1.Packet.ConnectionRequestAccepted: {
+                const packet = new connection_request_accepted_1.ConnectionRequestAccepted(frame.payload).deserialize();
+                const newI = new proto_1.NewIncomingConnection();
+                newI.serverAddress = this.client.serverAddress;
+                newI.internalAddresses = packet.systemAddresses;
+                newI.incomingTimestamp = BigInt(Date.now());
+                newI.serverTimestamp = packet.timestamp;
+                this.client.emit("new-incoming-connection", newI);
+                this.frameAndSend(newI.serialize(), proto_1.Priority.Immediate);
+                break;
+            }
+            case 254: {
+                this.client.emit("encapsulated", frame.payload);
+                break;
+            }
+        }
+    }
+    handle(frameSet) {
+        if (this.receivedFrameSequences.has(frameSet.sequence)) {
+            if (this.client.options.debug)
+                utils_1.Logger.debug(`Received duplicate frameset ${frameSet.sequence}`);
+            return;
+        }
+        this.lostFrameSequences.delete(frameSet.sequence);
+        if (frameSet.sequence < this.lastInputSequence ||
+            frameSet.sequence === this.lastInputSequence) {
+            if (this.client.options.debug)
+                utils_1.Logger.debug(`Received out of order frameset ${frameSet.sequence}!`);
+            return;
+        }
+        this.receivedFrameSequences.add(frameSet.sequence);
+        const diff = frameSet.sequence - this.lastInputSequence;
+        if (diff !== 1) {
+            for (let index = this.lastInputSequence + 1; index < frameSet.sequence; index++) {
+                if (!this.receivedFrameSequences.has(index)) {
+                    this.lostFrameSequences.add(index);
+                }
+            }
+        }
+        this.lastInputSequence = frameSet.sequence;
+        for (const frame of frameSet.frames) {
+            this.handleFrame(frame);
+        }
+    }
+    handleFrame(frame) {
+        if (frame.isSplit) {
+            this.handleSplit(frame);
+        }
+        else if (frame.isSequenced) {
+            this.handleSequenced(frame);
+        }
+        else if (frame.isOrdered) {
+            this.handleOrdered(frame);
+        }
+        else {
+            this.processFrame(frame);
+        }
+    }
+    handleOrdered(frame) {
+        const expectedOrderIndex = this.inputOrderIndex[frame.orderChannel];
+        const outOfOrderQueue = this.inputOrderingQueue.get(frame.orderChannel);
+        if (frame.orderedFrameIndex === expectedOrderIndex) {
+            this.processOrderedFrames(frame, outOfOrderQueue);
+        }
+        else if (frame.orderedFrameIndex > expectedOrderIndex) {
+            if (this.client.options.debug)
+                utils_1.Logger.debug(`Queuing out-of-order frame: ${frame.orderedFrameIndex}`);
+            outOfOrderQueue.set(frame.orderedFrameIndex, frame);
+        }
+        else {
+            if (this.client.options.debug)
+                utils_1.Logger.debug(`Discarding old frame: ${frame.orderedFrameIndex}`);
+        }
+    }
+    processOrderedFrames(frame, outOfOrderQueue) {
+        this.processFrame(frame);
+        this.inputOrderIndex[frame.orderChannel]++;
+        let nextOrderIndex = this.inputOrderIndex[frame.orderChannel];
+        while (outOfOrderQueue.has(nextOrderIndex)) {
+            const nextFrame = outOfOrderQueue.get(nextOrderIndex);
+            if (nextFrame) {
+                if (this.client.options.debug)
+                    console.debug(`Processing queued frame: ${nextOrderIndex}`);
+                this.processFrame(nextFrame);
+                outOfOrderQueue.delete(nextOrderIndex);
+                this.inputOrderIndex[frame.orderChannel]++;
+                nextOrderIndex++;
+            }
+        }
+    }
+    handleSequenced(frame) {
+        const currentHighestSequence = this.inputHighestSequenceIndex[frame.orderChannel];
+        if (this.client.options.debug)
+            utils_1.Logger.debug(`Handling sequenced frame: sequenceFrameIndex=${frame.sequenceFrameIndex}, currentHighest=${currentHighestSequence}`);
+        if (frame.sequenceFrameIndex > currentHighestSequence) {
+            this.inputHighestSequenceIndex[frame.orderChannel] =
+                frame.sequenceFrameIndex;
+            this.processFrame(frame);
+        }
+        else {
+            if (this.client.options.debug)
+                utils_1.Logger.debug(`Discarding old sequenced frame: ${frame.sequenceFrameIndex}`);
+        }
+    }
+    handleSplit(frame) {
+        if (!this.fragmentsQueue.has(frame.splitId)) {
+            this.fragmentsQueue.set(frame.splitId, new Map());
+        }
+        const fragment = this.fragmentsQueue.get(frame.splitId);
+        if (!fragment)
+            return;
+        fragment.set(frame.splitFrameIndex, frame);
+        if (fragment.size === frame.splitCount) {
+            this.reassembleAndProcessFragment(frame, fragment);
+        }
+    }
+    reassembleAndProcessFragment(frame, fragment) {
+        const stream = new binarystream_1.BinaryStream();
+        for (let index = 0; index < fragment.size; index++) {
+            const sframe = fragment.get(index);
+            if (sframe) {
+                stream.writeBuffer(sframe.payload);
+            }
+            else {
+                utils_1.Logger.error(`Missing fragment at index ${index} for splitId=${frame.splitId}`);
+                return;
+            }
+        }
+        const reassembledFrame = new proto_1.Frame();
+        reassembledFrame.reliability = frame.reliability;
+        reassembledFrame.reliableFrameIndex = frame.reliableFrameIndex;
+        reassembledFrame.sequenceFrameIndex = frame.sequenceFrameIndex;
+        reassembledFrame.orderedFrameIndex = frame.orderedFrameIndex;
+        reassembledFrame.orderChannel = frame.orderChannel;
+        reassembledFrame.payload = stream.getBuffer();
+        this.fragmentsQueue.delete(frame.splitId);
+        this.handleFrame(reassembledFrame);
+    }
+    frameAndSend(payload, priority = proto_1.Priority.Normal) {
+        const frame = new proto_1.Frame();
+        frame.reliability = proto_1.Reliability.ReliableOrdered;
+        frame.orderChannel = 0;
+        frame.payload = payload;
+        this.sendFrame(frame, priority);
+    }
+    sendFrame(frame, priority) {
+        if (frame.isSequenced) {
+            frame.orderedFrameIndex = this.outputOrderIndex[frame.orderChannel];
+            frame.sequenceFrameIndex = this.outputSequenceIndex[frame.orderChannel]++;
+        }
+        else if (frame.isOrdered) {
+            frame.orderedFrameIndex = this.outputOrderIndex[frame.orderChannel]++;
+            this.outputSequenceIndex[frame.orderChannel] = 0;
+        }
+        const maxSize = this.client.options.mtuSize - 36;
+        const splitSize = Math.ceil(frame.payload.byteLength / maxSize);
+        if (frame.payload.byteLength > maxSize) {
+            this.handleLargePayload(frame, maxSize, splitSize);
+        }
+        else {
+            if (frame.isReliable)
+                frame.reliableFrameIndex = this.outputReliableIndex++;
+            this.queueFrame(frame, priority);
+        }
+    }
+    handleLargePayload(frame, maxSize, splitSize) {
+        const splitId = this.outputSplitIndex++ % 65_536;
+        for (let index = 0; index < frame.payload.byteLength; index += maxSize) {
+            const nframe = this.createSplitFrame(frame, index, maxSize, splitId, splitSize);
+            this.queueFrame(nframe, proto_1.Priority.Immediate);
+        }
+    }
+    createSplitFrame(originalFrame, index, maxSize, splitId, splitSize) {
+        const nframe = new proto_1.Frame();
+        nframe.reliability = originalFrame.reliability;
+        nframe.sequenceFrameIndex = originalFrame.sequenceFrameIndex;
+        nframe.orderedFrameIndex = originalFrame.orderedFrameIndex;
+        nframe.orderChannel = originalFrame.orderChannel;
+        nframe.payload = originalFrame.payload.subarray(index, index + maxSize);
+        nframe.splitId = splitId;
+        nframe.splitCount = splitSize;
+        if (nframe.isReliable) {
+            nframe.reliableFrameIndex = this.outputReliableIndex++;
+        }
+        return nframe;
+    }
+    queueFrame(frame, priority) {
+        let length = 4;
+        for (const queuedFrame of this.outputFrames) {
+            length += queuedFrame.getByteLength();
+        }
+        if (length + frame.getByteLength() > this.client.options.mtuSize - 36) {
+            this.sendQueue(this.outputFrames.size);
+        }
+        this.outputFrames.add(frame);
+        if (priority === proto_1.Priority.Immediate) {
+            this.sendQueue(1);
+        }
+    }
+    sendQueue(amount) {
+        if (this.outputFrames.size === 0)
+            return;
+        const frameset = new proto_2.Frameset();
+        frameset.sequence = this.outputSequence++;
+        frameset.frames = [...this.outputFrames].slice(0, amount);
+        this.outputBackup.set(frameset.sequence, frameset.frames);
+        for (const frame of frameset.frames)
+            this.outputFrames.delete(frame);
+        this.client.send(frameset.serialize());
+    }
+}
+exports.Framer = Framer;

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./client-evens";
+export * from "./client";
+export * from "./client-options";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC"}

package/dist/client/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client-evens"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./client-options"), exports);