@baltica/raknet 0.0.1

package/dist/shared/network-session.js

@@ -0,0 +1,480 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkSession = void 0;
+const binarystream_1 = require("@serenityjs/binarystream");
+const proto_1 = require("./proto");
+const utils_1 = require("@baltica/utils");
+const MTU_HEADER_SIZE = 36;
+const RECEIVE_WINDOW = 2048;
+const RELIABLE_WINDOW = 4096;
+const FRAGMENT_TIMEOUT = 30_000;
+const ORDER_QUEUE_MAX = 1024;
+const ORDER_SKIP_THRESHOLD = 512;
+const RAKNET_PROTOCOL = 11;
+const GAME_PACKET_ID = 0xfe;
+class NetworkSession extends utils_1.Emitter {
+    mtu;
+    client;
+    guid;
+    remoteGuid;
+    status = proto_1.Status.Disconnected;
+    address;
+    send;
+    serverMessage;
+    maxRetransmit = 3;
+    retransmitInterval = 1000;
+    outputReliableIndex = 0;
+    outputSplitIndex = 0;
+    outputSequence = 0;
+    outputSequenceIndex = new Array(32).fill(0);
+    outputOrderIndex = new Array(32).fill(0);
+    outputFrames = new Set();
+    outputBackup = new Map();
+    receivedFrameSequences = new Set();
+    lostFrameSequences = new Set();
+    pendingAcks = new Set();
+    lastInputSequence = -1;
+    fragmentsQueue = new Map();
+    inputHighestSequenceIndex = new Array(32).fill(0);
+    inputOrderIndex = new Array(32).fill(0);
+    inputOrderingQueue = new Map();
+    receivedReliableFrameIndices = new Set();
+    highestReliableIndex = -1;
+    offlineRetry = null;
+    outputBackupTimestamps = new Map();
+    constructor(mtu, client) {
+        super();
+        this.mtu = mtu;
+        this.client = client;
+        for (let i = 0; i < 32; i++)
+            this.inputOrderingQueue.set(i, new Map());
+    }
+    sendOfflineWithRetry(data) {
+        this.offlineRetry = { data, attempts: 1, maxAttempts: this.maxRetransmit, lastSent: Date.now(), interval: this.retransmitInterval };
+        this.send(data);
+    }
+    clearOfflineRetry() {
+        this.offlineRetry = null;
+    }
+    receive(buffer) {
+        const id = buffer[0];
+        const payload = buffer.subarray(1);
+        if (id === proto_1.Packet.Ack)
+            return this.onAck(new proto_1.Ack(payload).deserialize());
+        if (id === proto_1.Packet.Nack)
+            return this.onNack(new proto_1.Nack(payload).deserialize());
+        if (id >= proto_1.Packet.FrameSetMin && id <= proto_1.Packet.FrameSetMax)
+            return this.onFrameSet(new proto_1.FrameSet(payload).deserialize());
+        if (this.client)
+            this.handleClientOffline(id, buffer);
+        else
+            this.handleServerOffline(id, buffer);
+    }
+    handleClientOffline(id, buffer) {
+        const payload = buffer.subarray(1);
+        switch (id) {
+            case proto_1.Packet.UnconnectedPong: {
+                this.clearOfflineRetry();
+                const pong = new proto_1.UnconnectedPong(payload).deserialize();
+                this.serverMessage = pong.message;
+                this.remoteGuid = pong.guid;
+                this.emit("pong", pong.message);
+                break;
+            }
+            case proto_1.Packet.OpenConnectionReply1: {
+                this.clearOfflineRetry();
+                const reply = new proto_1.OpenConnectionReplyOne(payload).deserialize();
+                this.remoteGuid = reply.guid;
+                this.mtu = Math.min(this.mtu, reply.mtu);
+                const req = new proto_1.OpenConnectionRequestTwo();
+                req.address = this.address;
+                req.mtu = this.mtu;
+                req.guid = this.guid;
+                req.cookie = reply.cookie;
+                req.clientSupportsecurity = false;
+                this.sendOfflineWithRetry(req.serialize());
+                break;
+            }
+            case proto_1.Packet.OpenConnectionReply2: {
+                this.clearOfflineRetry();
+                const reply = new proto_1.OpenConnectionReplyTwo(payload).deserialize();
+                this.mtu = Math.min(this.mtu, reply.mtu);
+                this.status = proto_1.Status.Connecting;
+                const req = new proto_1.ConnectionRequest();
+                req.guid = this.guid;
+                req.timestamp = BigInt(Date.now());
+                req.useSecurity = false;
+                this.frameAndSend(req.serialize(), proto_1.Priority.High);
+                break;
+            }
+            case proto_1.Packet.AlreadyConnected: {
+                this.clearOfflineRetry();
+                this.status = proto_1.Status.Disconnected;
+                this.emit("disconnect");
+                break;
+            }
+            case proto_1.Packet.IncompatibleProtocolVersion: {
+                this.clearOfflineRetry();
+                this.status = proto_1.Status.Disconnected;
+                this.emit("error", new Error("Incompatible protocol version"));
+                break;
+            }
+        }
+    }
+    handleServerOffline(id, buffer) {
+        const payload = buffer.subarray(1);
+        switch (id) {
+            case proto_1.Packet.UnconnectedPing:
+            case proto_1.Packet.UnconnectedPingOpenConnections: {
+                const ping = new proto_1.UnconnectedPing(payload).deserialize();
+                const pong = new proto_1.UnconnectedPong();
+                pong.timestamp = ping.timestamp;
+                pong.guid = this.guid;
+                pong.message = this.serverMessage ?? "";
+                this.send(pong.serialize());
+                break;
+            }
+            case proto_1.Packet.OpenConnectionRequest1: {
+                const req = new proto_1.OpenConnectionRequestOne(payload).deserialize();
+                const reply = new proto_1.OpenConnectionReplyOne();
+                reply.guid = this.guid;
+                reply.security = false;
+                reply.cookie = null;
+                reply.hasCookie = false;
+                reply.serverPublicKey = null;
+                reply.mtu = Math.min(this.mtu, req.mtu);
+                this.send(reply.serialize());
+                break;
+            }
+            case proto_1.Packet.OpenConnectionRequest2: {
+                const req = new proto_1.OpenConnectionRequestTwo(payload).deserialize();
+                this.mtu = Math.min(this.mtu, req.mtu);
+                this.remoteGuid = req.guid;
+                this.address = req.address;
+                const reply = new proto_1.OpenConnectionReplyTwo();
+                reply.guid = this.guid;
+                reply.address = req.address;
+                reply.mtu = this.mtu;
+                reply.encryptionEnabled = false;
+                this.send(reply.serialize());
+                this.status = proto_1.Status.Connecting;
+                break;
+            }
+        }
+    }
+    handleOnlinePacket(payload) {
+        const id = payload[0];
+        const data = payload.subarray(1);
+        switch (id) {
+            case proto_1.Packet.ConnectionRequestAccepted: {
+                if (!this.client)
+                    break;
+                const accepted = new proto_1.ConnectionRequestAccepted(data).deserialize();
+                const nic = new proto_1.NewIncomingConnection();
+                nic.address = this.address;
+                nic.internalAddress = new proto_1.Address("0.0.0.0", 0, 4);
+                nic.incomingTimestamp = accepted.requestTimestamp;
+                nic.serverTimestamp = BigInt(Date.now());
+                this.frameAndSend(nic.serialize(), proto_1.Priority.High);
+                this.status = proto_1.Status.Connected;
+                this.emit("connect");
+                break;
+            }
+            case proto_1.Packet.ConnectionRequest: {
+                if (this.client)
+                    break;
+                const req = new proto_1.ConnectionRequest(data).deserialize();
+                const accepted = new proto_1.ConnectionRequestAccepted();
+                accepted.address = this.address;
+                accepted.systemIndex = 0;
+                accepted.addresses = Array.from({ length: 20 }, () => new proto_1.Address("0.0.0.0", 0, 4));
+                accepted.requestTimestamp = req.timestamp;
+                accepted.timestamp = BigInt(Date.now());
+                this.frameAndSend(accepted.serialize(), proto_1.Priority.High);
+                break;
+            }
+            case proto_1.Packet.NewIncomingConnection: {
+                if (this.client)
+                    break;
+                this.status = proto_1.Status.Connected;
+                this.emit("connect");
+                break;
+            }
+            case proto_1.Packet.ConnectedPing: {
+                const ping = new proto_1.ConnectedPing(data).deserialize();
+                const pong = new proto_1.ConnectedPong();
+                pong.pingTimestamp = ping.timestamp;
+                pong.pongTimestamp = BigInt(Date.now());
+                this.frameAndSend(pong.serialize(), proto_1.Priority.High);
+                break;
+            }
+            case proto_1.Packet.ConnectedPong:
+                break;
+            case proto_1.Packet.DisconnectionNotification:
+                this.status = proto_1.Status.Disconnected;
+                this.emit("disconnect");
+                break;
+            default:
+                if (id === GAME_PACKET_ID)
+                    this.emit("encapsulated", payload);
+                break;
+        }
+    }
+    tick() {
+        const now = Date.now();
+        if (this.offlineRetry) {
+            const r = this.offlineRetry;
+            if (now - r.lastSent >= r.interval) {
+                if (r.attempts >= r.maxAttempts) {
+                    this.offlineRetry = null;
+                    this.status = proto_1.Status.Disconnected;
+                    this.emit("error", new Error("Connection timed out after " + r.maxAttempts + " attempts"));
+                }
+                else {
+                    r.attempts++;
+                    r.lastSent = now;
+                    this.send(r.data);
+                }
+            }
+        }
+        const windowStart = this.lastInputSequence - RECEIVE_WINDOW;
+        if (windowStart > 0) {
+            for (const s of this.receivedFrameSequences)
+                if (s < windowStart)
+                    this.receivedFrameSequences.delete(s);
+            for (const s of this.lostFrameSequences)
+                if (s < windowStart)
+                    this.lostFrameSequences.delete(s);
+        }
+        const relStart = this.highestReliableIndex - RELIABLE_WINDOW;
+        if (relStart > 0) {
+            for (const i of this.receivedReliableFrameIndices)
+                if (i < relStart)
+                    this.receivedReliableFrameIndices.delete(i);
+        }
+        for (const [id, entry] of this.fragmentsQueue) {
+            if (now - entry.timestamp > FRAGMENT_TIMEOUT)
+                this.fragmentsQueue.delete(id);
+        }
+        if (this.pendingAcks.size > 0) {
+            const ack = new proto_1.Ack();
+            ack.sequences = [...this.pendingAcks];
+            this.pendingAcks.clear();
+            this.send(ack.serialize());
+        }
+        if (this.lostFrameSequences.size > 0) {
+            const nack = new proto_1.Nack();
+            nack.sequences = [...this.lostFrameSequences];
+            this.lostFrameSequences.clear();
+            this.send(nack.serialize());
+        }
+        // Retransmit unacked frame sets that are older than the retry interval
+        for (const [seq, sentAt] of this.outputBackupTimestamps) {
+            if (now - sentAt >= this.retransmitInterval) {
+                const frames = this.outputBackup.get(seq);
+                if (frames) {
+                    const fs = new proto_1.FrameSet();
+                    fs.sequence = seq;
+                    fs.frames = frames;
+                    this.send(fs.serialize());
+                    this.outputBackupTimestamps.set(seq, now);
+                }
+                else {
+                    this.outputBackupTimestamps.delete(seq);
+                }
+            }
+        }
+        if (this.outputFrames.size > 0)
+            this.flush();
+    }
+    onAck(ack) {
+        for (const seq of ack.sequences) {
+            this.outputBackup.delete(seq);
+            this.outputBackupTimestamps.delete(seq);
+        }
+    }
+    onNack(nack) {
+        for (const seq of nack.sequences) {
+            const frames = this.outputBackup.get(seq);
+            if (!frames)
+                continue;
+            const fs = new proto_1.FrameSet();
+            fs.sequence = seq;
+            fs.frames = frames;
+            this.send(fs.serialize());
+        }
+    }
+    frameAndSend(data, priority = proto_1.Priority.Medium) {
+        const frame = new proto_1.Frame();
+        frame.reliability = proto_1.Reliability.ReliableOrdered;
+        frame.orderChannel = 0;
+        frame.payload = data;
+        this.sendFrame(frame, priority);
+    }
+    sendFrame(frame, priority = proto_1.Priority.Medium) {
+        const channel = frame.orderChannel;
+        if (frame.isSequenced()) {
+            frame.orderedFrameIndex = this.outputOrderIndex[channel];
+            frame.sequenceFrameIndex = this.outputSequenceIndex[channel]++;
+        }
+        else if (frame.isOrdered()) {
+            frame.orderedFrameIndex = this.outputOrderIndex[channel]++;
+            this.outputSequenceIndex[channel] = 0;
+        }
+        const maxSize = this.mtu - MTU_HEADER_SIZE;
+        if (frame.payload.byteLength > maxSize) {
+            this.sendSplit(frame, maxSize, priority);
+        }
+        else {
+            if (frame.isReliable())
+                frame.reliableFrameIndex = this.outputReliableIndex++;
+            this.queueFrame(frame, priority);
+        }
+    }
+    sendSplit(frame, maxSize, priority) {
+        const payload = frame.payload;
+        const splitSize = Math.ceil(payload.byteLength / maxSize);
+        const splitId = this.outputSplitIndex++ & 0xffff;
+        for (let i = 0; i < splitSize; i++) {
+            const nf = new proto_1.Frame();
+            nf.reliability = frame.reliability;
+            nf.sequenceFrameIndex = frame.sequenceFrameIndex;
+            nf.orderedFrameIndex = frame.orderedFrameIndex;
+            nf.orderChannel = frame.orderChannel;
+            if (nf.isReliable())
+                nf.reliableFrameIndex = this.outputReliableIndex++;
+            nf.payload = payload.subarray(i * maxSize, Math.min((i + 1) * maxSize, payload.byteLength));
+            nf.splitFrameIndex = i;
+            nf.splitId = splitId;
+            nf.splitSize = splitSize;
+            this.queueFrame(nf, priority);
+        }
+    }
+    queueFrame(frame, priority) {
+        let length = 4;
+        for (const f of this.outputFrames)
+            length += f.getByteLength();
+        if (length + frame.getByteLength() > this.mtu - MTU_HEADER_SIZE)
+            this.flush();
+        this.outputFrames.add(frame);
+        if (priority === proto_1.Priority.High)
+            this.flush();
+    }
+    flush() {
+        if (this.outputFrames.size === 0)
+            return;
+        const fs = new proto_1.FrameSet();
+        fs.sequence = this.outputSequence++;
+        fs.frames = [...this.outputFrames];
+        this.outputBackup.set(fs.sequence, fs.frames);
+        this.outputBackupTimestamps.set(fs.sequence, Date.now());
+        this.outputFrames.clear();
+        const serialized = fs.serialize();
+        this.send(serialized);
+    }
+    onFrameSet(fs) {
+        if (this.receivedFrameSequences.has(fs.sequence))
+            return;
+        this.lostFrameSequences.delete(fs.sequence);
+        this.receivedFrameSequences.add(fs.sequence);
+        this.pendingAcks.add(fs.sequence);
+        if (fs.sequence > this.lastInputSequence) {
+            for (let i = this.lastInputSequence + 1; i < fs.sequence; i++) {
+                if (!this.receivedFrameSequences.has(i))
+                    this.lostFrameSequences.add(i);
+            }
+            this.lastInputSequence = fs.sequence;
+        }
+        for (const frame of fs.frames)
+            this.handleFrame(frame);
+    }
+    handleFrame(frame) {
+        if (frame.isReliable()) {
+            if (this.receivedReliableFrameIndices.has(frame.reliableFrameIndex))
+                return;
+            this.receivedReliableFrameIndices.add(frame.reliableFrameIndex);
+            if (frame.reliableFrameIndex > this.highestReliableIndex)
+                this.highestReliableIndex = frame.reliableFrameIndex;
+        }
+        if (frame.isSplit())
+            this.handleSplit(frame);
+        else if (frame.isSequenced())
+            this.handleSequenced(frame);
+        else if (frame.isOrdered())
+            this.handleOrdered(frame);
+        else
+            this.handleOnlinePacket(frame.payload);
+    }
+    handleSplit(frame) {
+        let entry = this.fragmentsQueue.get(frame.splitId);
+        if (!entry) {
+            entry = { frames: new Map(), timestamp: Date.now() };
+            this.fragmentsQueue.set(frame.splitId, entry);
+        }
+        entry.frames.set(frame.splitFrameIndex, frame);
+        if (entry.frames.size !== frame.splitSize)
+            return;
+        const stream = new binarystream_1.BinaryStream();
+        for (let i = 0; i < frame.splitSize; i++) {
+            const f = entry.frames.get(i);
+            if (!f) {
+                this.fragmentsQueue.delete(frame.splitId);
+                return;
+            }
+            stream.write(f.payload);
+        }
+        this.fragmentsQueue.delete(frame.splitId);
+        const reassembled = new proto_1.Frame();
+        reassembled.reliability = frame.reliability;
+        reassembled.reliableFrameIndex = frame.reliableFrameIndex;
+        reassembled.sequenceFrameIndex = frame.sequenceFrameIndex;
+        reassembled.orderedFrameIndex = frame.orderedFrameIndex;
+        reassembled.orderChannel = frame.orderChannel;
+        reassembled.splitSize = 0;
+        reassembled.payload = stream.getBuffer();
+        if (reassembled.isSequenced())
+            this.handleSequenced(reassembled);
+        else if (reassembled.isOrdered())
+            this.handleOrdered(reassembled);
+        else
+            this.handleOnlinePacket(reassembled.payload);
+    }
+    handleSequenced(frame) {
+        const ch = frame.orderChannel;
+        if (frame.sequenceFrameIndex < this.inputHighestSequenceIndex[ch])
+            return;
+        this.inputHighestSequenceIndex[ch] = frame.sequenceFrameIndex + 1;
+        this.handleOnlinePacket(frame.payload);
+    }
+    handleOrdered(frame) {
+        const ch = frame.orderChannel;
+        const expected = this.inputOrderIndex[ch];
+        if (frame.orderedFrameIndex === expected) {
+            this.inputHighestSequenceIndex[ch] = 0;
+            this.inputOrderIndex[ch] = expected + 1;
+            this.handleOnlinePacket(frame.payload);
+            const queue = this.inputOrderingQueue.get(ch);
+            let next = expected + 1;
+            while (queue.has(next)) {
+                this.handleOnlinePacket(queue.get(next).payload);
+                queue.delete(next);
+                next++;
+            }
+            this.inputOrderIndex[ch] = next;
+        }
+        else if (frame.orderedFrameIndex > expected) {
+            if (frame.orderedFrameIndex - expected > ORDER_SKIP_THRESHOLD) {
+                const queue = this.inputOrderingQueue.get(ch);
+                if (queue)
+                    queue.clear();
+                this.inputOrderIndex[ch] = frame.orderedFrameIndex + 1;
+                this.handleOnlinePacket(frame.payload);
+                return;
+            }
+            const queue = this.inputOrderingQueue.get(ch);
+            if (queue.size < ORDER_QUEUE_MAX)
+                queue.set(frame.orderedFrameIndex, frame);
+        }
+    }
+}
+exports.NetworkSession = NetworkSession;

