@ethora/chat-component 26.6.5 → 26.6.7

package/dist/networking/apiClient.d.ts

@@ -1,12 +1,20 @@
+import { RefreshResult } from './authRefresh';
 declare const http: import('axios').AxiosInstance;
 declare let appToken: string;
 export declare function setBaseURL(newBaseURL?: string, customAppToken?: string): void;
-export declare function refresh(): Promise<{
-    data: {
-        refreshToken: string;
-        token: string;
-        fileToken?: string;
-    };
-}>;
+/**
+ * @deprecated Import `refreshAuthTokens` from `./authRefresh` instead.
+ *
+ * Kept as a thin forwarder so existing call sites keep working while
+ * they migrate. Declared as a function (not `const refresh =
+ * refreshAuthTokens`) on purpose: this module and `authRefresh` import
+ * each other, and a const would capture the binding before the other
+ * module finished evaluating.
+ *
+ * Behaviour change vs. the old implementation: it no longer dispatches
+ * `logout()` on every failure. Only a fatal verdict from the backend
+ * ends the session - see the interceptor below.
+ */
+export declare function refresh(): Promise<RefreshResult>;
 export default http;
 export { appToken };

package/dist/networking/authRefresh.d.ts

@@ -0,0 +1,102 @@
+/**
+ * THE single refresh-token rotation point for the SDK.
+ *
+ * The backend now runs refresh-token ROTATION with REUSE DETECTION:
+ * every successful `/v1/users/login/refresh` burns the presented
+ * refresh token and issues a new one. Presenting an already-rotated
+ * token is indistinguishable, server-side, from a stolen token - so it
+ * is treated as theft and (once the backend leaves monitor mode and
+ * enables enforcing mode) kills the whole token family.
+ *
+ * That puts three hard obligations on the client:
+ *
+ *   1. Persist the NEW refreshToken from every response, immediately,
+ *      before any other logic can throw and drop it on the floor.
+ *   2. Never rotate concurrently - including ACROSS TABS. Two parallel
+ *      refreshes both start from the same token; the loser presents a
+ *      burned one and looks like an attacker. Hence Web Locks below,
+ *      plus a same-tab in-flight promise.
+ *   3. Route EVERY refresh path through here. One "side" refresh
+ *      elsewhere (service worker, poller, host app) breaks the scheme
+ *      for everyone.
+ *
+ * The subtle part is (2): serialising the requests is NOT enough. A tab
+ * that waited on the lock still holds the token it read before waiting,
+ * which the winner has since burned. The token must be RE-READ from
+ * cross-tab storage inside the lock - see `performRefresh`.
+ *
+ * Callers must also stop treating 401 as "log out". Two of the four
+ * refresh error codes are race signals, not auth failures - see
+ * `RefreshErrorCode` below and `RefreshFatalError`.
+ */
+export type RefreshErrorCode = 'REFRESH_IN_PROGRESS' | 'REFRESH_TOKEN_ALREADY_ROTATED' | 'REFRESH_TOKEN_REUSE_DETECTED' | 'REFRESH_TOKEN_NOT_FOUND';
+export interface RefreshResult {
+    token: string;
+    refreshToken: string;
+    fileToken?: string;
+    xmppPassword?: string;
+}
+/**
+ * Thrown when the session is genuinely dead and the caller must do a
+ * hard logout (clear storage, drop XMPP, send the user to login).
+ *
+ * Anything else this module rejects with - network errors, 5xx, an
+ * unrecognised 401 - is NOT fatal and must NOT trigger a logout.
+ */
+export declare class RefreshFatalError extends Error {
+    code: RefreshErrorCode;
+    constructor(code: RefreshErrorCode, message?: string);
+}
+export declare const isRefreshFatalError: (error: unknown) => error is RefreshFatalError;
+/**
+ * All four codes come back as HTTP 401, so the status alone tells us
+ * nothing - the code in the body is the only signal.
+ *
+ * TODO(backend-confirm): the exact location of `code` in the payload is
+ * not documented yet. Until it is, probe every shape the API uses
+ * elsewhere and take the first hit. Once confirmed, collapse this to
+ * the single real path.
+ */
+export declare const parseRefreshErrorCode: (error: unknown) => RefreshErrorCode | null;
+/**
+ * Is there anything left to rotate?
+ *
+ * Callers used to answer this by reading the redux copy, which is wrong
+ * in exactly the case that matters: `scrubSensitiveChatStateTransform`
+ * (roomStore/index.ts) blanks token/refreshToken before redux-persist
+ * writes them, so a freshly rehydrated second tab holds an EMPTY
+ * refresh token while the real one sits in `ETHORA_USER_SESSION`. Every
+ * such gate therefore has to go through storage first, same as the
+ * rotation itself.
+ */
+export declare const hasRotatableSession: () => boolean;
+export interface RefreshOptions {
+    /**
+     * Rotate THIS token instead of the one in the store/storage.
+     *
+     * Only for bootstrap, where the session being restored isn't in the
+     * store yet (a host-supplied `userLogin.user`, a persisted record).
+     * Everywhere else, omitting it is the correct and safer choice: the
+     * module then always presents the newest token it knows about.
+     */
+    refreshToken?: string;
+}
+/**
+ * Rotate the tokens. Concurrent callers in this tab share ONE request;
+ * concurrent tabs are serialised by the Web Lock. This is the lock the
+ * new backend scheme requires.
+ *
+ * Rejects with `RefreshFatalError` when the session is dead (caller
+ * should hard-logout) and with a plain error otherwise (caller should
+ * surface the failure and leave the session alone).
+ */
+export declare function refreshAuthTokens(options?: RefreshOptions): Promise<RefreshResult>;
+/**
+ * Fire-and-forget variant for call sites that only want "make sure the
+ * tokens are fresh" and have no meaningful error handling - chat
+ * bootstrap, XMPP reconnect. Never rejects.
+ */
+export declare function refreshAuthTokensQuietly(): Promise<RefreshResult | null>;
+export declare function startCrossTabTokenSync(): () => void;
+/** Test seam: drops any shared in-flight promise between cases. */
+export declare function __resetAuthRefreshStateForTests(): void;

