@ethora/chat-component-rn 26.10.9 → 26.10.11

package/src/booking/scheduledCallLink.ts

@@ -0,0 +1,145 @@
+import { store } from '../roomStore';
+
+/**
+ * Deep links for scheduled calls.
+ *
+ *   https://<host>/call/<slug>      universal / app link, <host> must be a known host
+ *   <scheme>://call/<slug>          the app's own URL scheme
+ *
+ * The slug is the secret in the link; this only extracts it. Whether the
+ * signed-in user may see the call is the server's answer to
+ * `GET /v1/chats/calls/scheduled/:slug`.
+ *
+ * Known hosts and schemes come from `config.scheduledCalls` and from
+ * `configureScheduledCallLinks()`, which a host calls at startup so a link
+ * that opens the app before `<Chat>` is mounted can already be recognised.
+ */
+
+/** The hosted web app: always accepted. */
+export const DEFAULT_SCHEDULED_CALL_HOSTS = ['app.chat.ethora.com'];
+
+export interface ScheduledCallLinkOptions {
+  /** Hosts whose `https://<host>/call/<slug>` links open the app. */
+  hosts?: string[];
+  /** Custom URL schemes, without `://` (e.g. `ethorachat`). */
+  schemes?: string[];
+}
+
+let configured: Required<ScheduledCallLinkOptions> = { hosts: [], schemes: [] };
+
+const clean = (value: string): string =>
+  String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/:\/\/.*$/, '')
+    .replace(/:$/, '');
+
+const cleanHost = (value: string): string =>
+  String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/^https?:\/\//, '')
+    .replace(/\/.*$/, '')
+    .replace(/:\d+$/, '');
+
+/** Replaces the host list and schemes set by a previous call. */
+export const configureScheduledCallLinks = (
+  options: ScheduledCallLinkOptions
+): void => {
+  configured = {
+    hosts: (options.hosts || []).map(cleanHost).filter(Boolean),
+    schemes: (options.schemes || []).map(clean).filter(Boolean),
+  };
+};
+
+export const __resetScheduledCallLinksForTests = (): void => {
+  configured = { hosts: [], schemes: [] };
+};
+
+const fromStore = (): ScheduledCallLinkOptions => {
+  try {
+    return store.getState().chatSettingStore?.config?.scheduledCalls || {};
+  } catch {
+    return {};
+  }
+};
+
+/** Every host and scheme in force right now. */
+export const getScheduledCallLinkTargets = (): Required<ScheduledCallLinkOptions> => {
+  const fromConfig = fromStore();
+  const hosts = new Set<string>([
+    ...DEFAULT_SCHEDULED_CALL_HOSTS,
+    ...configured.hosts,
+    ...(fromConfig.hosts || []).map(cleanHost),
+  ]);
+  const schemes = new Set<string>([
+    ...configured.schemes,
+    ...(fromConfig.schemes || []).map(clean),
+  ]);
+  hosts.delete('');
+  schemes.delete('');
+  return { hosts: [...hosts], schemes: [...schemes] };
+};
+
+// 22+ url-safe characters per the contract; accept a little shorter so a
+// backend that trims its encoding does not break every link.
+const SLUG = /^[A-Za-z0-9_-]{16,128}$/;
+const URL_SHAPE = /^([a-z][a-z0-9+.-]*):\/\/([^/?#]*)([^?#]*)(?:\?[^#]*)?(?:#.*)?$/i;
+const NEVER_SCHEMES = new Set(['javascript', 'data', 'file', 'blob', 'about', 'vbscript']);
+
+const slugFromPath = (path: string, prefix: '/call/' | '/'): string | null => {
+  if (!path.startsWith(prefix)) {return null;}
+  const rest = path.slice(prefix.length).replace(/\/+$/, '');
+  if (rest.includes('/')) {return null;}
+  let slug = rest;
+  try {
+    slug = decodeURIComponent(rest);
+  } catch {
+    return null;
+  }
+  return SLUG.test(slug) ? slug : null;
+};
+
+/**
+ * The slug of a scheduled-call link, or null when the URL is anything else.
+ *
+ * `https://app.chat.ethora.com/call/<slug>` (and any other configured host)
+ * and `<scheme>://call/<slug>` qualify. With no scheme configured any custom
+ * scheme is accepted (only `http(s)` and a few script-like ones never are);
+ * once schemes are configured only those are.
+ */
+export const parseScheduledCallLink = (
+  url: string | null | undefined,
+  options?: ScheduledCallLinkOptions
+): string | null => {
+  if (typeof url !== 'string') {return null;}
+  const match = URL_SHAPE.exec(url.trim());
+  if (!match) {return null;}
+  const scheme = match[1].toLowerCase();
+  const authority = match[2];
+  const path = match[3] || '';
+
+  const targets = getScheduledCallLinkTargets();
+  const hosts = options?.hosts?.length
+    ? options.hosts.map(cleanHost)
+    : targets.hosts;
+  const schemes = options?.schemes?.length
+    ? options.schemes.map(clean)
+    : targets.schemes;
+
+  if (scheme === 'https' || scheme === 'http') {
+    // Universal links are https only; a plain http link is never trusted.
+    if (scheme !== 'https') {return null;}
+    if (authority.includes('@')) {return null;}
+    const host = cleanHost(authority);
+    if (!host || !hosts.includes(host)) {return null;}
+    return slugFromPath(path, '/call/');
+  }
+
+  if (NEVER_SCHEMES.has(scheme)) {return null;}
+  if (schemes.length > 0 && !schemes.includes(scheme)) {return null;}
+  // <scheme>://call/<slug>; some launchers hand over <scheme>:///call/<slug>.
+  if (authority.toLowerCase() === 'call') {return slugFromPath(path, '/');}
+  if (authority === '') {return slugFromPath(path, '/call/');}
+  return null;
+};

package/src/booking/scheduledCallStore.ts

@@ -0,0 +1,69 @@
+import { useSyncExternalStore } from 'react';
+import type {
+  ScheduledCallDetail,
+} from '../networking/api-requests/scheduledCalls.api';
+
+/**
+ * UI state of the scheduled-call flow: the pre-join sheet (a call opened from
+ * a card or a link) and the editor (schedule a new call / edit one). Kept
+ * outside redux because it is transient and has no business in persistence,
+ * the same way the call overlay's own UI state is (VideoCalls/callUiStore).
+ */
+
+export type PreJoinErrorReason =
+  | 'not-a-member'
+  | 'not-found'
+  | 'cancelled'
+  | 'network';
+
+export type PreJoinState =
+  | { phase: 'loading'; slug: string }
+  | { phase: 'ready'; slug: string; detail: ScheduledCallDetail }
+  | {
+      phase: 'error';
+      slug: string;
+      reason: PreJoinErrorReason;
+      /** The call's title when the server told us (cancelled). */
+      title?: string;
+    };
+
+export type EditorState =
+  | { mode: 'create'; roomJid: string }
+  | { mode: 'edit'; roomJid: string; detail: ScheduledCallDetail };
+
+interface ScheduledCallUiState {
+  preJoin: PreJoinState | null;
+  editor: EditorState | null;
+}
+
+let state: ScheduledCallUiState = { preJoin: null, editor: null };
+const listeners = new Set<() => void>();
+
+const emit = (patch: Partial<ScheduledCallUiState>) => {
+  state = { ...state, ...patch };
+  listeners.forEach((listener) => listener());
+};
+
+export const scheduledCallUi = {
+  getState: (): ScheduledCallUiState => state,
+  subscribe: (listener: () => void): (() => void) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  },
+  showPreJoin: (preJoin: PreJoinState) => emit({ preJoin }),
+  closePreJoin: () => emit({ preJoin: null }),
+  openCreate: (roomJid: string) => emit({ editor: { mode: 'create', roomJid } }),
+  openEdit: (roomJid: string, detail: ScheduledCallDetail) =>
+    emit({ editor: { mode: 'edit', roomJid, detail } }),
+  closeEditor: () => emit({ editor: null }),
+  reset: () => emit({ preJoin: null, editor: null }),
+};
+
+export const useScheduledCallUi = (): ScheduledCallUiState =>
+  useSyncExternalStore(
+    scheduledCallUi.subscribe,
+    scheduledCallUi.getState,
+    scheduledCallUi.getState
+  );

package/src/booking/startRoomCall.ts

@@ -0,0 +1,103 @@
+import { store } from '../roomStore';
+import {
+  acceptIncomingCall,
+  setCallError,
+  startOutgoingCall,
+} from '../roomStore/callSlice';
+import { sendCallInviteSignal } from '../networking/callTokenStanza';
+import { requestOutgoingCall } from '../calls/startCall';
+import { chatNameOfRoom } from './scheduledCall';
+
+/**
+ * Joining a scheduled call is the ordinary call start for that room, taken
+ * on a user tap: a private room starts (or answers) its call, a group or
+ * public room starts or joins the room call. This file is the ONE place the
+ * booking flow reaches into the call path, so when the call transport
+ * changes only this function follows (it mirrors CallButtons.placeCall and
+ * hands the request to the shared requestOutgoingCall, so a private room
+ * gets the p2p call and a group room the LiveKit one, as the server decides).
+ */
+
+export type StartRoomCallOutcome =
+  | 'started'
+  | 'answered'
+  | 'busy'
+  | 'disabled'
+  | 'no-room'
+  | 'failed';
+
+const BAD_TITLES = ['deleted', 'deleted user', 'unknown', 'null'];
+
+export const startRoomCall = async (
+  roomJid: string,
+  kind: 'audio' | 'video'
+): Promise<StartRoomCallOutcome> => {
+  const state = store.getState();
+  if (state.chatSettingStore.config?.videoCalls?.enabled !== true) {
+    return 'disabled';
+  }
+  const chatName = chatNameOfRoom(roomJid);
+  if (!chatName) {return 'no-room';}
+
+  const room = Object.values(state.rooms.rooms || {}).find(
+    (r: any) => chatNameOfRoom(r?.jid || '') === chatName
+  ) as any;
+  const fullJid: string = room?.jid || roomJid;
+  if (!fullJid.includes('@')) {return 'no-room';}
+
+  const call = state.call;
+  if (call.phase !== 'idle') {
+    // The same room is already ringing us: joining means answering it.
+    if (
+      call.phase === 'ringing-incoming' &&
+      call.roomBareName === chatName
+    ) {
+      store.dispatch(acceptIncomingCall());
+      return 'answered';
+    }
+    return 'busy';
+  }
+
+  const selfLocal = String(
+    state.chatSettingStore.user?.xmppUsername || ''
+  ).split('@')[0];
+  const isGroup = room?.type === 'group';
+  const peer =
+    room?.type === 'private'
+      ? (room?.members || []).find((member: any) => {
+          const local = String(member?.xmppUsername || '').split('@')[0];
+          return local && local !== selfLocal;
+        })
+      : undefined;
+  const peerXmppUsername: string | null = peer?.xmppUsername || null;
+
+  const rawTitle = String(room?.title || room?.name || '').trim();
+  const peerDisplay = peer
+    ? `${peer.firstName || ''} ${peer.lastName || ''}`.trim() || peer.name || ''
+    : '';
+  const bad = !rawTitle || BAD_TITLES.includes(rawTitle.toLowerCase());
+  const dialName = (bad ? peerDisplay : rawTitle) || peerDisplay || chatName;
+
+  store.dispatch(
+    startOutgoingCall({
+      roomJid: fullJid,
+      roomName: dialName,
+      roomBareName: chatName,
+      kind,
+      peerXmppUsername,
+      isGroup,
+    })
+  );
+  if (peerXmppUsername) {
+    sendCallInviteSignal(kind, { peerXmppUsername, roomBareName: chatName });
+  }
+  try {
+    await requestOutgoingCall({ chatName, kind, peerXmppUsername });
+    return 'started';
+  } catch (error) {
+    store.dispatch(
+      setCallError(error instanceof Error ? error.message : 'call failed')
+    );
+    return 'failed';
+  }
+};

package/src/calls/callBusy.ts

@@ -0,0 +1,10 @@
+import type { BusyCallSnapshot } from './callMode';
+
+/**
+ * The call slice as `decideIncomingWhileBusy` should see it. A call that
+ * failed (phase 'error') only has its error card left on screen, waiting to
+ * be dismissed; it must not make the phone refuse the next incoming call as
+ * busy.
+ */
+export const busySnapshot = (call: BusyCallSnapshot): BusyCallSnapshot =>
+  call.phase === 'error' ? { ...call, phase: 'idle' } : call;

package/src/calls/callDisplay.ts

@@ -0,0 +1,74 @@
+// Display-name hygiene for the call UI. Names reach the ring screen from
+// several places (a call-token attribute, a JWT claim, a room title, a push
+// payload); this keeps raw identifiers and hostile text from ever being shown
+// as a person's name.
+
+/** Shown on the ring screen when no human-readable name is known. */
+export const NEUTRAL_INCOMING_CALL_LABEL = 'Incoming call';
+
+const MAX_CALL_NAME_LENGTH = 80;
+
+const HEX24 = '[0-9a-fA-F]{24}';
+// A user JID local part: <appId>_<userId>, optionally with an @domain.
+const USER_ID = `${HEX24}_${HEX24}(?:@[A-Za-z0-9.]+)?`;
+
+// A 1:1 chat is named "<jidA>-<jidB>" (two user ids joined by a hyphen).
+const ONE_TO_ONE_ROOM = new RegExp(`^${USER_ID}(?:-${USER_ID})*$`);
+// A group chat is named "<appId>_<uuid>".
+const GROUP_ROOM = new RegExp(
+  `^${HEX24}_[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$`
+);
+// Anything long that is nothing but hex, underscores and hyphens is an id.
+const OPAQUE_ID = /^[0-9a-f_-]{16,}$/i;
+
+/**
+ * True for strings that are a chat's internal name or an id rather than
+ * something a person would be called: two user JIDs joined (the private chat
+ * name), a lone user id, an `<appId>_<uuid>` group name, or any long run of
+ * hex / underscore / hyphen.
+ */
+export const looksLikeRawRoomName = (value: unknown): boolean => {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) return false;
+  return (
+    ONE_TO_ONE_ROOM.test(text) ||
+    GROUP_ROOM.test(text) ||
+    OPAQUE_ID.test(text)
+  );
+};
+
+// C0/C1 controls, bidi overrides/isolates and zero-width characters: none of
+// them belong in a name, and the bidi ones can make text read backwards.
+// eslint-disable-next-line no-control-regex
+const UNWANTED_CHARS = /[\u0000-\u001F\u007F-\u009F​-‏‪-‮⁠-⁤⁦-⁩]/g;
+
+/**
+ * Plain-text, display-safe version of a name: control characters stripped,
+ * whitespace collapsed and trimmed, capped at about 80 characters. Returns ''
+ * when nothing usable is left or the value is a raw chat name / id.
+ */
+export const sanitizeCallName = (value: unknown): string => {
+  if (typeof value !== 'string') return '';
+  const cleaned = value
+    .replace(UNWANTED_CHARS, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!cleaned) return '';
+  // Cap by code point so a surrogate pair is never cut in half.
+  const capped = Array.from(cleaned).slice(0, MAX_CALL_NAME_LENGTH).join('').trim();
+  return looksLikeRawRoomName(capped) ? '' : capped;
+};
+
+/** sanitizeCallName with null instead of '' (state-friendly). */
+export const safeCallName = (value: unknown): string | null =>
+  sanitizeCallName(value) || null;
+
+/**
+ * An xmppUsername from a stanza attribute, or null when it is not shaped like
+ * one (it is only ever used for lookups and routing, never shown).
+ */
+export const sanitizeXmppUsername = (value: unknown): string | null => {
+  const text = typeof value === 'string' ? value.trim() : '';
+  const local = text.split('/')[0];
+  return /^[A-Za-z0-9_-]{1,128}(?:@[A-Za-z0-9.-]+)?$/.test(local) ? local : null;
+};