package/dist/shared/proto/enums/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./packet";
+export * from "./reliability";
+export * from "./priority";
+export * from "./status";

package/dist/shared/proto/enums/index.js

@@ -0,0 +1,20 @@
+"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("./packet"), exports);
+__exportStar(require("./reliability"), exports);
+__exportStar(require("./priority"), exports);
+__exportStar(require("./status"), exports);

package/dist/shared/proto/enums/packet.d.ts

@@ -0,0 +1,21 @@
+export declare enum Packet {
+    UnconnectedPing = 1,
+    UnconnectedPingOpenConnections = 2,
+    UnconnectedPong = 28,
+    ConnectedPing = 0,
+    ConnectedPong = 3,
+    OpenConnectionRequest1 = 5,
+    OpenConnectionReply1 = 6,
+    OpenConnectionRequest2 = 7,
+    OpenConnectionReply2 = 8,
+    ConnectionRequest = 9,
+    ConnectionRequestAccepted = 16,
+    NewIncomingConnection = 19,
+    DisconnectionNotification = 21,
+    IncompatibleProtocolVersion = 25,
+    AlreadyConnected = 18,
+    Ack = 192,
+    Nack = 160,
+    FrameSetMin = 128,
+    FrameSetMax = 141
+}

package/dist/shared/proto/enums/packet.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Packet = void 0;
+var Packet;
+(function (Packet) {
+    Packet[Packet["UnconnectedPing"] = 1] = "UnconnectedPing";
+    Packet[Packet["UnconnectedPingOpenConnections"] = 2] = "UnconnectedPingOpenConnections";
+    Packet[Packet["UnconnectedPong"] = 28] = "UnconnectedPong";
+    Packet[Packet["ConnectedPing"] = 0] = "ConnectedPing";
+    Packet[Packet["ConnectedPong"] = 3] = "ConnectedPong";
+    Packet[Packet["OpenConnectionRequest1"] = 5] = "OpenConnectionRequest1";
+    Packet[Packet["OpenConnectionReply1"] = 6] = "OpenConnectionReply1";
+    Packet[Packet["OpenConnectionRequest2"] = 7] = "OpenConnectionRequest2";
+    Packet[Packet["OpenConnectionReply2"] = 8] = "OpenConnectionReply2";
+    Packet[Packet["ConnectionRequest"] = 9] = "ConnectionRequest";
+    Packet[Packet["ConnectionRequestAccepted"] = 16] = "ConnectionRequestAccepted";
+    Packet[Packet["NewIncomingConnection"] = 19] = "NewIncomingConnection";
+    Packet[Packet["DisconnectionNotification"] = 21] = "DisconnectionNotification";
+    Packet[Packet["IncompatibleProtocolVersion"] = 25] = "IncompatibleProtocolVersion";
+    Packet[Packet["AlreadyConnected"] = 18] = "AlreadyConnected";
+    Packet[Packet["Ack"] = 192] = "Ack";
+    Packet[Packet["Nack"] = 160] = "Nack";
+    Packet[Packet["FrameSetMin"] = 128] = "FrameSetMin";
+    Packet[Packet["FrameSetMax"] = 141] = "FrameSetMax";
+})(Packet || (exports.Packet = Packet = {}));