package/dist/networking/xmppClient.d.ts

@@ -2,6 +2,10 @@ import { Client } from '@xmpp/client';
 import { Iso639_1Codes, XmppClientInterface, xmppSettingsInterface, IMessage } from '../types/types';
 import { AllRoomPresenceSummary } from './xmpp/allRoomPresences.xmpp';
 type HistorySource = 'active' | 'send_ack' | 'background' | 'default';
+export type XmppCredentialsProvider = () => Promise<{
+    username: string;
+    password: string;
+}>;
 export declare class XmppClient implements XmppClientInterface {
     client: Client;
     devServer: string | undefined;
@@ -18,7 +22,6 @@ export declare class XmppClient implements XmppClientInterface {
     private reconnecting;
     private reconnectPromise;
     presencesReady: boolean;
-    private sendAllPresencesInFlight;
     private connectionSteps;
     private messageQueue;
     private highLaneBurstLimit;
@@ -81,6 +84,51 @@ export declare class XmppClient implements XmppClientInterface {
     private pausedDueToOfflineCap;
     private authFailureDetected;
     private intentionalLogout;
+    /**
+     * Ported from the RN client (bug #17). The XMPP password now expires
+     * after an hour, so a SASL `not-authorized` is no longer a dead end -
+     * it is the normal, expected end of a credential's life.
+     *
+     * Note the shape of the failure, confirmed with the backend: an
+     * ALREADY-ESTABLISHED connection is NOT dropped when its password
+     * expires - authentication happens once, at SASL bind. So a tab that
+     * simply stays open keeps working indefinitely, and the expiry only
+     * bites on the next (re)connect: a network blip, a laptop waking from
+     * sleep, a server restart. That makes it rare, intermittent and easy
+     * to misdiagnose - and before this hook it was permanent, because the
+     * client latched `authFailureDetected` and refused to reconnect for
+     * the rest of the page's life. Only a reload brought the chat back.
+     */
+    private credentialsProvider;
+    private credentialsRefreshInFlight;
+    /**
+     * Bounded so a genuinely dead session (revoked account, wrong host)
+     * can't spin refresh -> reconnect -> auth-fail forever. Reset on every
+     * successful 'online'.
+     */
+    private authRecoveryAttempts;
+    private maxAuthRecoveryAttempts;
+    /**
+     * Inject (or replace) the callback used to fetch fresh XMPP
+     * credentials after a SASL `not-authorized`. The provider refreshes
+     * whatever upstream credential is needed (the REST session, which now
+     * re-issues the hourly XMPP password) and returns username+password.
+     */
+    setCredentialsProvider(provider: XmppCredentialsProvider | null): void;
+    updateCredentials(username: string, password: string): void;
+    /**
+     * Single-flight wrapper around the provider. Several reconnect paths
+     * (error handler, watchdog, visibility) can fire at once; they share
+     * one request and update the credentials exactly once.
+     */
+    private refreshCredentialsOnce;
+    /**
+     * A SASL failure used to be terminal here. With an hourly XMPP
+     * password it is routine, so try to re-mint credentials and come back
+     * instead of latching the connection off for the rest of the page's
+     * life. Returns true when a retry was started.
+     */
+    private recoverFromAuthFailure;
     private isTerminalAuthFailure;
     constructor(username: string, password: string, xmppSettings?: xmppSettingsInterface);
     initializeClient(): Promise<void>;
@@ -93,7 +141,6 @@ export declare class XmppClient implements XmppClientInterface {
     private startAdaptivePing;
     private markActivity;
     sendAllPresencesAndMarkReady(): Promise<void>;
-    private runAllPresencesSweep;
     reconnect(): Promise<void>;
     allRoomPresencesStanza(): Promise<AllRoomPresenceSummary>;
     ensureConnected(timeout?: number): Promise<void>;

package/dist/roomStore/Middleware/unreadMidlleware.d.ts

@@ -1,3 +1,2 @@
 import { Middleware } from '@reduxjs/toolkit';
-export declare const resolveTouchedRooms: (action: any, prevState: any, nextState: any) => Set<string>;
 export declare const unreadMiddleware: Middleware;

package/dist/roomStore/callSlice.d.ts

@@ -13,7 +13,6 @@ export interface CallState {
     token: string | null;
     error: string | null;
     startedAt: number | null;
-    connectedAt: number | null;
 }
 export declare const startOutgoingCall: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJid: string;

package/dist/roomStore/chatSettingsSlice.d.ts

@@ -8,37 +8,14 @@ interface ChatState {
     selectedUser?: IUser;
     activeFile?: ModalFile;
     langSource?: Iso639_1Codes;
-    /**
-     * Whether THIS reader's own outgoing messages get tagged with
-     * `<translate source="xx"/>` (see sendTextMessageWithTranslateTag) so
-     * translations can be generated for them. Defaults to true so existing
-     * hosts that already set `config.translates.enabled` see no change
-     * until a reader explicitly opts out via the language-selector toggle.
-     *
-     * Turning this off does NOT untag anything already sent - a message
-     * ships with whatever tag was active at send time, permanently. Turning
-     * it back on only affects messages sent from that point forward. Same
-     * asymmetry the other direction: turning it on doesn't retroactively
-     * tag old messages either - see the disclaimer surfaced next to the
-     * toggle in LanguageSelectorModal.
-     */
-    translateSendEnabled?: boolean;
-    /**
-     * Reader's own auto/manual pick from the language-selector modal's
-     * switcher. Undefined means "never touched it" - falls back to
-     * `config.translates.mode` (see resolveTranslateMode). Ignored entirely
-     * when the host sets `config.translates.forceType: true`, which is also
-     * why the switcher itself doesn't render in that case - nothing should
-     * ever write here that a host has pinned.
-     */
-    translateMode?: 'auto' | 'manual';
 }
 export declare const setUser: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<User, "chatSettingStore/setUser">, setConfig: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"chatSettingStore/setConfig">, refreshTokens: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     token: string;
     refreshToken: string;
     fileToken?: string;
+    xmppPassword?: string;
 }, "chatSettingStore/refreshTokens">, logout: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"chatSettingStore/logout">, setActiveModal: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<string, "chatSettingStore/setActiveModal">, setDeleteModal: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<DeleteModal, "chatSettingStore/setDeleteModal">, setSelectedUser: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<IUser, "chatSettingStore/setSelectedUser">, updateUser: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     updates: Partial<User>;
-}, "chatSettingStore/updateUser">, setActiveFile: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ModalFile, "chatSettingStore/setActiveFile">, setLangSource: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<Iso639_1Codes, "chatSettingStore/setLangSource">, setTranslateSendEnabled: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<boolean, "chatSettingStore/setTranslateSendEnabled">, setTranslateMode: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<"auto" | "manual", "chatSettingStore/setTranslateMode">;
+}, "chatSettingStore/updateUser">, setActiveFile: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ModalFile, "chatSettingStore/setActiveFile">, setLangSource: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<Iso639_1Codes, "chatSettingStore/setLangSource">;
 declare const _default: import('redux').Reducer<ChatState>;
 export default _default;

package/dist/roomStore/roomsSlice.d.ts

@@ -9,7 +9,6 @@ interface RoomMessagesState {
     editAction?: EditAction;
     isLoading: boolean;
     usersSet: Record<string, RoomMember>;
-    presenceByRoom: Record<string, string[]>;
     reportRoom: {
         isOpen: boolean;
     };
@@ -68,13 +67,7 @@ export declare const addRoom: import('@reduxjs/toolkit').ActionCreatorWithOption
     chatJID?: string;
 }, "roomMessages/setRoomNoMessages">, setCurrentRoom: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     roomJID: string | null;
-}, "roomMessages/setCurrentRoom">, setMemberOnline: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
-    roomJID: string;
-    xmppUsername: string;
-}, "roomMessages/setMemberOnline">, setMemberOffline: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
-    roomJID: string;
-    xmppUsername: string;
-}, "roomMessages/setMemberOffline">, setChatUiVisible: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<boolean, "roomMessages/setChatUiVisible">, setRoomRole: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
+}, "roomMessages/setCurrentRoom">, setChatUiVisible: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<boolean, "roomMessages/setChatUiVisible">, setRoomRole: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{
     chatJID: string;
     role: string;
 }, "roomMessages/setRoomRole">, setReactions: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ReactionAction, "roomMessages/setReactions">, setLogoutState: import('@reduxjs/toolkit').ActionCreatorWithoutPayload<"roomMessages/setLogoutState">, setActiveMessage: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<{

package/dist/types/models/config.model.d.ts

@@ -201,10 +201,25 @@ export interface IConfig {
     defaultRooms?: ConfigRoom[];
     refreshTokens?: {
         enabled: boolean;
+        /**
+         * Host-owned rotation. When set, the SDK calls this INSTEAD of
+         * `/v1/users/login/refresh` - always, including during bootstrap -
+         * and never rotates the Ethora refresh token itself. Serialised
+         * through the same lock (and the same Web Lock) as the built-in path.
+         *
+         * Return `refreshToken` whenever the host's flow actually rotates an
+         * Ethora refresh token: the backend now treats a re-presented one as
+         * theft, so omitting it leaves a burned token in storage that ends
+         * the session the next time it is used. It stays optional because
+         * some hosts re-mint an access token from a different authority
+         * (SuperTokens, an owner-session endpoint) and hold no Ethora
+         * refresh token at all.
+         */
         refreshFunction?: () => Promise<{
             accessToken: string;
             refreshToken?: string;
             fileToken?: string;
+            xmppPassword?: string;
         } | null>;
     };
     backgroundChat?: {
@@ -223,88 +238,6 @@ export interface IConfig {
     translates?: {
         enabled: boolean;
         translations?: Iso639_1Codes;
-        /**
-         * 'auto' shows the translation inline automatically. 'manual' shows a
-         * "Translate" link the reader clicks (LinkedIn-style), then renders the
-         * result inline with a "Show original" toggle. Default 'auto'.
-         *
-         * Neither mode calls any translation service - both only ever display
-         * `message.translations`, whatever arrived attached to the stanza (see
-         * `readerLocale` below for how a message gets translated in the first
-         * place). This is purely a display choice: show it immediately, or let
-         * the reader ask for it.
-         */
-        mode?: 'auto' | 'manual';
-        /**
-         * Pins `mode` as fixed host policy. When true, the language-selector
-         * modal's auto/manual switcher does not render at all, and the reader
-         * has no way to override `mode` - it's always whatever the host set.
-         * Defaults to false: the reader can flip between auto and manual
-         * themselves via the switcher, which then wins over `mode` (the host's
-         * declared default, used until the reader touches it).
-         */
-        forceType?: boolean;
-        /**
-         * Reader's full locale (BCP-47, e.g. "fr-CA"). Falls back to
-         * `config.i18n.locale`. The region is passed through to `onTranslate` so
-         * the service can distinguish fr-CA vs fr-FR; the Translate button
-         * visibility comparison ignores the region (en-US vs en-CA => no button).
-         *
-         * This is also how a host drives the reader's language from OUTSIDE the
-         * chat component: set it (e.g. from your own app's language switcher)
-         * and pass the updated config down as a normal prop. Whenever it
-         * changes, the component syncs it into the same internal state the
-         * in-chat language picker writes to - so it drives both what a reader
-         * sees translated INTO and the source language declared on their own
-         * outgoing messages. Leave unset to let the reader manage it themselves
-         * via the picker (see `showLanguageSelector`).
-         */
-        readerLocale?: string;
-        /**
-         * Shows/hides the globe-icon language picker in the chat header.
-         * Defaults to true whenever `enabled` is true. Set to false when the
-         * host manages the reader's language itself (via `readerLocale`) and
-         * an in-chat picker would just be a second, redundant control.
-         */
-        showLanguageSelector?: boolean;
-        /**
-         * Shows/hides the list of selectable languages INSIDE the picker
-         * (English/Español/...). Defaults to true. Set to false to keep only
-         * the enable/disable-translates toggle - for hosts that drive the
-         * reader's language externally via `readerLocale` and don't want a
-         * second, redundant language list, but still want the reader to control
-         * whether their own outgoing messages get tagged for translation.
-         */
-        showLanguageList?: boolean;
-        /**
-         * Host-provided translation function. When set, the manual Translate
-         * action calls this - wire it to your own service - instead of reading
-         * `message.translations`. Optional; omit to use only what already
-         * arrived over XMPP.
-         */
-        onTranslate?: (text: string, ctx: {
-            sourceLocale?: string;
-            targetLocale: string;
-            message: IMessage;
-        }) => Promise<string>;
-        /**
-         * Host predicate deciding whether to show the Translate action for a given
-         * message. When omitted, the component compares base languages (message
-         * source vs reader, region ignored) and shows the action when they differ.
-         */
-        showTranslateForMessage?: (message: IMessage) => boolean;
-    };
-    /**
-     * Static UI i18n (interface captions like "Search...", "Type message").
-     * `locale` is a BCP-47 tag the host passes from the device/user (e.g. "en",
-     * "fr-CA", "es-US"); captions resolve to its base language. `strings`
-     * overrides or extends any built-in caption by key (see src/i18n/strings.ts).
-     * Built-in languages: en, fr, es. Independent from `translates` (dynamic
-     * per-message translation).
-     */
-    i18n?: {
-        locale?: string;
-        strings?: Record<string, string>;
     };
     disableRoomConfig?: boolean;
     disableProfilesInteractions?: boolean;
@@ -444,46 +377,6 @@ export interface IConfig {
         iconPath?: string;
         badgePath?: string;
         softAsk?: boolean;
-        /**
-         * In-app banner that nudges the user to turn on browser notifications.
-         * Off by default. The banner renders one of two states automatically from
-         * the current `Notification.permission`:
-         *  - "default" (never asked) → an "Enable notifications" card with a button
-         *    that triggers the browser permission prompt;
-         *  - "denied" (blocked) → a "Notifications are blocked" card explaining how
-         *    to re-allow it from the browser's site settings.
-         * It hides itself entirely once permission is "granted", when the browser
-         * has no Notification API, or when `pushNotifications.enabled` is not true.
-         * Every label is overridable so it can be localised.
-         */
-        permissionBanner?: {
-            /** Master switch for the banner. Default false (opt-in). */
-            enabled?: boolean;
-            /** Show the prompt while permission is "default". Default true. */
-            showWhenDefault?: boolean;
-            /**
-             * Show the notice while permission is "denied". Default false: a blocked
-             * state can only be fixed by hand in the browser's site settings, so by
-             * default we don't nag. Set true to opt back into the reminder.
-             */
-            showWhenBlocked?: boolean;
-            /** Render a dismiss (×) control. Default true. Dismissal lasts the tab session. */
-            dismissible?: boolean;
-            /** Where the fixed banner is anchored. Default "bottom-right". */
-            position?: 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
-            /** Title for the "enable" state. Default "Enable notifications". */
-            enableTitle?: string;
-            /** Description for the "enable" state. */
-            enableDescription?: string;
-            /** Button label for the "enable" state. Default "Enable notifications". */
-            enableButtonLabel?: string;
-            /** Title for the "blocked" state. Default "Notifications are blocked". */
-            blockedTitle?: string;
-            /** Description for the "blocked" state. */
-            blockedDescription?: string;
-            /** Inline style overrides merged onto the banner container. */
-            style?: React.CSSProperties;
-        };
         onClick?: (params: {
             roomJID?: string;
             messageId?: string;

package/dist/types/models/language.model.d.ts

@@ -1,4 +1,4 @@
-export type Iso639_1Codes = 'en' | 'en-CA' | 'es' | 'es-US' | 'pt' | 'ht' | 'fr' | 'fr-CA' | 'zh';
+export type Iso639_1Codes = 'en' | 'es' | 'pt' | 'ht' | 'zh';
 export interface Language {
     iso639_1: Iso639_1Codes;
     name: string;

package/dist/types/models/message.model.d.ts

@@ -22,7 +22,6 @@ export interface IMessage {
     activeMessage?: boolean;
     isReply?: boolean | string;
     isDeleted?: boolean;
-    isEdited?: boolean;
     mainMessage?: string;
     reply?: IReply[];
     reaction?: Record<string, ReactionMessage>;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const ETHORA_CHAT_COMPONENT_VERSION = "26.6.1";
+export declare const ETHORA_CHAT_COMPONENT_VERSION = "26.06.04";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethora/chat-component",
-  "version": "26.6.5",
+  "version": "26.6.7",
   "type": "module",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",

package/public/firebase-messaging-sw.js

@@ -384,10 +384,9 @@ async function handlePush(raw = {}, source = 'push') {
   });
 
   const visible = isVisibleClients(windowClients);
-  const hasAnyClient = windowClients.length > 0;
 
   if (DEBUG) log('clients:', dumpClients(windowClients));
-  log('visibleClientExists:', visible, 'anyClientExists:', hasAnyClient);
+  log('visibleClientExists:', visible);
 
   await broadcastDebugMessage({
     source,
@@ -446,20 +445,9 @@ async function handlePush(raw = {}, source = 'push') {
     },
   };
 
-  // Calls: a client that's merely backgrounded (open, just not the
-  // visible/focused tab) is NOT the "nobody will hear this ring" case -
-  // VideoCallOverlay already rings its own OS notification for exactly
-  // that state (see its comment: this SW push is meant to be the
-  // fully-offline fallback). `visible` collapses "backgrounded but open"
-  // and "fully closed" into the same false, which duplicated that
-  // client-side ring every time the tab was merely hidden. Suppress on
-  // ANY open client for calls; regular messages keep the visible-only
-  // check they already had.
-  const suppress = isCall ? hasAnyClient : visible;
-
-  if (!suppress) {
+  if (!visible) {
     log('SHOW NOTIFICATION', {
-      reason: isCall ? 'NO_CLIENT_AT_ALL' : 'NO_VISIBLE_CLIENT',
+      reason: 'NO_VISIBLE_CLIENT',
       tag: options.tag,
       isCall,
     });
@@ -468,7 +456,7 @@ async function handlePush(raw = {}, source = 'push') {
   }
 
   log('SKIP NOTIFICATION', {
-    reason: isCall ? 'CLIENT_OPEN_WILL_RING_ITSELF' : 'VISIBLE_CLIENT',
+    reason: 'VISIBLE_CLIENT',
   });
 }