raknet-typeo 1.0.0

package/src/protocol/offline.js

@@ -0,0 +1,151 @@
+import { BinaryStream } from "../utils/binary-stream.js";
+import { MessageId, OFFLINE_MESSAGE_DATA_ID, RAKNET_PROTOCOL_VERSION } from "../constants.js";
+
+export function isOfflineMessage(buf) {
+  if (buf.length < 1) return false;
+  const id = buf[0];
+  const offlineIds = [
+    MessageId.UnconnectedPing,
+    MessageId.UnconnectedPingOpenConn,
+    MessageId.UnconnectedPong,
+    MessageId.OpenConnectionRequest1,
+    MessageId.OpenConnectionReply1,
+    MessageId.OpenConnectionRequest2,
+    MessageId.OpenConnectionReply2,
+    MessageId.IncompatibleProtocolVersion,
+    MessageId.AlreadyConnected,
+    MessageId.NoFreeIncomingConnections,
+    MessageId.ConnectionBanned,
+    MessageId.IpRecentlyConnected,
+  ];
+  return offlineIds.includes(id);
+}
+
+export function hasOfflineDataId(buf, offset) {
+  if (buf.length < offset + 16) return false;
+  return OFFLINE_MESSAGE_DATA_ID.equals(buf.slice(offset, offset + 16));
+}
+
+export function readUnconnectedPing(buf) {
+  const s = new BinaryStream(buf);
+  s.skip(1);
+  const sendTimestamp = s.readInt64BE();
+  if (!hasOfflineDataId(buf, s.offset)) return null;
+  s.skip(16);
+  const clientGuid = s.readInt64BE();
+  return { sendTimestamp, clientGuid };
+}
+
+export function writeUnconnectedPong(sendTimestamp, serverGuid, motd) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.UnconnectedPong);
+  s.writeInt64BE(sendTimestamp);
+  s.writeInt64BE(serverGuid);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeString(motd);
+  return s.flush();
+}
+
+export function writeUnconnectedPing(sendTimestamp, clientGuid, openConnections = false) {
+  const s = new BinaryStream();
+  s.writeByte(openConnections ? MessageId.UnconnectedPingOpenConn : MessageId.UnconnectedPing);
+  s.writeInt64BE(sendTimestamp);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(clientGuid);
+  return s.flush();
+}
+
+export function readOpenConnectionRequest1(buf) {
+  const s = new BinaryStream(buf);
+  s.skip(1);
+  if (!hasOfflineDataId(buf, s.offset)) return null;
+  s.skip(16);
+  const protocol = s.readByte();
+  const mtu = buf.length + 28;
+  return { protocol, mtu };
+}
+
+export function writeOpenConnectionReply1(serverGuid, mtu) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.OpenConnectionReply1);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(serverGuid);
+  s.writeBool(false);
+  s.writeUInt16BE(mtu);
+  return s.flush();
+}
+
+export function readOpenConnectionRequest2(buf) {
+  const s = new BinaryStream(buf);
+  s.skip(1);
+  if (!hasOfflineDataId(buf, s.offset)) return null;
+  s.skip(16);
+  const addr      = s.readAddress();
+  const mtu       = s.readUInt16BE();
+  const clientGuid = s.readInt64BE();
+  return { serverAddress: addr.address, serverPort: addr.port, mtu, clientGuid };
+}
+
+export function writeOpenConnectionReply2(serverGuid, clientAddress, clientPort, mtu) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.OpenConnectionReply2);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(serverGuid);
+  s.writeAddress(clientAddress, clientPort, 4);
+  s.writeUInt16BE(mtu);
+  s.writeBool(false);
+  return s.flush();
+}
+
+export function writeIncompatibleProtocolVersion(serverGuid) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.IncompatibleProtocolVersion);
+  s.writeByte(RAKNET_PROTOCOL_VERSION);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(serverGuid);
+  return s.flush();
+}
+
+export function writeNoFreeIncomingConnections(serverGuid) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.NoFreeIncomingConnections);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(serverGuid);
+  return s.flush();
+}
+
+export function writeAlreadyConnected(serverGuid) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.AlreadyConnected);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(serverGuid);
+  return s.flush();
+}
+
+export function writeConnectionBanned(serverGuid) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.ConnectionBanned);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeInt64BE(serverGuid);
+  return s.flush();
+}
+
+export function writeOpenConnectionRequest1(mtu) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.OpenConnectionRequest1);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeByte(RAKNET_PROTOCOL_VERSION);
+  const padding = mtu - 28 - 1 - 16 - 1;
+  if (padding > 0) s.writeBytes(Buffer.alloc(padding, 0));
+  return s.flush();
+}
+
+export function writeOpenConnectionRequest2(serverAddress, serverPort, mtu, clientGuid) {
+  const s = new BinaryStream();
+  s.writeByte(MessageId.OpenConnectionRequest2);
+  s.writeBytes(OFFLINE_MESSAGE_DATA_ID);
+  s.writeAddress(serverAddress, serverPort, 4);
+  s.writeUInt16BE(mtu);
+  s.writeInt64BE(clientGuid);
+  return s.flush();
+}

