@ethora/chat-component-rn 26.7.9 → 26.7.10

package/src/components/MainComponents/ChatRoom.tsx

@@ -6,10 +6,12 @@ import { useDispatch } from 'react-redux';
 import MessageList from './MessageList';
 import SendInput from '../styled/SendInput';
 import {
+  clearReadBoundary,
   clearVisibleRoom,
   deleteRoomMessage,
   setEditAction,
   setLastViewedTimestamp,
+  setReadBoundary,
   setVisibleRoom,
 } from '../../roomStore/roomsSlice';
 import Loader from '../styled/Loader';
@@ -47,7 +49,10 @@ import {
 } from 'react-native-keyboard-controller';
 import useComposing from '../../hooks/useComposing';
 import { store } from '../../roomStore';
-import { getServerReadTimestamp } from '../../helpers/getServerReadTimestamp';
+import {
+  getFlushBoundaryTs,
+  getReadMarkerTimestamp,
+} from '../../helpers/getServerReadTimestamp';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import {
   getInputDockPaddingBottom,
@@ -218,32 +223,62 @@ const ChatRoom: React.FC<ChatRoomProps> = React.memo(
     // Tracks what the user actually saw: `null` while they're at the
     // bottom (safe to mark everything read), or the timestamp of the
     // newest message visible when they scrolled away from it. Reported
-    // by MessageList via onReadBoundaryChange. Without this, leaving a
-    // room (or backgrounding) while scrolled up stamped `now()` as read
-    // and silently discarded genuinely-unread messages. Customer-
-    // reported #33.
-    const readBoundaryRef = useRef<number | null>(null);
+    // by MessageList via onReadBoundaryChange, and mirrored into redux
+    // (`rooms.readBoundaries`) rather than kept only in a local ref - it
+    // is the single source of truth every "leaving this room" path
+    // consults (xmppProvider's AppState background handler, its
+    // `isVisible=false` handler, the live `advance()` effect, and
+    // `useChatRoomFocus`'s `leaveRoom`), not just this component's own
+    // unmount cleanup below. Without a boundary, leaving a room (or
+    // backgrounding) while scrolled up stamped `now()` (bug #33) or,
+    // after the #38 fix, the newest acked message regardless of scroll
+    // position (bug #42) - both silently discard genuinely-unread
+    // messages.
+    //
+    // MessageList reports the boundary from onScroll, which fires on
+    // every frame of a drag (the "back at the bottom" branch re-reports
+    // `null` each time). Mirror only actual CHANGES into redux: an
+    // unconditional dispatch per scroll frame would run the whole
+    // middleware chain and, worse, reset persistenceMiddleware's 200 ms
+    // debounce on every frame, starving the persisted write for as long
+    // as the user keeps scrolling.
+    const lastBoundarySentRef = useRef<number | null>(null);
     const handleReadBoundaryChange = useCallback((boundaryTs: number | null) => {
-      readBoundaryRef.current = boundaryTs;
-    }, []);
+      if (!activeRoomJID) {
+        return;
+      }
+      const next = boundaryTs && boundaryTs > 0 ? boundaryTs : null;
+      if (lastBoundarySentRef.current === next) {
+        return;
+      }
+      lastBoundarySentRef.current = next;
+      dispatch(setReadBoundary({ jid: activeRoomJID, ts: next }));
+    }, [activeRoomJID, dispatch]);
 
     useEffect(() => {
       if (!activeRoomJID) {
         return;
       }
 
-      readBoundaryRef.current = null;
+      lastBoundarySentRef.current = null;
+      dispatch(setReadBoundary({ jid: activeRoomJID, ts: null }));
       dispatch(setVisibleRoom({ roomJID: activeRoomJID }));
       setIsLoadingMore(false);
       return () => {
-        const rooms = store.getState().rooms?.rooms;
-        const heapState = store.getState().roomHeapSlice;
-        // Fall back to the newest server-acked message, never the device
+        const state = store.getState();
+        const rooms = state.rooms?.rooms;
+        const heapState = state.roomHeapSlice;
+        const boundaryTs = state.rooms?.readBoundaries?.[activeRoomJID] ?? null;
+        // getReadMarkerTimestamp honours the boundary (the newest message
+        // the user actually reached) when one is set, and otherwise falls
+        // back to the newest server-acked message - never the device
         // clock: a fast device clock would write a future marker that the
         // forward-only private-store merge could never correct (bug #38).
-        const timestamp =
-          readBoundaryRef.current ??
-          getServerReadTimestamp(rooms?.[activeRoomJID], heapState);
+        const timestamp = getReadMarkerTimestamp(
+          rooms?.[activeRoomJID],
+          heapState,
+          boundaryTs,
+        );
         if (timestamp > 0) {
           dispatch(
             setLastViewedTimestamp({
@@ -261,13 +296,27 @@ const ChatRoom: React.FC<ChatRoomProps> = React.memo(
               // Carry the same boundary to the SERVER marker. Without
               // this the flush defaults to "everything" for the visible
               // room, so messages the user never scrolled down to come
-              // back as read on the next login — the local count was
+              // back as read on the next login - the local count was
               // right but the server overrode it.
-              visibleRoomTs: readBoundaryRef.current,
+              // Clamped through the same helper as the local stamp -
+              // an unclamped boundary would bypass the newest-acked
+              // ceiling on the one path where a bad value is permanent
+              // (the private-store merge is forward-only, bug #38).
+              visibleRoomTs: getFlushBoundaryTs(
+                rooms?.[activeRoomJID],
+                heapState,
+                boundaryTs,
+              ),
             })
             .catch(() => {});
         }
         dispatch(deleteRoomMessage({ roomJID: activeRoomJID, messageId: 'delimiter-new' }));
+        // The room is genuinely being left (unmount, or activeRoomJID
+        // changed to a different room) - release the boundary now that
+        // it's been consumed, so a stale value can't leak into the next
+        // time this room becomes visible.
+        dispatch(clearReadBoundary({ jid: activeRoomJID }));
+        lastBoundarySentRef.current = null;
         setIsLoadingMore(false);
       };
     }, [activeRoomJID, dispatch]);
@@ -303,6 +352,8 @@ const ChatRoom: React.FC<ChatRoomProps> = React.memo(
     const inputDockPaddingBottom = getInputDockPaddingBottom({
       platform: Platform.OS,
       bottomInset: insets.bottom,
+      configuredPadding: configWithEventHandlers?.inputDockPaddingBottom,
+      hostOwnsLayout: !!configWithEventHandlers?.disableKeyboardAvoidingView,
     });
 
     // Keyboard avoidance is delegated to react-native-keyboard-controller's

package/src/context/xmppProvider.tsx

@@ -48,7 +48,10 @@ import {
   deleteRoomMessage,
   setUnreadSyncing,
 } from '../roomStore/roomsSlice';
-import { getServerReadTimestamp } from '../helpers/getServerReadTimestamp';
+import {
+  getFlushBoundaryTs,
+  getReadMarkerTimestamp,
+} from '../helpers/getServerReadTimestamp';
 import { runHistoryPreloadScheduler } from '../helpers/historyPreloadScheduler';
 import { updateMessagesTillLast } from '../helpers/updateMessagesTillLast';
 import { secureUserStorage } from '../helpers/secureUserStorage';
@@ -638,7 +641,8 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       // Mark the open room "not visible" while backgrounded so messages
       // that arrive (or MAM-replay on reconnect) count as unread instead
       // of being silently treated as read — the "mounted == visible ==
-      // read" gap. Stamp lastViewed=<newest server-acked message>, not
+      // read" gap. Stamp lastViewed=<the read boundary, if the user left
+      // scrolled up, else the newest server-acked message>, not
       // Date.now(), as the read baseline: a device clock running ahead
       // would otherwise write a future marker that the forward-only
       // private-store merge can never correct again (bug #38). Then
@@ -647,11 +651,23 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       // here in the provider so consumers using the component as a
       // package get correct unread without reaching into the chat store
       // themselves.
+      //
+      // The read boundary (rooms.readBoundaries) is deliberately left
+      // untouched here - MessageList normally stays mounted through a
+      // simple background/foreground cycle, so its own scroll-tracking
+      // ref (the only thing that could re-derive this value) is still
+      // intact, and clearing the redux copy would desync the two. It's
+      // only USED here for the one-shot stamp+flush, matching customer
+      // #42: leaving (or backgrounding) a room while scrolled up must not
+      // mark messages the user never reached as read.
       visibleBeforeBackground = visibleRoomJID;
+      let boundaryTs: number | null = null;
       if (visibleRoomJID) {
-        const readTs = getServerReadTimestamp(
+        boundaryTs = state.rooms?.readBoundaries?.[visibleRoomJID] ?? null;
+        const readTs = getReadMarkerTimestamp(
           rooms?.[visibleRoomJID],
-          state.roomHeapSlice
+          state.roomHeapSlice,
+          boundaryTs
         );
         // Nothing to anchor to yet (no known messages, no prior marker)
         // - skip the local stamp rather than fall back to the device
@@ -671,10 +687,21 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
         store.dispatch(clearVisibleRoom());
       }
       // Fire-and-forget — we're going to the background and don't
-      // care about the resolution path.
-      c.flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID }).catch(
-        () => {}
-      );
+      // care about the resolution path. `visibleRoomTs` carries the same
+      // boundary to the SERVER marker - without it the flush defaults to
+      // "everything" for the visible room, overriding a correct smaller
+      // local count.
+      c.flushLastViewedToPrivateStoreStanza(rooms, {
+        visibleRoomJID,
+        // Clamped through the same helper as the local stamp above.
+        visibleRoomTs: visibleRoomJID
+          ? getFlushBoundaryTs(
+              rooms?.[visibleRoomJID],
+              state.roomHeapSlice,
+              boundaryTs
+            )
+          : undefined,
+      }).catch(() => {});
     });
     return () => sub.remove();
   }, [client, config?.xmppSettings?.keepAliveInBackground]);
