raknet-typeo 1.0.0

package/src/connection.js

@@ -0,0 +1,394 @@
+import { EventEmitter } from "events";
+import { BinaryStream } from "./utils/binary-stream.js";
+import { createFrame, readFrames, encodeFrameSet, getFrameSize } from "./protocol/frame.js";
+import { encodeAck, encodeNack, decodeAckLike } from "./protocol/ack.js";
+import {
+  MessageId,
+  PacketReliability,
+  PacketPriority,
+  isReliable,
+  isOrdered,
+  isSequenced,
+  ACK_FLAG,
+  NACK_FLAG,
+  DATAGRAM_FLAG,
+  MAX_CHANNELS,
+  MAX_SPLIT_COUNT,
+} from "./constants.js";
+
+const FRAME_OVERHEAD   = 60;
+const ACK_TIMEOUT_MS   = 150;
+const PING_INTERVAL_MS = 5_000;
+const TIMEOUT_MS       = 20_000;
+
+export class Connection extends EventEmitter {
+  constructor(address, port, guid, sendFn, mtu) {
+    super();
+    this.address  = address;
+    this.port     = port;
+    this.guid     = guid;
+    this._sendFn  = sendFn;
+    this._mtu     = Math.min(mtu, 1492);
+
+    this._sendSequenceNumber    = 0;
+    this._receiveSequenceNumber = 0;
+    this._reliableSendIndex     = 0;
+    this._splitId               = 0;
+
+    this._orderSendIndex      = new Array(MAX_CHANNELS).fill(0);
+    this._orderReceiveIndex   = new Array(MAX_CHANNELS).fill(0);
+    this._sequenceSendIndex   = new Array(MAX_CHANNELS).fill(0);
+    this._sequenceReceiveIndex = new Array(MAX_CHANNELS).fill(0);
+
+    this._receivedSequences = new Set();
+    this._nackQueue         = [];
+    this._ackQueue          = [];
+
+    this._reliablePackets = new Map();
+    this._splitPackets    = new Map();
+
+    this._holdingQueue = Array.from({ length: MAX_CHANNELS }, () => new Map());
+    this._sendQueue    = [];
+
+    this._lastPingTime     = Date.now();
+    this._lastReceivedTime = Date.now();
+    this._pingInterval     = undefined;
+    this._tickInterval     = undefined;
+
+    this.connected = false;
+  }
+
+  start() {
+    this._pingInterval = setInterval(() => {
+      if (Date.now() - this._lastReceivedTime > TIMEOUT_MS) {
+        this.emit("timeout");
+        this.close();
+        return;
+      }
+      if (Date.now() - this._lastPingTime > PING_INTERVAL_MS) this._sendConnectedPing();
+    }, 1000);
+
+    this._tickInterval = setInterval(() => this._tick(), 50);
+  }
+
+  _tick() {
+    this._flushAckQueue();
+    this._flushNackQueue();
+    this._flushSendQueue();
+    this._retransmitLostPackets();
+  }
+
+  handleDatagram(buf) {
+    this._lastReceivedTime = Date.now();
+    const flag = buf[0];
+
+    // ACK_FLAG = 0xC0, NACK_FLAG = 0xA0 — compare exactly, not via bitmask,
+    // because 0xC0 has DATAGRAM_FLAG (0x80) set and would fall through otherwise.
+    if (flag === ACK_FLAG) {
+      for (const seq of decodeAckLike(buf)) this._reliablePackets.delete(seq);
+      return;
+    }
+
+    if (flag === NACK_FLAG) {
+      for (const seq of decodeAckLike(buf)) {
+        const entry = this._reliablePackets.get(seq);
+        if (entry) entry.sendTime = 0;
+      }
+      return;
+    }
+
+    if ((flag & DATAGRAM_FLAG) === 0) return;
+
+    const seqNum = buf.readUIntLE(1, 3);
+
+    if (this._receivedSequences.has(seqNum)) {
+      this._ackQueue.push(seqNum);
+      return;
+    }
+
+    for (let i = this._receiveSequenceNumber; i < seqNum; i++) {
+      if (!this._receivedSequences.has(i)) this._nackQueue.push(i);
+    }
+
+    this._receivedSequences.add(seqNum);
+    this._ackQueue.push(seqNum);
+
+    if (seqNum >= this._receiveSequenceNumber) this._receiveSequenceNumber = seqNum + 1;
+
+    for (const frame of readFrames(buf)) this._handleFrame(frame);
+  }
+
+  _handleFrame(frame) {
+    if (frame.split) { this._handleSplitFrame(frame); return; }
+    this._processFrame(frame);
+  }
+
+  _handleSplitFrame(frame) {
+    const { splitId, splitCount, splitIndex } = frame;
+
+    if (!this._splitPackets.has(splitId)) {
+      if (this._splitPackets.size > MAX_SPLIT_COUNT) this._splitPackets.clear();
+      this._splitPackets.set(splitId, {
+        splitId, splitCount,
+        received: new Map(),
+        reliability  : frame.reliability,
+        orderIndex   : frame.orderIndex,
+        orderChannel : frame.orderChannel,
+      });
+    }
+
+    const split = this._splitPackets.get(splitId);
+    split.received.set(splitIndex, frame.body);
+
+    if (split.received.size === splitCount) {
+      this._splitPackets.delete(splitId);
+      const parts = [];
+      for (let i = 0; i < splitCount; i++) parts.push(split.received.get(i));
+      this._processFrame({
+        ...frame,
+        split        : false,
+        body         : Buffer.concat(parts),
+        orderIndex   : split.orderIndex,
+        orderChannel : split.orderChannel,
+      });
+    }
+  }
+
+  _processFrame(frame) {
+    if (isSequenced(frame.reliability)) {
+      const ch = frame.orderChannel;
+      if (frame.sequenceIndex < this._sequenceReceiveIndex[ch]) return;
+      this._sequenceReceiveIndex[ch] = frame.sequenceIndex + 1;
+    }
+
+    if (isOrdered(frame.reliability) && !isSequenced(frame.reliability)) {
+      const ch            = frame.orderChannel;
+      const expectedIndex = this._orderReceiveIndex[ch];
+      if (frame.orderIndex === expectedIndex) {
+        this._orderReceiveIndex[ch]++;
+        this._handlePacketBody(frame.body);
+        this._releaseHeld(ch);
+      } else if (frame.orderIndex > expectedIndex) {
+        const held = this._holdingQueue[ch];
+        if (!held.has(frame.orderIndex)) held.set(frame.orderIndex, new Map([[frame.orderChannel, frame]]));
+      }
+      return;
+    }
+
+    this._handlePacketBody(frame.body);
+  }
+
+  _releaseHeld(channel) {
+    const held = this._holdingQueue[channel];
+    let next   = this._orderReceiveIndex[channel];
+    while (held.has(next)) {
+      const frames = held.get(next);
+      held.delete(next);
+      for (const frame of frames.values()) this._handlePacketBody(frame.body);
+      this._orderReceiveIndex[channel]++;
+      next++;
+    }
+  }
+
+  _handlePacketBody(body) {
+    if (body.length === 0) return;
+    const id = body[0];
+
+    switch (id) {
+      case MessageId.ConnectedPing: {
+        const s = new BinaryStream(body);
+        s.skip(1);
+        this._sendConnectedPong(s.readInt64BE());
+        break;
+      }
+      case MessageId.ConnectedPong:
+        break;
+      case MessageId.ConnectionRequest:
+        this._handleConnectionRequest(body);
+        break;
+      case MessageId.ConnectionRequestAccepted:
+        this._handleConnectionRequestAccepted(body);
+        break;
+      case MessageId.NewIncomingConnection:
+        if (!this.connected) { this.connected = true; this.emit("connected"); }
+        break;
+      case MessageId.DisconnectionNotification:
+        this.emit("disconnected", "disconnect_notification");
+        this.close(false);
+        break;
+      case MessageId.DetectLostConnections:
+        this._sendConnectedPong(BigInt(Date.now()));
+        break;
+      default:
+        this.emit("encapsulated", body);
+        break;
+    }
+  }
+
+  _handleConnectionRequest(body) {
+    const s = new BinaryStream(body);
+    s.skip(1);
+    const clientGuid  = s.readInt64BE();
+    const requestTime = s.readInt64BE();
+
+    const res = new BinaryStream();
+    res.writeByte(MessageId.ConnectionRequestAccepted);
+    res.writeAddress(this.address, this.port, 4);
+    res.writeUInt16BE(0);
+    for (let i = 0; i < 20; i++) res.writeAddress("127.0.0.1", 0, 4);
+    res.writeInt64BE(requestTime);
+    res.writeInt64BE(BigInt(Date.now()));
+
+    this.sendEncapsulated(res.flush(), PacketPriority.Immediate, PacketReliability.Reliable);
+    this.connected = true;
+    this.emit("connected", clientGuid);
+  }
+
+  _handleConnectionRequestAccepted(body) {
+    const s = new BinaryStream(body);
+    s.skip(1);
+    s.readAddress();
+    s.skip(2);
+    for (let i = 0; i < 20; i++) s.readAddress();
+    const pingTime = s.readInt64BE();
+
+    const res = new BinaryStream();
+    res.writeByte(MessageId.NewIncomingConnection);
+    res.writeAddress("127.0.0.1", 0, 4);
+    for (let i = 0; i < 20; i++) res.writeAddress("127.0.0.1", 0, 4);
+    res.writeInt64BE(pingTime);
+    res.writeInt64BE(BigInt(Date.now()));
+
+    this.sendEncapsulated(res.flush(), PacketPriority.Immediate, PacketReliability.Reliable);
+    this.connected = true;
+    this.emit("connected");
+  }
+
+  _sendConnectedPing() {
+    this._lastPingTime = Date.now();
+    const s = new BinaryStream();
+    s.writeByte(MessageId.ConnectedPing);
+    s.writeInt64BE(BigInt(Date.now()));
+    this.sendEncapsulated(s.flush(), PacketPriority.Immediate, PacketReliability.Unreliable);
+  }
+
+  _sendConnectedPong(pingTime) {
+    const s = new BinaryStream();
+    s.writeByte(MessageId.ConnectedPong);
+    s.writeInt64BE(pingTime);
+    s.writeInt64BE(BigInt(Date.now()));
+    this.sendEncapsulated(s.flush(), PacketPriority.Immediate, PacketReliability.Unreliable);
+  }
+
+  sendEncapsulated(buf, priority = PacketPriority.Medium, reliability = PacketReliability.ReliableOrdered, orderChannel = 0) {
+    const maxBodySize = this._mtu - FRAME_OVERHEAD;
+    if (buf.length > maxBodySize) { this._sendSplit(buf, reliability, orderChannel); return; }
+
+    const frame = createFrame(buf, reliability, orderChannel);
+    if (isReliable(reliability))  frame.reliableIndex  = this._reliableSendIndex++;
+    if (isSequenced(reliability)) frame.sequenceIndex  = this._sequenceSendIndex[orderChannel]++;
+    if (isOrdered(reliability))   frame.orderIndex     = this._orderSendIndex[orderChannel]++;
+
+    if (priority === PacketPriority.Immediate) this._flushFrames([frame]);
+    else this._sendQueue.push(frame);
+  }
+
+  _sendSplit(buf, reliability, orderChannel) {
+    const maxBodySize    = this._mtu - FRAME_OVERHEAD - 10;
+    const splitCount     = Math.ceil(buf.length / maxBodySize);
+    const id             = this._splitId++ & 0xffff;
+    const baseOrderIndex = isOrdered(reliability) ? this._orderSendIndex[orderChannel]++ : 0;
+
+    for (let i = 0; i < splitCount; i++) {
+      const chunk = buf.slice(i * maxBodySize, (i + 1) * maxBodySize);
+      const frame = createFrame(chunk, reliability, orderChannel);
+      frame.split      = true;
+      frame.splitCount = splitCount;
+      frame.splitId    = id;
+      frame.splitIndex = i;
+      if (isReliable(reliability)) frame.reliableIndex = this._reliableSendIndex++;
+      if (isOrdered(reliability))  frame.orderIndex    = baseOrderIndex;
+      this._flushFrames([frame]);
+    }
+  }
+
+  _flushSendQueue() {
+    if (this._sendQueue.length === 0) return;
+    const batch = [];
+    let batchSize = 4;
+
+    while (this._sendQueue.length > 0) {
+      const frame = this._sendQueue[0];
+      const fSize = getFrameSize(frame);
+
+      if (batchSize + fSize > this._mtu) {
+        if (batch.length > 0) { this._flushFrames(batch.splice(0)); batchSize = 4; }
+        else { this._sendQueue.shift(); this._flushFrames([frame]); }
+        continue;
+      }
+      this._sendQueue.shift();
+      batch.push(frame);
+      batchSize += fSize;
+    }
+
+    if (batch.length > 0) this._flushFrames(batch);
+  }
+
+  _flushFrames(frames) {
+    const seqNum = this._sendSequenceNumber++;
+    const buf    = encodeFrameSet(seqNum, frames);
+    this._sendFn(buf, this.address, this.port);
+
+    for (const frame of frames) {
+      if (isReliable(frame.reliability)) {
+        this._reliablePackets.set(seqNum, { frame, sendTime: Date.now() });
+        break;
+      }
+    }
+  }
+
+  _retransmitLostPackets() {
+    const now = Date.now();
+    for (const [seq, entry] of this._reliablePackets) {
+      if (entry.sendTime === 0 || now - entry.sendTime > ACK_TIMEOUT_MS * 3) {
+        const resendSeq = this._sendSequenceNumber++;
+        this._sendFn(encodeFrameSet(resendSeq, [entry.frame]), this.address, this.port);
+        this._reliablePackets.delete(seq);
+        this._reliablePackets.set(resendSeq, { frame: entry.frame, sendTime: now });
+      }
+    }
+  }
+
+  _flushAckQueue() {
+    if (this._ackQueue.length === 0) return;
+    this._sendFn(encodeAck(this._ackQueue.splice(0)), this.address, this.port);
+  }
+
+  _flushNackQueue() {
+    if (this._nackQueue.length === 0) return;
+    this._sendFn(encodeNack(this._nackQueue.splice(0)), this.address, this.port);
+  }
+
+  sendConnectionRequest(guid) {
+    const s = new BinaryStream();
+    s.writeByte(MessageId.ConnectionRequest);
+    s.writeInt64BE(guid);
+    s.writeInt64BE(BigInt(Date.now()));
+    s.writeBool(false);
+    this.sendEncapsulated(s.flush(), PacketPriority.Immediate, PacketReliability.Reliable);
+  }
+
+  sendDisconnect() {
+    const s = new BinaryStream();
+    s.writeByte(MessageId.DisconnectionNotification);
+    this.sendEncapsulated(s.flush(), PacketPriority.Immediate, PacketReliability.ReliableOrdered);
+  }
+
+  close(notify = true) {
+    if (this._pingInterval) clearInterval(this._pingInterval);
+    if (this._tickInterval) clearInterval(this._tickInterval);
+    if (notify && this.connected) this.sendDisconnect();
+    this.connected = false;
+    this.removeAllListeners();
+  }
+}

