@ethora/chat-component-rn 26.8.1 → 26.8.3

package/src/hooks/useChatRoomFocus.ts

@@ -1,12 +1,17 @@
 import { useEffect, useRef } from 'react';
 import { useDispatch } from 'react-redux';
 import {
+  clearReadBoundary,
   clearVisibleRoom,
   setCurrentRoom,
   setLastViewedTimestamp,
   setVisibleRoom,
 } from '../roomStore/roomsSlice';
 import { store } from '../roomStore';
+import {
+  getFlushBoundaryTs,
+  getReadMarkerTimestamp,
+} from '../helpers/getServerReadTimestamp';
 
 interface UseChatRoomFocusOptions {
   /** The room JID that the consumer's tab/screen is currently showing. */
@@ -32,7 +37,10 @@ interface UseChatRoomFocusOptions {
  * Without this hook, `useUnread()` will always return 0 for the chat
  * room because the SDK assumes "mounted == active". With this hook,
  * focus marks the room visible (clearing the badge) and blur stamps
- * `lastViewedTimestamp = Date.now()` so future messages count as unread.
+ * `lastViewedTimestamp` to the newest SERVER-acknowledged message so
+ * future messages count as unread. Deliberately not `Date.now()`: a
+ * device clock running ahead would write a future marker that the
+ * forward-only private-store merge could never correct again (bug #38).
  *
  * Usage with React Navigation:
  *
@@ -58,20 +66,52 @@ export const useChatRoomFocus = ({
     isFocused: false,
   });
 
-  const leaveRoom = (jid: string) => {
-    const timestamp = Date.now();
-    dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
+  // `clearBoundary`: pass true only when the room the user is leaving is
+  // genuinely being released (switching to a different room, or this
+  // hook unmounting) - not on a mere same-room blur. `<ChatRoom>`'s
+  // MessageList typically stays mounted across a same-room focus loss
+  // (the whole point of this hook is that the host keeps `<Chat>`
+  // mounted in a hidden tab), so its own scroll-tracking ref is still
+  // intact and the redux boundary must stay in sync with it - clearing
+  // it here would desync the two.
+  const leaveRoom = (jid: string, clearBoundary: boolean) => {
+    const state = store.getState();
+    const rooms = state.rooms?.rooms;
+    const boundaryTs = state.rooms?.readBoundaries?.[jid] ?? null;
+    // getReadMarkerTimestamp: honour the boundary (the newest message the
+    // user actually reached) when the user left this room scrolled up,
+    // otherwise fall back to the newest server-acked message. Only stamp
+    // when we actually have something to anchor to - skip rather than
+    // fall back to the device clock (bug #38). Ignoring the boundary here
+    // would stamp "everything read" regardless of scroll position (bug
+    // #42, a regression of #33 reintroduced by #38).
+    const timestamp = getReadMarkerTimestamp(rooms?.[jid], state.roomHeapSlice, boundaryTs);
+    if (timestamp > 0) {
+      dispatch(setLastViewedTimestamp({ chatJID: jid, timestamp }));
+    }
     dispatch(clearVisibleRoom());
-    const rooms = store.getState().rooms?.rooms;
-    (store.getState().chatSettingStore as any)?.client
-      ?.flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: jid })
+    (state.chatSettingStore as any)?.client
+      ?.flushLastViewedToPrivateStoreStanza(rooms, {
+        visibleRoomJID: jid,
+        // Carry the same boundary to the SERVER marker - without it the
+        // flush defaults to "everything" for the visible room. Clamped
+        // through the same helper as the local stamp above.
+        visibleRoomTs: getFlushBoundaryTs(
+          rooms?.[jid],
+          state.roomHeapSlice,
+          boundaryTs
+        ),
+      })
       .catch(() => {});
+    if (clearBoundary) {
+      dispatch(clearReadBoundary({ jid }));
+    }
   };
 
   useEffect(() => {
     const prev = prevRef.current;
     if (prev.isFocused && prev.roomJID && (prev.roomJID !== roomJID || !isFocused)) {
-      leaveRoom(prev.roomJID);
+      leaveRoom(prev.roomJID, prev.roomJID !== roomJID);
     }
 
     if (roomJID && isFocused) {
@@ -86,7 +126,7 @@ export const useChatRoomFocus = ({
     return () => {
       const prev = prevRef.current;
       if (prev.isFocused && prev.roomJID) {
-        leaveRoom(prev.roomJID);
+        leaveRoom(prev.roomJID, true);
       }
     };
   }, []);

package/src/hooks/useChatWrapperInit.ts

@@ -9,9 +9,8 @@ import { AppDispatch, RootState } from '../roomStore';
 import { useXmppClient } from '../context/xmppProvider';
 import { chatAutoEnterer } from '../helpers/chatAutoEnterer';
 import { initRoomsPresence } from '../helpers/initRoomsPresence';
-import { updatedChatLastTimestamps } from '../helpers/updatedChatLastTimestamps';
 import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
-import { refresh } from '../networking/apiClient';
+import { refreshAuthTokensQuietly } from '../networking/authRefresh';
 import { setLangSource, setConfig } from '../roomStore/chatSettingsSlice';
 import { setIsLoading } from '../roomStore/roomsSlice';
 import { useRoomState } from './useRoomState';
@@ -19,6 +18,7 @@ import { useChatSettingState } from './useChatSettingState';
 import { isChatIdPresentInArray } from '../helpers/isChatIdPresentInArray';
 import useGetNewArchRoom from './useGetNewArchRoom';
 import { getRoomsWithRetry } from '../helpers/getRoomsWithRetry';
+import { shallowEqual } from '../helpers/shallowEqual';
 
 interface useChatWrapperInitProps {
   roomJID: string | null | undefined;
@@ -66,6 +66,20 @@ const useChatWrapperInit = ({
     };
   }, [user.xmppPassword]);
 
+  // Presentational config flags (e.g. `disableHeader`) can change while the
+  // chat stays mounted — sync them to redux whenever `config` actually
+  // changes, not just at init. Shallow-equal guard: an inline object
+  // literal from the host is a fresh reference every render even when
+  // nothing in it changed, and dispatching unconditionally would re-render
+  // every config consumer on every host render.
+  const lastSyncedConfigRef = useRef<IConfig | undefined>(undefined);
+  useEffect(() => {
+    if (!shallowEqual(lastSyncedConfigRef.current, config)) {
+      lastSyncedConfigRef.current = config;
+      dispatch(setConfig(config));
+    }
+  }, [config, dispatch]);
+
   const getRoomsWithRertyRequest = async () => {
     setIsRetrying(true);
     const retryRooms = await getRoomsWithRetry(
@@ -159,15 +173,21 @@ const useChatWrapperInit = ({
                 }
               }
               try {
+                // getChatsPrivateStoreRequestStanza hydrates redux itself
+                // (dispatch(applyPrivateStoreMarkers(...)) internally,
+                // clamped + forward-only) - do not also apply the raw
+                // return value here. That used to double-dispatch via
+                // updatedChatLastTimestamps' unconditional
+                // setLastViewedTimestamp, which has neither the
+                // forward-only guard nor the future-marker clamp, so on
+                // every reconnect it could silently re-clobber a value
+                // the clamp had just corrected (bug #38).
                 const roomTimestampObject: any =
                   await newClient.getChatsPrivateStoreRequestStanza();
                 console.log(
                   'Got chats private store',
                   roomTimestampObject?.length || 0
                 );
-                if (roomTimestampObject) {
-                  updatedChatLastTimestamps(roomTimestampObject, dispatch);
-                }
                 if (!hasSyncedHistoryRef.current) {
                   console.log('Updating messages till last');
                   await updateMessagesTillLast(rooms, newClient);
@@ -183,7 +203,7 @@ const useChatWrapperInit = ({
               }
 
               {
-                config?.refreshTokens?.enabled && refresh();
+                config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
               }
             } catch (error) {
               console.error(' Error during initialization', error);
@@ -209,15 +229,15 @@ const useChatWrapperInit = ({
             setInited(true);
             console.log(' Getting chats private store for existing client');
             try {
+              // See the "new client" branch above: getChatsPrivateStoreRequestStanza
+              // already hydrates redux (clamped + forward-only); do not
+              // also apply the raw return value here.
               const roomTimestampObject: any =
                 await client.getChatsPrivateStoreRequestStanza();
               console.log(
                 'Got chats private store for existing client',
                 roomTimestampObject?.length || 0
               );
-              if (roomTimestampObject) {
-                updatedChatLastTimestamps(roomTimestampObject, dispatch);
-              }
               if (!hasSyncedHistoryRef.current) {
                 console.log(
                   'Updating messages till last for existing client'
@@ -237,7 +257,7 @@ const useChatWrapperInit = ({
               setConnectionLost(false);
             }
             {
-              config?.refreshTokens?.enabled && refresh();
+              config?.refreshTokens?.enabled && refreshAuthTokensQuietly();
             }
           }
         }

package/src/hooks/useComposing.tsx

@@ -1,4 +1,5 @@
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef } from 'react';
+import { AppState, AppStateStatus } from 'react-native';
 import { useXmppClient } from '../context/xmppProvider';
 import { useSelector } from 'react-redux';
 import { RootState } from '../roomStore';
@@ -9,8 +10,16 @@ const useComposing = (config?: IConfig) => {
   const { client } = useXmppClient();
   const { activeRoomJID } = useSelector((state: RootState) => state.rooms);
   const { user } = useChatSettingState();
+  // RN keeps a focused TextInput focused when the app is backgrounded or
+  // the device is locked — nothing fires `onBlur`, so without this the
+  // other participant sees "typing…" for as long as the user is away.
+  // Tracks whether the input is *currently* focused, independent of the
+  // foreground/background transition, so we know whether to resume
+  // composing on return.
+  const isFocusedRef = useRef(false);
 
   const sendStartComposing = useCallback(() => {
+    isFocusedRef.current = true;
     if (config?.disableTypingIndicator) {
       return;
     }
@@ -24,6 +33,7 @@ const useComposing = (config?: IConfig) => {
   }, [activeRoomJID, client, config?.disableTypingIndicator, user.firstName, user.lastName]);
 
   const sendEndComposing = useCallback(() => {
+    isFocusedRef.current = false;
     if (config?.disableTypingIndicator) {
       return;
     }
@@ -44,6 +54,32 @@ const useComposing = (config?: IConfig) => {
     return () => clearTimeout(timerId);
   }, [sendEndComposing]);
 
+  // Foreground/background transition only — a pause in typing must NOT
+  // clear the indicator (that would flicker for a slowly-composing user),
+  // so this deliberately does not hook keystroke/idle timing at all.
+  useEffect(() => {
+    const handleAppStateChange = (nextState: AppStateStatus) => {
+      if (nextState !== 'active') {
+        if (isFocusedRef.current && !config?.disableTypingIndicator && client) {
+          client.sendTypingRequestStanza(
+            activeRoomJID || '',
+            `${user.firstName} ${user.lastName}`,
+            false
+          );
+        }
+      } else if (isFocusedRef.current && !config?.disableTypingIndicator && client) {
+        client.sendTypingRequestStanza(
+          activeRoomJID || '',
+          `${user.firstName} ${user.lastName}`,
+          true
+        );
+      }
+    };
+
+    const subscription = AppState.addEventListener('change', handleAppStateChange);
+    return () => subscription.remove();
+  }, [activeRoomJID, client, config?.disableTypingIndicator, user.firstName, user.lastName]);
+
   return { sendStartComposing, sendEndComposing };
 };
 

package/src/hooks/useCustomTypingIndicator.tsx

@@ -6,6 +6,7 @@ import {
   generateProcessingText,
 } from '../components/styled/StyledInputComponents/CustomTypingIndicator';
 import { RootState } from '../roomStore';
+import { useTheme } from './useTheme';
 
 /**
  * Hook for managing custom typing indicator functionality
@@ -13,6 +14,7 @@ import { RootState } from '../roomStore';
  */
 export const useCustomTypingIndicator = (roomJID: string) => {
   const { config } = useChatSettingState();
+  const theme = useTheme();
   const { rooms } = useSelector((state: RootState) => ({
     rooms: state.rooms.rooms,
   }));
@@ -68,7 +70,8 @@ export const useCustomTypingIndicator = (roomJID: string) => {
             top: '8px',
             left: '16px',
             right: '16px',
-            background: 'rgba(255, 255, 255, 0.95)',
+            background: theme.surface,
+            color: theme.text,
             padding: '8px 12px',
             borderRadius: '8px',
             boxShadow: '0 2px 8px rgba(0, 0, 0, 0.1)',
@@ -93,7 +96,8 @@ export const useCustomTypingIndicator = (roomJID: string) => {
             position: 'fixed',
             bottom: '80px',
             right: '20px',
-            background: 'rgba(255, 255, 255, 0.95)',
+            background: theme.surface,
+            color: theme.text,
             padding: '12px 16px',
             borderRadius: '20px',
             boxShadow: '0 4px 16px rgba(0, 0, 0, 0.15)',
@@ -108,7 +112,7 @@ export const useCustomTypingIndicator = (roomJID: string) => {
           };
       }
     },
-    [typingConfig?.styles]
+    [typingConfig?.styles, theme]
   );
 
   return {

package/src/hooks/useFileToken.ts

@@ -0,0 +1,7 @@
+import { useSelector } from 'react-redux';
+import { RootState } from '../roomStore';
+
+export const useFileToken = (): string =>
+  useSelector(
+    (state: RootState) => state.chatSettingStore.user?.fileToken || ''
+  );

package/src/hooks/useLogout.tsx

@@ -7,9 +7,11 @@ import { setLogoutState } from '../roomStore/roomsSlice';
 import { useCallback } from 'react';
 import { clearHeap } from '../roomStore/roomHeapSlice';
 import { pushSubscriptionService } from '../services/pushSubscriptionService';
+import { releasePushRegistration } from '../services/pushRegistration';
 import { clearRoomsRestCache } from '../networking/api-requests/rooms.api';
 import { clearPersistedState } from '../roomStore/persistence';
-import { localStorageConstants } from '../helpers/constants/LOCAL_STORAGE';
+import { secureUserStorage } from '../helpers/secureUserStorage';
+import { getFlushBoundaryTs } from '../helpers/getServerReadTimestamp';
 
 // AsyncStorage keys the library writes but that aren't cleared by any
 // slice reducer. Listed here so a single logout call wipes the full
@@ -59,10 +61,23 @@ const logoutService = {
       const client = (state.chatSettingStore as any)?.client;
       const rooms = state.rooms?.rooms;
       const visibleRoomJID = state.rooms?.visibleRoomJID || null;
+      // The visible room is exempt from `onlyIfNoUnread`'s skip (it's
+      // meant to write "read up to now" for whatever's open), so if the
+      // user is logging out while scrolled up with unread messages
+      // above, the boundary must still be carried through here - same
+      // reasoning as every other "leaving a room" path (bug #42).
+      const boundaryTs = visibleRoomJID
+        ? getFlushBoundaryTs(
+            rooms?.[visibleRoomJID],
+            state.roomHeapSlice,
+            state.rooms?.readBoundaries?.[visibleRoomJID] ?? null
+          )
+        : undefined;
       if (client?.flushLastViewedToPrivateStoreStanza) {
         await Promise.race([
           client.flushLastViewedToPrivateStoreStanza(rooms, {
             visibleRoomJID,
+            visibleRoomTs: boundaryTs,
             onlyIfNoUnread: true,
           }),
           new Promise((res) => setTimeout(res, 2000)),
@@ -79,9 +94,15 @@ const logoutService = {
       /* non-fatal */
     }
 
-    // 2. Push: clear locally-subscribed-rooms cache. Doesn't talk to the
-    //    server — that's the host app's responsibility (it owns the FCM/
-    //    APNs token lifecycle).
+    // 2. Push. Release the device-token registration on the backend
+    //    while the access token is still valid (the token itself is kept
+    //    so the next login re-registers it), then clear the local MucSub
+    //    room cache.
+    try {
+      await releasePushRegistration();
+    } catch (e) {
+      console.warn('logoutService: push release failed', e);
+    }
     try {
       await pushSubscriptionService.reset();
     } catch (e) {
@@ -120,17 +141,23 @@ const logoutService = {
 
     // 6. Stray keys the slices don't touch.
     try {
-      await AsyncStorage.multiRemove([
-        ...LIBRARY_STRAY_KEYS,
-        // Belt-and-suspenders: the chat slice's `logout` reducer
-        // schedules an async remove of ETHORA_USER fire-and-forget;
-        // re-issue it here so the disk is provably clean before this
-        // Promise resolves.
-        localStorageConstants.ETHORA_USER,
-      ]);
+      await AsyncStorage.multiRemove(LIBRARY_STRAY_KEYS);
     } catch (e) {
       console.warn('logoutService: stray-key clear failed', e);
     }
+
+    // 7. Belt-and-suspenders: the chat slice's `logout` reducer already
+    //    fires an async ETHORA_USER removal, but re-issue it here (via
+    //    the same secureUserStorage split the reducer uses) so BOTH the
+    //    plain-AsyncStorage profile half AND the Keychain/Keystore
+    //    secrets are provably gone before this Promise resolves — a bare
+    //    `AsyncStorage.removeItem(ETHORA_USER)` here would only clear the
+    //    profile half and leave the tokens behind.
+    try {
+      await secureUserStorage().remove();
+    } catch (e) {
+      console.warn('logoutService: secure user storage clear failed', e);
+    }
   },
 };
 

package/src/hooks/usePendingNotification.ts

@@ -4,7 +4,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import { RootState } from '../roomStore';
 import { setCurrentRoom, clearPendingNotificationJid } from '../roomStore/roomsSlice';
 
-const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
+import { PENDING_NOTIFICATION_JID_KEY, readPendingJid } from '../helpers/pushPayload';
 
 export function usePendingNotification() {
   const dispatch = useDispatch();
@@ -21,21 +21,15 @@ export function usePendingNotification() {
       let jidToOpen = pendingNotificationJid;
 
       if (!jidToOpen) {
-        try {
-          const storedJid = await AsyncStorage.getItem(PENDING_NOTIFICATION_JID_KEY);
-          if (storedJid) {
-            jidToOpen = storedJid;
-            await AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY);
-          }
-        } catch (error) {
-          console.error('Error reading from AsyncStorage:', error);
-        }
+        jidToOpen = await readPendingJid();
       }
 
       if (jidToOpen) {
         const room = rooms[jidToOpen];
         if (room) {
-          return;
+          dispatch(clearPendingNotificationJid());
+          AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY).catch(() => undefined);
+          dispatch(setCurrentRoom({ roomJID: jidToOpen }));
         }
       }
     };

package/src/hooks/useSendMessage.tsx

@@ -9,8 +9,8 @@ import {
   clearMessageFailure,
   markMessageFailed,
 } from '../roomStore/roomHeapSlice';
-import { uploadFileViaFetch } from '../networking/api-requests/auth.api';
-import { enqueueOutboundSend } from '../networking/outboundQueue';
+import { uploadFileV2 } from '../networking/api-requests/auth.api';
+import { enqueueOutboundSend, removeOutboundSend } from '../networking/outboundQueue';
 import { RootState, store } from '../roomStore';
 import { getGlobalXmppClient } from '../utils/clientRegistry';
 import { useEventHandlers } from './useEventHandlers';
@@ -182,17 +182,45 @@ export const useSendMessage = (_configOverride?: IConfig) => {
       // PENDING_WATCHDOG_MS, flip the bubble to "failed → tap to
       // retry". We check at fire-time whether the message is still
       // pending and not already marked failed by the catch path.
-      const watchdogTimer = setTimeout(() => {
+      // One-shot extension for the case below. Declared outside the
+      // timer so the rescheduled run can't extend again.
+      let watchdogExtended = false;
+      const runWatchdog = () => {
         const state = reduxStore.getState();
         const roomMsgs = state.rooms?.rooms?.[activeRoomJID]?.messages || [];
         const stillPending = roomMsgs.find(
           (m: any) => m.id === optimisticId && m.pending
         );
         const alreadyFailed = state.roomHeapSlice?.failedMessages?.[optimisticId];
+
+        // Don't call it a failure while the stream is still coming back.
+        // A reconnect tears the old client down and builds a new one, and
+        // any echo in flight during that window is simply lost — the
+        // message may well have been delivered (it has been observed
+        // arriving twice on the receiving side). Failing it here shows a
+        // red "tap to retry" under a message that actually went through.
+        // Give the reconnect one more window to produce an echo, once.
+        const streamOnline = getGlobalXmppClient()?.status === 'online';
+        if (stillPending && !alreadyFailed && !streamOnline && !watchdogExtended) {
+          watchdogExtended = true;
+          console.warn(
+            `Send watchdog — ${optimisticId} still pending but the stream is not online; extending one window`
+          );
+          watchdogTimer = setTimeout(runWatchdog, PENDING_WATCHDOG_MS);
+          return;
+        }
+
         if (stillPending && !alreadyFailed) {
           console.warn(
             `Send watchdog fired — message ${optimisticId} stuck pending > ${PENDING_WATCHDOG_MS}ms; marking failed`
           );
+          // Drop the buffered replay now that the bubble is showing
+          // "failed / tap to retry" — a later onOnline flush must not
+          // silently resend it behind the user's back. If the original
+          // send actually lands after this point, the server echo still
+          // flips the bubble back to delivered (newMessageMidlleware);
+          // only an explicit tap-to-retry should trigger another send.
+          removeOutboundSend(optimisticId);
           dispatch(
             markMessageFailed({
               kind: 'text',
@@ -211,7 +239,9 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             messageType: 'text',
           });
         }
-      }, PENDING_WATCHDOG_MS);
+      };
+
+      let watchdogTimer = setTimeout(runWatchdog, PENDING_WATCHDOG_MS);
 
       try {
         // The single send closure, used both for the immediate send and for
@@ -285,6 +315,9 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         });
       } catch (error) {
         clearTimeout(watchdogTimer);
+        // Same reasoning as the watchdog: once the bubble shows failed,
+        // only an explicit tap-to-retry should resend it.
+        removeOutboundSend(optimisticId);
         dispatch(
           markMessageFailed({
             kind: 'text',
@@ -431,6 +464,10 @@ export const useSendMessage = (_configOverride?: IConfig) => {
           console.warn(
             `Media-send watchdog fired — ${id} stuck pending > ${PENDING_WATCHDOG_MS}ms; marking failed`
           );
+          // See the text-send watchdog above: drop the buffered replay so
+          // a later onOnline flush can't silently resend behind the
+          // "failed / tap to retry" bubble.
+          removeOutboundSend(id);
           dispatch(
             markMessageFailed({
               kind: 'media',
@@ -467,19 +504,11 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         name: data?.name || data?.fileName || `media_${Date.now()}`,
       };
 
-      // Mirror the web client: a single multipart POST to /files/ with
-      // the file under the plural "files" field. We send it via fetch
-      // (not axios) because RN's fetch sets the multipart boundary on the
-      // Content-Type header correctly. The previous axios fallback omitted
-      // a valid boundary, so the server mis-parsed one file as many and
-      // rejected the request with HTTP 413 "TOO_MANY_FILES". The only
-      // retry is the documented singular-"file" fallback for deployments
-      // that 500 on the plural field (bug #10).
       const tryUpload = async () => {
         const fd = new FormData();
         fd.append('files', fileBlob as any);
         try {
-          return await uploadFileViaFetch(fd);
+          return await uploadFileV2(fd, activeRoomJID);
         } catch (err: any) {
           if (err?.response?.status === 500) {
             console.warn(
@@ -488,7 +517,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
             );
             const fd2 = new FormData();
             fd2.append('file', fileBlob as any);
-            return await uploadFileViaFetch(fd2);
+            return await uploadFileV2(fd2, activeRoomJID);
           }
           throw err;
         }
@@ -646,6 +675,22 @@ export const useSendMessage = (_configOverride?: IConfig) => {
     async (failedId: string) => {
       const payload = failedMessages[failedId];
       if (!payload) {return;}
+
+      // The server may have accepted the original send even though its
+      // echo arrived too late to beat the watchdog — the bubble shows
+      // failed, but a confirmed (non-pending) copy is already sitting in
+      // the room. Resending here would deliver a genuine duplicate; just
+      // clear the failure and let the existing copy stand.
+      const roomMsgs = rooms?.[payload.roomJID]?.messages || [];
+      const alreadyDelivered = roomMsgs.some(
+        (m: any) =>
+          !m.pending && (m.id === failedId || m.xmppId === failedId)
+      );
+      if (alreadyDelivered) {
+        dispatch(clearMessageFailure(failedId));
+        return;
+      }
+
       dispatch(clearMessageFailure(failedId));
       handleMessageRetry({
         messageId: failedId,
@@ -675,7 +720,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         );
       }
     },
-    [failedMessages, dispatch, handleMessageRetry, sendMessage, sendMedia]
+    [failedMessages, rooms, dispatch, handleMessageRetry, sendMessage, sendMedia]
   );
 
   // ChatRoom/ThreadWrapper consume this as the "edit branch" of send.

package/src/hooks/useTheme.ts

@@ -0,0 +1,41 @@
+/** @format */
+
+import { useContext, useMemo, useSyncExternalStore } from 'react';
+import { ReactReduxContext } from 'react-redux';
+import { ThemeContext } from 'styled-components/native';
+import type { RootState } from '../roomStore';
+import { resolveTheme, type ChatTheme } from '../theme/theme';
+
+const noSubscribe = () => () => {};
+
+/**
+ * Effective palette for the current config (light or dark).
+ *
+ * Source order:
+ *   1. the styled-components ThemeProvider mounted by ReduxWrapper (same
+ *      object every styled template sees);
+ *   2. otherwise `config` from the redux store, when a Provider is present
+ *      (components rendered under a bare <Provider> in tests / hosts);
+ *   3. otherwise the light defaults.
+ * Never throws outside a provider, so leaf components stay renderable in
+ * isolation.
+ */
+export const useTheme = (): ChatTheme => {
+  const styledTheme = useContext(ThemeContext) as ChatTheme | undefined;
+  const reduxCtx = useContext(ReactReduxContext);
+  const store = reduxCtx?.store;
+
+  const config = useSyncExternalStore(
+    store ? store.subscribe : noSubscribe,
+    () =>
+      store
+        ? (store.getState() as RootState).chatSettingStore.config
+        : undefined,
+    () => undefined
+  );
+
+  return useMemo(
+    () => (styledTheme && 'statusBarStyle' in styledTheme ? styledTheme : resolveTheme(config)),
+    [styledTheme, config]
+  );
+};

package/src/hooks/useUnreadMessagesCounter.ts

@@ -11,6 +11,12 @@ interface UnreadMessagesStats {
   totalCount: number;
   unreadByRoom: UnreadMessagesMap;
   isLoading: boolean;
+  // True while at least one room's unread count could still be a floor
+  // rather than the true total — the history-preload scheduler paged back
+  // as far as its catch-up budget allows without finding the read
+  // boundary. Lets a host show "99+"-style affordances honestly instead of
+  // implying an exact count it can't back up.
+  isCapped: boolean;
 }
 
 export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
@@ -35,6 +41,7 @@ export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
   const rooms = roomsState.rooms;
   const unreadByRoom: UnreadMessagesMap = {};
   let totalCount = 0;
+  let isCapped = false;
 
   Object.entries(rooms).forEach(([roomJid, room]: [string, IRoom]) => {
     const unreadCount = room.unreadMessages || 0;
@@ -42,6 +49,9 @@ export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
       unreadByRoom[roomJid] = unreadCount;
       totalCount += unreadCount;
     }
+    if ((room as any)?.unreadCapped) {
+      isCapped = true;
+    }
   });
 
   return {
@@ -49,6 +59,7 @@ export const useUnreadMessagesCounter = (): UnreadMessagesStats => {
     totalCount,
     unreadByRoom,
     isLoading: !!roomsState.isUnreadSyncing || !!roomsState.isLoading,
+    isCapped,
   };
 };