@bruch/max-client 0.1.0

package/dist/telemetry/index.js

@@ -0,0 +1,831 @@
+// @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/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/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/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 });
+  });
+}
+export {
+  mainTabParams,
+  defaultTelemetryTiming,
+  defaultProfiles,
+  TelemetryService,
+  TelemetryPayloadBuilder,
+  Screen,
+  NavigationPlanner
+};
+
+//# debugId=3534F2E6FEFBAE9064756E2164756E21