@voltkit-rtc/client 0.2.0

package/src/broadcast.ts

@@ -0,0 +1,352 @@
+/**
+ * Publishing a broadcast stream.
+ *
+ * A broadcast is one publisher and an audience of any size, delivered over
+ * LL-HLS and WebRTC. Publishing is WHIP: one HTTP exchange of SDP, then media
+ * straight to the media server. Viewers need nothing from this package -- they
+ * play the stream's LL-HLS URL in any HLS player.
+ */
+
+import { AudioMixer, type MusicInput, type MusicOptions } from './music.js';
+
+/** The media server refused, or could not be reached. */
+export class WhipError extends Error {
+  /**
+   * @param status HTTP status, or 0 when the request never got an answer.
+   */
+  constructor(readonly status: number, message: string) {
+    super(message);
+    this.name = 'WhipError';
+  }
+
+  /**
+   * The publish URL was not accepted: its token is missing, expired, for a
+   * different stream, or the account behind it cannot go on air. The same URL
+   * will be refused again -- get a new one from your backend.
+   */
+  get isRefused(): boolean {
+    return this.status === 401 || this.status === 403;
+  }
+}
+
+export type BroadcastState =
+  | 'idle'
+  | 'connecting'
+  /** Media is flowing to the media server. */
+  | 'live'
+  /** The connection dropped. WebRTC may recover it; if it reaches `failed`, start again. */
+  | 'interrupted'
+  | 'failed'
+  | 'stopped';
+
+export interface BroadcastEvents {
+  state: (state: BroadcastState) => void;
+  /**
+   * Publishing worked, but something that affects cost or quality did not
+   * apply -- most importantly, H.264 was not available in this browser.
+   */
+  warning: (message: string) => void;
+}
+
+export interface BroadcastStartOptions {
+  /** Media you already hold. It stays yours: `stop()` will not end its tracks. */
+  stream?: MediaStream;
+  /** Used to acquire camera and microphone when `stream` is not given. */
+  constraints?: MediaStreamConstraints;
+  /** Music playing inside the page, to go on air from the first second. See `setMusic`. */
+  music?: MusicInput;
+  musicOptions?: MusicOptions;
+}
+
+type Handler = (...args: never[]) => void;
+
+const WHIP_TIMEOUT_MS = 15_000;
+/** A browser that never reports "complete" still publishes with what it has. */
+const ICE_GATHER_TIMEOUT_MS = 3_000;
+/** Helper formats that ride along with a codec. Not codecs in their own right. */
+const HELPER_FORMATS = new Set(['video/rtx', 'video/red', 'video/ulpfec', 'video/flexfec-03']);
+
+/**
+ * Send an SDP offer to a WHIP endpoint and return the answer, plus the session
+ * resource the server names for ending it.
+ */
+export async function whipOffer(
+  whipUrl: string,
+  offerSdp: string,
+  timeoutMs = WHIP_TIMEOUT_MS,
+): Promise<{ answerSdp: string; resource: string | null }> {
+  let res: Response;
+  try {
+    res = await fetch(whipUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/sdp', Accept: 'application/sdp' },
+      body: offerSdp,
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (err) {
+    // Never echo the URL: it carries the publish token.
+    const timedOut = (err as Error)?.name === 'TimeoutError';
+    throw new WhipError(0, timedOut
+      ? 'the media server did not answer in time'
+      : 'could not reach the media server');
+  }
+  const body = await res.text();
+  if (res.status !== 201 && res.status !== 200) {
+    const line = body.split('\n')[0]?.trim().slice(0, 200);
+    throw new WhipError(res.status, line || 'the media server refused the stream');
+  }
+  const location = res.headers.get('Location');
+  // Location may be relative; it is relative to the URL that was posted to.
+  return { answerSdp: body, resource: location ? new URL(location, whipUrl).toString() : null };
+}
+
+/**
+ * Tell the server the session is over. Best effort: the media server also
+ * notices the connection going away, so a failure here is not an error.
+ */
+export async function whipEnd(resource: string): Promise<void> {
+  try {
+    // keepalive lets it finish when called while the page is being closed.
+    await fetch(resource, { method: 'DELETE', keepalive: true, signal: AbortSignal.timeout(5_000) });
+  } catch {
+    /* the session ends when the connection does */
+  }
+}
+
+/**
+ * Publishes camera and microphone to one broadcast stream.
+ *
+ * ```ts
+ * const publisher = new BroadcastPublisher(stream.publish.whipUrl);
+ * publisher.on('state', (s) => setState(s));
+ * const media = await publisher.start();
+ * video.srcObject = media;
+ * // ...
+ * await publisher.stop();
+ * ```
+ *
+ * The `whipUrl` comes from your backend (`POST /v1/streams`) and already
+ * carries the publish token. Treat it like a password.
+ */
+export class BroadcastPublisher {
+  private pc: RTCPeerConnection | null = null;
+  private media: MediaStream | null = null;
+  private ownsMedia = false;
+  private resource: string | null = null;
+  private audioSender: RTCRtpSender | null = null;
+  private micTrack: MediaStreamTrack | null = null;
+  /** Present only while music is in use: the broadcast carries one audio track, so the two are mixed. */
+  private mixer: AudioMixer | null = null;
+  private micOn = true;
+  private current: BroadcastState = 'idle';
+  private readonly listeners = new Map<string, Set<Handler>>();
+
+  constructor(private readonly whipUrl: string) {}
+
+  get state(): BroadcastState {
+    return this.current;
+  }
+
+  /** What is being published, for a local preview. */
+  get localStream(): MediaStream | null {
+    return this.media;
+  }
+
+  on<K extends keyof BroadcastEvents>(event: K, fn: BroadcastEvents[K]): () => void {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn as Handler);
+    return () => set!.delete(fn as Handler);
+  }
+
+  private emit<K extends keyof BroadcastEvents>(event: K, ...args: Parameters<BroadcastEvents[K]>): void {
+    for (const fn of this.listeners.get(event) ?? []) {
+      try {
+        (fn as (...a: unknown[]) => void)(...args);
+      } catch (err) {
+        console.error(`listener for ${event} threw`, err);
+      }
+    }
+  }
+
+  private set(state: BroadcastState): void {
+    if (this.current === state) return;
+    this.current = state;
+    this.emit('state', state);
+  }
+
+  /** Go on air. Resolves once the media server has accepted the stream. */
+  async start(options: BroadcastStartOptions = {}): Promise<MediaStream> {
+    if (this.pc) throw new Error('already publishing; call stop() first');
+    this.set('connecting');
+    try {
+      this.ownsMedia = !options.stream;
+      const media = options.stream ?? await navigator.mediaDevices.getUserMedia(
+        options.constraints ?? { audio: true, video: { width: 1280, height: 720 } },
+      );
+      this.media = media;
+
+      const pc = new RTCPeerConnection();
+      this.pc = pc;
+      pc.addEventListener('connectionstatechange', () => {
+        if (this.pc !== pc) return;
+        if (pc.connectionState === 'connected') this.set('live');
+        else if (pc.connectionState === 'disconnected') this.set('interrupted');
+        else if (pc.connectionState === 'failed') this.set('failed');
+      });
+
+      this.micTrack = media.getAudioTracks()[0] ?? null;
+      if (options.music) {
+        this.mixer = new AudioMixer(this.micTrack);
+        this.mixer.setMusic(options.music, options.musicOptions);
+      }
+      for (const track of media.getVideoTracks()) {
+        this.preferH264(pc.addTransceiver(track, { direction: 'sendonly', streams: [media] }));
+      }
+      // Always an audio line, even with no microphone, so music can be added
+      // later without renegotiating with the media server.
+      const audio = this.mixer?.track ?? this.micTrack;
+      const transceiver = audio
+        ? pc.addTransceiver(audio, { direction: 'sendonly', streams: [media] })
+        : pc.addTransceiver('audio', { direction: 'sendonly' });
+      this.audioSender = transceiver.sender;
+
+      await pc.setLocalDescription(await pc.createOffer());
+      await iceGathered(pc);
+      const offerSdp = pc.localDescription?.sdp;
+      if (!offerSdp) throw new WhipError(0, 'could not create an offer in this browser');
+
+      const answer = await whipOffer(this.whipUrl, offerSdp);
+      this.resource = answer.resource;
+      await pc.setRemoteDescription({ type: 'answer', sdp: answer.answerSdp });
+      return media;
+    } catch (err) {
+      this.teardown();
+      this.set('failed');
+      throw err;
+    }
+  }
+
+  /**
+   * Put H.264 first, and offer nothing else for video.
+   *
+   * The media server repackages H.264 into HLS untouched. Any other codec
+   * makes it decode and re-encode every frame, which is the entire cost of a
+   * stream -- so a publisher that negotiates VP8 works, and quietly costs many
+   * times more.
+   */
+  private preferH264(transceiver: RTCRtpTransceiver): void {
+    try {
+      const all = RTCRtpSender.getCapabilities('video')?.codecs ?? [];
+      const h264 = all.filter((c) => c.mimeType.toLowerCase() === 'video/h264');
+      if (h264.length === 0) {
+        this.emit('warning', 'H.264 is not available in this browser; the stream will be transcoded');
+        return;
+      }
+      const helpers = all.filter((c) => HELPER_FORMATS.has(c.mimeType.toLowerCase()));
+      transceiver.setCodecPreferences([...h264, ...helpers]);
+    } catch (err) {
+      this.emit('warning', `could not prefer H.264 (${(err as Error).message}); the stream may be transcoded`);
+    }
+  }
+
+  /** Mute or unmute the microphone without leaving the air. Music keeps playing. */
+  setMicEnabled(enabled: boolean): void {
+    this.micOn = enabled;
+    if (this.mixer) this.mixer.setMicEnabled(enabled);
+    else if (this.micTrack) this.micTrack.enabled = enabled;
+  }
+
+  /**
+   * Put music from inside the page on air, mixed with the microphone.
+   *
+   * A broadcast carries a single audio track, so the two are mixed here, in
+   * the browser, before they are sent. The music never passes through the
+   * microphone, so the audience hears it clean, and each has its own switch:
+   * `setMusicEnabled` and `setMicEnabled`.
+   */
+  async setMusic(input: MusicInput, options?: MusicOptions): Promise<void> {
+    if (!this.pc || !this.audioSender) throw new Error('start() the broadcast before adding music');
+    if (!this.mixer) {
+      this.mixer = new AudioMixer(this.micTrack);
+      // The raw track was being sent until now; its own switch no longer applies.
+      if (this.micTrack) this.micTrack.enabled = true;
+      this.mixer.setMicEnabled(this.micOn);
+      await this.audioSender.replaceTrack(this.mixer.track);
+    }
+    this.mixer.setMusic(input, options);
+  }
+
+  /** Switch the music off or on for the audience. The microphone is untouched. */
+  setMusicEnabled(enabled: boolean): void {
+    this.mixer?.setMusicEnabled(enabled);
+  }
+
+  /** 0 to 1, for the audience. */
+  setMusicVolume(volume: number): void {
+    this.mixer?.setMusicVolume(volume);
+  }
+
+  /** Take the music off air. The microphone carries on. */
+  clearMusic(): void {
+    this.mixer?.clearMusic();
+  }
+
+  get musicEnabled(): boolean {
+    return this.mixer?.musicEnabled ?? false;
+  }
+
+  get micEnabled(): boolean {
+    return this.micOn && this.micTrack !== null;
+  }
+
+  /** Turn the camera on or off without leaving the air. */
+  setCamEnabled(enabled: boolean): void {
+    for (const t of this.media?.getVideoTracks() ?? []) t.enabled = enabled;
+  }
+
+  /** Go off air and release the camera and microphone. Idempotent. */
+  async stop(): Promise<void> {
+    const resource = this.resource;
+    this.teardown();
+    if (resource) await whipEnd(resource);
+    this.set('stopped');
+  }
+
+  private teardown(): void {
+    const { pc, media } = this;
+    this.pc = null;
+    this.media = null;
+    this.resource = null;
+    this.audioSender = null;
+    this.micTrack = null;
+    this.mixer?.close();
+    this.mixer = null;
+    this.micOn = true;
+    pc?.close();
+    if (this.ownsMedia && media) for (const t of media.getTracks()) t.stop();
+  }
+}
+
+/**
+ * WHIP sends one complete offer, so the candidates have to be in it before it
+ * is sent.
+ */
+function iceGathered(pc: RTCPeerConnection): Promise<void> {
+  if (pc.iceGatheringState === 'complete') return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      pc.removeEventListener('icegatheringstatechange', check);
+      resolve();
+    };
+    const check = () => {
+      if (pc.iceGatheringState === 'complete') done();
+    };
+    const timer = setTimeout(done, ICE_GATHER_TIMEOUT_MS);
+    pc.addEventListener('icegatheringstatechange', check);
+  });
+}

