@ethora/chat-component-rn 26.5.21 → 26.6.10

package/src/networking/stanzaHandlers.ts

@@ -9,12 +9,14 @@ import {
   setCurrentRoom,
   setRoomRole,
   updateRoom,
+  mergeUsersSet,
 } from '../roomStore/roomsSlice';
 import { IRoom, RoomMember } from '../types/types';
 import { createMessageFromXml } from '../helpers/createMessageFromXml';
 import { getDataFromXml } from '../helpers/getDataFromXml';
 import { setDeleteModal } from '../roomStore/chatSettingsSlice';
 import { messageNotificationManager } from '../utils/messageNotificationManager';
+import { transformCallLogMessage } from '../helpers/callLogMessage';
 
 // TO DO: we are thinking to refactor this code in the following way:
 // each stanza will be parsed for 'type'
@@ -51,10 +53,21 @@ const onRealtimeMessage = async (stanza: Element) => {
       return;
     }
 
-    if (!data.attrs.senderJID) {
+    // Not every sender stamps `senderJID` onto `<data>` — the web SDK's
+    // translate-tagged send path in particular builds `<data>` from a
+    // differently-named attr bag (roomJID/firstName/userMessage/…) that
+    // has no senderJID at all. This used to hard-drop the message here —
+    // live AND, via the identical check in onMessageHistory, in the MAM
+    // backfill too — so anything sent through that path just never
+    // appeared, on this device or after a restart. The stanza's own
+    // `from` is always the full MUC occupant jid (`room@conference/nick`,
+    // exactly what senderJID would have held), so fall back to it instead
+    // of dropping the message. Web's own onRealtimeMessage only requires
+    // `<data>` to exist at all — no senderJID check — so this brings RN
+    // to the same tolerance.
+    const senderJID = data.attrs.senderJID || stanza.attrs.from;
+    if (!senderJID) {
       console.log(stanza.toString());
-      console.log(data.attrs.senderJID);
-
       console.log('Missing sender information in real-time message.');
       return;
     }
@@ -66,17 +79,29 @@ const onRealtimeMessage = async (stanza: Element) => {
     const parsed = await getDataFromXml(stanza);
     const { data: pData, id: pId, body: pBody, ...pRest } =
       parsed ?? ({} as Partial<NonNullable<typeof parsed>>);
+    const mergedData: Record<string, unknown> = { ...(pData || data.attrs) };
+    if (!mergedData.senderJID) {mergedData.senderJID = senderJID;}
     // Cast at the call site: createMessageFromXml accepts the merged
     // wrapped/positional shape; IUser type drift between models prevents
     // a narrower type here without a wider refactor.
-    const message = await createMessageFromXml({
-      data: pData || data.attrs,
+    const rawMessage = await createMessageFromXml({
+      data: mergedData,
       id: pId || id,
       body: pBody ?? '',
       ...pRest,
       isDeleted: !!deleted || !!pRest?.deleted,
     } as Parameters<typeof createMessageFromXml>[0]);
 
+    // Turn server call-state stanzas into a friendly call-log entry
+    // ("Outgoing call · 12 sec" / "Missed call"). Non-call messages pass
+    // through unchanged. Without this the raw message keeps body
+    // "call-state" and gets dropped by the call-signal filter in
+    // roomsSlice, so call history silently disappears.
+    const message = transformCallLogMessage(
+      rawMessage,
+      store.getState().chatSettingStore.user?.xmppUsername || ''
+    );
+
     const roomJID = stanza.attrs.from.split('/')[0];
     store.dispatch(
       addRoomMessage({
@@ -90,8 +115,8 @@ const onRealtimeMessage = async (stanza: Element) => {
     try {
       const state = store.getState();
       const currentUserWallet = (state.chatSettingStore.user?.walletAddress || '').toLowerCase();
-      const senderJID = String(data.attrs.senderJID || '').toLowerCase();
-      if (currentUserWallet && senderJID.includes(currentUserWallet)) {
+      const senderJIDLower = String(senderJID || '').toLowerCase();
+      if (currentUserWallet && senderJIDLower.includes(currentUserWallet)) {
         return message; // own message, skip toast
       }
       const room = state.rooms.rooms[roomJID];
@@ -193,25 +218,44 @@ const onMessageHistory = async (stanza: any) => {
     }
     // console.log(stanza.attrs.from);
 
-    if (
-      !data?.attrs ||
-      !data.attrs.senderFirstName ||
-      !data.attrs.senderLastName ||
-      !data.attrs.senderJID
-    ) {
+    // Mirror the realtime path's tolerance: don't hard-require
+    // senderFirstName/senderLastName/senderJID on <data> — the web SDK's
+    // translate-tagged send path doesn't stamp any of them, and this used
+    // to drop those messages out of MAM backfill entirely (so they never
+    // appeared even after a restart). The inner forwarded <message>'s own
+    // `from` is the full MUC occupant jid (room@conference/nick), exactly
+    // what senderJID would have held — fall back to it. createMessageFromXml
+    // already derives a display name from the jid when senderFirstName/
+    // senderLastName are absent.
+    const innerFrom =
+      stanza
+        .getChild('result')
+        ?.getChild('forwarded')
+        ?.getChild('message')?.attrs?.from || stanza.attrs.from;
+    const senderJID = data?.attrs?.senderJID || innerFrom;
+    if (!data?.attrs || !senderJID) {
       // console.log(
       //   "Missing sender information in message history.",
       //   stanza.toString()
       // );
       return;
     }
-    const message = await createMessageFromXml(
-      data.attrs,
+    const mergedAttrs = { ...data.attrs };
+    if (!mergedAttrs.senderJID) {mergedAttrs.senderJID = senderJID;}
+    const rawMessage = await createMessageFromXml(
+      mergedAttrs,
       body,
       id,
       stanza.attrs.from,
       !!deleted
     );
+
+    // Same call-log transform as the realtime path, applied to archived
+    // history so calls received while offline still render as log entries.
+    const message = transformCallLogMessage(
+      rawMessage,
+      store.getState().chatSettingStore.user?.xmppUsername || ''
+    );
     store.dispatch(
       addRoomMessage({
         roomJID: stanza.attrs.from,
@@ -349,6 +393,21 @@ const onGetMembers = (stanza: Element) => {
     });
 
     store.dispatch(updateRoom({ jid, updates: { roomMembers } }));
+
+    // Also feed the identity cache Message.tsx reads sender names from
+    // (state.rooms.usersSet). Keyed by both the bare local part and the
+    // full jid since a message's `user.id` can be either depending on
+    // how it was parsed (see createUserNameFromSetUser).
+    const usersSetUpdates: Record<string, RoomMember> = {};
+    for (const member of roomMembers) {
+      if (!member.jid) {continue;}
+      const local = member.jid.split('@')[0];
+      usersSetUpdates[local] = member;
+      usersSetUpdates[member.jid] = member;
+    }
+    if (Object.keys(usersSetUpdates).length > 0) {
+      store.dispatch(mergeUsersSet({ members: usersSetUpdates }));
+    }
   } catch (err) {
     console.warn('onGetMembers parse failed', err);
   }

package/src/networking/xmpp/handleStanzas.xmpp.ts

@@ -18,22 +18,63 @@ import {
   onMessageError,
 } from '../stanzaHandlers';
 import XmppClient from '../xmppClient';
+import { onCallTokenMessage } from '../callTokenStanza';
+
+/**
+ * Unwrap a mucsub event wrapper so the chat handlers see the real inner
+ * `<message>` (the one carrying `<data senderJID=…>` and `<body>`).
+ *
+ * We subscribe every room to `urn:xmpp:mucsub:nodes:messages` (see
+ * subscribeToRoomMessages / pushSubscriptionService), so ejabberd pushes
+ * room traffic as:
+ *
+ *   <message from="room@conference/…">
+ *     <event xmlns="http://jabber.org/protocol/pubsub#event">
+ *       <items node="urn:xmpp:mucsub:nodes:messages">
+ *         <item><message …><data senderJID=…/><body>…</body></message></item>
+ *
+ * Without unwrapping, onRealtimeMessage reads `<data>` off the OUTER
+ * wrapper, finds nothing, logs "Missing data elements in real-time
+ * message" and drops the stanza — so live messages never render and only
+ * surface later through the MAM history fetch (i.e. after an app restart
+ * or re-opening the room). Mirrors the web SDK's handleStanza.
+ */
+const unwrapMucsubMessage = (stanza: Element): Element => {
+  const inner = (stanza as any)
+    ?.getChild?.('event', 'http://jabber.org/protocol/pubsub#event')
+    ?.getChild?.('items')
+    ?.getChild?.('item')
+    ?.getChild?.('message');
+  return (inner as Element) || stanza;
+};
 
 export function handleStanza(stanza: Element, xmppWs: XmppClient) {
   if (stanza?.attrs?.type === 'headline') {return;}
+
+  // Call signaling is swallowed before any chat handler sees it. A
+  // `<data type="call-*">` frame is not user-visible content, and letting
+  // it through renders bubbles reading "Deleted User: call-state" and
+  // fires new-message notifications for a call that never happened.
+  // Returns false for server call-LOGS, which do belong in the chat.
+  if (stanza?.name === 'message' && onCallTokenMessage(stanza)) {
+    return;
+  }
+
   switch (stanza.name) {
-    case 'message':
-      onMessageError(stanza, xmppWs);
-      onReactionMessage(stanza);
-      onReactionHistory(stanza);
-      onDeleteMessage(stanza);
-      onEditMessage(stanza);
-      onChatInvite(stanza, xmppWs);
-      onRealtimeMessage(stanza);
-      onMessageHistory(stanza);
-      handleComposing(stanza, xmppWs.username);
-      onPresenceInRoom(stanza);
+    case 'message': {
+      const unwrapped = unwrapMucsubMessage(stanza);
+      onMessageError(unwrapped, xmppWs);
+      onReactionMessage(unwrapped);
+      onReactionHistory(unwrapped);
+      onDeleteMessage(unwrapped);
+      onEditMessage(unwrapped);
+      onChatInvite(unwrapped, xmppWs);
+      onRealtimeMessage(unwrapped);
+      onMessageHistory(unwrapped);
+      handleComposing(unwrapped, xmppWs.username);
+      onPresenceInRoom(unwrapped);
       break;
+    }
     case 'presence':
       onRoomKicked(stanza);
       onPresenceInRoom(stanza);

package/src/networking/xmpp/sendTextMessage.xmpp.ts

@@ -12,7 +12,7 @@ let _sendTextSeq = 0;
  *
  * Mirrors web's `SERVICE` derivation (utils/runtimeHostConfig.ts).
  */
-const toServiceXmlns = (devServer: string | undefined, client: Client): string => {
+export const toServiceXmlns = (devServer: string | undefined, client: Client): string => {
   // Prefer the URL the client is actually connected to — guaranteed to
   // be the one the server expects.
   const clientService = (client as any)?.options?.service as string | undefined;

package/src/networking/xmpp/sendTextMessageWithTranslateTag.xmpp.ts

@@ -1,6 +1,22 @@
 import { Client, xml } from '@xmpp/client';
 import { Iso639_1Codes } from '../../types/types';
+import { toServiceXmlns } from './sendTextMessage.xmpp';
 
+/**
+ * Same wire message as `sendTextMessage`, plus a `<translate source="xx"/>`
+ * child that DECLARES the message's source language so the backend can
+ * translate it for readers in other languages. No pre-translation happens
+ * client-side.
+ *
+ * The `<data>` element MUST be built identically to `sendTextMessage`
+ * (correct `xmlns` = the `wss://<host>/ws` service URL, and the
+ * `senderFirstName` / `senderLastName` / `senderJID` / `roomJid` attr
+ * names the server + parser expect). An earlier version spread a loose
+ * `stanzaMessage` bag into `<data>` with no xmlns and mismatched attr
+ * names — the server silently dropped those stanzas, so no echo came back
+ * and every sent message stayed stuck in the "pending" state. Keep this in
+ * lockstep with sendTextMessage.xmpp.ts.
+ */
 export const sendTextMessageWithTranslateTag = (
   client: Client,
   stanzaMessage: {
@@ -18,27 +34,47 @@ export const sendTextMessageWithTranslateTag = (
   },
   source: Iso639_1Codes,
   customId?: string
-) => {
-  const id = customId || `get-translate-messsage:${Date.now().toString()}`;
+): boolean => {
+  const id = customId || `send-text-message-${Date.now()}`;
 
   try {
+    const dataXmlns = toServiceXmlns(stanzaMessage.devServer, client);
     const message = xml(
       'message',
       {
         to: stanzaMessage.roomJID,
         type: 'groupchat',
-        id: id,
+        id,
       },
       xml('data', {
-        ...stanzaMessage,
+        xmlns: dataXmlns,
+        senderFirstName: stanzaMessage.firstName,
+        senderLastName: stanzaMessage.lastName,
+        fullName: `${stanzaMessage.firstName} ${stanzaMessage.lastName}`,
+        photoURL: stanzaMessage.photo,
+        senderJID: client.jid?.toString(),
+        senderWalletAddress: stanzaMessage.walletAddress,
+        roomJid: stanzaMessage.roomJID,
+        isSystemMessage: false,
+        tokenAmount: 0,
+        quickReplies: '',
+        notDisplayedValue: '',
+        showInChannel: stanzaMessage.showInChannel || false,
+        isReply: stanzaMessage.isReply || false,
+        mainMessage: stanzaMessage.mainMessage || '',
         push: 'true',
       }),
       xml('body', {}, stanzaMessage.userMessage),
-      xml('translate', { source: source })
+      // `<translate source>` only DECLARES the language this text is in; it
+      // costs nothing to send and is what lets each reader translate the
+      // message into their own language on their side.
+      xml('translate', { source })
     );
 
     client.send(message);
+    return true;
   } catch (error) {
     console.error('An error occurred while sending message:', error);
+    return false;
   }
 };

package/src/networking/xmppClient.ts

@@ -10,6 +10,7 @@ import { sendTypingRequest } from './xmpp/sendTypingRequest.xmpp';
 import { sendPing } from './xmpp/sendPing.xmpp';
 import { getHistory } from './xmpp/getHistory.xmpp';
 import { sendTextMessage } from './xmpp/sendTextMessage.xmpp';
+import { sendTextMessageWithTranslateTag } from './xmpp/sendTextMessageWithTranslateTag.xmpp';
 import { deleteMessage } from './xmpp/deleteMessage.xmpp';
 import { presenceInRoom } from './xmpp/presenceInRoom.xmpp';
 import { getLastMessage } from './xmpp/getLastMessageArchive.xmpp';
@@ -35,6 +36,31 @@ import {
 // Canonical production XMPP WSS endpoint (standard wss/443, no port suffix).
 const DEFAULT_DEV_SERVER = 'xmpp.chat.ethora.com';
 
+// How long to wait for the old client's stop() during a reconnect before
+// giving up on it. Short on purpose: we are already tearing this client
+// down, and a socket that hasn't closed in 3s is exactly the dead one we
+// must not block on. See the call site in reconnect().
+const STOP_TIMEOUT_MS = 3000;
+
+/**
+ * Resolve when `promise` settles or when `ms` elapses, whichever is first.
+ * Never rejects: a teardown that fails or hangs must not break the caller's
+ * control flow (that is the whole point of using it around stop()).
+ */
+function withTimeout(promise: Promise<unknown>, ms: number): Promise<void> {
+  return new Promise<void>((resolve) => {
+    let settled = false;
+    const done = () => {
+      if (settled) {return;}
+      settled = true;
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    Promise.resolve(promise).then(done, done);
+  });
+}
+
 // @xmpp/client surfaces SASL/stream errors in a few shapes depending on
 // where it fails — XMPPError on stream:error, SASLError on SASL bind, or
 // a generic Error whose message contains "not-authorized". Match all of
@@ -697,9 +723,17 @@ export class XmppClient {
       const old = this.client;
       if (old) {
         this.detachEventListeners();
-        try {
-          await old.stop();
-        } catch {}
+        // NEVER await a bare stop(): on a half-dead socket (the exact case
+        // we're reconnecting for) @xmpp/client's stop() can hang forever
+        // waiting on a close handshake that never lands. That leaves this
+        // function parked before `finally`, so `reconnecting` stays true and
+        // EVERY later reconnect — watchdog, NetInfo, AppState — silently
+        // returns at the single-flight guard. The client then never comes
+        // back until the app is killed, which reads as "new messages just
+        // stop arriving". Cap the teardown and move on: initializeClient()
+        // replaces `this.client` anyway, and the old one's listeners are
+        // already detached above, so a late-settling stop() is harmless.
+        await withTimeout(old.stop(), STOP_TIMEOUT_MS);
       }
       this.initializeClient();
     } finally {
@@ -755,12 +789,17 @@ export class XmppClient {
       // handshake can't re-enter handleStanza and dispatch into a store
       // that's being wiped (or, on re-login, the new session's store).
       this.detachEventListeners();
-      try {
-        await this.client.stop();
-        console.log('XMPP client connection closed.');
-      } catch (error) {
-        console.error('Error closing the xmpp client:', error);
-      }
+      // Bounded like the reconnect teardown: a stop() that never settles on
+      // a dead socket would otherwise hang logout (the LOGOUT_EVENT handler
+      // awaits this) and leave the app wedged on the sign-out screen. The
+      // rejection is still logged — only the *waiting* is capped.
+      await withTimeout(
+        Promise.resolve(this.client.stop()).catch((error: unknown) => {
+          console.error('Error closing the xmpp client:', error);
+        }),
+        STOP_TIMEOUT_MS
+      );
+      console.log('XMPP client connection closed.');
     }
     this.status = 'offline';
     this.presencesReady = false;
@@ -1031,6 +1070,13 @@ export class XmppClient {
     console.warn('sendMessageReactionStanza: not implemented in RN xmpp client');
   }
 
+  // Sends a groupchat message carrying a `<translate source="xx"/>` tag so
+  // the backend knows the message's source language and can translate it
+  // for each reader (mirrors the web SDK's send path). `langSource` is the
+  // sender's own language; it only DECLARES the source, no pre-translation
+  // happens client-side. Structure mirrors `sendMessage`: buffer + replay
+  // when the stream isn't ready so a reconnect flush re-sends it, and
+  // forward `customId` so the optimistic bubble reconciles with the echo.
   sendTextMessageWithTranslateTagStanza(
     roomJID: string,
     firstName: string,
@@ -1042,26 +1088,49 @@ export class XmppClient {
     isReply?: boolean,
     showInChannel?: boolean,
     mainMessage?: string,
-    _langSource?: string,
+    langSource?: string,
     customId?: string
-  ) {
-    // No translate tag support yet — fall back to a regular text send.
-    // Forward the caller's customId so the optimistic message (heap/redux)
-    // reconciles with the server echo. Without it, translated sends went
-    // out with no client id → the echo carried a server-assigned id and
-    // surfaced as a stuck-pending message PLUS a duplicate (affected both
-    // the live translated-send path and resend).
-    this.sendMessage(
-      roomJID,
-      firstName,
-      lastName,
-      photo,
-      walletAddress,
-      userMessage,
-      notDisplayedValue,
-      isReply,
-      showInChannel,
-      mainMessage,
+  ): boolean {
+    const source = (langSource || 'en') as any;
+    if (!this.isStreamReady()) {
+      enqueueOutboundSend({
+        optimisticId: customId || `send-text-message-${Date.now()}`,
+        roomJID,
+        enqueuedAt: Date.now(),
+        send: (c) =>
+          c.sendTextMessageWithTranslateTagStanza(
+            roomJID,
+            firstName,
+            lastName,
+            photo,
+            walletAddress,
+            userMessage,
+            notDisplayedValue,
+            isReply,
+            showInChannel,
+            mainMessage,
+            langSource,
+            customId
+          ),
+      });
+      return false;
+    }
+    return sendTextMessageWithTranslateTag(
+      this.client,
+      {
+        roomJID,
+        firstName,
+        lastName,
+        photo,
+        walletAddress,
+        userMessage,
+        notDisplayedValue,
+        isReply,
+        showInChannel,
+        mainMessage,
+        devServer: this.devServer || DEFAULT_DEV_SERVER,
+      },
+      source,
       customId
     );
   }

package/src/roomStore/callSlice.ts

@@ -0,0 +1,190 @@
+import { PayloadAction, createSlice } from '@reduxjs/toolkit';
+
+export type CallPhase =
+  | 'idle'
+  | 'requesting'
+  | 'ringing-incoming'
+  | 'connecting'
+  | 'in-call'
+  | 'error';
+
+export type CallDirection = 'outgoing' | 'incoming' | null;
+export type CallKind = 'audio' | 'video';
+
+export interface CallState {
+  phase: CallPhase;
+  direction: CallDirection;
+  kind: CallKind;
+  roomJid: string | null;
+  roomName: string | null;
+  // Bare room name (JID localpart). Server's call-state stanzas reference
+  // calls by this value, and we echo it back on hangup signaling.
+  roomBareName: string | null;
+  // Stable callId from the call-token data attr (or JWT metadata). Used
+  // when emitting our own call-state hangup so the peer can correlate.
+  callId: string | null;
+  // Peer's XMPP localpart (bare username, no @host). For outgoing we
+  // resolve it from members[]; for incoming we derive it from the room
+  // name format "<userA>-<userB>" minus our own username.
+  peerXmppUsername: string | null;
+  token: string | null;
+  error: string | null;
+  startedAt: number | null;
+  // When the call actually connected (phase -> 'in-call'). Null until then.
+  // Used to compute a duration for the local "call ended" log fallback.
+  connectedAt: number | null;
+}
+
+const initialState: CallState = {
+  phase: 'idle',
+  direction: null,
+  kind: 'video',
+  roomJid: null,
+  roomName: null,
+  roomBareName: null,
+  callId: null,
+  peerXmppUsername: null,
+  token: null,
+  error: null,
+  startedAt: null,
+  connectedAt: null,
+};
+
+const resetState = (): CallState => ({ ...initialState });
+
+const callSlice = createSlice({
+  name: 'call',
+  initialState,
+  reducers: {
+    startOutgoingCall(
+      state,
+      action: PayloadAction<{
+        roomJid: string;
+        roomName?: string | null;
+        roomBareName?: string | null;
+        kind?: CallKind;
+        peerXmppUsername?: string | null;
+      }>
+    ) {
+      state.phase = 'requesting';
+      state.direction = 'outgoing';
+      state.kind = action.payload.kind || 'video';
+      state.roomJid = action.payload.roomJid;
+      state.roomName = action.payload.roomName || null;
+      state.roomBareName =
+        action.payload.roomBareName ||
+        (action.payload.roomJid || '').split('@')[0] ||
+        null;
+      state.peerXmppUsername = action.payload.peerXmppUsername || null;
+      state.callId = null;
+      state.token = null;
+      state.error = null;
+      state.startedAt = Date.now();
+      state.connectedAt = null;
+    },
+    setIncomingCallToken(
+      state,
+      action: PayloadAction<{
+        roomJid: string;
+        roomName?: string | null;
+        roomBareName?: string | null;
+        token: string;
+        kind?: CallKind;
+        callId?: string | null;
+        peerXmppUsername?: string | null;
+      }>
+    ) {
+      state.phase = 'ringing-incoming';
+      state.direction = 'incoming';
+      state.kind = action.payload.kind || 'video';
+      state.roomJid = action.payload.roomJid;
+      state.roomName = action.payload.roomName || null;
+      state.roomBareName =
+        action.payload.roomBareName ||
+        (action.payload.roomJid || '').split('@')[0] ||
+        null;
+      state.callId = action.payload.callId || null;
+      state.peerXmppUsername = action.payload.peerXmppUsername || null;
+      state.token = action.payload.token;
+      state.error = null;
+      state.startedAt = Date.now();
+      state.connectedAt = null;
+    },
+    setOutgoingCallToken(
+      state,
+      action: PayloadAction<{
+        roomJid: string;
+        token: string;
+        callId?: string | null;
+      }>
+    ) {
+      if (state.direction !== 'outgoing') {return;}
+
+      const currentRoom = state.roomJid || '';
+      if (currentRoom && currentRoom !== action.payload.roomJid) {return;}
+
+      state.phase = 'connecting';
+      state.roomJid = action.payload.roomJid;
+      state.token = action.payload.token;
+      if (action.payload.callId) {state.callId = action.payload.callId;}
+      state.error = null;
+      state.startedAt = state.startedAt || Date.now();
+    },
+    acceptIncomingCall(state) {
+      if (state.direction !== 'incoming') {return;}
+      state.phase = 'connecting';
+      state.error = null;
+      state.startedAt = state.startedAt || Date.now();
+    },
+    declineIncomingCall() {
+      return resetState();
+    },
+    endCall() {
+      return resetState();
+    },
+    setCallError(state, action: PayloadAction<string>) {
+      state.phase = 'error';
+      state.error = action.payload;
+      state.startedAt = state.startedAt || Date.now();
+    },
+    setCallPhase(state, action: PayloadAction<CallPhase>) {
+      state.phase = action.payload;
+      if (action.payload === 'in-call') {
+        state.error = null;
+        // Anchor the connect moment once, so a mid-call reconnect blip
+        // doesn't reset the duration used by the local call-end log.
+        state.connectedAt = state.connectedAt || Date.now();
+      }
+    },
+    // Patch the call kind in-place. Used when the server's call-token
+    // stanza doesn't carry a `kind` attribute and we receive the
+    // client-side `call-invite` hint AFTER the call-token has already
+    // landed (race window: token relays through server, invite is direct
+    // chat, normally invite wins but not always).
+    setCallKind(state, action: PayloadAction<CallKind>) {
+      if (state.phase === 'idle') {return;}
+      state.kind = action.payload;
+    },
+    resetCall() {
+      return resetState();
+    },
+  },
+  extraReducers: (builder) => {
+    builder.addCase('chatSettingStore/logout' as any, () => resetState());
+  },
+});
+
+export const {
+  startOutgoingCall,
+  setIncomingCallToken,
+  setOutgoingCallToken,
+  acceptIncomingCall,
+  declineIncomingCall,
+  endCall,
+  setCallError,
+  setCallPhase,
+  setCallKind,
+  resetCall,
+} = callSlice.actions;
+
+export default callSlice.reducer;