package/src/constants.js

@@ -0,0 +1,87 @@
+export const OFFLINE_MESSAGE_DATA_ID = Buffer.from([
+  0x00, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0xfe, 0xfe,
+  0xfd, 0xfd, 0xfd, 0xfd, 0x12, 0x34, 0x56, 0x78,
+]);
+
+export const RAKNET_PROTOCOL_VERSION = 10;
+
+export const MessageId = Object.freeze({
+  ConnectedPing              : 0x00,
+  UnconnectedPing            : 0x01,
+  UnconnectedPingOpenConn    : 0x02,
+  ConnectedPong              : 0x03,
+  DetectLostConnections      : 0x04,
+  OpenConnectionRequest1     : 0x05,
+  OpenConnectionReply1       : 0x06,
+  OpenConnectionRequest2     : 0x07,
+  OpenConnectionReply2       : 0x08,
+  ConnectionRequest          : 0x09,
+  ConnectionRequestAccepted  : 0x10,
+  ConnectionAttemptFailed    : 0x11,
+  AlreadyConnected           : 0x12,
+  NewIncomingConnection      : 0x13,
+  NoFreeIncomingConnections  : 0x14,
+  DisconnectionNotification  : 0x15,
+  ConnectionLost             : 0x16,
+  ConnectionBanned           : 0x17,
+  InvalidPassword            : 0x18,
+  IncompatibleProtocolVersion: 0x19,
+  IpRecentlyConnected        : 0x1a,
+  Timestamp                  : 0x1b,
+  UnconnectedPong            : 0x1c,
+  AdvertiseSystem            : 0x1d,
+  DownloadProgress           : 0x1e,
+  RemoteDisconnected         : 0x1f,
+});
+
+export const PacketReliability = Object.freeze({
+  Unreliable              : 0,
+  UnreliableSequenced     : 1,
+  Reliable                : 2,
+  ReliableOrdered         : 3,
+  ReliableSequenced       : 4,
+  UnreliableWithAckReceipt: 5,
+  ReliableWithAckReceipt  : 6,
+  ReliableOrderedWithAckReceipt: 7,
+});
+
+export const PacketPriority = Object.freeze({
+  Immediate : 0,
+  High      : 1,
+  Medium    : 2,
+  Low       : 3,
+});
+
+export function isReliable(reliability) {
+  return (
+    reliability === PacketReliability.Reliable ||
+    reliability === PacketReliability.ReliableOrdered ||
+    reliability === PacketReliability.ReliableSequenced ||
+    reliability === PacketReliability.ReliableWithAckReceipt ||
+    reliability === PacketReliability.ReliableOrderedWithAckReceipt
+  );
+}
+
+export function isSequenced(reliability) {
+  return (
+    reliability === PacketReliability.UnreliableSequenced ||
+    reliability === PacketReliability.ReliableSequenced
+  );
+}
+
+export function isOrdered(reliability) {
+  return (
+    reliability === PacketReliability.ReliableOrdered ||
+    reliability === PacketReliability.ReliableOrderedWithAckReceipt ||
+    reliability === PacketReliability.UnreliableSequenced ||
+    reliability === PacketReliability.ReliableSequenced
+  );
+}
+
+export const MAX_MTU_SIZE   = 1492;
+export const MIN_MTU_SIZE   = 400;
+export const MAX_SPLIT_COUNT = 128;
+export const MAX_CHANNELS   = 32;
+export const DATAGRAM_FLAG  = 0x80;
+export const ACK_FLAG       = 0xc0;
+export const NACK_FLAG      = 0xa0;

