@mtcute/core 0.17.0 → 0.18.0-rc.5

package/highlevel/updates/manager.cjs

@@ -0,0 +1,1448 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const tl = require("@mtcute/tl");
+const Long = require("long");
+const errors = require("../../types/errors.cjs");
+const utils$1 = require("../../types/utils.cjs");
+const earlyTimer = require("../../utils/early-timer.cjs");
+const linkedList = require("../../utils/linked-list.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+require("@mtcute/tl-runtime");
+const batchedQueries = require("../methods/chats/batched-queries.cjs");
+const peersIndex = require("../types/peers/peers-index.cjs");
+const types = require("./types.cjs");
+const utils$2 = require("./utils.cjs");
+const peerUtils$1 = require("../utils/peer-utils.cjs");
+const KEEP_ALIVE_INTERVAL = 15 * 60 * 1e3;
+const UPDATES_TOO_LONG = { _: "updatesTooLong" };
+class UpdatesManager {
+  constructor(client, params = {}) {
+    this.client = client;
+    this.params = params;
+    if (client.params.disableUpdates) {
+      throw new errors.MtArgumentError("Updates must be enabled to use updates manager");
+    }
+    this._onKeepAlive = this._onKeepAlive.bind(this);
+    this.postponedTimer.onTimeout(() => {
+      this.hasTimedoutPostponed = true;
+      this.updatesLoopCv.notify();
+    });
+    this.log = client.log.create("updates");
+    this.catchUpOnStart = params.catchUp ?? false;
+    this.noDispatchEnabled = !params.disableNoDispatch;
+    if (params.channelPtsLimit) {
+      if (typeof params.channelPtsLimit === "function") {
+        this._channelPtsLimit = params.channelPtsLimit;
+      } else {
+        const limit = params.channelPtsLimit;
+        this._channelPtsLimit = () => limit;
+      }
+    } else {
+      this._channelPtsLimit = () => this.auth?.isBot ? 1e5 : 100;
+    }
+  }
+  updatesLoopActive = false;
+  updatesLoopCv = new utils.ConditionVariable();
+  postponedTimer = new earlyTimer.EarlyTimer();
+  hasTimedoutPostponed = false;
+  pendingUpdateContainers = new linkedList.SortedLinkedList((a, b) => a.seqStart - b.seqStart);
+  pendingPtsUpdates = new linkedList.SortedLinkedList((a, b) => a.ptsBefore - b.ptsBefore);
+  pendingPtsUpdatesPostponed = new linkedList.SortedLinkedList((a, b) => a.ptsBefore - b.ptsBefore);
+  pendingQtsUpdates = new linkedList.SortedLinkedList((a, b) => a.qtsBefore - b.qtsBefore);
+  pendingQtsUpdatesPostponed = new linkedList.SortedLinkedList((a, b) => a.qtsBefore - b.qtsBefore);
+  pendingUnorderedUpdates = new utils.Deque();
+  noDispatchEnabled;
+  // channel id or 0 => msg id
+  noDispatchMsg = /* @__PURE__ */ new Map();
+  // channel id or 0 => pts
+  noDispatchPts = /* @__PURE__ */ new Map();
+  noDispatchQts = /* @__PURE__ */ new Set();
+  lock = new utils.AsyncLock();
+  // rpsIncoming?: RpsMeter
+  // rpsProcessing?: RpsMeter
+  // accessing storage every time might be expensive,
+  // so store everything here, and load & save
+  // every time session is loaded & saved.
+  pts;
+  qts;
+  date;
+  seq;
+  // old values of the updates state (i.e. as in DB)
+  // used to avoid redundant storage calls
+  oldPts;
+  oldQts;
+  oldDate;
+  oldSeq;
+  // whether to catch up channels from the locally stored pts
+  catchingUp = false;
+  catchUpOnStart;
+  cpts = /* @__PURE__ */ new Map();
+  cptsMod = /* @__PURE__ */ new Map();
+  channelDiffTimeouts = /* @__PURE__ */ new Map();
+  channelsOpened = /* @__PURE__ */ new Map();
+  log;
+  _onCatchingUp = () => {
+  };
+  // eslint-disable-next-line ts/no-unsafe-function-type
+  _channelPtsLimit;
+  auth;
+  // todo: do we need a local copy?
+  keepAliveInterval;
+  onCatchingUp(handler) {
+    this._onCatchingUp = handler;
+  }
+  destroy() {
+    this.stopLoop();
+  }
+  notifyLoggedIn(self) {
+    this.auth = self;
+    this.startLoop().catch((err) => this.client.onError.emit(utils.unknownToError(err)));
+  }
+  notifyLoggedOut() {
+    this.stopLoop();
+    this.cpts.clear();
+    this.cptsMod.clear();
+    this.pts = this.qts = this.date = this.seq = void 0;
+  }
+  async prepare() {
+    await this._loadUpdatesStorage();
+  }
+  _onKeepAlive() {
+    this.log.debug("no updates for >15 minutes, catching up");
+    this.handleUpdate(UPDATES_TOO_LONG);
+  }
+  /**
+   * Start updates loop.
+   *
+   * You must first call {@link enableUpdatesProcessing} to use this method.
+   *
+   * It is recommended to use this method in callback to {@link start},
+   * or otherwise make sure the user is logged in.
+   *
+   * > **Note**: If you are using {@link UpdatesManagerParams.catchUp} option,
+   * > catching up will be done in background, you can't await it.
+   * > Instead, listen for the `updating` and `connected` connection state events.
+   */
+  async startLoop() {
+    if (this.updatesLoopActive) return;
+    if (!this.catchUpOnStart) {
+      await this._fetchUpdatesState();
+    }
+    this.updatesLoopActive = true;
+    utils.timers.clearInterval(this.keepAliveInterval);
+    this.keepAliveInterval = utils.timers.setInterval(this._onKeepAlive, KEEP_ALIVE_INTERVAL);
+    this._loop().catch((err) => this.client.onError.emit(utils.unknownToError(err)));
+    if (this.catchUpOnStart) {
+      this.catchUp();
+    }
+  }
+  /**
+   * **ADVANCED**
+   *
+   * Manually stop updates loop.
+   * Usually done automatically when stopping the client with {@link close}
+   */
+  stopLoop() {
+    if (!this.updatesLoopActive) return;
+    utils.timers.clearInterval(this.keepAliveInterval);
+    for (const timer of this.channelDiffTimeouts.values()) {
+      utils.timers.clearTimeout(timer);
+    }
+    this.channelDiffTimeouts.clear();
+    this.updatesLoopActive = false;
+    this.pendingUpdateContainers.clear();
+    this.pendingUnorderedUpdates.clear();
+    this.pendingPtsUpdates.clear();
+    this.pendingQtsUpdates.clear();
+    this.pendingPtsUpdatesPostponed.clear();
+    this.pendingQtsUpdatesPostponed.clear();
+    this.postponedTimer.reset();
+    this.updatesLoopCv.notify();
+  }
+  /**
+   * Catch up with the server by loading missed updates.
+   *.
+   * > **Note**: In case the storage was not properly
+   * > closed the last time, "catching up" might
+   * > result in duplicate updates.
+   */
+  catchUp() {
+    if (!this.updatesLoopActive) {
+      this.log.warn("catch up requested, but updates loop is not active, ignoring");
+      return;
+    }
+    this.log.debug("catch up requested");
+    this._onCatchingUp(true);
+    this.catchingUp = true;
+    this.handleUpdate(UPDATES_TOO_LONG);
+  }
+  handleClientUpdate(update, noDispatch = true) {
+    if (noDispatch && this.noDispatchEnabled) {
+      this._addToNoDispatchIndex(update);
+    }
+    this.handleUpdate(update);
+  }
+  handleUpdate(update) {
+    this.log.debug(
+      "received %s, queueing for processing. containers queue size: %d",
+      update._,
+      this.pendingUpdateContainers.length
+    );
+    switch (update._) {
+      case "updatesTooLong":
+      case "updateShortMessage":
+      case "updateShortChatMessage":
+      case "updateShort":
+      case "updateShortSentMessage":
+        this.pendingUpdateContainers.add({
+          upd: update,
+          seqStart: 0,
+          seqEnd: 0
+        });
+        break;
+      case "updates":
+      case "updatesCombined":
+        this.pendingUpdateContainers.add({
+          upd: update,
+          seqStart: update._ === "updatesCombined" ? update.seqStart : update.seq,
+          seqEnd: update.seq
+        });
+        break;
+      default:
+        utils$1.assertNever();
+    }
+    this.updatesLoopCv.notify();
+  }
+  /**
+   * **ADVANCED**
+   *
+   * Notify the updates manager that some channel was "opened".
+   * Channel difference for "opened" channels will be fetched on a regular basis.
+   * This is a low-level method, prefer using {@link openChat} instead.
+   *
+   * Channel must be resolve-able with `resolvePeer` method (i.e. be in cache);
+   * base chat PTS must either be passed (e.g. from {@link Dialog}), or cached in storage.
+   *
+   * @param channelId  Bare ID of the channel
+   * @param pts  PTS of the channel, if known (e.g. from {@link Dialog})
+   * @returns `true` if the channel was opened for the first time, `false` if it is already opened
+   */
+  notifyChannelOpened(channelId, pts) {
+    if (this.channelsOpened.has(channelId)) {
+      this.log.debug("channel %d opened again", channelId);
+      this.channelsOpened.set(channelId, this.channelsOpened.get(channelId) + 1);
+      return false;
+    }
+    this.channelsOpened.set(channelId, 1);
+    this.log.debug("channel %d opened (pts=%d)", channelId, pts);
+    this._fetchChannelDifferenceViaUpdate(channelId, pts);
+    return true;
+  }
+  /**
+   * **ADVANCED**
+   *
+   * Notify the updates manager that some channel was "closed".
+   * Basically the opposite of {@link notifyChannelOpened}.
+   * This is a low-level method, prefer using {@link closeChat} instead.
+   *
+   * @param channelId  Bare channel ID
+   * @returns `true` if the chat was closed for the last time, `false` otherwise
+   */
+  notifyChannelClosed(channelId) {
+    const opened = this.channelsOpened.get(channelId);
+    if (opened === void 0) {
+      return false;
+    }
+    if (opened > 1) {
+      this.log.debug("channel %d closed, but is opened %d more times", channelId, opened - 1);
+      this.channelsOpened.set(channelId, opened - 1);
+      return false;
+    }
+    this.channelsOpened.delete(channelId);
+    this.log.debug("channel %d closed", channelId);
+    return true;
+  }
+  /// /////////////////////////////////////////// IMPLEMENTATION //////////////////////////////////////////////
+  async _fetchUpdatesState() {
+    const { client, lock, log } = this;
+    await lock.acquire();
+    log.debug("fetching initial state");
+    try {
+      let fetchedState = await client.call({ _: "updates.getState" });
+      log.debug(
+        "updates.getState returned state: pts=%d, qts=%d, date=%d, seq=%d",
+        fetchedState.pts,
+        fetchedState.qts,
+        fetchedState.date,
+        fetchedState.seq
+      );
+      const diff = await client.call({
+        _: "updates.getDifference",
+        pts: fetchedState.pts,
+        qts: fetchedState.qts,
+        date: fetchedState.date
+      });
+      switch (diff._) {
+        case "updates.differenceEmpty":
+          break;
+        case "updates.differenceTooLong":
+          fetchedState.pts = diff.pts;
+          break;
+        case "updates.differenceSlice":
+          fetchedState = diff.intermediateState;
+          break;
+        case "updates.difference":
+          fetchedState = diff.state;
+          break;
+        default:
+          utils$1.assertNever(diff);
+      }
+      this.qts = fetchedState.qts;
+      this.pts = fetchedState.pts;
+      this.date = fetchedState.date;
+      this.seq = fetchedState.seq;
+      log.debug("loaded initial state: pts=%d, qts=%d, date=%d, seq=%d", this.pts, this.qts, this.date, this.seq);
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "AUTH_KEY_UNREGISTERED")) {
+        lock.release();
+        this.stopLoop();
+        return;
+      }
+      if (this.client.isConnected) {
+        log.error("failed to fetch updates state: %s", e);
+      }
+      lock.release();
+      throw e;
+    }
+    lock.release();
+  }
+  async _loadUpdatesStorage() {
+    const storedState = await this.client.storage.updates.getState();
+    if (storedState) {
+      this.pts = this.oldPts = storedState[0];
+      this.qts = this.oldQts = storedState[1];
+      this.date = this.oldDate = storedState[2];
+      this.seq = this.oldSeq = storedState[3];
+      this.log.debug(
+        "loaded stored state: pts=%d, qts=%d, date=%d, seq=%d",
+        storedState[0],
+        storedState[1],
+        storedState[2],
+        storedState[3]
+      );
+    }
+  }
+  async _saveUpdatesStorage(save = false) {
+    const { client } = this;
+    if (this.pts !== void 0) {
+      if (this.oldPts === void 0 || this.oldPts !== this.pts) {
+        await client.storage.updates.setPts(this.pts);
+      }
+      if (this.oldQts === void 0 || this.oldQts !== this.qts) {
+        await client.storage.updates.setQts(this.qts);
+      }
+      if (this.oldDate === void 0 || this.oldDate !== this.date) {
+        await client.storage.updates.setDate(this.date);
+      }
+      if (this.oldSeq === void 0 || this.oldSeq !== this.seq) {
+        await client.storage.updates.setSeq(this.seq);
+      }
+      this.oldPts = this.pts;
+      this.oldQts = this.qts;
+      this.oldDate = this.date;
+      this.oldSeq = this.seq;
+      await client.storage.updates.setManyChannelPts(this.cptsMod);
+      this.cptsMod.clear();
+      if (save) {
+        await client.mt.storage.save();
+      }
+    }
+  }
+  _addToNoDispatchIndex(updates) {
+    if (!updates) return;
+    const { noDispatchMsg, noDispatchPts, noDispatchQts } = this;
+    const addUpdate = (upd) => {
+      const channelId = utils$2.extractChannelIdFromUpdate(upd) ?? 0;
+      const pts = "pts" in upd ? upd.pts : void 0;
+      if (pts) {
+        const set = noDispatchPts.get(channelId);
+        if (!set) noDispatchPts.set(channelId, /* @__PURE__ */ new Set([pts]));
+        else set.add(pts);
+      }
+      const qts = "qts" in upd ? upd.qts : void 0;
+      if (qts) {
+        noDispatchQts.add(qts);
+      }
+      switch (upd._) {
+        case "updateNewMessage":
+        case "updateNewChannelMessage":
+        case "updateBotNewBusinessMessage": {
+          const channelId2 = upd.message.peerId?._ === "peerChannel" ? upd.message.peerId.channelId : 0;
+          const set = noDispatchMsg.get(channelId2);
+          if (!set) noDispatchMsg.set(channelId2, /* @__PURE__ */ new Set([upd.message.id]));
+          else set.add(upd.message.id);
+          break;
+        }
+      }
+    };
+    switch (updates._) {
+      case "updates":
+      case "updatesCombined":
+        updates.updates.forEach(addUpdate);
+        break;
+      case "updateShortMessage":
+      case "updateShortChatMessage":
+      case "updateShortSentMessage": {
+        let set = noDispatchMsg.get(0);
+        if (!set) noDispatchMsg.set(0, /* @__PURE__ */ new Set([updates.id]));
+        else set.add(updates.id);
+        set = noDispatchPts.get(0);
+        if (!set) noDispatchPts.set(0, /* @__PURE__ */ new Set([updates.pts]));
+        else set.add(updates.pts);
+        break;
+      }
+      case "updateShort":
+        addUpdate(updates.update);
+        break;
+      case "updatesTooLong":
+        break;
+      default:
+        utils$1.assertNever();
+    }
+  }
+  async _fetchMissingPeers(upd, peers, fromDifference = false) {
+    const { client, log } = this;
+    const missing = /* @__PURE__ */ new Set();
+    async function fetchPeer(peer, allowZeroHash = false) {
+      if (!peer) return true;
+      const bare = typeof peer === "number" ? peerUtils.parseMarkedPeerId(peer)[1] : peerUtils.getBarePeerId(peer);
+      const marked = typeof peer === "number" ? peer : peerUtils.getMarkedPeerId(peer);
+      const index = marked > 0 ? peers.users : peers.chats;
+      const fromIndex = index.get(bare);
+      if (fromIndex && !fromIndex.min) return true;
+      if (missing.has(marked)) return false;
+      const cached = await client.storage.peers.getCompleteById(marked);
+      if (!cached) {
+        if (fromDifference && allowZeroHash && peerUtils.parseMarkedPeerId(marked)[0] === "channel") {
+          log.debug("trying to fetch peer %d with zero access hash", marked);
+          const fetched = await batchedQueries._getChannelsBatched(client, {
+            _: "inputChannel",
+            channelId: bare,
+            accessHash: Long.ZERO
+          });
+          if (fetched?._ === "channel" && !fetched.min) {
+            index.set(bare, fetched);
+            return true;
+          }
+        }
+        missing.add(marked);
+        return fromDifference;
+      }
+      index.set(bare, cached);
+      return true;
+    }
+    switch (upd._) {
+      case "updateNewMessage":
+      case "updateNewChannelMessage":
+      case "updateEditMessage":
+      case "updateEditChannelMessage": {
+        const msg = upd.message;
+        if (msg._ === "messageEmpty") return missing;
+        if (!await fetchPeer(msg.peerId, true)) return missing;
+        if (!await fetchPeer(msg.fromId)) return missing;
+        if (msg.replyTo) {
+          if (msg.replyTo._ === "messageReplyHeader" && !await fetchPeer(msg.replyTo.replyToPeerId)) {
+            return missing;
+          }
+          if (msg.replyTo._ === "messageReplyStoryHeader" && !await fetchPeer(msg.replyTo.peer)) {
+            return missing;
+          }
+        }
+        if (msg._ !== "messageService") {
+          if (msg.fwdFrom && (!await fetchPeer(msg.fwdFrom.fromId) || !await fetchPeer(msg.fwdFrom.savedFromPeer, true))) {
+            return missing;
+          }
+          if (!await fetchPeer(msg.viaBotId)) return missing;
+          if (msg.entities) {
+            for (const ent of msg.entities) {
+              if (ent._ === "messageEntityMentionName") {
+                if (!await fetchPeer(ent.userId)) return missing;
+              }
+            }
+          }
+          if (msg.media) {
+            switch (msg.media._) {
+              case "messageMediaContact":
+                if (msg.media.userId && !await fetchPeer(msg.media.userId)) {
+                  return missing;
+                }
+            }
+          }
+        } else {
+          switch (msg.action._) {
+            case "messageActionChatCreate":
+            case "messageActionChatAddUser":
+            case "messageActionInviteToGroupCall":
+              for (const user of msg.action.users) {
+                if (!await fetchPeer(user)) return missing;
+              }
+              break;
+            case "messageActionChatJoinedByLink":
+              if (!await fetchPeer(msg.action.inviterId)) {
+                return missing;
+              }
+              break;
+            case "messageActionChatDeleteUser":
+              if (!await fetchPeer(msg.action.userId)) return missing;
+              break;
+            case "messageActionChatMigrateTo":
+              if (!await fetchPeer(peerUtils.toggleChannelIdMark(msg.action.channelId), true)) {
+                return missing;
+              }
+              break;
+            case "messageActionChannelMigrateFrom":
+              if (!await fetchPeer(-msg.action.chatId)) return missing;
+              break;
+            case "messageActionGeoProximityReached":
+              if (!await fetchPeer(msg.action.fromId)) return missing;
+              if (!await fetchPeer(msg.action.toId)) return missing;
+              break;
+          }
+        }
+        break;
+      }
+      case "updateDraftMessage":
+        if ("entities" in upd.draft && upd.draft.entities) {
+          for (const ent of upd.draft.entities) {
+            if (ent._ === "messageEntityMentionName") {
+              if (!await fetchPeer(ent.userId)) return missing;
+            }
+          }
+        }
+    }
+    return missing;
+  }
+  async _storeMessageReferences(msg) {
+    if (msg._ === "messageEmpty") return;
+    const { client } = this;
+    const peerId = msg.peerId;
+    if (peerId._ !== "peerChannel") return;
+    const channelId = peerUtils.toggleChannelIdMark(peerId.channelId);
+    const promises = [];
+    function store(peer) {
+      if (!peer) return;
+      if (Array.isArray(peer)) {
+        peer.forEach(store);
+        return;
+      }
+      const marked = typeof peer === "number" ? peer : peerUtils.getMarkedPeerId(peer);
+      promises.push(client.storage.refMsgs.store(marked, channelId, msg.id));
+    }
+    store(msg.fromId);
+    if (msg._ === "message") {
+      store(msg.viaBotId);
+      store(msg.fwdFrom?.fromId);
+      if (msg.media) {
+        switch (msg.media._) {
+          case "messageMediaWebPage":
+            if (msg.media.webpage._ === "webPage" && msg.media.webpage.attributes) {
+              for (const attr of msg.media.webpage.attributes) {
+                if (attr._ === "webPageAttributeStory") {
+                  store(attr.peer);
+                }
+              }
+            }
+            break;
+          case "messageMediaContact":
+            store(msg.media.userId);
+            break;
+          case "messageMediaStory":
+            store(msg.media.peer);
+            break;
+          case "messageMediaGiveaway":
+            store(msg.media.channels.map(peerUtils.toggleChannelIdMark));
+            break;
+        }
+      }
+    } else {
+      switch (msg.action._) {
+        case "messageActionChatCreate":
+        case "messageActionChatAddUser":
+        case "messageActionInviteToGroupCall":
+          store(msg.action.users);
+          break;
+        case "messageActionChatDeleteUser":
+          store(msg.action.userId);
+          break;
+      }
+    }
+    if (msg.replyTo) {
+      switch (msg.replyTo._) {
+        case "messageReplyHeader":
+          store(msg.replyTo.replyToPeerId);
+          store(msg.replyTo.replyFrom?.fromId);
+          break;
+        case "messageReplyStoryHeader":
+          store(msg.replyTo.peer);
+          break;
+      }
+    }
+    await Promise.all(promises);
+  }
+  async _fetchChannelDifference(channelId, fallbackPts) {
+    const { channelDiffTimeouts, cpts, cptsMod, channelsOpened, client, log, pendingUnorderedUpdates } = this;
+    if (channelDiffTimeouts.has(channelId)) {
+      utils.timers.clearTimeout(channelDiffTimeouts.get(channelId));
+      channelDiffTimeouts.delete(channelId);
+    }
+    let _pts = cpts.get(channelId);
+    if (!_pts && this.catchingUp) {
+      _pts = await client.storage.updates.getChannelPts(channelId);
+    }
+    if (!_pts) _pts = fallbackPts;
+    if (!_pts) {
+      log.debug("fetchChannelDifference failed for channel %d: base pts not available", channelId);
+      return false;
+    }
+    const channelPeer = await client.storage.peers.getById(peerUtils.toggleChannelIdMark(channelId));
+    if (!channelPeer) {
+      log.debug("fetchChannelDifference failed for channel %d: input peer not found", channelId);
+      return false;
+    }
+    const channel = peerUtils$1.toInputChannel(channelPeer);
+    let pts = _pts;
+    let limit = this._channelPtsLimit(channelId);
+    if (pts <= 0) {
+      pts = 1;
+      limit = 1;
+    }
+    let lastTimeout = 0;
+    for (; ; ) {
+      const diff = await client.call({
+        _: "updates.getChannelDifference",
+        force: true,
+        // Set to true to skip some possibly unneeded updates and reduce server-side load
+        channel,
+        pts,
+        limit,
+        filter: { _: "channelMessagesFilterEmpty" }
+      });
+      if (diff.timeout) {
+        lastTimeout = this.params.overrideOpenChatTimeout ? this.params.overrideOpenChatTimeout(diff) : diff.timeout;
+      }
+      if (diff._ === "updates.channelDifferenceEmpty") {
+        log.debug("getChannelDifference (cid = %d) returned channelDifferenceEmpty", channelId);
+        break;
+      }
+      const peers = peersIndex.PeersIndex.from(diff);
+      if (diff._ === "updates.channelDifferenceTooLong") {
+        if (diff.dialog._ === "dialog") {
+          pts = diff.dialog.pts;
+        }
+        if (this.params.onChannelTooLong) {
+          this.params.onChannelTooLong(channelId, diff);
+        } else {
+          log.warn(
+            "getChannelDifference (cid = %d) returned channelDifferenceTooLong. new pts: %d, recent msgs: %d",
+            channelId,
+            pts,
+            diff.messages.length
+          );
+          diff.messages.forEach((message) => {
+            log.debug(
+              "processing message %d (%s) from TooLong diff for channel %d",
+              message.id,
+              message._,
+              channelId
+            );
+            if (message._ === "messageEmpty") return;
+            pendingUnorderedUpdates.pushBack(utils$2.toPendingUpdate(utils$2.messageToUpdate(message), peers, true));
+          });
+        }
+        break;
+      }
+      log.debug(
+        "getChannelDifference (cid = %d) returned %d messages, %d updates. new pts: %d, final: %b",
+        channelId,
+        diff.newMessages.length,
+        diff.otherUpdates.length,
+        diff.pts,
+        diff.final
+      );
+      diff.newMessages.forEach((message) => {
+        log.debug("processing message %d (%s) from diff for channel %d", message.id, message._, channelId);
+        if (message._ === "messageEmpty") return;
+        pendingUnorderedUpdates.pushBack(utils$2.toPendingUpdate(utils$2.messageToUpdate(message), peers, true));
+      });
+      diff.otherUpdates.forEach((upd) => {
+        const parsed = utils$2.toPendingUpdate(upd, peers, true);
+        log.debug(
+          "processing %s from diff for channel %d, pts_before: %d, pts: %d",
+          upd._,
+          channelId,
+          parsed.ptsBefore,
+          parsed.pts
+        );
+        if (utils$2.isMessageEmpty(upd)) return;
+        pendingUnorderedUpdates.pushBack(parsed);
+      });
+      pts = diff.pts;
+      if (diff.final) break;
+    }
+    cpts.set(channelId, pts);
+    cptsMod.set(channelId, pts);
+    if (lastTimeout !== 0 && channelsOpened.has(channelId)) {
+      log.debug("scheduling next fetch for channel %d in %d seconds", channelId, lastTimeout);
+      channelDiffTimeouts.set(
+        channelId,
+        utils.timers.setTimeout(() => this._fetchChannelDifferenceViaUpdate(channelId), lastTimeout * 1e3)
+      );
+    }
+    return true;
+  }
+  _fetchChannelDifferenceLater(requestedDiff, channelId, fallbackPts) {
+    if (!requestedDiff.has(channelId)) {
+      requestedDiff.set(
+        channelId,
+        this._fetchChannelDifference(channelId, fallbackPts).catch((err) => {
+          this.log.warn("error fetching difference for %d: %e", channelId, err);
+        }).then((ok) => {
+          requestedDiff.delete(channelId);
+          if (!ok) {
+            this.log.debug("channel difference for %d failed, falling back to common diff", channelId);
+            this._fetchDifferenceLater(requestedDiff);
+          }
+        })
+      );
+    }
+  }
+  _fetchChannelDifferenceViaUpdate(channelId, pts) {
+    this.handleUpdate(
+      utils$2.createDummyUpdatesContainer([
+        {
+          _: "updateChannelTooLong",
+          channelId,
+          pts
+        }
+      ])
+    );
+  }
+  async _fetchDifference(requestedDiff) {
+    const { client, log, pendingPtsUpdates, pendingUnorderedUpdates } = this;
+    const diff = await client.call({
+      _: "updates.getDifference",
+      pts: this.pts,
+      date: this.date,
+      qts: this.qts
+    });
+    switch (diff._) {
+      case "updates.differenceEmpty":
+        log.debug("updates.getDifference returned updates.differenceEmpty");
+        return;
+      case "updates.differenceTooLong":
+        this.pts = diff.pts;
+        log.debug("updates.getDifference returned updates.differenceTooLong");
+        return;
+    }
+    const fetchedState = diff._ === "updates.difference" ? diff.state : diff.intermediateState;
+    log.debug(
+      "updates.getDifference returned %d messages, %d updates. new pts: %d, qts: %d, seq: %d, final: %b",
+      diff.newMessages.length,
+      diff.otherUpdates.length,
+      fetchedState.pts,
+      fetchedState.qts,
+      fetchedState.seq,
+      diff._ === "updates.difference"
+    );
+    const peers = peersIndex.PeersIndex.from(diff);
+    diff.newMessages.forEach((message) => {
+      log.debug("processing message %d in %j (%s) from common diff", message.id, message.peerId, message._);
+      if (message._ === "messageEmpty") return;
+      pendingUnorderedUpdates.pushBack(utils$2.toPendingUpdate(utils$2.messageToUpdate(message), peers, true));
+    });
+    diff.otherUpdates.forEach((upd) => {
+      if (upd._ === "updateChannelTooLong") {
+        log.debug(
+          "received updateChannelTooLong for channel %d in common diff (pts = %d), fetching diff",
+          upd.channelId,
+          upd.pts
+        );
+        this._fetchChannelDifferenceLater(requestedDiff, upd.channelId, upd.pts);
+        return;
+      }
+      if (utils$2.isMessageEmpty(upd)) return;
+      const parsed = utils$2.toPendingUpdate(upd, peers, true);
+      if (parsed.channelId && parsed.ptsBefore) {
+        pendingPtsUpdates.add(parsed);
+      } else {
+        pendingUnorderedUpdates.pushBack(parsed);
+      }
+      log.debug(
+        "received %s from common diff, cid: %d, pts_before: %d, pts: %d, qts_before: %d",
+        upd._,
+        parsed.channelId,
+        parsed.ptsBefore,
+        parsed.pts,
+        parsed.qtsBefore
+      );
+    });
+    this.pts = fetchedState.pts;
+    this.qts = fetchedState.qts;
+    this.seq = fetchedState.seq;
+    this.date = fetchedState.date;
+    if (diff._ === "updates.difference") {
+      return;
+    }
+    this.handleUpdate(UPDATES_TOO_LONG);
+  }
+  _fetchDifferenceLater(requestedDiff) {
+    if (!requestedDiff.has(0)) {
+      requestedDiff.set(
+        0,
+        this._fetchDifference(requestedDiff).catch((err) => {
+          if (tl.tl.RpcError.is(err, "AUTH_KEY_UNREGISTERED")) {
+            this.stopLoop();
+            return;
+          }
+          this.log.warn("error fetching common difference: %e", err);
+          if (tl.tl.RpcError.is(err, "PERSISTENT_TIMESTAMP_INVALID")) {
+            return this._fetchUpdatesState();
+          }
+        }).then(() => {
+          requestedDiff.delete(0);
+        })
+      );
+    }
+  }
+  async _onUpdate(pending, requestedDiff, postponed = false, unordered = false) {
+    const { client, log } = this;
+    const upd = pending.update;
+    let missing;
+    if (pending.peers.hasMin || pending.peers.empty) {
+      log.debug("loading missing peers for %s (pts = %d, cid = %d)", upd._, pending.pts, pending.channelId);
+      missing = await this._fetchMissingPeers(upd, pending.peers, pending.fromDifference);
+      if (!pending.fromDifference && missing.size) {
+        log.debug(
+          "fetching difference because some peers were min (%J) and not cached for %s (pts = %d, cid = %d)",
+          missing,
+          upd._,
+          pending.pts,
+          pending.channelId
+        );
+        if (pending.channelId && !(upd._ === "updateNewChannelMessage" && upd.message._ === "messageService")) {
+          this._fetchChannelDifferenceLater(requestedDiff, pending.channelId, pending.ptsBefore);
+        } else {
+          this._fetchDifferenceLater(requestedDiff);
+        }
+        return;
+      }
+      if (missing.size) {
+        log.debug(
+          "peers still missing after fetching difference: %J for %s (pts = %d, cid = %d)",
+          missing,
+          upd._,
+          pending.pts,
+          pending.channelId
+        );
+      }
+    }
+    if (!unordered) {
+      if (pending.pts) {
+        const localPts = pending.channelId ? this.cpts.get(pending.channelId) : this.pts;
+        if (localPts && pending.ptsBefore !== localPts) {
+          log.warn(
+            "pts_before does not match local_pts for %s (cid = %d, pts_before = %d, pts = %d, local_pts = %d)",
+            upd._,
+            pending.channelId,
+            pending.ptsBefore,
+            pending.pts,
+            localPts
+          );
+        }
+        log.debug(
+          "applying new pts (cid = %d) because received %s: %d -> %d (before: %d, count: %d) (postponed = %s)",
+          pending.channelId,
+          upd._,
+          localPts,
+          pending.pts,
+          pending.ptsBefore,
+          pending.pts - pending.ptsBefore,
+          postponed
+        );
+        if (pending.channelId) {
+          this.cpts.set(pending.channelId, pending.pts);
+          this.cptsMod.set(pending.channelId, pending.pts);
+        } else {
+          this.pts = pending.pts;
+        }
+      }
+      if (pending.qtsBefore) {
+        log.debug(
+          "applying new qts because received %s: %d -> %d (postponed = %s)",
+          upd._,
+          this.qts,
+          pending.qtsBefore + 1,
+          postponed
+        );
+        this.qts = pending.qts;
+      }
+    }
+    if (utils$2.isMessageEmpty(upd)) return;
+    switch (upd._) {
+      case "mtcute.dummyUpdate":
+        return;
+      case "updateDcOptions": {
+        const config = client.mt.network.config.getCached();
+        if (config) {
+          client.mt.network.config.setData({
+            ...config,
+            dcOptions: upd.dcOptions
+          }, config.expires * 1e3);
+        } else {
+          client.mt.network.config.update(true).catch((err) => client.onError.emit(utils.unknownToError(err)));
+        }
+        break;
+      }
+      case "updateConfig":
+        client.mt.network.config.update(true).catch((err) => client.onError.emit(utils.unknownToError(err)));
+        break;
+      case "updateUserName":
+        break;
+      case "updateDeleteChannelMessages":
+        if (!this.auth?.isBot) {
+          await client.storage.refMsgs.delete(peerUtils.toggleChannelIdMark(upd.channelId), upd.messages);
+        }
+        break;
+      case "updateNewMessage":
+      case "updateEditMessage":
+      case "updateNewChannelMessage":
+      case "updateEditChannelMessage":
+        if (!this.auth?.isBot) {
+          await this._storeMessageReferences(upd.message);
+        }
+        break;
+    }
+    if (missing?.size) {
+      if (this.auth?.isBot) {
+        this.log.warn(
+          "missing peers (%J) after getDifference for %s (pts = %d, cid = %d)",
+          missing,
+          upd._,
+          pending.pts,
+          pending.channelId
+        );
+      } else {
+        await client.mt.storage.save();
+        for (const id of missing) {
+          Promise.resolve(client.storage.peers.getById(id)).then((peer) => {
+            if (!peer) {
+              this.log.warn("cannot fetch full peer %d - getPeerById returned null", id);
+              return;
+            }
+            log.warn("cannot fetch full peer %d - unknown peer type %s", id, peer._);
+          }).catch((err) => {
+            log.warn("error fetching full peer %d: %e", id, err);
+          });
+        }
+      }
+    }
+    if (this.noDispatchEnabled) {
+      const channelId = pending.channelId ?? 0;
+      const msgId = upd._ === "updateNewMessage" || upd._ === "updateNewChannelMessage" || upd._ === "updateBotNewBusinessMessage" ? upd.message.id : void 0;
+      const foundByMsgId = msgId && this.noDispatchMsg.get(channelId)?.delete(msgId);
+      const foundByPts = this.noDispatchPts.get(channelId)?.delete(pending.pts);
+      const foundByQts = this.noDispatchQts.delete(pending.qts);
+      if (foundByMsgId || foundByPts || foundByQts) {
+        log.debug("not dispatching %s because it is in no_dispatch index", upd._);
+        return;
+      }
+    }
+    log.debug("dispatching %s (postponed = %s)", upd._, postponed);
+    client.onRawUpdate.emit(new types.RawUpdateInfo(upd, pending.peers));
+  }
+  async _loop() {
+    const {
+      log,
+      client,
+      cpts,
+      cptsMod,
+      pendingUpdateContainers,
+      pendingPtsUpdates,
+      pendingPtsUpdatesPostponed,
+      pendingQtsUpdates,
+      pendingQtsUpdatesPostponed,
+      pendingUnorderedUpdates,
+      updatesLoopCv,
+      postponedTimer
+    } = this;
+    log.debug("updates loop started, state available? %b", this.pts);
+    try {
+      if (!this.pts) {
+        await this._fetchUpdatesState();
+      }
+      while (this.updatesLoopActive) {
+        if (!(pendingUpdateContainers.length || pendingPtsUpdates.length || pendingQtsUpdates.length || pendingUnorderedUpdates.length || this.hasTimedoutPostponed)) {
+          if (this.catchingUp) {
+            this.log.debug("catching up completed");
+            this.catchingUp = false;
+            this._onCatchingUp(false);
+          }
+          await updatesLoopCv.wait();
+        }
+        if (!this.updatesLoopActive) break;
+        log.debug(
+          "updates loop tick. pending containers: %d, pts: %d, pts_postponed: %d, qts: %d, qts_postponed: %d, unordered: %d",
+          pendingUpdateContainers.length,
+          pendingPtsUpdates.length,
+          pendingPtsUpdatesPostponed.length,
+          pendingQtsUpdates.length,
+          pendingQtsUpdatesPostponed.length,
+          pendingUnorderedUpdates.length
+        );
+        const requestedDiff = /* @__PURE__ */ new Map();
+        this.log.debug("processing pending containers");
+        while (pendingUpdateContainers.length) {
+          const { upd, seqStart, seqEnd } = pendingUpdateContainers.popFront();
+          switch (upd._) {
+            case "updatesTooLong":
+              log.debug("received updatesTooLong, fetching difference");
+              this._fetchDifferenceLater(requestedDiff);
+              break;
+            case "updatesCombined":
+            case "updates": {
+              if (seqStart !== 0) {
+                const nextLocalSeq = this.seq + 1;
+                log.debug(
+                  "received seq-ordered %s (seq_start = %d, seq_end = %d, size = %d)",
+                  upd._,
+                  seqStart,
+                  seqEnd,
+                  upd.updates.length
+                );
+                if (nextLocalSeq > seqStart) {
+                  log.debug(
+                    "ignoring updates group because already applied (by seq: exp %d, got %d)",
+                    nextLocalSeq,
+                    seqStart
+                  );
+                  continue;
+                }
+                if (nextLocalSeq < seqStart) {
+                  log.debug(
+                    "fetching difference because gap detected (by seq: exp %d, got %d)",
+                    nextLocalSeq,
+                    seqStart
+                  );
+                  this._fetchDifferenceLater(requestedDiff);
+                }
+              } else {
+                log.debug("received %s (size = %d)", upd._, upd.updates.length);
+              }
+              await client.storage.peers.updatePeersFrom(upd);
+              const peers = peersIndex.PeersIndex.from(upd);
+              for (const update of upd.updates) {
+                switch (update._) {
+                  case "updateChannelTooLong":
+                    log.debug(
+                      "received updateChannelTooLong for channel %d (pts = %d) in container, fetching diff",
+                      update.channelId,
+                      update.pts
+                    );
+                    this._fetchChannelDifferenceLater(requestedDiff, update.channelId, update.pts);
+                    continue;
+                  case "updatePtsChanged":
+                    if (client.mt.network.getPoolSize("main") > 1) {
+                      log.debug(
+                        "updatePtsChanged received, resetting pts to 1 and fetching difference"
+                      );
+                      this.pts = 1;
+                      this._fetchDifferenceLater(requestedDiff);
+                    } else {
+                      log.debug("updatePtsChanged received, fetching updates state");
+                      await this._fetchUpdatesState();
+                    }
+                    continue;
+                }
+                const parsed = utils$2.toPendingUpdate(update, peers);
+                if (parsed.ptsBefore !== void 0) {
+                  pendingPtsUpdates.add(parsed);
+                } else if (parsed.qtsBefore !== void 0) {
+                  pendingQtsUpdates.add(parsed);
+                } else {
+                  pendingUnorderedUpdates.pushBack(parsed);
+                }
+              }
+              if (seqEnd !== 0 && seqEnd > this.seq) {
+                this.seq = seqEnd;
+                this.date = upd.date;
+              }
+              break;
+            }
+            case "updateShort": {
+              log.debug("received short %s", upd._);
+              const parsed = utils$2.toPendingUpdate(upd.update, new peersIndex.PeersIndex());
+              if (parsed.ptsBefore !== void 0) {
+                pendingPtsUpdates.add(parsed);
+              } else if (parsed.qtsBefore !== void 0) {
+                pendingQtsUpdates.add(parsed);
+              } else {
+                pendingUnorderedUpdates.pushBack(parsed);
+              }
+              break;
+            }
+            case "updateShortMessage": {
+              log.debug("received updateShortMessage");
+              const message = {
+                _: "message",
+                out: upd.out,
+                mentioned: upd.mentioned,
+                mediaUnread: upd.mediaUnread,
+                silent: upd.silent,
+                id: upd.id,
+                fromId: {
+                  _: "peerUser",
+                  userId: upd.out ? this.auth.userId : upd.userId
+                },
+                peerId: {
+                  _: "peerUser",
+                  userId: upd.userId
+                },
+                fwdFrom: upd.fwdFrom,
+                viaBotId: upd.viaBotId,
+                replyTo: upd.replyTo,
+                date: upd.date,
+                message: upd.message,
+                entities: upd.entities,
+                ttlPeriod: upd.ttlPeriod
+              };
+              const update = {
+                _: "updateNewMessage",
+                message,
+                pts: upd.pts,
+                ptsCount: upd.ptsCount
+              };
+              pendingPtsUpdates.add({
+                update,
+                ptsBefore: upd.pts - upd.ptsCount,
+                pts: upd.pts,
+                peers: new peersIndex.PeersIndex(),
+                fromDifference: false
+              });
+              break;
+            }
+            case "updateShortChatMessage": {
+              log.debug("received updateShortChatMessage");
+              const message = {
+                _: "message",
+                out: upd.out,
+                mentioned: upd.mentioned,
+                mediaUnread: upd.mediaUnread,
+                silent: upd.silent,
+                id: upd.id,
+                fromId: {
+                  _: "peerUser",
+                  userId: upd.fromId
+                },
+                peerId: {
+                  _: "peerChat",
+                  chatId: upd.chatId
+                },
+                fwdFrom: upd.fwdFrom,
+                viaBotId: upd.viaBotId,
+                replyTo: upd.replyTo,
+                date: upd.date,
+                message: upd.message,
+                entities: upd.entities,
+                ttlPeriod: upd.ttlPeriod
+              };
+              const update = {
+                _: "updateNewMessage",
+                message,
+                pts: upd.pts,
+                ptsCount: upd.ptsCount
+              };
+              pendingPtsUpdates.add({
+                update,
+                ptsBefore: upd.pts - upd.ptsCount,
+                pts: upd.pts,
+                peers: new peersIndex.PeersIndex(),
+                fromDifference: false
+              });
+              break;
+            }
+            case "updateShortSentMessage": {
+              log.warn("received updateShortSentMessage");
+              break;
+            }
+            default:
+              utils$1.assertNever(upd);
+          }
+        }
+        this.log.debug("processing pending pts-ordered updates");
+        while (pendingPtsUpdates.length) {
+          const pending = pendingPtsUpdates.popFront();
+          const upd = pending.update;
+          let localPts = null;
+          if (!pending.channelId) {
+            localPts = this.pts;
+          } else if (cpts.has(pending.channelId)) {
+            localPts = cpts.get(pending.channelId);
+          } else if (this.catchingUp) {
+            const saved = await client.storage.updates.getChannelPts(pending.channelId);
+            if (saved) {
+              cpts.set(pending.channelId, saved);
+              localPts = saved;
+            }
+          }
+          if (localPts) {
+            const diff = localPts - pending.ptsBefore;
+            const isPtsDrop = diff > 1000009;
+            if (diff > 0 && !isPtsDrop) {
+              log.debug(
+                "ignoring %s (cid = %d) because already applied (by pts: exp %d, got %d)",
+                upd._,
+                pending.channelId,
+                localPts,
+                pending.ptsBefore
+              );
+              continue;
+            }
+            if (diff < 0) {
+              if (diff > -3) {
+                log.debug(
+                  "postponing %s for 0.5s (cid = %d) because small gap detected (by pts: exp %d, got %d, diff=%d)",
+                  upd._,
+                  pending.channelId,
+                  localPts,
+                  pending.ptsBefore,
+                  diff
+                );
+                pending.timeout = Date.now() + 500;
+                pendingPtsUpdatesPostponed.add(pending);
+                postponedTimer.emitBefore(pending.timeout);
+              } else if (diff > -1e6) {
+                log.debug(
+                  "fetching difference after %s (cid = %d) because pts gap detected (by pts: exp %d, got %d, diff=%d)",
+                  upd._,
+                  pending.channelId,
+                  localPts,
+                  pending.ptsBefore,
+                  diff
+                );
+                if (pending.channelId) {
+                  this._fetchChannelDifferenceLater(requestedDiff, pending.channelId);
+                } else {
+                  this._fetchDifferenceLater(requestedDiff);
+                }
+              } else {
+                log.debug(
+                  "skipping all updates because pts gap is too big (by pts: exp %d, got %d, diff=%d)",
+                  localPts,
+                  pending.ptsBefore,
+                  diff
+                );
+                if (pending.channelId) {
+                  cpts.set(pending.channelId, 0);
+                  cptsMod.set(pending.channelId, 0);
+                } else {
+                  await this._fetchUpdatesState();
+                }
+              }
+              continue;
+            }
+            if (isPtsDrop) {
+              log.debug("pts drop detected (%d -> %d)", localPts, pending.ptsBefore);
+            }
+          }
+          await this._onUpdate(pending, requestedDiff);
+        }
+        this.log.debug("processing postponed pts-ordered updates");
+        for (let item = pendingPtsUpdatesPostponed._first; item; item = item.n) {
+          const pending = item.v;
+          const upd = pending.update;
+          let localPts;
+          if (!pending.channelId) {
+            localPts = this.pts;
+          } else if (cpts.has(pending.channelId)) {
+            localPts = cpts.get(pending.channelId);
+          }
+          if (!localPts) {
+            log.warn(
+              "local pts not available for postponed %s (cid = %d), skipping",
+              upd._,
+              pending.channelId
+            );
+            continue;
+          }
+          if (localPts > pending.ptsBefore) {
+            log.debug(
+              "ignoring postponed %s (cid = %d) because already applied (by pts: exp %d, got %d)",
+              upd._,
+              pending.channelId,
+              localPts,
+              pending.ptsBefore
+            );
+            pendingPtsUpdatesPostponed._remove(item);
+            continue;
+          }
+          if (localPts < pending.ptsBefore) {
+            const now = Date.now();
+            if (now < pending.timeout) {
+              log.debug(
+                "postponed %s (cid = %d) is still waiting (%dms left) (current pts %d, need %d)",
+                upd._,
+                pending.channelId,
+                pending.timeout - now,
+                localPts,
+                pending.ptsBefore
+              );
+            } else {
+              log.debug(
+                "gap for postponed %s (cid = %d) wasn't filled, fetching diff (current pts %d, need %d)",
+                upd._,
+                pending.channelId,
+                localPts,
+                pending.ptsBefore
+              );
+              pendingPtsUpdatesPostponed._remove(item);
+              if (pending.channelId) {
+                this._fetchChannelDifferenceLater(requestedDiff, pending.channelId);
+              } else {
+                this._fetchDifferenceLater(requestedDiff);
+              }
+            }
+            continue;
+          }
+          await this._onUpdate(pending, requestedDiff, true);
+          pendingPtsUpdatesPostponed._remove(item);
+        }
+        this.log.debug("processing pending qts-ordered updates");
+        while (pendingQtsUpdates.length) {
+          const pending = pendingQtsUpdates.popFront();
+          const upd = pending.update;
+          const diff = this.qts - pending.qtsBefore;
+          const isQtsDrop = diff > 1000009;
+          if (diff > 0 && !isQtsDrop) {
+            log.debug(
+              "ignoring %s because already applied (by qts: exp %d, got %d)",
+              upd._,
+              this.qts,
+              pending.qtsBefore
+            );
+            continue;
+          }
+          if (this.qts < pending.qtsBefore) {
+            if (diff > -3) {
+              log.debug(
+                "postponing %s for 0.5s because small gap detected (by qts: exp %d, got %d, diff=%d)",
+                upd._,
+                this.qts,
+                pending.qtsBefore,
+                diff
+              );
+              pending.timeout = Date.now() + 500;
+              pendingQtsUpdatesPostponed.add(pending);
+              postponedTimer.emitBefore(pending.timeout);
+            } else {
+              log.debug(
+                "fetching difference after %s because qts gap detected (by qts: exp %d, got %d, diff=%d)",
+                upd._,
+                this.qts,
+                pending.qtsBefore,
+                diff
+              );
+              this._fetchDifferenceLater(requestedDiff);
+            }
+            continue;
+          }
+          if (isQtsDrop) {
+            log.debug("qts drop detected (%d -> %d)", this.qts, pending.qtsBefore);
+          }
+          await this._onUpdate(pending, requestedDiff);
+        }
+        this.log.debug("processing postponed qts-ordered updates");
+        for (let item = pendingQtsUpdatesPostponed._first; item; item = item.n) {
+          const pending = item.v;
+          const upd = pending.update;
+          if (this.qts > pending.qtsBefore) {
+            log.debug(
+              "ignoring postponed %s because already applied (by qts: exp %d, got %d)",
+              upd._,
+              this.qts,
+              pending.qtsBefore
+            );
+            continue;
+          }
+          if (this.qts < pending.qtsBefore) {
+            const now = Date.now();
+            if (now < pending.timeout) {
+              log.debug(
+                "postponed %s is still waiting (%dms left) (current qts %d, need %d)",
+                upd._,
+                pending.timeout - now,
+                this.qts,
+                pending.qtsBefore
+              );
+            } else {
+              log.debug(
+                "gap for postponed %s wasn't filled, fetching diff (current qts %d, need %d)",
+                upd._,
+                this.qts,
+                pending.qtsBefore
+              );
+              pendingQtsUpdatesPostponed._remove(item);
+              this._fetchDifferenceLater(requestedDiff);
+            }
+            continue;
+          }
+          await this._onUpdate(pending, requestedDiff, true);
+          pendingQtsUpdatesPostponed._remove(item);
+        }
+        this.hasTimedoutPostponed = false;
+        while (requestedDiff.size) {
+          log.debug(
+            "waiting for %d pending diffs before processing unordered: %J",
+            requestedDiff.size,
+            requestedDiff.keys()
+          );
+          await Promise.all([...requestedDiff.values()]);
+          log.debug(
+            "pending diffs awaited, new diffs requested: %d (%J)",
+            requestedDiff.size,
+            requestedDiff.keys()
+          );
+        }
+        this.log.debug("processing pending unordered updates");
+        while (pendingUnorderedUpdates.length) {
+          const pending = pendingUnorderedUpdates.popFront();
+          await this._onUpdate(pending, requestedDiff, false, true);
+        }
+        while (requestedDiff.size) {
+          log.debug(
+            "waiting for %d pending diffs after processing unordered: %J",
+            requestedDiff.size,
+            requestedDiff.keys()
+          );
+          await Promise.all([...requestedDiff.values()]);
+          log.debug(
+            "pending diffs awaited, new diffs requested: %d (%j)",
+            requestedDiff.size,
+            requestedDiff.keys()
+          );
+        }
+        await this._saveUpdatesStorage(true);
+      }
+      log.debug("updates loop stopped");
+    } catch (e) {
+      log.error("updates loop encountered error, restarting: %s", e);
+      return this._loop();
+    }
+  }
+}
+exports.UpdatesManager = UpdatesManager;