@experiaapp/webchat-react-native 2.0.1

package/lib/adapters/webrtc.d.ts

@@ -0,0 +1,131 @@
+/**
+ * A single ICE server entry, web-parity shape (see `core/ice.ts`). Mirrors the
+ * `RTCIceServer` dictionary: one or more URLs plus optional TURN credentials.
+ */
+export interface IceServer {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+/** The `pc_config` passed to `createPeerConnection`, web parity. */
+export interface PeerConnectionConfig {
+    iceServers: IceServer[];
+}
+/**
+ * Media constraints handed to `getUserMedia`. Loosely typed (the native module
+ * accepts a superset of the DOM `MediaStreamConstraints`); the signaling core
+ * only ever passes `{ video, audio }`.
+ */
+export interface MediaStreamConstraints {
+    audio?: boolean | Record<string, unknown>;
+    video?: boolean | Record<string, unknown>;
+}
+/**
+ * The subset of a media track the core touches: kind (`"audio" | "video"`),
+ * an `enabled` flag (mute/camera toggle), and `stop()` (camera release on
+ * teardown, C10).
+ *
+ * `_switchCamera()` is a `react-native-webrtc` extension present on local VIDEO
+ * tracks: the native layer flips front<->back and resolves to the correct
+ * DEFAULT camera on multi-camera phones (wide/ultrawide/tele exposed as separate
+ * devices). It is optional so web/fakes that lack it satisfy the type.
+ */
+export interface MediaStreamTrackLike {
+    kind: string;
+    enabled: boolean;
+    stop(): void;
+    /** react-native-webrtc local-video extension: flip front/back reliably. */
+    _switchCamera?(): void;
+}
+/**
+ * The subset of a media stream the core touches. `toURL()` feeds `RTCView`
+ * (Task 3); `getTracks()` + `release()` drive teardown / camera release (C10).
+ * `getVideoTracks()` / `getAudioTracks()` are used by the camera-switch fallback
+ * and the replaceTrack path; optional so minimal fakes still satisfy the type.
+ */
+export interface MediaStreamLike {
+    getTracks(): MediaStreamTrackLike[];
+    getVideoTracks?(): MediaStreamTrackLike[];
+    getAudioTracks?(): MediaStreamTrackLike[];
+    toURL?(): string;
+    release?(): void;
+}
+/**
+ * A device descriptor returned by `mediaDevices.enumerateDevices()`. `facing`
+ * is the react-native-webrtc extension that tags a camera `"environment"`
+ * (back) or `"user"` (front); the camera-switch fallback prefers the FIRST
+ * `"environment"` device (the primary back camera) over ultrawide/tele.
+ */
+export interface MediaDeviceInfoLike {
+    deviceId: string;
+    kind: string;
+    facing?: string;
+    label?: string;
+}
+/**
+ * The subset of `RTCPeerConnection` the signaling state machine drives. Kept
+ * minimal and structural so a fake (plain object literal) satisfies it in tests.
+ *
+ * Teardown contract (C10/C11): callers MUST `getSenders()` → `track.stop()` on
+ * every local track, `stream.release()` each captured stream, then `close()` the
+ * connection so the camera/mic are fully released (verified by restart×5).
+ */
+export interface RTCPeerConnectionLike {
+    addTrack(track: MediaStreamTrackLike, stream: MediaStreamLike): unknown;
+    getSenders(): Array<{
+        track: MediaStreamTrackLike | null;
+        replaceTrack?(track: MediaStreamTrackLike | null): Promise<void>;
+    }>;
+    getTransceivers(): Array<{
+        sender: {
+            track: MediaStreamTrackLike | null;
+            replaceTrack?(track: MediaStreamTrackLike | null): Promise<void>;
+        };
+    }>;
+    createAnswer(options?: unknown): Promise<unknown>;
+    setLocalDescription(desc: unknown): Promise<void>;
+    setRemoteDescription(desc: unknown): Promise<void>;
+    addIceCandidate(candidate: unknown): Promise<void>;
+    restartIce?(): void;
+    close(): void;
+    signalingState?: string;
+    remoteDescription?: unknown;
+    onicecandidate?: ((event: unknown) => void) | null;
+    ontrack?: ((event: unknown) => void) | null;
+    onconnectionstatechange?: ((event: unknown) => void) | null;
+    onnegotiationneeded?: ((event: unknown) => void) | null;
+    connectionState?: string;
+}
+/**
+ * The injectable WebRTC surface. `createPeerConnection` builds a peer connection
+ * from a web-parity {@link PeerConnectionConfig}; `getUserMedia` captures the
+ * local camera/mic. Real impls wrap `react-native-webrtc`; tests inject a fake.
+ */
+export interface WebRTCFactory {
+    createPeerConnection(config: PeerConnectionConfig): RTCPeerConnectionLike;
+    getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStreamLike>;
+    /**
+     * Lists the available media input/output devices (camera-switch fallback,
+     * when a track lacks `_switchCamera`). Optional so a minimal fake factory
+     * that never exercises the fallback still satisfies the type.
+     */
+    enumerateDevices?(): Promise<MediaDeviceInfoLike[]>;
+}
+/**
+ * Real factory backed by `react-native-webrtc`. The native module is required
+ * lazily inside the methods so simply importing this file (e.g. for the
+ * {@link WebRTCFactory} type) does not pull in native bindings — chat-only
+ * consumers and the unit-test core never load it (C15/C16).
+ *
+ * `RTCIceCandidate` / `RTCSessionDescription` are re-exported through the loader
+ * so the signaling core can wrap inbound SDP/candidates with the same native
+ * classes the web UI uses (`new RTCSessionDescription(sdp)` etc.).
+ */
+export declare function reactNativeWebRTCFactory(): WebRTCFactory;
+/**
+ * Fully release the camera/mic for a call (C10). Stops every local track, calls
+ * `release()` on each captured stream if available, then `close()`s the peer
+ * connection. Null-safe so it can run from an error path or double-leave without
+ * throwing. Pure orchestration over the injected handles — no native import.
+ */
+export declare function teardownPeerConnection(pc: RTCPeerConnectionLike | null | undefined, localStreams?: Array<MediaStreamLike | null | undefined>): void;

package/lib/adapters/webrtc.js

@@ -0,0 +1,70 @@
+"use strict";
+// src/adapters/webrtc.ts
+//
+// WebRTC capability behind an injectable factory so the framework-agnostic
+// signaling core (VideoCallClient) never imports a native module directly. The
+// real impl ({@link reactNativeWebRTCFactory}) is constructed in the example
+// apps and injected; unit tests inject a FAKE factory so the state machine can
+// be exercised with no native calls (Plan Task 3).
+//
+// RTCView rendering note (Task 3): the UI renders local/remote tiles with
+// `<RTCView streamURL={stream.toURL()} />` from `react-native-webrtc`. That is a
+// view component (not a factory capability) so it is imported directly in the UI
+// layer; this adapter only owns peer-connection + getUserMedia creation and the
+// teardown contract documented on {@link RTCPeerConnectionLike}.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactNativeWebRTCFactory = reactNativeWebRTCFactory;
+exports.teardownPeerConnection = teardownPeerConnection;
+/**
+ * Real factory backed by `react-native-webrtc`. The native module is required
+ * lazily inside the methods so simply importing this file (e.g. for the
+ * {@link WebRTCFactory} type) does not pull in native bindings — chat-only
+ * consumers and the unit-test core never load it (C15/C16).
+ *
+ * `RTCIceCandidate` / `RTCSessionDescription` are re-exported through the loader
+ * so the signaling core can wrap inbound SDP/candidates with the same native
+ * classes the web UI uses (`new RTCSessionDescription(sdp)` etc.).
+ */
+function reactNativeWebRTCFactory() {
+    // Lazy require keeps native bindings out of the import graph until a real
+    // call is placed; typed as the module's shape via a structural cast.
+    const load = () => 
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    require("react-native-webrtc");
+    return {
+        createPeerConnection(config) {
+            const { RTCPeerConnection } = load();
+            return new RTCPeerConnection(config);
+        },
+        getUserMedia(constraints) {
+            const { mediaDevices } = load();
+            return mediaDevices.getUserMedia(constraints);
+        },
+        enumerateDevices() {
+            const { mediaDevices } = load();
+            return mediaDevices.enumerateDevices();
+        },
+    };
+}
+/**
+ * Fully release the camera/mic for a call (C10). Stops every local track, calls
+ * `release()` on each captured stream if available, then `close()`s the peer
+ * connection. Null-safe so it can run from an error path or double-leave without
+ * throwing. Pure orchestration over the injected handles — no native import.
+ */
+function teardownPeerConnection(pc, localStreams = []) {
+    var _a;
+    for (const stream of localStreams) {
+        if (!stream)
+            continue;
+        stream.getTracks().forEach((track) => track.stop());
+        (_a = stream.release) === null || _a === void 0 ? void 0 : _a.call(stream);
+    }
+    if (pc) {
+        pc.onicecandidate = null;
+        pc.ontrack = null;
+        pc.onconnectionstatechange = null;
+        pc.onnegotiationneeded = null;
+        pc.close();
+    }
+}

package/lib/core/VideoCallClient.d.ts

@@ -0,0 +1,106 @@
+import { type PcConfig } from "./ice";
+/** Minimal socket surface (same shape as core `MinimalSocket`). */
+export interface MinimalSocket {
+    on(event: string, cb: Function): void;
+    off(event: string, cb?: Function): void;
+    emit(event: string, data?: unknown): void;
+}
+/** A media track (subset of MediaStreamTrack we touch). */
+export interface FakeableTrack {
+    kind: string;
+    enabled: boolean;
+    stop(): void;
+    /**
+     * react-native-webrtc local-video extension: flips front<->back and resolves
+     * to the correct DEFAULT camera on multi-camera phones. Optional/structural
+     * so web tracks and fakes that lack it still satisfy the type.
+     */
+    _switchCamera?(): void;
+}
+/** A media stream (subset of MediaStream we touch). */
+export interface FakeableStream {
+    getTracks(): FakeableTrack[];
+    getAudioTracks?(): FakeableTrack[];
+    getVideoTracks?(): FakeableTrack[];
+    /** native MediaStream exposes toURL() (for RTCView) + release(); optional for fakes. */
+    toURL?(): string;
+    release?(): void;
+}
+/** An RTP sender (subset we touch): its current track + replaceTrack. */
+export interface FakeableSender {
+    track: FakeableTrack | null;
+    replaceTrack?(track: FakeableTrack | null): Promise<void>;
+}
+/** A media-device descriptor from `enumerateDevices` (camera-switch fallback). */
+export interface FakeableDeviceInfo {
+    deviceId: string;
+    kind: string;
+    /** react-native-webrtc tag: "environment" (back) / "user" (front). */
+    facing?: string;
+    label?: string;
+}
+/** A peer connection (subset we touch), with assignable `on*` handlers. */
+export interface FakeablePeerConnection {
+    signalingState?: string;
+    connectionState?: string;
+    remoteDescription?: unknown;
+    setRemoteDescription(desc: unknown): Promise<void>;
+    setLocalDescription(desc?: unknown): Promise<void>;
+    createAnswer(options?: unknown): Promise<unknown>;
+    addIceCandidate(candidate: unknown): Promise<void>;
+    addTrack(track: FakeableTrack, stream: FakeableStream): unknown;
+    getTransceivers(): Array<{
+        sender: FakeableSender;
+    }>;
+    getSenders(): FakeableSender[];
+    restartIce?(): void;
+    close(): void;
+    onicecandidate?: ((e: {
+        candidate: {
+            type?: string;
+        } | null;
+    }) => void) | null;
+    ontrack?: ((e: {
+        track: FakeableTrack;
+        streams: FakeableStream[];
+    }) => void) | null;
+    onconnectionstatechange?: ((e?: unknown) => void) | null;
+    onnegotiationneeded?: ((e?: unknown) => void) | null;
+}
+/** Injected WebRTC factory — the only native seam. */
+export interface WebRTCFactory {
+    createPeerConnection(config: PcConfig): FakeablePeerConnection;
+    getUserMedia(constraints: unknown): Promise<FakeableStream>;
+    /** Camera-switch fallback: list devices when a track lacks `_switchCamera`. */
+    enumerateDevices?(): Promise<FakeableDeviceInfo[]>;
+}
+export interface VideoCallClientOptions {
+    socket: MinimalSocket;
+    webrtcFactory: WebRTCFactory;
+    /**
+     * The existing chat session id. Retained on the options (public API; the
+     * provider still passes it) but NOT sent on the video-call `join`/`leave_room`
+     * anymore — web parity: the web widget emits a bare `join` and a `leave_room`
+     * with a room literal (see `start()`/`leave()` below).
+     */
+    getSessionId: () => string;
+    /** Override the pc_config; defaults to web-parity `iceServers()`. */
+    pcConfig?: PcConfig;
+    /** Override getUserMedia constraints; defaults to web parity. */
+    mediaConstraints?: unknown;
+}
+export type VideoCallEvent = "localStream" | "remoteStream" | "ended" | "error";
+type Listener = (data?: any) => void;
+export declare function createVideoCallClient(opts: VideoCallClientOptions): {
+    on(event: VideoCallEvent, cb: Listener): void;
+    start: () => Promise<void>;
+    leave: () => void;
+    toggleMute: () => boolean;
+    toggleVideo: () => boolean;
+    switchCamera: () => Promise<void>;
+    /** test/inspection seam */
+    isStarted: () => boolean;
+    getPeerConnection: () => FakeablePeerConnection | null;
+};
+export type VideoCallClient = ReturnType<typeof createVideoCallClient>;
+export {};

package/lib/core/VideoCallClient.js

@@ -0,0 +1,302 @@
+"use strict";
+// src/core/VideoCallClient.ts
+// Answerer-only signaling state machine for 1:1 video calls.
+//
+// Ports the web widget `VideoCall.tsx` handlers 1:1 over the EXISTING chat socket
+// (no second connection). WebRTC lives behind an injected factory so this state
+// machine is fully unit-testable with a FakeSocket + a fake factory (no native
+// modules). Media/audio is validated on real devices, not here.
+//
+// Call scoping (C8 — web parity): the call is scoped by the existing chat session,
+// so `session_id` is sent on `join` and `leave_room` exactly as the web widget does.
+//
+// B15: remote AUDIO tracks are NOT dropped (the web `ontrack` skipped audio for its
+// DOM-element rendering hack; RN keeps audio so the agent is audible).
+// B16/C9: an inbound peer-left / call-ended signal triggers full teardown.
+// C6: ICE-restart on `connectionState === "failed"` mirrors web (restartIce()); the
+// server re-offer contract for restart is documented in the plan, handled here via
+// the normal `offer`/`negotiation` -> createAnswer path.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVideoCallClient = createVideoCallClient;
+const ice_1 = require("./ice");
+/** Default constraints mirror the web widget (`initVideoCall`). */
+const DEFAULT_CONSTRAINTS = {
+    video: true,
+    audio: { echoCancellation: true, noiseSuppression: true },
+};
+/**
+ * Inbound signals from the agent/server that mean "the other side is gone" and the
+ * call must be torn down (B16/C9). The web widget had no explicit handler, so we
+ * accept the common server names; any of them triggers a full teardown.
+ */
+const END_SIGNALS = ["leave_room", "peer_left", "call_ended", "room_closed"];
+function createVideoCallClient(opts) {
+    var _a, _b;
+    // `getSessionId` is intentionally NOT destructured: web parity dropped it from
+    // both the `join` and `leave_room` payloads (see `start()`/`leave()`). It stays
+    // on VideoCallClientOptions for API stability and possible future use.
+    const { socket, webrtcFactory } = opts;
+    const pcConfig = (_a = opts.pcConfig) !== null && _a !== void 0 ? _a : (0, ice_1.iceServers)();
+    const constraints = (_b = opts.mediaConstraints) !== null && _b !== void 0 ? _b : DEFAULT_CONSTRAINTS;
+    const listeners = {};
+    const emit = (event, data) => { var _a; return ((_a = listeners[event]) !== null && _a !== void 0 ? _a : []).forEach((l) => l(data)); };
+    let pc = null;
+    let localStream = null;
+    let started = false;
+    let torndown = false;
+    // Bound socket handlers, kept so leave()/teardown can `off` them precisely.
+    const bound = [];
+    function bind(event, cb) {
+        socket.on(event, cb);
+        bound.push({ event, cb });
+    }
+    /** Forward a local ICE candidate iff it passes the web-parity filter. */
+    function wireIceCandidate(connection) {
+        connection.onicecandidate = (e) => {
+            if (e.candidate && (0, ice_1.isForwardableCandidate)(e.candidate.type)) {
+                socket.emit("candidate", JSON.stringify(e.candidate));
+            }
+        };
+    }
+    // Ported 1:1 from web `createAnswer` (incl. glare/rollback handling).
+    async function createAnswer(sdp) {
+        if (!pc)
+            return;
+        try {
+            if (pc.signalingState !== "stable") {
+                // glare: roll our local back and accept theirs (no answer this round)
+                await Promise.all([
+                    pc.setLocalDescription({ type: "rollback" }),
+                    pc.setRemoteDescription(sdp),
+                ]);
+                return;
+            }
+            await pc.setRemoteDescription(sdp);
+            const mySdp = await pc.createAnswer({
+                offerToReceiveVideo: true,
+                offerToReceiveAudio: true,
+            });
+            await pc.setLocalDescription(mySdp);
+            socket.emit("answer", JSON.stringify(mySdp));
+            wireIceCandidate(pc);
+        }
+        catch (e) {
+            emit("error", e);
+        }
+    }
+    function wireSocketHandlers() {
+        bind("offer", (offer) => {
+            const parsed = JSON.parse(offer);
+            createAnswer(parsed);
+            if (pc) {
+                pc.onnegotiationneeded = () => {
+                    if (!pc || pc.signalingState !== "stable")
+                        return;
+                    try {
+                        socket.emit("negotiation", "");
+                    }
+                    catch (e) {
+                        emit("error", e);
+                    }
+                };
+            }
+        });
+        bind("negotiation", (offer) => {
+            const parsed = JSON.parse(offer);
+            createAnswer(parsed);
+        });
+        bind("candidate", async (candidate) => {
+            if (!pc)
+                return;
+            if (candidate === null)
+                return;
+            if (pc.remoteDescription == null)
+                return;
+            try {
+                await pc.addIceCandidate(JSON.parse(candidate));
+            }
+            catch (e) {
+                emit("error", e);
+            }
+        });
+        bind("answer", async (answer) => {
+            if (!pc)
+                return;
+            const parsed = JSON.parse(answer);
+            try {
+                await pc.setRemoteDescription(parsed);
+            }
+            catch (e) {
+                emit("error", e);
+            }
+        });
+        // B16/C9: inbound end-signal -> full teardown + emit "ended".
+        END_SIGNALS.forEach((sig) => bind(sig, () => {
+            teardown();
+            emit("ended");
+        }));
+    }
+    // Ported from web `initVideoCall`: getUserMedia -> addTrack -> wire handlers -> join.
+    async function start() {
+        if (started)
+            return;
+        started = true;
+        torndown = false;
+        try {
+            pc = webrtcFactory.createPeerConnection(pcConfig);
+            wireSocketHandlers();
+            const stream = await webrtcFactory.getUserMedia(constraints);
+            localStream = stream;
+            emit("localStream", stream);
+            stream.getTracks().forEach((track) => {
+                pc === null || pc === void 0 ? void 0 : pc.addTrack(track, stream);
+            });
+            // C6: failed connection attempts ICE recovery instead of terminating.
+            pc.onconnectionstatechange = () => {
+                var _a;
+                if (pc && pc.connectionState === "failed") {
+                    (_a = pc.restartIce) === null || _a === void 0 ? void 0 : _a.call(pc);
+                }
+            };
+            wireIceCandidate(pc);
+            // B15: keep remote audio tracks. The web widget dropped audio because it
+            // rendered each track into its own DOM <video>; RN surfaces the whole
+            // remote stream (audio + video) so the agent is audible.
+            pc.ontrack = (event) => {
+                var _a;
+                const remote = (_a = event.streams) === null || _a === void 0 ? void 0 : _a[0];
+                if (remote)
+                    emit("remoteStream", remote);
+            };
+            // WEB PARITY: the web widget emits `join` with NO payload (new-webchat
+            // VideoCall.tsx — `socketConnection.emit("join")`). It is purely the
+            // "ready, send me the offer" trigger; the server already knows the session
+            // from the shared chat socket. Do not add a payload here.
+            socket.emit("join");
+        }
+        catch (e) {
+            started = false;
+            emit("error", e);
+        }
+    }
+    /** Toggle local mic tracks (mute/unmute). Returns the new muted state. */
+    function toggleMute() {
+        let nowEnabled = true;
+        pc === null || pc === void 0 ? void 0 : pc.getSenders().forEach((s) => {
+            if (s.track && s.track.kind === "audio") {
+                s.track.enabled = !s.track.enabled;
+                nowEnabled = s.track.enabled;
+            }
+        });
+        return !nowEnabled;
+    }
+    /** Toggle local camera tracks. Returns the new "video off" state. */
+    function toggleVideo() {
+        let nowEnabled = true;
+        pc === null || pc === void 0 ? void 0 : pc.getSenders().forEach((s) => {
+            if (s.track && s.track.kind === "video") {
+                s.track.enabled = !s.track.enabled;
+                nowEnabled = s.track.enabled;
+            }
+        });
+        return !nowEnabled;
+    }
+    /**
+     * Flip the local camera front<->back RELIABLY.
+     *
+     * On RN the web approach (replace by an arbitrary `deviceId`) picks the WRONG
+     * back camera when a phone exposes wide/ultrawide/tele as separate devices.
+     *
+     * PRIMARY: react-native-webrtc local-video tracks expose `_switchCamera()`,
+     * which the native layer resolves to the correct DEFAULT camera (handling
+     * multi-camera devices). We prefer it whenever present.
+     *
+     * FALLBACK (no `_switchCamera`, e.g. fakes/web): enumerate the devices, pick
+     * the PRIMARY back camera (the FIRST `facing === "environment"` device — not
+     * ultrawide/tele), `getUserMedia` that camera, and `replaceTrack` on the video
+     * sender. Never blindly pick an arbitrary deviceId.
+     */
+    async function switchCamera() {
+        var _a, _b, _c, _d, _e;
+        if (!pc)
+            return;
+        const videoTrack = (_b = (_a = localStream === null || localStream === void 0 ? void 0 : localStream.getVideoTracks) === null || _a === void 0 ? void 0 : _a.call(localStream)[0]) !== null && _b !== void 0 ? _b : null;
+        // PRIMARY: native flip resolves the correct default camera itself.
+        if (videoTrack && typeof videoTrack._switchCamera === "function") {
+            videoTrack._switchCamera();
+            return;
+        }
+        // FALLBACK: pick the primary back camera explicitly, then replaceTrack.
+        if (typeof webrtcFactory.enumerateDevices !== "function")
+            return;
+        try {
+            const devices = await webrtcFactory.enumerateDevices();
+            const cameras = devices.filter((d) => d.kind === "videoinput");
+            // First environment-facing camera = the primary back lens (not wide/tele).
+            const backCamera = cameras.find((d) => d.facing === "environment");
+            const video = backCamera
+                ? { facingMode: "environment", deviceId: backCamera.deviceId }
+                : { facingMode: "environment" };
+            const stream = await webrtcFactory.getUserMedia({ video, audio: false });
+            const newVideoTrack = (_d = (_c = stream.getVideoTracks) === null || _c === void 0 ? void 0 : _c.call(stream)[0]) !== null && _d !== void 0 ? _d : null;
+            if (!newVideoTrack)
+                return;
+            const videoSender = pc
+                .getSenders()
+                .find((s) => s.track && s.track.kind === "video");
+            await ((_e = videoSender === null || videoSender === void 0 ? void 0 : videoSender.replaceTrack) === null || _e === void 0 ? void 0 : _e.call(videoSender, newVideoTrack));
+            // Stop the old local video track and swap it into the local stream so the
+            // local preview + subsequent teardown release the new camera, not the old.
+            if (videoTrack)
+                videoTrack.stop();
+            localStream = stream;
+            emit("localStream", stream);
+        }
+        catch (e) {
+            emit("error", e);
+        }
+    }
+    // Full teardown (C10): off socket handlers, stop+release local media, close pc.
+    // Idempotent so an inbound end-signal and a user leave() can't double-free.
+    function teardown() {
+        var _a;
+        if (torndown)
+            return;
+        torndown = true;
+        started = false;
+        bound.forEach(({ event, cb }) => socket.off(event, cb));
+        bound.length = 0;
+        localStream === null || localStream === void 0 ? void 0 : localStream.getTracks().forEach((track) => track.stop());
+        (_a = localStream === null || localStream === void 0 ? void 0 : localStream.release) === null || _a === void 0 ? void 0 : _a.call(localStream);
+        localStream = null;
+        if (pc) {
+            pc.close();
+            pc = null;
+        }
+    }
+    // User-initiated hangup: emit leave_room then teardown.
+    // WEB PARITY: the web widget emits `leave_room` with a HARD-CODED literal
+    // `{ room: "1234f" }` (new-webchat VideoCall.tsx handleLeaveRoom). We mirror it
+    // exactly so the SDK hangup matches the production-proven web client. NOTE: if
+    // the signaling server expects a real room/session key here, change the value
+    // to `getSessionId()` — the field name `room` is what the server reads.
+    function leave() {
+        socket.emit("leave_room", { room: "1234f" });
+        teardown();
+        emit("ended");
+    }
+    return {
+        on(event, cb) {
+            var _a;
+            ((_a = listeners[event]) !== null && _a !== void 0 ? _a : (listeners[event] = [])).push(cb);
+        },
+        start,
+        leave,
+        toggleMute,
+        toggleVideo,
+        switchCamera,
+        /** test/inspection seam */
+        isStarted: () => started,
+        getPeerConnection: () => pc,
+    };
+}

package/lib/core/WebchatClient.d.ts

@@ -0,0 +1,34 @@
+type Listener = (data: any) => void;
+export interface MinimalSocket {
+    on(event: string, cb: Function): void;
+    off(event: string, cb?: Function): void;
+    emit(event: string, data?: unknown): void;
+    connect?(): void;
+    disconnect(): void;
+    connected?: boolean;
+}
+export interface WebchatClientOptions {
+    socketFactory: () => MinimalSocket;
+    sessionTimeoutMs?: number;
+    /** B8 resume seam — host/persistence layer provides the stored session id. */
+    getStoredSessionId?: () => string;
+    /** B7: how many session_request retries before giving up (default 3). */
+    maxSessionRetries?: number;
+}
+export declare function createWebchatClient(opts: WebchatClientOptions): {
+    on(event: string, cb: Listener): void;
+    connect(): void;
+    sendMessage(payload: import("./types").OutgoingPayload): void;
+    /**
+     * Emit a feedback activity (web parity): `socket.emit("activity", { messageKey, type })`.
+     * `type` is the backend verb the provider computes from the toggle —
+     * "like" | "unlike" | "dislike" | "undislike". The matching inbound reflection
+     * arrives on "activityAck" (re-emitted as the client's "activityAck" event).
+     */
+    emitActivity(payload: {
+        messageKey: string;
+        type: string;
+    }): void;
+    disconnect(): void;
+};
+export {};