@bruch/max-client 0.1.0

package/dist/index.js

@@ -0,0 +1,3967 @@
+// @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 };
+}
+// src/types/utils.ts
+function toMaxId(value, field = "id") {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value))
+    return BigInt(value);
+  if (typeof value === "number" && Number.isSafeInteger(value))
+    return BigInt(value);
+  throw new TypeError(`${field} must be a lossless integer`);
+}
+function optionalMaxId(value, field = "id") {
+  return value === null || value === undefined ? null : toMaxId(value, field);
+}
+function asRecord(value, field = "payload") {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+function optionalRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback = 0) {
+  if (typeof value === "bigint") {
+    const number = Number(value);
+    return Number.isSafeInteger(number) ? number : fallback;
+  }
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+// src/types/attachments.ts
+var AttachmentType = {
+  PHOTO: "PHOTO",
+  VIDEO: "VIDEO",
+  FILE: "FILE",
+  CONTACT: "CONTACT",
+  STICKER: "STICKER",
+  AUDIO: "AUDIO",
+  CONTROL: "CONTROL",
+  INLINE_KEYBOARD: "INLINE_KEYBOARD",
+  SHARE: "SHARE",
+  CALL: "CALL"
+};
+function parseAttachment(value) {
+  const raw = asRecord(value, "attachment");
+  return { type: asString(raw.type ?? raw._type, "UNKNOWN"), raw };
+}
+// src/types/models.ts
+var ChatType = {
+  DIALOG: "DIALOG",
+  CHAT: "CHAT",
+  CHANNEL: "CHANNEL"
+};
+
+class Message {
+  id;
+  chatId;
+  sender;
+  text;
+  time;
+  type;
+  cid;
+  attaches;
+  stats;
+  status;
+  reactionInfo;
+  options;
+  previousMessageId;
+  ttl;
+  unread;
+  mark;
+  elements;
+  raw;
+  actions = null;
+  constructor(payload) {
+    this.id = toMaxId(payload.id, "message.id");
+    this.chatId = optionalMaxId(payload.chatId, "message.chatId");
+    this.sender = optionalMaxId(payload.sender, "message.sender");
+    this.text = asString(payload.text);
+    this.time = asNumber(payload.time);
+    this.type = asString(payload.type);
+    this.cid = optionalMaxId(payload.cid, "message.cid");
+    this.attaches = asArray(payload.attaches).map(parseAttachment);
+    this.stats = optionalRecord(payload.stats);
+    this.status = typeof payload.status === "string" ? payload.status : null;
+    this.reactionInfo = parseReactionInfo(payload.reactionInfo);
+    this.options = typeof payload.options === "number" || optionalRecord(payload.options) !== null ? payload.options : null;
+    this.previousMessageId = optionalMaxId(payload.prevMessageId, "message.prevMessageId");
+    this.ttl = typeof payload.ttl === "boolean" ? payload.ttl : null;
+    this.unread = payload.unread === null || payload.unread === undefined ? null : asNumber(payload.unread);
+    this.mark = payload.mark === null || payload.mark === undefined ? null : asNumber(payload.mark);
+    this.elements = asArray(payload.elements).map((item) => asRecord(item, "element"));
+    this.raw = Object.freeze({ ...payload });
+  }
+  static fromPayload(value) {
+    return new Message(asRecord(value, "message"));
+  }
+  bind(actions) {
+    this.actions = actions;
+    return this;
+  }
+  async reply(text, options = {}) {
+    return await this.requireActions().sendMessage({
+      ...options,
+      chatId: this.requireChatId(),
+      text,
+      replyTo: this.id
+    });
+  }
+  async answer(text, options = {}) {
+    return await this.requireActions().sendMessage({
+      ...options,
+      chatId: this.requireChatId(),
+      text
+    });
+  }
+  async forward(chatId, notify = true) {
+    return await this.requireActions().forwardMessage({
+      chatId,
+      messageId: this.id,
+      sourceChatId: this.requireChatId(),
+      notify
+    });
+  }
+  async edit(text, attachments) {
+    return await this.requireActions().editMessage({
+      chatId: this.requireChatId(),
+      messageId: this.id,
+      text,
+      ...attachments !== undefined ? { attachments } : {}
+    });
+  }
+  async pin(notifyPin = true) {
+    return await this.requireActions().pinMessage({
+      chatId: this.requireChatId(),
+      messageId: this.id,
+      notifyPin
+    });
+  }
+  async delete(forMe = false) {
+    return await this.requireActions().deleteMessage({
+      chatId: this.requireChatId(),
+      messageIds: [this.id],
+      forMe
+    });
+  }
+  async read() {
+    return await this.requireActions().readMessage(this.id, this.requireChatId());
+  }
+  async react(reaction) {
+    return await this.requireActions().addReaction(this.requireChatId(), this.id, reaction);
+  }
+  async unreact() {
+    return await this.requireActions().removeReaction(this.requireChatId(), this.id);
+  }
+  async getReactions() {
+    return (await this.requireActions().getReactions(this.requireChatId(), [this.id]))?.get(this.id) ?? null;
+  }
+  requireActions() {
+    if (!this.actions)
+      throw new Error("Message is not bound to a client");
+    return this.actions;
+  }
+  requireChatId() {
+    if (this.chatId === null)
+      throw new Error("Message has no chatId");
+    return this.chatId;
+  }
+}
+
+class Chat {
+  id;
+  type;
+  status;
+  owner;
+  participants;
+  title;
+  lastMessage;
+  pinnedMessage;
+  lastEventTime;
+  link;
+  description;
+  raw;
+  messageActions = null;
+  chatActions = null;
+  constructor(payload) {
+    this.id = toMaxId(payload.id, "chat.id");
+    this.type = asString(payload.type);
+    this.status = asString(payload.status);
+    this.owner = optionalMaxId(payload.owner, "chat.owner") ?? 0n;
+    this.participants = parseParticipants(payload.participants);
+    this.title = typeof payload.title === "string" ? payload.title : null;
+    this.lastMessage = payload.lastMessage ? Message.fromPayload(payload.lastMessage) : null;
+    this.pinnedMessage = payload.pinnedMessage ? Message.fromPayload(payload.pinnedMessage) : null;
+    this.lastEventTime = asNumber(payload.lastEventTime);
+    this.link = typeof payload.link === "string" ? payload.link : null;
+    this.description = typeof payload.description === "string" ? payload.description : null;
+    this.raw = Object.freeze({ ...payload });
+  }
+  static fromPayload(value) {
+    return new Chat(asRecord(value, "chat"));
+  }
+  bind(messageActions, chatActions) {
+    this.messageActions = messageActions;
+    this.chatActions = chatActions;
+    this.lastMessage?.bind(messageActions);
+    this.pinnedMessage?.bind(messageActions);
+    return this;
+  }
+  async answer(text, options = {}) {
+    return await this.requireMessageActions().sendMessage({ ...options, chatId: this.id, text });
+  }
+  async history(options = {}) {
+    return await this.requireMessageActions().fetchHistory({ ...options, chatId: this.id });
+  }
+  async getMessage(messageId) {
+    return (await this.requireMessageActions().getMessages(this.id, [messageId]))[0] ?? null;
+  }
+  async getMessages(messageIds) {
+    return await this.requireMessageActions().getMessages(this.id, messageIds);
+  }
+  async leave() {
+    const actions = this.requireChatActions();
+    if (this.type === ChatType.CHANNEL)
+      await actions.leaveChannel(this.id);
+    else if (this.type === ChatType.CHAT)
+      await actions.leaveGroup(this.id);
+    else
+      throw new Error("Cannot leave a dialog");
+  }
+  async delete(forMe = true) {
+    return await this.requireChatActions().deleteChat(this.id, forMe);
+  }
+  async invite(userIds) {
+    return await this.requireChatActions().inviteUsersToGroup(this.id, userIds);
+  }
+  async removeUsers(userIds) {
+    return await this.requireChatActions().removeUsersFromGroup(this.id, userIds);
+  }
+  requireMessageActions() {
+    if (!this.messageActions)
+      throw new Error("Chat is not bound to a client");
+    return this.messageActions;
+  }
+  requireChatActions() {
+    if (!this.chatActions)
+      throw new Error("Chat is not bound to a client");
+    return this.chatActions;
+  }
+}
+
+class User {
+  id;
+  names;
+  phone;
+  status;
+  description;
+  gender;
+  link;
+  webApp;
+  raw;
+  actions = null;
+  constructor(payload) {
+    this.id = toMaxId(payload.id, "user.id");
+    this.names = asArray(payload.names).map((item) => {
+      const name = asRecord(item, "name");
+      return {
+        firstName: asString(name.firstName),
+        lastName: typeof name.lastName === "string" ? name.lastName : null,
+        ...typeof name.name === "string" ? { name: name.name } : {}
+      };
+    });
+    this.phone = optionalMaxId(payload.phone, "user.phone");
+    this.status = typeof payload.status === "string" ? payload.status : null;
+    this.description = typeof payload.description === "string" ? payload.description : null;
+    this.gender = typeof payload.gender === "string" || typeof payload.gender === "number" ? payload.gender : null;
+    this.link = typeof payload.link === "string" ? payload.link : null;
+    this.webApp = typeof payload.webApp === "string" ? payload.webApp : optionalRecord(payload.webApp);
+    this.raw = Object.freeze({ ...payload });
+  }
+  static fromPayload(value) {
+    return new User(asRecord(value, "user"));
+  }
+  bind(actions) {
+    this.actions = actions;
+    return this;
+  }
+  async addContact() {
+    return await this.requireActions().addContact(this.id);
+  }
+  async removeContact() {
+    return await this.requireActions().removeContact(this.id);
+  }
+  getChatId(userId) {
+    return this.requireActions().getChatId(userId, this.id);
+  }
+  requireActions() {
+    if (!this.actions)
+      throw new Error("User is not bound to a client");
+    return this.actions;
+  }
+}
+
+class Profile {
+  contact;
+  profileOptions;
+  raw;
+  constructor(payload) {
+    this.contact = User.fromPayload(payload.contact);
+    const rawOptions = payload.profileOptions ?? payload.options;
+    this.profileOptions = Array.isArray(rawOptions) ? rawOptions.map((item) => asNumber(item)) : null;
+    this.raw = Object.freeze({ ...payload });
+  }
+  static fromPayload(value) {
+    return new Profile(asRecord(value, "profile"));
+  }
+}
+function parseReactionInfo(value) {
+  if (value === null || value === undefined)
+    return null;
+  const payload = asRecord(value, "reactionInfo");
+  return {
+    totalCount: asNumber(payload.totalCount),
+    counters: asArray(payload.counters).map((item) => {
+      const counter = asRecord(item, "reactionCounter");
+      return { count: asNumber(counter.count), reaction: asString(counter.reaction) };
+    }),
+    yourReaction: typeof payload.yourReaction === "string" ? payload.yourReaction : null
+  };
+}
+function parseReadState(value) {
+  const payload = asRecord(value, "readState");
+  return { unread: asNumber(payload.unread), mark: asNumber(payload.mark) };
+}
+function parseParticipants(value) {
+  const result = new Map;
+  if (value instanceof Map) {
+    for (const [id, role] of value)
+      result.set(toMaxId(id), asNumber(role));
+  } else if (value !== null && typeof value === "object") {
+    for (const [id, role] of Object.entries(value))
+      result.set(toMaxId(id), asNumber(role));
+  }
+  return result;
+}
+// src/session/store.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+import { join } from "path";
+
+// src/logging.ts
+var priorities = {
+  DEBUG: 10,
+  INFO: 20,
+  WARN: 30,
+  ERROR: 40,
+  SILENT: 100
+};
+
+class ConsoleLogger {
+  level;
+  constructor(level) {
+    this.level = level;
+  }
+  debug(message, context) {
+    this.write("DEBUG", message, context);
+  }
+  info(message, context) {
+    this.write("INFO", message, context);
+  }
+  warn(message, context) {
+    this.write("WARN", message, context);
+  }
+  error(message, context) {
+    this.write("ERROR", message, context);
+  }
+  write(level, message, context) {
+    if (priorities[level] < priorities[this.level])
+      return;
+    const suffix = context ? ` ${JSON.stringify(redact(context))}` : "";
+    const line = `[tsmax] ${level.toLowerCase()} ${message}${suffix}`;
+    if (level === "ERROR")
+      console.error(line);
+    else if (level === "WARN")
+      console.warn(line);
+    else
+      console.log(line);
+  }
+}
+var activeLogger = new ConsoleLogger("INFO");
+function configureLogging(level = "INFO", logger) {
+  activeLogger = logger ?? new ConsoleLogger(level);
+  return activeLogger;
+}
+function getLogger() {
+  return activeLogger;
+}
+function redact(value) {
+  if (Array.isArray(value))
+    return value.map(redact);
+  if (value === null || typeof value !== "object")
+    return value;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = /token|password|phone|code/i.test(key) ? "[redacted]" : redact(item);
+  }
+  return result;
+}
+
+// src/session/types.ts
+var DEFAULT_CONFIG_HASH = "00000000-0000000000000000-00000000-0000000000000000-0000000000000000-0-0000000000000000-00000000";
+function defaultSyncState(overrides = {}) {
+  return {
+    chatsSync: overrides.chatsSync ?? -1,
+    contactsSync: overrides.contactsSync ?? -1,
+    draftsSync: overrides.draftsSync ?? -1,
+    presenceSync: overrides.presenceSync ?? -1,
+    configHash: overrides.configHash ?? DEFAULT_CONFIG_HASH
+  };
+}
+function resolveSync(saved, overrides = {}) {
+  return { ...saved, ...overrides };
+}
+
+// src/session/store.ts
+var columns = `token, device_id, phone, mt_instance_id, chats_sync, contacts_sync,
+  drafts_sync, presence_sync, config_hash`;
+
+class SqliteSessionStore {
+  path;
+  database = null;
+  constructor(workDir, databaseName = "session.db") {
+    mkdirSync(workDir, { recursive: true });
+    this.path = join(workDir, databaseName);
+  }
+  async saveSession(session) {
+    const db = this.getDatabase();
+    db.query(`INSERT OR REPLACE INTO sessions (${columns}) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(session.token, session.deviceId, session.phone, session.mtInstanceId, session.sync.chatsSync, session.sync.contactsSync, session.sync.draftsSync, session.sync.presenceSync, String(session.sync.configHash));
+    getLogger().info("session saved");
+  }
+  async updateToken(oldToken, newToken) {
+    this.getDatabase().query("UPDATE sessions SET token = ? WHERE token = ?").run(newToken, oldToken);
+  }
+  async loadSession() {
+    return this.rowToSession(this.getDatabase().query(`SELECT ${columns} FROM sessions LIMIT 1`).get());
+  }
+  async loadSessionByDeviceId(deviceId) {
+    return this.rowToSession(this.getDatabase().query(`SELECT ${columns} FROM sessions WHERE device_id = ?`).get(deviceId));
+  }
+  async loadSessionByPhone(phone) {
+    return this.rowToSession(this.getDatabase().query(`SELECT ${columns} FROM sessions WHERE phone = ?`).get(phone));
+  }
+  async deleteSession(token) {
+    this.getDatabase().query("DELETE FROM sessions WHERE token = ?").run(token);
+  }
+  async deleteAllSessions() {
+    this.getDatabase().run("DELETE FROM sessions");
+  }
+  async close() {
+    this.database?.close();
+    this.database = null;
+  }
+  getDatabase() {
+    if (this.database)
+      return this.database;
+    const database = new Database(this.path, { create: true, strict: true });
+    database.run(`CREATE TABLE IF NOT EXISTS sessions (
+      token TEXT NOT NULL PRIMARY KEY,
+      device_id TEXT NOT NULL,
+      phone TEXT NOT NULL,
+      mt_instance_id TEXT NOT NULL DEFAULT '',
+      chats_sync INTEGER NOT NULL DEFAULT -1,
+      contacts_sync INTEGER NOT NULL DEFAULT -1,
+      drafts_sync INTEGER NOT NULL DEFAULT -1,
+      presence_sync INTEGER NOT NULL DEFAULT -1,
+      config_hash TEXT NOT NULL DEFAULT ''
+    )`);
+    this.ensureColumns(database);
+    database.query("UPDATE sessions SET config_hash = ? WHERE config_hash = ''").run(DEFAULT_CONFIG_HASH);
+    this.database = database;
+    return database;
+  }
+  ensureColumns(database) {
+    const existing = new Set(database.query("PRAGMA table_info(sessions)").all().map((row) => row.name));
+    const definitions = {
+      mt_instance_id: "TEXT NOT NULL DEFAULT ''",
+      chats_sync: "INTEGER NOT NULL DEFAULT -1",
+      contacts_sync: "INTEGER NOT NULL DEFAULT -1",
+      drafts_sync: "INTEGER NOT NULL DEFAULT -1",
+      presence_sync: "INTEGER NOT NULL DEFAULT -1",
+      config_hash: "TEXT NOT NULL DEFAULT ''"
+    };
+    for (const [name, definition] of Object.entries(definitions)) {
+      if (!existing.has(name))
+        database.run(`ALTER TABLE sessions ADD COLUMN ${name} ${definition}`);
+    }
+  }
+  rowToSession(row) {
+    if (!row)
+      return null;
+    return {
+      token: row.token,
+      deviceId: row.device_id,
+      phone: row.phone,
+      mtInstanceId: row.mt_instance_id || "",
+      sync: defaultSyncState({
+        chatsSync: row.chats_sync,
+        contactsSync: row.contacts_sync,
+        draftsSync: row.drafts_sync,
+        presenceSync: row.presence_sync,
+        configHash: row.config_hash || DEFAULT_CONFIG_HASH
+      })
+    };
+  }
+}
+// src/files/file.ts
+import { basename, extname } from "path";
+
+class MaxFile {
+  raw;
+  path;
+  url;
+  name;
+  constructor(source) {
+    const sources = [source.raw, source.path, source.url].filter((value) => value !== undefined);
+    if (sources.length !== 1)
+      throw new TypeError("Exactly one of raw, path, or url must be provided");
+    this.raw = source.raw ?? null;
+    this.path = source.path ?? null;
+    this.url = source.url ?? null;
+    this.name = source.name ?? inferName(source.path, source.url);
+    if (!this.name)
+      throw new TypeError("A name is required for raw file data");
+  }
+  async read() {
+    if (this.raw)
+      return this.raw;
+    if (this.path)
+      return new Uint8Array(await Bun.file(this.path).arrayBuffer());
+    if (this.url) {
+      const response = await fetch(this.url);
+      if (!response.ok)
+        throw new Error(`Failed to download ${this.url}: ${response.status}`);
+      return new Uint8Array(await response.arrayBuffer());
+    }
+    throw new Error("File has no source");
+  }
+  async size() {
+    if (this.raw)
+      return this.raw.byteLength;
+    if (this.path)
+      return Bun.file(this.path).size;
+    if (this.url) {
+      const response = await fetch(this.url, { method: "HEAD" });
+      if (!response.ok)
+        throw new Error(`Failed to inspect ${this.url}: ${response.status}`);
+      const length = response.headers.get("content-length");
+      if (!length)
+        return (await this.read()).byteLength;
+      return Number(length);
+    }
+    throw new Error("File has no source");
+  }
+  async* chunks(chunkSize) {
+    if (!Number.isInteger(chunkSize) || chunkSize <= 0)
+      throw new RangeError("chunkSize must be positive");
+    const data = await this.read();
+    for (let offset = 0;offset < data.byteLength; offset += chunkSize) {
+      yield data.slice(offset, offset + chunkSize);
+    }
+  }
+}
+
+class File extends MaxFile {
+}
+
+class Video extends MaxFile {
+}
+var allowedPhotoExtensions = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"]);
+
+class Photo extends MaxFile {
+  constructor(source) {
+    super(source);
+    const extension = extname(this.url ? new URL(this.url).pathname : this.path ?? this.name).toLowerCase();
+    if (!allowedPhotoExtensions.has(extension)) {
+      throw new TypeError(`Invalid photo extension: ${extension}`);
+    }
+  }
+  get format() {
+    const extension = extname(this.url ? new URL(this.url).pathname : this.path ?? this.name).toLowerCase().slice(1);
+    const normalized = extension === "jpg" ? "jpeg" : extension;
+    return { extension, mimeType: `image/${normalized}` };
+  }
+}
+function inferName(path, url) {
+  if (path)
+    return basename(path);
+  if (url)
+    return basename(new URL(url).pathname);
+  return "";
+}
+// src/auth/providers.ts
+import QRCode from "qrcode";
+var consoleSmsCodeProvider = (phone) => {
+  const code = prompt(`SMS code for ${phone}:`);
+  if (!code)
+    throw new Error("SMS code is required");
+  return code;
+};
+var consolePasswordProvider = (hint) => {
+  const password = prompt(`2FA password${hint ? ` (${hint})` : ""}:`);
+  if (!password)
+    throw new Error("2FA password is required");
+  return password;
+};
+var consoleEmailCodeProvider = (email) => {
+  const code = prompt(`Email code for ${email}:`);
+  if (!code)
+    throw new Error("Email code is required");
+  return code;
+};
+var consoleQrHandler = async (link) => {
+  console.log(await QRCode.toString(link, { type: "terminal", small: true }));
+  console.log(link);
+};
+
+// src/auth/flows.ts
+class SmsAuthFlow {
+  codeProvider;
+  passwordProvider;
+  constructor(codeProvider = consoleSmsCodeProvider, passwordProvider = consolePasswordProvider) {
+    this.codeProvider = codeProvider;
+    this.passwordProvider = passwordProvider;
+  }
+  async authenticate(app) {
+    const phone = app.config.phone;
+    if (!phone)
+      throw new Error("Phone is required for SMS authentication");
+    const start = await app.api.auth.requestCode(phone);
+    const token = typeof start.token === "string" ? start.token : "";
+    if (!token)
+      throw new Error("SMS request returned no token");
+    const result = await app.api.auth.sendCode(token, await this.codeProvider(phone));
+    if (result.loginToken)
+      return { token: result.loginToken };
+    if (result.passwordChallenge) {
+      return {
+        token: await this.passwordLogin(app, result.passwordChallenge.trackId, result.passwordChallenge.hint)
+      };
+    }
+    if (result.registerToken) {
+      const registration = app.config.registrationConfig;
+      if (!registration)
+        throw new Error("registrationConfig is required for a new account");
+      return {
+        token: await app.api.auth.confirmRegistration(registration.firstName, registration.lastName ?? null, result.registerToken)
+      };
+    }
+    throw new Error("Authentication returned no login, registration, or password challenge");
+  }
+  async passwordLogin(app, trackId, hint) {
+    for (;; ) {
+      const result = await app.api.auth.checkPassword(trackId, await this.passwordProvider(hint));
+      if (result.loginToken)
+        return result.loginToken;
+    }
+  }
+}
+
+class QrAuthFlow {
+  qrHandler;
+  passwordProvider;
+  constructor(qrHandler = consoleQrHandler, passwordProvider = consolePasswordProvider) {
+    this.qrHandler = qrHandler;
+    this.passwordProvider = passwordProvider;
+  }
+  async authenticate(app) {
+    const request = await app.api.auth.requestQr();
+    await this.qrHandler(request.qrLink);
+    while (Date.now() < request.expiresAt) {
+      const status = await app.api.auth.checkQr(request.trackId);
+      if (status.loginAvailable) {
+        const result = await app.api.auth.confirmQr(request.trackId);
+        if (result.loginToken)
+          return { token: result.loginToken };
+        if (result.passwordChallenge) {
+          for (;; ) {
+            const checked = await app.api.auth.checkPassword(result.passwordChallenge.trackId, await this.passwordProvider(result.passwordChallenge.hint));
+            if (checked.loginToken)
+              return { token: checked.loginToken };
+          }
+        }
+        break;
+      }
+      await Bun.sleep(request.pollingInterval);
+    }
+    throw new Error("QR authentication expired");
+  }
+}
+// src/telemetry/navigation.ts
+var Screen = {
+  BACKGROUND: 1,
+  CONTACTS: 100,
+  CHATS: 150,
+  SEARCH: 151,
+  CALLS: 300,
+  CHAT: 350,
+  SETTINGS: 450,
+  MINIAPP: 500
+};
+var mainTabParams = { source_type: 5, source_id: 1, tab_config: 2 };
+var defaultProfiles = {
+  quick: {
+    steps: 2,
+    minPause: 35,
+    maxPause: 95,
+    longPauseChance: 0.05,
+    minLongPause: 180,
+    maxLongPause: 420,
+    backChance: 0.3
+  },
+  browse: {
+    steps: 4,
+    minPause: 70,
+    maxPause: 210,
+    longPauseChance: 0.12,
+    minLongPause: 240,
+    maxLongPause: 720,
+    backChance: 0.22
+  },
+  read: {
+    steps: 3,
+    minPause: 140,
+    maxPause: 360,
+    longPauseChance: 0.25,
+    minLongPause: 420,
+    maxLongPause: 1200,
+    backChance: 0.18
+  }
+};
+var graph = {
+  [Screen.BACKGROUND]: [
+    { screen: Screen.CHATS, weight: 10 },
+    { screen: Screen.SETTINGS, weight: 1 }
+  ],
+  [Screen.CHATS]: [
+    { screen: Screen.CHAT, weight: 7 },
+    { screen: Screen.CONTACTS, weight: 2 },
+    { screen: Screen.SEARCH, weight: 2 },
+    { screen: Screen.CALLS, weight: 1 },
+    { screen: Screen.SETTINGS, weight: 1 },
+    { screen: Screen.CHATS, weight: 2 }
+  ],
+  [Screen.CHAT]: [
+    { screen: Screen.CHATS, weight: 8 },
+    { screen: Screen.CHAT, weight: 2 },
+    { screen: Screen.SETTINGS, weight: 1 }
+  ],
+  [Screen.CONTACTS]: [
+    { screen: Screen.CHATS, weight: 6 },
+    { screen: Screen.CHAT, weight: 2 },
+    { screen: Screen.SEARCH, weight: 1 }
+  ],
+  [Screen.SEARCH]: [
+    { screen: Screen.CHATS, weight: 5 },
+    { screen: Screen.CHAT, weight: 3 },
+    { screen: Screen.CONTACTS, weight: 1 }
+  ],
+  [Screen.CALLS]: [
+    { screen: Screen.CHATS, weight: 5 },
+    { screen: Screen.CONTACTS, weight: 2 },
+    { screen: Screen.SETTINGS, weight: 2 }
+  ],
+  [Screen.SETTINGS]: [
+    { screen: Screen.CHATS, weight: 7 },
+    { screen: Screen.CONTACTS, weight: 2 },
+    { screen: Screen.CALLS, weight: 2 },
+    { screen: Screen.MINIAPP, weight: 1 }
+  ],
+  [Screen.MINIAPP]: [
+    { screen: Screen.SETTINGS, weight: 3 },
+    { screen: Screen.CHATS, weight: 6 }
+  ]
+};
+
+class NavigationPlanner {
+  random;
+  currentScreen = Screen.BACKGROUND;
+  history = [];
+  constructor(random = Math) {
+    this.random = random;
+  }
+  newProfile() {
+    const profiles = Object.values(defaultProfiles);
+    return profiles[Math.floor(this.random.random() * profiles.length)];
+  }
+  pause(profile) {
+    const long = this.random.random() < profile.longPauseChance;
+    return this.between(long ? profile.minLongPause : profile.minPause, long ? profile.maxLongPause : profile.maxPause);
+  }
+  nextScreen(profile) {
+    if (this.history.length > 0 && this.random.random() < profile.backChance) {
+      this.currentScreen = this.history.pop();
+      return this.currentScreen;
+    }
+    const transitions = graph[this.currentScreen];
+    const total = transitions.reduce((sum, item) => sum + item.weight, 0);
+    let point = Math.floor(this.random.random() * total) + 1;
+    let selected = transitions[transitions.length - 1];
+    for (const transition of transitions) {
+      point -= transition.weight;
+      if (point <= 0) {
+        selected = transition;
+        break;
+      }
+    }
+    if (selected.screen !== this.currentScreen) {
+      this.history.push(this.currentScreen);
+      if (this.history.length > 4)
+        this.history.shift();
+    }
+    this.currentScreen = selected.screen;
+    return selected.screen;
+  }
+  resetToBackground() {
+    this.currentScreen = Screen.BACKGROUND;
+    this.history.length = 0;
+  }
+  between(minimum, maximum) {
+    return minimum + this.random.random() * (maximum - minimum);
+  }
+}
+// src/telemetry/payloads.ts
+class TelemetryPayloadBuilder {
+  random;
+  constructor(random = Math) {
+    this.random = random;
+  }
+  login(userId, sessionId) {
+    return this.event(userId, sessionId, "PERF", "login", {
+      properties: { connection_type: 2, vpn: 0, class: 2, background: 1, warm_start: 1 },
+      errorType: 100
+    });
+  }
+  navigation(options) {
+    return this.event(options.userId, options.sessionId, "NAV", "GO", {
+      prev_time: options.prevTime,
+      screen_to: options.screenTo,
+      action_id: options.actionId,
+      screen_from: options.screenFrom,
+      ...options.extraParams
+    });
+  }
+  openChat(userId, sessionId) {
+    const messages = this.integer(60, 240);
+    const render = this.integer(50, 260);
+    return this.event(userId, sessionId, "PERF", "open_chat_to_render", {
+      spans: [
+        { duration: messages + render, name: "open_chat_to_render" },
+        { duration: messages, name: "messages_list_created" },
+        { duration: render, name: "messages_render" }
+      ],
+      properties: { class: 2, warm: 1, flow: 1 }
+    });
+  }
+  openChats(userId, sessionId) {
+    const created = this.integer(50, 230);
+    const rendered = this.integer(180, 650);
+    return this.event(userId, sessionId, "PERF", "open_chats_to_render", {
+      spans: [
+        { duration: created + rendered, name: "open_chats_to_render" },
+        { duration: created, name: "chats_tab_created" },
+        { duration: rendered, name: "chat_list_render" }
+      ],
+      properties: { class: 2 }
+    });
+  }
+  toPayload(events) {
+    return { events };
+  }
+  event(userId, sessionId, type, event, params) {
+    return { time: Date.now(), userId, type, event, params, sessionId };
+  }
+  integer(minimum, maximum) {
+    return Math.floor(this.random.random() * (maximum - minimum + 1)) + minimum;
+  }
+}
+// src/telemetry/service.ts
+var defaultTelemetryTiming = {
+  startupDelay: [15, 90],
+  sessionIdleDelay: [900, 2700],
+  renderDelay: [0.15, 1.2],
+  returnDelay: [12, 45],
+  returnToBackgroundChance: 0.4,
+  openChatsRenderChance: 0.2
+};
+
+class TelemetryService {
+  app;
+  random;
+  timing;
+  planner;
+  payloads;
+  controller = null;
+  task = null;
+  actionId = 0;
+  sessionId;
+  lastNavTime = Date.now();
+  constructor(app, random = Math, timing = defaultTelemetryTiming) {
+    this.app = app;
+    this.random = random;
+    this.timing = timing;
+    this.planner = new NavigationPlanner(random);
+    this.payloads = new TelemetryPayloadBuilder(random);
+    this.sessionId = app.config.device.clientSessionId;
+  }
+  get running() {
+    return this.task !== null;
+  }
+  get ready() {
+    return this.app.started && this.app.me !== null && this.app.connection.isOpen !== false;
+  }
+  start() {
+    if (this.running || !this.ready)
+      return;
+    const controller = new AbortController;
+    this.controller = controller;
+    this.task = this.run(controller.signal).finally(() => {
+      if (this.controller === controller) {
+        this.controller = null;
+        this.task = null;
+      }
+    });
+  }
+  async stop() {
+    const task = this.task;
+    this.controller?.abort();
+    this.controller = null;
+    if (task)
+      await task.catch(() => {
+        return;
+      });
+    this.task = null;
+  }
+  async sendEvents(events) {
+    if (events.length === 0 || !this.ready)
+      return;
+    await this.app.invoke(Opcode.LOG, this.payloads.toPayload(events), this.app.config.requestTimeout);
+  }
+  sourceParams(screen) {
+    if (screen === Screen.CHATS)
+      return { ...mainTabParams };
+    if (screen !== Screen.CHAT)
+      return {};
+    const chat = this.pickChat();
+    return chat ? { source_type: chat.type === "DIALOG" ? 1 : 2, source_id: chat.id } : { source_type: 1, source_id: this.userId };
+  }
+  async run(signal) {
+    try {
+      await sleep(this.between(this.timing.startupDelay) * 1000, signal);
+      await this.sendEvents([this.payloads.login(this.userId, this.sessionId)]);
+      while (!signal.aborted) {
+        this.sessionId += 1;
+        await this.sendEvents(await this.collectSessionEvents(this.planner.newProfile(), signal));
+        this.planner.resetToBackground();
+        await sleep(this.between(this.timing.sessionIdleDelay) * 1000, signal);
+      }
+    } catch (error) {
+      if (!signal.aborted)
+        getLogger().debug("telemetry loop stopped", { error: String(error) });
+    }
+  }
+  async collectSessionEvents(profile, signal) {
+    const events = [];
+    for (let step = 0;step < profile.steps; step += 1) {
+      await sleep(this.planner.pause(profile) * 1000, signal);
+      if (!this.ready)
+        return events;
+      const from = this.planner.currentScreen;
+      const to = this.planner.nextScreen(profile);
+      events.push(this.navigationEvent(from, to));
+      if (to === Screen.CHAT) {
+        await sleep(this.between(this.timing.renderDelay) * 1000, signal);
+        events.push(this.payloads.openChat(this.userId, this.sessionId));
+      } else if (to === Screen.CHATS && this.random.random() < this.timing.openChatsRenderChance) {
+        await sleep(this.between(this.timing.renderDelay) * 1000, signal);
+        events.push(this.payloads.openChats(this.userId, this.sessionId));
+      }
+    }
+    if (this.planner.currentScreen !== Screen.BACKGROUND && this.random.random() < this.timing.returnToBackgroundChance) {
+      await sleep(this.between(this.timing.returnDelay) * 1000, signal);
+      const from = this.planner.currentScreen;
+      this.planner.resetToBackground();
+      events.push(this.navigationEvent(from, Screen.BACKGROUND));
+    }
+    return events;
+  }
+  navigationEvent(from, to) {
+    this.actionId = this.actionId + 1 >>> 0;
+    const event = this.payloads.navigation({
+      userId: this.userId,
+      sessionId: this.sessionId,
+      screenFrom: from,
+      screenTo: to,
+      prevTime: this.lastNavTime,
+      actionId: this.actionId,
+      extraParams: this.sourceParams(to)
+    });
+    this.lastNavTime = event.time;
+    return event;
+  }
+  get userId() {
+    if (!this.app.me)
+      throw new Error("Telemetry requires an authenticated profile");
+    return this.app.me.contact.id;
+  }
+  pickChat() {
+    if (this.app.chats.length === 0)
+      return null;
+    return this.app.chats[Math.floor(this.random.random() * this.app.chats.length)] ?? null;
+  }
+  between(range) {
+    return range[0] + this.random.random() * (range[1] - range[0]);
+  }
+}
+async function sleep(milliseconds, signal) {
+  if (signal.aborted)
+    throw signal.reason;
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, milliseconds);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }, { once: true });
+  });
+}
+// src/api/response.ts
+function payload(frame) {
+  return frame.payload ?? {};
+}
+function payloadItem(frame, key) {
+  return payload(frame)[key];
+}
+function requiredItem(frame, key) {
+  const value = payloadItem(frame, key);
+  if (value === null || value === undefined)
+    throw new TypeError(`Response is missing ${key}`);
+  return value;
+}
+function listItem(frame, key) {
+  return asArray(payloadItem(frame, key));
+}
+
+// src/api/account.ts
+class AccountApi {
+  app;
+  uploads;
+  constructor(app, uploads) {
+    this.app = app;
+    this.uploads = uploads;
+  }
+  async requestProfilePhotoUploadUrl() {
+    return asString(requiredItem(await this.app.invoke(Opcode.PHOTO_UPLOAD, { count: 1, profile: true }), "url"));
+  }
+  async changeProfile(options) {
+    let photoToken = options.photoToken ?? null;
+    if (options.photo) {
+      const uploaded = await this.uploads.uploadPhoto(options.photo, true);
+      if (uploaded._type === "PHOTO")
+        photoToken = uploaded.photoToken;
+    }
+    const frame = await this.app.invoke(Opcode.PROFILE, {
+      firstName: options.firstName,
+      lastName: options.lastName ?? null,
+      description: options.description ?? null,
+      photoToken,
+      avatarType: "USER_AVATAR"
+    });
+    this.app.me = Profile.fromPayload(requiredItem(frame, "profile"));
+    return true;
+  }
+  async createFolder(title, chatInclude, filters = []) {
+    return payload(await this.app.invoke(Opcode.FOLDERS_UPDATE, {
+      id: crypto.randomUUID(),
+      title,
+      include: chatInclude,
+      filters
+    }));
+  }
+  async getFolders(folderSync = 0) {
+    return payload(await this.app.invoke(Opcode.FOLDERS_GET, { folderSync }));
+  }
+  async updateFolder(folderId, title, chatInclude = [], filters = [], options = []) {
+    return payload(await this.app.invoke(Opcode.FOLDERS_UPDATE, {
+      id: folderId,
+      title,
+      include: chatInclude,
+      filters,
+      options
+    }));
+  }
+  async deleteFolder(folderId) {
+    return payload(await this.app.invoke(Opcode.FOLDERS_DELETE, { folderIds: [folderId] }));
+  }
+  async closeAllSessions() {
+    if (!this.app.session)
+      return false;
+    const data = payload(await this.app.invoke(Opcode.SESSIONS_CLOSE, {}));
+    const token = asString(data.token);
+    if (!token)
+      return false;
+    await this.app.store.updateToken(this.app.session.token, token);
+    this.app.session = { ...this.app.session, token };
+    return true;
+  }
+  async logout() {
+    await this.app.invoke(Opcode.LOGOUT, {});
+    return true;
+  }
+}
+// src/config.ts
+var DeviceType = {
+  WEB: "WEB",
+  ANDROID: "ANDROID",
+  IOS: "IOS",
+  DESKTOP: "DESKTOP"
+};
+var androidAgents = [
+  {
+    deviceType: DeviceType.ANDROID,
+    osVersion: "Android 14",
+    timezone: "Europe/Moscow",
+    screen: "411dpi 411dpi 1080x2400",
+    pushDeviceType: "GCM",
+    arch: "arm64-v8a",
+    locale: "ru",
+    deviceName: "Pixel 8",
+    deviceLocale: "ru"
+  },
+  {
+    deviceType: DeviceType.ANDROID,
+    osVersion: "Android 14",
+    timezone: "Europe/Moscow",
+    screen: "425dpi 425dpi 1080x2340",
+    pushDeviceType: "GCM",
+    arch: "arm64-v8a",
+    locale: "ru",
+    deviceName: "Samsung SM-S911B",
+    deviceLocale: "ru"
+  }
+];
+function resolveConfig(options) {
+  const extra = options.extra ?? {};
+  const userAgent = extra.userAgent ?? (options.web ? createWebAgent() : createMobileAgent());
+  return {
+    phone: options.phone ?? null,
+    workDir: options.workDir ?? ".",
+    sessionName: options.sessionName ?? "session.db",
+    token: extra.token ?? null,
+    registrationConfig: extra.registrationConfig ?? null,
+    host: extra.host ?? "api.oneme.ru",
+    port: extra.port ?? 443,
+    url: extra.url ?? "wss://ws-api.oneme.ru/websocket",
+    useTls: extra.useTls ?? true,
+    proxy: extra.proxy ?? null,
+    reconnect: extra.reconnect ?? true,
+    reconnectDelay: extra.reconnectDelay ?? 1,
+    requestTimeout: extra.requestTimeout ?? 30,
+    logLevel: extra.logLevel ?? "INFO",
+    telemetry: extra.telemetry ?? true,
+    ...extra.store ? { store: extra.store } : {},
+    sync: extra.sync ?? defaultSyncState(),
+    device: {
+      deviceId: extra.deviceId ?? crypto.randomUUID(),
+      mtInstanceId: extra.mtInstanceId ?? crypto.randomUUID(),
+      clientSessionId: Math.floor(Math.random() * 70) + 1,
+      userAgent
+    }
+  };
+}
+function createMobileAgent() {
+  const base = androidAgents[Math.floor(Math.random() * androidAgents.length)];
+  return { ...base, appVersion: "26.14.1", buildNumber: 6686 };
+}
+function createWebAgent() {
+  return {
+    deviceType: DeviceType.WEB,
+    appVersion: "26.5.5",
+    osVersion: "Linux",
+    timezone: "Europe/Moscow",
+    screen: "1080x1920 1.0x",
+    locale: "ru",
+    deviceName: "Chrome",
+    deviceLocale: "ru",
+    headerUserAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
+  };
+}
+
+// src/api/auth.ts
+class AuthApi {
+  app;
+  constructor(app) {
+    this.app = app;
+  }
+  async requestCode(phone) {
+    const frame = await this.app.invoke(Opcode.AUTH_REQUEST, {
+      phone,
+      type: "START_AUTH",
+      language: "ru"
+    });
+    return payload(frame);
+  }
+  async sendCode(token, verifyCode) {
+    const frame = await this.app.invoke(Opcode.AUTH, {
+      token,
+      verifyCode,
+      authTokenType: "CHECK_CODE"
+    });
+    return parseCodeResult(payload(frame));
+  }
+  async checkPassword(trackId, password) {
+    const frame = await this.app.invoke(Opcode.AUTH_LOGIN_CHECK_PASSWORD, { trackId, password });
+    const data = payload(frame);
+    return { ...parseCodeResult(data), error: typeof data.error === "string" ? data.error : null };
+  }
+  async requestQr() {
+    const data = payload(await this.app.invoke(Opcode.GET_QR, {}));
+    return {
+      expiresAt: asNumber(data.expiresAt),
+      pollingInterval: asNumber(data.pollingInterval),
+      qrLink: asString(data.qrLink),
+      trackId: asString(data.trackId),
+      ttl: asNumber(data.ttl)
+    };
+  }
+  async checkQr(trackId) {
+    const data = asRecord(requiredItem(await this.app.invoke(Opcode.GET_QR_STATUS, { trackId }), "status"));
+    return { expiresAt: asNumber(data.expiresAt), loginAvailable: data.loginAvailable === true };
+  }
+  async confirmQr(trackId) {
+    return parseCodeResult(payload(await this.app.invoke(Opcode.LOGIN_BY_QR, { trackId })));
+  }
+  async confirmRegistration(firstName, lastName, token) {
+    const data = payload(await this.app.invoke(Opcode.AUTH_CONFIRM, {
+      firstName,
+      lastName,
+      token,
+      tokenType: "REGISTER"
+    }));
+    return asString(data.token);
+  }
+  async handshake(deviceId) {
+    const { userAgent, mtInstanceId, clientSessionId } = this.app.config.device;
+    if (userAgent.deviceType === DeviceType.WEB) {
+      await this.app.invoke(Opcode.SESSION_INIT, {
+        userAgent: webUserAgent(userAgent),
+        deviceId
+      });
+    } else {
+      await this.app.invoke(Opcode.SESSION_INIT, {
+        mt_instanceid: mtInstanceId,
+        userAgent,
+        clientSessionId,
+        deviceId
+      });
+    }
+  }
+  async login() {
+    const session = this.app.session;
+    if (!session)
+      throw new Error("No session available for login");
+    const sync = resolveSync(session.sync, this.app.config.sync);
+    const userAgent = this.app.config.device.userAgent;
+    const loginPayload = userAgent.deviceType === DeviceType.WEB ? {
+      token: session.token,
+      chatsCount: 40,
+      interactive: true,
+      chatsSync: sync.chatsSync,
+      contactsSync: sync.contactsSync,
+      presenceSync: sync.presenceSync,
+      draftsSync: sync.draftsSync
+    } : {
+      userAgent,
+      token: session.token,
+      chatsSync: sync.chatsSync,
+      contactsSync: sync.contactsSync,
+      draftsSync: sync.draftsSync,
+      presenceSync: sync.presenceSync,
+      interactive: true,
+      exp: { chatsCountGroups: Uint8Array.from([10, 50]) },
+      configHash: sync.configHash
+    };
+    const result = parseLogin(payload(await this.app.invoke(Opcode.LOGIN, loginPayload)), this.app);
+    const updatedSync = defaultSyncState({
+      chatsSync: result.time ?? session.sync.chatsSync,
+      contactsSync: result.time ?? session.sync.contactsSync,
+      draftsSync: result.time ?? session.sync.draftsSync,
+      presenceSync: result.time ?? session.sync.presenceSync,
+      configHash: result.configHash ?? session.sync.configHash
+    });
+    this.app.session = {
+      ...session,
+      mtInstanceId: this.app.config.device.mtInstanceId,
+      sync: updatedSync
+    };
+    await this.app.store.saveSession(this.app.session);
+    return result;
+  }
+  async createTrack() {
+    const data = payload(await this.app.invoke(Opcode.AUTH_CREATE_TRACK, { type: 0 }));
+    const trackId = asString(data.trackId);
+    if (!trackId)
+      throw new Error("Failed to create auth track");
+    return trackId;
+  }
+  async setTwoFactor(options) {
+    const trackId = await this.createTrack();
+    await this.app.invoke(Opcode.AUTH_VALIDATE_PASSWORD, { trackId, password: options.password });
+    const capabilities = [1];
+    if (options.email !== undefined) {
+      await this.app.invoke(Opcode.AUTH_VERIFY_EMAIL, { trackId, email: options.email });
+      if (!options.emailCodeProvider)
+        throw new Error("emailCodeProvider is required");
+      const verifyCode = await options.emailCodeProvider(options.email);
+      await this.app.invoke(Opcode.AUTH_CHECK_EMAIL, { trackId, verifyCode });
+      capabilities.push(3);
+    }
+    if (options.hint !== undefined) {
+      await this.app.invoke(Opcode.AUTH_VALIDATE_HINT, { trackId, hint: options.hint });
+      capabilities.push(2);
+    }
+    await this.app.invoke(Opcode.AUTH_SET_2FA, {
+      trackId,
+      password: options.password,
+      hint: options.hint ?? null,
+      expectedCapabilities: capabilities
+    });
+    return true;
+  }
+  async removeTwoFactor(password) {
+    const trackId = await this.createTrack();
+    await this.app.invoke(Opcode.AUTH_CHECK_PASSWORD, { trackId, password });
+    await this.app.invoke(Opcode.AUTH_SET_2FA, {
+      trackId,
+      remove2fa: true,
+      expectedCapabilities: [4]
+    });
+    return true;
+  }
+  async changePassword(oldPassword, newPassword) {
+    const trackId = await this.createTrack();
+    await this.app.invoke(Opcode.AUTH_CHECK_PASSWORD, { trackId, password: oldPassword });
+    await this.app.invoke(Opcode.AUTH_VALIDATE_PASSWORD, { trackId, password: newPassword });
+    await this.app.invoke(Opcode.AUTH_SET_2FA, {
+      trackId,
+      password: newPassword,
+      hint: null,
+      expectedCapabilities: [5]
+    });
+    return true;
+  }
+  async authorizeQrLogin(qrLink) {
+    await this.app.invoke(Opcode.AUTH_QR_APPROVE, { qrLink });
+    return true;
+  }
+  async checkTwoFactor() {
+    return this.app.me?.profileOptions?.includes(2) ?? false;
+  }
+}
+function parseCodeResult(data) {
+  const attrs = data.tokenAttrs ? asRecord(data.tokenAttrs) : {};
+  const login = attrs.LOGIN ? asRecord(attrs.LOGIN) : null;
+  const register = attrs.REGISTER ? asRecord(attrs.REGISTER) : null;
+  const challenge = data.passwordChallenge ? asRecord(data.passwordChallenge) : null;
+  return {
+    loginToken: login ? asString(login.token) || null : null,
+    registerToken: register ? asString(register.token) || null : null,
+    passwordChallenge: challenge ? {
+      trackId: asString(challenge.trackId),
+      hint: typeof challenge.hint === "string" ? challenge.hint : null
+    } : null
+  };
+}
+function parseLogin(data, app) {
+  const profile = Profile.fromPayload(data.profile);
+  app.bindUser(profile.contact);
+  const chats = asArray(data.chats).map((item) => app.bindChat(Chat.fromPayload(item)));
+  const contacts = asArray(data.contacts).map((item) => item ? app.bindUser(User.fromPayload(item)) : null);
+  const messages = new Map;
+  if (data.messages && typeof data.messages === "object") {
+    for (const [chatId, items] of Object.entries(data.messages)) {
+      messages.set(toMaxId(chatId), asArray(items).map((item) => app.bindMessage(Message.fromPayload(item))));
+    }
+  }
+  const config = data.config ? asRecord(data.config) : null;
+  return {
+    chats,
+    profile,
+    messages,
+    contacts,
+    token: typeof data.token === "string" ? data.token : null,
+    time: data.time === null || data.time === undefined ? null : asNumber(data.time),
+    configHash: typeof config?.hash === "string" || typeof config?.hash === "number" ? config.hash : null
+  };
+}
+function webUserAgent(agent) {
+  const {
+    deviceType,
+    locale,
+    deviceLocale,
+    osVersion,
+    deviceName,
+    headerUserAgent,
+    appVersion,
+    screen,
+    timezone
+  } = agent;
+  return {
+    deviceType,
+    locale,
+    deviceLocale,
+    osVersion,
+    deviceName,
+    appVersion,
+    screen,
+    timezone,
+    ...headerUserAgent ? { headerUserAgent } : {}
+  };
+}
+// src/api/bots.ts
+class BotsApi {
+  app;
+  constructor(app) {
+    this.app = app;
+  }
+  async getBotInitData(botId, chatId, startParam) {
+    return payload(await this.app.invoke(Opcode.WEB_APP_INIT_DATA, {
+      botId,
+      chatId: chatId ?? null,
+      startParam: startParam ?? null
+    }));
+  }
+}
+// src/errors.ts
+class TsMaxError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+}
+
+class UploadError extends TsMaxError {
+}
+
+class ConnectionError extends TsMaxError {
+}
+
+class TimeoutError extends TsMaxError {
+}
+
+class ApiError extends TsMaxError {
+  opcode;
+  payload;
+  constructor(opcode, options = {}) {
+    const parts = [];
+    if (options.localizedMessage)
+      parts.push(options.localizedMessage);
+    if (options.message && options.message !== options.localizedMessage)
+      parts.push(options.message);
+    if (options.title)
+      parts.push(`(${options.title})`);
+    if (options.error)
+      parts.push(`[${options.error}]`);
+    super(parts.join(" ") || "API request failed");
+    this.opcode = opcode;
+    this.payload = options.payload ?? {};
+    this.error = options.error ?? null;
+    this.title = options.title ?? null;
+    this.localizedMessage = options.localizedMessage ?? null;
+  }
+  error;
+  title;
+  localizedMessage;
+}
+
+// src/api/chats.ts
+class ChatApi {
+  app;
+  cache = new Map;
+  constructor(app) {
+    this.app = app;
+  }
+  seed(chats) {
+    for (const chat of chats)
+      this.cache.set(chat.id, this.app.bindChat(chat));
+  }
+  async createGroup(name, participantIds = [], notify = true) {
+    const frame = await this.app.invoke(Opcode.MSG_SEND, {
+      message: {
+        cid: BigInt(Date.now()),
+        attaches: [
+          {
+            _type: "CONTROL",
+            event: "new",
+            chatType: "CHAT",
+            title: name,
+            userIds: participantIds
+          }
+        ]
+      },
+      notify
+    });
+    const chatRaw = payloadItem(frame, "chat");
+    if (!chatRaw)
+      return null;
+    const chat = this.cacheChat(Chat.fromPayload(chatRaw));
+    const data = payload(frame);
+    const message = this.app.bindMessage(Message.fromPayload(data.message ?? data));
+    return [chat, message];
+  }
+  async inviteUsersToGroup(chatId, userIds, showHistory = true) {
+    return await this.memberAction(chatId, userIds, "add", showHistory);
+  }
+  async inviteUsersToChannel(chatId, userIds, showHistory = true) {
+    return await this.inviteUsersToGroup(chatId, userIds, showHistory);
+  }
+  async removeUsersFromGroup(chatId, userIds, cleanMsgPeriod = 0) {
+    const frame = await this.app.invoke(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId,
+      userIds,
+      operation: "remove",
+      cleanMsgPeriod
+    });
+    return this.optionalChat(payloadItem(frame, "chat"));
+  }
+  async changeGroupSettings(chatId, settings) {
+    const options = {};
+    const keys = [
+      ["allCanPinMessage", "ALL_CAN_PIN_MESSAGE"],
+      ["onlyOwnerCanChangeIconTitle", "ONLY_OWNER_CAN_CHANGE_ICON_TITLE"],
+      ["onlyAdminCanAddMember", "ONLY_ADMIN_CAN_ADD_MEMBER"],
+      ["onlyAdminCanCall", "ONLY_ADMIN_CAN_CALL"],
+      ["membersCanSeePrivateLink", "MEMBERS_CAN_SEE_PRIVATE_LINK"]
+    ];
+    for (const [source, target] of keys) {
+      const value = settings[source];
+      if (typeof value === "boolean")
+        options[target] = value;
+    }
+    const frame = await this.app.invoke(Opcode.CHAT_UPDATE, { chatId, options });
+    this.optionalChat(payloadItem(frame, "chat"));
+  }
+  async changeGroupProfile(chatId, name, description = null) {
+    const frame = await this.app.invoke(Opcode.CHAT_UPDATE, { chatId, theme: name, description });
+    this.optionalChat(payloadItem(frame, "chat"));
+  }
+  async joinGroup(link) {
+    const processed = processJoinLink(link);
+    if (!processed)
+      throw new TypeError("Invalid group link");
+    return await this.join(processed);
+  }
+  async joinChannel(link) {
+    return await this.join(processJoinLink(link) ?? link);
+  }
+  async resolveGroupByLink(link) {
+    const processed = processJoinLink(link);
+    if (!processed)
+      throw new TypeError("Invalid group link");
+    const frame = await this.app.invoke(Opcode.LINK_INFO, { link: processed });
+    return this.optionalChat(payloadItem(frame, "chat"));
+  }
+  async reworkInviteLink(chatId) {
+    const frame = await this.app.invoke(Opcode.CHAT_UPDATE, { revokePrivateLink: true, chatId });
+    const chat = this.optionalChat(payloadItem(frame, "chat"));
+    if (!chat)
+      throw new TsMaxError("Chat not found in response");
+    return chat;
+  }
+  async getChats(chatIds) {
+    const missing = chatIds.filter((id) => !this.cache.has(id));
+    if (missing.length > 0) {
+      const frame = await this.app.invoke(Opcode.CHAT_INFO, { chatIds: missing });
+      for (const raw of listItem(frame, "chats"))
+        this.cacheChat(Chat.fromPayload(raw));
+    }
+    return chatIds.flatMap((id) => {
+      const chat = this.cache.get(id);
+      return chat ? [chat] : [];
+    });
+  }
+  async getChat(chatId) {
+    const chat = (await this.getChats([chatId]))[0];
+    if (!chat)
+      throw new TsMaxError("Chat not found in response");
+    return chat;
+  }
+  async fetchChats(marker = Date.now()) {
+    const frame = await this.app.invoke(Opcode.CHATS_LIST, { marker });
+    return listItem(frame, "chats").map((raw) => this.cacheChat(Chat.fromPayload(raw)));
+  }
+  async leaveGroup(chatId) {
+    await this.app.invoke(Opcode.CHAT_LEAVE, { chatId });
+    this.cache.delete(chatId);
+  }
+  async leaveChannel(chatId) {
+    await this.leaveGroup(chatId);
+  }
+  async deleteChat(chatId, forMe = true, lastEventTime = Date.now()) {
+    await this.app.invoke(Opcode.CHAT_DELETE, { chatId, lastEventTime, forAll: !forMe });
+    this.cache.delete(chatId);
+    return true;
+  }
+  async getJoinRequests(chatId, count = 100) {
+    return listItem(await this.app.invoke(Opcode.CHAT_MEMBERS, { chatId, type: "JOIN_REQUEST", count }), "members").map((item) => asRecord(item));
+  }
+  async confirmJoinRequests(chatId, userIds, showHistory = true) {
+    return await this.memberAction(chatId, userIds, "add", showHistory, "JOIN_REQUEST");
+  }
+  async confirmJoinRequest(chatId, userId, showHistory = true) {
+    return await this.confirmJoinRequests(chatId, [userId], showHistory);
+  }
+  async declineJoinRequests(chatId, userIds) {
+    return await this.memberAction(chatId, userIds, "remove", null, "JOIN_REQUEST");
+  }
+  async declineJoinRequest(chatId, userId) {
+    return await this.declineJoinRequests(chatId, [userId]);
+  }
+  async join(link) {
+    const frame = await this.app.invoke(Opcode.CHAT_JOIN, { link });
+    const chat = this.optionalChat(payloadItem(frame, "chat"));
+    if (!chat)
+      throw new TsMaxError("Chat not found in response");
+    return chat;
+  }
+  async memberAction(chatId, userIds, operation, showHistory, type) {
+    const frame = await this.app.invoke(Opcode.CHAT_MEMBERS_UPDATE, {
+      chatId,
+      userIds,
+      operation,
+      showHistory,
+      ...type ? { type } : {}
+    });
+    return this.optionalChat(payloadItem(frame, "chat"));
+  }
+  optionalChat(raw) {
+    return raw ? this.cacheChat(Chat.fromPayload(raw)) : null;
+  }
+  cacheChat(chat) {
+    const bound = this.app.bindChat(chat);
+    this.cache.set(bound.id, bound);
+    return bound;
+  }
+}
+function processJoinLink(link) {
+  const index = link.indexOf("join/");
+  return index >= 0 ? link.slice(index) : null;
+}
+// src/formatting/markdown.ts
+var markers = new Map([
+  ["```", "CODE"],
+  ["**", "STRONG"],
+  ["__", "UNDERLINE"],
+  ["~~", "STRIKETHROUGH"],
+  ["`", "MONOSPACED"],
+  ["_", "EMPHASIZED"],
+  ["*", "EMPHASIZED"]
+]);
+function formatMarkdown(text) {
+  let clean = "";
+  let index = 0;
+  let cleanPosition = 0;
+  let lineStart = true;
+  const active = new Map;
+  const elements = [];
+  while (index < text.length) {
+    const link = parseLink(text, index);
+    if (link) {
+      const length = utf16Length(link.label);
+      elements.push({ type: "LINK", from: cleanPosition, length, attributes: { url: link.url } });
+      clean += link.label;
+      cleanPosition += length;
+      index = link.next;
+      lineStart = false;
+      continue;
+    }
+    const current = text[index];
+    if (lineStart && (current === "#" || current === ">")) {
+      const result = parseLineEntity(text, index, current === "#" ? "HEADING" : "QUOTE");
+      if (result) {
+        clean += result.value;
+        const length = utf16Length(result.value);
+        elements.push({ type: result.type, from: cleanPosition, length });
+        cleanPosition += length;
+        index = result.next;
+        lineStart = false;
+        continue;
+      }
+    }
+    let handled = false;
+    for (const [marker, type] of markers) {
+      if (!text.startsWith(marker, index))
+        continue;
+      const open = active.get(marker);
+      if (open === undefined) {
+        const closing = text.indexOf(marker, index + marker.length);
+        const newline = text.indexOf(`
+`, index + marker.length);
+        if (closing <= index + marker.length || marker !== "```" && newline !== -1 && closing > newline) {
+          clean += marker;
+          cleanPosition += utf16Length(marker);
+        } else {
+          active.set(marker, cleanPosition);
+        }
+      } else {
+        const length = cleanPosition - open;
+        if (length > 0)
+          elements.push({ type, from: open, length });
+        active.delete(marker);
+      }
+      index += marker.length;
+      handled = true;
+      break;
+    }
+    if (handled) {
+      lineStart = false;
+      continue;
+    }
+    clean += current;
+    cleanPosition += utf16Length(current);
+    index += 1;
+    lineStart = current === `
+`;
+  }
+  return { text: clean, elements };
+}
+function parseLink(text, index) {
+  if (text[index] !== "[")
+    return null;
+  const labelEnd = text.indexOf("]", index + 1);
+  if (labelEnd < 0 || text[labelEnd + 1] !== "(")
+    return null;
+  const urlEnd = text.indexOf(")", labelEnd + 2);
+  if (urlEnd < 0)
+    return null;
+  const label = text.slice(index + 1, labelEnd);
+  const url = text.slice(labelEnd + 2, urlEnd);
+  return label && url ? { label, url, next: urlEnd + 1 } : null;
+}
+function parseLineEntity(text, index, type) {
+  let contentStart = index + 1;
+  if (type === "HEADING") {
+    while (text[contentStart] === "#")
+      contentStart += 1;
+    if (text[contentStart] !== " ")
+      return null;
+  }
+  if (text[contentStart] === " ")
+    contentStart += 1;
+  const newline = text.indexOf(`
+`, contentStart);
+  const next = newline < 0 ? text.length : newline;
+  const value = text.slice(contentStart, next);
+  return value ? { type, value, next } : null;
+}
+function utf16Length(value) {
+  return value.length;
+}
+// src/api/messages.ts
+class MessageApi {
+  app;
+  uploads;
+  previousCid = Date.now();
+  constructor(app, uploads) {
+    this.app = app;
+    this.uploads = uploads;
+  }
+  async sendMessage(options) {
+    const formatted = formatMarkdown(options.text);
+    const attaches = await this.uploadAttachments(options.attachments);
+    const link = options.replyTo ? { type: "REPLY", messageId: options.replyTo } : undefined;
+    const frame = await this.app.invoke(Opcode.MSG_SEND, {
+      chatId: options.chatId,
+      message: {
+        text: formatted.text,
+        cid: this.nextCid(),
+        elements: formatted.elements,
+        attaches,
+        ...link ? { link } : {}
+      },
+      notify: options.notify ?? true
+    });
+    return this.parseMessage(payload(frame));
+  }
+  async forwardMessage(options) {
+    const frame = await this.app.invoke(Opcode.MSG_SEND, {
+      chatId: options.chatId,
+      message: {
+        cid: -this.nextCid(),
+        link: {
+          type: "FORWARD",
+          messageId: options.messageId.toString(),
+          chatId: options.sourceChatId ?? options.chatId
+        },
+        attaches: []
+      },
+      notify: options.notify ?? true
+    });
+    return this.parseMessage(payload(frame));
+  }
+  async getMessages(chatId, messageIds) {
+    const frame = await this.app.invoke(Opcode.MSG_GET, { chatId, messageIds });
+    return listItem(frame, "messages").map((item) => {
+      const message = this.app.bindMessage(Message.fromPayload(item));
+      message.chatId ??= chatId;
+      return message;
+    });
+  }
+  async getMessage(chatId, messageId) {
+    return (await this.getMessages(chatId, [messageId]))[0] ?? null;
+  }
+  async editMessage(options) {
+    const formatted = formatMarkdown(options.text);
+    const frame = await this.app.invoke(Opcode.MSG_EDIT, {
+      chatId: options.chatId,
+      messageId: options.messageId,
+      text: formatted.text,
+      elements: formatted.elements,
+      attachments: await this.uploadAttachments(options.attachments)
+    });
+    const message = this.app.bindMessage(Message.fromPayload(requiredItem(frame, "message")));
+    message.chatId ??= options.chatId;
+    return message;
+  }
+  async fetchHistory(options) {
+    const frame = await this.app.invoke(Opcode.CHAT_HISTORY, {
+      chatId: options.chatId,
+      forward: options.forward ?? 0,
+      backward: options.backward ?? 40,
+      backwardTime: options.backwardTime ?? 0,
+      forwardTime: options.forwardTime ?? 0,
+      from: options.from ?? Date.now(),
+      itemType: options.itemType ?? "REGULAR",
+      getChat: options.getChat ?? false,
+      getMessages: options.getMessages ?? true,
+      interactive: options.interactive ?? false
+    });
+    const result = listItem(frame, "messages").map((item) => this.app.bindMessage(Message.fromPayload(item)));
+    return result.length > 0 ? result : null;
+  }
+  async deleteMessage(options) {
+    await this.app.invoke(Opcode.MSG_DELETE, options);
+    return true;
+  }
+  async pinMessage(options) {
+    await this.app.invoke(Opcode.CHAT_UPDATE, {
+      chatId: options.chatId,
+      notifyPin: options.notifyPin,
+      pinMessageId: options.messageId
+    });
+    return true;
+  }
+  async readMessage(messageId, chatId) {
+    const frame = await this.app.invoke(Opcode.CHAT_MARK, {
+      type: "READ_MESSAGE",
+      chatId,
+      messageId,
+      mark: Date.now()
+    });
+    return parseReadState(payload(frame));
+  }
+  async addReaction(chatId, messageId, reaction) {
+    const frame = await this.app.invoke(Opcode.MSG_REACTION, {
+      chatId,
+      messageId: messageId.toString(),
+      reaction: { id: reaction }
+    });
+    return parseReactionInfo(payloadItem(frame, "reactionInfo"));
+  }
+  async removeReaction(chatId, messageId) {
+    const frame = await this.app.invoke(Opcode.MSG_CANCEL_REACTION, {
+      chatId,
+      messageId: messageId.toString()
+    });
+    return parseReactionInfo(payloadItem(frame, "reactionInfo"));
+  }
+  async getReactions(chatId, messageIds) {
+    const frame = await this.app.invoke(Opcode.MSG_GET_REACTIONS, {
+      chatId,
+      messageIds: messageIds.map(String)
+    });
+    const raw = payloadItem(frame, "messagesReactions");
+    if (!raw)
+      return null;
+    const result = new Map;
+    for (const [id, info] of Object.entries(asRecord(raw))) {
+      const parsed = parseReactionInfo(info);
+      if (parsed)
+        result.set(toMaxId(id), parsed);
+    }
+    return result;
+  }
+  async getVideoById(chatId, messageId, videoId) {
+    const frame = await this.app.invoke(Opcode.VIDEO_PLAY, {
+      chatId,
+      messageId: messageId.toString(),
+      videoId
+    });
+    return frame.payload;
+  }
+  async getFileById(chatId, messageId, fileId) {
+    const frame = await this.app.invoke(Opcode.FILE_DOWNLOAD, {
+      chatId,
+      messageId: messageId.toString(),
+      fileId
+    });
+    return frame.payload;
+  }
+  nextCid() {
+    const next = Math.max(Date.now(), this.previousCid + 1);
+    this.previousCid = next;
+    return BigInt(next);
+  }
+  async uploadAttachments(attachments2) {
+    const result = [];
+    for (const attachment of attachments2 ?? [])
+      result.push(await this.uploads.upload(attachment));
+    return result;
+  }
+  parseMessage(value) {
+    if (!value)
+      return null;
+    const data = asRecord(value);
+    const candidate = data.message ?? value;
+    return this.app.bindMessage(Message.fromPayload(candidate));
+  }
+}
+
+// src/api/uploads.ts
+class UploadApi {
+  app;
+  constructor(app) {
+    this.app = app;
+  }
+  async upload(attachment) {
+    if (attachment instanceof Photo)
+      return await this.uploadPhoto(attachment);
+    if (attachment instanceof Video)
+      return await this.uploadVideo(attachment);
+    if (attachment instanceof File)
+      return await this.uploadFile(attachment);
+    throw new UploadError("Unsupported attachment");
+  }
+  async uploadPhoto(photo, profile = false) {
+    const response = payload(await this.app.invoke(Opcode.PHOTO_UPLOAD, { count: 1, profile }));
+    const url = asString(response.url);
+    if (!url)
+      throw new UploadError("No photo upload URL received");
+    const photoId = new URL(url).searchParams.get("photoIds");
+    if (!photoId)
+      throw new UploadError("Photo upload URL has no photoIds");
+    const form = new FormData;
+    const bytes = await photo.read();
+    form.append("file", new Blob([bytes], { type: photo.format.mimeType }), `image.${photo.format.extension}`);
+    const upload = await fetch(url, { method: "POST", body: form });
+    if (!upload.ok)
+      throw new UploadError(`Photo upload failed with status ${upload.status}`);
+    const result = asRecord(await upload.json(), "photo upload response");
+    const photos = asRecord(result.photos, "photos");
+    const item = asRecord(photos[photoId], "photo result");
+    const token = asString(item.token);
+    if (!token)
+      throw new UploadError("Photo upload response has no token");
+    return { _type: "PHOTO", photoToken: token };
+  }
+  async uploadVideo(video) {
+    const response = payload(await this.app.invoke(Opcode.VIDEO_UPLOAD, { count: 1, profile: false }));
+    const info = asRecord(asArray(response.info)[0], "video upload info");
+    const videoId = asNumber(info.videoId);
+    const token = asString(info.token);
+    const waiter = this.app.createAttachmentWaiter?.("videoId", videoId, 60);
+    try {
+      await this.postBinary(asString(info.url), video, true);
+      await waiter?.promise;
+      return { _type: "VIDEO", videoId, token };
+    } finally {
+      waiter?.cancel();
+    }
+  }
+  async uploadFile(file2) {
+    const response = payload(await this.app.invoke(Opcode.FILE_UPLOAD, { count: 1, profile: false }));
+    const info = asRecord(asArray(response.info)[0], "file upload info");
+    const fileId = asNumber(info.fileId);
+    const waiter = this.app.createAttachmentWaiter?.("fileId", fileId, 60);
+    try {
+      await this.postBinary(asString(info.url), file2, false);
+      await waiter?.promise;
+      return { _type: "FILE", fileId };
+    } finally {
+      waiter?.cancel();
+    }
+  }
+  async postBinary(url, file2, contentRange) {
+    if (!url)
+      throw new UploadError("No upload URL received");
+    const bytes = await file2.read();
+    const headers = {
+      "Content-Disposition": `attachment; filename=${encodeURIComponent(file2.name)}`,
+      "Content-Length": String(bytes.byteLength)
+    };
+    if (contentRange || bytes.byteLength > 0)
+      headers["Content-Range"] = `0-${bytes.byteLength - 1}/${bytes.byteLength}`;
+    const response = await fetch(url, { method: "POST", headers, body: bytes });
+    if (!response.ok)
+      throw new UploadError(`Upload failed with status ${response.status}`);
+  }
+}
+
+// src/api/users.ts
+class UserApi {
+  app;
+  cache = new Map;
+  constructor(app) {
+    this.app = app;
+  }
+  seed(users) {
+    for (const user of users)
+      if (user)
+        this.cacheUser(user);
+  }
+  getCachedUser(userId) {
+    return this.cache.get(userId) ?? null;
+  }
+  async getUsers(userIds) {
+    const missing = userIds.filter((id) => !this.cache.has(id));
+    if (missing.length > 0)
+      for (const user of await this.fetchUsers(missing))
+        this.cache.set(user.id, user);
+    return userIds.flatMap((id) => this.cache.has(id) ? [this.cache.get(id)] : []);
+  }
+  async getUser(userId) {
+    return (await this.getUsers([userId]))[0] ?? null;
+  }
+  async fetchUsers(userIds) {
+    const frame = await this.app.invoke(Opcode.CONTACT_INFO, { contactIds: userIds });
+    return listItem(frame, "contacts").map((raw) => this.cacheUser(User.fromPayload(raw)));
+  }
+  async searchByPhone(phone) {
+    const frame = await this.app.invoke(Opcode.CONTACT_INFO_BY_PHONE, { phone });
+    return this.cacheUser(User.fromPayload(requiredItem(frame, "contact")));
+  }
+  async getSessions() {
+    return listItem(await this.app.invoke(Opcode.SESSIONS_INFO, {}), "sessions").map((item) => asRecord(item));
+  }
+  async addContact(contactId) {
+    const frame = await this.app.invoke(Opcode.CONTACT_UPDATE, { contactId, action: "add" });
+    return this.cacheUser(User.fromPayload(requiredItem(frame, "contact")));
+  }
+  async removeContact(contactId) {
+    await this.app.invoke(Opcode.CONTACT_UPDATE, { contactId, action: "remove" });
+    this.cache.delete(contactId);
+    return true;
+  }
+  async importContacts(contacts) {
+    const contactList = Object.fromEntries(contacts.map((item) => [item.phone, { firstName: item.firstName }]));
+    const frame = await this.app.invoke(Opcode.SYNC, { contactList });
+    return listItem(frame, "contacts").map((raw) => this.cacheUser(User.fromPayload(raw)));
+  }
+  getChatId(firstUserId, secondUserId) {
+    return firstUserId ^ secondUserId;
+  }
+  cacheUser(user) {
+    const bound = this.app.bindUser(user);
+    this.cache.set(bound.id, bound);
+    return bound;
+  }
+}
+
+// src/api/facade.ts
+class ApiFacade {
+  auth;
+  uploads;
+  messages;
+  chats;
+  users;
+  account;
+  bots;
+  constructor(app) {
+    this.auth = new AuthApi(app);
+    this.uploads = new UploadApi(app);
+    this.messages = new MessageApi(app, this.uploads);
+    this.chats = new ChatApi(app);
+    this.users = new UserApi(app);
+    this.account = new AccountApi(app, this.uploads);
+    this.bots = new BotsApi(app);
+  }
+}
+// src/dispatch/router.ts
+var EventType = {
+  MESSAGE_NEW: "messageNew",
+  MESSAGE_EDIT: "messageEdit",
+  MESSAGE_DELETE: "messageDelete",
+  MESSAGE_READ: "messageRead",
+  TYPING: "typing",
+  PRESENCE: "presence",
+  REACTION_UPDATE: "reactionUpdate",
+  CHAT_UPDATE: "chatUpdate",
+  RAW: "raw"
+};
+
+class Router {
+  children = [];
+  handlers = new Map;
+  startHandlers = [];
+  errorHandlers = [];
+  disconnectHandlers = [];
+  includeRouter(router) {
+    this.children.push(router);
+    return () => {
+      const index = this.children.indexOf(router);
+      if (index >= 0)
+        this.children.splice(index, 1);
+    };
+  }
+  on(event, handler, ...filters) {
+    const entry = { handler, filters };
+    const entries = this.handlers.get(event) ?? [];
+    entries.push(entry);
+    this.handlers.set(event, entries);
+    return () => {
+      const index = entries.indexOf(entry);
+      if (index >= 0)
+        entries.splice(index, 1);
+    };
+  }
+  onStart(handler) {
+    this.startHandlers.push(handler);
+    return () => remove(this.startHandlers, handler);
+  }
+  onError(handler) {
+    this.errorHandlers.push(handler);
+    return () => remove(this.errorHandlers, handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+    return () => remove(this.disconnectHandlers, handler);
+  }
+  onMessage(handler, ...filters) {
+    return this.on("messageNew", handler, ...filters);
+  }
+  onMessageEdit(handler, ...filters) {
+    return this.on("messageEdit", handler, ...filters);
+  }
+  onMessageDelete(handler, ...filters) {
+    return this.on("messageDelete", handler, ...filters);
+  }
+  onMessageRead(handler, ...filters) {
+    return this.on("messageRead", handler, ...filters);
+  }
+  onTyping(handler, ...filters) {
+    return this.on("typing", handler, ...filters);
+  }
+  onPresence(handler, ...filters) {
+    return this.on("presence", handler, ...filters);
+  }
+  onReactionUpdate(handler, ...filters) {
+    return this.on("reactionUpdate", handler, ...filters);
+  }
+  onChatUpdate(handler, ...filters) {
+    return this.on("chatUpdate", handler, ...filters);
+  }
+  onRaw(handler, ...filters) {
+    return this.on("raw", handler, ...filters);
+  }
+}
+function remove(values, value) {
+  const index = values.indexOf(value);
+  if (index >= 0)
+    values.splice(index, 1);
+}
+
+// src/dispatch/dispatcher.ts
+class Dispatcher {
+  rootRouter;
+  client = null;
+  constructor(rootRouter) {
+    this.rootRouter = rootRouter;
+  }
+  bindClient(client) {
+    this.client = client;
+  }
+  async emitStart() {
+    const client = this.requireClient();
+    for (const router of this.routers()) {
+      for (const handler of router.startHandlers) {
+        try {
+          await handler(client);
+        } catch (error) {
+          await this.emitError(error, "start", null, router);
+        }
+      }
+    }
+  }
+  async emitDisconnect(error, reconnect, delay) {
+    for (const router of this.routers()) {
+      for (const handler of router.disconnectHandlers) {
+        try {
+          await handler(error, reconnect, delay);
+        } catch {}
+      }
+    }
+  }
+  async dispatch(frame) {
+    await this.dispatchEvent("raw", frame);
+    if (frame.cmd !== Command.REQUEST || !frame.payload)
+      return;
+    const resolved = resolveEvent(frame);
+    if (resolved)
+      await this.dispatchEvent(resolved.type, resolved.event);
+  }
+  async dispatchEvent(type, event) {
+    const client = this.requireClient();
+    for (const router of this.routers()) {
+      const entries = router.handlers.get(type) ?? [];
+      for (const rawEntry of entries) {
+        const entry = rawEntry;
+        try {
+          let matches = true;
+          for (const filter of entry.filters) {
+            if (!await filter(event)) {
+              matches = false;
+              break;
+            }
+          }
+          if (matches)
+            await entry.handler(event, client);
+        } catch (error) {
+          await this.emitError(error, type, event, router);
+        }
+      }
+    }
+  }
+  async emitError(error, eventType, event, source) {
+    const failure = error instanceof Error ? error : new Error(String(error));
+    const client = this.requireClient();
+    let handled = false;
+    for (const router of this.routers()) {
+      for (const handler of router.errorHandlers) {
+        handled = true;
+        await handler(failure, { client, eventType, event, router: source });
+      }
+    }
+    if (!handled)
+      throw failure;
+  }
+  *routers(router = this.rootRouter) {
+    yield router;
+    for (const child of router.children)
+      yield* this.routers(child);
+  }
+  requireClient() {
+    if (!this.client)
+      throw new Error("Dispatcher has no bound client");
+    return this.client;
+  }
+}
+function resolveEvent(frame) {
+  const payload2 = frame.payload;
+  if (frame.opcode === Opcode.NOTIF_MESSAGE || frame.opcode === Opcode.MSG_EDIT) {
+    const messagePayload = payload2.message ?? payload2;
+    const message = Message.fromPayload(messagePayload);
+    if (message.status === "REMOVED")
+      return { type: EventType.MESSAGE_DELETE, event: deleteFromMessage(message, payload2) };
+    return {
+      type: message.status === "EDITED" ? EventType.MESSAGE_EDIT : EventType.MESSAGE_NEW,
+      event: message
+    };
+  }
+  if (frame.opcode === Opcode.NOTIF_CHAT) {
+    return { type: EventType.CHAT_UPDATE, event: Chat.fromPayload(payload2.chat ?? payload2) };
+  }
+  if (frame.opcode === Opcode.NOTIF_MSG_DELETE) {
+    const chat = payload2.chat ? asRecord(payload2.chat) : null;
+    const event = {
+      chatId: toMaxId(payload2.chatId ?? chat?.id, "delete.chatId"),
+      messageIds: asArray(payload2.messageIds).map((id) => toMaxId(id)),
+      chat: chat ? Chat.fromPayload(chat) : null,
+      ttl: asBoolean(payload2.ttl)
+    };
+    return { type: EventType.MESSAGE_DELETE, event };
+  }
+  if (frame.opcode === Opcode.NOTIF_TYPING) {
+    const event = {
+      chatId: toMaxId(payload2.chatId),
+      userId: toMaxId(payload2.userId),
+      typing: asBoolean(payload2.typing, true)
+    };
+    return { type: EventType.TYPING, event };
+  }
+  if (frame.opcode === Opcode.NOTIF_MARK) {
+    const event = {
+      chatId: toMaxId(payload2.chatId),
+      userId: optionalMaxId(payload2.userId),
+      mark: asNumber(payload2.mark)
+    };
+    return { type: EventType.MESSAGE_READ, event };
+  }
+  if (frame.opcode === Opcode.NOTIF_PRESENCE) {
+    const presence = payload2.presence ? asRecord(payload2.presence) : payload2;
+    const event = {
+      userId: toMaxId(payload2.userId),
+      online: asBoolean(presence.online ?? presence.status === "ONLINE"),
+      lastSeen: presence.lastSeen === undefined ? null : asNumber(presence.lastSeen),
+      raw: presence
+    };
+    return { type: EventType.PRESENCE, event };
+  }
+  if (frame.opcode === Opcode.NOTIF_MSG_REACTIONS_CHANGED) {
+    const event = {
+      chatId: toMaxId(payload2.chatId),
+      messageId: toMaxId(payload2.messageId),
+      reactionInfo: parseReactionInfo({
+        totalCount: payload2.totalCount,
+        counters: payload2.counters,
+        yourReaction: payload2.yourReaction
+      })
+    };
+    return { type: EventType.REACTION_UPDATE, event };
+  }
+  return null;
+}
+function deleteFromMessage(message, payload2) {
+  if (message.chatId === null)
+    throw new TypeError("Removed message has no chatId");
+  return {
+    chatId: message.chatId,
+    messageIds: [message.id],
+    message,
+    ttl: asBoolean(payload2.ttl)
+  };
+}
+// src/app.ts
+class App {
+  connection;
+  config;
+  authFlow;
+  dispatcher;
+  api;
+  telemetry;
+  store;
+  session = null;
+  me = null;
+  chats = [];
+  contacts = [];
+  messages = new Map;
+  started = false;
+  pingController = null;
+  attachmentWaiters = new Map;
+  constructor(connection, config, authFlow, rootRouter) {
+    this.connection = connection;
+    this.config = config;
+    this.authFlow = authFlow;
+    this.dispatcher = new Dispatcher(rootRouter);
+    this.store = config.store ?? new SqliteSessionStore(config.workDir, config.sessionName);
+    this.api = new ApiFacade(this);
+    this.telemetry = new TelemetryService(this);
+    this.connection.onEvent = async (frame) => {
+      this.resolveAttachmentWaiters(frame);
+      await this.dispatcher.dispatch(frame);
+    };
+    this.connection.onClose = (error) => this.connectionLost(error);
+  }
+  bindClient(client) {
+    this.dispatcher.bindClient(client);
+  }
+  async start() {
+    if (this.started)
+      return;
+    let saved = await this.store.loadSession();
+    if (saved?.mtInstanceId)
+      this.config.device.mtInstanceId = saved.mtInstanceId;
+    await this.connection.open();
+    await this.api.auth.handshake(saved?.deviceId ?? this.config.device.deviceId);
+    this.startPing();
+    if (!saved) {
+      const token = this.config.token ?? (await this.authFlow.authenticate(this)).token;
+      if (!token)
+        throw new Error("Authentication failed: no token returned");
+      saved = {
+        token,
+        deviceId: this.config.device.deviceId,
+        phone: this.config.phone ?? "",
+        mtInstanceId: this.config.device.mtInstanceId,
+        sync: defaultSyncState()
+      };
+      await this.store.saveSession(saved);
+    }
+    this.session = saved;
+    const login = await this.api.auth.login();
+    let activeSession = this.session ?? saved;
+    if (login.token && login.token !== activeSession.token) {
+      await this.store.updateToken(activeSession.token, login.token);
+      activeSession = { ...activeSession, token: login.token };
+    }
+    this.session = activeSession;
+    this.me = login.profile;
+    this.chats = login.chats;
+    this.contacts = login.contacts;
+    this.messages = login.messages;
+    this.api.chats.seed(this.chats);
+    this.api.users.seed([...this.contacts, this.me.contact]);
+    this.bindUser(this.me.contact);
+    this.started = true;
+    if (this.config.telemetry)
+      this.telemetry.start();
+    getLogger().info("client started", {
+      profileId: this.me.contact.id.toString(),
+      chats: this.chats.length
+    });
+  }
+  async close() {
+    this.pingController?.abort();
+    this.pingController = null;
+    await this.telemetry.stop();
+    for (const entries of this.attachmentWaiters.values()) {
+      for (const entry of entries)
+        entry.reject(new Error("Client closed before upload processing completed"));
+    }
+    this.attachmentWaiters.clear();
+    await this.connection.close();
+    await this.store.close();
+    this.started = false;
+  }
+  async invoke(opcode, payload2 = {}, timeout) {
+    const frame = {
+      ver: this.connection.protocol.version,
+      opcode,
+      cmd: Command.REQUEST,
+      seq: this.connection.nextSequence(),
+      payload: payload2
+    };
+    const response = await this.connection.request(frame, timeout ?? this.config.requestTimeout);
+    if (response.cmd === Command.ERROR)
+      throw buildApiError(response);
+    return response;
+  }
+  bindMessage(message) {
+    return message.bind(this.api.messages);
+  }
+  bindChat(chat) {
+    return chat.bind(this.api.messages, this.api.chats);
+  }
+  bindUser(user) {
+    return user.bind(this.api.users);
+  }
+  createAttachmentWaiter(field, id, timeoutSeconds = 60) {
+    const key = `${field}:${id}`;
+    const entries = this.attachmentWaiters.get(key) ?? new Set;
+    let active = true;
+    let resolvePromise = () => {
+      return;
+    };
+    let rejectPromise = () => {
+      return;
+    };
+    const promise = new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    const entry = {
+      resolve: () => {
+        if (!active)
+          return;
+        active = false;
+        clearTimeout(timer);
+        entries.delete(entry);
+        resolvePromise();
+      },
+      reject: (error) => {
+        if (!active)
+          return;
+        active = false;
+        clearTimeout(timer);
+        entries.delete(entry);
+        rejectPromise(error);
+      }
+    };
+    entries.add(entry);
+    this.attachmentWaiters.set(key, entries);
+    const timer = setTimeout(() => entry.reject(new Error(`Timed out waiting for ${field}=${id} processing`)), timeoutSeconds * 1000);
+    return {
+      promise,
+      cancel: () => {
+        if (!active)
+          return;
+        active = false;
+        clearTimeout(timer);
+        entries.delete(entry);
+        if (entries.size === 0)
+          this.attachmentWaiters.delete(key);
+        promise.catch(() => {
+          return;
+        });
+      }
+    };
+  }
+  startPing() {
+    const controller = new AbortController;
+    this.pingController = controller;
+    this.pingLoop(controller.signal);
+  }
+  async pingLoop(signal) {
+    try {
+      while (!signal.aborted) {
+        await this.invoke(Opcode.PING, { interactive: true });
+        await sleep2(30000, signal);
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        getLogger().warn("ping failed", { error: String(error) });
+        await this.connection.close();
+      }
+    }
+  }
+  connectionLost(error) {
+    this.started = false;
+    this.pingController?.abort();
+    if (error)
+      getLogger().warn("connection lost", { error: error.message });
+  }
+  resolveAttachmentWaiters(frame) {
+    if (frame.opcode !== Opcode.NOTIF_ATTACH || !frame.payload)
+      return;
+    for (const field of ["fileId", "videoId"]) {
+      const value = frame.payload[field];
+      if (typeof value !== "number" || !Number.isSafeInteger(value))
+        continue;
+      const key = `${field}:${value}`;
+      const entries = this.attachmentWaiters.get(key);
+      if (!entries)
+        continue;
+      this.attachmentWaiters.delete(key);
+      for (const entry of entries)
+        entry.resolve();
+    }
+  }
+}
+function buildApiError(frame) {
+  const data = frame.payload ?? {};
+  return new ApiError(frame.opcode, {
+    error: typeof data.error === "string" ? data.error : null,
+    title: typeof data.title === "string" ? data.title : null,
+    message: typeof data.message === "string" ? data.message : null,
+    localizedMessage: typeof data.localizedMessage === "string" ? data.localizedMessage : null,
+    payload: data
+  });
+}
+async function sleep2(milliseconds, signal) {
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, milliseconds);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    }, { once: true });
+  });
+}
+
+// src/connection/pending.ts
+class PendingRequests {
+  requests = new Map;
+  create(sequence, timeoutSeconds) {
+    if (this.requests.has(sequence))
+      throw new Error(`Duplicate request sequence: ${sequence}`);
+    return new Promise((resolve, reject) => {
+      const request = { resolve, reject, timer: null };
+      if (timeoutSeconds !== undefined) {
+        request.timer = setTimeout(() => {
+          this.requests.delete(sequence);
+          reject(new TimeoutError(`Request ${sequence} timed out`));
+        }, timeoutSeconds * 1000);
+      }
+      this.requests.set(sequence, request);
+    });
+  }
+  resolve(sequence, frame) {
+    const request = this.requests.get(sequence);
+    if (!request)
+      return false;
+    this.requests.delete(sequence);
+    if (request.timer)
+      clearTimeout(request.timer);
+    request.resolve(frame);
+    return true;
+  }
+  discard(sequence) {
+    const request = this.requests.get(sequence);
+    if (request?.timer)
+      clearTimeout(request.timer);
+    this.requests.delete(sequence);
+  }
+  cancelAll(reason = new ConnectionError("Connection closed")) {
+    for (const request of this.requests.values()) {
+      if (request.timer)
+        clearTimeout(request.timer);
+      request.reject(reason);
+    }
+    this.requests.clear();
+  }
+}
+
+// src/connection/connection.ts
+class ConnectionManager {
+  reader;
+  transport;
+  protocol;
+  requests = new PendingRequests;
+  onEvent = null;
+  onClose = null;
+  sequence = -1;
+  receiveTask = null;
+  abortController = null;
+  constructor(reader, transport, protocol) {
+    this.reader = reader;
+    this.transport = transport;
+    this.protocol = protocol;
+  }
+  get isOpen() {
+    return this.transport.connected;
+  }
+  async open() {
+    if (this.isOpen)
+      return;
+    await this.transport.connect();
+    this.abortController = new AbortController;
+    this.receiveTask = this.receiveLoop(this.abortController.signal);
+  }
+  async close() {
+    this.abortController?.abort();
+    this.abortController = null;
+    this.requests.cancelAll();
+    await this.transport.close();
+    try {
+      await this.receiveTask;
+    } catch {}
+    this.receiveTask = null;
+  }
+  async send(frame) {
+    if (!this.isOpen)
+      throw new ConnectionError("Connection is not open");
+    await this.transport.send(this.protocol.encode(frame));
+  }
+  async request(frame, timeoutSeconds) {
+    const response = this.requests.create(frame.seq, timeoutSeconds);
+    try {
+      await this.send(frame);
+      return await response;
+    } catch (error) {
+      this.requests.discard(frame.seq);
+      throw error;
+    }
+  }
+  async waitClosed() {
+    await this.receiveTask;
+  }
+  nextSequence() {
+    this.sequence = this.sequence + 1 & 65535;
+    return this.sequence;
+  }
+  async receiveLoop(signal) {
+    try {
+      while (!signal.aborted) {
+        const raw = await this.reader.read();
+        const frame = this.protocol.decode(raw);
+        if ((frame.cmd === Command.RESPONSE || frame.cmd === Command.ERROR) && frame.seq !== null) {
+          this.requests.resolve(frame.seq, frame);
+        }
+        if (this.onEvent)
+          Promise.resolve(this.onEvent(frame));
+      }
+    } catch (error) {
+      if (signal.aborted)
+        return;
+      const failure = error instanceof Error ? error : new ConnectionError(String(error));
+      this.requests.cancelAll(failure);
+      this.onClose?.(failure);
+      throw failure;
+    }
+  }
+}
+// src/connection/readers.ts
+class TcpReader {
+  transport;
+  framer;
+  constructor(transport, framer = new TcpPacketFramer) {
+    this.transport = transport;
+    this.framer = framer;
+  }
+  async read() {
+    const header = await this.transport.recv(TCP_HEADER_SIZE);
+    const payloadLength = this.framer.unpackPayloadLength(header);
+    if (payloadLength === null)
+      throw new ConnectionError("Incomplete TCP header");
+    if (payloadLength === 0)
+      return header;
+    const payload2 = await this.transport.recv(payloadLength);
+    const result = new Uint8Array(header.byteLength + payload2.byteLength);
+    result.set(header);
+    result.set(payload2, header.byteLength);
+    return result;
+  }
+}
+
+class WsReader {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async read() {
+    return await this.transport.recv();
+  }
+}
+// src/transport/base.ts
+class AsyncQueue {
+  values = [];
+  waiters = [];
+  failure = null;
+  push(value) {
+    const waiter = this.waiters.shift();
+    if (waiter)
+      waiter.resolve(value);
+    else
+      this.values.push(value);
+  }
+  async shift() {
+    const value = this.values.shift();
+    if (value !== undefined)
+      return value;
+    if (this.failure)
+      throw this.failure;
+    return await new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+  }
+  fail(reason) {
+    this.failure = reason;
+    for (const waiter of this.waiters.splice(0))
+      waiter.reject(reason);
+  }
+  clear() {
+    this.values.length = 0;
+  }
+  reset() {
+    this.clear();
+    this.failure = null;
+  }
+}
+// src/transport/tcp.ts
+var defaultConnector = async (options) => await Bun.connect(options);
+
+class TcpTransport {
+  host;
+  port;
+  useTls;
+  proxy;
+  connector;
+  socket = null;
+  chunks = new AsyncQueue;
+  buffered = new Uint8Array;
+  constructor(host, port, useTls = true, proxy = null, connector = defaultConnector) {
+    this.host = host;
+    this.port = port;
+    this.useTls = useTls;
+    this.proxy = proxy;
+    this.connector = connector;
+  }
+  get connected() {
+    return this.socket !== null && this.socket.readyState === 1;
+  }
+  async connect() {
+    if (this.socket)
+      return;
+    this.chunks.reset();
+    const endpoint = this.proxy ? new URL(this.proxy) : null;
+    let resolveOpen = () => {
+      return;
+    };
+    let rejectOpen = () => {
+      return;
+    };
+    let opened = false;
+    const open = new Promise((resolve, reject) => {
+      resolveOpen = resolve;
+      rejectOpen = reject;
+    });
+    const handlers = this.handlers();
+    try {
+      this.socket = await this.connector({
+        hostname: endpoint?.hostname ?? this.host,
+        port: endpoint ? Number(endpoint.port || defaultProxyPort(endpoint.protocol)) : this.port,
+        tls: endpoint?.protocol === "https:" ? { serverName: endpoint.hostname } : !endpoint && this.useTls ? { serverName: this.host } : false,
+        socket: {
+          ...handlers,
+          open: () => {
+            opened = true;
+            resolveOpen();
+          },
+          close: (socket, error) => {
+            handlers.close?.(socket, error);
+            if (!opened)
+              rejectOpen(error ?? new ConnectionError("Connection closed while opening"));
+          },
+          error: (socket, error) => {
+            handlers.error?.(socket, error);
+            if (!opened)
+              rejectOpen(error);
+          },
+          connectError: (socket, error) => {
+            handlers.connectError?.(socket, error);
+            if (!opened)
+              rejectOpen(error);
+          },
+          timeout: (socket) => {
+            handlers.timeout?.(socket);
+            if (!opened)
+              rejectOpen(new ConnectionError("Connection timed out while opening"));
+          }
+        }
+      });
+      await open;
+    } catch (error) {
+      this.socket = null;
+      throw error;
+    }
+    if (endpoint) {
+      await this.openTunnel(endpoint);
+      if (this.useTls)
+        await this.upgradeTls();
+    }
+  }
+  async close() {
+    this.socket?.end();
+    this.socket = null;
+    this.buffered = new Uint8Array;
+    this.chunks.reset();
+  }
+  async send(data) {
+    if (!this.socket || !this.connected)
+      throw new ConnectionError("Transport is not connected");
+    await this.sendRaw(data);
+  }
+  async recv(length) {
+    if (!this.connected)
+      throw new ConnectionError("Transport is not connected");
+    if (length === undefined)
+      return await this.chunks.shift();
+    while (this.buffered.byteLength < length) {
+      this.buffered = concatBytes(this.buffered, await this.chunks.shift());
+    }
+    const result = this.buffered.slice(0, length);
+    this.buffered = this.buffered.slice(length);
+    return result;
+  }
+  handlers() {
+    return {
+      data: (_socket, data) => this.chunks.push(Uint8Array.from(data)),
+      close: (_socket, error) => {
+        this.socket = null;
+        this.chunks.fail(error ?? new ConnectionError("Connection closed"));
+      },
+      end: () => this.chunks.fail(new ConnectionError("Connection closed by server")),
+      error: (_socket, error) => this.chunks.fail(error),
+      connectError: (_socket, error) => this.chunks.fail(error),
+      timeout: () => this.chunks.fail(new ConnectionError("Connection timed out"))
+    };
+  }
+  async openTunnel(proxy) {
+    if (proxy.protocol === "http:" || proxy.protocol === "https:") {
+      await this.httpConnect(proxy);
+      return;
+    }
+    if (proxy.protocol === "socks5:" || proxy.protocol === "socks5h:") {
+      await this.socks5Connect(proxy);
+      return;
+    }
+    if (proxy.protocol === "socks4:" || proxy.protocol === "socks4a:") {
+      await this.socks4Connect(proxy);
+      return;
+    }
+    throw new TypeError(`Unsupported proxy protocol: ${proxy.protocol}`);
+  }
+  async httpConnect(proxy) {
+    const headers = [
+      `CONNECT ${this.host}:${this.port} HTTP/1.1`,
+      `Host: ${this.host}:${this.port}`
+    ];
+    if (proxy.username || proxy.password) {
+      headers.push(`Proxy-Authorization: Basic ${Buffer.from(`${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`).toString("base64")}`);
+    }
+    await this.sendRaw(new TextEncoder().encode(`${headers.join(`\r
+`)}\r
+\r
+`));
+    const response = new TextDecoder().decode(await this.readUntil(Uint8Array.from([13, 10, 13, 10])));
+    const status = Number(/^HTTP\/\d(?:\.\d)?\s+(\d{3})/.exec(response)?.[1]);
+    if (status !== 200)
+      throw new ConnectionError(`HTTP proxy CONNECT failed with status ${status || "unknown"}`);
+  }
+  async socks5Connect(proxy) {
+    const authenticated = Boolean(proxy.username || proxy.password);
+    await this.sendRaw(Uint8Array.from(authenticated ? [5, 2, 0, 2] : [5, 1, 0]));
+    const greeting = await this.recv(2);
+    if (greeting[0] !== 5 || greeting[1] === 255)
+      throw new ConnectionError("SOCKS5 negotiation failed");
+    if (greeting[1] === 2) {
+      const username = new TextEncoder().encode(decodeURIComponent(proxy.username));
+      const password = new TextEncoder().encode(decodeURIComponent(proxy.password));
+      if (username.length > 255 || password.length > 255)
+        throw new TypeError("SOCKS5 credentials are too long");
+      await this.sendRaw(Uint8Array.from([1, username.length, ...username, password.length, ...password]));
+      const auth2 = await this.recv(2);
+      if (auth2[1] !== 0)
+        throw new ConnectionError("SOCKS5 authentication failed");
+    } else if (greeting[1] !== 0) {
+      throw new ConnectionError(`Unsupported SOCKS5 auth method: ${greeting[1]}`);
+    }
+    const hostname = new TextEncoder().encode(this.host);
+    if (hostname.length > 255)
+      throw new TypeError("SOCKS5 hostname is too long");
+    await this.sendRaw(Uint8Array.from([
+      5,
+      1,
+      0,
+      3,
+      hostname.length,
+      ...hostname,
+      this.port >>> 8 & 255,
+      this.port & 255
+    ]));
+    const head = await this.recv(4);
+    if (head[0] !== 5 || head[1] !== 0)
+      throw new ConnectionError(`SOCKS5 CONNECT failed: ${head[1]}`);
+    const addressLength = head[3] === 1 ? 4 : head[3] === 4 ? 16 : (await this.recv(1))[0];
+    if (addressLength === undefined)
+      throw new ConnectionError("Invalid SOCKS5 response");
+    await this.recv(addressLength + 2);
+  }
+  async socks4Connect(proxy) {
+    const user = new TextEncoder().encode(decodeURIComponent(proxy.username));
+    const host = new TextEncoder().encode(this.host);
+    const request = Uint8Array.from([
+      4,
+      1,
+      this.port >>> 8 & 255,
+      this.port & 255,
+      0,
+      0,
+      0,
+      1,
+      ...user,
+      0,
+      ...host,
+      0
+    ]);
+    await this.sendRaw(request);
+    const response = await this.recv(8);
+    if (response[1] !== 90)
+      throw new ConnectionError(`SOCKS4 CONNECT failed: ${response[1]}`);
+  }
+  async upgradeTls() {
+    const socket = this.socket;
+    if (!socket)
+      throw new ConnectionError("Proxy socket closed before TLS upgrade");
+    await new Promise((resolve, reject) => {
+      const handlers = this.handlers();
+      const [, tls] = socket.upgradeTLS({
+        tls: { serverName: this.host },
+        socket: {
+          ...handlers,
+          open: () => resolve(),
+          error: (_socket, error) => {
+            handlers.error?.(_socket, error);
+            reject(error);
+          }
+        }
+      });
+      this.socket = tls;
+    });
+  }
+  async sendRaw(data) {
+    const socket = this.socket;
+    if (!socket || socket.readyState <= 0)
+      throw new ConnectionError("Socket is not connected");
+    let offset = 0;
+    while (offset < data.byteLength) {
+      const written = socket.write(data, offset, data.byteLength - offset);
+      if (written < 0)
+        throw new ConnectionError("Socket closed while writing");
+      if (written === 0) {
+        await Bun.sleep(0);
+        continue;
+      }
+      offset += written;
+    }
+    socket.flush();
+  }
+  async readUntil(delimiter) {
+    let data = this.buffered;
+    for (;; ) {
+      const index = findBytes(data, delimiter);
+      if (index >= 0) {
+        const end = index + delimiter.length;
+        const result = data.slice(0, end);
+        this.buffered = data.slice(end);
+        return result;
+      }
+      if (data.byteLength > 64 * 1024)
+        throw new ConnectionError("Proxy response header is too large");
+      data = concatBytes(data, await this.chunks.shift());
+    }
+  }
+}
+function concatBytes(left, right) {
+  const result = new Uint8Array(left.byteLength + right.byteLength);
+  result.set(left);
+  result.set(right, left.byteLength);
+  return result;
+}
+function defaultProxyPort(protocol) {
+  if (protocol === "https:")
+    return 443;
+  if (protocol === "http:")
+    return 8080;
+  return 1080;
+}
+function findBytes(source, target) {
+  outer:
+    for (let index = 0;index <= source.length - target.length; index += 1) {
+      for (let offset = 0;offset < target.length; offset += 1) {
+        if (source[index + offset] !== target[offset])
+          continue outer;
+      }
+      return index;
+    }
+  return -1;
+}
+// src/transport/websocket.ts
+class WebSocketTransport {
+  url;
+  proxy;
+  socket = null;
+  messages = new AsyncQueue;
+  constructor(url, proxy = null) {
+    this.url = url;
+    this.proxy = proxy;
+  }
+  get connected() {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+  async connect() {
+    if (this.socket)
+      return;
+    const socket = new WebSocket(this.url, {
+      headers: { Origin: "https://web.max.ru" },
+      ...this.proxy ? { proxy: this.proxy } : {}
+    });
+    this.socket = socket;
+    await new Promise((resolve, reject) => {
+      socket.addEventListener("open", () => resolve(), { once: true });
+      socket.addEventListener("error", () => reject(new ConnectionError("WebSocket connection failed")), {
+        once: true
+      });
+    });
+    socket.addEventListener("message", (event) => {
+      if (typeof event.data === "string")
+        this.messages.push(event.data);
+      else
+        this.messages.fail(new TypeError("Expected a text WebSocket frame"));
+    });
+    socket.addEventListener("close", () => {
+      this.socket = null;
+      this.messages.fail(new ConnectionError("WebSocket closed"));
+    });
+    socket.addEventListener("error", () => this.messages.fail(new ConnectionError("WebSocket failed")));
+  }
+  async close() {
+    const socket = this.socket;
+    this.socket = null;
+    if (socket && socket.readyState < WebSocket.CLOSING)
+      socket.close();
+    this.messages.clear();
+  }
+  async send(data) {
+    if (!this.socket || !this.connected)
+      throw new ConnectionError("Transport is not connected");
+    this.socket.send(data);
+  }
+  async recv() {
+    if (!this.connected)
+      throw new ConnectionError("Transport is not connected");
+    return await this.messages.shift();
+  }
+}
+// src/client.ts
+class BaseClient {
+  router = new Router;
+  app;
+  config;
+  stopping = false;
+  constructor(config, _authFlow, app) {
+    this.config = config;
+    configureLogging(config.logLevel);
+    this.app = app;
+    this.app.bindClient(this);
+  }
+  get me() {
+    return this.app.me;
+  }
+  get chats() {
+    return this.app.chats;
+  }
+  get contacts() {
+    return this.app.contacts;
+  }
+  get messages() {
+    return this.app.messages;
+  }
+  get session() {
+    return this.app.session;
+  }
+  get api() {
+    return this.app.api;
+  }
+  get account() {
+    return this.api.account;
+  }
+  get auth() {
+    return this.api.auth;
+  }
+  get bots() {
+    return this.api.bots;
+  }
+  get chatApi() {
+    return this.api.chats;
+  }
+  get users() {
+    return this.api.users;
+  }
+  async start() {
+    this.stopping = false;
+    for (;; ) {
+      try {
+        await this.app.start();
+        await this.app.dispatcher.emitStart();
+        await this.app.connection.waitClosed();
+        await this.app.close();
+        return;
+      } catch (error) {
+        await this.app.close();
+        if (this.stopping)
+          return;
+        const failure = error instanceof Error ? error : new Error(String(error));
+        await this.app.dispatcher.emitDisconnect(failure, this.config.reconnect, this.config.reconnectDelay);
+        if (!this.config.reconnect)
+          throw failure;
+        await Bun.sleep(this.config.reconnectDelay * 1000);
+        this.app = this.rebuildApp();
+        this.app.bindClient(this);
+      }
+    }
+  }
+  async stop() {
+    this.stopping = true;
+    await this.app.close();
+  }
+  async close() {
+    await this.stop();
+  }
+  async relogin(start = true) {
+    if (!this.app.session)
+      throw new Error("Cannot relogin before session is loaded");
+    await this.app.store.deleteSession(this.app.session.token);
+    await this.app.close();
+    this.config.token = null;
+    this.app = this.rebuildApp();
+    this.app.bindClient(this);
+    if (start)
+      await this.start();
+  }
+  includeRouter(router2) {
+    return this.router.includeRouter(router2);
+  }
+  onStart(handler) {
+    return this.router.onStart(handler);
+  }
+  onError(handler) {
+    return this.router.onError(handler);
+  }
+  onDisconnect(handler) {
+    return this.router.onDisconnect(handler);
+  }
+  onMessage(handler, ...filters) {
+    return this.router.onMessage(handler, ...filters);
+  }
+  onMessageEdit(handler, ...filters) {
+    return this.router.onMessageEdit(handler, ...filters);
+  }
+  onMessageDelete(handler, ...filters) {
+    return this.router.onMessageDelete(handler, ...filters);
+  }
+  onMessageRead(handler, ...filters) {
+    return this.router.onMessageRead(handler, ...filters);
+  }
+  onTyping(handler, ...filters) {
+    return this.router.onTyping(handler, ...filters);
+  }
+  onPresence(handler, ...filters) {
+    return this.router.onPresence(handler, ...filters);
+  }
+  onReactionUpdate(handler, ...filters) {
+    return this.router.onReactionUpdate(handler, ...filters);
+  }
+  onChatUpdate(handler, ...filters) {
+    return this.router.onChatUpdate(handler, ...filters);
+  }
+  onRaw(handler, ...filters) {
+    return this.router.onRaw(handler, ...filters);
+  }
+  async sendMessage(options) {
+    return await this.api.messages.sendMessage(options);
+  }
+  async forwardMessage(options) {
+    return await this.api.messages.forwardMessage(options);
+  }
+  async getMessages(chatId, messageIds) {
+    return await this.api.messages.getMessages(chatId, messageIds);
+  }
+  async getMessage(chatId, messageId) {
+    return await this.api.messages.getMessage(chatId, messageId);
+  }
+  async editMessage(options) {
+    return await this.api.messages.editMessage(options);
+  }
+  async fetchHistory(options) {
+    return await this.api.messages.fetchHistory(options);
+  }
+  async deleteMessage(options) {
+    return await this.api.messages.deleteMessage(options);
+  }
+  async pinMessage(options) {
+    return await this.api.messages.pinMessage(options);
+  }
+  async readMessage(messageId, chatId) {
+    return await this.api.messages.readMessage(messageId, chatId);
+  }
+  async addReaction(chatId, messageId, reaction) {
+    return await this.api.messages.addReaction(chatId, messageId, reaction);
+  }
+  async removeReaction(chatId, messageId) {
+    return await this.api.messages.removeReaction(chatId, messageId);
+  }
+  async getReactions(chatId, messageIds) {
+    return await this.api.messages.getReactions(chatId, messageIds);
+  }
+  async getVideoById(chatId, messageId, videoId) {
+    return await this.api.messages.getVideoById(chatId, messageId, videoId);
+  }
+  async getFileById(chatId, messageId, fileId) {
+    return await this.api.messages.getFileById(chatId, messageId, fileId);
+  }
+  async createGroup(name, participantIds = [], notify = true) {
+    return await this.api.chats.createGroup(name, participantIds, notify);
+  }
+  async inviteUsersToGroup(chatId, userIds, showHistory = true) {
+    return await this.api.chats.inviteUsersToGroup(chatId, userIds, showHistory);
+  }
+  async inviteUsersToChannel(chatId, userIds, showHistory = true) {
+    return await this.api.chats.inviteUsersToChannel(chatId, userIds, showHistory);
+  }
+  async removeUsersFromGroup(chatId, userIds) {
+    return await this.api.chats.removeUsersFromGroup(chatId, userIds);
+  }
+  async getChats(chatIds) {
+    return await this.api.chats.getChats(chatIds);
+  }
+  async getChat(chatId) {
+    return await this.api.chats.getChat(chatId);
+  }
+  async fetchChats(marker) {
+    return await this.api.chats.fetchChats(marker);
+  }
+  async joinGroup(link) {
+    return await this.api.chats.joinGroup(link);
+  }
+  async joinChannel(link) {
+    return await this.api.chats.joinChannel(link);
+  }
+  async leaveGroup(chatId) {
+    await this.api.chats.leaveGroup(chatId);
+  }
+  async leaveChannel(chatId) {
+    await this.api.chats.leaveChannel(chatId);
+  }
+  async deleteChat(chatId, forMe = true) {
+    return await this.api.chats.deleteChat(chatId, forMe);
+  }
+  async changeGroupSettings(chatId, settings) {
+    await this.api.chats.changeGroupSettings(chatId, settings);
+  }
+  async changeGroupProfile(chatId, name, description = null) {
+    await this.api.chats.changeGroupProfile(chatId, name, description);
+  }
+  async resolveGroupByLink(link) {
+    return await this.api.chats.resolveGroupByLink(link);
+  }
+  async reworkInviteLink(chatId) {
+    return await this.api.chats.reworkInviteLink(chatId);
+  }
+  async getJoinRequests(chatId, count = 100) {
+    return await this.api.chats.getJoinRequests(chatId, count);
+  }
+  async confirmJoinRequests(chatId, userIds, showHistory = true) {
+    return await this.api.chats.confirmJoinRequests(chatId, userIds, showHistory);
+  }
+  async confirmJoinRequest(chatId, userId, showHistory = true) {
+    return await this.api.chats.confirmJoinRequest(chatId, userId, showHistory);
+  }
+  async declineJoinRequests(chatId, userIds) {
+    return await this.api.chats.declineJoinRequests(chatId, userIds);
+  }
+  async declineJoinRequest(chatId, userId) {
+    return await this.api.chats.declineJoinRequest(chatId, userId);
+  }
+  getCachedUser(userId) {
+    return this.api.users.getCachedUser(userId);
+  }
+  async getUsers(userIds) {
+    return await this.api.users.getUsers(userIds);
+  }
+  async getUser(userId) {
+    return await this.api.users.getUser(userId);
+  }
+  async fetchUsers(userIds) {
+    return await this.api.users.fetchUsers(userIds);
+  }
+  async searchByPhone(phone) {
+    return await this.api.users.searchByPhone(phone);
+  }
+  async addContact(contactId) {
+    return await this.api.users.addContact(contactId);
+  }
+  async removeContact(contactId) {
+    return await this.api.users.removeContact(contactId);
+  }
+  async importContacts(contacts) {
+    return await this.api.users.importContacts(contacts);
+  }
+  getChatId(firstUserId, secondUserId) {
+    return this.api.users.getChatId(firstUserId, secondUserId);
+  }
+  async setTwoFactor(options) {
+    return await this.auth.setTwoFactor(options);
+  }
+  async removeTwoFactor(password) {
+    return await this.auth.removeTwoFactor(password);
+  }
+  async changePassword(oldPassword, newPassword) {
+    return await this.auth.changePassword(oldPassword, newPassword);
+  }
+  async authorizeQrLogin(qrLink) {
+    return await this.auth.authorizeQrLogin(qrLink);
+  }
+  async checkTwoFactor() {
+    return await this.auth.checkTwoFactor();
+  }
+  async changeProfile(options) {
+    return await this.account.changeProfile(options);
+  }
+  async requestProfilePhotoUploadUrl() {
+    return await this.account.requestProfilePhotoUploadUrl();
+  }
+  async createFolder(title, chatInclude, filters = []) {
+    return await this.account.createFolder(title, chatInclude, filters);
+  }
+  async getFolders(folderSync = 0) {
+    return await this.account.getFolders(folderSync);
+  }
+  async updateFolder(folderId, title, chatInclude = [], filters = [], options = []) {
+    return await this.account.updateFolder(folderId, title, chatInclude, filters, options);
+  }
+  async deleteFolder(folderId) {
+    return await this.account.deleteFolder(folderId);
+  }
+  async closeAllSessions() {
+    return await this.account.closeAllSessions();
+  }
+  async logout() {
+    return await this.account.logout();
+  }
+  async getSessions() {
+    return await this.users.getSessions();
+  }
+  async getBotInitData(botId, chatId, startParam) {
+    return await this.bots.getBotInitData(botId, chatId, startParam);
+  }
+}
+
+class Client extends BaseClient {
+  authFlow;
+  constructor(options) {
+    const config = resolveConfig({
+      phone: options.phone,
+      ...options.workDir !== undefined ? { workDir: options.workDir } : {},
+      ...options.sessionName !== undefined ? { sessionName: options.sessionName } : {},
+      ...options.extraConfig !== undefined ? { extra: options.extraConfig } : {}
+    });
+    const authFlow = options.authFlow ?? new SmsAuthFlow(options.smsCodeProvider, options.passwordProvider);
+    const transport = new TcpTransport(config.host, config.port, config.useTls, config.proxy);
+    const connection2 = new ConnectionManager(new TcpReader(transport), transport, new TcpProtocol);
+    const placeholder = new Router;
+    const app = new App(connection2, config, authFlow, placeholder);
+    super(config, authFlow, app);
+    this.authFlow = authFlow;
+    app.dispatcher.rootRouter.children.push(this.router);
+  }
+  rebuildApp() {
+    const transport = new TcpTransport(this.config.host, this.config.port, this.config.useTls, this.config.proxy);
+    const connection2 = new ConnectionManager(new TcpReader(transport), transport, new TcpProtocol);
+    return new App(connection2, this.config, this.authFlow, this.router);
+  }
+}
+
+class WebClient extends BaseClient {
+  authFlow;
+  constructor(options = {}) {
+    const config = resolveConfig({
+      phone: null,
+      ...options.workDir !== undefined ? { workDir: options.workDir } : {},
+      ...options.sessionName !== undefined ? { sessionName: options.sessionName } : {},
+      web: true,
+      ...options.extraConfig !== undefined ? { extra: options.extraConfig } : {}
+    });
+    const authFlow = options.authFlow ?? new QrAuthFlow(options.qrHandler, options.passwordProvider);
+    const transport = new WebSocketTransport(config.url, config.proxy);
+    const connection2 = new ConnectionManager(new WsReader(transport), transport, new WsProtocol);
+    const placeholder = new Router;
+    const app = new App(connection2, config, authFlow, placeholder);
+    super(config, authFlow, app);
+    this.authFlow = authFlow;
+    app.dispatcher.rootRouter.children.push(this.router);
+  }
+  rebuildApp() {
+    const transport = new WebSocketTransport(this.config.url, this.config.proxy);
+    const connection2 = new ConnectionManager(new WsReader(transport), transport, new WsProtocol);
+    return new App(connection2, this.config, this.authFlow, this.router);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  toMaxId,
+  resolveSync,
+  resolveConfig,
+  parseReadState,
+  parseReactionInfo,
+  parseAttachment,
+  optionalRecord,
+  optionalMaxId,
+  mainTabParams,
+  getLogger,
+  formatMarkdown,
+  defaultTelemetryTiming,
+  defaultSyncState,
+  defaultProfiles,
+  consoleSmsCodeProvider,
+  consoleQrHandler,
+  consolePasswordProvider,
+  consoleEmailCodeProvider,
+  configureLogging,
+  asString,
+  asRecord,
+  asNumber,
+  asBoolean,
+  asArray,
+  ZstdCompression,
+  WsProtocol,
+  WebClient,
+  Video,
+  VERSION,
+  UserApi,
+  User,
+  UploadError,
+  UploadApi,
+  TsMaxError,
+  TimeoutError,
+  TelemetryService,
+  TelemetryPayloadBuilder,
+  TcpProtocol,
+  TcpPayloadDecoder,
+  TcpPacketFramer,
+  TCP_HEADER_SIZE,
+  SqliteSessionStore,
+  SmsAuthFlow,
+  Screen,
+  Router,
+  QrAuthFlow,
+  Profile,
+  Photo,
+  Opcode,
+  NavigationPlanner,
+  MsgpackPayloadCodec,
+  MessageApi,
+  Message,
+  MaxFile,
+  Lz4BlockCompression,
+  File,
+  EventType,
+  Dispatcher,
+  DeviceType,
+  DEFAULT_CONFIG_HASH,
+  ConnectionError,
+  Command,
+  Client,
+  ChatType,
+  ChatApi,
+  Chat,
+  BotsApi,
+  BaseClient,
+  AuthApi,
+  AttachmentType,
+  ApiFacade,
+  ApiError,
+  AccountApi
+};
+
+//# debugId=DCB99DD4AB754F0E64756E2164756E21