package/dist/shared/proto/enums/priority.d.ts

@@ -0,0 +1,6 @@
+export declare const Priority: {
+    readonly Low: 0;
+    readonly Medium: 1;
+    readonly High: 2;
+};
+export type Priority = (typeof Priority)[keyof typeof Priority];

package/dist/shared/proto/enums/priority.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Priority = void 0;
+exports.Priority = {
+    Low: 0,
+    Medium: 1,
+    High: 2,
+};

package/dist/shared/proto/enums/reliability.d.ts

@@ -0,0 +1,10 @@
+export declare enum Reliability {
+    Unreliable = 0,
+    UnreliableSequenced = 1,
+    Reliable = 2,
+    ReliableOrdered = 3,
+    ReliableSequenced = 4,
+    UnreliableWithAckReceipt = 5,
+    ReliableWithAckReceipt = 6,
+    ReliableOrderedWithAckReceipt = 7
+}

package/dist/shared/proto/enums/reliability.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reliability = void 0;
+var Reliability;
+(function (Reliability) {
+    Reliability[Reliability["Unreliable"] = 0] = "Unreliable";
+    Reliability[Reliability["UnreliableSequenced"] = 1] = "UnreliableSequenced";
+    Reliability[Reliability["Reliable"] = 2] = "Reliable";
+    Reliability[Reliability["ReliableOrdered"] = 3] = "ReliableOrdered";
+    Reliability[Reliability["ReliableSequenced"] = 4] = "ReliableSequenced";
+    Reliability[Reliability["UnreliableWithAckReceipt"] = 5] = "UnreliableWithAckReceipt";
+    Reliability[Reliability["ReliableWithAckReceipt"] = 6] = "ReliableWithAckReceipt";
+    Reliability[Reliability["ReliableOrderedWithAckReceipt"] = 7] = "ReliableOrderedWithAckReceipt";
+})(Reliability || (exports.Reliability = Reliability = {}));

