@bruch/max-client 0.1.0

package/dist/logging.d.ts

@@ -0,0 +1,10 @@
+export type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "SILENT";
+export interface Logger {
+    debug(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+}
+export declare function configureLogging(level?: LogLevel, logger?: Logger): Logger;
+export declare function getLogger(): Logger;
+//# sourceMappingURL=logging.d.ts.map

package/dist/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../src/logging.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtE,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACjE;AA0CD,wBAAgB,gBAAgB,CAAC,KAAK,GAAE,QAAiB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAGlF;AAED,wBAAgB,SAAS,IAAI,MAAM,CAElC"}

package/dist/protocol/compression.d.ts

@@ -0,0 +1,8 @@
+export declare class Lz4BlockCompression {
+    decompress(source: Uint8Array, maxOutput?: number): Uint8Array;
+    private ensureSize;
+}
+export declare class ZstdCompression {
+    decompress(source: Uint8Array, maxOutput?: number): Uint8Array;
+}
+//# sourceMappingURL=compression.d.ts.map

package/dist/protocol/compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/protocol/compression.ts"],"names":[],"mappings":"AAEA,qBAAa,mBAAmB;IAC9B,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,SAAqB,GAAG,UAAU;IAsD1E,OAAO,CAAC,UAAU;CAGnB;AAED,qBAAa,eAAe;IAC1B,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,SAAqB,GAAG,UAAU;CAK3E"}

package/dist/protocol/enums.d.ts

@@ -0,0 +1,175 @@
+export declare const Command: {
+    readonly REQUEST: 0;
+    readonly RESPONSE: 1;
+    readonly EVENT: 2;
+    readonly ERROR: 3;
+};
+export type Command = (typeof Command)[keyof typeof Command];
+export declare const Opcode: {
+    readonly PING: 1;
+    readonly DEBUG: 2;
+    readonly RECONNECT: 3;
+    readonly LOG: 5;
+    readonly SESSION_INIT: 6;
+    readonly PROFILE: 16;
+    readonly AUTH_REQUEST: 17;
+    readonly AUTH: 18;
+    readonly LOGIN: 19;
+    readonly LOGOUT: 20;
+    readonly SYNC: 21;
+    readonly CONFIG: 22;
+    readonly AUTH_CONFIRM: 23;
+    readonly PRESET_AVATARS: 25;
+    readonly ASSETS_GET: 26;
+    readonly ASSETS_UPDATE: 27;
+    readonly ASSETS_GET_BY_IDS: 28;
+    readonly ASSETS_ADD: 29;
+    readonly SEARCH_FEEDBACK: 31;
+    readonly CONTACT_INFO: 32;
+    readonly CONTACT_ADD: 33;
+    readonly CONTACT_UPDATE: 34;
+    readonly CONTACT_PRESENCE: 35;
+    readonly CONTACT_LIST: 36;
+    readonly CONTACT_SEARCH: 37;
+    readonly CONTACT_MUTUAL: 38;
+    readonly CONTACT_PHOTOS: 39;
+    readonly CONTACT_SORT: 40;
+    readonly CONTACT_VERIFY: 42;
+    readonly REMOVE_CONTACT_PHOTO: 43;
+    readonly CONTACT_INFO_BY_PHONE: 46;
+    readonly CHAT_INFO: 48;
+    readonly CHAT_HISTORY: 49;
+    readonly CHAT_MARK: 50;
+    readonly CHAT_MEDIA: 51;
+    readonly CHAT_DELETE: 52;
+    readonly CHATS_LIST: 53;
+    readonly CHAT_CLEAR: 54;
+    readonly CHAT_UPDATE: 55;
+    readonly CHAT_CHECK_LINK: 56;
+    readonly CHAT_JOIN: 57;
+    readonly CHAT_LEAVE: 58;
+    readonly CHAT_MEMBERS: 59;
+    readonly PUBLIC_SEARCH: 60;
+    readonly CHAT_PERSONAL_CONFIG: 61;
+    readonly CHAT_LIVESTREAM_INFO: 62;
+    readonly CHAT_CREATE: 63;
+    readonly MSG_SEND: 64;
+    readonly MSG_TYPING: 65;
+    readonly MSG_DELETE: 66;
+    readonly MSG_EDIT: 67;
+    readonly CHAT_SEARCH: 68;
+    readonly MSG_SHARE_PREVIEW: 70;
+    readonly MSG_GET: 71;
+    readonly MSG_SEARCH_TOUCH: 72;
+    readonly MSG_SEARCH: 73;
+    readonly MSG_GET_STAT: 74;
+    readonly CHAT_SUBSCRIBE: 75;
+    readonly VIDEO_CHAT_START: 76;
+    readonly CHAT_MEMBERS_UPDATE: 77;
+    readonly VIDEO_CHAT_START_ACTIVE: 78;
+    readonly VIDEO_CHAT_HISTORY: 79;
+    readonly PHOTO_UPLOAD: 80;
+    readonly STICKER_UPLOAD: 81;
+    readonly VIDEO_UPLOAD: 82;
+    readonly VIDEO_PLAY: 83;
+    readonly VIDEO_CHAT_CREATE_JOIN_LINK: 84;
+    readonly CHAT_PIN_SET_VISIBILITY: 86;
+    readonly FILE_UPLOAD: 87;
+    readonly FILE_DOWNLOAD: 88;
+    readonly LINK_INFO: 89;
+    readonly MSG_DELETE_RANGE: 92;
+    readonly SESSIONS_INFO: 96;
+    readonly SESSIONS_CLOSE: 97;
+    readonly PHONE_BIND_REQUEST: 98;
+    readonly PHONE_BIND_CONFIRM: 99;
+    readonly AUTH_LOGIN_RESTORE_PASSWORD: 101;
+    readonly GET_INBOUND_CALLS: 103;
+    readonly AUTH_2FA_DETAILS: 104;
+    readonly EXTERNAL_CALLBACK: 105;
+    readonly AUTH_VALIDATE_PASSWORD: 107;
+    readonly AUTH_VALIDATE_HINT: 108;
+    readonly AUTH_VERIFY_EMAIL: 109;
+    readonly AUTH_CHECK_EMAIL: 110;
+    readonly AUTH_SET_2FA: 111;
+    readonly AUTH_CREATE_TRACK: 112;
+    readonly AUTH_CHECK_PASSWORD: 113;
+    readonly AUTH_LOGIN_CHECK_PASSWORD: 115;
+    readonly AUTH_LOGIN_PROFILE_DELETE: 116;
+    readonly CHAT_COMPLAIN: 117;
+    readonly MSG_SEND_CALLBACK: 118;
+    readonly SUSPEND_BOT: 119;
+    readonly LOCATION_STOP: 124;
+    readonly LOCATION_SEND: 125;
+    readonly LOCATION_REQUEST: 126;
+    readonly GET_LAST_MENTIONS: 127;
+    readonly NOTIF_MESSAGE: 128;
+    readonly NOTIF_TYPING: 129;
+    readonly NOTIF_MARK: 130;
+    readonly NOTIF_CONTACT: 131;
+    readonly NOTIF_PRESENCE: 132;
+    readonly NOTIF_CONFIG: 134;
+    readonly NOTIF_CHAT: 135;
+    readonly NOTIF_ATTACH: 136;
+    readonly NOTIF_CALL_START: 137;
+    readonly NOTIF_CONTACT_SORT: 139;
+    readonly NOTIF_MSG_DELETE_RANGE: 140;
+    readonly NOTIF_MSG_DELETE: 142;
+    readonly NOTIF_CALLBACK_ANSWER: 143;
+    readonly CHAT_BOT_COMMANDS: 144;
+    readonly BOT_INFO: 145;
+    readonly NOTIF_LOCATION: 147;
+    readonly NOTIF_LOCATION_REQUEST: 148;
+    readonly NOTIF_ASSETS_UPDATE: 150;
+    readonly NOTIF_DRAFT: 152;
+    readonly NOTIF_DRAFT_DISCARD: 153;
+    readonly NOTIF_MSG_DELAYED: 154;
+    readonly NOTIF_MSG_REACTIONS_CHANGED: 155;
+    readonly NOTIF_MSG_YOU_REACTED: 156;
+    readonly CALLS_TOKEN: 158;
+    readonly NOTIF_PROFILE: 159;
+    readonly WEB_APP_INIT_DATA: 160;
+    readonly COMPLAIN: 161;
+    readonly COMPLAIN_REASONS_GET: 162;
+    readonly VIDEO_CHAT_JOIN: 166;
+    readonly DRAFT_SAVE: 176;
+    readonly DRAFT_DISCARD: 177;
+    readonly MSG_REACTION: 178;
+    readonly MSG_CANCEL_REACTION: 179;
+    readonly MSG_GET_REACTIONS: 180;
+    readonly MSG_GET_DETAILED_REACTIONS: 181;
+    readonly STICKER_CREATE: 193;
+    readonly STICKER_SUGGEST: 194;
+    readonly VIDEO_CHAT_MEMBERS: 195;
+    readonly CHAT_HIDE: 196;
+    readonly CHAT_SEARCH_COMMON_PARTICIPANTS: 198;
+    readonly PROFILE_DELETE: 199;
+    readonly PROFILE_DELETE_TIME: 200;
+    readonly TRANSCRIBE_MEDIA: 202;
+    readonly ORG_INFO: 256;
+    readonly CHAT_REACTIONS_SETTINGS_SET: 257;
+    readonly REACTIONS_SETTINGS_GET_BY_CHAT_ID: 258;
+    readonly ASSETS_REMOVE: 259;
+    readonly ASSETS_MOVE: 260;
+    readonly ASSETS_LIST_MODIFY: 261;
+    readonly FOLDERS_GET: 272;
+    readonly FOLDERS_GET_BY_ID: 273;
+    readonly FOLDERS_UPDATE: 274;
+    readonly FOLDERS_REORDER: 275;
+    readonly FOLDERS_DELETE: 276;
+    readonly NOTIF_FOLDERS: 277;
+    readonly GET_QR: 288;
+    readonly GET_QR_STATUS: 289;
+    readonly AUTH_QR_APPROVE: 290;
+    readonly LOGIN_BY_QR: 291;
+    readonly NOTIF_BANNERS: 292;
+    readonly NOTIF_TRANSCRIPTION: 293;
+    readonly CHAT_SUGGEST: 300;
+    readonly AUDIO_PLAY: 301;
+    readonly BANNERS_GET: 302;
+    readonly MSG_DELIVERY: 303;
+    readonly SEND_VOTE: 304;
+    readonly VOTERS_LIST_BY_ANSWER: 305;
+    readonly GET_POLL_UPDATES: 306;
+};
+export type Opcode = (typeof Opcode)[keyof typeof Opcode];
+//# sourceMappingURL=enums.d.ts.map

package/dist/protocol/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/protocol/enums.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO;;;;;CAKV,CAAC;AACX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,OAAO,OAAO,CAAC,CAAC;AAE7D,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqKT,CAAC;AACX,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,MAAM,CAAC,CAAC"}

package/dist/protocol/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./compression.ts";
+export * from "./enums.ts";
+export * from "./tcp.ts";
+export * from "./types.ts";
+export * from "./websocket.ts";
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/protocol/index.js

@@ -0,0 +1,438 @@
+// @bun
+// src/protocol/compression.ts
+var DEFAULT_MAX_OUTPUT = 5 * 1024 * 1024;
+
+class Lz4BlockCompression {
+  decompress(source, maxOutput = DEFAULT_MAX_OUTPUT) {
+    const output = [];
+    let position = 0;
+    while (position < source.length) {
+      const token = source[position++];
+      if (token === undefined)
+        break;
+      let literalLength = token >>> 4;
+      if (literalLength === 15) {
+        while (position < source.length) {
+          const byte = source[position++];
+          if (byte === undefined)
+            break;
+          literalLength += byte;
+          if (byte !== 255)
+            break;
+        }
+      }
+      if (position + literalLength > source.length) {
+        throw new RangeError("LZ4: literal length out of bounds");
+      }
+      for (let index = 0;index < literalLength; index += 1) {
+        output.push(source[position + index]);
+      }
+      position += literalLength;
+      this.ensureSize(output.length, maxOutput);
+      if (position >= source.length)
+        break;
+      if (position + 1 >= source.length)
+        throw new RangeError("LZ4: incomplete offset");
+      const offset = source[position] | source[position + 1] << 8;
+      position += 2;
+      if (offset === 0)
+        throw new RangeError("LZ4: zero offset");
+      let matchLength = (token & 15) + 4;
+      if ((token & 15) === 15) {
+        while (position < source.length) {
+          const byte = source[position++];
+          if (byte === undefined)
+            break;
+          matchLength += byte;
+          if (byte !== 255)
+            break;
+        }
+      }
+      const matchPosition = output.length - offset;
+      if (matchPosition < 0)
+        throw new RangeError("LZ4: match out of bounds");
+      for (let index = 0;index < matchLength; index += 1) {
+        output.push(output[matchPosition + index % offset]);
+      }
+      this.ensureSize(output.length, maxOutput);
+    }
+    return Uint8Array.from(output);
+  }
+  ensureSize(size, maximum) {
+    if (size > maximum)
+      throw new RangeError("LZ4: output too large");
+  }
+}
+
+class ZstdCompression {
+  decompress(source, maxOutput = DEFAULT_MAX_OUTPUT) {
+    const output = Bun.zstdDecompressSync(source);
+    if (output.byteLength > maxOutput)
+      throw new RangeError("Zstd: output too large");
+    return output;
+  }
+}
+// src/protocol/enums.ts
+var Command = {
+  REQUEST: 0,
+  RESPONSE: 1,
+  EVENT: 2,
+  ERROR: 3
+};
+var Opcode = {
+  PING: 1,
+  DEBUG: 2,
+  RECONNECT: 3,
+  LOG: 5,
+  SESSION_INIT: 6,
+  PROFILE: 16,
+  AUTH_REQUEST: 17,
+  AUTH: 18,
+  LOGIN: 19,
+  LOGOUT: 20,
+  SYNC: 21,
+  CONFIG: 22,
+  AUTH_CONFIRM: 23,
+  PRESET_AVATARS: 25,
+  ASSETS_GET: 26,
+  ASSETS_UPDATE: 27,
+  ASSETS_GET_BY_IDS: 28,
+  ASSETS_ADD: 29,
+  SEARCH_FEEDBACK: 31,
+  CONTACT_INFO: 32,
+  CONTACT_ADD: 33,
+  CONTACT_UPDATE: 34,
+  CONTACT_PRESENCE: 35,
+  CONTACT_LIST: 36,
+  CONTACT_SEARCH: 37,
+  CONTACT_MUTUAL: 38,
+  CONTACT_PHOTOS: 39,
+  CONTACT_SORT: 40,
+  CONTACT_VERIFY: 42,
+  REMOVE_CONTACT_PHOTO: 43,
+  CONTACT_INFO_BY_PHONE: 46,
+  CHAT_INFO: 48,
+  CHAT_HISTORY: 49,
+  CHAT_MARK: 50,
+  CHAT_MEDIA: 51,
+  CHAT_DELETE: 52,
+  CHATS_LIST: 53,
+  CHAT_CLEAR: 54,
+  CHAT_UPDATE: 55,
+  CHAT_CHECK_LINK: 56,
+  CHAT_JOIN: 57,
+  CHAT_LEAVE: 58,
+  CHAT_MEMBERS: 59,
+  PUBLIC_SEARCH: 60,
+  CHAT_PERSONAL_CONFIG: 61,
+  CHAT_LIVESTREAM_INFO: 62,
+  CHAT_CREATE: 63,
+  MSG_SEND: 64,
+  MSG_TYPING: 65,
+  MSG_DELETE: 66,
+  MSG_EDIT: 67,
+  CHAT_SEARCH: 68,
+  MSG_SHARE_PREVIEW: 70,
+  MSG_GET: 71,
+  MSG_SEARCH_TOUCH: 72,
+  MSG_SEARCH: 73,
+  MSG_GET_STAT: 74,
+  CHAT_SUBSCRIBE: 75,
+  VIDEO_CHAT_START: 76,
+  CHAT_MEMBERS_UPDATE: 77,
+  VIDEO_CHAT_START_ACTIVE: 78,
+  VIDEO_CHAT_HISTORY: 79,
+  PHOTO_UPLOAD: 80,
+  STICKER_UPLOAD: 81,
+  VIDEO_UPLOAD: 82,
+  VIDEO_PLAY: 83,
+  VIDEO_CHAT_CREATE_JOIN_LINK: 84,
+  CHAT_PIN_SET_VISIBILITY: 86,
+  FILE_UPLOAD: 87,
+  FILE_DOWNLOAD: 88,
+  LINK_INFO: 89,
+  MSG_DELETE_RANGE: 92,
+  SESSIONS_INFO: 96,
+  SESSIONS_CLOSE: 97,
+  PHONE_BIND_REQUEST: 98,
+  PHONE_BIND_CONFIRM: 99,
+  AUTH_LOGIN_RESTORE_PASSWORD: 101,
+  GET_INBOUND_CALLS: 103,
+  AUTH_2FA_DETAILS: 104,
+  EXTERNAL_CALLBACK: 105,
+  AUTH_VALIDATE_PASSWORD: 107,
+  AUTH_VALIDATE_HINT: 108,
+  AUTH_VERIFY_EMAIL: 109,
+  AUTH_CHECK_EMAIL: 110,
+  AUTH_SET_2FA: 111,
+  AUTH_CREATE_TRACK: 112,
+  AUTH_CHECK_PASSWORD: 113,
+  AUTH_LOGIN_CHECK_PASSWORD: 115,
+  AUTH_LOGIN_PROFILE_DELETE: 116,
+  CHAT_COMPLAIN: 117,
+  MSG_SEND_CALLBACK: 118,
+  SUSPEND_BOT: 119,
+  LOCATION_STOP: 124,
+  LOCATION_SEND: 125,
+  LOCATION_REQUEST: 126,
+  GET_LAST_MENTIONS: 127,
+  NOTIF_MESSAGE: 128,
+  NOTIF_TYPING: 129,
+  NOTIF_MARK: 130,
+  NOTIF_CONTACT: 131,
+  NOTIF_PRESENCE: 132,
+  NOTIF_CONFIG: 134,
+  NOTIF_CHAT: 135,
+  NOTIF_ATTACH: 136,
+  NOTIF_CALL_START: 137,
+  NOTIF_CONTACT_SORT: 139,
+  NOTIF_MSG_DELETE_RANGE: 140,
+  NOTIF_MSG_DELETE: 142,
+  NOTIF_CALLBACK_ANSWER: 143,
+  CHAT_BOT_COMMANDS: 144,
+  BOT_INFO: 145,
+  NOTIF_LOCATION: 147,
+  NOTIF_LOCATION_REQUEST: 148,
+  NOTIF_ASSETS_UPDATE: 150,
+  NOTIF_DRAFT: 152,
+  NOTIF_DRAFT_DISCARD: 153,
+  NOTIF_MSG_DELAYED: 154,
+  NOTIF_MSG_REACTIONS_CHANGED: 155,
+  NOTIF_MSG_YOU_REACTED: 156,
+  CALLS_TOKEN: 158,
+  NOTIF_PROFILE: 159,
+  WEB_APP_INIT_DATA: 160,
+  COMPLAIN: 161,
+  COMPLAIN_REASONS_GET: 162,
+  VIDEO_CHAT_JOIN: 166,
+  DRAFT_SAVE: 176,
+  DRAFT_DISCARD: 177,
+  MSG_REACTION: 178,
+  MSG_CANCEL_REACTION: 179,
+  MSG_GET_REACTIONS: 180,
+  MSG_GET_DETAILED_REACTIONS: 181,
+  STICKER_CREATE: 193,
+  STICKER_SUGGEST: 194,
+  VIDEO_CHAT_MEMBERS: 195,
+  CHAT_HIDE: 196,
+  CHAT_SEARCH_COMMON_PARTICIPANTS: 198,
+  PROFILE_DELETE: 199,
+  PROFILE_DELETE_TIME: 200,
+  TRANSCRIBE_MEDIA: 202,
+  ORG_INFO: 256,
+  CHAT_REACTIONS_SETTINGS_SET: 257,
+  REACTIONS_SETTINGS_GET_BY_CHAT_ID: 258,
+  ASSETS_REMOVE: 259,
+  ASSETS_MOVE: 260,
+  ASSETS_LIST_MODIFY: 261,
+  FOLDERS_GET: 272,
+  FOLDERS_GET_BY_ID: 273,
+  FOLDERS_UPDATE: 274,
+  FOLDERS_REORDER: 275,
+  FOLDERS_DELETE: 276,
+  NOTIF_FOLDERS: 277,
+  GET_QR: 288,
+  GET_QR_STATUS: 289,
+  AUTH_QR_APPROVE: 290,
+  LOGIN_BY_QR: 291,
+  NOTIF_BANNERS: 292,
+  NOTIF_TRANSCRIPTION: 293,
+  CHAT_SUGGEST: 300,
+  AUDIO_PLAY: 301,
+  BANNERS_GET: 302,
+  MSG_DELIVERY: 303,
+  SEND_VOTE: 304,
+  VOTERS_LIST_BY_ANSWER: 305,
+  GET_POLL_UPDATES: 306
+};
+// src/protocol/tcp.ts
+import { decode, encode } from "@msgpack/msgpack";
+var TCP_HEADER_SIZE = 10;
+
+class TcpPacketFramer {
+  pack(options) {
+    if (options.payloadBytes.byteLength > 16777215) {
+      throw new RangeError("TCP payload exceeds the 24-bit length field");
+    }
+    const result = new Uint8Array(TCP_HEADER_SIZE + options.payloadBytes.byteLength);
+    const view = new DataView(result.buffer);
+    view.setUint8(0, options.ver);
+    view.setUint8(1, options.cmd);
+    view.setUint16(2, options.seq, false);
+    view.setUint16(4, options.opcode, false);
+    const packedLength = (options.flags & 255) << 24 | options.payloadBytes.byteLength;
+    view.setUint32(6, packedLength >>> 0, false);
+    result.set(options.payloadBytes, TCP_HEADER_SIZE);
+    return result;
+  }
+  unpack(data) {
+    if (data.byteLength < TCP_HEADER_SIZE)
+      return null;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const packedLength = view.getUint32(6, false);
+    const payloadLength = packedLength & 16777215;
+    if (data.byteLength < TCP_HEADER_SIZE + payloadLength)
+      return null;
+    return {
+      header: {
+        ver: view.getUint8(0),
+        cmd: view.getUint8(1),
+        seq: view.getUint16(2, false),
+        opcode: view.getUint16(4, false),
+        flags: packedLength >>> 24,
+        payloadLength
+      },
+      payloadBytes: data.slice(TCP_HEADER_SIZE, TCP_HEADER_SIZE + payloadLength)
+    };
+  }
+  unpackPayloadLength(data) {
+    if (data.byteLength < TCP_HEADER_SIZE)
+      return null;
+    return new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(6, false) & 16777215;
+  }
+}
+
+class MsgpackPayloadCodec {
+  encode(payload) {
+    if (payload === null || payload === undefined)
+      return new Uint8Array;
+    return encode(payload, { useBigInt64: true, ignoreUndefined: true });
+  }
+  decode(payload) {
+    if (payload.byteLength === 0)
+      return {};
+    return normalizeKeys(decode(payload, { useBigInt64: true }));
+  }
+}
+
+class TcpPayloadDecoder {
+  serializer;
+  lz4;
+  zstd;
+  constructor(serializer = new MsgpackPayloadCodec, lz4 = new Lz4BlockCompression, zstd = new ZstdCompression) {
+    this.serializer = serializer;
+    this.lz4 = lz4;
+    this.zstd = zstd;
+  }
+  decode(payload, flags = 0) {
+    if (payload.byteLength === 0)
+      return {};
+    let decoded = payload;
+    if (flags === 255)
+      decoded = this.zstd.decompress(payload);
+    else if (flags > 127)
+      throw new RangeError(`Invalid TCP compression factor: ${flags}`);
+    else if (flags > 0)
+      decoded = this.lz4.decompress(payload);
+    return this.serializer.decode(decoded);
+  }
+}
+
+class TcpProtocol {
+  version = 10;
+  framer = new TcpPacketFramer;
+  serializer = new MsgpackPayloadCodec;
+  payloadDecoder = new TcpPayloadDecoder(this.serializer);
+  encode(frame) {
+    const payloadBytes = this.serializer.encode(frame.payload);
+    return this.framer.pack({
+      ver: this.version,
+      cmd: frame.cmd ?? 0,
+      seq: frame.seq,
+      opcode: frame.opcode,
+      flags: 0,
+      payloadBytes
+    });
+  }
+  decode(raw) {
+    const packet = this.framer.unpack(raw);
+    if (!packet)
+      return { opcode: 0, cmd: 0, seq: null, payload: null, raw: null };
+    const payload = this.payloadDecoder.decode(packet.payloadBytes, packet.header.flags);
+    return {
+      opcode: packet.header.opcode,
+      cmd: packet.header.cmd,
+      seq: packet.header.seq,
+      payload,
+      raw: payload
+    };
+  }
+}
+function normalizeKeys(value) {
+  if (Array.isArray(value))
+    return value.map(normalizeKeys);
+  if (value instanceof Map) {
+    const result = Object.create(null);
+    for (const [key, item] of value)
+      result[normalizeKey(key)] = normalizeKeys(item);
+    return result;
+  }
+  if (value !== null && typeof value === "object" && !(value instanceof Uint8Array)) {
+    const result = Object.create(null);
+    for (const [key, item] of Object.entries(value))
+      result[normalizeKey(key)] = normalizeKeys(item);
+    return result;
+  }
+  return value;
+}
+function normalizeKey(value) {
+  if (value instanceof Uint8Array)
+    return new TextDecoder().decode(value);
+  return String(value);
+}
+// src/protocol/websocket.ts
+import { isInteger, isSafeNumber, parse, stringify } from "lossless-json";
+
+class WsProtocol {
+  version = 11;
+  encode(frame) {
+    return stringify({ ...frame, cmd: frame.cmd ?? 0, ver: this.version });
+  }
+  decode(raw) {
+    try {
+      const value = parse(raw, undefined, {
+        parseNumber: (text) => {
+          if (isInteger(text) && !isSafeNumber(text))
+            return BigInt(text);
+          return Number(text);
+        }
+      });
+      if (!isRecord(value))
+        return emptyFrame();
+      const opcode = safeHeaderNumber(value.opcode);
+      const cmd = safeHeaderNumber(value.cmd ?? 0);
+      const seq = value.seq === null || value.seq === undefined ? null : safeHeaderNumber(value.seq);
+      const payload = isRecord(value.payload) ? value.payload : null;
+      return { opcode, cmd, seq, payload, raw: payload };
+    } catch {
+      return emptyFrame();
+    }
+  }
+}
+function safeHeaderNumber(value) {
+  const result = typeof value === "bigint" ? Number(value) : value;
+  if (typeof result !== "number" || !Number.isSafeInteger(result)) {
+    throw new TypeError("Invalid WebSocket frame header");
+  }
+  return result;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function emptyFrame() {
+  return { opcode: 0, cmd: 0, seq: null, payload: null, raw: null };
+}
+export {
+  ZstdCompression,
+  WsProtocol,
+  TcpProtocol,
+  TcpPayloadDecoder,
+  TcpPacketFramer,
+  TCP_HEADER_SIZE,
+  Opcode,
+  MsgpackPayloadCodec,
+  Lz4BlockCompression,
+  Command
+};
+
+//# debugId=48D4D6DC5C20417D64756E2164756E21