@ethora/chat-component-rn 26.10.9 → 26.10.11

package/CHANGELOG.md

@@ -7,8 +7,22 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this pr
 
 ### Added
 
+- **Languages from the install's get-config.** New `config.translates.languages`: pass `translateLanguages` from `GET /v1/apps/get-config` as-is (e.g. `["en-CA", "fr-CA", "es-US"]`). The globe picker, the profile's Language tab and the Settings chat-language list offer those languages instead of the built-in list; the interface-language list offers the ones the component has captions for. An empty array (no translation server) hides the chat-language lists and the globe. Omitted, the built-in list stays. `settings.languages.chatLanguages` / `appLanguages` still win.
+
+- **Push language.** The push token is registered with `language` (`config.translates.readerLocale`, else `config.i18n.locale`, else the language picked in the chat; the full tag is sent, the server reduces fr-CA / es-US to fr / es). When it changes the token is re-registered by itself (a plain re-POST, no release first), so hosts never call `registerPushToken` again for it. A backend that predates the field gets the registration again without it. The legacy gateway (`pushNotifications.apiUrl`) gets no language.
+
+- **App icon badge follows the unread count in the foreground.** The server sets the badge only with a push, so an opened app kept the last push's number. While the app is active the badge is now the unread total (0 once everything is read), set again on every return to the foreground. Needs `expo-notifications`; `config.pushNotifications.syncAppBadge: false` leaves the badge to the host.
+
 - **The sender's avatar in chat pushes.** A push that carries the sender's avatar (`image`; the push service sends it unless the app switched it off with `PUT /v1/push/sender-avatar/:appId`) shows it the way messengers do: the avatar next to the text, the app icon as the small badge. iOS: the notification service extension downloads it and turns the push into a communication notification (`INSendMessageIntent` with the sender as `INPerson`), for plain and sealed pushes; sealed pushes now also get their attachment preview. The config plugin adds the Communication Notifications capability and `INSendMessageIntent` to `NSUserActivityTypes` (`communicationNotifications: false` leaves them out); with manual signing the App ID needs the capability. Android: `registerSealedPushTask({ onMessageShown })` hands every shown sealed push with an avatar (`ShownMessagePush`) to the host, which redraws the notification natively (expo-notifications has no per-notification avatar). A push without an avatar, or one whose avatar does not load, shows as before.
 