package/src/index.js

@@ -0,0 +1,52 @@
+export { RakServer }             from "./server.js";
+export { RakClient }             from "./client.js";
+export { RakWebSocketServer }    from "./ws-server.js";
+export { RakWebSocketClient }    from "./ws-client.js";
+export { Connection }            from "./connection.js";
+export { BinaryStream }          from "./utils/binary-stream.js";
+export { UdpTransport }          from "./transport/udp.js";
+export { WebSocketServerTransport, WebSocketClientTransport } from "./transport/websocket.js";
+
+export {
+  MessageId,
+  PacketReliability,
+  PacketPriority,
+  RAKNET_PROTOCOL_VERSION,
+  OFFLINE_MESSAGE_DATA_ID,
+  MAX_MTU_SIZE,
+  MIN_MTU_SIZE,
+  MAX_CHANNELS,
+  isReliable,
+  isSequenced,
+  isOrdered,
+} from "./constants.js";
+
+export {
+  createFrame,
+  readFrame,
+  readFrames,
+  writeFrame,
+  encodeFrameSet,
+  getFrameSize,
+  getFrameHeaderSize,
+} from "./protocol/frame.js";
+
+export { encodeAck, encodeNack, decodeAckLike }      from "./protocol/ack.js";
+
+export {
+  isOfflineMessage,
+  hasOfflineDataId,
+  readUnconnectedPing,
+  writeUnconnectedPong,
+  writeUnconnectedPing,
+  readOpenConnectionRequest1,
+  writeOpenConnectionReply1,
+  readOpenConnectionRequest2,
+  writeOpenConnectionReply2,
+  writeIncompatibleProtocolVersion,
+  writeNoFreeIncomingConnections,
+  writeAlreadyConnected,
+  writeConnectionBanned,
+  writeOpenConnectionRequest1,
+  writeOpenConnectionRequest2,
+} from "./protocol/offline.js";