package/src/server.js

@@ -0,0 +1,161 @@
+import { EventEmitter } from "events";
+import { Connection } from "./connection.js";
+import {
+  isOfflineMessage,
+  readUnconnectedPing,
+  writeUnconnectedPong,
+  readOpenConnectionRequest1,
+  writeOpenConnectionReply1,
+  readOpenConnectionRequest2,
+  writeOpenConnectionReply2,
+  writeIncompatibleProtocolVersion,
+  writeNoFreeIncomingConnections,
+  writeAlreadyConnected,
+} from "./protocol/offline.js";
+import {
+  MessageId,
+  PacketReliability,
+  PacketPriority,
+  RAKNET_PROTOCOL_VERSION,
+  DATAGRAM_FLAG,
+  ACK_FLAG,
+  NACK_FLAG,
+  MAX_MTU_SIZE,
+} from "./constants.js";
+import { UdpTransport } from "./transport/udp.js";
+
+export class RakServer extends EventEmitter {
+  constructor(address, port, guid, maxConnections = 20, motd = "MCPE;Server;390;1.14.0;0;20;0;world;Survival;1;", options = {}) {
+    super();
+    this.address         = address;
+    this.port            = port;
+    this._guid           = guid ?? randomBigInt();
+    this._maxConnections = maxConnections;
+    this._motd           = motd;
+    this._transport      = options.transport ?? new UdpTransport();
+    this._connections    = new Map();
+    this._bound          = false;
+    this._setupTransport();
+  }
+
+  _setupTransport() {
+    this._transport.onError((err) => this.emit("error", err));
+    this._transport.onMessage((msg, rinfo) => this._handleMessage(msg, rinfo.address, rinfo.port));
+  }
+
+  listen() {
+    return new Promise((resolve, reject) => {
+      this._transport.bind(this.port, this.address)
+        .then(() => { this._bound = true; this.emit("listening"); resolve(); })
+        .catch(reject);
+    });
+  }
+
+  _key(address, port) { return `${address}:${port}`; }
+
+  _handleMessage(msg, address, port) {
+    if (msg.length === 0) return;
+    const flag = msg[0];
+
+    if (isOfflineMessage(msg)) {
+      this._handleOffline(msg, address, port, flag);
+      return;
+    }
+
+    const conn = this._connections.get(this._key(address, port));
+    if (conn) {
+      if (
+        (flag & DATAGRAM_FLAG) === DATAGRAM_FLAG ||
+        (flag & ACK_FLAG)      === ACK_FLAG       ||
+        (flag & NACK_FLAG)     === NACK_FLAG
+      ) {
+        conn.handleDatagram(msg);
+      }
+    }
+  }
+
+  _handleOffline(msg, address, port, id) {
+    const sendFn = (buf, a, p) => this._transport.send(buf, a, p);
+
+    switch (id) {
+      case MessageId.UnconnectedPing:
+      case MessageId.UnconnectedPingOpenConn: {
+        const ping = readUnconnectedPing(msg);
+        if (!ping) return;
+        this._transport.send(writeUnconnectedPong(ping.sendTimestamp, this._guid, this._motd), address, port);
+        this.emit("ping", { address, port, guid: ping.clientGuid });
+        break;
+      }
+
+      case MessageId.OpenConnectionRequest1: {
+        const req     = readOpenConnectionRequest1(msg);
+        if (!req) return;
+        const connKey = this._key(address, port);
+        if (this._connections.has(connKey)) { this._transport.send(writeAlreadyConnected(this._guid), address, port); return; }
+        if (req.protocol !== RAKNET_PROTOCOL_VERSION) { this._transport.send(writeIncompatibleProtocolVersion(this._guid), address, port); return; }
+        if (this._connections.size >= this._maxConnections) { this._transport.send(writeNoFreeIncomingConnections(this._guid), address, port); return; }
+        this._transport.send(writeOpenConnectionReply1(this._guid, Math.min(req.mtu, MAX_MTU_SIZE)), address, port);
+        break;
+      }
+
+      case MessageId.OpenConnectionRequest2: {
+        const req     = readOpenConnectionRequest2(msg);
+        if (!req) return;
+        const connKey = this._key(address, port);
+        if (this._connections.has(connKey)) { this._transport.send(writeAlreadyConnected(this._guid), address, port); return; }
+        if (this._connections.size >= this._maxConnections) { this._transport.send(writeNoFreeIncomingConnections(this._guid), address, port); return; }
+
+        this._transport.send(writeOpenConnectionReply2(this._guid, address, port, req.mtu), address, port);
+        const conn = new Connection(address, port, req.clientGuid, sendFn, req.mtu);
+        this._registerConnection(conn, connKey);
+        break;
+      }
+    }
+  }
+
+  _registerConnection(conn, connKey) {
+    conn.on("connected", () => this.emit("connect", conn));
+    conn.on("disconnected", (reason) => { this._connections.delete(connKey); this.emit("disconnect", conn, reason); });
+    conn.on("timeout",      ()       => { this._connections.delete(connKey); this.emit("disconnect", conn, "timeout"); });
+    conn.on("encapsulated", (packet) => {
+      this.emit("encapsulated", packet, { address: conn.address, port: conn.port });
+      this.emit("message", packet, conn);
+    });
+    conn.on("error", (err) => this.emit("error", err));
+    this._connections.set(connKey, conn);
+    conn.start();
+  }
+
+  send(buf, address, port, priority, reliability, channel) {
+    this._connections.get(this._key(address, port))?.sendEncapsulated(buf, priority, reliability, channel);
+  }
+
+  broadcast(buf, priority, reliability, channel) {
+    for (const conn of this._connections.values()) conn.sendEncapsulated(buf, priority, reliability, channel);
+  }
+
+  getConnection(address, port) { return this._connections.get(this._key(address, port)); }
+  getConnections()              { return [...this._connections.values()]; }
+
+  closeConnection(address, port) {
+    const key  = this._key(address, port);
+    const conn = this._connections.get(key);
+    if (conn) { conn.close(true); this._connections.delete(key); this.emit("disconnect", conn, "server_closed"); }
+  }
+
+  setMotd(motd) { this._motd = motd; }
+
+  close() {
+    for (const conn of this._connections.values()) conn.close(true);
+    this._connections.clear();
+    if (!this._bound) return Promise.resolve();
+    this._bound = false;
+    return this._transport.close();
+  }
+}
+
+function randomBigInt() {
+  const hi = BigInt(Math.floor(Math.random() * 0x7fffffff));
+  const lo = BigInt(Math.floor(Math.random() * 0xffffffff));
+  return (hi << 32n) | lo;
+}