+- **Peer to peer 1:1 calls and group calls (port of the web SDK's p2p / group calls).** A 1:1 call now runs over our own WebRTC peer connection when the server says so (`mode=p2p` on the create response and the `call-token`): offer, answer, ICE candidates and hang up travel as direct XMPP messages (`<data type="call-p2p">`), TURN/STUN servers come from the backend (`GET /v1/calls/ice-servers`, also refreshed before an ICE restart), the clients report `ringing` / `decline` / `connected` / `end` to `POST /v1/chats/call/state/*` (a p2p call has no LiveKit webhook), and a dropped network restarts ICE (grace period, one restart per outage, a small cap per call, then a clean failure). The server picks the transport per call, so an install without P2P keeps calling over LiveKit exactly as before. It uses `@livekit/react-native-webrtc`'s `RTCPeerConnection` / `mediaDevices` (loaded lazily like the LiveKit packages; no `react-native-webrtc`, which would duplicate the native classes). The new modules are parallel to the web SDK's `src/calls/` (`callMode`, `callDisplay`, `senderTrust`, `startCall`, `p2p/{icePolicy, negotiator, signalStanza, signalInbox, P2PCallController, p2pRuntime}`) so later syncs are a copy; the React Native side is `webrtcRuntime`, `p2pCallSession` (the controller seen through the call session snapshot), `P2PCallRunner` and `CallVideo` (LiveKit `VideoTrack` or the fork's `RTCView`). One call screen, the minimized strip, CallKit and the ongoing-call notification serve both transports.
+  - **Rings like every other call.** The VoIP push of a p2p call (`mode=p2p`, empty `callToken`) rings through the same path and under the same `callKitUuid(callId)`; Answer and Decline on the CallKit / ConnectionService screen work for p2p too, a decline is reported to the server, and iOS audio activation reaches WebRTC's audio session even in a build without LiveKit's JS. A phone already in a call declines a second p2p call to its caller instead of leaving them ringing, and two people dialling each other at once settle on the smaller callId on both ends. The caller keeps re-sending its offer for the whole ring window (4, 10, 18 and 26 s) so a callee that is still cold-starting from the push still receives it.
+  - **Group calls.** Members-only group rooms get the call buttons (`videoCalls.allowedRoomTypes` now defaults to `['private', 'group']`; `['private']` keeps calls 1:1; public rooms never call) and run over LiveKit. The call screen is a grid of everyone in the room (us first, the speaker outlined, a mic-off badge on anyone muted, at most nine cameras drawn at a time, speakers first), the call goes on while anyone is in the room, and one member declining does not end it for the others. The ring names the room and the caller ("Ann is calling in Design team"); a group push (`group=true`) rings the same way.
+  - **Safer call-tokens.** `livekitUrl` (the server's own LiveKit URL, which wins over `videoCalls.livekitUrl`), the ICE list and the caller's name/id are honoured only on a `call-token` that comes from the app's system account (the sender JID is stamped by ejabberd), so a forged token cannot steer media to another server. A raw chat name is never shown as a caller; with no name the ring says "Incoming call".
+  - Fixes on the way: a `call-state` signal that names a different call than the one on screen (a late server log of the previous call in the same room) no longer ends the current call, and a group member's decline relayed by the server no longer ends the call for the others. New strings (`call.*` group, p2p and status keys) in en, fr, es, pt, ht and zh. Tests: `p2p.*`, `calls.*`, `callTokenStanza.modes`, `callState.api`, `callSlice.route`, `p2pCallRunner`, `p2pCallSession`, `p2pCallPush`, `p2pCallKit`, `groupCallView`, `groupLayout`, `callSessionController.group`, `callButtons`, `videoCallOverlay.modes`.
+
+- **Scheduled calls and deep links.** With `videoCalls.enabled` the room header gets a Schedule a call button (title, date and time, duration, video or audio) and the room shows an invite card for every scheduled call (`<data type="scheduledCall">`): one card per call, the latest status wins (scheduled, updated, cancelled), states upcoming, join window (from 15 minutes before the start to the end), ended and cancelled, **Add to Google / Outlook / .ics** buttons that open the server's links, **Join** through the room's ordinary call start on a tap (no media before it), and Edit / Cancel call for the creator and room moderators. New exports `parseScheduledCallLink(url)` (`https://<host>/call/<slug>` for known hosts and `<scheme>://call/<slug>`), `openScheduledCall(slug)`, `handleScheduledCallUrl(url)`, `handleScheduledCallPush(data)`, `configureScheduledCallLinks({ hosts, schemes })` and the `getScheduledCall` / `listScheduledCalls` / `createScheduledCall` / `updateScheduledCall` / `cancelScheduledCall` API helpers, plus `config.scheduledCalls` (`enabled`, `onOpenError`, `hosts`, `schemes`). A link that arrives before sign-in or before `<Chat>` is ready is held (memory and AsyncStorage, 30 minutes) and opened once both are true: slug resolved, room opened, pre-join sheet shown, with "not a member", "not found" and "cancelled" screens. A reminder push (`type: 'scheduledCallReminder'`) given to `handlePushPayload` opens the same flow (new outcome `'scheduledCall'`). The example app registers its URL scheme, iOS associated domain and Android `/call/*` intent filter and forwards incoming URLs. `booking.*` strings in en, fr, es, pt, ht and zh. Needs the matching backend (`/v1/chats/calls/scheduled`). README, "Scheduled calls and deep links".
+
 - **Incoming calls from VoIP pushes (iOS) and from a host's call notification (Android).** A host whose PushKit code reports a VoIP push to CallKit itself (iOS requires that before any JS runs) uses the new `callKitUuid(callId)` for the CallKit UUID; the SDK reports the same call under the same UUID, so the VoIP push and the XMPP invite never ring twice (`CallUUIDAlreadyExists` is now taken as "already on screen"). `handlePushPayload` / `handleCallPush` hold a call push that comes before `<Chat>` configured the store and ring it once it has (a held push expires with the 60 s LiveKit token), and address the room through the conference domain when the room list is not loaded yet. Answer and Decline made on the CallKit screen before JS listened are replayed from callkeep's buffered events (`didLoadWithEvents`) and applied when the call reaches the store; a declined call tells the caller once the socket is up. A call push that cannot ring (calls off, no token, no room, busy) ends its CallKit call. New `answerCallFromPush` / `declineCallFromPush` for a host's own incoming-call notification, `registerSealedPushTask({ onCallPush })` for showing one from the Android background task (not called in the foreground), and exported `isCallPush` / `parseCallPush`. An incoming call now stops ringing after 45 s, and a `call-token` stanza for a call already known from its push no longer throws an answered call back to the ring screen.
 
 - **Pushes for reactions.** Adding an emoji to someone else's message asks the server for a push to that message's author: `sendMessageReactionStanza` takes `ReactionStanzaData` (`push`, `messageAuthor`, `messageText`, the sender's avatar and the attachment attributes) and puts it on the stanza's `<data>`; the text is cut to 120 characters and left out of encrypted rooms, and nothing is asked for a removed emoji or one's own message. The push service shows it as `<name> reacted ❤️ to "…"`, silent, next to (not instead of) the chat's new-message push; a tap opens the chat. Android: `registerSealedPushTask({ reactionChannelId })` posts a sealed reaction push on that (silent) channel with its own identifier per chat; the sealed envelope and content carry `type: 'reaction'` (the content also the emoji as `reaction`). Needs the matching ejabberd `mod_offline_post` and push service.
@@ -49,6 +63,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this pr
 
 ### Changed
 
+- `npm run build` no longer runs `expo prebuild` first. The npm hook was named `prebuild`; the script is now `prebuild:native` (`npm run prebuild:native`).
 - `pushNotifications.onClick` / `onNotificationPress` are marked deprecated: they were never called. The tapped notification's data goes to `handlePushPayload`, which opens the room. The push section of `instructions.md` now shows the whole host side in one place and states the rule the SDK cannot enforce: sign-out must go through the SDK (`useLogout()` / the built-in item), or the device stays registered.
 
 - **The interface language reaches every caption.** The room-list menu (New Chat / Profile / Settings / Sign out, and the sign-out confirmation), the room menu, the thread screen, the delete-message dialog, the Visibility and Manage Data screens, "sending..." / "edited" / the failed-send retry under a bubble and the toasts' titles were hard-coded in English and ignored the app language; they now come from the string tables (`menu.*`, `thread.*`, `message.sending` / `message.failedRetry`, `modal.deleteMessage.*`, `toast.copied` / `toast.copyFailed` / `toast.saveSuccessful` / `toast.failedToCreateRoom` in every locale). A host's `logout.label` / `logout.confirm` copy still wins; without it the SDK's own, in the UI language, is shown - hosts that passed English copy only to have a label can drop it. Spanish "Chats" is now "Conversaciones".
@@ -83,6 +98,8 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this pr
 
 - **A call no longer hangs on after the other side drops it.** The `call-state` handler read the state, `callId` and `room` from the `<message>` instead of its `<data>`, so the peer's `cancelled` / `declined` / `ended` signal and the server's call log never ended the call; the server's `call-state-declined` is now handled too, and a late signal of an earlier call in the same room no longer ends the current one. A call declined on the CallKit / system screen tells the caller once the socket is up instead of losing the signal while it reconnects.
 
+- **Reporting a chat reaches the server.** The report form sent its UI ids (`violence`, `childAbuse`, `personalDetails`, `illegalDrugs`) as the category and no text when the details were empty, so `POST /v1/chats/reports/:chatName` rejected most reports with 422. Each category is now mapped onto the value the server accepts (Child Abuse, which the server has no value for, goes as `other` with its name in the text), the text is never empty, and the toasts say whether the report was sent. The mapping lives in `helpers/reportRoom.ts`, shared in shape with the web SDK.
+
 - **Removed reaction in a room with no loaded messages crashed the history parse, and archive-replayed reactions overwrote the room preview.** Both fixed.
 
 - **Prototype pollution guard and users cache cap.** Dynamic keys in the store are guarded against `__proto__` style keys, and the users cache is merged and capped at 5000 entries.

package/README.md

@@ -17,11 +17,14 @@ React Native chat UI + chat core for iOS and Android, powered by the Ethora plat
 - [Pinning a single room](#pinning-a-single-room)
 - [Unread tracking in tab-based hosts](#unread-tracking-in-tab-based-hosts)
 - [Logging out](#logging-out)
+- [Languages and push language](#languages-and-push-language)
 - [Customization flags worth knowing](#customization-flags-worth-knowing)
 - [Server events](#server-events)
+- [Audio and video calls](#audio-and-video-calls)
 - [Startup behaviour](#startup-behaviour)
 - [Message reactions](#message-reactions)
 - [Replies & threads](#replies--threads)
+- [Scheduled calls and deep links](#scheduled-calls-and-deep-links)
 - [Keyboard handling](#keyboard-handling)
 - [Header height & font sizing](#header-height--font-sizing)
 - [Dark theme](#dark-theme)
@@ -345,6 +348,41 @@ config = {
 
 The user's interface language wins over `config.i18n.locale`, which stays the default for a user who never chose. `hideAppearance` and `hidePushToggle` hide the built-in cards.
 
+## Languages and push language
+
+The languages offered to the user come from your install: pass `translateLanguages` from `GET /v1/apps/get-config` as `translates.languages`. The SDK does not call get-config itself (it needs your `domainName`), so read it where your app already does, or fetch it once:
+
+```tsx
+const [translateLanguages, setTranslateLanguages] = useState<string[]>();
+
+useEffect(() => {
+  fetch(`https://api.chat.ethora.com/v1/apps/get-config?domainName=${DOMAIN_NAME}`)
+    .then((r) => r.json())
+    .then((json) => setTranslateLanguages(json?.result?.translateLanguages ?? []))
+    .catch(() => undefined); // keeps the built-in list
+}, []);
+
+<Chat
+  config={{
+    ...baseConfig,
+    translates: {
+      enabled: true,
+      mode: 'auto',
+      languages: translateLanguages, // e.g. ["en-CA", "fr-CA", "es-US"]
+      // Optional, when your own app picks the reader's language:
+      // readerLocale: userLocale,
+    },
+    // Optional: the interface language of the chat.
+    // i18n: { locale: userLocale },
+  }}
+/>
+```
+
+- The list drives the globe picker, the profile's Language tab and the Settings chat-language list; the interface-language list takes the languages the SDK has captions for (en, fr, es, pt, ht, zh).
+- `[]` means the install has no translation server: the language lists and the globe are hidden. Leaving `languages` out keeps the built-in en-CA / es-US / fr-CA.
+- **Push language** needs no code: the push token is registered with `language` = `translates.readerLocale`, else `i18n.locale`, else what the user picked in the chat, and is registered again by itself whenever that changes.
+- **App icon badge:** in the foreground it follows the unread total (0 once everything is read), since the server sets it only with a push. Needs `expo-notifications`; `pushNotifications.syncAppBadge: false` turns it off.
+
 ## Customization flags worth knowing
 
 | Flag | What it does |
@@ -375,6 +413,35 @@ The user's interface language wins over `config.i18n.locale`, which stays the de
 
 The server can push `ethora-event` headlines (namespace `urn:ethora:events:1`) to refresh a client without a reload. Two types are handled: `user-profile-updated` (refreshes that user's cached profile and name) and `chat-meta-updated` (schedules a refresh of that room's metadata, for rooms the client already holds). A headline is accepted only from a trusted sender: a bare server JID (no resource) on the session's own XMPP domain, delivered as a headline. Room occupants, other users, and other domains are ignored. Set `trustedEventSenders` to pin the exact sender(s) instead of accepting any bare JID of the domain.
 
+## Audio and video calls
+
+Calls are opt-in (`config.videoCalls.enabled: true`). They use native modules, so the host needs a dev build or a prebuilt binary (not Expo Go) with the optional peers `@livekit/react-native` and `@livekit/react-native-webrtc`, the microphone/camera permissions and the audio background modes.
+
+| Where | Carried by |
+| --- | --- |
+| 1:1 (private) chat | Our own WebRTC peer to peer connection, with TURN/STUN from the backend (`GET /v1/calls/ice-servers`) and the offer/answer signalled over XMPP. The server decides per call: it answers `p2p` when it has P2P enabled and falls back to `livekit` otherwise, so an install without a TURN relay keeps calling over LiveKit exactly as before. |
+| Members-only group chat | LiveKit, always. The call screen is a grid of everyone in the room with the person who is speaking outlined; one member declining does not end the call for the others, and the call ends when you hang up (or the room drops). Public rooms do not call. |
+
+```tsx
+<Chat
+  config={{
+    videoCalls: {
+      enabled: true,
+      livekitUrl: 'wss://livekit.example.com',   // still required: it enables the call buttons
+      enableAudioCalls: true,                    // audio button next to the video one
+      allowedRoomTypes: ['private', 'group'],    // the default; ['private'] keeps calls 1:1
+    },
+  }}
+/>
+```
+
+- **One WebRTC.** Peer to peer calls use the WebRTC classes of `@livekit/react-native-webrtc` (LiveKit's fork). Do not add `react-native-webrtc` next to it: two copies of the native classes do not link. A build without the fork cannot take a p2p call; it declines it, so the caller is not left ringing.
+- **Encryption.** A p2p call is encrypted between the two phones by DTLS-SRTP; the LiveKit insertable-streams E2EE layer applies to LiveKit calls only.
+- **Ringing.** Every kind of call rings through the same path: an XMPP `call-token` while the app is connected, a VoIP push (`mode=p2p` with an empty `callToken` for a p2p call, `group=true` for a group call) when it is not, and CallKit (iOS) / ConnectionService (Android) via the optional `react-native-callkeep`. Answer and Decline on the system screen work for p2p calls too; a decline is reported to the server (`POST /v1/chats/call/state/decline/:callId`) because a p2p call has no LiveKit webhook to tell it. `handlePushPayload` / `handleCallPush` take the push payload as before.
+- **Who is calling.** `livekitUrl` and the ICE servers on a `call-token`, and the caller's name, are honoured only when the stanza comes from the app's system account. A raw chat name is never shown as a caller: the ring screen shows the caller's name, else a neutral "Incoming call".
+- **Reconnecting.** If the network drops mid-call, the p2p connection restarts ICE with fresh TURN credentials and the call shows "Reconnecting..."; it ends after a few failed restarts.
+- **Server side.** P2P needs a backend with `CALLS_P2P_ENABLED` and a TURN relay; group calls need a backend that accepts them (an older backend refuses with an error on the call screen). Everything else falls back to LiveKit 1:1.
+
 ## Startup behaviour
 
 The room list renders as soon as `GET /v1/chats/my` returns; it does not wait for MUC joins. With `initBeforeLoad`, `XmppProvider` reports ready right after `/chats/my`. Joins then run as a background sweep (open room first, then by recent activity, `historyQoS.joinConcurrency` at a time, up to 3 retries for rooms that did not join). Sending, fetching history and opening a room each join that room on demand, and the offline send queue drains after the first wave. Background history preload is staged by default (see `historyPreload`).
@@ -465,6 +532,64 @@ Message flags a custom message component can read: `unencrypted`, `undecryptable
 
 Requires an XMPP server that lets members read each other's OMEMO PEP nodes (`access_model: open`).
 
+## Scheduled calls and deep links
+
+With `config.videoCalls.enabled`, the room header gets a **Schedule a call** button (in the room types `videoCalls.allowedRoomTypes` allows, private and group by default). The sheet takes a title, a date and time, a duration (15 to 120 minutes) and, with `enableAudioCalls`, video or audio. The server posts an **invite card** into the room for every member: title, local date and time, duration, **Add to Google Calendar / Outlook / .ics** buttons (the server's own links, opened with `Linking.openURL`) and **Join**. The card is one per call: an edit or a cancel updates it in place, and the older messages of the same call draw nothing. Join is enabled from 15 minutes before the start until the call ends; before that the card says when it opens, afterwards it is greyed, and a cancelled call is struck through. Join is the room's ordinary call start (a private room starts or answers its call, a group room starts or joins the room call) and it only runs on that tap: no media starts when a card or a link is opened. The person who scheduled the call, and a room moderator, also see **Edit** and **Cancel call**.
+
+Every invite carries a link, `https://<web host>/call/<slug>`, which the calendar event, the invite e-mail and the reminder push (10 minutes before the start) all use. To make it open your app:
+
+```tsx
+import { useEffect } from 'react';
+import { Linking } from 'react-native';
+import { Chat, configureScheduledCallLinks, handleScheduledCallUrl } from '@ethora/chat-component-rn';
+
+// Once, at startup (before <Chat> mounts): which links belong to this app.
+configureScheduledCallLinks({
+  hosts: ['app.chat.ethora.com'], // the web domain of your Ethora app; this default is always accepted
+  schemes: ['myapp'],             // your URL scheme, for myapp://call/<slug>
+});
+
+export default function App() {
+  useEffect(() => {
+    Linking.getInitialURL().then((url) => url && handleScheduledCallUrl(url));
+    const sub = Linking.addEventListener('url', ({ url }) => handleScheduledCallUrl(url));
+    return () => sub.remove();
+  }, []);
+  // ...
+  return <Chat config={config} />;
+}
+```
+
+- `parseScheduledCallLink(url)` returns the slug for `https://<known host>/call/<slug>` and `<scheme>://call/<slug>`, otherwise `null`. Known hosts: `app.chat.ethora.com`, the ones passed to `configureScheduledCallLinks`, and `config.scheduledCalls.hosts`. With no scheme configured any custom scheme is accepted; once `schemes` is set only those are.
+- `openScheduledCall(slug)` opens a call by slug and `handleScheduledCallUrl(url)` does the parse and the open in one step (it returns `false` for any other URL, so your own routing can carry on).
+- **A link that comes too early is kept.** If it arrives before the user is signed in, or before `<Chat>` is configured and connected (a cold start from a tapped link, or the login screen in between), the slug is held, in memory and in AsyncStorage for 30 minutes, and opened as soon as both are true. Opening resolves the slug with the API, opens the room, and shows the **pre-join** sheet with a Join button. A call that was cancelled, an unknown one, and a room you are not a member of each get their own message instead.
+- **Reminder push.** The push `data` has `type: 'scheduledCallReminder'` and a `slug`. Passing a tapped notification's data to `handlePushPayload(data)` (see Pushes) opens the same flow and returns `'scheduledCall'`; `handleScheduledCallPush(data)` does only that.
+
+Making the OS hand the links to your app is host configuration. For an Expo app, in `app.json`:
+
+```json
+{
+  "expo": {
+    "scheme": "myapp",
+    "ios": { "associatedDomains": ["applinks:app.chat.ethora.com"] },
+    "android": {
+      "intentFilters": [
+        {
+          "action": "VIEW",
+          "autoVerify": true,
+          "data": [{ "scheme": "https", "host": "app.chat.ethora.com", "pathPrefix": "/call/" }],
+          "category": ["BROWSABLE", "DEFAULT"]
+        }
+      ]
+    }
+  }
+}
+```
+
+The web host must serve `/.well-known/apple-app-site-association` (your Apple team id and bundle id, path `/call/*`) and `/.well-known/assetlinks.json` (your Android package and SHA-256 fingerprints) for the universal links to open the app; the Ethora web app serves both from its runtime config. Until they do, `myapp://call/<slug>` still works. This repo's example app is wired this way (`app.json`, `App.tsx`).
+
+The server picks the links (`GET /v1/chats/calls/scheduled/:slug` returns them); the SDK never builds a calendar URL itself. `getScheduledCall`, `listScheduledCalls`, `createScheduledCall`, `updateScheduledCall` and `cancelScheduledCall` are exported for hosts that build their own UI. `config.scheduledCalls.enabled: false` hides the Schedule button and the Join buttons, and `config.scheduledCalls.onOpenError({ slug, reason })` is told when a link could not be opened (`'not-found' | 'not-a-member' | 'cancelled' | 'network'`). The strings are the `booking.*` keys of `config.i18n.strings`. The invite is sent in the clear even in an end-to-end encrypted room, like other system messages.
+
 ## Session loss
 
 When the server rejects the XMPP password (SASL `not-authorized`) the SDK refreshes credentials and reconnects. If that cannot produce a working password — the refresh request fails, returns no new password, or the new one is rejected too — twice in a row, the session is ended exactly like **Sign out** (`performLogout`, then `logout.onAfterLogout`), so the host can route to its login screen. A network outage never triggers this: without a reachable server there is no rejection, and the client keeps reconnecting with backoff.
@@ -674,7 +799,7 @@ just don't commit a `yarn.lock` back into the repo.
 
 ### `expo prebuild` and the `dependencies` guard
 
-`npm run prebuild|ios|android` each chain through to `expo prebuild`
+`npm run prebuild:native|ios|android` each chain through to `expo prebuild`
 on first run, and `expo prebuild` likes to hoist `expo`, `react`,
 and `react-native` from `devDependencies` into `dependencies`.
 That's wrong for a published library — consumers of

package/lib/commonjs/booking/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DEFAULT_SCHEDULED_CALL_HOSTS", {
+  enumerable: true,
+  get: function () {
+    return _scheduledCallLink.DEFAULT_SCHEDULED_CALL_HOSTS;
+  }
+});
+Object.defineProperty(exports, "configureScheduledCallLinks", {
+  enumerable: true,
+  get: function () {
+    return _scheduledCallLink.configureScheduledCallLinks;
+  }
+});
+Object.defineProperty(exports, "handleScheduledCallPush", {
+  enumerable: true,
+  get: function () {
+    return _pendingScheduledCall.handleScheduledCallPush;
+  }
+});
+Object.defineProperty(exports, "handleScheduledCallUrl", {
+  enumerable: true,
+  get: function () {
+    return _pendingScheduledCall.handleScheduledCallUrl;
+  }
+});
+Object.defineProperty(exports, "openScheduledCall", {
+  enumerable: true,
+  get: function () {
+    return _pendingScheduledCall.openScheduledCall;
+  }
+});
+Object.defineProperty(exports, "parseScheduledCallLink", {
+  enumerable: true,
+  get: function () {
+    return _scheduledCallLink.parseScheduledCallLink;
+  }
+});
+var _scheduledCallLink = require("./scheduledCallLink");
+var _pendingScheduledCall = require("./pendingScheduledCall");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/booking/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_scheduledCallLink","require","_pendingScheduledCall"],"sourceRoot":"../../../src","sources":["booking/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,kBAAA,GAAAC,OAAA;AAKA,IAAAC,qBAAA,GAAAD,OAAA","ignoreList":[]}

package/lib/commonjs/booking/pendingScheduledCall.js

@@ -0,0 +1,275 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scheduledCallSlugFromPush = exports.resolveAndOpenScheduledCall = exports.openScheduledCall = exports.isScheduledCallReminderPush = exports.isScheduledCallReady = exports.installScheduledCallHook = exports.handleScheduledCallUrl = exports.handleScheduledCallPush = exports.createPendingScheduledCallQueue = exports.asyncPendingStorage = exports.__resetPendingScheduledCallForTests = exports.SCHEDULED_CALL_REMINDER_PUSH_TYPE = exports.PENDING_SCHEDULED_CALL_TTL_MS = exports.PENDING_SCHEDULED_CALL_KEY = void 0;
+var _asyncStorage = _interopRequireDefault(require("@react-native-async-storage/async-storage"));
+var _roomStore = require("../roomStore");
+var _pushPayload = require("../helpers/pushPayload");
+var _normalizeRoomJid = require("../helpers/normalizeRoomJid");
+var _scheduledCalls = require("../networking/api-requests/scheduledCalls.api");
+var _scheduledCallLink = require("./scheduledCallLink");
+var _scheduledCall = require("./scheduledCall");
+var _scheduledCallStore = require("./scheduledCallStore");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Opening a scheduled call from a link or a reminder push.
+ *
+ * A link can arrive while the app is still starting: before the user is
+ * signed in, or before `<Chat>` has configured the store and connected. The
+ * slug is then held (in memory, and in AsyncStorage so a cold start that
+ * is interrupted by the sign-in screen keeps it) and opened once both are
+ * true. Opening = resolve the slug through the API, open its room, show the
+ * pre-join sheet. No media starts before the user taps Join.
+ */
+
+const PENDING_SCHEDULED_CALL_KEY = exports.PENDING_SCHEDULED_CALL_KEY = 'ethora_pending_scheduled_call';
+/** A link older than this is dropped instead of ambushing the user later. */
+const PENDING_SCHEDULED_CALL_TTL_MS = exports.PENDING_SCHEDULED_CALL_TTL_MS = 30 * 60 * 1000;
+const asyncPendingStorage = exports.asyncPendingStorage = {
+  async read() {
+    try {
+      const raw = await _asyncStorage.default.getItem(PENDING_SCHEDULED_CALL_KEY);
+      if (!raw) {
+        return null;
+      }
+      const parsed = JSON.parse(raw);
+      return typeof parsed?.slug === 'string' && Number.isFinite(parsed?.at) ? {
+        slug: parsed.slug,
+        at: parsed.at
+      } : null;
+    } catch {
+      return null;
+    }
+  },
+  async write(value) {
+    try {
+      await _asyncStorage.default.setItem(PENDING_SCHEDULED_CALL_KEY, JSON.stringify(value));
+    } catch {
+      // Memory still holds it.
+    }
+  },
+  async clear() {
+    try {
+      await _asyncStorage.default.removeItem(PENDING_SCHEDULED_CALL_KEY);
+    } catch {
+      // Nothing to do.
+    }
+  }
+};
+/**
+ * The hold-until-ready logic, free of the store so it can be tested. One
+ * slot: a newer link replaces an older one (the user tapped it last).
+ */
+const createPendingScheduledCallQueue = deps => {
+  const now = deps.now || Date.now;
+  const ttl = deps.ttlMs ?? PENDING_SCHEDULED_CALL_TTL_MS;
+  let held = null;
+  let restored = false;
+  const fresh = entry => !!entry && now() - entry.at <= ttl;
+  const flush = () => {
+    if (!held) {
+      return false;
+    }
+    if (!fresh(held)) {
+      held = null;
+      void deps.storage.clear();
+      return false;
+    }
+    if (!deps.isReady()) {
+      return false;
+    }
+    const {
+      slug
+    } = held;
+    held = null;
+    void deps.storage.clear();
+    deps.open(slug);
+    return true;
+  };
+  return {
+    /** A link arrived: open it now, or hold it. Returns what happened. */
+    submit(slug) {
+      held = {
+        slug,
+        at: now()
+      };
+      if (flush()) {
+        return 'opened';
+      }
+      void deps.storage.write(held);
+      return 'held';
+    },
+    /** Something that can make us ready changed. */
+    poke() {
+      return flush();
+    },
+    /** Pick up a link persisted by an earlier run of the app. */
+    async restore() {
+      if (restored) {
+        return;
+      }
+      restored = true;
+      const saved = await deps.storage.read();
+      // A link that arrived while we were reading is newer: keep it.
+      if (!held && saved && fresh(saved)) {
+        held = saved;
+      } else if (!fresh(saved)) {
+        void deps.storage.clear();
+      }
+      flush();
+    },
+    peek: () => held,
+    reset() {
+      held = null;
+      restored = false;
+    }
+  };
+};
+exports.createPendingScheduledCallQueue = createPendingScheduledCallQueue;
+const isScheduledCallReady = () => {
+  const settings = _roomStore.store.getState().chatSettingStore;
+  return !!settings.user?.token && settings.config !== undefined && (settings.connection === 'online' || settings.connection === 'syncing');
+};
+exports.isScheduledCallReady = isScheduledCallReady;
+const reportOpenError = (slug, reason) => {
+  try {
+    _roomStore.store.getState().chatSettingStore.config?.scheduledCalls?.onOpenError?.({
+      slug,
+      reason
+    });
+  } catch {
+    // A host callback must not break the flow.
+  }
+};
+
+/** Resolve the slug, open its room, show the pre-join sheet. */
+const resolveAndOpenScheduledCall = async slug => {
+  _scheduledCallStore.scheduledCallUi.showPreJoin({
+    phase: 'loading',
+    slug
+  });
+  let detail;
+  try {
+    detail = await (0, _scheduledCalls.getScheduledCall)(slug);
+  } catch (error) {
+    const code = (0, _scheduledCalls.isScheduledCallApiError)(error) ? error.code : 'unknown';
+    const reason = code === 'not-a-member' ? 'not-a-member' : code === 'not-found' ? 'not-found' : 'network';
+    _scheduledCallStore.scheduledCallUi.showPreJoin({
+      phase: 'error',
+      slug,
+      reason
+    });
+    reportOpenError(slug, reason);
+    return;
+  }
+  if (detail.scheduledCall.status === 'cancelled') {
+    _scheduledCallStore.scheduledCallUi.showPreJoin({
+      phase: 'error',
+      slug,
+      reason: 'cancelled',
+      title: detail.scheduledCall.title
+    });
+    reportOpenError(slug, 'cancelled');
+    return;
+  }
+  const conference = _roomStore.store.getState().chatSettingStore.config?.xmppSettings?.conference;
+  const jid = detail.chat?.jid || (0, _normalizeRoomJid.normalizeRoomJid)(detail.chat?.name || (0, _scheduledCall.chatNameOfRoom)(detail.scheduledCall.chatName), conference);
+  if (jid) {
+    (0, _pushPayload.openRoomFromPush)(jid);
+  }
+  _scheduledCallStore.scheduledCallUi.showPreJoin({
+    phase: 'ready',
+    slug,
+    detail
+  });
+};
+exports.resolveAndOpenScheduledCall = resolveAndOpenScheduledCall;
+const queue = createPendingScheduledCallQueue({
+  isReady: isScheduledCallReady,
+  open: slug => {
+    void resolveAndOpenScheduledCall(slug);
+  },
+  storage: asyncPendingStorage
+});
+let unsubscribe = null;
+
+/**
+ * Watches the store so a held link opens the moment sign-in and the chat
+ * are both there. Idempotent; `<Chat>` arms it on import and
+ * `openScheduledCall` arms it too, so a link that beats `<Chat>` is not lost.
+ */
+const installScheduledCallHook = () => {
+  if (unsubscribe) {
+    return;
+  }
+  unsubscribe = _roomStore.store.subscribe(() => {
+    if (queue.peek()) {
+      queue.poke();
+    }
+  });
+  void queue.restore();
+};
+
+/**
+ * Open a scheduled call by slug: now when the user is signed in and the
+ * chat is up, otherwise as soon as both are true. Returns `'opening'` when
+ * it started right away and `'pending'` when it is held.
+ */
+exports.installScheduledCallHook = installScheduledCallHook;
+const openScheduledCall = slug => {
+  installScheduledCallHook();
+  return queue.submit(slug) === 'opened' ? 'opening' : 'pending';
+};
+
+/**
+ * Hand any URL to the SDK: a scheduled-call link is opened (or held) and
+ * `true` is returned; anything else returns `false` untouched.
+ */
+exports.openScheduledCall = openScheduledCall;
+const handleScheduledCallUrl = url => {
+  const slug = (0, _scheduledCallLink.parseScheduledCallLink)(url);
+  if (!slug) {
+    return false;
+  }
+  openScheduledCall(slug);
+  return true;
+};
+
+/** The reminder push the backend sends 10 minutes before a call. */
+exports.handleScheduledCallUrl = handleScheduledCallUrl;
+const SCHEDULED_CALL_REMINDER_PUSH_TYPE = exports.SCHEDULED_CALL_REMINDER_PUSH_TYPE = 'scheduledCallReminder';
+const isScheduledCallReminderPush = data => String(data?.type || '') === SCHEDULED_CALL_REMINDER_PUSH_TYPE;
+
+/** Slug of a reminder push: `slug`, else parsed out of `joinUrl`. */
+exports.isScheduledCallReminderPush = isScheduledCallReminderPush;
+const scheduledCallSlugFromPush = data => {
+  if (!isScheduledCallReminderPush(data)) {
+    return null;
+  }
+  const slug = String(data?.slug || '').trim();
+  if (/^[A-Za-z0-9_-]{16,128}$/.test(slug)) {
+    return slug;
+  }
+  return (0, _scheduledCallLink.parseScheduledCallLink)(String(data?.joinUrl || ''));
+};
+
+/** A tap on the reminder push opens the same flow as the join link. */
+exports.scheduledCallSlugFromPush = scheduledCallSlugFromPush;
+const handleScheduledCallPush = data => {
+  const slug = scheduledCallSlugFromPush(data);
+  if (!slug) {
+    return false;
+  }
+  openScheduledCall(slug);
+  return true;
+};
+exports.handleScheduledCallPush = handleScheduledCallPush;
+const __resetPendingScheduledCallForTests = () => {
+  queue.reset();
+  unsubscribe?.();
+  unsubscribe = null;
+};
+exports.__resetPendingScheduledCallForTests = __resetPendingScheduledCallForTests;
+//# sourceMappingURL=pendingScheduledCall.js.map

package/lib/commonjs/booking/pendingScheduledCall.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_asyncStorage","_interopRequireDefault","require","_roomStore","_pushPayload","_normalizeRoomJid","_scheduledCalls","_scheduledCallLink","_scheduledCall","_scheduledCallStore","e","__esModule","default","PENDING_SCHEDULED_CALL_KEY","exports","PENDING_SCHEDULED_CALL_TTL_MS","asyncPendingStorage","read","raw","AsyncStorage","getItem","parsed","JSON","parse","slug","Number","isFinite","at","write","value","setItem","stringify","clear","removeItem","createPendingScheduledCallQueue","deps","now","Date","ttl","ttlMs","held","restored","fresh","entry","flush","storage","isReady","open","submit","poke","restore","saved","peek","reset","isScheduledCallReady","settings","store","getState","chatSettingStore","user","token","config","undefined","connection","reportOpenError","reason","scheduledCalls","onOpenError","resolveAndOpenScheduledCall","scheduledCallUi","showPreJoin","phase","detail","getScheduledCall","error","code","isScheduledCallApiError","scheduledCall","status","title","conference","xmppSettings","jid","chat","normalizeRoomJid","name","chatNameOfRoom","chatName","openRoomFromPush","queue","unsubscribe","installScheduledCallHook","subscribe","openScheduledCall","handleScheduledCallUrl","url","parseScheduledCallLink","SCHEDULED_CALL_REMINDER_PUSH_TYPE","isScheduledCallReminderPush","data","String","type","scheduledCallSlugFromPush","trim","test","joinUrl","handleScheduledCallPush","__resetPendingScheduledCallForTests"],"sourceRoot":"../../../src","sources":["booking/pendingScheduledCall.ts"],"mappings":"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","ignoreList":[]}