package/src/chat.ts

@@ -0,0 +1,352 @@
+/**
+ * Chat for the orchestrator's signaling protocol.
+ *
+ * A channel shares its name with the room of the same name, so there are two
+ * ways into one conversation: `StreamClient` carries chat over the socket it
+ * already holds for media, and `ChatClient` here opens a socket that carries
+ * nothing else -- for an audience that is watching a broadcast over a CDN and
+ * has no reason to be on an SFU.
+ */
+import type { Role } from './index.js';
+
+export interface ChatMessage {
+  /** Monotonic within a channel, so the oldest id held is a paging cursor. */
+  id: string;
+  channel: string;
+  from: string;
+  /** Present on a direct message, which only its two ends receive. */
+  to?: string;
+  /** "text" unless the sender said otherwise. Anything else is the app's own. */
+  type: string;
+  /**
+   * Delivered exactly as sent. Render it as text, never as HTML: escaping is
+   * the renderer's job and the server does not do it for you.
+   */
+  text?: string;
+  metadata?: unknown;
+  /** Echoed from the sender, to match an optimistic message to the real one. */
+  clientMsgId?: string;
+  ts: number;
+}
+
+export interface SendMessageOptions {
+  type?: string;
+  /** Make it a direct message to one identity. */
+  to?: string;
+  metadata?: unknown;
+  clientMsgId?: string;
+  /** Delivered and not stored: reactions, hearts, anything not worth replaying. */
+  ephemeral?: boolean;
+}
+
+export interface ChatState {
+  channel: string;
+  /** Distinct identities connected, in the room or only in its chat. */
+  members: number;
+  /** Whether a moderator has muted THIS identity. */
+  muted: boolean;
+  /** Only present for moderators. */
+  mutedIdentities?: string[];
+}
+
+export interface ChatJoinResult {
+  channel: string;
+  identity: string;
+  role: Role;
+  members: number;
+  muted: boolean;
+  /** The most recent messages, oldest first. */
+  messages: ChatMessage[];
+}
+
+export interface ChatEvents {
+  message: (m: ChatMessage) => void;
+  messageDeleted: (e: { id: string; by: string }) => void;
+  chatMuted: (e: { identity: string; muted: boolean; by: string }) => void;
+  typing: (e: { identity: string; typing: boolean }) => void;
+}
+
+export interface ChatClientEvents extends ChatEvents {
+  connected: () => void;
+  disconnected: (reason: string) => void;
+  joined: (result: ChatJoinResult) => void;
+  error: (err: Error) => void;
+  /** The session ended and will not recover. Nothing further will be emitted. */
+  closed: (reason: 'gave-up' | 'left' | 'ended') => void;
+  /** The account behind this connection ran out; see StreamClient's event. */
+  usageLimit: (e: { reason: string; graceSeconds: number; endsAt: number }) => void;
+}
+
+/** An error returned by the server, carrying its machine-readable code. */
+export class ChatRpcError extends Error {
+  constructor(readonly code: string, message: string) {
+    super(`${code}: ${message}`);
+    this.name = 'ChatRpcError';
+  }
+}
+
+type Handler = (...args: never[]) => void;
+
+interface Pending {
+  resolve: (v: unknown) => void;
+  reject: (e: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+const RPC_TIMEOUT_MS = 15_000;
+const MAX_RECONNECT_ATTEMPTS = 8;
+/** A token that is wrong will be wrong next time too; retrying only adds noise. */
+const TERMINAL_JOIN_ERRORS = new Set([
+  'bad-token',
+  'no-token',
+  // The account cannot use the service until it is topped up or restored.
+  'quota-exhausted',
+  'daily-limit-reached',
+  'monthly-limit-reached',
+  'tenant-suspended',
+]);
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * A chat-only connection. Takes the `wsUrl` and `token` returned by
+ * `POST /v1/chat/{channel}/tokens`.
+ */
+export class ChatClient {
+  private ws: WebSocket | null = null;
+  private readonly pending = new Map<number, Pending>();
+  private readonly listeners = new Map<string, Set<Handler>>();
+  private nextId = 1;
+  private token: string;
+  private joinResult: ChatJoinResult | null = null;
+  private closedByUs = false;
+  private reconnecting = false;
+  private reconnectAttempt = 0;
+
+  constructor(private readonly wsUrl: string, token: string) {
+    this.token = token;
+  }
+
+  on<K extends keyof ChatClientEvents>(event: K, fn: ChatClientEvents[K]): () => void {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(fn as Handler);
+    return () => set!.delete(fn as Handler);
+  }
+
+  private emit<K extends keyof ChatClientEvents>(event: K, ...args: Parameters<ChatClientEvents[K]>): void {
+    for (const fn of this.listeners.get(event) ?? []) {
+      try {
+        (fn as (...a: unknown[]) => void)(...args);
+      } catch (err) {
+        console.error(`listener for ${event} threw`, err);
+      }
+    }
+  }
+
+  /** What join returned, including the history the channel had at that moment. */
+  get info(): ChatJoinResult | null {
+    return this.joinResult;
+  }
+
+  async connect(): Promise<ChatJoinResult> {
+    await this.openSocket();
+    const result = (await this.rpc('join', { token: this.token })) as ChatJoinResult;
+    this.joinResult = result;
+    this.emit('joined', result);
+    return result;
+  }
+
+  private openSocket(): Promise<void> {
+    this.detachSocket();
+    return new Promise((resolve, reject) => {
+      const url = new URL(this.wsUrl);
+      url.searchParams.set('token', this.token);
+      const ws = new WebSocket(url.toString());
+      this.ws = ws;
+
+      const onError = () => reject(new Error('websocket failed to open'));
+      ws.addEventListener('open', () => {
+        this.reconnectAttempt = 0;
+        this.emit('connected');
+        resolve();
+      }, { once: true });
+      ws.addEventListener('error', onError, { once: true });
+      ws.addEventListener('message', (ev) => {
+        if (this.ws === ws) this.onMessage(ev.data as string);
+      });
+      ws.addEventListener('close', (ev) => {
+        ws.removeEventListener('error', onError);
+        // Only the socket we currently consider ours may drive reconnection.
+        if (this.ws !== ws) return;
+        this.ws = null;
+        this.failAllPending(new Error(`socket closed (${ev.code})`));
+        this.emit('disconnected', ev.reason || String(ev.code));
+        if (ev.code === 4003 && !this.closedByUs) {
+          // Ended by the server after telling us why (usageLimit). Final.
+          this.closedByUs = true;
+          this.emit('closed', 'ended');
+          return;
+        }
+        if (!this.closedByUs) void this.scheduleReconnect();
+      });
+    });
+  }
+
+  private detachSocket(): void {
+    const ws = this.ws;
+    this.ws = null;
+    if (ws && ws.readyState <= WebSocket.OPEN) {
+      try {
+        ws.close(1000, 'superseded');
+      } catch {
+        /* already closing */
+      }
+    }
+  }
+
+  /** Single-flight, with backoff: the same shape as the room client's. */
+  private async scheduleReconnect(): Promise<void> {
+    if (this.reconnecting || this.closedByUs) return;
+    this.reconnecting = true;
+    try {
+      while (!this.closedByUs) {
+        this.reconnectAttempt += 1;
+        if (this.reconnectAttempt > MAX_RECONNECT_ATTEMPTS) {
+          this.emit('error', new Error(`gave up after ${MAX_RECONNECT_ATTEMPTS} reconnect attempts`));
+          this.closedByUs = true;
+          this.emit('closed', 'gave-up');
+          return;
+        }
+        const backoff = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15_000);
+        await sleep(backoff + Math.random() * 400);
+        if (this.closedByUs) return;
+        try {
+          await this.connect();
+          return;
+        } catch (err) {
+          this.emit('error', err as Error);
+          if (err instanceof ChatRpcError && TERMINAL_JOIN_ERRORS.has(err.code)) {
+            this.closedByUs = true;
+            this.emit('closed', 'gave-up');
+            return;
+          }
+        }
+      }
+    } finally {
+      this.reconnecting = false;
+    }
+  }
+
+  close(): void {
+    if (this.closedByUs) return;
+    this.closedByUs = true;
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close(1000, 'client closed');
+    this.emit('closed', 'left');
+  }
+
+  private rpc(method: string, params: unknown = {}): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      if (this.ws?.readyState !== WebSocket.OPEN) {
+        reject(new Error('socket is not open'));
+        return;
+      }
+      const id = this.nextId++;
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, RPC_TIMEOUT_MS);
+      this.pending.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  private failAllPending(err: Error): void {
+    for (const p of this.pending.values()) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+
+  private onMessage(raw: string): void {
+    let msg: Record<string, unknown>;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (typeof msg.id === 'number') {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      clearTimeout(p.timer);
+      this.pending.delete(msg.id);
+      if (msg.ok) p.resolve(msg.result);
+      else {
+        const e = msg.error as { code?: string; message?: string } | undefined;
+        p.reject(new ChatRpcError(e?.code ?? 'error', e?.message ?? 'unknown'));
+      }
+      return;
+    }
+    switch (msg.event) {
+      case 'message':
+        this.emit('message', msg.data as ChatMessage);
+        break;
+      case 'messageDeleted':
+        this.emit('messageDeleted', msg.data as { id: string; by: string });
+        break;
+      case 'chatMuted':
+        this.emit('chatMuted', msg.data as { identity: string; muted: boolean; by: string });
+        break;
+      case 'typing':
+        this.emit('typing', msg.data as { identity: string; typing: boolean });
+        break;
+      case 'usageLimit':
+        this.emit('usageLimit', msg.data as { reason: string; graceSeconds: number; endsAt: number });
+        break;
+      case 'tokenRefreshed': {
+        // A channel outlives its join token many times over. The server hands
+        // out a fresh one periodically so a reconnect at any point still works.
+        const e = msg.data as { token?: string };
+        if (e.token) this.token = e.token;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  sendMessage(text: string, opts: SendMessageOptions = {}): Promise<{ id: string; ts: number }> {
+    return this.rpc('sendMessage', { text, ...opts }) as Promise<{ id: string; ts: number }>;
+  }
+
+  /** Older messages, oldest first. Pass the oldest id you hold as `before`. */
+  async getMessages(opts: { limit?: number; before?: string } = {}): Promise<ChatMessage[]> {
+    const res = (await this.rpc('getMessages', opts)) as { messages: ChatMessage[] };
+    return res.messages;
+  }
+
+  /** Your own message, or anyone's if you are a moderator. */
+  deleteMessage(messageId: string): Promise<unknown> {
+    return this.rpc('deleteMessage', { messageId });
+  }
+
+  /** Moderators only. A mute outlasts the muted socket reconnecting. */
+  muteChat(identity: string, muted = true): Promise<unknown> {
+    return this.rpc('muteChat', { identity, muted });
+  }
+
+  /** Advisory, and throttled by the server; safe to call on every keystroke. */
+  setTyping(typing: boolean): Promise<unknown> {
+    return this.rpc('setTyping', { typing });
+  }
+
+  getChatState(): Promise<ChatState> {
+    return this.rpc('getChatState') as Promise<ChatState>;
+  }
+}