package/src/transport/udp.js

@@ -0,0 +1,38 @@
+import * as dgram from "dgram";
+
+export class UdpTransport {
+  constructor() {
+    this._socket = dgram.createSocket({ type: "udp4", reuseAddr: true });
+  }
+
+  getRawSocket() { return this._socket; }
+
+  send(buf, address, port) {
+    this._socket.send(buf, 0, buf.length, port, address);
+  }
+
+  bind(port, address) {
+    return new Promise((resolve, reject) => {
+      this._socket.once("error", reject);
+      this._socket.bind(port, address ?? "0.0.0.0", () => {
+        this._socket.off("error", reject);
+        resolve();
+      });
+    });
+  }
+
+  onMessage(handler) {
+    this._socket.on("message", (msg, rinfo) => {
+      handler(msg, { address: rinfo.address, port: rinfo.port });
+    });
+  }
+
+  onError(handler) { this._socket.on("error", handler); }
+
+  close() {
+    return new Promise((resolve) => {
+      try { this._socket.close(() => resolve()); }
+      catch { resolve(); }
+    });
+  }
+}

package/src/transport/websocket.js

@@ -0,0 +1,138 @@
+import * as http from "http";
+import * as https from "https";
+import { WebSocket, WebSocketServer } from "ws";
+
+let virtualPortCounter = 10000;
+function nextVirtualPort() { return virtualPortCounter++; }
+
+export class WebSocketServerTransport {
+  constructor(tlsOptions) {
+    this._tlsOptions     = tlsOptions;
+    this._messageHandler = undefined;
+    this._errorHandler   = undefined;
+    this._peers          = new Map();
+  }
+
+  bind(port, address) {
+    return new Promise((resolve, reject) => {
+      this._httpServer = this._tlsOptions
+        ? https.createServer(this._tlsOptions)
+        : http.createServer();
+
+      this._wss = new WebSocketServer({ server: this._httpServer });
+
+      this._wss.on("connection", (ws, req) => {
+        const remoteIp =
+          (req.headers["x-forwarded-for"])
+            ?.split(",")[0]
+            ?.trim() ?? req.socket.remoteAddress ?? "0.0.0.0";
+        const virtualPort = nextVirtualPort();
+        const key = `${remoteIp}:${virtualPort}`;
+        this._peers.set(key, ws);
+
+        ws.on("message", (data) => {
+          const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+          this._messageHandler?.(buf, { address: remoteIp, port: virtualPort });
+        });
+
+        ws.on("close", () => {
+          this._peers.delete(key);
+          this._messageHandler?.(Buffer.from([0x15]), { address: remoteIp, port: virtualPort });
+        });
+
+        ws.on("error", (err) => this._errorHandler?.(err));
+      });
+
+      this._wss.on("error", (err) => { this._errorHandler?.(err); reject(err); });
+      this._httpServer.listen(port, address ?? "0.0.0.0", () => resolve());
+    });
+  }
+
+  send(buf, address, port) {
+    const ws = this._peers.get(`${address}:${port}`);
+    if (ws && ws.readyState === WebSocket.OPEN) ws.send(buf);
+  }
+
+  onMessage(handler) { this._messageHandler = handler; }
+  onError(handler)   { this._errorHandler   = handler; }
+
+  close() {
+    return new Promise((resolve) => {
+      for (const ws of this._peers.values()) ws.terminate();
+      this._peers.clear();
+      this._wss.close(() => this._httpServer.close(() => resolve()));
+    });
+  }
+
+  getHttpServer() { return this._httpServer; }
+
+  mountOnExisting(server, path = "/raknet") {
+    this._httpServer = server;
+    this._wss = new WebSocketServer({ server, path });
+
+    this._wss.on("connection", (ws, req) => {
+      const remoteIp =
+        (req.headers["x-forwarded-for"])
+          ?.split(",")[0]
+          ?.trim() ?? req.socket.remoteAddress ?? "0.0.0.0";
+      const virtualPort = nextVirtualPort();
+      const key = `${remoteIp}:${virtualPort}`;
+      this._peers.set(key, ws);
+
+      ws.on("message", (data) => {
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        this._messageHandler?.(buf, { address: remoteIp, port: virtualPort });
+      });
+
+      ws.on("close", () => {
+        this._peers.delete(key);
+        this._messageHandler?.(Buffer.from([0x15]), { address: remoteIp, port: virtualPort });
+      });
+
+      ws.on("error", (err) => this._errorHandler?.(err));
+    });
+  }
+}
+
+export class WebSocketClientTransport {
+  constructor(serverUrl) {
+    this._serverUrl      = serverUrl;
+    this._serverAddress  = serverUrl;
+    this._serverPort     = 0;
+    this._messageHandler = undefined;
+    this._errorHandler   = undefined;
+  }
+
+  bind(_port, _address) {
+    return new Promise((resolve, reject) => {
+      this._ws = new WebSocket(this._serverAddress);
+      this._ws.binaryType = "nodebuffer";
+
+      this._ws.on("open", () => resolve());
+      this._ws.on("error", (err) => { this._errorHandler?.(err); reject(err); });
+
+      this._ws.on("message", (data) => {
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        this._messageHandler?.(buf, { address: this._serverAddress, port: this._serverPort });
+      });
+
+      this._ws.on("close", () => {
+        this._messageHandler?.(Buffer.from([0x15]), { address: this._serverAddress, port: this._serverPort });
+      });
+    });
+  }
+
+  send(buf, _address, _port) {
+    if (this._ws && this._ws.readyState === WebSocket.OPEN) this._ws.send(buf);
+  }
+
+  onMessage(handler) { this._messageHandler = handler; }
+  onError(handler)   { this._errorHandler   = handler; }
+
+  close() {
+    return new Promise((resolve) => {
+      if (this._ws) { this._ws.once("close", () => resolve()); this._ws.close(); }
+      else resolve();
+    });
+  }
+}

