stream-chat 9.20.3 → 9.22.0

package/dist/cjs/index.browser.js

@@ -96,7 +96,9 @@ __export(index_exports, {
   MergedStateStore: () => MergedStateStore,
   MessageComposer: () => MessageComposer,
   MessageComposerMiddlewareExecutor: () => MessageComposerMiddlewareExecutor,
+  MessageDeliveryReporter: () => MessageDeliveryReporter,
   MessageDraftComposerMiddlewareExecutor: () => MessageDraftComposerMiddlewareExecutor,
+  MessageReceiptsTracker: () => MessageReceiptsTracker,
   MessageSearchSource: () => MessageSearchSource,
   MiddlewareExecutor: () => MiddlewareExecutor,
   MinPriority: () => MinPriority,
@@ -1147,6 +1149,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) {
     /**
@@ -1225,6 +1242,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 = {};
@@ -1750,6 +1783,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) {
@@ -1769,35 +1821,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);
       }
@@ -5811,19 +5905,20 @@ var TextComposer = class {
       selection
     }) => {
       if (!this.enabled) return;
+      const normalizedText = text.replace(/\r\n/g, "\n");
       const finalSelection = selection ?? this.selection;
       const { maxLengthOnEdit } = this.composer.config.text ?? {};
       const currentText = this.text;
       const textBeforeTrim = [
         currentText.slice(0, finalSelection.start),
-        text,
+        normalizedText,
         currentText.slice(finalSelection.end)
       ].join("");
       const finalText = textBeforeTrim.slice(
         0,
         typeof maxLengthOnEdit === "number" ? maxLengthOnEdit : textBeforeTrim.length
       );
-      const expectedCursorPosition = finalSelection.start + text.length;
+      const expectedCursorPosition = finalSelection.start + normalizedText.length;
       const cursorPosition = Math.min(expectedCursorPosition, finalText.length);
       await this.handleChange({
         text: finalText,
@@ -6329,7 +6424,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(),
@@ -6857,12 +6952,9 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         );
         this.initState({ composition: draft });
       } catch (error) {
-        this.client.notifications.add({
-          message: "Failed to get the draft",
-          origin: {
-            emitter: "MessageComposer",
-            context: { composer: this }
-          }
+        this.client.logger("error", `messageComposer:getDraft`, {
+          tags: ["channel", "messageComposer"],
+          error
         });
       }
     };
@@ -7062,6 +7154,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 {
   /**
@@ -7143,6 +7673,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
@@ -7952,15 +8488,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
@@ -8268,6 +8813,7 @@ var Channel = class {
       }),
       { method: "upsertChannels" }
     );
+    this.getClient().syncDeliveredCandidates([this]);
     return state;
   }
   /**
@@ -8539,17 +9085,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) {
@@ -8583,7 +9156,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);
@@ -8599,7 +9173,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;
@@ -8609,6 +9185,7 @@ var Channel = class {
           if (this._countMessageAsUnread(event.message)) {
             channelState.unreadCount = channelState.unreadCount + 1;
           }
+          client.syncDeliveredCandidates([this]);
         }
         break;
       case "message.updated":
@@ -8691,9 +9268,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,
@@ -8701,6 +9281,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":
@@ -8841,6 +9426,8 @@ var Channel = class {
     if (state.read) {
       for (const read of state.read) {
         this.state.read[read.user.id] = {
+          last_delivered_at: read.last_delivered_at ? new Date(read.last_delivered_at) : void 0,
+          last_delivered_message_id: read.last_delivered_message_id,
           last_read: new Date(read.last_read),
           last_read_message_id: read.last_read_message_id,
           unread_messages: read.unread_messages ?? 0,
@@ -8850,6 +9437,7 @@ var Channel = class {
           this.state.unreadCount = this.state.read[read.user.id].unread_messages;
         }
       }
+      this.messageReceiptsTracker.ingestInitial(state.read);
     }
     return {
       messageSet
@@ -12400,6 +12988,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) {
@@ -13070,6 +13659,7 @@ var StreamChat = class _StreamChat {
       c.messageComposer.initStateFromChannelResponse(channelState);
       channels.push(c);
     }
+    this.syncDeliveredCandidates(channels);
     return channels;
   }
   /**
@@ -13834,10 +14424,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 });
@@ -13846,7 +14452,7 @@ var StreamChat = class _StreamChat {
           {
             task: {
               messageId: messageID,
-              payload: [messageID, hardDelete],
+              payload: [messageID, options],
               type: "delete-message"
             }
           }
@@ -13858,17 +14464,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
@@ -14004,7 +14620,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.20.3";
+    const version = "9.22.0";
     const clientBundle = "browser-cjs";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -15152,6 +15768,22 @@ var StreamChat = class _StreamChat {
   deleteImage(url) {
     return this.delete(`${this.baseURL}/uploads/image`, { url });
   }
+  /**
+   * Send the mark delivered event for this user
+   *
+   * @param {MarkDeliveredOptions} data
+   * @return {Promise<EventAPIResponse | void>} Description
+   */
+  async markChannelsDelivered(data) {
+    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
@@ -15178,6 +15810,7 @@ var EVENT_MAP = {
   "message.undeleted": true,
   "notification.added_to_channel": true,
   "notification.channel_deleted": true,
+  "message.delivered": true,
   "notification.channel_mutes_updated": true,
   "notification.channel_truncated": true,
   "notification.invite_accepted": true,
@@ -15187,6 +15820,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,
@@ -15197,6 +15831,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,
@@ -15221,12 +15858,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