package/src/calls/callMode.ts

@@ -0,0 +1,286 @@
+// Pure helpers that decide HOW a call is carried, shared by the dialer
+// (ChatHeader), the stanza handler (callTokenStanza) and the overlay.
+//
+// Three kinds of call exist:
+//   - 1:1 over our own WebRTC peer connection ("p2p"): chosen by the server,
+//     only for private chats and only when the install has P2P enabled;
+//   - 1:1 over LiveKit: the fallback when the server answers `livekit`;
+//   - group over LiveKit: any non-private chat, always `livekit`.
+// The client never picks the transport, it follows the server's `mode`.
+
+import { sanitizeCallName, sanitizeXmppUsername } from './callDisplay';
+
+export type CallMode = 'livekit' | 'p2p';
+export type CallKindName = 'audio' | 'video';
+export type CallRoomType = 'private' | 'group';
+
+/** Serializable subset of RTCIceServer (kept free of DOM types for redux). */
+export interface IceServerConfig {
+  urls: string | string[];
+  username?: string;
+  credential?: string;
+}
+
+const ICE_URL_RE = /^(stun|stuns|turn|turns):/i;
+
+/**
+ * Accepts an array, an `{ iceServers }` envelope or a JSON string of either
+ * (the call-token stanza carries the list as a JSON attribute) and returns
+ * only well formed stun/turn entries. Anything else is dropped, never thrown.
+ */
+export const normalizeIceServers = (raw: unknown): IceServerConfig[] => {
+  let value: unknown = raw;
+  if (typeof value === 'string') {
+    const text = value.trim();
+    if (!text) return [];
+    try {
+      value = JSON.parse(text);
+    } catch {
+      return [];
+    }
+  }
+  if (
+    value &&
+    !Array.isArray(value) &&
+    typeof value === 'object' &&
+    Array.isArray((value as { iceServers?: unknown }).iceServers)
+  ) {
+    value = (value as { iceServers: unknown[] }).iceServers;
+  }
+  if (!Array.isArray(value)) return [];
+
+  const out: IceServerConfig[] = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== 'object') continue;
+    const e = entry as Record<string, unknown>;
+    const rawUrls = e.urls ?? e.url;
+    const candidates: unknown[] = Array.isArray(rawUrls) ? rawUrls : [rawUrls];
+    const list = candidates
+      .filter((u): u is string => typeof u === 'string')
+      .map((u) => u.trim())
+      .filter((u) => ICE_URL_RE.test(u));
+    if (list.length === 0) continue;
+    const server: IceServerConfig = {
+      urls: typeof rawUrls === 'string' ? list[0] : list,
+    };
+    if (typeof e.username === 'string' && e.username) {
+      server.username = e.username;
+    }
+    if (typeof e.credential === 'string' && e.credential) {
+      server.credential = e.credential;
+    }
+    out.push(server);
+  }
+  return out;
+};
+
+/**
+ * A LiveKit server URL as the backend publishes it. Only websocket / http(s)
+ * URLs are accepted: the value ends up as the connect target of the media
+ * session, so anything else (javascript:, data:, garbage) is treated as unset.
+ */
+export const normalizeLivekitUrl = (raw: unknown): string | null => {
+  const text = typeof raw === 'string' ? raw.trim() : '';
+  return /^(wss?|https?):\/\/[^\s]+$/i.test(text) ? text : null;
+};
+
+const isTrueish = (value: unknown): boolean => {
+  const text = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  return text === 'true' || text === '1';
+};
+
+/** Attributes of a `<data type="call-token">` element, defensively read. */
+export interface ParsedCallTokenAttrs {
+  token: string;
+  room: string;
+  /** Raw `callId` attribute, null when absent (the JWT may still carry it). */
+  callId: string | null;
+  /** Valid `kind` attribute, null when absent or unrecognised. */
+  kind: CallKindName | null;
+  mode: CallMode;
+  group: boolean;
+  /** Callee's ICE servers for `mode=p2p`, null when absent or unparseable. */
+  iceServers: IceServerConfig[] | null;
+  /**
+   * Public LiveKit wss URL for `mode=livekit`, null when the server did not
+   * send one (older backends), it is empty, or it is not a usable URL.
+   */
+  livekitUrl: string | null;
+  /**
+   * Caller's display name as plain text (control characters stripped, capped,
+   * raw chat names refused); '' when absent. Only trustworthy from the system
+   * account, see calls/senderTrust.
+   */
+  callerName: string;
+  /** Caller's xmppUsername when well formed, else null. Same trust rule. */
+  caller: string | null;
+}
+
+/**
+ * Tolerant reader for the call-token stanza. A server that sends neither
+ * `mode` nor `group` (every server before P2P / group calls) yields
+ * `mode: 'livekit'`, `group: false`, i.e. exactly the legacy behaviour.
+ */
+export const parseCallTokenAttrs = (
+  attrs: Record<string, any> | undefined | null
+): ParsedCallTokenAttrs => {
+  const a = attrs || {};
+  const kindRaw = String(a.kind || '')
+    .trim()
+    .toLowerCase();
+  const mode: CallMode =
+    String(a.mode || '')
+      .trim()
+      .toLowerCase() === 'p2p'
+      ? 'p2p'
+      : 'livekit';
+  const iceList = mode === 'p2p' ? normalizeIceServers(a.ice) : [];
+  return {
+    token: String(a.token || '').trim(),
+    room: String(a.room || '').trim(),
+    callId: String(a.callId || a.callid || '').trim() || null,
+    kind: kindRaw === 'audio' || kindRaw === 'video' ? kindRaw : null,
+    mode,
+    // A p2p call is 1:1 by construction; never let a stray attribute flip it.
+    group: mode === 'livekit' && isTrueish(a.group),
+    iceServers: mode === 'p2p' && iceList.length > 0 ? iceList : null,
+    livekitUrl: mode === 'livekit' ? normalizeLivekitUrl(a.livekitUrl) : null,
+    callerName: sanitizeCallName(a.callerName),
+    caller: sanitizeXmppUsername(a.caller),
+  };
+};
+
+/** Normalised `POST /v1/chats/call/create/:chatName` response. */
+export interface CallCreateResult {
+  callId: string | null;
+  mode: CallMode;
+  kind: CallKindName;
+  /** Server-reported group flag, null when the server did not say. */
+  group: boolean | null;
+  /** Public LiveKit wss URL when the server knows it. */
+  livekitUrl: string | null;
+  iceServers: IceServerConfig[];
+  ttlSeconds: number | null;
+}
+
+/**
+ * Reads the create response. Old servers answer with no `mode`, which maps to
+ * `livekit` (the caller then waits for its own call-token as before). A p2p
+ * answer without a callId is unusable (no way to correlate signalling) and
+ * throws.
+ */
+export const parseCallCreateResponse = (
+  data: unknown,
+  fallbackKind: CallKindName
+): CallCreateResult => {
+  const root = (data && typeof data === 'object' ? data : {}) as Record<
+    string,
+    any
+  >;
+  const d =
+    root.result && typeof root.result === 'object' && !root.mode
+      ? (root.result as Record<string, any>)
+      : root;
+  const mode: CallMode =
+    String(d.mode || '')
+      .trim()
+      .toLowerCase() === 'p2p'
+      ? 'p2p'
+      : 'livekit';
+  const kindRaw = String(d.kind || '')
+    .trim()
+    .toLowerCase();
+  const callId = String(d.callId || d.callid || '').trim() || null;
+  if (mode === 'p2p' && !callId) {
+    throw new Error('Call response is missing callId');
+  }
+  const ttl = Number(d.ttlSeconds);
+  const livekitUrl = normalizeLivekitUrl(d.livekitUrl);
+  return {
+    callId,
+    mode,
+    kind:
+      kindRaw === 'audio' || kindRaw === 'video'
+        ? (kindRaw as CallKindName)
+        : fallbackKind,
+    group: typeof d.group === 'boolean' ? d.group : null,
+    livekitUrl,
+    iceServers: mode === 'p2p' ? normalizeIceServers(d.iceServers) : [],
+    ttlSeconds: Number.isFinite(ttl) && ttl > 0 ? ttl : null,
+  };
+};
+
+/**
+ * Which room types may start / receive calls. Hosts that never set
+ * `allowedRoomTypes` get 1:1 and group chats; an explicit list is respected
+ * as written (so `['private']` keeps a host on 1:1 only).
+ */
+export const DEFAULT_CALL_ROOM_TYPES: CallRoomType[] = ['private', 'group'];
+
+export const isCallRoomTypeAllowed = (
+  roomType: string | undefined | null,
+  allowedRoomTypes?: CallRoomType[] | null
+): boolean => {
+  if (roomType !== 'private' && roomType !== 'group') return false;
+  const allowed = allowedRoomTypes || DEFAULT_CALL_ROOM_TYPES;
+  return allowed.includes(roomType);
+};
+
+export interface BusyCallSnapshot {
+  phase: string;
+  direction: 'incoming' | 'outgoing' | null;
+  mode: CallMode;
+  callId: string | null;
+  roomBareName: string | null;
+}
+
+/**
+ * What to do with an incoming call-token while another call may be active.
+ *  - accept:      nothing active, ring.
+ *  - duplicate:   same callId as the active call (server re-delivery), ignore.
+ *  - replace:     legacy LiveKit behaviour (a new token overwrites the old
+ *                 call), kept exactly for livekit-vs-livekit.
+ *  - glare-yield: both sides dialled each other; the lexicographically smaller
+ *                 callId wins on BOTH ends, and this is the loser: drop our
+ *                 outgoing call and ring for theirs.
+ *  - glare-keep:  same race, we hold the winning callId, ignore theirs (the
+ *                 other side yields).
+ *  - busy:        a different call is in progress, decline the newcomer.
+ */
+export type IncomingWhileBusyDecision =
+  | 'accept'
+  | 'duplicate'
+  | 'replace'
+  | 'glare-yield'
+  | 'glare-keep'
+  | 'busy';
+
+export const decideIncomingWhileBusy = (
+  current: BusyCallSnapshot,
+  incoming: {
+    mode: CallMode;
+    callId: string | null;
+    roomBareName: string | null;
+  }
+): IncomingWhileBusyDecision => {
+  if (current.phase === 'idle') return 'accept';
+  if (incoming.callId && current.callId === incoming.callId) return 'duplicate';
+  if (current.mode !== 'p2p' && incoming.mode !== 'p2p') return 'replace';
+
+  const sameRoom =
+    !!incoming.roomBareName && current.roomBareName === incoming.roomBareName;
+  if (
+    sameRoom &&
+    current.direction === 'outgoing' &&
+    current.phase === 'requesting' &&
+    incoming.mode === 'p2p' &&
+    current.mode === 'p2p' &&
+    current.callId &&
+    incoming.callId
+  ) {
+    return incoming.callId < current.callId ? 'glare-yield' : 'glare-keep';
+  }
+  return 'busy';
+};