@experiaapp/webchat-react-native 2.0.1

package/lib/state/WebchatProvider.js

@@ -0,0 +1,906 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebchatContext = void 0;
+exports.WebchatProvider = WebchatProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// src/state/WebchatProvider.tsx
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const messagesReducer_1 = require("../core/messagesReducer");
+const WebchatClient_1 = require("../core/WebchatClient");
+const persistence_1 = require("../core/persistence");
+const unread_1 = require("../core/unread");
+const greet_1 = require("../core/greet");
+const types_1 = require("../core/types");
+const configClient_1 = require("../core/configClient");
+const themeFactory_1 = require("../theme/themeFactory");
+const expoDefaults_1 = require("../adapters/expoDefaults");
+const media_1 = require("../core/media");
+const picker_1 = require("../adapters/picker");
+const VideoCallClient_1 = require("../core/VideoCallClient");
+exports.WebchatContext = (0, react_1.createContext)(null);
+const DAY_MS = 24 * 60 * 60 * 1000;
+/**
+ * Resolve the localize default language without statically importing
+ * `react-native-localize` (an optional native peer). Lazy-required so chat-only
+ * consumers without the lib — and tests that don't mock it — never load it. Any
+ * failure (lib absent / native module not linked) falls back to 'en'.
+ */
+function localizeDefaultLanguage() {
+    var _a, _b;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const localize = require("react-native-localize");
+        const code = (_b = (_a = localize.getLocales) === null || _a === void 0 ? void 0 : _a.call(localize)[0]) === null || _b === void 0 ? void 0 : _b.languageCode;
+        return code === "ar" ? "ar" : "en";
+    }
+    catch {
+        return "en";
+    }
+}
+/** Lazy-require initI18n (pulls react-native-localize); never throws into the provider. */
+function safeInitI18n(language) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require("../i18n").initI18n(language);
+    }
+    catch {
+        /* i18n is best-effort; the lib/native module may be absent */
+    }
+}
+function WebchatProvider(props) {
+    var _a;
+    // store: a host-injected KeyValueStore ALWAYS wins (tests inject a MemoryStore).
+    // When the host injects NONE, the backend is config-driven (Tier C #33, web
+    // `config.storage`): "sessionStorage"/"memory" -> an ephemeral MemoryStore (history
+    // does NOT survive a relaunch), "localStorage" (default) -> the persistent
+    // AsyncStorage store (24h sliding TTL). Resolved ONCE per mount via selectStore so
+    // the ephemeral path doesn't churn a new Map every render. `injectedStore` is left
+    // undefined (not defaulted) so selectStore can tell host-injected from absent.
+    const { config, socketFactory, store: injectedStore, now = () => Date.now(), children, 
+    // #1/#2 config fetch: inject a fetch for tests; default to the ambient global
+    // inside fetchConfig. With no `configUrl` we skip the fetch and use the prop config.
+    fetchImpl, 
+    // Phase 2 injectables — default to identity/limits so nothing native is touched
+    // unless the host wires a real picker/reader. `readBase64` turns an asset uri into
+    // raw base64 (eager `asset.base64` short-circuits it); `mediaLimits` overrides caps.
+    readBase64, mediaLimits = media_1.DEFAULT_LIMITS, 
+    // Phase 3 video seams (Group E) — ALL optional and lazily resolved inside startCall,
+    // so non-video flows (and every non-video test) never touch a native module:
+    //   - `webrtcFactory`  defaults to the real react-native-webrtc factory at call time.
+    //   - `audioRoute`     defaults to the real react-native-incall-manager wrapper.
+    //   - `createVideoClient` defaults to the real createVideoCallClient.
+    // Tests inject fakes so startCall/endCall are exercised with no native calls.
+    webrtcFactory, audioRoute, createVideoClient = VideoCallClient_1.createVideoCallClient, 
+    // Received-voice playback seam (audit #23): the injected AudioAdapter the live
+    // Bubble uses to render an inline <VoiceMessage> for audio attachments. Optional
+    // (chat-only consumers never wire it); exposed on context so the Surface/MessageList
+    // don't have to thread it as a prop.
+    audioAdapter, 
+    // Tenant custom-font loader (item 28, web `publicStyle.defaultFontFamily`).
+    // Lazily resolved like the other expo seams: defaults to createExpoFontLoader()
+    // which returns `undefined` when expo-font is absent (Metro/jest never break),
+    // so the require is the only touch of the native module and only when a tenant
+    // font is actually configured. Tests inject a fake loader. When the loader is
+    // undefined (no expo-font) OR no font is configured, fonts simply never load and
+    // every component keeps the system font (current behaviour).
+    fontLoader = (0, expoDefaults_1.createExpoFontLoader)(), } = props;
+    // Resolve the persistence store ONCE per mount (Tier C #33). A host-injected store
+    // wins; otherwise config.storage selects ephemeral (sessionStorage/memory) vs the
+    // persistent AsyncStorage backend. config.storage is read off the prop config (the
+    // backend choice is stable from mount and the server fetch can't re-bind a live
+    // store). useRef keeps the ephemeral MemoryStore identity stable across renders.
+    const storeRef = (0, react_1.useRef)((0, persistence_1.selectStore)(injectedStore, config === null || config === void 0 ? void 0 : config.storage, async_storage_1.default));
+    const store = storeRef.current;
+    const [state, dispatch] = (0, react_1.useReducer)(messagesReducer_1.messagesReducer, messagesReducer_1.initialState);
+    const [status, setStatus] = (0, react_1.useState)("idle");
+    const [isStorageReady, setStorageReady] = (0, react_1.useState)(false); // B9: hard precondition gate
+    // Item 34 — latched once we first reach a CONFIRMED session ("session-confirmed");
+    // never resets. Gates hideWhenNotConnected so we only hide AFTER a real
+    // established-then-lost drop. We latch on session-confirmed (not bare transport
+    // "connected") so the initial handshake window (connect -> session-pending) is NOT
+    // treated as "previously connected" — otherwise the surface/launcher would vanish
+    // mid-handshake before the user ever had a usable connection.
+    const [wasConnected, setWasConnected] = (0, react_1.useState)(false);
+    // #1/#2: resolvedConfig/theme/dir/language. Start from the merged prop+default so the
+    // very first render (pre-fetch) already has a coherent theme/dir; the server merge
+    // refines it once the fetch resolves.
+    const [resolved, setResolved] = (0, react_1.useState)(() => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const merged = (0, configClient_1.mergeConfig)(config, null);
+        const language = ((_b = (_a = config.language) !== null && _a !== void 0 ? _a : merged.language) !== null && _b !== void 0 ? _b : "en");
+        const variant = (0, themeFactory_1.resolveVariant)(merged.interfaceTheme);
+        return {
+            config: merged,
+            language,
+            dir: (language === "ar" ? "rtl" : "ltr"),
+            variant,
+            // First render uses NO loaded font map (undefined) => theme.font.family stays
+            // undefined and every component renders with the system font. The brand fonts
+            // load asynchronously (best-effort, below) and rebuild the theme when they
+            // resolve — an accepted FOUT (flash of system text, then the brand font).
+            theme: (0, themeFactory_1.buildTheme)(variant, (_c = merged.publicStyle) !== null && _c !== void 0 ? _c : {}, (_d = merged.chatSectionStyle) !== null && _d !== void 0 ? _d : {}, (_e = merged.headerSectionStyle) !== null && _e !== void 0 ? _e : {}, (_f = merged.sendSectionStyle) !== null && _f !== void 0 ? _f : {}, (_g = merged.wedgitSectionStyle) !== null && _g !== void 0 ? _g : {}),
+        };
+    });
+    // item 28 — loaded weight->family map from the brand-font loader. `undefined`
+    // until the tenant fonts resolve (and forever when none are configured / expo-font
+    // is absent); once set it is fed into buildTheme so theme.font.family/familyMap
+    // become defined. NEVER blocks render — the theme rebuilds in a later commit.
+    const [loadedFonts, setLoadedFonts] = (0, react_1.useState)(undefined);
+    const sessionId = (0, react_1.useRef)("");
+    const connectedRef = (0, react_1.useRef)(false);
+    // Always-current mirrors so persistence/handlers running in stale effect closures
+    // (greet on session_confirm) read the latest values, not the mount-render snapshot.
+    const messagesRef = (0, react_1.useRef)(state.messages);
+    messagesRef.current = state.messages;
+    const lastReadRef = (0, react_1.useRef)(state.lastReadAt);
+    lastReadRef.current = state.lastReadAt;
+    // S7: a chat that is mounted with no explicit `open` control stays connected so it can
+    // receive while closed (the host toggles surface visibility). Only a deliberately-passed
+    // `open={false}` (with autoConnection off) keeps the socket closed.
+    const openRef = (0, react_1.useRef)(props.open !== undefined ? Boolean(props.open) : true);
+    const lastActivity = (0, react_1.useRef)(now()); // #16 sliding TTL anchor
+    const ttlRef = (0, react_1.useRef)(DAY_MS); // #16: refined from resolvedConfig
+    const pending = (0, react_1.useRef)([]); // B10: sends queued while disconnected
+    const greeted = (0, react_1.useRef)(new Set()); // C3/#17: per-session greet dedup
+    const client = (0, react_1.useRef)(null);
+    const mediaKeys = (0, react_1.useRef)(new Set()); // P2: outgoing media messageKeys awaiting an UPDATE_MSG echo
+    const queuedMedia = (0, react_1.useRef)(new Map()); // P2: media[] for sends queued while disconnected
+    const recvSeq = (0, react_1.useRef)(0); // monotonic suffix so received-message keys never collide within a ms
+    // resolvedConfig snapshot for callbacks that run outside render (AppState/netinfo).
+    const cfgRef = (0, react_1.useRef)(resolved.config);
+    cfgRef.current = resolved.config;
+    const lastUnread = (0, react_1.useRef)(0); // #4: change-detection for onUnreadChange
+    // P3 video: the live chat socket instance (captured below by wrapping socketFactory),
+    // reused by the VideoCallClient so the call rides the EXISTING connection (no second socket).
+    const socketRef = (0, react_1.useRef)(null);
+    const videoClient = (0, react_1.useRef)(null);
+    const audioRouteRef = (0, react_1.useRef)(null);
+    const [videoCallStarted, setVideoCallStarted] = (0, react_1.useState)(false);
+    // --- Prechat / greet coordination (web parity) -----------------------------
+    // The greet (/chitchat.greet) carries the prechat form data. To match web — which
+    // defers the session/greet until the form is submitted, then sends the collected
+    // fields as `prechatFormSubmission` (ChatContainer.tsx:167-185) — we DEFER the greet
+    // while a prechat form is showing and unsubmitted, then send it (with the data) once
+    // the values arrive. A RESUMED session never shows the form, so it greets normally
+    // (and is already in `greeted`, so shouldGreet short-circuits anyway).
+    const [resumedSession, setResumedSession] = (0, react_1.useState)(false); // reactive (UI gate)
+    const resumedSessionRef = (0, react_1.useRef)(false); // sync (greet handler)
+    const prechatSubmittedRef = (0, react_1.useRef)(false); // values arrived this session
+    const pendingGreetIdRef = (0, react_1.useRef)(null); // confirmed id awaiting a deferred greet
+    // Live prechat values (props.prechatValues is captured stale in the mount-effect
+    // socket handler; a ref keeps the greet reading the CURRENT submitted values).
+    const prechatValuesRef = (0, react_1.useRef)(props.prechatValues);
+    prechatValuesRef.current = props.prechatValues;
+    // configReady: gate the greet until the server config has resolved when a configUrl
+    // is actually fetched — otherwise a server-driven prechatForm.enabled could arrive
+    // AFTER session_confirm and the greet would already have fired without the form.
+    // No real fetch (no configUrl / no fetch impl) => ready immediately (offline/tests).
+    const configReadyRef = (0, react_1.useRef)(!((config === null || config === void 0 ? void 0 : config.configUrl) && (fetchImpl !== null && fetchImpl !== void 0 ? fetchImpl : globalThis.fetch)));
+    // Defer the greet while a prechat form will collect data first: enabled (server
+    // config OR host fields), a NEW (non-resumed) session, not yet submitted — or while
+    // the server config is still loading and could turn the form on. Recomputed each
+    // render into a ref so the mount-effect socket handler reads the CURRENT decision.
+    const prechatEnabled = ((_a = resolved.config.prechatForm) === null || _a === void 0 ? void 0 : _a.enabled) === true || props.hasPrechatFields === true;
+    const deferGreetRef = (0, react_1.useRef)(false);
+    deferGreetRef.current =
+        !resumedSessionRef.current &&
+            !prechatSubmittedRef.current &&
+            (prechatEnabled || !configReadyRef.current);
+    // #16: anything that counts as activity refreshes the sliding-TTL anchor + persists it
+    // so the window slides from last use, not only from the last new message.
+    const touchActivity = (0, react_1.useCallback)(() => { lastActivity.current = now(); }, [now]);
+    // Whether the socket should be connected right now (S7/S8): the master switch must be on,
+    // and either we auto-connect or the surface is open.
+    const shouldConnect = (0, react_1.useCallback)(() => {
+        const c = cfgRef.current;
+        if (c.enableConnection === false)
+            return false; // master switch off -> never connect
+        return c.autoConnection === true || openRef.current; // auto, or open-gated
+    }, []);
+    // --- Config fetch + merge (#1/#2) ------------------------------------------
+    // Runs once on mount (channel-keyed). Fetches the server config when a configUrl is
+    // present + a fetch is available (injected for tests; default to ambient inside the
+    // client), merges prop>server>default, and recomputes theme/dir/language/variant.
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        (async () => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            let server = null;
+            // Fetch the server config only when a fetch is explicitly injected (the documented
+            // test seam) or the host opts into ambient-fetch with `useAmbientFetch`. Without
+            // either we default to the prop+default config (no network) — keeping unit tests
+            // and chat-only embeds offline.
+            // Fetch the server config by DEFAULT (the whole point of configUrl): use an
+            // injected fetch in tests, else the ambient global fetch (present in RN + node).
+            // Tests stay offline via a jest stub that rejects fetch (see jest.setup.ui.js).
+            const doFetch = fetchImpl !== null && fetchImpl !== void 0 ? fetchImpl : globalThis.fetch;
+            if (config.configUrl && doFetch) {
+                try {
+                    server = await (0, configClient_1.fetchConfig)(config.configUrl, config.channelId, doFetch);
+                }
+                catch (e) {
+                    (_a = props.onError) === null || _a === void 0 ? void 0 : _a.call(props, e); // recoverable config-fetch error (C5); fall back to prop+default
+                }
+            }
+            if (cancelled)
+                return;
+            const merged = (0, configClient_1.mergeConfig)(config, server);
+            // language precedence: prop > server config > localize default
+            const language = ((_c = (_b = config.language) !== null && _b !== void 0 ? _b : merged.language) !== null && _c !== void 0 ? _c : localizeDefaultLanguage());
+            merged.language = language;
+            const variant = (0, themeFactory_1.resolveVariant)(merged.interfaceTheme);
+            ttlRef.current = (_d = merged.ttlMs) !== null && _d !== void 0 ? _d : DAY_MS; // #16
+            setResolved({
+                config: merged,
+                language,
+                dir: (language === "ar" ? "rtl" : "ltr"),
+                variant,
+                // Build with the CURRENT loaded map (undefined on first resolve => system
+                // font). If the fonts have already loaded by a later config refresh the map
+                // is reused; the separate font-load effect below rebuilds the theme when the
+                // map first arrives.
+                theme: (0, themeFactory_1.buildTheme)(variant, (_e = merged.publicStyle) !== null && _e !== void 0 ? _e : {}, (_f = merged.chatSectionStyle) !== null && _f !== void 0 ? _f : {}, (_g = merged.headerSectionStyle) !== null && _g !== void 0 ? _g : {}, (_h = merged.sendSectionStyle) !== null && _h !== void 0 ? _h : {}, (_j = merged.wedgitSectionStyle) !== null && _j !== void 0 ? _j : {}, loadedFonts),
+            });
+            safeInitI18n(language); // swap browser detector for explicit/localize language (C23)
+            // Config is now resolved — the prechat decision (server prechatForm.enabled) is
+            // known. Release any greet deferred purely on "config still loading": decide from
+            // the freshly-merged config (deferGreetRef still holds the pre-resolve render's
+            // value here). If no form is needed, fire the pending greet now.
+            configReadyRef.current = true;
+            const stillDefer = !resumedSessionRef.current &&
+                !prechatSubmittedRef.current &&
+                (((_k = merged.prechatForm) === null || _k === void 0 ? void 0 : _k.enabled) === true || props.hasPrechatFields === true);
+            const pendingId = pendingGreetIdRef.current;
+            if (pendingId && !stillDefer) {
+                pendingGreetIdRef.current = null;
+                sendGreet(pendingId);
+            }
+            // item 28 — load tenant custom fonts best-effort, AFTER the theme is set with
+            // the system font (so the FIRST render never waits on the network — accepted
+            // FOUT). Only when a loader exists (expo-font present) AND the tenant actually
+            // shipped a `defaultFontFamily.fonts[]`. The loader tolerates per-weight
+            // failures and resolves a weight->family map; an empty map / any failure leaves
+            // the system font. NEVER throws into the provider.
+            const fontFamily = (_l = merged.publicStyle) === null || _l === void 0 ? void 0 : _l.defaultFontFamily;
+            if (fontLoader && (fontFamily === null || fontFamily === void 0 ? void 0 : fontFamily.fonts) && fontFamily.fonts.length > 0) {
+                // fire-and-forget: do NOT await — render proceeds with the system font and the
+                // theme rebuilds in a later commit once this resolves (the font-load effect).
+                void (async () => {
+                    try {
+                        const map = await fontLoader(fontFamily);
+                        if (cancelled)
+                            return;
+                        // Only promote to a defined family when at least one weight loaded.
+                        if (map && Object.keys(map).length > 0)
+                            setLoadedFonts(map);
+                    }
+                    catch {
+                        /* loader is best-effort (it already tolerates per-weight failures);
+                           a total failure leaves the system font — never throw. */
+                    }
+                })();
+            }
+        })();
+        return () => { cancelled = true; };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [config.channelId]);
+    // item 28 — when the brand fonts resolve (loadedFonts goes from undefined to a
+    // non-empty map), rebuild the theme so theme.font.family/familyMap become defined
+    // and every component picks up the loaded family for the weight it renders. Runs in
+    // its OWN commit (after the system-font render) — the accepted FOUT. A no-op while
+    // loadedFonts is undefined (the common case: no tenant font / expo-font absent).
+    (0, react_1.useEffect)(() => {
+        if (!loadedFonts)
+            return;
+        setResolved((prev) => {
+            var _a, _b, _c, _d, _e;
+            const c = prev.config;
+            return {
+                ...prev,
+                theme: (0, themeFactory_1.buildTheme)(prev.variant, (_a = c.publicStyle) !== null && _a !== void 0 ? _a : {}, (_b = c.chatSectionStyle) !== null && _b !== void 0 ? _b : {}, (_c = c.headerSectionStyle) !== null && _c !== void 0 ? _c : {}, (_d = c.sendSectionStyle) !== null && _d !== void 0 ? _d : {}, (_e = c.wedgitSectionStyle) !== null && _e !== void 0 ? _e : {}, loadedFonts),
+            };
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [loadedFonts]);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        (async () => {
+            var _a, _b;
+            const restored = (await (0, persistence_1.loadSession)(store, config.channelId, {
+                now: now(), ttlMs: ttlRef.current,
+            }));
+            if (cancelled)
+                return;
+            if (restored) {
+                dispatch({ type: "HYDRATE", messages: restored.messages });
+                sessionId.current = restored.sessionId;
+                if (restored.sessionId) {
+                    greeted.current.add(restored.sessionId); // restored session already greeted (C3)
+                    // Returning user: this session is a RESUME, not a new one — suppress the
+                    // prechat form (web `!sessionId` gate). Set the ref synchronously for the
+                    // greet handler + the state for the UI gate (useWebchat → Surface).
+                    resumedSessionRef.current = true;
+                    setResumedSession(true);
+                }
+                // #17: rehydrate the explicit greetSent set so a cold start doesn't re-greet.
+                ((_a = restored.greetSent) !== null && _a !== void 0 ? _a : []).forEach((id) => greeted.current.add(id));
+                // #4: seed lastReadAt to the newest restored bot ts (restored history is NOT unread).
+                const newestBot = restored.messages
+                    .filter((m) => m.sender === "response")
+                    .reduce((acc, m) => Math.max(acc, m.timestamp), 0);
+                const seed = (_b = restored.lastReadAt) !== null && _b !== void 0 ? _b : newestBot;
+                if (seed > 0)
+                    dispatch({ type: "MARK_READ", at: seed });
+                if (restored.lastActivity)
+                    lastActivity.current = restored.lastActivity;
+            }
+            setStorageReady(true); // B9: hydration done -> safe to connect + evaluate prechat gate
+            // Wrap the factory so we keep a handle on the SAME socket instance the chat client
+            // uses (P3): a video call reuses this exact connection rather than opening a second one.
+            const c = (0, WebchatClient_1.createWebchatClient)({
+                socketFactory: () => {
+                    const s = socketFactory(config);
+                    socketRef.current = s;
+                    return s;
+                },
+                getStoredSessionId: () => sessionId.current, // B8 resume by stored id on (re)connect
+            });
+            c.on("status", (s) => {
+                var _a, _b;
+                setStatus(s);
+                const isUp = s === "connected" || s === "session-confirmed";
+                connectedRef.current = isUp;
+                // item 34: latch only on a CONFIRMED session (not bare transport connect) so
+                // the initial handshake never counts as "previously connected".
+                if (s === "session-confirmed")
+                    setWasConnected(true);
+                if (isUp) {
+                    (_a = props.onConnected) === null || _a === void 0 ? void 0 : _a.call(props);
+                    // flush any sends queued while disconnected (B10): emit + mark sent now.
+                    // Media sends carry their encoded media[] (stashed by key) and DO NOT auto-ACK —
+                    // they reconcile to 'sent' on the server UPDATE_MSG echo instead.
+                    pending.current.splice(0).forEach((p) => {
+                        const media = queuedMedia.current.get(p.key);
+                        if (media) {
+                            queuedMedia.current.delete(p.key);
+                            emitMessage(p.key, p.text, media); // stays pending until UPDATE_MSG
+                        }
+                        else {
+                            emitMessage(p.key, p.text);
+                            dispatch({ type: "ACK", key: p.key });
+                        }
+                    });
+                }
+                if (s === "reconnecting" || s === "session-failed")
+                    (_b = props.onDisconnected) === null || _b === void 0 ? void 0 : _b.call(props);
+            });
+            c.on("error", (e) => { var _a; return (_a = props.onError) === null || _a === void 0 ? void 0 : _a.call(props, e); }); // typed WebChatError from the client (B7/C5)
+            c.on("session", (id) => {
+                sessionId.current = id;
+                // greet only on a genuinely new session_confirm; survives cold start (C3/#17).
+                if (!(0, greet_1.shouldGreet)({ sessionId: id, greetedSessions: greeted.current }))
+                    return;
+                // Defer when a prechat form will collect data first (web parity): the greet
+                // carries that data as `prechatFormSubmission`, so it must wait for submit.
+                // sendGreet() runs from the prechat-values effect (on submit) or the config
+                // effect (once config resolves and confirms no form is needed).
+                if (deferGreetRef.current) {
+                    pendingGreetIdRef.current = id;
+                    return;
+                }
+                sendGreet(id);
+            });
+            c.on("message", (m) => {
+                var _a, _b, _c;
+                // Item 26 — autoJoinVideoCall (web parity: redux/messages/actions.ts:128-138).
+                // When the tenant enables autoJoinVideoCall, the server signals an incoming call
+                // by pushing a bot message whose text is the sentinel "Start recording..."; the
+                // web build dispatches START_VIDEO_CALL on it. The SDK's analog is startCall().
+                // We auto-invoke it here, reading the flag off cfgRef (this handler runs outside
+                // render). startCall is idempotent (no-ops if a call is already active or the
+                // socket isn't wired), so this never double-starts or regresses the manual flow.
+                if ((m === null || m === void 0 ? void 0 : m.text) === "Start recording..." && cfgRef.current.autoJoinVideoCall === true) {
+                    startCall();
+                }
+                // P2 reconciliation: the server echoes our own media send back tagged as the
+                // client sender (`sender: "client"`) carrying the HOSTED media URL — so the
+                // optimistic bubble can swap its heavy base64 for the lightweight URL instead of
+                // keeping the data URL forever (and instead of appending a duplicate bubble).
+                //
+                // The LIVE backend echo is bare — NO messageKey, NO text, e.g.
+                //   {"media":["https://…s3…png"],"sender":"client"}
+                // so we cannot always match by key. Target resolution (in order):
+                //   1. explicit messageKey echo (if the server ever sends one) -> that exact send;
+                //   2. otherwise FIFO — the OLDEST still-pending media send. `mediaKeys` is a Set
+                //      (insertion order preserved) and the server confirms sends in order over the
+                //      single socket, so the oldest unreconciled media key is the right target.
+                //      (Out-of-order confirmation without a key is unrecoverable, but doesn't occur
+                //      on a single ordered socket.)
+                // A `sender: "client"` message is NEVER a bot message, so we always consume it here
+                // and never let it fall through to RECEIVE (that was the duplicate-bubble bug).
+                const echoKey = m === null || m === void 0 ? void 0 : m.messageKey;
+                const isClientEcho = (m === null || m === void 0 ? void 0 : m.sender) === "client" || (echoKey && mediaKeys.current.has(echoKey));
+                if (isClientEcho) {
+                    const hasMediaEcho = Array.isArray(m === null || m === void 0 ? void 0 : m.media) ? m.media.length > 0 : Boolean(m === null || m === void 0 ? void 0 : m.mediaUrl);
+                    // matching messageKey wins; else the oldest pending media key (FIFO).
+                    const targetKey = echoKey && mediaKeys.current.has(echoKey)
+                        ? echoKey
+                        : mediaKeys.current.values().next().value;
+                    if (targetKey && hasMediaEcho) {
+                        mediaKeys.current.delete(targetKey);
+                        const url = Array.isArray(m.media) ? m.media[0] : m.mediaUrl;
+                        dispatch({
+                            type: "UPDATE_MSG",
+                            key: targetKey,
+                            patch: { mediaUrl: url, media: m.media, ...(m.type !== undefined ? { type: m.type } : {}) },
+                        });
+                    }
+                    // A text-only client echo (no media, nothing pending) has nothing to reconcile —
+                    // just don't append it as a bot bubble.
+                    (_a = props.onMessageReceived) === null || _a === void 0 ? void 0 : _a.call(props, m);
+                    return;
+                }
+                // Preserve the server-driven reaction contract (web parity): the stable
+                // server id (`messageKey`, distinct from the SDK's own `key`), the per-message
+                // `options` (incl. `enableReaction` gating the thumbs row), and any prior
+                // `userReaction`. Dropping these would make the feedback feature unreachable.
+                dispatch({
+                    type: "RECEIVE",
+                    message: {
+                        // Unique key: `now()` alone collides when the server bursts more than one
+                        // message in the same millisecond (React "two children with the same key").
+                        // A monotonic suffix guarantees uniqueness.
+                        key: (_b = m.key) !== null && _b !== void 0 ? _b : `b${now()}-${(recvSeq.current += 1)}`,
+                        sender: "response",
+                        text: m.text,
+                        quick_replies: m.quick_replies,
+                        timestamp: now(),
+                        // Preserve incoming MEDIA (web RecieverMsg parity): files[] objects and
+                        // media[]/mediaUrl URL strings. Dropping these is why received photo /
+                        // video / document attachments never rendered (Bubble.collectAttachments
+                        // found nothing on the normalized message).
+                        ...(m.files !== undefined ? { files: m.files } : {}),
+                        ...(m.media !== undefined ? { media: m.media } : {}),
+                        ...(m.mediaUrl !== undefined ? { mediaUrl: m.mediaUrl } : {}),
+                        ...(m.type !== undefined ? { type: m.type } : {}),
+                        ...(m.messageKey !== undefined ? { messageKey: m.messageKey } : {}),
+                        ...(m.options !== undefined ? { options: m.options } : {}),
+                        ...(m.userReaction !== undefined ? { userReaction: m.userReaction } : {}),
+                    },
+                });
+                (_c = props.onMessageReceived) === null || _c === void 0 ? void 0 : _c.call(props, m);
+            });
+            // Section 4 — inbound feedback reflection (web parity). The server echoes a
+            // like/dislike toggle back on "activityAck" with { messageKey, type }. Map the
+            // backend verb onto the stored reaction ("like"/"dislike" set it; any toggle-off
+            // verb — "unlike"/"undislike" — or anything else clears it) and dispatch REACT to
+            // reconcile the optimistic state with the server's truth.
+            c.on("activityAck", (d) => {
+                const reaction = (d === null || d === void 0 ? void 0 : d.type) === "like" ? "like" : (d === null || d === void 0 ? void 0 : d.type) === "dislike" ? "dislike" : null;
+                if (d === null || d === void 0 ? void 0 : d.messageKey)
+                    dispatch({ type: "REACT", messageKey: d.messageKey, reaction });
+            });
+            client.current = c;
+            if (shouldConnect())
+                c.connect(); // S7/S8: don't connect a deliberately-closed/disabled socket
+        })();
+        return () => { var _a; cancelled = true; endCall(); (_a = client.current) === null || _a === void 0 ? void 0 : _a.disconnect(); };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [config.channelId]);
+    // persist on change (base64 stripped by callers in Phase 2). Also re-persists when the
+    // read marker moves (#4) so lastReadAt survives a cold start for the badge baseline.
+    (0, react_1.useEffect)(() => {
+        persistSession();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [state.messages, state.lastReadAt]);
+    // Prechat submit (web parity): once the form values arrive, mark submitted and flush
+    // any greet that was deferred on session_confirm — so the greet carries the data as
+    // `prechatFormSubmission`. If the session hasn't confirmed yet, the deferred branch is
+    // cleared (deferGreetRef now false) and the session handler greets directly on confirm.
+    (0, react_1.useEffect)(() => {
+        const pv = props.prechatValues;
+        if (pv && Object.keys(pv).length > 0) {
+            prechatSubmittedRef.current = true;
+            const pendingId = pendingGreetIdRef.current;
+            if (pendingId) {
+                pendingGreetIdRef.current = null;
+                sendGreet(pendingId);
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.prechatValues]);
+    // #4: notify the host whenever the unread count changes (and reset is observed on open).
+    const unread = (0, unread_1.unreadCount)(state.messages, state.lastReadAt);
+    (0, react_1.useEffect)(() => {
+        var _a;
+        if (unread !== lastUnread.current) {
+            lastUnread.current = unread;
+            (_a = props.onUnreadChange) === null || _a === void 0 ? void 0 : _a.call(props, unread);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [unread]);
+    // #4: reflect the controlled `open` prop. Opening marks-read (resets unread) + refreshes
+    // the sliding-TTL anchor, and connects a deliberately-opened socket if it wasn't auto.
+    (0, react_1.useEffect)(() => {
+        if (props.open === undefined)
+            return;
+        openRef.current = props.open;
+        if (props.open)
+            markReadAndTouch();
+        if (isStorageReady)
+            reconcileConnection();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.open, isStorageReady]);
+    // openOnLoad (#7/S8): once config resolves + storage is ready, an openOnLoad config
+    // (with no controlling `open` prop) opens the surface + connects.
+    (0, react_1.useEffect)(() => {
+        if (props.open !== undefined)
+            return; // controlled open wins
+        if (!isStorageReady)
+            return;
+        if (cfgRef.current.openOnLoad && !openRef.current) {
+            openRef.current = true;
+            markReadAndTouch();
+            reconcileConnection();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isStorageReady, resolved.config]);
+    // #6: AppState + connectivity reconnect. On returning to 'active' (and on regained
+    // network connectivity) reconnect the socket — respecting the open/enable gates — and
+    // re-request the session by stored id. Sliding-TTL anchor refreshes on foreground.
+    (0, react_1.useEffect)(() => {
+        var _a;
+        const onForeground = () => {
+            markReadAndTouch(); // foreground counts as read + activity (#4/#16)
+            if (shouldConnect() && client.current) {
+                // re-establish + resume by stored id (the client re-emits session_request on connect)
+                client.current.disconnect();
+                client.current.connect();
+            }
+        };
+        const sub = react_native_1.AppState.addEventListener("change", (s) => {
+            if (s === "active")
+                onForeground();
+        });
+        // Lazy-require netinfo (optional peer): on regained connectivity, reconnect.
+        let netUnsub;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const NetInfo = (_a = require("@react-native-community/netinfo").default) !== null && _a !== void 0 ? _a : require("@react-native-community/netinfo");
+            netUnsub = NetInfo.addEventListener((s) => {
+                if ((s === null || s === void 0 ? void 0 : s.isConnected) && shouldConnect() && client.current && !connectedRef.current) {
+                    client.current.connect();
+                }
+            });
+        }
+        catch {
+            /* netinfo absent — AppState reconnect still covers foreground churn */
+        }
+        return () => {
+            var _a;
+            // AppState.addEventListener's return shape has varied across RN versions
+            // (subscription object vs legacy void); guard the remove so unmount never throws.
+            try {
+                (_a = sub === null || sub === void 0 ? void 0 : sub.remove) === null || _a === void 0 ? void 0 : _a.call(sub);
+            }
+            catch { /* already removed / legacy API */ }
+            try {
+                netUnsub === null || netUnsub === void 0 ? void 0 : netUnsub();
+            }
+            catch { /* already removed */ }
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Persist the full session snapshot (history + read marker + greet set). base64 is
+    // stripped by stripBase64OnAck in the reducer, so messages here never carry data URLs
+    // once acked; the optimistic-pending base64 window is acceptable (overwritten on ack).
+    const persistSession = () => {
+        const snapshot = {
+            sessionId: sessionId.current,
+            messages: messagesRef.current,
+            lastActivity: lastActivity.current,
+            lastReadAt: lastReadRef.current,
+            greetSent: Array.from(greeted.current),
+        };
+        (0, persistence_1.saveSession)(store, snapshot, config.channelId);
+    };
+    // #4/#16: mark everything read up to now + refresh the activity anchor (open/foreground).
+    const markReadAndTouch = () => {
+        touchActivity();
+        dispatch({ type: "MARK_READ", at: now() });
+    };
+    // Bring the socket into line with the open/enable gates (open after a closed mount, etc.).
+    const reconcileConnection = () => {
+        if (!client.current)
+            return;
+        if (shouldConnect()) {
+            if (!connectedRef.current)
+                client.current.connect();
+        }
+    };
+    const emitMessage = (key, text, media, metadata, payload, extra) => {
+        var _a, _b;
+        return (_a = client.current) === null || _a === void 0 ? void 0 : _a.sendMessage({
+            // #5: `payload` is the backend message body; `text` is the display value.
+            message: payload !== null && payload !== void 0 ? payload : text,
+            ...(payload && text ? { text } : {}),
+            session_id: sessionId.current,
+            customData: { language: (_b = cfgRef.current.language) !== null && _b !== void 0 ? _b : "en" },
+            messageKey: key,
+            type: "EMIT_NEW_USER_MESSAGE", // #5: inject the message type
+            // WIRE FORMAT (web parity, DigitalGovernmentFooter handleSend): `media` is an
+            // array of base64 data-URL STRINGS — `media: filesBase64` where each entry is a
+            // `FileReader.readAsDataURL` string. Sending the MediaEntry OBJECTS
+            // ({data,name,mimeType,size}) makes the backend reject the send with
+            // "MsgToExp: invalid media string" (it reads each media[] entry as a string).
+            // `typeMedia` mirrors the web (the first file's mime type).
+            ...(media && media.length
+                ? { media: media.map((m) => m.data), typeMedia: media[0].mimeType }
+                : {}),
+            ...(metadata ? { metadata } : {}), // #5: forward host metadata untouched (S9)
+            ...(extra !== null && extra !== void 0 ? extra : {}), // greet's prechatFormSubmission (web parity)
+        });
+    };
+    // Send the welcome/prechat greet for a confirmed session (web ChatContainer:167-185).
+    // Carries the collected prechat fields as `prechatFormSubmission` + a Form-Response
+    // message body; the welcome flag gates the TEXT only — prechat data is always sent.
+    // Reads LIVE prechat values (prechatValuesRef), so a value submitted after mount is
+    // included. Idempotent per session via `greeted`.
+    const sendGreet = (id) => {
+        var _a;
+        if (!(0, greet_1.shouldGreet)({ sessionId: id, greetedSessions: greeted.current }))
+            return;
+        greeted.current.add(id);
+        persistSession(); // #17: persist greetSent BEFORE greeting so a crash mid-greet doesn't double-greet
+        const welcome = cfgRef.current.sendWelcomeMessage !== false;
+        const pv = (_a = prechatValuesRef.current) !== null && _a !== void 0 ? _a : {};
+        const hasPrechat = Object.keys(pv).length > 0;
+        if (welcome || hasPrechat) {
+            const g = (0, greet_1.buildGreet)(pv);
+            emitMessage(`g${now()}`, g.message, undefined, undefined, undefined, g.prechatFormSubmission ? { prechatFormSubmission: g.prechatFormSubmission } : undefined);
+        }
+    };
+    // B10: NEVER mark un-acked as sent. Mark 'sent' only when connected at emit time;
+    // otherwise keep 'pending' and flush on reconnect (above). No synchronous auto-ACK.
+    //
+    // #5: object form. A bare string is `{ text }`. `payload` is what the backend receives
+    // as the body (text is the display value); metadata is forwarded on the OutgoingPayload.
+    const send = (input) => {
+        var _a, _b, _c, _d;
+        const norm = typeof input === "string" ? { text: input } : input;
+        const display = (_b = (_a = norm.text) !== null && _a !== void 0 ? _a : norm.payload) !== null && _b !== void 0 ? _b : "";
+        const body = (_d = (_c = norm.payload) !== null && _c !== void 0 ? _c : norm.text) !== null && _d !== void 0 ? _d : "";
+        const metadata = norm.metadata;
+        touchActivity(); // a send is activity (#16)
+        const key = `u${now()}`;
+        dispatch({ type: "SEND", message: { key, sender: "user", text: display, timestamp: now() } }); // status: pending
+        if (connectedRef.current) {
+            emitMessage(key, display, undefined, metadata, body);
+            dispatch({ type: "ACK", key });
+        }
+        else {
+            // queue with the resolved backend body so the flush emits the right payload
+            pending.current.push({ key, text: body });
+        }
+    };
+    // P2: send picked/recorded media.
+    //
+    // Flow: validate → encode → optimistic SEND (status 'pending', carrying the base64 media[]
+    // so the bubble previews immediately) → emit `user_uttered` with media[] + messageKey (or
+    // queue while disconnected, B10). The message flips to 'sent' ONLY on the server UPDATE_MSG
+    // echo, which also patches `mediaUrl` and strips the heavy base64 (no base64 ever persists
+    // after ack). Any failure (size/count reject, encode fail, emit fail) sets 'failed' and
+    // emits a typed WebChatError (C5) via onError. Validation happens BEFORE encoding so an
+    // oversize/over-count selection is never base64-inflated.
+    const attach = async (assets, text) => {
+        var _a, _b, _c, _d, _e;
+        const key = `m${now()}`;
+        touchActivity(); // #16
+        // 1) validate BEFORE encoding (reject oversize/over-count/unsupported before any inflation).
+        const files = assets.map((a) => ({ name: a.name, mimeType: a.mimeType, size: a.size, uri: a.uri, base64: a.base64 }));
+        const { accepted, rejected } = (0, media_1.validateSelection)(files, mediaLimits);
+        if (rejected.length > 0) {
+            (_a = props.onError) === null || _a === void 0 ? void 0 : _a.call(props, new types_1.WebChatError("send", `attachment rejected: ${rejected[0].reason}`, false, rejected));
+        }
+        if (accepted.length === 0)
+            return; // nothing left to send; no bubble created
+        // keep only accepted assets (validateSelection preserves order)
+        const acceptedNames = new Set(accepted.map((f) => f.name));
+        const keptAssets = assets.filter((a) => acceptedNames.has(a.name));
+        // 2) encode -> media[] data URLs (queued -> encoding). Reader is injected; the eager
+        // asset.base64 short-circuits it (see toMediaEntry).
+        const reader = readBase64 !== null && readBase64 !== void 0 ? readBase64 : (async () => { throw new types_1.WebChatError("send", "no base64 reader injected", false); });
+        let media;
+        try {
+            media = await Promise.all(keptAssets.map((a) => (0, picker_1.toMediaEntry)(a, reader)));
+        }
+        catch (e) {
+            // create the bubble so the failure is visible, then mark it failed
+            dispatch({ type: "SEND", message: { key, sender: "user", files: keptAssets, timestamp: now() } });
+            dispatch({ type: "FAIL", key });
+            (_b = props.onError) === null || _b === void 0 ? void 0 : _b.call(props, e instanceof types_1.WebChatError ? e : new types_1.WebChatError("send", "media encode failed", false, e));
+            return;
+        }
+        // 3) optimistic bubble carrying the base64 data URLs for immediate preview (status 'pending').
+        dispatch({
+            type: "SEND",
+            message: {
+                key,
+                sender: "user",
+                // Web parity (handleSend): one message carries the optional caption + media.
+                ...(text && text.trim() ? { text: text.trim() } : {}),
+                media: media.map((m) => m.data),
+                files: keptAssets,
+                timestamp: now(),
+            },
+        });
+        // 4) emit (sending), or queue while disconnected (B10). Either way this key is marked as
+        // awaiting reconciliation so the server echo routes to UPDATE_MSG (NOT auto-ACK).
+        mediaKeys.current.add(key);
+        try {
+            if (connectedRef.current) {
+                emitMessage(key, (_c = text === null || text === void 0 ? void 0 : text.trim()) !== null && _c !== void 0 ? _c : "", media);
+            }
+            else {
+                pending.current.push({ key, text: (_d = text === null || text === void 0 ? void 0 : text.trim()) !== null && _d !== void 0 ? _d : "" });
+                queuedMedia.current.set(key, media); // re-attached on flush
+            }
+        }
+        catch (e) {
+            mediaKeys.current.delete(key);
+            dispatch({ type: "FAIL", key });
+            (_e = props.onError) === null || _e === void 0 ? void 0 : _e.call(props, e instanceof types_1.WebChatError ? e : new types_1.WebChatError("send", "media send failed", true, e));
+        }
+    };
+    // Section 4 — apply a like/dislike reaction to a received message (web parity,
+    // mirror of redux/messages/actions.ts reactToMessage). Reads the message's CURRENT
+    // userReaction (from the always-current mirror so a stale render closure can't read a
+    // wrong value), computes the toggle-clear next state + the backend verb, dispatches
+    // REACT optimistically, and emits the "activity" event. A reaction is user activity (#16).
+    const react = (messageKey, reaction) => {
+        var _a, _b, _c;
+        touchActivity();
+        const current = (_b = (_a = messagesRef.current.find((m) => m.messageKey === messageKey)) === null || _a === void 0 ? void 0 : _a.userReaction) !== null && _b !== void 0 ? _b : null;
+        // toggle-clear: tapping the ACTIVE reaction clears it; otherwise switch to it.
+        const next = current === reaction ? null : reaction;
+        // backend verb: like when not-liked -> "like", already-liked -> "unlike";
+        // dislike when not-disliked -> "dislike", already-disliked -> "undislike".
+        const type = reaction === "like"
+            ? current === "like" ? "unlike" : "like"
+            : current === "dislike" ? "undislike" : "dislike";
+        dispatch({ type: "REACT", messageKey, reaction: next }); // optimistic
+        (_c = client.current) === null || _c === void 0 ? void 0 : _c.emitActivity({ messageKey, type });
+    };
+    // B19: real erasure — purge persisted storage + reset state; resetSession also restarts the session.
+    // clearHistory drops messages only and keeps the live session (web parity: clearing messages does
+    // NOT clear sessionId, so a dismissed prechat stays dismissed). resetSession zeroes the session and
+    // reconnects for a brand-new one, then fires onSessionReset so the host can reset session-scoped UI
+    // (prechat form re-appears, mirroring web's `!sessionId` gate — without it, a one-time prechatDone
+    // latch would keep the form hidden for the new session).
+    const clearHistory = () => { dispatch({ type: "CLEAR" }); (0, persistence_1.clearSession)(store, config.channelId); };
+    const resetSession = () => {
+        var _a, _b, _c;
+        clearHistory();
+        sessionId.current = "";
+        greeted.current.clear();
+        // A reset forces a brand-new session: re-arm the prechat/greet flow so the form
+        // shows again and the greet waits for a fresh submit (web `!sessionId` semantics).
+        resumedSessionRef.current = false;
+        setResumedSession(false);
+        prechatSubmittedRef.current = false;
+        pendingGreetIdRef.current = null;
+        (_a = client.current) === null || _a === void 0 ? void 0 : _a.disconnect();
+        (_b = client.current) === null || _b === void 0 ? void 0 : _b.connect();
+        (_c = props.onSessionReset) === null || _c === void 0 ? void 0 : _c.call(props);
+    };
+    // --- Phase 3: video calls (Group E) ----------------------------------------
+    //
+    // startCall builds a VideoCallClient over the SAME chat socket the WebchatClient
+    // already owns (socketRef, captured above) — no second connection. The call is
+    // scoped by the live chat session (`session_id` on join, C8/web parity). The
+    // WebRTC factory + audio route are lazily resolved here (defaults = real native
+    // adapters) so non-video flows never load native bindings; tests inject fakes.
+    //
+    // Resilience seam: the client's "ended" event (inbound peer-left / hangup, B16/C9,
+    // or its own leave) flips videoCallStarted back to false so the Surface returns to
+    // the thread without a silent dangling call.
+    const startCall = () => {
+        if (videoClient.current)
+            return; // already in a call
+        const socket = socketRef.current;
+        if (!socket)
+            return; // socket not wired yet (pre-connect)
+        // Lazily resolve the native seams ONLY when a call is actually placed.
+        const factory = webrtcFactory !== null && webrtcFactory !== void 0 ? webrtcFactory : require("../adapters/webrtc").reactNativeWebRTCFactory();
+        const route = audioRoute !== null && audioRoute !== void 0 ? audioRoute : require("../adapters/audioRoute").reactNativeAudioRoute();
+        audioRouteRef.current = route;
+        const vc = createVideoClient({
+            socket: socket,
+            webrtcFactory: factory,
+            getSessionId: () => sessionId.current,
+        });
+        videoClient.current = vc;
+        // Inbound hangup / teardown -> clear the active-call flag + release the audio session.
+        vc.on("ended", () => {
+            var _a;
+            videoClient.current = null;
+            try {
+                (_a = audioRouteRef.current) === null || _a === void 0 ? void 0 : _a.stop();
+            }
+            catch { /* never started */ }
+            audioRouteRef.current = null;
+            setVideoCallStarted(false);
+        });
+        vc.on("error", () => {
+            var _a;
+            // a start/getUserMedia failure releases the route; the Surface drops back to the thread.
+            try {
+                (_a = audioRouteRef.current) === null || _a === void 0 ? void 0 : _a.stop();
+            }
+            catch { /* never started */ }
+        });
+        try {
+            route.start({ media: "video" });
+        }
+        catch { /* audio route optional */ }
+        void vc.start();
+        setVideoCallStarted(true);
+    };
+    // Route the live call's audio output (audit #25). Delegates to the provider's REAL
+    // AudioRoute (audioRouteRef, started in startCall) so the in-call speaker toggle
+    // reaches the actual audio session rather than a no-op stub. A no-op (best-effort)
+    // when no call is active / the route lacks setSpeaker.
+    const setSpeaker = (on) => {
+        var _a, _b;
+        try {
+            (_b = (_a = audioRouteRef.current) === null || _a === void 0 ? void 0 : _a.setSpeaker) === null || _b === void 0 ? void 0 : _b.call(_a, on);
+        }
+        catch { /* route unavailable */ }
+    };
+    // Tear the active call down. Idempotent: safe on a double-call / unmount.
+    const endCall = () => {
+        var _a;
+        const vc = videoClient.current;
+        videoClient.current = null;
+        try {
+            vc === null || vc === void 0 ? void 0 : vc.leave();
+        }
+        catch { /* already torn down */ }
+        try {
+            (_a = audioRouteRef.current) === null || _a === void 0 ? void 0 : _a.stop();
+        }
+        catch { /* already stopped */ }
+        audioRouteRef.current = null;
+        setVideoCallStarted(false);
+    };
+    // Item 23 — "awaiting a bot reply": the last message in the thread is a user
+    // message (no `response` message has landed since). Derived from the live message
+    // list (no extra reducer state needed); a subsequent bot RECEIVE flips it false.
+    const lastMsg = state.messages[state.messages.length - 1];
+    const awaitingReply = (lastMsg === null || lastMsg === void 0 ? void 0 : lastMsg.sender) === "user";
+    const value = {
+        messages: state.messages, status, isStorageReady, unread,
+        awaitingReply,
+        wasConnected,
+        resumedSession,
+        audioAdapter, // audit #23: received-voice playback seam (may be undefined)
+        setSpeaker, // audit #25: in-call speaker route -> provider AudioRoute
+        resolvedConfig: resolved.config,
+        theme: resolved.theme,
+        dir: resolved.dir,
+        language: resolved.language,
+        send, attach, clearHistory, resetSession, react,
+        videoCallStarted, startCall, endCall,
+        _video: {
+            socket: socketRef.current,
+            getSessionId: () => sessionId.current,
+            client: videoClient.current,
+        },
+    };
+    return (0, jsx_runtime_1.jsx)(exports.WebchatContext.Provider, { value: value, children: children });
+}