stream-chat 9.21.0 → 9.22.1

package/dist/esm/index.mjs

@@ -30,6 +30,12 @@ var require_https = __commonJS({
   }
 });
 
+// (disabled):node_modules/jsonwebtoken/index.js
+var require_jsonwebtoken = __commonJS({
+  "(disabled):node_modules/jsonwebtoken/index.js"() {
+  }
+});
+
 // (disabled):crypto
 var require_crypto = __commonJS({
   "(disabled):crypto"() {
@@ -968,6 +974,21 @@ var runDetached = (callback, options) => {
 };
 
 // src/channel_state.ts
+var messageSetBounds = (a, b) => ({
+  newestMessageA: new Date(a[0]?.created_at ?? 0),
+  oldestMessageA: new Date(a.slice(-1)[0]?.created_at ?? 0),
+  newestMessageB: new Date(b[0]?.created_at ?? 0),
+  oldestMessageB: new Date(b.slice(-1)[0]?.created_at ?? 0)
+});
+var aContainsOrEqualsB = (a, b) => {
+  const { newestMessageA, newestMessageB, oldestMessageA, oldestMessageB } = messageSetBounds(a, b);
+  return newestMessageA >= newestMessageB && oldestMessageB >= oldestMessageA;
+};
+var aOverlapsB = (a, b) => {
+  const { newestMessageA, newestMessageB, oldestMessageA, oldestMessageB } = messageSetBounds(a, b);
+  return oldestMessageA < oldestMessageB && oldestMessageB < newestMessageA && newestMessageA < newestMessageB;
+};
+var messageSetsOverlapByTimestamp = (a, b) => aContainsOrEqualsB(a, b) || aContainsOrEqualsB(b, a) || aOverlapsB(a, b) || aOverlapsB(b, a);
 var ChannelState = class {
   constructor(channel) {
     /**
@@ -1046,6 +1067,22 @@ var ChannelState = class {
         deletedAt: deletedAt ?? null
       });
     };
+    /**
+     * Identifies the set index into which a message set would pertain if its first item's creation date corresponded to oldestTimestampMs.
+     * @param oldestTimestampMs
+     */
+    this.findMessageSetByOldestTimestamp = (oldestTimestampMs) => {
+      let lo = 0, hi = this.messageSets.length;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        const msgSet = this.messageSets[mid];
+        if (msgSet.messages.length === 0) return -1;
+        const oldestMessageTimestampInSet = msgSet.messages[0].created_at.getTime();
+        if (oldestMessageTimestampInSet <= oldestTimestampMs) hi = mid;
+        else lo = mid + 1;
+      }
+      return lo;
+    };
     this._channel = channel;
     this.watcher_count = 0;
     this.typing = {};
@@ -1571,6 +1608,25 @@ var ChannelState = class {
     }
     return this.messageSets[messageSetIndex].messages.find((m) => m.id === messageId);
   }
+  findMessageByTimestamp(timestampMs, parentMessageId, exactTsMatch = false) {
+    if (parentMessageId && !this.threads[parentMessageId] || this.messageSets.length === 0)
+      return null;
+    const setIndex = this.findMessageSetByOldestTimestamp(timestampMs);
+    const targetMsgSet = this.messageSets[setIndex]?.messages;
+    if (!targetMsgSet?.length) return null;
+    const firstMsgTimestamp = targetMsgSet[0].created_at.getTime();
+    const lastMsgTimestamp = targetMsgSet.slice(-1)[0].created_at.getTime();
+    const isOutOfBound = timestampMs < firstMsgTimestamp || lastMsgTimestamp < timestampMs;
+    if (isOutOfBound && exactTsMatch) return null;
+    let msgIndex = 0, hi = targetMsgSet.length - 1;
+    while (msgIndex < hi) {
+      const mid = msgIndex + hi >>> 1;
+      if (timestampMs <= targetMsgSet[mid].created_at.getTime()) hi = mid;
+      else msgIndex = mid + 1;
+    }
+    const foundMessage = targetMsgSet[msgIndex];
+    return !exactTsMatch ? foundMessage : foundMessage.created_at.getTime() === timestampMs ? foundMessage : null;
+  }
   switchToMessageSet(index) {
     const currentMessages = this.messageSets.find((s) => s.isCurrent);
     if (!currentMessages) {
@@ -1590,35 +1646,77 @@ var ChannelState = class {
   findTargetMessageSet(newMessages, addIfDoesNotExist = true, messageSetToAddToIfDoesNotExist = "current") {
     let messagesToAdd = newMessages;
     let targetMessageSetIndex;
+    if (newMessages.length === 0)
+      return { targetMessageSetIndex: 0, messagesToAdd: newMessages };
     if (addIfDoesNotExist) {
-      const overlappingMessageSetIndices = this.messageSets.map((_, i) => i).filter(
+      const overlappingMessageSetIndicesByMsgIds = this.messageSets.map((_, i) => i).filter(
         (i) => this.areMessageSetsOverlap(this.messageSets[i].messages, newMessages)
       );
+      const overlappingMessageSetIndicesByTimestamp = this.messageSets.map((_, i) => i).filter(
+        (i) => messageSetsOverlapByTimestamp(
+          this.messageSets[i].messages,
+          newMessages.map(formatMessage)
+        )
+      );
       switch (messageSetToAddToIfDoesNotExist) {
         case "new":
-          if (overlappingMessageSetIndices.length > 0) {
-            targetMessageSetIndex = overlappingMessageSetIndices[0];
+          if (overlappingMessageSetIndicesByMsgIds.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByMsgIds[0];
+          } else if (overlappingMessageSetIndicesByTimestamp.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByTimestamp[0];
           } else if (newMessages.some((m) => !m.parent_id)) {
-            this.messageSets.push({
-              messages: [],
-              isCurrent: false,
-              isLatest: false,
-              pagination: DEFAULT_MESSAGE_SET_PAGINATION
-            });
-            targetMessageSetIndex = this.messageSets.length - 1;
+            const setIngestIndex = this.findMessageSetByOldestTimestamp(
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              new Date(newMessages[0].created_at).getTime()
+            );
+            if (setIngestIndex === -1) {
+              this.messageSets.push({
+                messages: [],
+                isCurrent: false,
+                isLatest: false,
+                pagination: DEFAULT_MESSAGE_SET_PAGINATION
+              });
+              targetMessageSetIndex = this.messageSets.length - 1;
+            } else {
+              const isLatest = setIngestIndex === 0;
+              this.messageSets.splice(setIngestIndex, 0, {
+                messages: [],
+                isCurrent: false,
+                isLatest,
+                pagination: DEFAULT_MESSAGE_SET_PAGINATION
+                // fixme: it is problematic decide about pagination without having data
+              });
+              if (isLatest) {
+                this.messageSets.slice(1).forEach((set) => {
+                  set.isLatest = false;
+                });
+              }
+              targetMessageSetIndex = setIngestIndex;
+            }
           }
           break;
         case "current":
-          targetMessageSetIndex = this.messageSets.findIndex((s) => s.isCurrent);
+          if (overlappingMessageSetIndicesByTimestamp.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByTimestamp[0];
+          } else {
+            targetMessageSetIndex = this.messageSets.findIndex((s) => s.isCurrent);
+          }
           break;
         case "latest":
-          targetMessageSetIndex = this.messageSets.findIndex((s) => s.isLatest);
+          if (overlappingMessageSetIndicesByTimestamp.length > 0) {
+            targetMessageSetIndex = overlappingMessageSetIndicesByTimestamp[0];
+          } else {
+            targetMessageSetIndex = this.messageSets.findIndex((s) => s.isLatest);
+          }
           break;
         default:
           targetMessageSetIndex = -1;
       }
-      const mergeTargetMessageSetIndex = overlappingMessageSetIndices.splice(0, 1)[0];
-      const mergeSourceMessageSetIndices = [...overlappingMessageSetIndices];
+      const mergeTargetMessageSetIndex = overlappingMessageSetIndicesByMsgIds.splice(
+        0,
+        1
+      )[0];
+      const mergeSourceMessageSetIndices = [...overlappingMessageSetIndicesByMsgIds];
       if (mergeTargetMessageSetIndex !== void 0 && mergeTargetMessageSetIndex !== targetMessageSetIndex) {
         mergeSourceMessageSetIndices.push(targetMessageSetIndex);
       }
@@ -6151,7 +6249,7 @@ var Thread = class extends WithSubscriptions {
       if (this.ownUnreadCount === 0 && !force) {
         return null;
       }
-      return await this.channel.markRead({ thread_id: this.id });
+      return await this.client.messageDeliveryReporter.markRead(this);
     };
     this.throttledMarkAsRead = throttle(
       () => this.markAsRead(),
@@ -6881,6 +6979,444 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
 _MessageComposer.generateId = generateUUIDv4;
 var MessageComposer = _MessageComposer;
 
+// src/messageDelivery/MessageDeliveryReporter.ts
+var MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD = 100;
+var MARK_AS_DELIVERED_BUFFER_TIMEOUT = 1e3;
+var MARK_AS_READ_THROTTLE_TIMEOUT2 = 1e3;
+var isChannel = (item) => item instanceof Channel;
+var isThread = (item) => item instanceof Thread;
+var MessageDeliveryReporter = class {
+  constructor({ client }) {
+    this.deliveryReportCandidates = /* @__PURE__ */ new Map();
+    this.nextDeliveryReportCandidates = /* @__PURE__ */ new Map();
+    this.markDeliveredRequestPromise = null;
+    this.markDeliveredTimeout = null;
+    /**
+     * Retrieve the reference to the latest message in the state that is nor read neither reported as delivered
+     * @param collection
+     */
+    this.getNextDeliveryReportCandidate = (collection) => {
+      const ownUserId = this.client.user?.id;
+      if (!ownUserId) return;
+      let latestMessages = [];
+      let lastDeliveredAt;
+      let lastReadAt;
+      let key = void 0;
+      if (isChannel(collection)) {
+        latestMessages = collection.state.latestMessages;
+        const ownReadState = collection.state.read[ownUserId] ?? {};
+        lastReadAt = ownReadState?.last_read;
+        lastDeliveredAt = ownReadState?.last_delivered_at;
+        key = collection.cid;
+      } else if (isThread(collection)) {
+        latestMessages = collection.state.getLatestValue().replies;
+        const ownReadState = collection.state.getLatestValue().read[ownUserId] ?? {};
+        lastReadAt = ownReadState?.lastReadAt;
+        lastDeliveredAt = ownReadState?.lastDeliveredAt;
+        key = `${collection.channel.cid}:${collection.id}`;
+        return;
+      } else {
+        return;
+      }
+      if (!key) return;
+      const [latestMessage] = latestMessages.slice(-1);
+      const wholeCollectionIsRead = !latestMessage || lastReadAt >= latestMessage.created_at;
+      if (wholeCollectionIsRead) return { key, id: null };
+      const wholeCollectionIsMarkedDelivered = !latestMessage || (lastDeliveredAt ?? 0) >= latestMessage.created_at;
+      if (wholeCollectionIsMarkedDelivered) return { key, id: null };
+      return { key, id: latestMessage.id || null };
+    };
+    /**
+     * Fires delivery announcement request followed by immediate delivery candidate buffer reset.
+     * @param options
+     */
+    this.announceDelivery = (options) => {
+      if (this.markDeliveredRequestInFlight || !this.hasDeliveryCandidates) return;
+      const { latest_delivered_messages, sendBuffer } = this.confirmationsFromDeliveryReportCandidates();
+      if (!latest_delivered_messages.length) return;
+      const payload = { ...options, latest_delivered_messages };
+      const postFlightReconcile = () => {
+        this.markDeliveredRequestPromise = null;
+        for (const [k, v] of this.nextDeliveryReportCandidates.entries()) {
+          this.deliveryReportCandidates.set(k, v);
+        }
+        this.nextDeliveryReportCandidates = /* @__PURE__ */ new Map();
+        this.announceDeliveryBuffered(options);
+      };
+      const handleError = () => {
+        for (const [k, v] of Object.entries(sendBuffer)) {
+          if (!this.deliveryReportCandidates.has(k)) {
+            this.deliveryReportCandidates.set(k, v);
+          }
+        }
+        postFlightReconcile();
+      };
+      this.markDeliveredRequestPromise = this.client.markChannelsDelivered(payload).then(postFlightReconcile, handleError);
+    };
+    this.announceDeliveryBuffered = (options) => {
+      if (this.hasTimer || this.markDeliveredRequestInFlight || !this.hasDeliveryCandidates)
+        return;
+      this.markDeliveredTimeout = setTimeout(() => {
+        this.markDeliveredTimeout = null;
+        this.announceDelivery(options);
+      }, MARK_AS_DELIVERED_BUFFER_TIMEOUT);
+    };
+    /**
+     * Delegates the mark-read call to the Channel or Thread instance
+     * @param collection
+     * @param options
+     */
+    this.markRead = async (collection, options) => {
+      let result = null;
+      if (isChannel(collection)) {
+        result = await collection.markAsReadRequest(options);
+      } else if (isThread(collection)) {
+        result = await collection.channel.markAsReadRequest({
+          ...options,
+          thread_id: collection.id
+        });
+      }
+      this.removeCandidateFor(collection);
+      return result;
+    };
+    /**
+     * Throttles the MessageDeliveryReporter.markRead call
+     * @param collection
+     * @param options
+     */
+    this.throttledMarkRead = throttle(this.markRead, MARK_AS_READ_THROTTLE_TIMEOUT2, {
+      leading: false,
+      trailing: true
+    });
+    this.client = client;
+  }
+  get markDeliveredRequestInFlight() {
+    return this.markDeliveredRequestPromise !== null;
+  }
+  get hasTimer() {
+    return this.markDeliveredTimeout !== null;
+  }
+  get hasDeliveryCandidates() {
+    return this.deliveryReportCandidates.size > 0;
+  }
+  /**
+   * Build latest_delivered_messages payload from an arbitrary buffer (deliveryReportCandidates / nextDeliveryReportCandidates)
+   */
+  confirmationsFrom(map2) {
+    return Array.from(map2.entries()).map(([key, messageId]) => {
+      const [type, id, parent_id] = key.split(":");
+      return parent_id ? { cid: `${type}:${id}`, id: messageId, parent_id } : { cid: key, id: messageId };
+    });
+  }
+  confirmationsFromDeliveryReportCandidates() {
+    const entries = Array.from(this.deliveryReportCandidates);
+    const sendBuffer = new Map(entries.slice(0, MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD));
+    this.deliveryReportCandidates = new Map(
+      entries.slice(MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD)
+    );
+    return { latest_delivered_messages: this.confirmationsFrom(sendBuffer), sendBuffer };
+  }
+  /**
+   * Generate candidate key for storing in the candidates buffer
+   * @param collection
+   * @private
+   */
+  candidateKeyFor(collection) {
+    if (isChannel(collection)) return collection.cid;
+    if (isThread(collection)) return `${collection.channel.cid}:${collection.id}`;
+  }
+  /**
+   * Updates the delivery candidates buffer with the latest delivery candidates
+   * @param collection
+   */
+  trackDeliveredCandidate(collection) {
+    if (isChannel(collection) && !collection.getConfig()?.read_events) return;
+    if (isThread(collection) && !collection.channel.getConfig()?.read_events) return;
+    const candidate = this.getNextDeliveryReportCandidate(collection);
+    if (!candidate?.key) return;
+    const buffer = this.markDeliveredRequestInFlight ? this.nextDeliveryReportCandidates : this.deliveryReportCandidates;
+    if (candidate.id === null) buffer.delete(candidate.key);
+    else buffer.set(candidate.key, candidate.id);
+  }
+  /**
+   * Removes candidate from the delivery report buffer
+   * @param collection
+   * @private
+   */
+  removeCandidateFor(collection) {
+    const candidateKey = this.candidateKeyFor(collection);
+    if (!candidateKey) return;
+    this.deliveryReportCandidates.delete(candidateKey);
+    this.nextDeliveryReportCandidates.delete(candidateKey);
+  }
+  /**
+   * Records the latest message delivered for Channel or Thread instances and schedules the next report
+   * if not already scheduled and candidates exist.
+   * Should be used for WS handling (message.new) as well as for ingesting HTTP channel query results.
+   * @param collections
+   */
+  syncDeliveredCandidates(collections) {
+    if (this.client.user?.privacy_settings?.delivery_receipts?.enabled === false) return;
+    for (const c of collections) this.trackDeliveredCandidate(c);
+    this.announceDeliveryBuffered();
+  }
+};
+
+// src/messageDelivery/MessageReceiptsTracker.ts
+var MIN_REF = { timestampMs: Number.NEGATIVE_INFINITY, msgId: "" };
+var compareRefsAsc = (a, b) => a.timestampMs !== b.timestampMs ? a.timestampMs - b.timestampMs : 0;
+var findIndex = (arr, target, keyOf) => {
+  let lo = 0, hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (compareRefsAsc(keyOf(arr[mid]), target) >= 0) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+};
+var findUpperIndex = (arr, target, keyOf) => {
+  let lo = 0, hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (compareRefsAsc(keyOf(arr[mid]), target) > 0) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+};
+var insertByKey = (arr, item, keyOf) => arr.splice(findUpperIndex(arr, keyOf(item), keyOf), 0, item);
+var removeByOldKey = (arr, item, oldKey, keyOf) => {
+  let i = findIndex(arr, oldKey, keyOf);
+  while (i < arr.length && compareRefsAsc(keyOf(arr[i]), oldKey) === 0) {
+    if (arr[i].user.id === item.user.id) {
+      arr.splice(i, 1);
+      return;
+    }
+    i++;
+  }
+};
+var MessageReceiptsTracker = class {
+  constructor({ locateMessage }) {
+    this.byUser = /* @__PURE__ */ new Map();
+    this.readSorted = [];
+    // asc by lastReadRef
+    this.deliveredSorted = [];
+    this.locateMessage = locateMessage;
+  }
+  /** Build initial state from server snapshots (single pass + sort). */
+  ingestInitial(responses) {
+    this.byUser.clear();
+    this.readSorted = [];
+    this.deliveredSorted = [];
+    for (const r of responses) {
+      const lastReadTimestamp = r.last_read ? new Date(r.last_read).getTime() : null;
+      const lastDeliveredTimestamp = r.last_delivered_at ? new Date(r.last_delivered_at).getTime() : null;
+      const lastReadRef = lastReadTimestamp ? this.locateMessage(lastReadTimestamp) ?? MIN_REF : MIN_REF;
+      let lastDeliveredRef = lastDeliveredTimestamp ? this.locateMessage(lastDeliveredTimestamp) ?? MIN_REF : MIN_REF;
+      const isReadAfterDelivered = compareRefsAsc(lastDeliveredRef, lastReadRef) < 0;
+      if (isReadAfterDelivered) lastDeliveredRef = lastReadRef;
+      const userProgress = { user: r.user, lastReadRef, lastDeliveredRef };
+      this.byUser.set(r.user.id, userProgress);
+      this.readSorted.splice(
+        findIndex(this.readSorted, lastReadRef, (up) => up.lastReadRef),
+        0,
+        userProgress
+      );
+      this.deliveredSorted.splice(
+        findIndex(this.deliveredSorted, lastDeliveredRef, (up) => up.lastDeliveredRef),
+        0,
+        userProgress
+      );
+    }
+  }
+  /** message.delivered — user device confirmed delivery up to and including messageId. */
+  onMessageDelivered({
+    user,
+    deliveredAt,
+    lastDeliveredMessageId
+  }) {
+    const timestampMs = new Date(deliveredAt).getTime();
+    const msgRef = lastDeliveredMessageId ? { timestampMs, msgId: lastDeliveredMessageId } : this.locateMessage(new Date(deliveredAt).getTime());
+    if (!msgRef) return;
+    const userProgress = this.ensureUser(user);
+    const newDelivered = compareRefsAsc(msgRef, userProgress.lastReadRef) < 0 ? userProgress.lastReadRef : msgRef;
+    if (compareRefsAsc(newDelivered, userProgress.lastDeliveredRef) <= 0) return;
+    removeByOldKey(
+      this.deliveredSorted,
+      userProgress,
+      userProgress.lastDeliveredRef,
+      (x) => x.lastDeliveredRef
+    );
+    userProgress.lastDeliveredRef = newDelivered;
+    insertByKey(this.deliveredSorted, userProgress, (x) => x.lastDeliveredRef);
+  }
+  /** message.read — user read up to and including messageId. */
+  onMessageRead({
+    user,
+    readAt,
+    lastReadMessageId
+  }) {
+    const timestampMs = new Date(readAt).getTime();
+    const msgRef = lastReadMessageId ? { timestampMs, msgId: lastReadMessageId } : this.locateMessage(timestampMs);
+    if (!msgRef) return;
+    const userProgress = this.ensureUser(user);
+    if (compareRefsAsc(msgRef, userProgress.lastReadRef) <= 0) return;
+    removeByOldKey(
+      this.readSorted,
+      userProgress,
+      userProgress.lastReadRef,
+      (x) => x.lastReadRef
+    );
+    userProgress.lastReadRef = msgRef;
+    insertByKey(this.readSorted, userProgress, (x) => x.lastReadRef);
+    if (compareRefsAsc(userProgress.lastDeliveredRef, userProgress.lastReadRef) < 0) {
+      removeByOldKey(
+        this.deliveredSorted,
+        userProgress,
+        userProgress.lastDeliveredRef,
+        (x) => x.lastDeliveredRef
+      );
+      userProgress.lastDeliveredRef = userProgress.lastReadRef;
+      insertByKey(this.deliveredSorted, userProgress, (x) => x.lastDeliveredRef);
+    }
+  }
+  /** notification.mark_unread — user marked messages unread starting at `first_unread_message_id`.
+   * Sets lastReadRef to the event’s last_read_* values. Delivery never moves backward.
+   * The event is sent only to the user that triggered the action (own user), so we will never adjust read ref
+   * for other users - we will not see changes in the UI for other users. However, this implementation does not
+   * take into consideration this fact and is ready to handle the mark-unread event for any user.
+   */
+  onNotificationMarkUnread({
+    user,
+    lastReadAt,
+    lastReadMessageId
+  }) {
+    const userProgress = this.ensureUser(user);
+    const newReadRef = lastReadAt ? { timestampMs: new Date(lastReadAt).getTime(), msgId: lastReadMessageId ?? "" } : { ...MIN_REF };
+    if (compareRefsAsc(newReadRef, userProgress.lastReadRef) === 0 && newReadRef.msgId === userProgress.lastReadRef.msgId) {
+      return;
+    }
+    removeByOldKey(
+      this.readSorted,
+      userProgress,
+      userProgress.lastReadRef,
+      (x) => x.lastReadRef
+    );
+    userProgress.lastReadRef = newReadRef;
+    insertByKey(this.readSorted, userProgress, (x) => x.lastReadRef);
+    if (compareRefsAsc(userProgress.lastDeliveredRef, userProgress.lastReadRef) < 0) {
+      removeByOldKey(
+        this.deliveredSorted,
+        userProgress,
+        userProgress.lastDeliveredRef,
+        (x) => x.lastDeliveredRef
+      );
+      userProgress.lastDeliveredRef = userProgress.lastReadRef;
+      insertByKey(this.deliveredSorted, userProgress, (x) => x.lastDeliveredRef);
+    }
+  }
+  /** All users who READ this message. */
+  readersForMessage(msgRef) {
+    const index = findIndex(this.readSorted, msgRef, ({ lastReadRef }) => lastReadRef);
+    return this.readSorted.slice(index).map((x) => x.user);
+  }
+  /** All users who have it DELIVERED (includes readers). */
+  deliveredForMessage(msgRef) {
+    const pos = findIndex(
+      this.deliveredSorted,
+      msgRef,
+      ({ lastDeliveredRef }) => lastDeliveredRef
+    );
+    return this.deliveredSorted.slice(pos).map((x) => x.user);
+  }
+  /** Users who delivered but have NOT read. */
+  deliveredNotReadForMessage(msgRef) {
+    const pos = findIndex(
+      this.deliveredSorted,
+      msgRef,
+      ({ lastDeliveredRef }) => lastDeliveredRef
+    );
+    const usersDeliveredNotRead = [];
+    for (let i = pos; i < this.deliveredSorted.length; i++) {
+      const userProgress = this.deliveredSorted[i];
+      if (compareRefsAsc(userProgress.lastReadRef, msgRef) < 0)
+        usersDeliveredNotRead.push(userProgress.user);
+    }
+    return usersDeliveredNotRead;
+  }
+  /** Users for whom `msgRef` is their *last read* (exact match). */
+  usersWhoseLastReadIs(msgRef) {
+    if (!msgRef.msgId) return [];
+    const start = findIndex(this.readSorted, msgRef, (x) => x.lastReadRef);
+    const end = findUpperIndex(this.readSorted, msgRef, (x) => x.lastReadRef);
+    const users = [];
+    for (let i = start; i < end; i++) {
+      const up = this.readSorted[i];
+      if (up.lastReadRef.msgId === msgRef.msgId) users.push(up.user);
+    }
+    return users;
+  }
+  /** Users for whom `msgRef` is their *last delivered* (exact match). */
+  usersWhoseLastDeliveredIs(msgRef) {
+    if (!msgRef.msgId) return [];
+    const start = findIndex(this.deliveredSorted, msgRef, (x) => x.lastDeliveredRef);
+    const end = findUpperIndex(this.deliveredSorted, msgRef, (x) => x.lastDeliveredRef);
+    const users = [];
+    for (let i = start; i < end; i++) {
+      const up = this.deliveredSorted[i];
+      if (up.lastDeliveredRef.msgId === msgRef.msgId) users.push(up.user);
+    }
+    return users;
+  }
+  // ---- queries: per-user status ----
+  hasUserRead(msgRef, userId) {
+    const up = this.byUser.get(userId);
+    return !!up && compareRefsAsc(up.lastReadRef, msgRef) >= 0;
+  }
+  hasUserDelivered(msgRef, userId) {
+    const up = this.byUser.get(userId);
+    return !!up && compareRefsAsc(up.lastDeliveredRef, msgRef) >= 0;
+  }
+  getUserProgress(userId) {
+    const userProgress = this.byUser.get(userId);
+    if (!userProgress) return null;
+    return userProgress;
+  }
+  groupUsersByLastReadMessage() {
+    return Array.from(this.byUser.values()).reduce(
+      (acc, userProgress) => {
+        const msgId = userProgress.lastReadRef.msgId;
+        if (!msgId) return acc;
+        if (!acc[msgId]) acc[msgId] = [];
+        acc[msgId].push(userProgress.user);
+        return acc;
+      },
+      {}
+    );
+  }
+  groupUsersByLastDeliveredMessage() {
+    return Array.from(this.byUser.values()).reduce(
+      (acc, userProgress) => {
+        const msgId = userProgress.lastDeliveredRef.msgId;
+        if (!msgId) return acc;
+        if (!acc[msgId]) acc[msgId] = [];
+        acc[msgId].push(userProgress.user);
+        return acc;
+      },
+      {}
+    );
+  }
+  ensureUser(user) {
+    let up = this.byUser.get(user.id);
+    if (!up) {
+      up = { user, lastReadRef: MIN_REF, lastDeliveredRef: MIN_REF };
+      this.byUser.set(user.id, up);
+      insertByKey(this.readSorted, up, (x) => x.lastReadRef);
+      insertByKey(this.deliveredSorted, up, (x) => x.lastDeliveredRef);
+    }
+    return up;
+  }
+};
+
 // src/channel.ts
 var Channel = class {
   /**
@@ -6962,6 +7498,12 @@ var Channel = class {
       client: this._client,
       compositionContext: this
     });
+    this.messageReceiptsTracker = new MessageReceiptsTracker({
+      locateMessage: (timestampMs) => {
+        const msg = this.state.findMessageByTimestamp(timestampMs);
+        return msg && { timestampMs, msgId: msg.id };
+      }
+    });
   }
   /**
    * getClient - Get the chat client for this channel. If client.disconnect() was called, this function will error
@@ -7771,15 +8313,24 @@ var Channel = class {
     return messageSlice[0];
   }
   /**
-   * markRead - Send the mark read event for this user, only works if the `read_events` setting is enabled
+   * markRead - Send the mark read event for this user, only works if the `read_events` setting is enabled. Syncs the message delivery report candidates local state.
    *
    * @param {MarkReadOptions} data
    * @return {Promise<EventAPIResponse | null>} Description
    */
   async markRead(data = {}) {
+    return await this.getClient().messageDeliveryReporter.markRead(this, data);
+  }
+  /**
+   * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is enabled
+   *
+   * @param {MarkReadOptions} data
+   * @return {Promise<EventAPIResponse | null>} Description
+   */
+  async markAsReadRequest(data = {}) {
     this._checkInitialized();
     if (!this.getConfig()?.read_events && !this.getClient()._isUsingServerAuth()) {
-      return Promise.resolve(null);
+      return null;
     }
     return await this.getClient().post(this._channelURL() + "/read", {
       ...data
@@ -8087,6 +8638,7 @@ var Channel = class {
       }),
       { method: "upsertChannels" }
     );
+    this.getClient().syncDeliveredCandidates([this]);
     return state;
   }
   /**
@@ -8358,17 +8910,44 @@ var Channel = class {
         break;
       case "message.read":
         if (event.user?.id && event.created_at) {
+          const previousReadState = channelState.read[event.user.id];
           channelState.read[event.user.id] = {
+            // in case we already have delivery information
+            ...previousReadState,
             last_read: new Date(event.created_at),
             last_read_message_id: event.last_read_message_id,
             user: event.user,
             unread_messages: 0
           };
-          if (event.user?.id === this.getClient().user?.id) {
+          this.messageReceiptsTracker.onMessageRead({
+            user: event.user,
+            readAt: event.created_at,
+            lastReadMessageId: event.last_read_message_id
+          });
+          const client = this.getClient();
+          const isOwnEvent = event.user?.id === client.user?.id;
+          if (isOwnEvent) {
             channelState.unreadCount = 0;
+            client.syncDeliveredCandidates([this]);
           }
         }
         break;
+      case "message.delivered":
+        if (event.user?.id && event.created_at) {
+          const previousReadState = channelState.read[event.user.id];
+          channelState.read[event.user.id] = {
+            ...previousReadState,
+            last_delivered_at: event.last_delivered_at ? new Date(event.last_delivered_at) : void 0,
+            last_delivered_message_id: event.last_delivered_message_id,
+            user: event.user
+          };
+          this.messageReceiptsTracker.onMessageDelivered({
+            user: event.user,
+            deliveredAt: event.created_at,
+            lastDeliveredMessageId: event.last_delivered_message_id
+          });
+        }
+        break;
       case "user.watching.start":
       case "user.updated":
         if (event.user?.id) {
@@ -8402,7 +8981,8 @@ var Channel = class {
         break;
       case "message.new":
         if (event.message) {
-          const ownMessage = event.user?.id === this.getClient().user?.id;
+          const client = this.getClient();
+          const ownMessage = event.user?.id === client.user?.id;
           const isThreadMessage = event.message.parent_id && !event.message.show_in_channel;
           if (this.state.isUpToDate || isThreadMessage) {
             channelState.addMessageSorted(event.message, ownMessage);
@@ -8418,7 +8998,9 @@ var Channel = class {
                 channelState.read[event.user.id] = {
                   last_read: new Date(event.created_at),
                   user: event.user,
-                  unread_messages: 0
+                  unread_messages: 0,
+                  last_delivered_at: new Date(event.created_at),
+                  last_delivered_message_id: event.message.id
                 };
               } else {
                 channelState.read[userId].unread_messages += 1;
@@ -8428,6 +9010,7 @@ var Channel = class {
           if (this._countMessageAsUnread(event.message)) {
             channelState.unreadCount = channelState.unreadCount + 1;
           }
+          client.syncDeliveredCandidates([this]);
         }
         break;
       case "message.updated":
@@ -8510,9 +9093,12 @@ var Channel = class {
         break;
       case "notification.mark_unread": {
         const ownMessage = event.user?.id === this.getClient().user?.id;
-        if (!(ownMessage && event.user)) break;
+        if (!ownMessage || !event.user) break;
         const unreadCount = event.unread_messages ?? 0;
+        const currentState = channelState.read[event.user.id];
         channelState.read[event.user.id] = {
+          // keep the message delivery info
+          ...currentState,
           first_unread_message_id: event.first_unread_message_id,
           last_read: new Date(event.last_read_at),
           last_read_message_id: event.last_read_message_id,
@@ -8520,6 +9106,11 @@ var Channel = class {
           unread_messages: unreadCount
         };
         channelState.unreadCount = unreadCount;
+        this.messageReceiptsTracker.onNotificationMarkUnread({
+          user: event.user,
+          lastReadAt: event.last_read_at,
+          lastReadMessageId: event.last_read_message_id
+        });
         break;
       }
       case "channel.updated":
@@ -8671,6 +9262,7 @@ var Channel = class {
           this.state.unreadCount = this.state.read[read.user.id].unread_messages;
         }
       }
+      this.messageReceiptsTracker.ingestInitial(state.read);
     }
     return {
       messageSet
@@ -9280,8 +9872,8 @@ var StableWSConnection = class {
 };
 
 // src/signing.ts
+var import_jsonwebtoken = __toESM(require_jsonwebtoken());
 var import_crypto = __toESM(require_crypto());
-import jwt from "jsonwebtoken";
 function JWTUserToken(apiSecret, userId, extraData = {}, jwtOptions = {}) {
   if (typeof userId !== "string") {
     throw new TypeError("userId should be a string");
@@ -9290,7 +9882,7 @@ function JWTUserToken(apiSecret, userId, extraData = {}, jwtOptions = {}) {
     user_id: userId,
     ...extraData
   };
-  if (jwt == null || jwt.sign == null) {
+  if (import_jsonwebtoken.default == null || import_jsonwebtoken.default.sign == null) {
     throw Error(
       `Unable to find jwt crypto, if you are getting this error is probably because you are trying to generate tokens on browser or React Native (or other environment where crypto functions are not available). Please Note: token should only be generated server-side.`
     );
@@ -9302,7 +9894,7 @@ function JWTUserToken(apiSecret, userId, extraData = {}, jwtOptions = {}) {
   if (payload.iat) {
     opts.noTimestamp = false;
   }
-  return jwt.sign(payload, apiSecret, opts);
+  return import_jsonwebtoken.default.sign(payload, apiSecret, opts);
 }
 function JWTServerToken(apiSecret, jwtOptions = {}) {
   const payload = {
@@ -9312,7 +9904,7 @@ function JWTServerToken(apiSecret, jwtOptions = {}) {
     { algorithm: "HS256", noTimestamp: true },
     jwtOptions
   );
-  return jwt.sign(payload, apiSecret, opts);
+  return import_jsonwebtoken.default.sign(payload, apiSecret, opts);
 }
 function UserFromToken(token) {
   const fragments = token.split(".");
@@ -12221,6 +12813,7 @@ var StreamChat = class _StreamChat {
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
     this.reminders = new ReminderManager({ client: this });
+    this.messageDeliveryReporter = new MessageDeliveryReporter({ client: this });
   }
   static getInstance(key, secretOrOptions, options) {
     if (!_StreamChat._instance) {
@@ -12891,6 +13484,7 @@ var StreamChat = class _StreamChat {
       c.messageComposer.initStateFromChannelResponse(channelState);
       channels.push(c);
     }
+    this.syncDeliveredCandidates(channels);
     return channels;
   }
   /**
@@ -13655,10 +14249,26 @@ var StreamChat = class _StreamChat {
       }
     );
   }
-  async deleteMessage(messageID, hardDelete) {
+  /**
+   * deleteMessage - Delete a message
+   *
+   * @param {string} messageID The id of the message to delete
+   * @param {boolean | DeleteMessageOptions | undefined} [optionsOrHardDelete]
+   * @return {Promise<APIResponse & { message: MessageResponse }>} The API response
+   */
+  // fixme: remove the signature with optionsOrHardDelete boolean with the next major release
+  async deleteMessage(messageID, optionsOrHardDelete) {
+    let options = {};
+    if (typeof optionsOrHardDelete === "boolean") {
+      options = optionsOrHardDelete ? { hardDelete: true } : {};
+    } else if (optionsOrHardDelete?.deleteForMe) {
+      options = { deleteForMe: true };
+    } else if (optionsOrHardDelete?.hardDelete) {
+      options = { hardDelete: true };
+    }
     try {
       if (this.offlineDb) {
-        if (hardDelete) {
+        if (options.hardDelete) {
           await this.offlineDb.hardDeleteMessage({ id: messageID });
         } else {
           await this.offlineDb.softDeleteMessage({ id: messageID });
@@ -13667,7 +14277,7 @@ var StreamChat = class _StreamChat {
           {
             task: {
               messageId: messageID,
-              payload: [messageID, hardDelete],
+              payload: [messageID, options],
               type: "delete-message"
             }
           }
@@ -13679,17 +14289,27 @@ var StreamChat = class _StreamChat {
         error
       });
     }
-    return this._deleteMessage(messageID, hardDelete);
+    return this._deleteMessage(messageID, options);
   }
-  async _deleteMessage(messageID, hardDelete) {
+  // fixme: remove the signature with optionsOrHardDelete boolean with the next major release
+  async _deleteMessage(messageID, optionsOrHardDelete) {
+    const { deleteForMe, hardDelete } = typeof optionsOrHardDelete === "boolean" ? { hardDelete: optionsOrHardDelete } : optionsOrHardDelete ?? {};
     let params = {};
     if (hardDelete) {
       params = { hard: true };
     }
-    return await this.delete(
+    if (deleteForMe) {
+      params = { ...params, delete_for_me: true };
+    }
+    const result = await this.delete(
       this.baseURL + `/messages/${encodeURIComponent(messageID)}`,
       params
     );
+    if (deleteForMe) {
+      result.message.deleted_for_me = true;
+      result.message.type = "deleted";
+    }
+    return result;
   }
   /**
    * undeleteMessage - Undelete a message
@@ -13825,7 +14445,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.21.0";
+    const version = "9.22.1";
     const clientBundle = "browser-esm";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -14974,19 +15594,21 @@ var StreamChat = class _StreamChat {
     return this.delete(`${this.baseURL}/uploads/image`, { url });
   }
   /**
-   * Send the mark delivered event for this user, only works if the `delivery_receipts` setting is enabled
+   * Send the mark delivered event for this user
    *
    * @param {MarkDeliveredOptions} data
    * @return {Promise<EventAPIResponse | void>} Description
    */
   async markChannelsDelivered(data) {
-    const deliveryReceiptsEnabled = this.user?.privacy_settings?.delivery_receipts?.enabled;
-    if (!deliveryReceiptsEnabled) return;
+    if (!data?.latest_delivered_messages?.length) return;
     return await this.post(
       this.baseURL + "/channels/delivered",
       data ?? {}
     );
   }
+  syncDeliveredCandidates(collections) {
+    this.messageDeliveryReporter.syncDeliveredCandidates(collections);
+  }
 };
 
 // src/events.ts
@@ -15023,6 +15645,7 @@ var EVENT_MAP = {
   "notification.mark_unread": true,
   "notification.message_new": true,
   "notification.mutes_updated": true,
+  "notification.reminder_due": true,
   "notification.removed_from_channel": true,
   "notification.thread_message_new": true,
   "poll.closed": true,
@@ -15033,6 +15656,9 @@ var EVENT_MAP = {
   "reaction.deleted": true,
   "reaction.new": true,
   "reaction.updated": true,
+  "reminder.created": true,
+  "reminder.deleted": true,
+  "reminder.updated": true,
   "thread.updated": true,
   "typing.start": true,
   "typing.stop": true,
@@ -15057,12 +15683,7 @@ var EVENT_MAP = {
   "transport.changed": true,
   "capabilities.changed": true,
   "live_location_sharing.started": true,
-  "live_location_sharing.stopped": true,
-  // Reminder events
-  "reminder.created": true,
-  "reminder.updated": true,
-  "reminder.deleted": true,
-  "notification.reminder_due": true
+  "live_location_sharing.stopped": true
 };
 
 // src/permissions.ts
@@ -16219,7 +16840,9 @@ export {
   MergedStateStore,
   MessageComposer,
   MessageComposerMiddlewareExecutor,
+  MessageDeliveryReporter,
   MessageDraftComposerMiddlewareExecutor,
+  MessageReceiptsTracker,
   MessageSearchSource,
   MiddlewareExecutor,
   MinPriority,