package/src/utils/binary-stream.js

@@ -0,0 +1,184 @@
+export class BinaryStream {
+  constructor(buffer) {
+    this._buffer = buffer ? Buffer.from(buffer) : Buffer.alloc(0);
+    this._offset = 0;
+  }
+
+  get buffer() { return this._buffer; }
+  get offset()  { return this._offset; }
+  get length()  { return this._buffer.length; }
+  get remaining() { return this._buffer.length - this._offset; }
+
+  seek(offset) { this._offset = offset; }
+  skip(n)      { this._offset += n; }
+
+  _grow(n) {
+    const needed = this._offset + n;
+    if (needed > this._buffer.length) {
+      const extended = Buffer.alloc(needed);
+      this._buffer.copy(extended);
+      this._buffer = extended;
+    }
+  }
+
+  readByte()  { return this._buffer.readUInt8(this._offset++); }
+  writeByte(value) {
+    this._grow(1);
+    this._buffer.writeUInt8(value & 0xff, this._offset++);
+  }
+
+  readBytes(n) {
+    const slice = this._buffer.slice(this._offset, this._offset + n);
+    this._offset += n;
+    return slice;
+  }
+
+  writeBytes(buf) {
+    this._grow(buf.length);
+    buf.copy(this._buffer, this._offset);
+    this._offset += buf.length;
+  }
+
+  readBool()         { return this.readByte() !== 0; }
+  writeBool(value)   { this.writeByte(value ? 1 : 0); }
+
+  readUInt16BE() {
+    const v = this._buffer.readUInt16BE(this._offset);
+    this._offset += 2;
+    return v;
+  }
+  writeUInt16BE(value) {
+    this._grow(2);
+    this._buffer.writeUInt16BE(value & 0xffff, this._offset);
+    this._offset += 2;
+  }
+
+  readUInt16LE() {
+    const v = this._buffer.readUInt16LE(this._offset);
+    this._offset += 2;
+    return v;
+  }
+  writeUInt16LE(value) {
+    this._grow(2);
+    this._buffer.writeUInt16LE(value & 0xffff, this._offset);
+    this._offset += 2;
+  }
+
+  readUInt24LE() {
+    const a = this._buffer.readUInt8(this._offset);
+    const b = this._buffer.readUInt8(this._offset + 1);
+    const c = this._buffer.readUInt8(this._offset + 2);
+    this._offset += 3;
+    return a | (b << 8) | (c << 16);
+  }
+  writeUInt24LE(value) {
+    this._grow(3);
+    this._buffer.writeUInt8(value & 0xff, this._offset);
+    this._buffer.writeUInt8((value >> 8) & 0xff, this._offset + 1);
+    this._buffer.writeUInt8((value >> 16) & 0xff, this._offset + 2);
+    this._offset += 3;
+  }
+
+  readInt32BE() {
+    const v = this._buffer.readInt32BE(this._offset);
+    this._offset += 4;
+    return v;
+  }
+  writeInt32BE(value) {
+    this._grow(4);
+    this._buffer.writeInt32BE(value, this._offset);
+    this._offset += 4;
+  }
+
+  readUInt32BE() {
+    const v = this._buffer.readUInt32BE(this._offset);
+    this._offset += 4;
+    return v;
+  }
+  writeUInt32BE(value) {
+    this._grow(4);
+    this._buffer.writeUInt32BE(value >>> 0, this._offset);
+    this._offset += 4;
+  }
+
+  readUInt32LE() {
+    const v = this._buffer.readUInt32LE(this._offset);
+    this._offset += 4;
+    return v;
+  }
+  writeUInt32LE(value) {
+    this._grow(4);
+    this._buffer.writeUInt32LE(value >>> 0, this._offset);
+    this._offset += 4;
+  }
+
+  readInt64BE() {
+    const v = this._buffer.readBigInt64BE(this._offset);
+    this._offset += 8;
+    return v;
+  }
+  writeInt64BE(value) {
+    this._grow(8);
+    this._buffer.writeBigInt64BE(value, this._offset);
+    this._offset += 8;
+  }
+
+  readUInt64BE() {
+    const v = this._buffer.readBigUInt64BE(this._offset);
+    this._offset += 8;
+    return v;
+  }
+  writeUInt64BE(value) {
+    this._grow(8);
+    this._buffer.writeBigUInt64BE(value, this._offset);
+    this._offset += 8;
+  }
+
+  readString() {
+    const len = this.readUInt16BE();
+    return this.readBytes(len).toString("utf8");
+  }
+  writeString(value) {
+    const buf = Buffer.from(value, "utf8");
+    this.writeUInt16BE(buf.length);
+    this.writeBytes(buf);
+  }
+
+  readAddress() {
+    const version = this.readByte();
+    if (version === 4) {
+      const parts = [];
+      for (let i = 0; i < 4; i++) parts.push(this.readByte() ^ 0xff);
+      const port = this.readUInt16BE();
+      return { address: parts.join("."), port, version: 4 };
+    } else {
+      this.skip(2);
+      const port = this.readUInt16BE();
+      this.skip(4);
+      const ipBytes = this.readBytes(16);
+      this.skip(4);
+      const parts = [];
+      for (let i = 0; i < 8; i++) parts.push(ipBytes.readUInt16BE(i * 2).toString(16));
+      return { address: parts.join(":"), port, version: 6 };
+    }
+  }
+
+  writeAddress(address, port, version = 4) {
+    this.writeByte(version);
+    if (version === 4) {
+      for (const part of address.split(".")) this.writeByte((parseInt(part) ^ 0xff) & 0xff);
+      this.writeUInt16BE(port);
+    } else {
+      this.writeUInt16BE(0x0a);
+      this.writeUInt16BE(port);
+      this.writeUInt32BE(0);
+      const parts = address.split(":").map((p) => parseInt(p, 16));
+      for (const part of parts) this.writeUInt16BE(part);
+      this.writeUInt32BE(0);
+    }
+  }
+
+  flush() {
+    return this._buffer.slice(0, this._offset);
+  }
+}

package/src/ws-client.js

@@ -0,0 +1,12 @@
+import { RakClient } from "./client.js";
+import { WebSocketClientTransport } from "./transport/websocket.js";
+
+export class RakWebSocketClient extends RakClient {
+  constructor(serverUrl, options = {}) {
+    const url       = new URL(serverUrl);
+    const address   = url.hostname;
+    const port      = parseInt(url.port) || (url.protocol === "wss:" ? 443 : 80);
+    const transport = new WebSocketClientTransport(serverUrl);
+    super(address, port, options.guid, { transport });
+  }
+}

package/src/ws-server.js

@@ -0,0 +1,13 @@
+import { RakServer } from "./server.js";
+import { WebSocketServerTransport } from "./transport/websocket.js";
+
+export class RakWebSocketServer extends RakServer {
+  constructor(address, port, guid, options = {}) {
+    const wsTransport = new WebSocketServerTransport(options.tls);
+    super(address, port, guid, options.maxConnections, options.motd, { transport: wsTransport });
+    this._wsTransport = wsTransport;
+    if (options.server) this._wsTransport.mountOnExisting(options.server, options.path ?? "/raknet");
+  }
+
+  getHttpServer() { return this._wsTransport.getHttpServer(); }
+}