stream-chat 10.0.0-rc.7 → 10.0.0-rc.8

package/dist/cjs/index.browser.js

@@ -51,11 +51,13 @@ __export(src_exports, {
   ChannelWatchStatus: () => ChannelWatchStatus,
   ClientState: () => ClientState,
   CommandSearchSource: () => CommandSearchSource,
+  ConnectionRecoveryManager: () => ConnectionRecoveryManager,
   CustomDataManager: () => CustomDataManager,
   DEFAULT_ATTACHMENT_MANAGER_CONFIG: () => DEFAULT_ATTACHMENT_MANAGER_CONFIG,
   DEFAULT_CHANNEL_CONFIG: () => DEFAULT_CHANNEL_CONFIG,
   DEFAULT_COMMANDS_CONFIG: () => DEFAULT_COMMANDS_CONFIG,
   DEFAULT_COMPOSER_CONFIG: () => DEFAULT_COMPOSER_CONFIG,
+  DEFAULT_CONNECTION_RECOVERY_MANAGER_CONFIG: () => DEFAULT_CONNECTION_RECOVERY_MANAGER_CONFIG,
   DEFAULT_LINK_PREVIEW_MANAGER_CONFIG: () => DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
   DEFAULT_LIVE_LOCATION_MANAGER_CONFIG: () => DEFAULT_LIVE_LOCATION_MANAGER_CONFIG,
   DEFAULT_LOCATION_COMPOSER_CONFIG: () => DEFAULT_LOCATION_COMPOSER_CONFIG,
@@ -1394,228 +1396,100 @@ var CooldownTimer = class extends WithSubscriptions {
   }
 };
 
-// src/errors.ts
-var import_axios = require("axios");
-var APIErrorCodes = {
-  "-1": { name: "InternalSystemError", retryable: true },
-  "2": { name: "AccessKeyError", retryable: false },
-  "3": { name: "AuthenticationFailedError", retryable: true },
-  "4": { name: "InputError", retryable: false },
-  "6": { name: "DuplicateUsernameError", retryable: false },
-  "9": { name: "RateLimitError", retryable: true },
-  "16": { name: "DoesNotExistError", retryable: false },
-  "17": { name: "NotAllowedError", retryable: false },
-  "18": { name: "EventNotSupportedError", retryable: false },
-  "19": { name: "ChannelFeatureNotSupportedError", retryable: false },
-  "20": { name: "MessageTooLongError", retryable: false },
-  "21": { name: "MultipleNestingLevelError", retryable: false },
-  "22": { name: "PayloadTooBigError", retryable: false },
-  "23": { name: "RequestTimeoutError", retryable: true },
-  "24": { name: "MaxHeaderSizeExceededError", retryable: false },
-  "40": { name: "AuthErrorTokenExpired", retryable: false },
-  "41": { name: "AuthErrorTokenNotValidYet", retryable: false },
-  "42": { name: "AuthErrorTokenUsedBeforeIssuedAt", retryable: false },
-  "43": { name: "AuthErrorTokenSignatureInvalid", retryable: false },
-  "44": { name: "CustomCommandEndpointMissingError", retryable: false },
-  "45": { name: "CustomCommandEndpointCallError", retryable: true },
-  "46": { name: "ConnectionIDNotFoundError", retryable: false },
-  "60": { name: "CoolDownError", retryable: true },
-  "69": { name: "ErrWrongRegion", retryable: false },
-  "70": { name: "ErrQueryChannelPermissions", retryable: false },
-  "71": { name: "ErrTooManyConnections", retryable: true },
-  "99": { name: "AppSuspendedError", retryable: false }
-};
-function isAPIError(error) {
-  return error.code !== void 0;
-}
-function isErrorRetryable(error) {
-  if (!error.code) return false;
-  const err = APIErrorCodes[`${error.code}`];
-  if (!err) return false;
-  return err.retryable;
-}
-function isEphemeral(error) {
-  if ((0, import_axios.isCancel)(error)) return false;
-  if (!error.response) return true;
-  return isErrorRetryable(error);
-}
-
-// src/entityStore/applyReactionLocally.ts
-var applyReactionLocally = (client, {
-  enforceUnique = false,
-  messageId,
-  reaction,
-  removed = false
-}) => {
-  const store = client.messageStore;
-  const user = client.user;
-  const existing = store.get(messageId);
-  if (!user || !existing) return;
-  const now = /* @__PURE__ */ new Date();
-  const reactionResponse = {
-    ...reaction,
-    created_at: reaction.created_at ?? now,
-    custom: reaction.custom ?? {},
-    message_id: messageId,
-    score: reaction.score ?? 1,
-    type: reaction.type,
-    updated_at: reaction.updated_at ?? now,
-    user,
-    user_id: user.id
-  };
-  const removedReactions = removed ? existing.own_reactions?.filter((r) => r.type === reactionResponse.type) ?? [] : enforceUnique ? existing.own_reactions ?? [] : [];
-  const withCounts = removed ? messageWithReactionRemoved(existing, reactionResponse) : messageWithReactionAdded(existing, reactionResponse, enforceUnique);
-  const own_reactions = computeOwnReactions({
-    current: existing.own_reactions ?? [],
-    enforceUnique,
-    reaction: reactionResponse,
-    removed,
-    userId: user.id
-  });
-  store.upsert({ ...withCounts, own_reactions });
-  store.flushSubscribers(messageId);
-  const persisted = store.get(messageId);
-  if (persisted) {
-    client.offlineDb?.executeQuerySafely(
-      (db) => removed ? db.deleteReaction({ message: persisted, reaction: reactionResponse }) : enforceUnique ? db.updateReaction({ message: persisted, reaction: reactionResponse }) : db.insertReaction({ message: persisted, reaction: reactionResponse }),
-      { method: "applyReactionLocally" }
+// src/offline-support/queueableOperations.ts
+var logger2 = chatLoggerSystem.getLogger("offline-db");
+var channelOf = (client, task, channel) => {
+  if (channel) return channel;
+  const { channelId, channelType } = task;
+  if (!channelType || !channelId) {
+    throw new Error(
+      `Cannot replay a "${task.type}" task without a channel type and id (message: ${task.messageId}).`
     );
   }
-  return () => {
-    if (!removed) {
-      applyReactionLocally(client, {
-        messageId,
-        reaction: reactionResponse,
-        removed: true
-      });
-    }
-    for (const removedReaction of removedReactions) {
-      applyReactionLocally(client, {
-        messageId,
-        reaction: removedReaction,
-        removed: false
-      });
-    }
-  };
+  return client.channel(channelType, channelId);
 };
-
-// src/entityStore/EntityStore.ts
-var EntityStore = class {
-  constructor({ getEntityId }) {
-    this.byId = /* @__PURE__ */ new Map();
-    this.subscribers = /* @__PURE__ */ new Map();
-    this.transactionDepth = 0;
-    this.pendingChanged = /* @__PURE__ */ new Map();
-    this.getEntityId = getEntityId;
-  }
-  // ---- reads ----
-  get(id) {
-    return typeof id === "string" ? this.byId.get(id) : void 0;
-  }
-  has(id) {
-    return this.byId.has(id);
-  }
-  // ---- writes ----
-  /**
-   * Replaces the canonical copy of `entity` and notifies every subscriber watching its id —
-   * except `subscriber`, the one that performed the write, which is expected to re-render itself
-   * (the paginator that performed the write already emits its own window inline, so it must not be
-   * notified a second time through the subscription).
-   */
-  upsert(entity, subscriber) {
-    const id = this.getEntityId(entity);
-    const previous = this.byId.get(id);
-    if (previous === entity) return;
-    this.byId.set(id, entity);
-    this.markDirty(id, subscriber);
-    this.autoFlush();
-  }
-  // ---- subscription registry / refcount ----
-  /** Registers `subscriber` for `id` (notification target + refcount). */
-  link(id, subscriber) {
-    let subscribers = this.subscribers.get(id);
-    if (!subscribers) {
-      subscribers = /* @__PURE__ */ new Set();
-      this.subscribers.set(id, subscribers);
-    }
-    subscribers.add(subscriber);
-  }
-  /** Drops `subscriber` from `id`; GCs the canonical copy when none remain. */
-  unlink(id, subscriber) {
-    const subscribers = this.subscribers.get(id);
-    if (!subscribers) return;
-    subscribers.delete(subscriber);
-    if (subscribers.size === 0) {
-      this.subscribers.delete(id);
-      this.byId.delete(id);
-    }
-  }
-  /**
-   * Sugar for atomic / ad-hoc consumers that watch a single id (e.g. a thread watching its parent
-   * message). Fires `handler` immediately with the current value (mirroring
-   * {@link StateStore.subscribe}) and on every subsequent change.
-   */
-  subscribe(id, handler) {
-    const subscriber = {
-      onEntitiesChanged: () => handler(this.byId.get(id))
-    };
-    this.link(id, subscriber);
-    handler(this.byId.get(id));
-    return () => this.unlink(id, subscriber);
+var QUEUEABLE_OPERATIONS = {
+  "create-draft": {
+    logFailureAs: {
+      message: "Creating the draft in the offline database failed.",
+      method: "createDraft"
+    },
+    run: ({ channel, client, task }) => channelOf(client, task, channel)._createDraft(...task.payload)
+  },
+  "delete-draft": {
+    logFailureAs: {
+      message: "Deleting the draft from the offline database failed.",
+      method: "deleteDraft"
+    },
+    run: ({ channel, client, task }) => channelOf(client, task, channel)._deleteDraft(...task.payload)
+  },
+  "delete-message": {
+    logFailureAs: { message: "Deleting the message failed.", method: "deleteMessage" },
+    run: ({ client, task }) => client._deleteMessage(...task.payload)
+  },
+  "delete-reaction": {
+    logFailureAs: { message: "Deleting the reaction failed.", method: "deleteReaction" },
+    run: ({ channel, client, task }) => channelOf(client, task, channel)._deleteReaction(...task.payload)
+  },
+  "send-message": {
+    logFailureAs: { message: "Sending the message failed.", method: "sendMessage" },
+    /**
+     * A replayed send is the first time local state learns the message exists server-side: the
+     * optimistic layer that would normally reconcile it belongs to a `MessageOperations` call that
+     * finished (and failed) long ago.
+     */
+    onReplay: ({ client, result, task }) => {
+      const message = result?.message;
+      if (!message) return;
+      if (message.parent_id) {
+        client.threads.threadsById[message.parent_id]?.upsertReplyLocally({
+          message,
+          timestampChanged: true
+        });
+      }
+      channelOf(client, task).messagePaginator.trackLastMessage(formatMessage(message));
+    },
+    run: ({ channel, client, task }) => channelOf(client, task, channel)._sendMessage(...task.payload)
+  },
+  "send-reaction": {
+    logFailureAs: { message: "Sending the reaction failed.", method: "sendReaction" },
+    run: ({ channel, client, task }) => channelOf(client, task, channel)._sendReaction(...task.payload)
+  },
+  "update-message": {
+    logFailureAs: { message: "Updating the message failed.", method: "updateMessage" },
+    run: ({ client, task }) => client._updateMessage(...task.payload)
   }
-  // ---- batching ----
-  /**
-   * Runs `fn`, coalescing all notifications produced by writes inside it into a single flush on
-   * exit. Re-entrant: nested transactions flush only when the outermost exits.
-   */
-  transaction(fn) {
-    this.transactionDepth += 1;
+};
+var queueOrRun = async ({
+  channel,
+  client,
+  queue = true,
+  task
+}) => {
+  const { offlineDb } = client;
+  if (offlineDb && queue) {
     try {
-      return fn();
-    } finally {
-      this.transactionDepth -= 1;
-      if (this.transactionDepth === 0) this.flush();
-    }
-  }
-  /**
-   * Immediately flushes any throttled/pending state publish on the subscribers of `id` (via
-   * {@link EntityStoreSubscriber.flushState}). Called after an optimistic (local-user) write to
-   * `id` so it renders without the throttle delay. Only that id's own subscribers are flushed — the
-   * write touched no other id — and flushing a subscriber with nothing pending is a no-op.
-   */
-  flushSubscribers(id) {
-    const subscribers = this.subscribers.get(id);
-    if (!subscribers) return;
-    for (const subscriber of subscribers) subscriber.flushState?.();
-  }
-  /**
-   * Records `id` as changed for every subscriber watching it, except `subscriber` — the one that
-   * wrote it and is resposible for updating itself (see {@link EntityStore.upsert}).
-   */
-  markDirty(id, subscriber) {
-    const subscribers = this.subscribers.get(id);
-    if (!subscribers) return;
-    for (const other of subscribers) {
-      if (other === subscriber) continue;
-      let changed = this.pendingChanged.get(other);
-      if (!changed) {
-        changed = /* @__PURE__ */ new Set();
-        this.pendingChanged.set(other, changed);
-      }
-      changed.add(id);
+      return await offlineDb.queueTask({ task });
+    } catch (error) {
+      const { message, method } = QUEUEABLE_OPERATIONS[task.type].logFailureAs;
+      const cid = task.channelType && task.channelId ? [`${task.channelType}:${task.channelId}`] : [];
+      logger2.withExtraTags(method, ...cid).error(message, { error });
     }
   }
-  autoFlush() {
-    if (this.transactionDepth === 0) this.flush();
-  }
-  flush() {
-    if (this.pendingChanged.size === 0) return;
-    const changedBySubscriber = this.pendingChanged;
-    this.pendingChanged = /* @__PURE__ */ new Map();
-    for (const [subscriber, changedIds] of changedBySubscriber) {
-      subscriber.onEntitiesChanged({ changedIds });
-    }
+  return await runQueueableOperation({ channel, client, task });
+};
+var runQueueableOperation = async ({
+  channel,
+  client,
+  task
+}) => {
+  const operation = QUEUEABLE_OPERATIONS[task.type];
+  if (!operation) {
+    throw new Error(
+      `Tried to execute invalid pending task type (${task.type}) while synchronizing the database.`
+    );
   }
+  return await operation.run({ channel, client, task });
 };
 
 // src/messageComposer/attachmentIdentity.ts
@@ -3802,6 +3676,55 @@ var TextComposer = class {
   // --- END TEXT PROCESSING ----
 };
 
+// src/errors.ts
+var import_axios = require("axios");
+var APIErrorCodes = {
+  "-1": { name: "InternalSystemError", retryable: true },
+  "2": { name: "AccessKeyError", retryable: false },
+  "3": { name: "AuthenticationFailedError", retryable: true },
+  "4": { name: "InputError", retryable: false },
+  "6": { name: "DuplicateUsernameError", retryable: false },
+  "9": { name: "RateLimitError", retryable: true },
+  "16": { name: "DoesNotExistError", retryable: false },
+  "17": { name: "NotAllowedError", retryable: false },
+  "18": { name: "EventNotSupportedError", retryable: false },
+  "19": { name: "ChannelFeatureNotSupportedError", retryable: false },
+  "20": { name: "MessageTooLongError", retryable: false },
+  "21": { name: "MultipleNestingLevelError", retryable: false },
+  "22": { name: "PayloadTooBigError", retryable: false },
+  "23": { name: "RequestTimeoutError", retryable: true },
+  "24": { name: "MaxHeaderSizeExceededError", retryable: false },
+  "40": { name: "AuthErrorTokenExpired", retryable: false },
+  "41": { name: "AuthErrorTokenNotValidYet", retryable: false },
+  "42": { name: "AuthErrorTokenUsedBeforeIssuedAt", retryable: false },
+  "43": { name: "AuthErrorTokenSignatureInvalid", retryable: false },
+  "44": { name: "CustomCommandEndpointMissingError", retryable: false },
+  "45": { name: "CustomCommandEndpointCallError", retryable: true },
+  "46": { name: "ConnectionIDNotFoundError", retryable: false },
+  "60": { name: "CoolDownError", retryable: true },
+  "69": { name: "ErrWrongRegion", retryable: false },
+  "70": { name: "ErrQueryChannelPermissions", retryable: false },
+  "71": { name: "ErrTooManyConnections", retryable: true },
+  "99": { name: "AppSuspendedError", retryable: false }
+};
+function isAPIError(error) {
+  return error.code !== void 0;
+}
+function isDoesNotExistError(error) {
+  return isAPIError(error) && APIErrorCodes[`${error.code}`]?.name === "DoesNotExistError";
+}
+function isErrorRetryable(error) {
+  if (!error.code) return false;
+  const err = APIErrorCodes[`${error.code}`];
+  if (!err) return false;
+  return err.retryable;
+}
+function isEphemeral(error) {
+  if ((0, import_axios.isCancel)(error)) return false;
+  if (!error.response) return true;
+  return isErrorRetryable(error);
+}
+
 // src/search/BaseSearchSource.ts
 var DEFAULT_SEARCH_SOURCE_OPTIONS = {
   pageSize: 10,
@@ -4325,6 +4248,17 @@ function autoCompleteOp(value, query) {
     return value.some((v) => typeof v === "string" && matchOneString(v));
   return false;
 }
+var LOGICAL_FILTER_OPERATORS = ["$and", "$or", "$nor"];
+var filterConstrainsField = (filters, field) => {
+  if (!filters || typeof filters !== "object") return false;
+  if (Array.isArray(filters))
+    return filters.some((entry) => filterConstrainsField(entry, field));
+  const node = filters;
+  if (field in node) return true;
+  return LOGICAL_FILTER_OPERATORS.some(
+    (operator) => filterConstrainsField(node[operator], field)
+  );
+};
 
 // src/pagination/paginators/stateThrottling.ts
 var isTestRunner = () => {
@@ -4334,8 +4268,127 @@ var isTestRunner = () => {
     return false;
   }
 };
-var enabled = !isTestRunner();
-var isStateThrottlingEnabled = () => enabled;
+var enabled = !isTestRunner();
+var isStateThrottlingEnabled = () => enabled;
+
+// src/entityStore/EntityStore.ts
+var EntityStore = class {
+  constructor({ getEntityId }) {
+    this.byId = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.transactionDepth = 0;
+    this.pendingChanged = /* @__PURE__ */ new Map();
+    this.getEntityId = getEntityId;
+  }
+  // ---- reads ----
+  get(id) {
+    return typeof id === "string" ? this.byId.get(id) : void 0;
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  // ---- writes ----
+  /**
+   * Replaces the canonical copy of `entity` and notifies every subscriber watching its id —
+   * except `subscriber`, the one that performed the write, which is expected to re-render itself
+   * (the paginator that performed the write already emits its own window inline, so it must not be
+   * notified a second time through the subscription).
+   */
+  upsert(entity, subscriber) {
+    const id = this.getEntityId(entity);
+    const previous = this.byId.get(id);
+    if (previous === entity) return;
+    this.byId.set(id, entity);
+    this.markDirty(id, subscriber);
+    this.autoFlush();
+  }
+  // ---- subscription registry / refcount ----
+  /** Registers `subscriber` for `id` (notification target + refcount). */
+  link(id, subscriber) {
+    let subscribers = this.subscribers.get(id);
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Set();
+      this.subscribers.set(id, subscribers);
+    }
+    subscribers.add(subscriber);
+  }
+  /** Drops `subscriber` from `id`; GCs the canonical copy when none remain. */
+  unlink(id, subscriber) {
+    const subscribers = this.subscribers.get(id);
+    if (!subscribers) return;
+    subscribers.delete(subscriber);
+    if (subscribers.size === 0) {
+      this.subscribers.delete(id);
+      this.byId.delete(id);
+    }
+  }
+  /**
+   * Sugar for atomic / ad-hoc consumers that watch a single id (e.g. a thread watching its parent
+   * message). Fires `handler` immediately with the current value (mirroring
+   * {@link StateStore.subscribe}) and on every subsequent change.
+   */
+  subscribe(id, handler) {
+    const subscriber = {
+      onEntitiesChanged: () => handler(this.byId.get(id))
+    };
+    this.link(id, subscriber);
+    handler(this.byId.get(id));
+    return () => this.unlink(id, subscriber);
+  }
+  // ---- batching ----
+  /**
+   * Runs `fn`, coalescing all notifications produced by writes inside it into a single flush on
+   * exit. Re-entrant: nested transactions flush only when the outermost exits.
+   */
+  transaction(fn) {
+    this.transactionDepth += 1;
+    try {
+      return fn();
+    } finally {
+      this.transactionDepth -= 1;
+      if (this.transactionDepth === 0) this.flush();
+    }
+  }
+  /**
+   * Immediately flushes any throttled/pending state publish on the subscribers of `id` (via
+   * {@link EntityStoreSubscriber.flushState}). Called after an optimistic (local-user) write to
+   * `id` so it renders without the throttle delay. Only that id's own subscribers are flushed — the
+   * write touched no other id — and flushing a subscriber with nothing pending is a no-op.
+   */
+  flushSubscribers(id) {
+    const subscribers = this.subscribers.get(id);
+    if (!subscribers) return;
+    for (const subscriber of subscribers) subscriber.flushState?.();
+  }
+  /**
+   * Records `id` as changed for every subscriber watching it, except `subscriber` — the one that
+   * wrote it and is resposible for updating itself (see {@link EntityStore.upsert}).
+   */
+  markDirty(id, subscriber) {
+    const subscribers = this.subscribers.get(id);
+    if (!subscribers) return;
+    for (const other of subscribers) {
+      if (other === subscriber) continue;
+      let changed = this.pendingChanged.get(other);
+      if (!changed) {
+        changed = /* @__PURE__ */ new Set();
+        this.pendingChanged.set(other, changed);
+      }
+      changed.add(id);
+    }
+  }
+  autoFlush() {
+    if (this.transactionDepth === 0) this.flush();
+  }
+  flush() {
+    if (this.pendingChanged.size === 0) return;
+    const changedBySubscriber = this.pendingChanged;
+    this.pendingChanged = /* @__PURE__ */ new Map();
+    for (const [subscriber, changedIds] of changedBySubscriber) {
+      subscriber.onEntitiesChanged({ changedIds });
+    }
+  }
+};
 
 // src/entityStore/StoreBackedItemIndex.ts
 var NOOP_OWNER = { onEntitiesChanged: () => void 0 };
@@ -5750,6 +5803,7 @@ var BasePaginator = class {
     const itemHasBeenRemoved = !!removedItemCoordinates?.state && removedItemCoordinates.state.currentIndex > -1;
     this._itemIndex.setOne(ingestedItem);
     if (!this.matchesFilter(ingestedItem)) {
+      this.shrinkOffsetAfterRemoval(removedItemCoordinates);
       if (!this.isWindowPublishSuspended && this.isStateThrottled && itemHasBeenRemoved)
         this.scheduleWindowPublish();
       return itemHasBeenRemoved;
@@ -5905,6 +5959,17 @@ var BasePaginator = class {
     }
     return result;
   }
+  /**
+   * Keeps `offset` addressing the same position in the *server's* result set after an item left the
+   * loaded window.
+   */
+  shrinkOffsetAfterRemoval(coordinates) {
+    if (this.isCursorPagination) return;
+    if ((coordinates?.state?.currentIndex ?? -1) < 0) return;
+    const { offset } = this.state.getLatestValue();
+    if (typeof offset !== "number") return;
+    this.state.partialNext({ offset: Math.max(0, offset - 1) });
+  }
   /**
    * Meaning of location values
    * - currentIndex === -1 could not be found
@@ -5923,6 +5988,7 @@ var BasePaginator = class {
       if (!coords.state && !coords.interval) return noAction;
       const result = this.removeItemAtCoordinates(coords);
       this._itemIndex.remove(this.getItemId(item));
+      this.shrinkOffsetAfterRemoval(result);
       if (!this.isWindowPublishSuspended && this.isStateThrottled)
         this.scheduleWindowPublish();
       return result;
@@ -6651,17 +6717,7 @@ var ChannelPaginator = class extends BasePaginator {
   }
   matchesFilter(channel) {
     const filters = this.buildMatchFilters();
-    const LOGICAL_FILTER_OPERATORS = ["$and", "$or", "$nor"];
-    const filterConstrainsHidden = (filters2) => {
-      if (!filters2 || typeof filters2 !== "object") return false;
-      if (Array.isArray(filters2)) return filters2.some(filterConstrainsHidden);
-      const node = filters2;
-      if ("hidden" in node) return true;
-      return LOGICAL_FILTER_OPERATORS.some(
-        (operator) => filterConstrainsHidden(node[operator])
-      );
-    };
-    if (channel.data?.hidden && !filterConstrainsHidden(filters)) return false;
+    if (channel.data?.hidden && !filterConstrainsField(filters, "hidden")) return false;
     return itemMatchesFilter(channel, filters, {
       resolvers: this._filterFieldToDataResolvers
     });
@@ -7200,7 +7256,30 @@ var MessageIntervalPaginator = class extends BasePaginator {
      */
     this.mergeNewestPage = (page, options) => {
       const headInterval = this.itemIntervals[0];
-      if (!headInterval?.isHead) return;
+      if (!headInterval?.isHead) {
+        const logicalHead = this.liveHeadLogical;
+        const hasAnchoredHead = this.itemIntervals.some(
+          (interval2) => !isLogicalInterval(interval2) && interval2.isHead
+        );
+        if (!logicalHead || hasAnchoredHead || !page?.length) return;
+        const takeOverView = this.isActiveInterval(logicalHead);
+        const anchored = this.ingestPage({ page, isHead: true, setActive: false });
+        if (!anchored || !takeOverView) return;
+        const hasMoreTail2 = !this.pageReachedChannelStart(page, options);
+        anchored.hasMoreTail = hasMoreTail2;
+        anchored.isTail = !hasMoreTail2;
+        this.setActiveInterval(anchored, { updateState: false });
+        this.state.partialNext({
+          items: this.intervalToItems(anchored),
+          hasMoreHead: false,
+          hasMoreTail: hasMoreTail2,
+          cursor: {
+            headward: null,
+            tailward: hasMoreTail2 ? anchored.itemIds[0] ?? null : null
+          }
+        });
+        return;
+      }
       const wasAtChannelStart = !this.state.getLatestValue().hasMoreTail;
       const preMergeLoadedCount = headInterval.itemIds.length;
       if (!this.isActiveInterval(headInterval)) {
@@ -7529,7 +7608,7 @@ var MessageIntervalPaginator = class extends BasePaginator {
         enforceUnique,
         reaction,
         removed,
-        userId: this.channel.getClient().userID
+        userId: this.channel.getClient().userId
       });
       this.ingestItem({ ...formatted, own_reactions });
     };
@@ -7687,6 +7766,9 @@ var MessageIntervalPaginator = class extends BasePaginator {
     };
     const isJump = this.isJumpQueryShape(queryShape);
     if (options?.reconcile && !isJump && typeof this.items !== "undefined") {
+      if (this.state.getLatestValue().lastQueryError) {
+        this.state.partialNext({ lastQueryError: void 0 });
+      }
       this.mergeNewestPage(messages, {
         candidateIds: options.candidateIds,
         requestedLimit: requestedPageSize
@@ -8525,7 +8607,7 @@ var ChannelMemberSearchSource = class extends BaseSearchSource {
 };
 
 // src/configuration/utils/applyInstanceConfiguration.ts
-var logger2 = chatLoggerSystem.getLogger("instance-configuration");
+var logger3 = chatLoggerSystem.getLogger("instance-configuration");
 var applyInstanceConfiguration = ({
   alsoWatch,
   applyConfig,
@@ -8534,7 +8616,7 @@ var applyInstanceConfiguration = ({
   key,
   reinitializeConfig
 }) => {
-  const scopedLogger2 = logger2.withExtraTags(key);
+  const scopedLogger2 = logger3.withExtraTags(key);
   let tearDown = null;
   const runTearDown = () => {
     if (!tearDown) return;
@@ -10749,7 +10831,7 @@ var createTextComposerPreValidationMiddleware = (composer) => ({
 });
 
 // src/messageComposer/middleware/textComposer/TextComposerMiddlewareExecutor.ts
-var logger3 = chatLoggerSystem.getLogger("text-composer");
+var logger4 = chatLoggerSystem.getLogger("text-composer");
 var TextComposerMiddlewareExecutor = class extends MiddlewareExecutor {
   constructor({ composer }) {
     super();
@@ -10772,7 +10854,7 @@ var TextComposerMiddlewareExecutor = class extends MiddlewareExecutor {
     });
     const { query, searchSource } = result.state.suggestions ?? {};
     searchSource?.search(query)?.catch(
-      (error) => logger3.withExtraTags("execute").error("Searching for suggestions failed.", { error })
+      (error) => logger4.withExtraTags("execute").error("Searching for suggestions failed.", { error })
     );
     return result;
   }
@@ -11381,44 +11463,142 @@ var parseError = (error) => {
   return stringError ? JSON.parse(stringError) : {};
 };
 var isAlreadyExistsError = (error, parsed) => parsed.code === 4 && error instanceof Error && error.message.includes("already exists");
+var isHardDelete = (options) => !!options?.hard;
 var MessageOperationStatePolicy = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
-  optimistic(localMessage) {
-    this.ctx.ingest({
+  optimistic(kind, params) {
+    const { localMessage } = params;
+    const previous = this.ctx.get(localMessage.id);
+    if (kind === "delete") {
+      const deleteForMe = params.options?.delete_for_me;
+      if (isHardDelete(params.options)) {
+        this.ctx.remove(localMessage.id);
+        this.ctx.purge(localMessage.id);
+        return { previous };
+      }
+      if (!previous) return {};
+      const applied2 = {
+        ...localMessage,
+        deleted_at: /* @__PURE__ */ new Date(),
+        type: "deleted",
+        ...deleteForMe ? { deleted_for_me: true } : {}
+      };
+      this.ctx.ingest(applied2);
+      this.ctx.persist(applied2);
+      return { applied: applied2, previous };
+    }
+    if (kind === "update") {
+      const isFailed = localMessage.status === "failed";
+      const editedAt = /* @__PURE__ */ new Date();
+      const applied2 = {
+        ...localMessage,
+        error: isFailed ? localMessage.error : void 0,
+        updated_at: editedAt,
+        // `message_text_updated_at` is what drives the "edited" indicator, so it has to appear
+        // immediately — but only for a message the server has actually seen. A failed message never
+        // received a server-confirmed text update and must not appear to have had one.
+        ...isFailed ? {} : { message_text_updated_at: editedAt }
+      };
+      this.ctx.ingest(applied2);
+      this.ctx.persist(applied2);
+      return { applied: applied2, previous };
+    }
+    const applied = {
       ...localMessage,
       error: void 0,
       status: !localMessage.status || localMessage.status === "failed" ? "sending" : localMessage.status
-    });
+    };
+    this.ctx.ingest(applied);
+    this.ctx.persist({ ...applied, status: "failed" });
+    return { applied, previous };
   }
   success({
+    kind,
     messageFromResponse,
-    messageId
+    messageId,
+    optimistic,
+    options
   }) {
+    if (!messageFromResponse) return;
     const formatted = formatMessage({ ...messageFromResponse, status: "received" });
+    if (kind === "delete") {
+      if (isHardDelete(options)) {
+        this.ctx.remove(messageId);
+        this.ctx.purge(messageId);
+        return;
+      }
+      if (!this.ctx.get(messageId)) return;
+      this.ctx.ingest(formatted);
+      this.ctx.persist(formatted);
+      return;
+    }
     const existing = this.ctx.get(messageId);
+    const nothingWroteSinceOptimistic = !!optimistic?.applied && existing === optimistic.applied;
     const serverNewer = !existing || formatted.updated_at.getTime() > existing.updated_at.getTime();
     const serverSameOrNewer = !existing || formatted.updated_at.getTime() >= existing.updated_at.getTime();
     const existingIsOurOptimisticSend = existing?.status === "sending";
-    if (serverNewer || existingIsOurOptimisticSend && serverSameOrNewer) {
-      this.ctx.ingest(formatted);
-    }
+    const applyServerCopy = nothingWroteSinceOptimistic || serverNewer || existingIsOurOptimisticSend && serverSameOrNewer;
+    if (!applyServerCopy) return;
+    this.ctx.ingest(formatted);
+    this.ctx.persist(formatted);
   }
-  failure({
+  async failure({
     error,
+    kind,
     localMessage,
-    messageId
+    messageId,
+    optimistic,
+    options
   }) {
     const parsed = parseError(error);
     if (isAlreadyExistsError(error, parsed)) {
       const existing = this.ctx.get(messageId);
       if (existing?.status === "sending") {
-        this.ctx.ingest({ ...localMessage, status: "received" });
+        const received = { ...localMessage, status: "received" };
+        this.ctx.ingest(received);
+        this.ctx.persist(received);
       }
       return;
     }
-    this.ctx.ingest({ ...localMessage, status: "failed", error: parsed });
+    const queued = kind !== "send" && kind !== "retry" && await this.ctx.isQueued(messageId, [
+      kind === "delete" ? "delete-message" : "update-message"
+    ]);
+    if (kind === "delete") {
+      if (!queued) this.revertDelete({ messageId, optimistic, options });
+      return;
+    }
+    if (kind === "update") {
+      if (queued) return;
+      const failed2 = {
+        ...this.ctx.get(messageId) ?? localMessage,
+        error: parsed,
+        status: "failed"
+      };
+      this.ctx.ingest(failed2);
+      this.ctx.persist(failed2);
+      return;
+    }
+    const failed = { ...localMessage, error: parsed, status: "failed" };
+    this.ctx.ingest(failed);
+    this.ctx.persist(failed);
+  }
+  revertDelete({
+    messageId,
+    optimistic,
+    options
+  }) {
+    const previous = optimistic?.previous;
+    if (!previous) return;
+    if (isHardDelete(options)) {
+      this.ctx.ingest(previous);
+      this.ctx.persist(previous);
+      return;
+    }
+    if (optimistic?.applied && this.ctx.get(messageId) !== optimistic.applied) return;
+    this.ctx.ingest(previous);
+    this.ctx.persist(previous);
   }
 };
 
@@ -11431,7 +11611,14 @@ var MessageOperations = class {
   constructor(ctx) {
     this.failedSendCache = /* @__PURE__ */ new Map();
     this.ctx = ctx;
-    this.policy = new MessageOperationStatePolicy({ ingest: ctx.ingest, get: ctx.get });
+    this.policy = new MessageOperationStatePolicy({
+      get: ctx.get,
+      ingest: ctx.ingest,
+      isQueued: ctx.isQueued,
+      persist: ctx.persist,
+      purge: ctx.purge,
+      remove: ctx.remove
+    });
     this.configController = new ConfigController({
       defaults: DEFAULT_MESSAGE_OPERATIONS_CONFIG
     });
@@ -11505,14 +11692,32 @@ var MessageOperations = class {
   clearCachedFailedSend(messageId) {
     this.failedSendCache.delete(messageId);
   }
-  async run(params, doRequest) {
+  /**
+   * The shared lifecycle: apply the optimistic state, fire the request, then reconcile or record the
+   * failure. `kind` is threaded through because the three operations want materially different state
+   * transitions — see {@link MessageOperationStatePolicy}.
+   */
+  async run(kind, params, doRequest) {
     const messageId = params.localMessage.id;
-    this.policy.optimistic(params.localMessage);
+    const optimistic = this.policy.optimistic(kind, params);
     try {
-      const { message: messageFromResponse } = await doRequest(params);
-      this.policy.success({ messageFromResponse, messageId });
+      const response = await doRequest(params);
+      this.policy.success({
+        kind,
+        messageFromResponse: response?.message,
+        messageId,
+        optimistic,
+        options: params.options
+      });
     } catch (e) {
-      this.policy.failure({ error: e, localMessage: params.localMessage, messageId });
+      await this.policy.failure({
+        error: e,
+        kind,
+        localMessage: params.localMessage,
+        messageId,
+        optimistic,
+        options: params.options
+      });
       throw e;
     }
   }
@@ -11523,6 +11728,7 @@ var MessageOperations = class {
     );
     try {
       await this.run(
+        "send",
         { ...params, message: messageToSend },
         requestFn ?? handlers.send ?? (async (p) => await this.ctx.defaults.send(p.message ?? messageToSend, p.options))
       );
@@ -11547,6 +11753,7 @@ var MessageOperations = class {
     const sendAsRetry = send ? (p) => send({ ...p }) : void 0;
     try {
       await this.run(
+        "retry",
         {
           ...params,
           message: messageToSend,
@@ -11575,6 +11782,7 @@ var MessageOperations = class {
         updateOptions.skip_push = params.options.skip_push;
     }
     return await this.run(
+      "update",
       params,
       requestFn ?? handlers.update ?? (async (p) => await this.ctx.defaults.update(p.localMessage, updateOptions))
     );
@@ -11582,11 +11790,140 @@ var MessageOperations = class {
   async delete(params, requestFn) {
     const handlers = this.ctx.handlers();
     const doRequest = requestFn ?? handlers.delete ?? (async (p) => await this.ctx.defaults.delete(p.localMessage.id, p.options));
-    const { message: messageFromResponse } = await doRequest(params);
-    this.ctx.ingest(formatMessage(messageFromResponse));
+    return await this.run("delete", params, doRequest);
+  }
+};
+
+// src/entityStore/applyReactionLocally.ts
+var applyReactionLocally = (client, {
+  enforceUnique = false,
+  messageId,
+  reaction,
+  removed = false
+}) => {
+  const store = client.messageStore;
+  const user = client.user;
+  const existing = store.get(messageId);
+  if (!user || !existing) return;
+  const now = /* @__PURE__ */ new Date();
+  const reactionResponse = {
+    ...reaction,
+    created_at: reaction.created_at ?? now,
+    custom: reaction.custom ?? {},
+    message_id: messageId,
+    score: reaction.score ?? 1,
+    type: reaction.type,
+    updated_at: reaction.updated_at ?? now,
+    user,
+    user_id: user.id
+  };
+  const removedReactions = removed ? existing.own_reactions?.filter((r) => r.type === reactionResponse.type) ?? [] : enforceUnique ? existing.own_reactions ?? [] : [];
+  const withCounts = removed ? messageWithReactionRemoved(existing, reactionResponse) : messageWithReactionAdded(existing, reactionResponse, enforceUnique);
+  const own_reactions = computeOwnReactions({
+    current: existing.own_reactions ?? [],
+    enforceUnique,
+    reaction: reactionResponse,
+    removed,
+    userId: user.id
+  });
+  store.upsert({ ...withCounts, own_reactions });
+  store.flushSubscribers(messageId);
+  const persisted = store.get(messageId);
+  if (persisted) {
+    client.offlineDb?.executeQuerySafely(
+      (db) => removed ? db.deleteReaction({ message: persisted, reaction: reactionResponse }) : enforceUnique ? db.updateReaction({ message: persisted, reaction: reactionResponse }) : db.insertReaction({ message: persisted, reaction: reactionResponse }),
+      { method: "applyReactionLocally" }
+    );
+  }
+  return () => {
+    if (!removed) {
+      applyReactionLocally(client, {
+        messageId,
+        reaction: reactionResponse,
+        removed: true
+      });
+    }
+    for (const removedReaction of removedReactions) {
+      applyReactionLocally(client, {
+        messageId,
+        reaction: removedReaction,
+        removed: false
+      });
+    }
+  };
+};
+
+// src/messageOperations/optimistic.ts
+var isQueuedForReplay = async (client, messageId, types) => {
+  const { offlineDb } = client;
+  if (!offlineDb?.state.getLatestValue().initialized) return false;
+  const pending = await offlineDb.getPendingTasks({ messageId });
+  return !!pending?.some((task) => types.includes(task.type));
+};
+var reconcileHeldMessage = (channel, message) => {
+  if (!message) return;
+  const { messageStore } = channel.getClient();
+  if (!messageStore.has(message.id)) return;
+  messageStore.upsert(formatMessage(message));
+};
+var addReactionOptimistically = async ({
+  channel,
+  messageId,
+  options,
+  reaction
+}) => {
+  const client = channel.getClient();
+  const undo = applyReactionLocally(client, {
+    enforceUnique: options?.enforce_unique ?? false,
+    messageId,
+    reaction
+  });
+  try {
+    const response = await channel.sendReaction({ id: messageId, reaction, ...options });
+    reconcileHeldMessage(channel, response?.message);
+  } catch (error) {
+    if (!await isQueuedForReplay(client, messageId, ["send-reaction"])) undo?.();
+    throw error;
+  }
+};
+var deleteReactionOptimistically = async ({
+  channel,
+  messageId,
+  type
+}) => {
+  const client = channel.getClient();
+  const undo = applyReactionLocally(client, {
+    messageId,
+    reaction: { type },
+    removed: true
+  });
+  try {
+    const response = await channel.deleteReaction({ id: messageId, type });
+    reconcileHeldMessage(channel, response?.message);
+  } catch (error) {
+    if (!await isQueuedForReplay(client, messageId, ["delete-reaction"])) undo?.();
+    throw error;
   }
 };
 
+// src/messageOperations/persistence.ts
+var createMessageOperationsPersistence = ({
+  channel
+}) => ({
+  persist: (message) => {
+    channel.getClient().offlineDb?.executeQuerySafely(
+      (db) => db.upsertMessageWithChannelGuard({ message: { ...message, cid: channel.cid } }),
+      { method: "messageOperations:persist" }
+    );
+  },
+  purge: (id) => {
+    channel.getClient().offlineDb?.executeQuerySafely((db) => db.hardDeleteMessage({ id }), {
+      method: "messageOperations:purge"
+    });
+  },
+  isQueued: (messageId, types) => isQueuedForReplay(channel.getClient(), messageId, types)
+});
+
 // src/configuration/utils/declarativeSlices.ts
 var mergeDeclarativeSlice = (general, specific) => {
   if (!general) return specific;
@@ -11625,23 +11962,60 @@ var Thread = class extends WithSubscriptions {
       defaults: DEFAULT_THREAD_CONFIG
     });
     this.failedRepliesMap = /* @__PURE__ */ new Map();
+    /** How many consumers have called `activate()` without a matching `deactivate()`. */
+    this._activeRefCount = 0;
+    /**
+     * Declares that a consumer is displaying this thread (mirrors `channel.activate()`).
+     *
+     * `active` is also what {@link ConnectionRecoveryManager} filters on to decide which threads to
+     * reload on reconnect, so an unbalanced `deactivate()` now costs more than a missed auto-read —
+     * hence the refcount, matching `channel.activate()`. A thread held by more than one mount stays
+     * active until the last holder releases it.
+     */
     this.activate = () => {
-      this.state.partialNext({ active: true });
+      this._activeRefCount += 1;
+      if (this._activeRefCount === 1) {
+        this.state.partialNext({ active: true });
+      }
     };
+    /**
+     * Declares that a consumer has stopped displaying this thread (mirrors `channel.deactivate()`).
+     * Only flips `active` back to `false` once the last holder deactivates.
+     */
     this.deactivate = () => {
-      this.state.partialNext({ active: false });
+      if (this._activeRefCount === 0) return;
+      this._activeRefCount -= 1;
+      if (this._activeRefCount === 0) {
+        this.state.partialNext({ active: false });
+      }
     };
+    /**
+     * Re-queries this thread's replies, sized to the loaded window, and reconciles them in place — the
+     * thread analogue of {@link Channel.reload}, and what connection recovery calls for every active
+     * thread.
+     *
+     * Preserves failed (unsent) replies. They are read out of the reply paginator rather than out of
+     * `failedRepliesMap`, because that map is only written by `upsertReplyLocally`, whose callers are
+     * this thread's own subscriptions and the offline-DB path keyed on `ThreadManager.threadsById` —
+     * neither of which covers a thread constructed directly and never registered (the common path in
+     * the React Native SDK, which resolves `threadsById[id] ?? new Thread(...)`). Reading the paginator
+     * is true for managed and unmanaged threads alike. An overlap merge keeps them anyway (the
+     * reconcile's provenance guard never prunes a non-server message); only a disjoint rebuild can drop
+     * them, so any that actually fell out are re-ingested below.
+     *
+     * Rethrows, except for a not-found answer on a thread that never had replies (see the catch).
+     */
     this.reload = async () => {
       if (this.state.getLatestValue().isLoading) {
         return;
       }
       this.state.partialNext({ isLoading: true });
       try {
-        const loadedReplyCount = this.messagePaginator.items?.length ?? 0;
-        const requestedReplyLimit = loadedReplyCount || this.messagePaginator.pageSize;
-        const reconcileCandidateIds = new Set(
-          (this.messagePaginator.items ?? []).map((reply) => reply.id)
-        );
+        const loadedReplies = this.messagePaginator.items ?? [];
+        const loadedReplyCount = loadedReplies.length;
+        const requestedReplyLimit = Math.max(loadedReplyCount, this.messagePaginator.pageSize ?? 0) || void 0;
+        const reconcileCandidateIds = new Set(loadedReplies.map((reply) => reply.id));
+        const failedBefore = loadedReplies.filter((reply) => reply.status === "failed");
         const thread = await this.client.getThreadAndHydrate(this.id, {
           watch: true,
           reply_limit: requestedReplyLimit
@@ -11652,6 +12026,22 @@ var Thread = class extends WithSubscriptions {
             candidateIds: reconcileCandidateIds
           }
         });
+        if (failedBefore.length) {
+          const visible = new Set((this.messagePaginator.items ?? []).map((r) => r.id));
+          this.messagePaginator.batch(
+            () => {
+              for (const failed of failedBefore) {
+                if (!visible.has(failed.id)) this.messagePaginator.ingestItem(failed);
+              }
+            },
+            { coalesce: true }
+          );
+        }
+      } catch (error) {
+        const notFound = isDoesNotExistError(error) || error?.status === 404;
+        const neverExisted = notFound && this.state.getLatestValue().replyCount === 0;
+        if (neverExisted) return;
+        throw error;
       } finally {
         this.state.partialNext({ isLoading: false });
       }
@@ -11918,7 +12308,7 @@ var Thread = class extends WithSubscriptions {
               enforceUnique: eventType === "reaction.updated",
               reaction,
               removed: eventType === "reaction.deleted",
-              userId: this.client.userID
+              userId: this.client.userId
             });
             this.updateParentMessageLocally({ message: { ...message, own_reactions } });
           }
@@ -12127,11 +12517,26 @@ var Thread = class extends WithSubscriptions {
       compositionContext: this
     });
     this.messageOperations = new MessageOperations({
+      ...createMessageOperationsPersistence({ channel: this.channel }),
       ingest: (m) => {
-        this.messagePaginator.ingestItem(m);
-        this.channel.getClient().messageStore.flushSubscribers(m.id);
+        const store = this.channel.getClient().messageStore;
+        if (this.messagePaginator.matchesFilter(m)) {
+          this.messagePaginator.ingestItem(m);
+        } else if (store.has(m.id)) {
+          store.upsert(m);
+        }
+        store.flushSubscribers(m.id);
+      },
+      // Mirrors `ingest`'s routing: a message this paginator does not hold can still be held by the
+      // client-global store (a thread parent, a message displayed by another collection), and the
+      // policy uses this both for its freshness comparison and to decide whether there is anything to
+      // update optimistically at all. Reading only the paginator would make those two disagree.
+      get: (id) => this.messagePaginator.getItem(id) ?? this.channel.getClient().messageStore.get(id),
+      remove: (id) => {
+        this.messagePaginator.removeItem({ id });
+        this.channel.messagePaginator.removeItem({ id });
+        this.channel.pinnedMessagesPaginator.removeItem({ id });
       },
-      get: (id) => this.messagePaginator.getItem(id),
       normalizeOutgoingMessage: (m) => ({
         ...m,
         parent_id: this.id
@@ -12293,63 +12698,32 @@ var Thread = class extends WithSubscriptions {
     );
   }
   /**
-   * Adds a reaction to a reply with an optimistic local state update, mirroring
-   * {@link Channel.addReactionWithLocalUpdate}. The optimistic message is applied to THIS thread's
-   * paginator (so pure replies get optimism the channel paginator can't give); the request routes
-   * through the parent channel since reactions are channel-level.
+   * Adds a reaction to a reply with an optimistic local state update — see
+   * {@link addReactionOptimistically}, which `Channel` shares. The request routes through the parent
+   * channel because reactions are channel-level, while the local write is addressed by message id and
+   * so reaches a pure reply no channel collection holds.
    */
   async addReactionWithLocalUpdate({
     messageId,
     reaction,
     options
   }) {
-    const client = this.channel.getClient();
-    const undo = applyReactionLocally(client, {
-      enforceUnique: options?.enforce_unique ?? false,
+    await addReactionOptimistically({
+      channel: this.channel,
       messageId,
+      options,
       reaction
     });
-    try {
-      const response = await this.channel.sendReaction({
-        id: messageId,
-        reaction,
-        ...options
-      });
-      if (response?.message && client.messageStore.has(response.message.id)) {
-        client.messageStore.upsert(formatMessage(response.message));
-      }
-    } catch (error) {
-      if (undo && (!client.offlineDb || !isEphemeral(error))) {
-        undo();
-      }
-      throw error;
-    }
   }
   /**
-   * Removes the current user's reaction from a reply with an optimistic local state update,
-   * mirroring {@link Thread.addReactionWithLocalUpdate}.
+   * Removes the current user's reaction from a reply with an optimistic local state update — see
+   * {@link deleteReactionOptimistically}, which `Channel` shares.
    */
   async deleteReactionWithLocalUpdate({
     messageId,
     type
   }) {
-    const client = this.channel.getClient();
-    const undo = applyReactionLocally(client, {
-      messageId,
-      reaction: { type },
-      removed: true
-    });
-    try {
-      const response = await this.channel.deleteReaction({ id: messageId, type });
-      if (response?.message && client.messageStore.has(response.message.id)) {
-        client.messageStore.upsert(formatMessage(response.message));
-      }
-    } catch (error) {
-      if (undo && (!client.offlineDb || !isEphemeral(error))) {
-        undo();
-      }
-      throw error;
-    }
+    await deleteReactionOptimistically({ channel: this.channel, messageId, type });
   }
 };
 var normalizeThreadParticipants = (participants, channelCid) => {
@@ -12432,7 +12806,7 @@ var initState6 = (composition) => {
     editedMessage
   };
 };
-var logger4 = chatLoggerSystem.getLogger("message-composer");
+var logger5 = chatLoggerSystem.getLogger("message-composer");
 var offlineDbLogger = chatLoggerSystem.getLogger("offline-db");
 var _MessageComposer = class _MessageComposer extends WithSubscriptions {
   // todo: mediaRecorder: MediaRecorderController;
@@ -12915,7 +13289,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         );
         this.initState({ composition: draft });
       } catch (error) {
-        logger4.withExtraTags("getDraft", this.channel.cid).error("Retrieving the draft from the server failed.", { error });
+        logger5.withExtraTags("getDraft", this.channel.cid).error("Retrieving the draft from the server failed.", { error });
       }
     };
     this.createPoll = async () => {
@@ -14249,8 +14623,7 @@ var ChannelApi = class {
 };
 
 // src/channel.ts
-var logger5 = chatLoggerSystem.getLogger("channel");
-var offlineDbLogger2 = chatLoggerSystem.getLogger("offline-db");
+var logger6 = chatLoggerSystem.getLogger("channel");
 var ownDeclarativeConfig = (slice) => {
   if (!slice) return void 0;
   const {
@@ -14390,11 +14763,31 @@ var Channel = class extends ChannelApi {
     this.cooldownTimer = new CooldownTimer({ channel: this });
     this.cooldownTimer.registerSubscriptions();
     this.messageOperations = new MessageOperations({
+      ...createMessageOperationsPersistence({ channel: this }),
       ingest: (m) => {
-        this.messagePaginator.ingestItem(m);
-        this.getClient().messageStore.flushSubscribers(m.id);
+        const store = this.getClient().messageStore;
+        if (this.messagePaginator.matchesFilter(m)) {
+          this.messagePaginator.ingestItem(m);
+        } else if (store.has(m.id)) {
+          store.upsert(m);
+        }
+        store.flushSubscribers(m.id);
+      },
+      // Mirrors `ingest`'s routing: a message this paginator does not hold can still be held by the
+      // client-global store (a thread parent, a message displayed by another collection), and the
+      // policy uses this both for its freshness comparison and to decide whether there is anything to
+      // update optimistically at all. Reading only the paginator would make those two disagree.
+      get: (id2) => this.messagePaginator.getItem(id2) ?? this.getClient().messageStore.get(id2),
+      remove: (id2) => {
+        const parentId = this.messagePaginator.getItem(id2)?.parent_id ?? this.getClient().messageStore.get(id2)?.parent_id;
+        this.messagePaginator.removeItem({ id: id2 });
+        this.pinnedMessagesPaginator.removeItem({ id: id2 });
+        if (parentId) {
+          this.getClient().threads.threadsById[parentId]?.messagePaginator.removeItem({
+            id: id2
+          });
+        }
       },
-      get: (id2) => this.messagePaginator.getItem(id2),
       handlers: () => {
         const { requestHandlers } = this.configState.getLatestValue();
         const deleteMessageRequest = requestHandlers?.deleteMessageRequest;
@@ -14600,24 +14993,20 @@ var Channel = class extends ChannelApi {
    */
   async sendMessage(...args) {
     const [request] = args;
-    try {
-      const offlineDb = this.getClient().offlineDb;
-      const messageId = request.message?.id;
-      if (offlineDb && messageId) {
-        return await offlineDb.queueTask({
-          task: {
-            channelId: this.id,
-            channelType: this.type,
-            messageId,
-            payload: args,
-            type: "send-message"
-          }
-        });
+    const messageId = request.message?.id;
+    return await queueOrRun({
+      channel: this,
+      client: this.getClient(),
+      // Nothing to key a queue entry on without a message id, so it runs but is not queued.
+      queue: !!messageId,
+      task: {
+        channelId: this.id,
+        channelType: this.type,
+        messageId,
+        payload: args,
+        type: "send-message"
       }
-    } catch (error) {
-      offlineDbLogger2.withExtraTags("sendMessage", this.cid).error("Sending the message failed.", { error });
-    }
-    return await this._sendMessage(...args);
+    });
   }
   /**
    * Sends a message with optimistic local state update.
@@ -14670,59 +15059,24 @@ var Channel = class extends ChannelApi {
     );
   }
   /**
-   * Adds a reaction with an optimistic local state update: the reaction is applied to the cached
-   * message immediately ({@link applyReactionLocally}), then the request is
-   * fired via {@link Channel.sendReaction} (which owns the offline-DB write + queue). The
-   * server-authoritative counts reconcile on the response; the message is rolled back on failure.
+   * Adds a reaction with an optimistic local state update - see {@link addReactionOptimistically}.
    */
   async addReactionWithLocalUpdate({
     messageId,
     reaction,
     options
   }) {
-    const client = this.getClient();
-    const undo = applyReactionLocally(client, {
-      enforceUnique: options?.enforce_unique ?? false,
-      messageId,
-      reaction
-    });
-    try {
-      const response = await this.sendReaction({ id: messageId, reaction, ...options });
-      if (response?.message && client.messageStore.has(response.message.id)) {
-        client.messageStore.upsert(formatMessage(response.message));
-      }
-    } catch (error) {
-      if (undo && (!client.offlineDb || !isEphemeral(error))) {
-        undo();
-      }
-      throw error;
-    }
+    await addReactionOptimistically({ channel: this, messageId, options, reaction });
   }
   /**
-   * Removes the current user's reaction with an optimistic local state update, mirroring
-   * {@link Channel.addReactionWithLocalUpdate}.
+   * Removes the current user's reaction with an optimistic local state update - see
+   * {@link deleteReactionOptimistically}.
    */
   async deleteReactionWithLocalUpdate({
     messageId,
     type
   }) {
-    const client = this.getClient();
-    const undo = applyReactionLocally(client, {
-      messageId,
-      reaction: { type },
-      removed: true
-    });
-    try {
-      const response = await this.deleteReaction({ id: messageId, type });
-      if (response?.message && client.messageStore.has(response.message.id)) {
-        client.messageStore.upsert(formatMessage(response.message));
-      }
-    } catch (error) {
-      if (undo && (!client.offlineDb || !isEphemeral(error))) {
-        undo();
-      }
-      throw error;
-    }
+    await deleteReactionOptimistically({ channel: this, messageId, type });
   }
   /**
    * Upload a file to this channel's file endpoint (multipart).
@@ -14817,23 +15171,17 @@ var Channel = class extends ChannelApi {
    */
   async sendReaction(...args) {
     const [{ id: messageId }] = args;
-    try {
-      const offlineDb = this.getClient().offlineDb;
-      if (offlineDb) {
-        return await offlineDb.queueTask({
-          task: {
-            channelId: this.id,
-            channelType: this.type,
-            messageId,
-            payload: args,
-            type: "send-reaction"
-          }
-        });
+    return await queueOrRun({
+      channel: this,
+      client: this.getClient(),
+      task: {
+        channelId: this.id,
+        channelType: this.type,
+        messageId,
+        payload: args,
+        type: "send-reaction"
       }
-    } catch (error) {
-      offlineDbLogger2.withExtraTags("sendReaction", this.cid).error("Sending the reaction failed.", { error });
-    }
-    return this._sendReaction(...args);
+    });
   }
   _sendReaction(...args) {
     return this.getClient().sendReaction(...args);
@@ -14841,23 +15189,17 @@ var Channel = class extends ChannelApi {
   async deleteReaction(...args) {
     this._checkInitialized();
     const [request] = args;
-    try {
-      const offlineDb = this.getClient().offlineDb;
-      if (offlineDb) {
-        return await offlineDb.queueTask({
-          task: {
-            channelId: this.id,
-            channelType: this.type,
-            messageId: request.id,
-            payload: args,
-            type: "delete-reaction"
-          }
-        });
+    return await queueOrRun({
+      channel: this,
+      client: this.getClient(),
+      task: {
+        channelId: this.id,
+        channelType: this.type,
+        messageId: request.id,
+        payload: args,
+        type: "delete-reaction"
       }
-    } catch (error) {
-      offlineDbLogger2.withExtraTags("deleteReaction", this.cid).error("Deleting the reaction failed.", { error });
-    }
-    return await this._deleteReaction(...args);
+    });
   }
   /**
    * Deletes a reaction by user and type.
@@ -15547,7 +15889,7 @@ var Channel = class extends ChannelApi {
     const previousData = this.data;
     this.data = state.channel;
     this.state.syncStateFromChannelData(this.data, previousData);
-    logger5.withExtraTags("watch", this.cid).info("Started watching the channel.");
+    logger6.withExtraTags("watch", this.cid).info("Started watching the channel.");
     return state;
   }
   /**
@@ -15559,13 +15901,17 @@ var Channel = class extends ChannelApi {
    * This is intentionally thin: it only re-issues `watch()` with a limit sized to the loaded window
    * (`items.length`, so the whole loaded window is refreshed — not the smaller channel-list page). The
    * actual fold + destructive reconciliation happens inside `query()` → `seedFirstPageSync`
-   * (the same path the channel-list re-hydrate and React's `recoverState` use), driven by the loaded-id
+   * (the same path the channel-list re-hydrate and connection recovery use), driven by the loaded-id
    * snapshot `query()` captures before its await. Owning that single path is what lets the SDK stop
    * passing the reconciliation window/snapshot itself.
    *
    * Preserves failed (unsent) messages: an overlap merge keeps them (the reconcile's provenance guard
    * never prunes a non-server message); only a disjoint rebuild can drop them, so any that actually
-   * fell out are re-ingested below.
+   * fell out are re-ingested below. The offline DB is consulted alongside the in-memory window, because
+   * a failed message can be absent from memory and still be the user's unsent work — a cold boot starts
+   * with an empty paginator, and an eviction can drop it mid-session. v9 got this from a second, lagging
+   * copy of the list (the React SDK's own state); with one reactive source of truth the persisted row is
+   * that buffer.
    */
   async reload() {
     if (this._reloading || !this.initialized && !this.offlineMode) return;
@@ -15573,18 +15919,28 @@ var Channel = class extends ChannelApi {
     try {
       const paginator = this.messagePaginator;
       const headItems = paginator.headItems;
-      const requestedLimit = headItems.length || paginator.pageSize;
-      const failedBefore = headItems.filter((message) => message.status === "failed");
+      const requestedLimit = Math.max(headItems.length, paginator.pageSize ?? 0) || void 0;
+      const offlineDb = this.getClient().offlineDb;
+      const failedInMemory = headItems.filter((message) => message.status === "failed");
+      const failedInDb = offlineDb ? await offlineDb.getFailedMessages({ cid: this.cid }) : [];
+      const failedById = /* @__PURE__ */ new Map();
+      for (const message of [...failedInDb, ...failedInMemory]) {
+        failedById.set(message.id, message);
+      }
+      const failedBefore = [...failedById.values()];
       await this.watch({ messages: { limit: requestedLimit } });
       this.offlineMode = false;
-      paginator.batch(
-        () => {
-          for (const failed of failedBefore) {
-            if (!paginator.getItem(failed.id)) paginator.ingestItem(failed);
-          }
-        },
-        { coalesce: true }
-      );
+      if (failedBefore.length) {
+        const visible = new Set((paginator.items ?? []).map((message) => message.id));
+        paginator.batch(
+          () => {
+            for (const failed of failedBefore) {
+              if (!visible.has(failed.id)) paginator.ingestItem(failed);
+            }
+          },
+          { coalesce: true }
+        );
+      }
     } finally {
       this._reloading = false;
     }
@@ -15600,7 +15956,7 @@ var Channel = class extends ChannelApi {
   async stopWatching(...args) {
     const response = await super.stopWatching(...args);
     this.watchStatus = ChannelWatchStatus.NotWatching;
-    logger5.withExtraTags("stopWatching", this.cid).info("Stopped watching the channel.");
+    logger6.withExtraTags("stopWatching", this.cid).info("Stopped watching the channel.");
     return response;
   }
   /**
@@ -15848,23 +16204,17 @@ var Channel = class extends ChannelApi {
    */
   async createDraft(...args) {
     const [request] = args;
-    try {
-      const offlineDb = this.getClient().offlineDb;
-      if (offlineDb) {
-        return await offlineDb.queueTask({
-          task: {
-            channelId: this.id,
-            channelType: this.type,
-            threadId: request.message?.parent_id,
-            payload: args,
-            type: "create-draft"
-          }
-        });
+    return await queueOrRun({
+      channel: this,
+      client: this.getClient(),
+      task: {
+        channelId: this.id,
+        channelType: this.type,
+        threadId: request.message?.parent_id,
+        payload: args,
+        type: "create-draft"
       }
-    } catch (error) {
-      offlineDbLogger2.withExtraTags("createDraft", this.cid).error("Creating the draft in the offline database failed.", { error });
-    }
-    return this._createDraft(...args);
+    });
   }
   async _deleteDraft(...args) {
     return await super.deleteDraft(...args);
@@ -15875,38 +16225,30 @@ var Channel = class extends ChannelApi {
    */
   async deleteDraft(...args) {
     const [request] = args;
-    try {
-      const offlineDb = this.getClient().offlineDb;
-      if (offlineDb) {
-        return await offlineDb.queueTask(
-          {
-            task: {
-              channelId: this.id,
-              channelType: this.type,
-              threadId: request?.parent_id,
-              payload: args,
-              type: "delete-draft"
-            }
-          }
-        );
+    return await queueOrRun({
+      channel: this,
+      client: this.getClient(),
+      task: {
+        channelId: this.id,
+        channelType: this.type,
+        threadId: request?.parent_id,
+        payload: args,
+        type: "delete-draft"
       }
-    } catch (error) {
-      offlineDbLogger2.withExtraTags("deleteDraft", this.cid).error("Deleting the draft from the offline database failed.", { error });
-    }
-    return this._deleteDraft(...args);
+    });
   }
   on(callbackOrString, callbackOrNothing) {
     const key = callbackOrNothing ? callbackOrString : "all";
     const callback = callbackOrNothing ? callbackOrNothing : callbackOrString;
     const set = this.listeners.get(key) ?? /* @__PURE__ */ new Set();
-    logger5.withExtraTags("on", this.cid).debug(`Attaching a listener for the "${key}" event.`);
+    logger6.withExtraTags("on", this.cid).debug(`Attaching a listener for the "${key}" event.`);
     set.add(callback);
     if (!this.listeners.has(key)) {
       this.listeners.set(key, set);
     }
     return {
       unsubscribe: () => {
-        logger5.withExtraTags("on", this.cid).debug(`Removing the listener for the "${key}" event.`);
+        logger6.withExtraTags("on", this.cid).debug(`Removing the listener for the "${key}" event.`);
         set.delete(callback);
         if (!set.size) {
           this.listeners.delete(key);
@@ -15917,7 +16259,7 @@ var Channel = class extends ChannelApi {
   off(callbackOrString, callbackOrNothing) {
     const key = callbackOrNothing ? callbackOrString : "all";
     const callback = callbackOrNothing ? callbackOrNothing : callbackOrString;
-    logger5.withExtraTags("off", this.cid).debug(`Removing the listener for the "${key}" event.`);
+    logger6.withExtraTags("off", this.cid).debug(`Removing the listener for the "${key}" event.`);
     const set = this.listeners.get(key);
     set?.delete(callback);
     if (!set?.size) {
@@ -15961,23 +16303,25 @@ var Channel = class extends ChannelApi {
    * `state.unreadCount` derives from — so channel-wide resets (`channel.truncated`, "all channels
    * read") must route through here rather than writing a count of their own.
    */
+  /** @returns whether the count actually changed, so callers can react only to the channels it did. */
   _setOwnUnreadCount(unreadCount) {
-    if (this.pendingDisposal) return;
+    if (this.pendingDisposal) return false;
     const userId = this.getClient().userId;
-    if (!userId) return;
+    if (!userId) return false;
     const currentUserReadState = this.state.read[userId];
     if (!currentUserReadState || currentUserReadState.unread_messages === unreadCount) {
-      return;
+      return false;
     }
     this._upsertReadState(
       userId,
       () => ({ ...currentUserReadState, unread_messages: unreadCount }),
       { changedUserIds: [userId] }
     );
+    return true;
   }
   _handleChannelEvent(event) {
     const channel = this;
-    logger5.withExtraTags("_handleChannelEvent", this.cid).debug(`Received an event of type "${event.type}".`, { event });
+    logger6.withExtraTags("_handleChannelEvent", this.cid).debug(`Received an event of type "${event.type}".`, { event });
     const channelState = channel.state;
     switch (event.type) {
       case "typing.start":
@@ -16001,13 +16345,14 @@ var Channel = class extends ChannelApi {
       case "ai_indicator.stop":
         channelState.partialNext({ aiState: AIStates.Stop });
         break;
-      // `message.read_locally` is the client-only event dispatched by `markReadLocally()` when read
-      // events are disabled (e.g. livestreams with `isLocalUnreadCountEnabled`). It reuses the exact
-      // `message.read` state logic so the read-state update lives in one place — only the
-      // delivery-report network sync below is skipped for it.
+      // `notification.mark_read` is the only read signal for a channel the user is not watching, since
+      // `message.read` goes to watchers only. `message.read_locally` is the local stand-in when read
+      // events are disabled (livestreams). Both reuse the `message.read` logic, minus its delivery sync.
+      case "notification.mark_read":
       case "message.read_locally":
       case "message.read":
-        if (event.user?.id && event.created_at) {
+        if (event.user?.id && event.created_at && // the same event announces a thread read, which says nothing about the channel
+        !(event.type === "notification.mark_read" && event.thread_id)) {
           const eventUser = event.user;
           const readAtDate = new Date(event.created_at);
           const toDate = (value) => value ? value instanceof Date ? value : new Date(value) : void 0;
@@ -16495,7 +16840,7 @@ var Channel = class extends ChannelApi {
     }
   }
   _disconnect() {
-    logger5.withExtraTags("_disconnect", this.cid).info("Disconnecting the channel.");
+    logger6.withExtraTags("_disconnect", this.cid).info("Disconnecting the channel.");
     this.unsubscribeConfiguration?.();
     this.unsubscribeConfiguration = void 0;
     this.unsubscribeServerConfig?.();
@@ -18614,7 +18959,7 @@ var decodeWSEvent = (data) => {
 };
 
 // src/connection.ts
-var logger6 = chatLoggerSystem.getLogger("connection");
+var logger7 = chatLoggerSystem.getLogger("connection");
 var decodeConnectionEvent = (data) => data.type === "connection.ok" ? decoders.HealthCheckEvent(data) : decodeWSEvent(data);
 var isCloseEvent = (res) => res.code !== void 0;
 var isErrorEvent = (res) => res.error !== void 0;
@@ -18645,10 +18990,10 @@ var StableWSConnection = class {
      */
     this.onlineStatusChanged = (event) => {
       if (event.type === "offline") {
-        logger6.withExtraTags("onlineStatusChanged").info("Network status changed to offline.");
+        logger7.withExtraTags("onlineStatusChanged").info("Network status changed to offline.");
         this._setHealth(false);
       } else if (event.type === "online") {
-        logger6.withExtraTags("onlineStatusChanged").info(`Network status changed to online. isHealthy: ${this.isHealthy}.`);
+        logger7.withExtraTags("onlineStatusChanged").info(`Network status changed to online. isHealthy: ${this.isHealthy}.`);
         if (!this.isHealthy) {
           this._reconnect({ interval: 10 });
         }
@@ -18656,7 +19001,7 @@ var StableWSConnection = class {
     };
     this.onopen = (wsId, authMessage) => {
       if (this.wsID !== wsId) return;
-      logger6.withExtraTags("onopen").debug("WebSocket onopen callback fired.", {
+      logger7.withExtraTags("onopen").debug("WebSocket onopen callback fired.", {
         wsID: wsId
       });
       const { ws } = this;
@@ -18664,14 +19009,14 @@ var StableWSConnection = class {
       try {
         ws.send(authMessage);
       } catch (error) {
-        logger6.withExtraTags("onopen").error("Failed to send the WebSocket auth message.", { error });
+        logger7.withExtraTags("onopen").error("Failed to send the WebSocket auth message.", { error });
         this.rejectPromise?.(this._errorFromWSEvent(error));
         this._destroyCurrentWSConnection();
       }
     };
     this.onmessage = (wsId, event) => {
       if (this.wsID !== wsId) return;
-      logger6.withExtraTags("onmessage").trace("WebSocket onmessage callback fired.", {
+      logger7.withExtraTags("onmessage").trace("WebSocket onmessage callback fired.", {
         event,
         wsID: wsId
       });
@@ -18696,7 +19041,7 @@ var StableWSConnection = class {
     };
     this.onclose = (wsId, event) => {
       if (this.wsID !== wsId) return;
-      logger6.withExtraTags("onclose").debug(`WebSocket onclose callback fired with code ${event.code}.`, {
+      logger7.withExtraTags("onclose").debug(`WebSocket onclose callback fired with code ${event.code}.`, {
         event,
         wsID: wsId
       });
@@ -18707,14 +19052,14 @@ var StableWSConnection = class {
         error.wasClean = event.wasClean;
         error.target = event.target;
         this.rejectPromise?.(error);
-        logger6.withExtraTags("onclose").warn(`The WebSocket connection was rejected: ${event.reason}.`, { event });
+        logger7.withExtraTags("onclose").warn(`The WebSocket connection was rejected: ${event.reason}.`, { event });
       } else {
         this.consecutiveFailures += 1;
         this.totalFailures += 1;
         this._setHealth(false);
         this.isConnecting = false;
         this.rejectPromise?.(this._errorFromWSEvent(event));
-        logger6.withExtraTags("onclose").warn("The WebSocket connection was closed. Attempting to reconnect.", {
+        logger7.withExtraTags("onclose").warn("The WebSocket connection was closed. Attempting to reconnect.", {
           event
         });
         this._reconnect();
@@ -18727,7 +19072,7 @@ var StableWSConnection = class {
       this._setHealth(false);
       this.isConnecting = false;
       this.rejectPromise?.(this._errorFromWSEvent(event));
-      logger6.withExtraTags("onerror").warn("The WebSocket connection raised an error.", { event });
+      logger7.withExtraTags("onerror").warn("The WebSocket connection raised an error.", { event });
       this._reconnect();
     };
     /**
@@ -18769,7 +19114,7 @@ var StableWSConnection = class {
         statusCode = event.error.StatusCode;
         message = event.error.message;
       }
-      logger6.withExtraTags("_errorFromWSEvent").warn(`The WebSocket failed with code ${code}.`, { event });
+      logger7.withExtraTags("_errorFromWSEvent").warn(`The WebSocket failed with code ${code}.`, { event });
       const error = new Error(
         `WS failed with code ${code} and reason - ${message}`
       );
@@ -18815,7 +19160,7 @@ var StableWSConnection = class {
       this.connectionCheckTimeoutRef = setTimeout(() => {
         const now = /* @__PURE__ */ new Date();
         if (this.lastEvent && now.getTime() - this.lastEvent.getTime() > this.connectionCheckTimeout) {
-          logger6.withExtraTags("scheduleConnectionCheck").warn("No events received within the health-check window. Reconnecting.");
+          logger7.withExtraTags("scheduleConnectionCheck").warn("No events received within the health-check window. Reconnecting.");
           this._setHealth(false);
           this._reconnect();
         }
@@ -18853,13 +19198,13 @@ var StableWSConnection = class {
     try {
       const healthCheck = await this._connect();
       this.consecutiveFailures = 0;
-      logger6.withExtraTags("connect").info(`Established a WebSocket connection. Health check: ${healthCheck}.`);
+      logger7.withExtraTags("connect").info(`Established a WebSocket connection. Health check: ${healthCheck}.`);
     } catch (error) {
       this.isHealthy = false;
       this.consecutiveFailures += 1;
       const e = error;
       if (e.code === chatCodes.TOKEN_EXPIRED && !this.client.tokenManager.isStatic()) {
-        logger6.withExtraTags("connect").warn(
+        logger7.withExtraTags("connect").warn(
           "WebSocket connection failed due to an expired token. Reloading the token and reconnecting."
         );
         this._reconnect({ refreshToken: true });
@@ -18924,7 +19269,7 @@ var StableWSConnection = class {
    * @param timeout - Optional timeout in milliseconds to wait for the close frame from the server.
    */
   disconnect(timeout) {
-    logger6.withExtraTags("disconnect").info(`Closing the WebSocket connection for wsID ${this.wsID}.`);
+    logger7.withExtraTags("disconnect").info(`Closing the WebSocket connection for wsID ${this.wsID}.`);
     this.wsID += 1;
     this.isConnecting = false;
     this.isDisconnected = true;
@@ -18941,7 +19286,7 @@ var StableWSConnection = class {
     if (ws && ws.close && ws.readyState === ws.OPEN) {
       isClosedPromise = new Promise((resolve) => {
         const onclose = (event) => {
-          logger6.withExtraTags("disconnect").debug(
+          logger7.withExtraTags("disconnect").debug(
             `Resolving the close promise ${event ? "with" : "without"} a close frame.`,
             { event }
           );
@@ -18950,13 +19295,13 @@ var StableWSConnection = class {
         ws.onclose = onclose;
         setTimeout(onclose, timeout != null ? timeout : 1e3);
       });
-      logger6.withExtraTags("disconnect").debug("Manually closing the connection via client.disconnect().");
+      logger7.withExtraTags("disconnect").debug("Manually closing the connection via client.disconnect().");
       ws.close(
         chatCodes.WS_CLOSED_SUCCESS,
         "Manually closed connection by calling client.disconnect()"
       );
     } else {
-      logger6.withExtraTags("disconnect").debug("The WebSocket connection does not exist or is already closed.");
+      logger7.withExtraTags("disconnect").debug("The WebSocket connection does not exist or is already closed.");
       isClosedPromise = Promise.resolve();
     }
     delete this.ws;
@@ -18974,20 +19319,20 @@ var StableWSConnection = class {
     this.client.insightMetrics.connectionStartTimestamp = (/* @__PURE__ */ new Date()).getTime();
     let isTokenReady = false;
     try {
-      logger6.withExtraTags("_connect").debug("Waiting for the auth token.");
+      logger7.withExtraTags("_connect").debug("Waiting for the auth token.");
       await this.client.tokenManager.tokenReady();
       isTokenReady = true;
     } catch (e) {
     }
     try {
       if (!isTokenReady) {
-        logger6.withExtraTags("_connect").warn("The token provider failed previously. Retrying.");
+        logger7.withExtraTags("_connect").warn("The token provider failed previously. Retrying.");
         await this.client.tokenManager.loadToken();
       }
       this._setupConnectionPromise();
       const wsURL = this._buildUrl();
       const authMessage = this.client._buildWSAuthMessage();
-      logger6.withExtraTags("_connect").info(`Connecting to ${wsURL}.`, {
+      logger7.withExtraTags("_connect").info(`Connecting to ${wsURL}.`, {
         wsURL,
         requestID: this.requestID
       });
@@ -19012,7 +19357,7 @@ var StableWSConnection = class {
       }
     } catch (error) {
       this.isConnecting = false;
-      logger6.withExtraTags("_connect").warn("An error occurred while connecting.", { error });
+      logger7.withExtraTags("_connect").warn("An error occurred while connecting.", { error });
       if (this.client.options.enableInsights) {
         this.client.insightMetrics.wsConsecutiveFailures++;
         this.client.insightMetrics.wsTotalFailures++;
@@ -19033,9 +19378,9 @@ var StableWSConnection = class {
    * @param options.refreshToken - Reload/refresh the user token before attempting to reconnect.
    */
   async _reconnect(options = {}) {
-    logger6.withExtraTags("_reconnect").info("Initiating a reconnect.");
+    logger7.withExtraTags("_reconnect").info("Initiating a reconnect.");
     if (this.isConnecting || this.isHealthy) {
-      logger6.withExtraTags("_reconnect").debug("Aborting reconnect: already connecting or healthy (check 1).");
+      logger7.withExtraTags("_reconnect").debug("Aborting reconnect: already connecting or healthy (check 1).");
       return;
     }
     let interval = options.interval;
@@ -19044,39 +19389,37 @@ var StableWSConnection = class {
     }
     await sleep(interval);
     if (this.isConnecting || this.isHealthy) {
-      logger6.withExtraTags("_reconnect").debug("Aborting reconnect: already connecting or healthy (check 2).");
+      logger7.withExtraTags("_reconnect").debug("Aborting reconnect: already connecting or healthy (check 2).");
       return;
     }
     if (this.isDisconnected) {
-      logger6.withExtraTags("_reconnect").debug("Aborting reconnect: disconnect() was called.");
+      logger7.withExtraTags("_reconnect").debug("Aborting reconnect: disconnect() was called.");
       return;
     }
-    logger6.withExtraTags("_reconnect").info("Destroying the current WebSocket connection.");
+    logger7.withExtraTags("_reconnect").info("Destroying the current WebSocket connection.");
     this._destroyCurrentWSConnection();
     if (options.refreshToken) {
       await this.client.tokenManager.loadToken();
     }
     try {
       await this._connect();
-      logger6.withExtraTags("_reconnect").debug("Waiting for the recover callback.");
-      await this.client.recoverState();
-      logger6.withExtraTags("_reconnect").debug("Finished the recover callback.");
+      this.client._settleConnectPromises();
       this.consecutiveFailures = 0;
     } catch (error) {
       this.isHealthy = false;
       this.consecutiveFailures += 1;
       if (error.code === chatCodes.TOKEN_EXPIRED && !this.client.tokenManager.isStatic()) {
-        logger6.withExtraTags("_reconnect").warn(
+        logger7.withExtraTags("_reconnect").warn(
           "WebSocket connection failed due to an expired token. Reloading the token and reconnecting."
         );
         return this._reconnect({ refreshToken: true });
       }
       if (error.isWSFailure) {
-        logger6.withExtraTags("_reconnect").warn("WebSocket connection failed. Retrying the reconnect.");
+        logger7.withExtraTags("_reconnect").warn("WebSocket connection failed. Retrying the reconnect.");
         this._reconnect();
       }
     }
-    logger6.withExtraTags("_reconnect").debug("Reconnect attempt finished.");
+    logger7.withExtraTags("_reconnect").debug("Reconnect attempt finished.");
   }
   /**
    * Removes the current WS connection.
@@ -19091,7 +19434,7 @@ var StableWSConnection = class {
 };
 
 // src/uploadManager.ts
-var logger7 = chatLoggerSystem.getLogger("upload-manager");
+var logger8 = chatLoggerSystem.getLogger("upload-manager");
 var initState7 = () => ({ uploads: {} });
 var upsertById = (uploads, record) => ({
   ...uploads,
@@ -19181,7 +19524,7 @@ var UploadManager = class {
           resolvePromise(response);
         } catch (error) {
           if (!abortController.signal.aborted) {
-            logger7.withExtraTags("upload", channelCid).error(`Upload "${id}" failed.`, { error });
+            logger8.withExtraTags("upload", channelCid).error(`Upload "${id}" failed.`, { error });
           }
           rejectPromise(error);
         } finally {
@@ -19232,7 +19575,7 @@ function UserFromToken(token) {
 }
 
 // src/token_manager.ts
-var logger8 = chatLoggerSystem.getLogger("token-manager");
+var logger9 = chatLoggerSystem.getLogger("token-manager");
 var TokenManager = class {
   /**
    * Initializes the token manager.
@@ -19302,7 +19645,7 @@ var TokenManager = class {
           try {
             this.token = await this.tokenProvider();
           } catch (e) {
-            logger8.withExtraTags("loadToken").error("The token provider threw an error.", { error: e });
+            logger9.withExtraTags("loadToken").error("The token provider threw an error.", { error: e });
             return reject(
               new Error(`Call to tokenProvider failed with message: ${e}`, { cause: e })
             );
@@ -19382,7 +19725,7 @@ var runWithRetry = (f, {
 };
 
 // src/api-client.ts
-var logger9 = chatLoggerSystem.getLogger("api-client");
+var logger10 = chatLoggerSystem.getLogger("api-client");
 var MULTIPART_CONTENT_TYPE = "multipart/form-data";
 var UPLOAD_REQUEST_DEFAULTS = {
   timeout: 0,
@@ -19501,7 +19844,7 @@ var ApiClient = class {
             requestResponse = await this.client.axiosInstance.request(config);
           } catch (error) {
             if (isTokenExpiredError(error)) {
-              logger9.withExtraTags("_doRequest").debug(
+              logger10.withExtraTags("_doRequest").debug(
                 `The token expired on a ${type.toUpperCase()} request. Reloading the token before retrying.`,
                 { url, config }
               );
@@ -20144,7 +20487,7 @@ var THREAD_MANAGER_INITIAL_STATE = {
   },
   ready: false
 };
-var logger10 = chatLoggerSystem.getLogger("thread-manager");
+var logger11 = chatLoggerSystem.getLogger("thread-manager");
 var ThreadManager = class extends WithSubscriptions {
   constructor({ client }) {
     super();
@@ -20294,7 +20637,7 @@ var ThreadManager = class extends WithSubscriptions {
           ready: true
         }));
       } catch (error) {
-        logger10.withExtraTags("reload").error("Failed to reload the thread list.", { error });
+        logger11.withExtraTags("reload").error("Failed to reload the thread list.", { error });
         this.state.next((current) => ({
           ...current,
           pagination: {
@@ -20330,7 +20673,7 @@ var ThreadManager = class extends WithSubscriptions {
           }
         }));
       } catch (error) {
-        logger10.withExtraTags("loadNextPage").error("Failed to load the next page of threads.", { error });
+        logger11.withExtraTags("loadNextPage").error("Failed to load the next page of threads.", { error });
         this.state.next((current) => ({
           ...current,
           pagination: {
@@ -21070,6 +21413,13 @@ var ignoreEventsForUnknownChannels = ({ event, ctx: { channelManager } }) => {
   );
   if (!channel) return { action: "stop" };
 };
+var restoreInterruptedWatch = (channel, client) => {
+  if (channel.pendingDisposal) return;
+  if (channel.watchStatus !== ChannelWatchStatus.WasWatching) return;
+  runDetached(getChannel({ channel, client }), {
+    context: `restoreInterruptedWatch(${channel.cid})`
+  });
+};
 var updateLists = async ({
   event,
   ctx: { channelManager }
@@ -21104,6 +21454,9 @@ var updateLists = async ({
     }
     paginator.ingestItem(channel);
   });
+  if (event.type !== "channel.hidden") {
+    restoreInterruptedWatch(channel, channelManager.client);
+  }
 };
 var channelDeletedHandler = {
   handle: removeItem,
@@ -21133,6 +21486,22 @@ var messageNewHandler = {
   handle: updateLists,
   id: "ChannelManager:default-handler:message.new"
 };
+var READ_STATE_SORT_FIELDS = ["has_unread", "unread_count"];
+var dependsOnReadState = (paginator) => paginator.effectiveSort.some(
+  ({ field }) => !!field && READ_STATE_SORT_FIELDS.includes(field)
+) || filterConstrainsField(paginator.buildMatchFilters(), "has_unread");
+var readStateChangedHandler = {
+  handle: ({ event, ctx: { channelManager } }) => {
+    const { client } = channelManager;
+    if (event.type === "message.read" && event.user?.id !== client.userId) return;
+    if (event.thread_id) return;
+    const channel = getCachedChannelFromEvent(event, client.activeChannels);
+    if (!channel) return;
+    if (!channelManager.paginators.some(dependsOnReadState)) return;
+    channelManager.ingestChannel(channel);
+  },
+  id: "ChannelManager:default-handler:read-state-changed"
+};
 var notificationAddedToChannelHandler = {
   handle: updateLists,
   id: "ChannelManager:default-handler:notification.added_to_channel"
@@ -21210,6 +21579,33 @@ var _ChannelManager = class _ChannelManager extends WithSubscriptions {
         await paginator.reload();
       })
     );
+    /**
+     * Re-run every loaded list's own first-page query — the channel-list half of connection recovery,
+     * driven by {@link ConnectionRecoveryManager}.
+     *
+     * Each list re-asserts its *own* `filters` / `sort` / `pageSize` rather than some substitute query,
+     * and because `client.queryChannels` watches by default, that page's channels are re-watched as a
+     * side effect. Channels below the first page are deliberately not touched — see
+     * `restoreInterruptedWatch` for how they come back.
+     *
+     * `{ keepPreviousItems: true, reset: 'yes' }` is the non-destructive refresh: `reset` restarts the
+     * window at page 1, while `keepPreviousItems` merges the fetched page into the loaded list instead
+     * of replacing it and keeps the item index populated — the latter is what stops a concurrent
+     * offline-replay ingest from rebuilding the list out of a cleared index. Notably NOT `silent`: the
+     * `isLoading` transition it would suppress is the in-flight guard that keeps a second overlapping
+     * query from being issued.
+     *
+     * Distinct from {@link ChannelManager.reload}, which is a destructive `reset` that blanks each list
+     * to its loading state.
+     *
+     * Paginators that were never queried are skipped: they run their own first query when they mount,
+     * and querying them here would race it.
+     */
+    this.recover = async () => await Promise.allSettled(
+      this.paginators.filter((paginator) => paginator.isInitialized).map(async (paginator) => {
+        await paginator.toTail({ keepPreviousItems: true, reset: "yes" });
+      })
+    );
     this.client = client;
     this.state = new StateStore({ paginators: paginators ?? [] });
     this.setOwnershipResolver(ownershipResolver);
@@ -21292,6 +21688,19 @@ var _ChannelManager = class _ChannelManager extends WithSubscriptions {
       }
     });
   }
+  /**
+   * Drops a channel from the lists whose filters it no longer matches, adding it nowhere.
+   *
+   * For state the client changes without an event naming the channel — zeroing every unread count on a
+   * global read. Removal-only: the backend rejects `has_unread: false`, so becoming read can never make
+   * a channel belong to a list, and `ingestChannel` would pull unloaded channels into matching ones.
+   */
+  dropFromUnmatchedLists(channel) {
+    this.paginators.forEach((paginator) => {
+      if (paginator.matchesFilter(channel)) return;
+      paginator.removeItem({ item: channel });
+    });
+  }
   /**
    * Filter a page of query results for a specific paginator according to ownership rules.
    * If no owners are specified by the resolver, all matching paginators keep the item.
@@ -21508,14 +21917,191 @@ _ChannelManager.defaultEventHandlers = {
   "channel.visible": [channelVisibleHandler],
   "member.updated": [memberUpdatedHandler],
   "message.new": [messageNewHandler],
+  "message.read": [readStateChangedHandler],
+  "message.read_locally": [readStateChangedHandler],
   "notification.added_to_channel": [notificationAddedToChannelHandler],
   "notification.channel_mutes_updated": [notificationChannelMutesUpdatedHandler],
+  "notification.mark_read": [readStateChangedHandler],
+  "notification.mark_unread": [readStateChangedHandler],
   "notification.message_new": [notificationMessageNewHandler],
   "notification.removed_from_channel": [notificationRemovedFromChannelHandler],
   "user.presence.changed": [userPresenceChangedHandler]
 };
 var ChannelManager = _ChannelManager;
 
+// src/ConnectionRecoveryManager.ts
+var logger12 = chatLoggerSystem.getLogger("client");
+var DEFAULT_CONNECTION_RECOVERY_MANAGER_CONFIG = deepFreezeConfig({ enabled: true });
+var ConnectionRecoveryManager = class extends WithSubscriptions {
+  constructor({ client }) {
+    super();
+    /** Set while a recovery is in flight; only used to keep the logs readable. */
+    this.isRecovering = false;
+    this.registerSubscriptions = () => {
+      if (!this.hasSubscriptions) {
+        this.addUnsubscribeFunction(
+          this.client.on("connection.changed", (event) => {
+            if (!event.online) return;
+            runDetached(this.recoverChannelLists(), { context: "recoverChannelLists" });
+            const syncEdgeDrivesActiveChannels = this.ensureSyncStatusSubscription();
+            if (!syncEdgeDrivesActiveChannels) {
+              runDetached(this.recoverActiveChannels(), {
+                context: "recoverActiveChannels"
+              });
+            }
+          }).unsubscribe
+        );
+        this.addUnsubscribeFunction(() => {
+          this.unsubscribeSyncStatus?.();
+          this.unsubscribeSyncStatus = void 0;
+        });
+      }
+      this.incrementRefCount();
+      return () => this.unregisterSubscriptions();
+    };
+    /**
+     * Bind to the offline DB's sync-status edge, if there is one to bind to yet.
+     *
+     * Resolved off `this.client` rather than injected: the DB is already reachable there, it is simply
+     * attached after this manager is constructed (and initialized later still), so the binding has to be
+     * deferred rather than handed in. Doing it from the `connection.changed` handler is safe even when
+     * this manager's listener runs before the sync manager's: `OfflineDBSyncManager` awaits
+     * `syncAndExecutePendingTasks()` before publishing, so the edge cannot land in the same synchronous
+     * dispatch that registers us.
+     *
+     * An offline DB whose `init()` never succeeded publishes no edge, so it must not be treated as the
+     * trigger — hence the `initialized` check, which also means a later successful init is picked up on
+     * the next reconnect.
+     *
+     * @returns whether the sync-status edge is now driving active-channel recovery.
+     */
+    this.ensureSyncStatusSubscription = () => {
+      if (this.unsubscribeSyncStatus) return true;
+      const { offlineDb } = this.client;
+      if (!offlineDb?.state.getLatestValue().initialized) return false;
+      const { unsubscribe } = offlineDb.syncManager.onSyncStatusChange((status) => {
+        if (!status) return;
+        runDetached(this.recoverActiveChannels(), { context: "recoverActiveChannels" });
+      });
+      this.unsubscribeSyncStatus = unsubscribe;
+      return true;
+    };
+    this.recoverChannelLists = async () => {
+      if (!this.config.enabled) return;
+      await this.client.channelManager.recover();
+    };
+    this.recoverActiveChannels = async () => {
+      if (!this.config.enabled) return;
+      const channels = this.recoverableActiveChannels;
+      const threads = this.recoverableActiveThreads;
+      this.isRecovering = true;
+      logger12.withExtraTags("connectionRecovery").info(
+        `Recovering ${channels.length} active channel(s) and ${threads.length} active thread(s).`
+      );
+      await Promise.allSettled([
+        ...channels.map((channel) => channel.reload()),
+        ...threads.map((thread) => thread.reload())
+      ]);
+      this.isRecovering = false;
+      this.client.dispatchEvent({ type: "connection.recovered" });
+    };
+    /**
+     * Run a full recovery now, without waiting for a connection event.
+     */
+    this.recover = async () => {
+      if (this.isRecovering) {
+        logger12.withExtraTags("connectionRecovery").debug("A recovery is already in flight.");
+      }
+      await Promise.allSettled([this.recoverChannelLists(), this.recoverActiveChannels()]);
+    };
+    this.configController = new ConfigController({
+      defaults: DEFAULT_CONNECTION_RECOVERY_MANAGER_CONFIG
+    });
+    this.client = client;
+  }
+  /**
+   * Resolved configuration, as a store — the shape every configurable class exposes
+   * (`configState` / `config` / `updateConfig`).
+   */
+  get configState() {
+    return this.configController.state;
+  }
+  /** The current resolved configuration. `Readonly` — change it through {@link updateConfig}. */
+  get config() {
+    return this.configState.getLatestValue();
+  }
+  /** Merges a partial configuration into the resolved config and notifies subscribers. */
+  updateConfig(config) {
+    this.configController.patch(config);
+  }
+  /**
+   * Rebuilds the resolved configuration from package defaults plus the declarative slice — the
+   * derivation entry point every configurable entity exposes, so the client routes a slice here and
+   * knows nothing about this manager's defaults or merge semantics.
+   */
+  initializeConfig(config) {
+    this.configController.initialize(config);
+  }
+  /**
+   * The channels this recovery reloads: the ones a consumer has declared it is currently reading.
+   *
+   * Deliberately NOT filtered on `watchStatus`. A channel opened while offline never reached
+   * `Watching` at all (its `watch()` threw, leaving `offlineMode`), so a `WasWatching` filter here
+   * would permanently strand the single most important offline case. `Channel.reload()`'s own
+   * `initialized || offlineMode` guard is the correct gate, and this is not a "restore a lost watch"
+   * decision anyway — it is "the channel being read must show the truth".
+   */
+  get recoverableActiveChannels() {
+    const channels = [];
+    for (const cid in this.client.activeChannels) {
+      const channel = this.client.activeChannels[cid];
+      if (channel?.active && !channel.pendingDisposal) channels.push(channel);
+    }
+    return channels;
+  }
+  /**
+   * The threads this recovery reloads: the ones a consumer has declared it is displaying.
+   *
+   * Threads need their own pass because nothing else brings an open thread's replies back — a
+   * channel reload refreshes the main message list, `ChannelManager.recover()` refreshes the channel
+   * lists*, and `ThreadManager`'s own recovery refreshes the thread *list*, reusing existing
+   * instances without rehydrating them unless they were separately marked stale (which only
+   * `user.watching.stop` does, never a reconnect).
+   *
+   * `active` is the filter that matters: `threadsById` holds every thread the list has paged in,
+   * which is not what should be re-fetched on a reconnect — only what someone is actually reading.
+   * Guarded on the owning channel the same way active channels are: a thread whose channel is being
+   * torn down has nothing to recover into.
+   *
+   * NOTE: `threadsById` is the thread LIST, not a thread cache. A thread opened from a message list
+   * is constructed directly (`threadsById[id] ?? new Thread(...)`) and only reaches the list because
+   * the UI SDKs adopt it there — prepended, once its replies have loaded — which is a workaround, not
+   * a contract. Two consequences, both accepted for now and both narrow:
+   *
+   * - A reconnect landing before that adoption misses the thread. Self-limiting: the UI SDKs re-issue
+   *   the load while the reply list is still unloaded, so a thread that failed to load gets adopted on
+   *   the retry.
+   * - `ThreadManager.reload()` rebuilds `state.threads` purely from the query response, so an adopted
+   *   thread absent from that response is evicted while still active. It cannot bite within the
+   *   reconnect that caused it: this getter is read before `connection.recovered` is dispatched, and
+   *   that event is what triggers the UI SDKs' list reload. It would take a LATER reconnect, after an
+   *   eviction, to miss the thread.
+   *
+   * The fix is a real off-list registry — see the commented-out `threadCache` in `ThreadManager` — at
+   * which point this getter reads from that instead, with no change to the `active` filter.
+   */
+  get recoverableActiveThreads() {
+    const threads = [];
+    for (const thread of Object.values(this.client.threads.threadsById)) {
+      if (!thread) continue;
+      const { active } = thread.state.getLatestValue();
+      if (!active || thread.channel.pendingDisposal) continue;
+      threads.push(thread);
+    }
+    return threads;
+  }
+};
+
 // src/reminders/ReminderTimer.ts
 var oneMinute = 60 * 1e3;
 var oneHour = 60 * oneMinute;
@@ -22003,7 +22589,7 @@ var CONSTRUCTION_ONLY_CONFIG_PATHS = {
 };
 
 // src/configuration/InstanceConfigurationRegistry.ts
-var logger11 = chatLoggerSystem.getLogger("instance-configuration");
+var logger13 = chatLoggerSystem.getLogger("instance-configuration");
 var InstanceConfigurationRegistry = class {
   constructor() {
     /**
@@ -22201,7 +22787,7 @@ var InstanceConfigurationRegistry = class {
       try {
         instance.reinitializeConfig?.();
       } catch (error) {
-        logger11.error("reinitializeConfig threw during reset", error);
+        logger13.error("reinitializeConfig threw during reset", error);
       }
     }
   }
@@ -22259,7 +22845,7 @@ var InstanceConfigurationRegistry = class {
   warnIfKeyLooksUnknown(key) {
     if (INSTANCE_CONFIG_TREE_KEYS.includes(key)) return;
     if (this.hasLiveInstances(key)) return;
-    logger11.withExtraTags(key).warn(
+    logger13.withExtraTags(key).warn(
       "Configuration registered for a key this package does not define, with nothing subscribed to it. Check the spelling; a key declared by a downstream SDK is expected here only if its owner subscribes later."
     );
   }
@@ -22286,7 +22872,7 @@ var InstanceConfigurationRegistry = class {
       return !isEqual(getPath(registered, path), getPath(config, path));
     });
     if (late.length === 0) return;
-    logger11.withExtraTags(key).warn(
+    logger13.withExtraTags(key).warn(
       `These paths are read once during construction, so they will not affect the ${key} instance(s) that already exist: ${late.join(", ")}. Register configuration before the instances are created \u2014 typically alongside StreamChat.getInstance().`
     );
   }
@@ -24352,8 +24938,8 @@ var ChatApi = class {
 function isString(value) {
   return typeof value === "string" || value instanceof String;
 }
-var logger12 = chatLoggerSystem.getLogger("client");
-var offlineDbLogger3 = chatLoggerSystem.getLogger("offline-db");
+var logger14 = chatLoggerSystem.getLogger("client");
+var offlineDbLogger2 = chatLoggerSystem.getLogger("offline-db");
 var StreamChat = class _StreamChat extends ChatApi {
   /**
    * Initializes a client.
@@ -24411,7 +24997,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         throw new Error('The "id" field on the user is missing');
       }
       if (this.userId === user.id && this.setUserPromise) {
-        logger12.withExtraTags("connectUser").warn(
+        logger14.withExtraTags("connectUser").warn(
           "Detected consecutive calls to connectUser. Ideally, this function should only be called once."
         );
         return this.setUserPromise;
@@ -24422,7 +25008,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         );
       }
       if (this.node && !this.options.allowServerSideConnect) {
-        logger12.withExtraTags("connectUser").warn(
+        logger14.withExtraTags("connectUser").warn(
           'Do not use connectUser server-side. connectUser impacts MAU and concurrent connection usage, and therefore your bill. If you have a valid use case, set "allowServerSideConnect: true" in the client options to disable this warning.'
         );
       }
@@ -24501,11 +25087,11 @@ var StreamChat = class _StreamChat extends ChatApi {
         );
       }
       if (this.wsConnection?.isConnecting && this.wsPromise) {
-        logger12.withExtraTags("openConnection").debug("A connection attempt is already in progress.");
+        logger14.withExtraTags("openConnection").debug("A connection attempt is already in progress.");
         return this.wsPromise;
       }
       if (this.wsConnection?.isHealthy && this._hasConnectionID()) {
-        logger12.withExtraTags("openConnection").debug("openConnection was called twice; a healthy connection already exists.");
+        logger14.withExtraTags("openConnection").debug("openConnection was called twice; a healthy connection already exists.");
         return;
       }
       this.clientId = `${this.userId}--${randomId()}`;
@@ -24521,7 +25107,7 @@ var StreamChat = class _StreamChat extends ChatApi {
      * @returns The close-connection promise.
      */
     this.disconnectUser = (timeout) => {
-      logger12.withExtraTags("disconnectUser").info("Disconnecting the client.");
+      logger14.withExtraTags("disconnectUser").info("Disconnecting the client.");
       delete this.user;
       delete this._user;
       const closePromise = this.closeConnection(timeout);
@@ -24540,7 +25126,7 @@ var StreamChat = class _StreamChat extends ChatApi {
       closePromise.finally(() => {
         this.tokenManager.reset();
       }).catch(
-        (err) => logger12.withExtraTags("disconnectUser").error("The close promise rejected during disconnect.", { error: err })
+        (err) => logger14.withExtraTags("disconnectUser").error("The close promise rejected during disconnect.", { error: err })
       );
       return closePromise;
     };
@@ -24558,7 +25144,7 @@ var StreamChat = class _StreamChat extends ChatApi {
      */
     this.connectAnonymousUser = () => {
       if (this.node && !this.options.allowServerSideConnect) {
-        logger12.withExtraTags("connectAnonymousUser").warn(
+        logger14.withExtraTags("connectAnonymousUser").warn(
           'Do not use connectUser server-side. connectUser impacts MAU and concurrent connection usage, and therefore your bill. If you have a valid use case, set "allowServerSideConnect: true" in the client options to disable this warning.'
         );
       }
@@ -24712,27 +25298,19 @@ var StreamChat = class _StreamChat extends ChatApi {
         (set) => set?.forEach((handleEvent) => handleEvent(event))
       );
     };
-    this.recoverState = async () => {
-      logger12.withExtraTags("recoverState").info(`Starting state recovery with connection ID ${this._getConnectionID()}.`);
-      const cids = Object.keys(this.activeChannels);
-      if (cids.length && this.recoverStateOnReconnect) {
-        logger12.withExtraTags("recoverState").info(`Starting the query for ${cids.length} channel(s).`);
-        await this.queryChannelsAndHydrate({
-          filter_conditions: {
-            cid: { $in: cids }
-          },
-          limit: 30,
-          sort: [{ field: "last_message_at", direction: -1 }]
-        });
-        logger12.withExtraTags("recoverState").info("Finished querying channels.");
-        this.dispatchEvent({
-          type: "connection.recovered"
-        });
-      } else {
-        this.dispatchEvent({
-          type: "connection.recovered"
-        });
-      }
+    /**
+     * Settles the connect promises after a successful reconnect, so the `await this.wsPromise` gates
+     * spread across the client stop resolving against a superseded (possibly rejected) attempt.
+     *
+     * Called by `StableWSConnection._reconnect()`. Recovery itself is owned by
+     * {@link ConnectionRecoveryManager}, which subscribes to the connection lifecycle and so covers
+     * every reconnect path — including `closeConnection()` → `openConnection()` (mobile backgrounding),
+     * which never reaches `_reconnect()` at all.
+     *
+     * @internal
+     */
+    this._settleConnectPromises = () => {
+      logger14.withExtraTags("_settleConnectPromises").info(`Connection re-established with connection ID ${this._getConnectionID()}.`);
       this.wsPromise = Promise.resolve();
       this.setUserPromise = Promise.resolve();
     };
@@ -24822,7 +25400,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.7";
+        const version = "10.0.0-rc.8";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -24881,7 +25459,6 @@ var StreamChat = class _StreamChat extends ChatApi {
     this.node = !this.browser;
     this.options = {
       warmUp: false,
-      recoverStateOnReconnect: true,
       disableCache: false,
       isLocalUnreadCountEnabled: false,
       wsUrlParams: new URLSearchParams({}),
@@ -24910,13 +25487,14 @@ var StreamChat = class _StreamChat extends ChatApi {
     this.tokenManager = new TokenManager();
     this.insightMetrics = new InsightMetrics();
     this.defaultWSTimeout = 15 * 1e3;
-    this.recoverStateOnReconnect = this.options.recoverStateOnReconnect;
     this.messageStore = new EntityStore({
       getEntityId: (message) => message.id
     });
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
     this.channelManager = new ChannelManager({ client: this });
+    this.connectionRecovery = new ConnectionRecoveryManager({ client: this });
+    this.connectionRecovery.registerSubscriptions();
     this.reminders = new ReminderManager({ client: this });
     this.messageDeliveryReporter = new MessageDeliveryReporter({ client: this });
     this.messageComposerCache = new FixedSizeQueueCache(64);
@@ -24983,6 +25561,7 @@ var StreamChat = class _StreamChat extends ChatApi {
    */
   initializeManagerConfig() {
     const config = this.config.getConfig("client");
+    this.connectionRecovery.initializeConfig(config?.connectionRecovery);
     this.reminders.initializeConfig(config?.reminders);
     this.threads.initializeConfig(config?.threads);
     this.messageDeliveryReporter.initializeConfig(config?.messageDelivery);
@@ -25144,14 +25723,14 @@ var StreamChat = class _StreamChat extends ChatApi {
     const key = callbackOrNothing ? callbackOrString : "all";
     const callback = callbackOrNothing ? callbackOrNothing : callbackOrString;
     const set = this.listeners.get(key) ?? /* @__PURE__ */ new Set();
-    logger12.withExtraTags("on").debug(`Attaching a listener for the "${key}" event.`);
+    logger14.withExtraTags("on").debug(`Attaching a listener for the "${key}" event.`);
     set.add(callback);
     if (!this.listeners.has(key)) {
       this.listeners.set(key, set);
     }
     return {
       unsubscribe: () => {
-        logger12.withExtraTags("on").debug(`Removing the listener for the "${key}" event.`);
+        logger14.withExtraTags("on").debug(`Removing the listener for the "${key}" event.`);
         set.delete(callback);
         if (!set.size) {
           this.listeners.delete(key);
@@ -25162,7 +25741,7 @@ var StreamChat = class _StreamChat extends ChatApi {
   off(callbackOrString, callbackOrNothing) {
     const key = callbackOrNothing ? callbackOrString : "all";
     const callback = callbackOrNothing ? callbackOrNothing : callbackOrString;
-    logger12.withExtraTags("off").debug(`Removing the listener for the "${key}" event.`);
+    logger14.withExtraTags("off").debug(`Removing the listener for the "${key}" event.`);
     const set = this.listeners.get(key);
     set?.delete(callback);
     if (!set?.size) {
@@ -25172,7 +25751,7 @@ var StreamChat = class _StreamChat extends ChatApi {
   _handleClientEvent(event) {
     const client = this;
     const postListenerCallbacks = [];
-    logger12.withExtraTags("_handleClientEvent").debug(`Received an event of type "${event.type}".`, { event });
+    logger14.withExtraTags("_handleClientEvent").debug(`Received an event of type "${event.type}".`, { event });
     if (event.type === "user.presence.changed" || event.type === "user.updated" || event.type === "user.deleted") {
       this._handleUserEvent(event);
     }
@@ -25199,14 +25778,10 @@ var StreamChat = class _StreamChat extends ChatApi {
       this.mutedUsers = event.me.mutes;
     }
     if (event.type === "notification.mark_read" && event.unread_channels === 0) {
-      const activeChannelKeys = Object.keys(this.activeChannels);
-      activeChannelKeys.forEach(
-        (activeChannelKey) => (
-          // resets `read[userId].unread_messages`, which is what the unread badge reads, so it does
-          // not stay stale.
-          this.activeChannels[activeChannelKey]._setOwnUnreadCount(0)
-        )
-      );
+      Object.values(this.activeChannels).forEach((channel) => {
+        if (!channel._setOwnUnreadCount(0)) return;
+        this.channelManager.dropFromUnmatchedLists(channel);
+      });
     }
     if ((event.type === "channel.deleted" || event.type === "notification.channel_deleted") && event.cid) {
       const { cid } = event;
@@ -25461,7 +26036,7 @@ var StreamChat = class _StreamChat extends ChatApi {
           });
         }
       } catch (e) {
-        offlineDbLogger3.withExtraTags("queryReactionsAndHydrate").warn("An error occurred while querying offline reactions.", { error: e });
+        offlineDbLogger2.withExtraTags("queryReactionsAndHydrate").warn("An error occurred while querying offline reactions.", { error: e });
       }
     }
     await this.wsPromise;
@@ -25729,21 +26304,15 @@ var StreamChat = class _StreamChat extends ChatApi {
    */
   async updateMessage(...args) {
     const [request] = args;
-    try {
-      if (this.offlineDb) {
-        return await this.offlineDb.queueTask({
-          task: {
-            ...getPendingTaskChannelData(request.message?.cid),
-            messageId: request.id,
-            payload: args,
-            type: "update-message"
-          }
-        });
+    return await queueOrRun({
+      client: this,
+      task: {
+        ...getPendingTaskChannelData(request.message?.cid),
+        messageId: request.id,
+        payload: args,
+        type: "update-message"
       }
-    } catch (error) {
-      offlineDbLogger3.withExtraTags("updateMessage").error("Updating the message failed.", { error });
-    }
-    return await this._updateMessage(...args);
+    });
   }
   async _updateMessage(...args) {
     return await super.updateMessage(...args);
@@ -25754,28 +26323,14 @@ var StreamChat = class _StreamChat extends ChatApi {
    */
   async deleteMessage(...args) {
     const [request] = args;
-    try {
-      if (this.offlineDb) {
-        if (request.hard) {
-          await this.offlineDb.hardDeleteMessage({ id: request.id });
-        } else {
-          await this.offlineDb.softDeleteMessage({
-            id: request.id,
-            deleteForMe: request.delete_for_me
-          });
-        }
-        return await this.offlineDb.queueTask({
-          task: {
-            messageId: request.id,
-            payload: args,
-            type: "delete-message"
-          }
-        });
+    return await queueOrRun({
+      client: this,
+      task: {
+        messageId: request.id,
+        payload: args,
+        type: "delete-message"
       }
-    } catch (error) {
-      offlineDbLogger3.withExtraTags("deleteMessage").error("Deleting the message failed.", { error });
-    }
-    return this._deleteMessage(...args);
+    });
   }
   async _deleteMessage(...args) {
     const [request] = args;
@@ -26253,7 +26808,19 @@ var REMINDER_FIELDS = {
     type: "number"
   }
 };
+var CONNECTION_RECOVERY_FIELDS = {
+  enabled: {
+    description: "Whether the client recovers its own state on reconnect. Turn it off only if the application re-queries and re-watches everything on screen itself.",
+    kind: "value",
+    type: "boolean"
+  }
+};
 var CLIENT_FIELDS = {
+  connectionRecovery: {
+    description: "Bringing the channels, lists and threads you are reading back in line after a reconnect.",
+    fields: CONNECTION_RECOVERY_FIELDS,
+    kind: "group"
+  },
   messageDelivery: {
     description: "Delivery and read receipt reporting.",
     fields: MESSAGE_DELIVERY_FIELDS,
@@ -26426,7 +26993,7 @@ var OfflineError = class extends Error {
 
 // src/offline-support/offline_sync_manager.ts
 var import_axios5 = require("axios");
-var logger13 = chatLoggerSystem.getLogger("offline-db");
+var logger15 = chatLoggerSystem.getLogger("offline-db");
 var OfflineDBSyncManager = class {
   constructor({
     client,
@@ -26464,7 +27031,7 @@ var OfflineDBSyncManager = class {
           }
         );
       } catch (error) {
-        logger13.withExtraTags("init").error("Failed to initialize the offline DB sync manager.", { error });
+        logger15.withExtraTags("init").error("Failed to initialize the offline DB sync manager.", { error });
       }
     };
     /**
@@ -26551,10 +27118,11 @@ var OfflineDBSyncManager = class {
               channel_cids: cids,
               last_sync_at: lastSyncedAtDate
             });
+            result.events = result.events?.map((event) => decodeWSEvent(event));
             const { syncMaxEventCount } = this;
             const exceedsLimit = typeof syncMaxEventCount === "number" && syncMaxEventCount > 0 && result.events.length > syncMaxEventCount;
             if (exceedsLimit) {
-              logger13.withExtraTags("sync").warn(
+              logger15.withExtraTags("sync").warn(
                 `Skipping sync event replay: received ${result.events.length} events, which exceeds the configured limit of ${syncMaxEventCount}. Visible channels are refreshed on reconnect instead.`
               );
             } else {
@@ -26574,7 +27142,7 @@ var OfflineDBSyncManager = class {
           lastSyncedAt: (/* @__PURE__ */ new Date()).toString()
         });
       } catch (e) {
-        logger13.withExtraTags("syncAndExecutePendingTasks").error("An error occurred while syncing the database.", { error: e });
+        logger15.withExtraTags("syncAndExecutePendingTasks").error("An error occurred while syncing the database.", { error: e });
         if ((0, import_axios5.isAxiosError)(e) && e.code === "ECONNABORTED") {
           return;
         }
@@ -26614,7 +27182,7 @@ var OfflineDBSyncManager = class {
 };
 
 // src/offline-support/offline_support_api.ts
-var logger14 = chatLoggerSystem.getLogger("offline-db");
+var logger16 = chatLoggerSystem.getLogger("offline-db");
 var AbstractOfflineDB = class {
   constructor({
     client,
@@ -26639,7 +27207,7 @@ var AbstractOfflineDB = class {
         }
       } catch (error) {
         this.state.partialNext({ initialized: false, userId: void 0 });
-        logger14.withExtraTags("init").error("Failed to initialize the offline database.", { error });
+        logger16.withExtraTags("init").error("Failed to initialize the offline database.", { error });
       }
     };
     /**
@@ -26685,51 +27253,75 @@ var AbstractOfflineDB = class {
     }, createQueries) => {
       const channelFromEvent = event.channel;
       const cid = event.cid || channelFromEvent?.cid;
-      const type = event.type;
       if (!cid) {
         return await createQueries(execute);
       }
-      const shouldUpsertChannelData = forceUpdate || !await this.channelExists({ cid });
-      if (shouldUpsertChannelData) {
-        const event_ = event;
-        let channelData = channelFromEvent;
-        if (!channelData && event_.channel_type && event_.channel_id) {
-          const channelFromState = this.client.channel(
-            event_.channel_type,
-            event_.channel_id
-          );
-          if (channelFromState.initialized && !channelFromState.pendingDisposal) {
-            channelData = channelFromState.data;
-          }
+      if (execute && !forceUpdate) {
+        try {
+          return await createQueries(true);
+        } catch (error) {
+          if (await this.channelExists({ cid })) throw error;
         }
-        if (channelData) {
-          const channelQuery = await this.upsertChannelData({
-            channel: channelData,
-            execute: false
-          });
-          if (channelQuery) {
-            const createdQueries = await createQueries(false);
-            const newQueries = [...channelQuery, ...createdQueries];
-            if (execute) {
-              await this.executeSqlBatch(newQueries);
-            }
-            return newQueries;
-          } else {
-            logger14.withExtraTags("queriesWithChannelGuard").warn(
-              `Could not create channel queries on a "${type}" event for an initialized channel that is not in the database. Skipping the event.`,
-              { event }
-            );
-            return [];
-          }
-        } else {
-          logger14.withExtraTags("queriesWithChannelGuard").warn(
-            `Received a "${type}" event for a non-initialized channel that is not in the database. Skipping the event.`,
-            { event }
-          );
-          return [];
+        return await this.queriesBehindChannelGuard({
+          createQueries,
+          event,
+          execute: true
+        });
+      }
+      if (!forceUpdate && await this.channelExists({ cid })) {
+        return await createQueries(execute);
+      }
+      return await this.queriesBehindChannelGuard({ createQueries, event, execute });
+    };
+    /**
+     * Prepends the channel row to `createQueries`' output so the queries cannot fail on the `cid`
+     * foreign key, sourcing the channel from the event and falling back to the in-memory channel.
+     *
+     * Skips the write entirely when neither can supply it: without a channel row the queries would fail
+     * anyway, and dropping the event is what the caller expects.
+     */
+    this.queriesBehindChannelGuard = async ({
+      createQueries,
+      event,
+      execute
+    }) => {
+      const type = event.type;
+      const channelFromEvent = event.channel;
+      const event_ = event;
+      let channelData = channelFromEvent;
+      if (!channelData && event_.channel_type && event_.channel_id) {
+        const channelFromState = this.client.channel(
+          event_.channel_type,
+          event_.channel_id
+        );
+        if (channelFromState.initialized && !channelFromState.pendingDisposal) {
+          channelData = channelFromState.data;
         }
       }
-      return await createQueries(execute);
+      if (!channelData) {
+        logger16.withExtraTags("queriesWithChannelGuard").warn(
+          `Received a "${type}" event for a non-initialized channel that is not in the database. Skipping the event.`,
+          { event }
+        );
+        return [];
+      }
+      const channelQuery = await this.upsertChannelData({
+        channel: channelData,
+        execute: false
+      });
+      if (!channelQuery) {
+        logger16.withExtraTags("queriesWithChannelGuard").warn(
+          `Could not create channel queries on a "${type}" event for an initialized channel that is not in the database. Skipping the event.`,
+          { event }
+        );
+        return [];
+      }
+      const createdQueries = await createQueries(false);
+      const newQueries = [...channelQuery, ...createdQueries];
+      if (execute) {
+        await this.executeSqlBatch(newQueries);
+      }
+      return newQueries;
     };
     /**
      * Handles a message.new event. Will always use a channel guard for the inner queries
@@ -26865,6 +27457,92 @@ var AbstractOfflineDB = class {
       }
       return queries;
     };
+    /**
+     * Upsert a single message, first making sure its channel row exists so the insert cannot fail on the
+     * foreign key.
+     *
+     * Concrete on purpose — it composes {@link channelExists}, {@link upsertChannelData} and
+     * {@link upsertMessages}, so every implementation inherits it and no custom offline DB has to
+     * implement anything new (same reasoning as {@link hardDeleteMessages}).
+     *
+     * The guard matters because the message-operations engine writes optimistically, and the very first
+     * message in a freshly created channel can reach here before that channel has ever been persisted.
+     * `upsertMessages` alone is used rather than `updateMessage` because `updateMessage` is an
+     * UPDATE — it no-ops when the row does not exist yet, which is exactly the write-ahead case.
+     *
+     * @param payload.message - The message to persist. Its `cid` decides which channel row is guarded.
+     * @param payload.execute - Whether to immediately execute the operation (optional, defaults to `true`).
+     */
+    this.upsertMessageWithChannelGuard = async ({
+      message,
+      execute = true
+    }) => {
+      const { cid } = message;
+      if (!cid) return [];
+      const messages = [message];
+      if (execute) {
+        try {
+          return await this.upsertMessages({ messages, execute: true });
+        } catch (error) {
+          if (await this.channelExists({ cid })) throw error;
+        }
+        return await this.upsertMessageBehindChannelGuard({ cid, messages, execute: true });
+      }
+      if (await this.channelExists({ cid })) {
+        return await this.upsertMessages({ messages, execute: false });
+      }
+      return await this.upsertMessageBehindChannelGuard({ cid, messages, execute });
+    };
+    /**
+     * Writes the channel row ahead of the messages so the insert cannot fail on the `cid` foreign key.
+     * Skips the write when there is nothing to build a channel row from — the message stays correct in
+     * memory either way, and an insert that cannot resolve its foreign key is not worth attempting.
+     */
+    this.upsertMessageBehindChannelGuard = async ({
+      cid,
+      execute,
+      messages
+    }) => {
+      const channel = this.client.activeChannels[cid];
+      if (!channel?.initialized || channel.pendingDisposal) {
+        logger16.withExtraTags("upsertMessageWithChannelGuard", cid).warn("Skipping message persistence: the channel is not in the database.");
+        return [];
+      }
+      const queries = [
+        ...await this.upsertChannelData({
+          channel: channel.data,
+          execute: false
+        }),
+        ...await this.upsertMessages({ messages, execute: false })
+      ];
+      if (execute) {
+        await this.executeSqlBatch(queries);
+      }
+      return queries;
+    };
+    /**
+     * The messages of a channel that are still in a local `failed` state, i.e. composed by this user but
+     * never accepted by the server.
+     *
+     * Concrete, composed from the existing {@link getChannels} primitive, so it adds nothing to
+     * {@link OfflineDBApi} that a custom offline DB would have to implement.
+     *
+     * This is the buffer that lets a failed message survive. v9 recovered such messages by diffing a
+     * second, lagging copy of the message list (the React SDK state) against `channel.state`; with a
+     * single reactive source of truth the persisted row is the only place that memory can be
+     * re-populated from — see `Channel.reload`.
+     *
+     * @param payload.cid - The channel whose failed messages to read.
+     */
+    this.getFailedMessages = async ({
+      cid
+    }) => {
+      const { initialized, userId } = this.state.getLatestValue();
+      if (!initialized || !userId) return [];
+      const channels = await this.getChannels({ cids: [cid], userId });
+      const messages = channels?.[0]?.messages ?? [];
+      return messages.map((message) => formatMessage(message)).filter((message) => message.status === "failed");
+    };
     /**
      * A utility method to handle read events. It will calculate the state of the reads if
      * present in the event, or optionally rely on the hard override in unreadMessages.
@@ -27322,46 +28000,23 @@ var AbstractOfflineDB = class {
      * @param isPendingTask - a control value telling us if it's an actual pending task being executed
      * or delayed execution
      */
+    /**
+     * Replays one queued operation, through the {@link QUEUEABLE_OPERATIONS} registry rather than a
+     * per-type branch here — the same registry a first attempt resolves through, so the two cannot
+     * describe different requests.
+     *
+     * @param task - the task to run.
+     * @param isPendingTask - whether this is a replay rather than a first attempt. A first attempt has an
+     *   optimistic layer above it that settles local state; a replay does not, so some operations have to
+     *   settle it themselves (see `onReplay`).
+     */
     this.executeTask = async ({ task }, isPendingTask = false) => {
-      if (task.type === "update-message") {
-        return await this.client._updateMessage(...task.payload);
-      }
-      if (task.type === "delete-message") {
-        return await this.client._deleteMessage(...task.payload);
-      }
-      const { channelType, channelId } = task;
-      if (channelType && channelId) {
-        const channel = this.client.channel(channelType, channelId);
-        if (task.type === "send-reaction") {
-          return await channel._sendReaction(...task.payload);
-        }
-        if (task.type === "delete-reaction") {
-          return await channel._deleteReaction(...task.payload);
-        }
-        if (task.type === "create-draft") {
-          return await channel._createDraft(...task.payload);
-        }
-        if (task.type === "delete-draft") {
-          return await channel._deleteDraft(...task.payload);
-        }
-        if (task.type === "send-message") {
-          const newMessageResponse = await channel._sendMessage(...task.payload);
-          const newMessage = newMessageResponse?.message;
-          if (isPendingTask && newMessage) {
-            if (newMessage?.parent_id) {
-              this.client.threads.threadsById[newMessage.parent_id]?.upsertReplyLocally({
-                message: newMessage,
-                timestampChanged: true
-              });
-            }
-            channel.messagePaginator.trackLastMessage(formatMessage(newMessage));
-          }
-          return newMessageResponse;
-        }
+      const result = await runQueueableOperation({ client: this.client, task });
+      if (isPendingTask) {
+        const operation = QUEUEABLE_OPERATIONS[task.type];
+        operation.onReplay?.({ client: this.client, result, task });
       }
-      throw new Error(
-        `Tried to execute invalid pending task type (${task.type}) while synchronizing the database.`
-      );
+      return result;
     };
     /**
      * A utility method used to execute all pending tasks. As each task succeeds execution,