@@ -705,13 +732,24 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
         store.dispatch(setVisibleRoom({ roomJID: activeRoomJID }));
       }
     } else {
+      // The read boundary (rooms.readBoundaries) is USED for the stamp
+      // and flush below but deliberately left in place - a host using
+      // `isVisible` keeps <Chat> mounted while hidden, so MessageList's
+      // own scroll-tracking ref is still intact and the redux copy must
+      // stay in sync with it. Only consumed, never Date.now(): a fast
+      // device clock would write a future marker that the forward-only
+      // private-store merge could then never correct (bug #38). And
+      // never "the newest acked message" unconditionally either - that
+      // silently marks messages the user scrolled past and never reached
+      // as read (bug #42, a regression of #33).
+      const boundaryTs = activeRoomJID
+        ? state.rooms?.readBoundaries?.[activeRoomJID] ?? null
+        : null;
       if (wasVisible && activeRoomJID) {
-        // Never Date.now(): a fast device clock would write a future
-        // marker that the forward-only private-store merge could then
-        // never correct (bug #38).
-        const readTs = getServerReadTimestamp(
+        const readTs = getReadMarkerTimestamp(
           rooms?.[activeRoomJID],
-          state.roomHeapSlice
+          state.roomHeapSlice,
+          boundaryTs
         );
         if (readTs > 0) {
           store.dispatch(
@@ -728,7 +766,19 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       store.dispatch(clearVisibleRoom());
       if (wasVisible && client?.flushLastViewedToPrivateStoreStanza) {
         client
-          .flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: activeRoomJID })
+          .flushLastViewedToPrivateStoreStanza(rooms, {
+            visibleRoomJID: activeRoomJID,
+            // Carry the same boundary to the SERVER marker - without it
+            // the flush defaults to "everything" for the visible room.
+            // Clamped exactly like the local stamp above.
+            visibleRoomTs: activeRoomJID
+              ? getFlushBoundaryTs(
+                  rooms?.[activeRoomJID],
+                  state.roomHeapSlice,
+                  boundaryTs
+                )
+              : undefined,
+          })
           .catch(() => {});
       }
     }
@@ -749,13 +799,21 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       if (room.messages === lastMessagesRef) {return;}
       lastMessagesRef = room.messages;
 
-      // getServerReadTimestamp (not a hand-rolled scan + Date.now()):
+      // getReadMarkerTimestamp (not a hand-rolled scan + Date.now()):
       // it excludes pending/optimistic messages, which carry the DEVICE
       // send time via `date` until the server echoes them back - a
       // manual scan without that exclusion could pick up a pending
       // message's device timestamp here and write a future marker the
-      // same way a raw Date.now() would (bug #38).
-      const newest = getServerReadTimestamp(room, s.roomHeapSlice);
+      // same way a raw Date.now() would (bug #38). And when the user has
+      // scrolled up (a boundary is set for this room), it clamps to that
+      // boundary instead of the newest message - without this, every
+      // incoming message while scrolled up advanced the marker to
+      // "newest" regardless of scroll position, and the later, smaller
+      // boundary write on leave was rejected by the forward-only
+      // private-store merge, leaving 0 unread even after a restart
+      // (customer #42, a regression of #33 reintroduced by #38).
+      const boundaryTs = s.rooms?.readBoundaries?.[jid] ?? null;
+      const newest = getReadMarkerTimestamp(room, s.roomHeapSlice, boundaryTs);
       if (!newest || newest <= lastStampedMs) {return;}
       lastStampedMs = newest;
 
@@ -766,9 +824,20 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       if (flushTimer) {clearTimeout(flushTimer);}
       if (client?.flushLastViewedToPrivateStoreStanza) {
         flushTimer = setTimeout(() => {
+          // Re-read fresh state rather than closing over `boundaryTs`:
+          // the user may have scrolled back to the bottom (clearing the
+          // boundary) in the 2s between the stamp and this flush, and
+          // the flush should reflect that.
+          const freshState = store.getState();
+          const freshBoundaryTs = freshState.rooms?.readBoundaries?.[jid] ?? null;
           client
-            .flushLastViewedToPrivateStoreStanza(store.getState().rooms?.rooms, {
+            .flushLastViewedToPrivateStoreStanza(freshState.rooms?.rooms, {
               visibleRoomJID: jid,
+              visibleRoomTs: getFlushBoundaryTs(
+                freshState.rooms?.rooms?.[jid],
+                freshState.roomHeapSlice,
+                freshBoundaryTs
+              ),
             })
             .catch(() => {});
         }, 2000);

package/src/helpers/getServerReadTimestamp.ts

@@ -1,5 +1,5 @@
 import type { IMessage, IRoom } from '../types/types';
-import { msgSortableMs } from '../roomStore/roomsSlice';
+import { msgSortableMs } from './msgSortableMs';
 
 // A stored/stamped read marker more than this far past the newest
 // message we actually know about for a room is not "the user is a
@@ -42,7 +42,7 @@ type RoomForReadTimestamp = Pick<IRoom, 'jid' | 'messages' | 'lastViewedTimestam
  *    `heapState.failedMessages` (a send that never reached the server
  *    at all).
  *
- * `msgSortableMs` (roomsSlice.ts) reads the server-assigned microsecond
+ * `msgSortableMs` (helpers/msgSortableMs.ts) reads the server-assigned microsecond
  * timestamp encoded in the first 13 digits of the message id - the same
  * source already used for message ordering and unread counting - so
  * this stays consistent with the rest of the read/unread pipeline.
@@ -118,3 +118,80 @@ export function isCorruptFutureReadMarker(
   if (marker <= newestAckedMs + FUTURE_READ_MARKER_TOLERANCE_MS) {return false;}
   return marker > Date.now() + FUTURE_READ_MARKER_TOLERANCE_MS;
 }
+
+/**
+ * Resolve the marker to STAMP (locally and to the server) for `room`,
+ * honouring an explicit read boundary when one is set.
+ *
+ * Bug #42 (a regression of #33, reintroduced by #38): #38 made every
+ * caller stamp the newest server-acknowledged message unconditionally.
+ * That is correct for a user who is at the bottom of the room, but wrong
+ * for a user who scrolled up, received messages, and left without
+ * scrolling back down - stamping "newest" there silently marks
+ * messages they never saw as read, both locally and (because the
+ * private-store merge is forward-only) permanently on the server.
+ *
+ * `boundaryTs` is the msgSortableMs of the newest message the user
+ * actually reached (see `readBoundaries` on `RoomMessagesState`,
+ * populated by MessageList's `onReadBoundaryChange`). When it's set and
+ * positive, it wins - but is still clamped to never exceed the newest
+ * server-acknowledged message, so a stale/corrupt boundary can't stamp a
+ * marker further ahead than the room's own history supports. When no
+ * boundary is set (the common case - the user is at the bottom), this is
+ * exactly `getServerReadTimestamp`.
+ *
+ * Never returns `Date.now()`, directly or indirectly - same rule as
+ * `getServerReadTimestamp` (bug #38).
+ */
+export function getReadMarkerTimestamp(
+  room: RoomForReadTimestamp | null | undefined,
+  heapState?: ReadTimestampHeapState | null,
+  boundaryTs?: number | null
+): number {
+  const newestAcked = getServerReadTimestamp(room, heapState);
+  if (
+    typeof boundaryTs === 'number' &&
+    Number.isFinite(boundaryTs) &&
+    boundaryTs > 0
+  ) {
+    // `newestAcked === 0` means this room has NOTHING server-acked and no
+    // prior marker, so there is nothing to clamp the boundary against -
+    // and MessageList derives the boundary from the rendered list, which
+    // at that point can only contain pending/failed sends carrying the
+    // DEVICE clock via `date`. Returning it here would smuggle a
+    // device-clock marker back in through the boundary (bug #38). Return
+    // 0 = "nothing to anchor to, skip the write", same contract as
+    // getServerReadTimestamp.
+    return newestAcked > 0 ? Math.min(boundaryTs, newestAcked) : 0;
+  }
+  return newestAcked;
+}
+
+/**
+ * The value to hand `flushLastViewedToPrivateStore` as `visibleRoomTs`
+ * for a room being left, or `undefined` when no boundary applies (the
+ * flush then uses its own newest-acked default).
+ *
+ * Exists so the SERVER write goes through the SAME clamp as the local
+ * stamp. Passing the raw redux boundary straight through would bypass
+ * `getReadMarkerTimestamp`'s clamp on exactly the path where a bad value
+ * is permanent: the private-store merge is forward-only, so a boundary
+ * that (through a pending own message's device `date`, or a stale
+ * readBoundaries entry) sat ahead of the room's real history would be
+ * written verbatim and could never be corrected again (bug #38).
+ */
+export function getFlushBoundaryTs(
+  room: RoomForReadTimestamp | null | undefined,
+  heapState?: ReadTimestampHeapState | null,
+  boundaryTs?: number | null
+): number | undefined {
+  if (
+    typeof boundaryTs !== 'number' ||
+    !Number.isFinite(boundaryTs) ||
+    boundaryTs <= 0
+  ) {
+    return undefined;
+  }
+  const clamped = getReadMarkerTimestamp(room, heapState, boundaryTs);
+  return clamped > 0 ? clamped : undefined;
+}

package/src/helpers/insertMessageWithDelimiter.ts

@@ -1,5 +1,35 @@
 import { IMessage } from '../types/types';
 import { isDateAfter, isDateBefore } from './dateComparison';
+import { msgSortableMs } from './msgSortableMs';
+
+// Robustly resolve a caller-supplied read marker to epoch milliseconds.
+// Callers pass a plain number (the redux read boundary, or a room's
+// lastViewedTimestamp), a Date object (older call sites), or occasionally
+// a numeric string. These are NOT interchangeable through the Date
+// constructor: `new Date(1757000000123)` (a number) reads as epoch-ms,
+// but `new Date("1757000000123")` (a string) is parsed as a date STRING
+// - a bare 13-digit string matches no recognized date format, so the
+// result is silently Invalid Date and every comparison against it is
+// `false`. Try Number() first so a numeric string/number is read as
+// epoch-ms; only fall through to Date parsing for genuine date/ISO
+// strings (e.g. a Date object's own `.toString()`). Never falls back to
+// `Date.now()` - a marker we can't resolve is treated as "no marker",
+// not "now" (bug #38).
+function resolveMarkerMs(
+  marker: number | { toString: () => string } | null | undefined
+): number {
+  if (marker == null) {return 0;}
+  if (typeof marker === 'number') {
+    return Number.isFinite(marker) ? marker : 0;
+  }
+  const raw = marker.toString();
+  if (raw.trim() !== '') {
+    const asNumber = Number(raw);
+    if (Number.isFinite(asNumber)) {return asNumber;}
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
 
 function deepMerge(target: any, source: any): any {
   for (const key in source) {
@@ -19,7 +49,7 @@ function deepMerge(target: any, source: any): any {
 export function insertMessageWithDelimiter(
   roomMessages: Partial<IMessage>[],
   message: IMessage,
-  lastViewedTimestamp: { toString: () => string } | null,
+  lastViewedTimestamp: number | { toString: () => string } | null,
 ) {
   const existingIndex = roomMessages.findIndex(
     (msg) =>
@@ -62,33 +92,39 @@ export function insertMessageWithDelimiter(
       roomMessages.push(message);
     }
 
+    const lastViewedMs = resolveMarkerMs(lastViewedTimestamp);
+    const newMessageMs = msgSortableMs(message);
     if (
-      lastViewedTimestamp &&
-      !roomMessages.some((msg) => msg.id === 'delimiter-new') &&
-      isDateAfter(newMessageDate.toString(), lastViewedTimestamp.toString())
+      lastViewedMs > 0 &&
+      newMessageMs > lastViewedMs &&
+      !roomMessages.some((msg) => msg.id === 'delimiter-new')
     ) {
-      const delimiterIndex = roomMessages.findIndex((msg) =>
-        isDateAfter(msg.date?.toString() ?? '', lastViewedTimestamp.toString())
+      // Find the first message STRICTLY newer than the marker, using the
+      // SAME timestamp source (msgSortableMs - the server id-encoded ms)
+      // as the unread middleware and countNewerMessages use to decide
+      // what counts as unread. Comparing against a DIFFERENT source (the
+      // old code compared `msg.date` strings) risks the boundary message
+      // itself landing on the wrong side of the cut: since bug #38 the
+      // marker can equal a real message's own timestamp exactly, and any
+      // drift between `date` and the id-encoded ms - or a raw numeric
+      // marker silently producing an Invalid Date via the Date
+      // constructor's string-parsing path - could count that message as
+      // unread, pushing the divider one message too early (ABOVE the
+      // last read message instead of directly below it). Customer #42.
+      const delimiterIndex = roomMessages.findIndex(
+        (msg) => msg.id !== 'delimiter-new' && msgSortableMs(msg) > lastViewedMs
       );
 
       if (delimiterIndex !== -1) {
         // The divider's date is what ORDERS it: roomsSlice re-sorts every
         // merged page by timestamp (see `byMs`), so a divider stamped with
-        // `new Date()` — i.e. now — sorted past every real message and
+        // `new Date()` (i.e. now) sorted past every real message and
         // rendered at the very bottom, BELOW the new messages it is
         // supposed to introduce. Anchor it a hair before the first unread
         // instead, which is where it belongs and where any later sort keeps
-        // it. Derived from that message rather than from
-        // lastViewedTimestamp so it works whatever format the caller passes.
-        const firstUnreadMs = Date.parse(
-          String(roomMessages[delimiterIndex]?.date ?? '')
-        );
-        const rawLastViewed = lastViewedTimestamp.toString();
-        const lastViewedMs =
-          Date.parse(rawLastViewed) || Number(rawLastViewed) || Date.now();
-        const anchorMs = Number.isFinite(firstUnreadMs)
-          ? firstUnreadMs - 1
-          : lastViewedMs;
+        // it.
+        const firstUnreadMs = msgSortableMs(roomMessages[delimiterIndex]);
+        const anchorMs = firstUnreadMs > 0 ? firstUnreadMs - 1 : lastViewedMs;
 
         roomMessages.splice(delimiterIndex, 0, {
           id: 'delimiter-new',
@@ -103,7 +139,7 @@ export function insertMessageWithDelimiter(
           roomJid: '',
         });
       }
-      }
+    }
   } else if (
     isDateBefore(newMessageDate.toString(), firstMessage?.date?.toString() ?? '')
   ) {

package/src/helpers/keyboardLayout.ts

@@ -14,9 +14,30 @@ export const getKeyboardVerticalOffset = ({
 }: KeyboardLayoutArgs): number =>
   configuredOffset + (platform === 'ios' ? bottomInset : 0);
 
+type InputDockPaddingArgs = Omit<KeyboardLayoutArgs, 'configuredOffset'> & {
+  // Explicit `inputDockPaddingBottom` config value, verbatim on both
+  // platforms when provided (0 allowed). Takes priority over every other
+  // rule below, including `hostOwnsLayout`.
+  configuredPadding?: number;
+  // True when the host app owns keyboard layout entirely (i.e.
+  // `disableKeyboardAvoidingView` is set) and `configuredPadding` was not
+  // given. The dock then gets no built-in bottom padding of its own,
+  // since it already sits above the host's own chrome (e.g. its tab bar).
+  hostOwnsLayout?: boolean;
+};
+
 export const getInputDockPaddingBottom = ({
   platform,
   bottomInset = 0,
   keyboardVisible = false,
-}: Omit<KeyboardLayoutArgs, 'configuredOffset'>): number =>
-  platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;
+  configuredPadding,
+  hostOwnsLayout = false,
+}: InputDockPaddingArgs): number => {
+  if (typeof configuredPadding === 'number') {
+    return configuredPadding;
+  }
+  if (hostOwnsLayout) {
+    return 0;
+  }
+  return platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;
+};

package/src/helpers/msgSortableMs.ts

@@ -0,0 +1,25 @@
+// Count messages strictly newer than a given millisecond timestamp using
+// `msg.id` (the server-authoritative microsecond timestamp prefixed by a
+// 13-digit millis, see `helpers/dateComparison`'s
+// `getHighResolutionTimestamp`) rather than `msg.date`, which can be
+// derived client-side (`createMessageFromXml` falls back to `Date.now()`
+// for realtime stanzas without a `date` attr) and drift from what the
+// server actually assigned.
+//
+// Extracted to its own module (rather than living in roomsSlice.ts, its
+// original home) so helpers that need the SAME ordering source - notably
+// `insertMessageWithDelimiter.ts`, which decides where the "New messages"
+// divider sits - can import it without creating a roomStore <-> helpers
+// import cycle (roomsSlice.ts already imports insertMessageWithDelimiter).
+// roomsSlice.ts re-exports this for backward compatibility with existing
+// call sites.
+export const msgSortableMs = (msg: any): number => {
+  const id = String(msg?.id || '');
+  const m = /^(\d{13})/.exec(id);
+  if (m) {return Number(m[1]);}
+  if (msg?.date) {
+    const t = new Date(msg.date as any).getTime();
+    if (Number.isFinite(t)) {return t;}
+  }
+  return 0;
+};