package/src/protocol/ack.js

@@ -0,0 +1,47 @@
+import { BinaryStream } from "../utils/binary-stream.js";
+import { ACK_FLAG, NACK_FLAG } from "../constants.js";
+
+export function encodeAck(sequences)  { return encodeAckLike(ACK_FLAG,  sequences); }
+export function encodeNack(sequences) { return encodeAckLike(NACK_FLAG, sequences); }
+
+function encodeAckLike(flag, sequences) {
+  const sorted = [...sequences].sort((a, b) => a - b);
+  const records = [];
+
+  for (const seq of sorted) {
+    if (records.length > 0) {
+      const last = records[records.length - 1];
+      if (seq === last.max + 1) { last.max = seq; continue; }
+    }
+    records.push({ min: seq, max: seq });
+  }
+
+  const s = new BinaryStream();
+  s.writeByte(flag);
+  s.writeUInt16BE(records.length);
+  for (const r of records) {
+    const single = r.min === r.max;
+    s.writeBool(single);
+    s.writeUInt24LE(r.min);
+    if (!single) s.writeUInt24LE(r.max);
+  }
+  return s.flush();
+}
+
+export function decodeAckLike(buf) {
+  const s = new BinaryStream(buf);
+  s.skip(1);
+  const count = s.readUInt16BE();
+  const sequences = [];
+  for (let i = 0; i < count; i++) {
+    const single = s.readBool();
+    const min    = s.readUInt24LE();
+    if (single) {
+      sequences.push(min);
+    } else {
+      const max = s.readUInt24LE();
+      for (let j = min; j <= max; j++) sequences.push(j);
+    }
+  }
+  return sequences;
+}