package/dist/shared/proto/enums/status.d.ts

@@ -0,0 +1,6 @@
+export declare enum Status {
+    Connecting = 0,
+    Connected = 1,
+    Disconnecting = 2,
+    Disconnected = 3
+}

package/dist/shared/proto/enums/status.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = void 0;
+var Status;
+(function (Status) {
+    Status[Status["Connecting"] = 0] = "Connecting";
+    Status[Status["Connected"] = 1] = "Connected";
+    Status[Status["Disconnecting"] = 2] = "Disconnecting";
+    Status[Status["Disconnected"] = 3] = "Disconnected";
+})(Status || (exports.Status = Status = {}));

package/dist/shared/proto/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./packets";
+export * from "./types";
+export * from "./enums";

package/dist/shared/proto/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("./packets"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./enums"), exports);

package/dist/shared/proto/packets/data-packet.d.ts

@@ -0,0 +1,7 @@
+import { BinaryStream } from "@serenityjs/binarystream";
+import { Packet } from "../enums/packet";
+export declare class DataPacket extends BinaryStream {
+    static ID: Packet;
+    serialize(): Buffer;
+    deserialize(): this;
+}

package/dist/shared/proto/packets/data-packet.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataPacket = void 0;
+const binarystream_1 = require("@serenityjs/binarystream");
+class DataPacket extends binarystream_1.BinaryStream {
+    static ID;
+    serialize() {
+        throw new Error(`${this.constructor.name}.serialize is not implemented!`);
+    }
+    deserialize() {
+        throw new Error(`${this.constructor.name}.deserialize is not implemented!`);
+    }
+}
+exports.DataPacket = DataPacket;

package/dist/shared/proto/packets/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./data-packet";
+export * from "./offline";
+export * from "./online";