package/src/protocol/frame.js

@@ -0,0 +1,100 @@
+import { BinaryStream } from "../utils/binary-stream.js";
+import { PacketReliability, isReliable, isSequenced, isOrdered } from "../constants.js";
+
+export function createFrame(body, reliability = PacketReliability.ReliableOrdered, orderChannel = 0) {
+  return {
+    reliability,
+    reliableIndex : 0,
+    sequenceIndex : 0,
+    orderIndex    : 0,
+    orderChannel,
+    split         : false,
+    splitCount    : 0,
+    splitId       : 0,
+    splitIndex    : 0,
+    body,
+  };
+}
+
+export function getFrameHeaderSize(frame) {
+  let size = 3;
+  if (isReliable(frame.reliability))  size += 3;
+  if (isSequenced(frame.reliability)) size += 3;
+  if (isOrdered(frame.reliability))   size += 4;
+  if (frame.split)                    size += 10;
+  return size;
+}
+
+export function getFrameSize(frame) {
+  return getFrameHeaderSize(frame) + frame.body.length;
+}
+
+export function writeFrame(stream, frame) {
+  let flags = (frame.reliability << 5) & 0xe0;
+  if (frame.split) flags |= 0x10;
+  stream.writeByte(flags);
+  stream.writeUInt16BE(frame.body.length << 3);
+
+  if (isReliable(frame.reliability))  stream.writeUInt24LE(frame.reliableIndex);
+  if (isSequenced(frame.reliability)) stream.writeUInt24LE(frame.sequenceIndex);
+  if (isOrdered(frame.reliability)) {
+    stream.writeUInt24LE(frame.orderIndex);
+    stream.writeByte(frame.orderChannel);
+  }
+  if (frame.split) {
+    stream.writeUInt32BE(frame.splitCount);
+    stream.writeUInt16BE(frame.splitId);
+    stream.writeUInt32BE(frame.splitIndex);
+  }
+
+  stream.writeBytes(frame.body);
+}
+
+export function readFrame(stream) {
+  const flags       = stream.readByte();
+  const reliability = (flags & 0xe0) >> 5;
+  const hasSplit    = (flags & 0x10) !== 0;
+
+  const bitLength  = stream.readUInt16BE();
+  const byteLength = Math.ceil(bitLength / 8);
+
+  let reliableIndex  = 0;
+  let sequenceIndex  = 0;
+  let orderIndex     = 0;
+  let orderChannel   = 0;
+  let splitCount     = 0;
+  let splitId        = 0;
+  let splitIndex     = 0;
+
+  if (isReliable(reliability))  reliableIndex  = stream.readUInt24LE();
+  if (isSequenced(reliability)) sequenceIndex  = stream.readUInt24LE();
+  if (isOrdered(reliability)) {
+    orderIndex   = stream.readUInt24LE();
+    orderChannel = stream.readByte();
+  }
+  if (hasSplit) {
+    splitCount = stream.readUInt32BE();
+    splitId    = stream.readUInt16BE();
+    splitIndex = stream.readUInt32BE();
+  }
+
+  const body = stream.readBytes(byteLength);
+
+  return { reliability, reliableIndex, sequenceIndex, orderIndex, orderChannel, split: hasSplit, splitCount, splitId, splitIndex, body };
+}
+
+export function readFrames(buf) {
+  const stream = new BinaryStream(buf);
+  stream.skip(4);
+  const frames = [];
+  while (stream.remaining > 0) frames.push(readFrame(stream));
+  return frames;
+}
+
+export function encodeFrameSet(sequenceNumber, frames) {
+  const stream = new BinaryStream();
+  stream.writeByte(0x84);
+  stream.writeUInt24LE(sequenceNumber);
+  for (const frame of frames) writeFrame(stream, frame);
+  return stream.flush();
+}