@rapidmx/meet-plugin 0.15.0 → 0.16.0

package/dist/apps/shared/signaling/SignalingClient.js

@@ -0,0 +1,278 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * The `SignalingChannel` (`../webrtc/types.js`) of a call: one WebSocket to this plugin's own signaling route
+ * (`BaseVideoMeetingRoute.signal()`, `wss://<origin>/api/mail/video-meetings/signal/<meetingUid>`), carrying every
+ * `SignalMessage` both ways - see the backend's `SignalingHub` for the protocol this speaks:
+ *
+ * - Once the socket opens, it says `{"op":"hello","v":1,"peer":<this tab's peer id>}`; the server answers
+ * `{"op":"ready","v":1,"maxMessageBytes":N}` and `connect()` resolves.
+ * - `send()` writes `{"op":"signal","data":<message>}`. The server stamps `from`/`peer` itself, and delivers a message
+ * with `to` to that peer only - so unlike the shared `/push` channel this replaced, nobody receives offers, answers or
+ * ICE candidates meant for someone else, and the client never sees its own messages echoed back.
+ * - A message the server delivers arrives as `{"op":"signal","data":...}` and is handed to every `onMessage()` listener.
+ * - A `ping` every `SIGNALING_KEEPALIVE_MS` keeps proxies from closing an idle socket.
+ *
+ * ## Authentication
+ *
+ * A browser `WebSocket` cannot send an `Authorization` header, so the upgrade is authenticated by the `jwt` cookie.
+ * For a guest (`token` given - `VideoMeetingJoinResult.authenticated` is `false`) this client sets that cookie to the
+ * guest token right before connecting (`applyAuthCookie()`), and expires it on `close()`; the media relay's own
+ * socket (`../relay/RelayClient.ts`) then authenticates with the same cookie. For a caller already signed in to RapidMX
+ * (`token` omitted) it writes nothing: a script cannot overwrite the real `HttpOnly` session cookie anyway, and that
+ * session is the identity `join()` granted.
+ *
+ * ## Losing the connection
+ *
+ * A socket that drops after `connect()` resolved is reopened with jittered exponential backoff, says `hello` again
+ * and carries on; whatever was sent meanwhile is held (up to `SIGNALING_MAX_QUEUED`, oldest dropped first) and sent
+ * once the new socket is ready. A close with 1008 is the server refusing the socket - no grant, the meeting ended,
+ * the participant was removed - and is final: before `connect()` resolved it rejects `connect()`, after that it
+ * calls `onClosed` with the server's reason. (The one 1008 that is not final, "Replaced.", only ever reaches a socket
+ * this client has already let go of.)
+ */
+import { apiOrigin } from "@rapidmx/web-client/lib/util/api.js";
+/** The version of the signaling wire protocol this client speaks - `SignalingHub`'s `SIGNALING_PROTOCOL_VERSION`. */
+export const SIGNALING_PROTOCOL_VERSION = 1;
+/** The first reconnect waits about this long, doubling on each further failure up to `SIGNALING_BACKOFF_MAX_MS`. */
+export const SIGNALING_BACKOFF_BASE_MS = 1000;
+export const SIGNALING_BACKOFF_MAX_MS = 30000;
+/** How often an idle socket is pinged. */
+export const SIGNALING_KEEPALIVE_MS = 25000;
+/** The most messages held while the socket is not ready. */
+export const SIGNALING_MAX_QUEUED = 256;
+/** What the server allows per message until it says otherwise in `ready` - its smallest possible limit. */
+export const SIGNALING_DEFAULT_MAX_MESSAGE_BYTES = 16 * 1024;
+/** The reason the server closes the socket with once the participant is removed from the meeting - `SignalingHub`'s
+ * `SIGNALING_EVICTED_REASON` (`apps/` cannot import from the backend's `src/`, so this mirrors it). */
+export const SIGNALING_EVICTED_REASON = "Removed from the meeting.";
+const SOCKET_OPEN = 1;
+/** The cookie name `JWTStrategyOptions.cookieName` defaults to (and this deployment always uses). */
+const AUTH_COOKIE_NAME = "jwt";
+/** The signaling WebSocket's URL for a meeting - the same origin derivation as the relay's `relayUrl()`. `undefined`
+ * when there is no origin at all (not running in a browser). */
+export function signalingUrl(meetingUid) {
+    const origin = apiOrigin() || (typeof window !== "undefined" ? window.location.origin : "");
+    return origin ? `${origin.replace(/^http/i, "ws")}/api/mail/video-meetings/signal/${encodeURIComponent(meetingUid)}` : undefined;
+}
+function defaultSocketFactory() {
+    return typeof WebSocket === "undefined" ? undefined : (url) => new WebSocket(url);
+}
+export class SignalingClient {
+    constructor(options) {
+        this.options = options;
+        this.ready = false;
+        this.closed = false;
+        this.everReady = false;
+        this.attempt = 0;
+        this.cookieApplied = false;
+        this.maxBytes = SIGNALING_DEFAULT_MAX_MESSAGE_BYTES;
+        this.queue = [];
+        this.listeners = new Set();
+    }
+    /** The largest message (the whole `signal` envelope, in bytes) the server accepts - what its `ready` said. */
+    get maxMessageBytes() {
+        return this.maxBytes;
+    }
+    /** Opens the socket and resolves once the server is ready; rejects when the server refuses it, or there is no way
+     * to open one at all (no `WebSocket`, no origin). Calling it on a closed client rejects at once. */
+    connect() {
+        if (this.closed) {
+            return Promise.reject(new Error("This signaling client has already been closed."));
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingConnect = { resolve, reject };
+            this.openSocket();
+        });
+    }
+    /** Closes the socket, stops reconnecting and clears the guest auth cookie this client applied - idempotent. */
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.ready = false;
+        clearTimeout(this.reconnectTimer);
+        this.stopKeepalive();
+        const socket = this.socket;
+        this.socket = undefined;
+        if (socket) {
+            socket.onopen = socket.onmessage = socket.onclose = socket.onerror = null;
+            try {
+                socket.close(1000, "closing");
+            }
+            catch {
+                // Already gone.
+            }
+        }
+        this.clearAuthCookie();
+        this.listeners.clear();
+        this.queue.length = 0;
+        this.pendingConnect?.reject(new Error("Closed before the signaling channel connected."));
+        this.pendingConnect = undefined;
+    }
+    onMessage(handler) {
+        this.listeners.add(handler);
+        return () => this.listeners.delete(handler);
+    }
+    /** Sends `message` now, or once the socket is ready again - see this module's doc comment. A no-op once closed. */
+    send(message) {
+        if (this.closed) {
+            return;
+        }
+        const text = JSON.stringify({ op: "signal", data: message });
+        // Straight out only when nothing is waiting, so a message never overtakes one queued before it.
+        if (this.ready && this.queue.length === 0 && this.write(text)) {
+            return;
+        }
+        if (this.queue.length >= SIGNALING_MAX_QUEUED) {
+            this.queue.shift();
+        }
+        this.queue.push(text);
+    }
+    openSocket() {
+        const url = this.options.url ?? signalingUrl(this.options.meetingUid);
+        const createSocket = this.options.createSocket ?? defaultSocketFactory();
+        if (!url || !createSocket) {
+            this.fail(new Error("This browser (or this page's connection) doesn't support the signaling channel."));
+            return;
+        }
+        this.applyAuthCookie();
+        let socket;
+        try {
+            socket = createSocket(url);
+        }
+        catch {
+            this.scheduleReconnect();
+            return;
+        }
+        this.socket = socket;
+        socket.onopen = () => this.write(JSON.stringify({ op: "hello", v: SIGNALING_PROTOCOL_VERSION, peer: this.options.peerId }));
+        socket.onmessage = (event) => this.handleFrame(event.data);
+        socket.onclose = (event) => {
+            if (this.socket !== socket) {
+                return;
+            }
+            this.socket = undefined;
+            this.ready = false;
+            this.stopKeepalive();
+            if (event?.code === 1008) {
+                this.refused(event.reason || "The meeting refused the connection.");
+                return;
+            }
+            this.scheduleReconnect();
+        };
+        // An error is always followed by a close, which decides what happens next.
+        socket.onerror = () => undefined;
+    }
+    handleFrame(raw) {
+        if (typeof raw !== "string") {
+            return;
+        }
+        let frame;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed !== "object") {
+                return;
+            }
+            frame = parsed;
+        }
+        catch {
+            return;
+        }
+        if (frame.op === "ready") {
+            this.handleReady(frame.maxMessageBytes);
+        }
+        else if (frame.op === "signal" && frame.data && typeof frame.data === "object") {
+            for (const listener of [...this.listeners]) {
+                listener(frame.data);
+            }
+        }
+    }
+    handleReady(maxMessageBytes) {
+        if (typeof maxMessageBytes === "number" && Number.isFinite(maxMessageBytes) && maxMessageBytes > 0) {
+            this.maxBytes = maxMessageBytes;
+        }
+        this.ready = true;
+        this.everReady = true;
+        this.attempt = 0;
+        this.startKeepalive();
+        while (this.queue.length > 0 && this.write(this.queue[0])) {
+            this.queue.shift();
+        }
+        this.pendingConnect?.resolve();
+        this.pendingConnect = undefined;
+    }
+    /** Writes `text` to the open socket; `false` when there is none or it threw. */
+    write(text) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== SOCKET_OPEN) {
+            return false;
+        }
+        try {
+            socket.send(text);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    startKeepalive() {
+        this.stopKeepalive();
+        this.keepaliveTimer = setInterval(() => this.write(JSON.stringify({ op: "ping", t: Date.now() })), SIGNALING_KEEPALIVE_MS);
+    }
+    stopKeepalive() {
+        clearInterval(this.keepaliveTimer);
+        this.keepaliveTimer = undefined;
+    }
+    scheduleReconnect() {
+        if (this.closed) {
+            return;
+        }
+        const ceiling = Math.min(SIGNALING_BACKOFF_MAX_MS, SIGNALING_BACKOFF_BASE_MS * 2 ** Math.min(this.attempt, 10));
+        const delay = ceiling / 2 + ((this.options.random ?? Math.random)() * ceiling) / 2;
+        this.attempt += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.openSocket();
+        }, delay);
+    }
+    /** The server closed the socket for good - see this module's doc comment. */
+    refused(reason) {
+        if (this.pendingConnect) {
+            this.fail(new Error(reason));
+            return;
+        }
+        if (this.everReady) {
+            this.options.onClosed?.(reason);
+        }
+    }
+    fail(err) {
+        this.pendingConnect?.reject(err);
+        this.pendingConnect = undefined;
+    }
+    /** Sets the `jwt` cookie to the guest `token`, so the browser attaches it to the upgrade this client is about to
+     * open - see this module's doc comment. A no-op without a token or a document. */
+    applyAuthCookie() {
+        if (!this.options.token) {
+            return;
+        }
+        const doc = this.options.documentRef ?? (typeof document === "undefined" ? undefined : document);
+        if (!doc) {
+            return;
+        }
+        this.cookieApplied = true;
+        const secure = (doc.location ?? (typeof location === "undefined" ? undefined : location))?.protocol === "https:" ? "; Secure" : "";
+        doc.cookie = `${AUTH_COOKIE_NAME}=${encodeURIComponent(this.options.token)}; path=/; SameSite=Lax${secure}`;
+    }
+    /** Expires the cookie `applyAuthCookie()` set; a no-op when it set none. */
+    clearAuthCookie() {
+        if (!this.cookieApplied) {
+            return;
+        }
+        const doc = this.options.documentRef ?? (typeof document === "undefined" ? undefined : document);
+        doc.cookie = `${AUTH_COOKIE_NAME}=; path=/; Max-Age=0`;
+    }
+}

package/dist/apps/shared/webrtc/MeshConnectionManager.d.ts

@@ -1,6 +1,6 @@
 /**
  * Full-mesh WebRTC connection management: one direct `RTCPeerConnection` per other participant, signaled entirely
- * over the meeting's own push channel (`SignalingChannel` - see `types.ts`) as this plugin's Phase 2
+ * over the meeting's own signaling channel (`SignalingChannel` - see `types.ts`) as this plugin's Phase 2
  * `.claude/NOTES.md` entry lays out. Pure state machine, no JSX/DOM rendering - `apps/meet/_CallView.tsx` owns one
  * instance per call and mirrors its events into React state.
  *
@@ -27,17 +27,17 @@
  *
  * ## Join announcement and roster discovery
  *
- * The channel has no history (a push event published while a socket was down is never replayed - see
- * `@rapidmx/web-client`'s `lib/mail/pushClient.ts` doc comment for the identical guarantee on the mail push channel this
- * one shares its transport with), so a newcomer's `hello` would only reach participants who happened to already be
- * subscribed *and* who joined before them - never the other way around. Every participant who learns of a
+ * The channel has no history (the server delivers a message only to the sockets connected at that moment, and never
+ * replays one to a socket that connects later - see the backend's `SignalingHub`), so a newcomer's `hello` would only
+ * reach participants who happened to already be connected *and* who joined before them - never the other way around. Every participant who learns of a
  * genuinely new peer (from any message, not just `hello`) therefore echoes its own `hello` right back, once, the
  * first time it becomes aware of that peer - so within one extra round trip everyone converges on the same full
  * roster regardless of join order. This is naturally bounded (each participant echoes at most once per peer it
  * ever discovers) rather than a risk of runaway flooding.
  *
- * Each message is its own `POST`, so nothing guarantees they arrive in the order they were sent. Two consequences
- * are handled here: an `offer` that beats its sender's `hello` creates the peer under a placeholder name that the
+ * Nothing in `SignalingChannel` itself promises that messages arrive in the order they were sent (one socket keeps
+ * one sender's messages in order today, but the transport this replaced sent each message as its own `POST`, and
+ * this manager does not depend on which transport it has). Two consequences are handled here: an `offer` that beats its sender's `hello` creates the peer under a placeholder name that the
  * `hello` then replaces (`participant-updated`), and an ICE candidate that beats its offer is held until the peer
  * exists rather than dropped.
  *

package/dist/apps/shared/webrtc/MeshConnectionManager.js

@@ -4,7 +4,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 /**
  * Full-mesh WebRTC connection management: one direct `RTCPeerConnection` per other participant, signaled entirely
- * over the meeting's own push channel (`SignalingChannel` - see `types.ts`) as this plugin's Phase 2
+ * over the meeting's own signaling channel (`SignalingChannel` - see `types.ts`) as this plugin's Phase 2
  * `.claude/NOTES.md` entry lays out. Pure state machine, no JSX/DOM rendering - `apps/meet/_CallView.tsx` owns one
  * instance per call and mirrors its events into React state.
  *
@@ -31,17 +31,17 @@
  *
  * ## Join announcement and roster discovery
  *
- * The channel has no history (a push event published while a socket was down is never replayed - see
- * `@rapidmx/web-client`'s `lib/mail/pushClient.ts` doc comment for the identical guarantee on the mail push channel this
- * one shares its transport with), so a newcomer's `hello` would only reach participants who happened to already be
- * subscribed *and* who joined before them - never the other way around. Every participant who learns of a
+ * The channel has no history (the server delivers a message only to the sockets connected at that moment, and never
+ * replays one to a socket that connects later - see the backend's `SignalingHub`), so a newcomer's `hello` would only
+ * reach participants who happened to already be connected *and* who joined before them - never the other way around. Every participant who learns of a
  * genuinely new peer (from any message, not just `hello`) therefore echoes its own `hello` right back, once, the
  * first time it becomes aware of that peer - so within one extra round trip everyone converges on the same full
  * roster regardless of join order. This is naturally bounded (each participant echoes at most once per peer it
  * ever discovers) rather than a risk of runaway flooding.
  *
- * Each message is its own `POST`, so nothing guarantees they arrive in the order they were sent. Two consequences
- * are handled here: an `offer` that beats its sender's `hello` creates the peer under a placeholder name that the
+ * Nothing in `SignalingChannel` itself promises that messages arrive in the order they were sent (one socket keeps
+ * one sender's messages in order today, but the transport this replaced sent each message as its own `POST`, and
+ * this manager does not depend on which transport it has). Two consequences are handled here: an `offer` that beats its sender's `hello` creates the peer under a placeholder name that the
  * `hello` then replaces (`participant-updated`), and an ICE candidate that beats its offer is held until the peer
  * exists rather than dropped.
  *
@@ -746,7 +746,7 @@ export class MeshConnectionManager {
         }
         const peer = this.peers.get(message.from);
         if (!peer) {
-            // A candidate that raced ahead of its own offer (each message is a separate `POST`) - hold it for
+            // A candidate that raced ahead of its own offer (see this module's doc comment on ordering) - hold it for
             // the peer to claim when it is created. Bounded, see `MAX_ORPHAN_PEERS`.
             const held = this.orphanCandidates.get(message.from);
             if (held) {

package/dist/apps/shared/webrtc/types.d.ts

@@ -1,7 +1,6 @@
-/** Shared types for `MeshConnectionManager.ts` and its signaling transport (`apps/shared/push/GuestSignalingClient.ts`) -
- * kept in their own module so a test can depend on the shapes alone. `GuestSignalingClient` itself now also serves
- * an already-authenticated real caller (`VideoMeetingJoinResult.authenticated`), not only a synthetic guest - see
- * its own doc comment. */
+/** Shared types for `MeshConnectionManager.ts` and its signaling transport (`apps/shared/signaling/SignalingClient.ts`) -
+ * kept in their own module so a test can depend on the shapes alone. `SignalingClient` serves both a guest and an
+ * already-authenticated real caller (`VideoMeetingJoinResult.authenticated`) - see its own doc comment. */
 /** What a participant is sending, and whether their hand is up. Announced in `hello` and re-sent as a `state`
  * message on every change, so a tile can show a muted microphone, an avatar for a camera that is off, and a raised
  * hand without inspecting the media itself (the far end of a `replaceTrack(null)` gives no dependable signal that
@@ -29,16 +28,19 @@ export declare const REACTION_EMOJIS: readonly ["👍", "👏", "❤️", "🎉"
  * every other participant has chosen for their own tab. */
 export type TransportMode = "auto" | "p2p" | "relay" | "websocket";
 /**
- * One WebRTC signaling message, published as the JSON body of `POST /push/:meetingUid` (`BasePushRoute.send()`)
- * and received back over `/push`'s WebSocket, exactly as `BaseVideoMeetingRoute`'s doc comment describes ("SDP
- * offers/answers and ICE candidates are ordinary `NotificationUtils.sendMessage()` payloads"). `type` is a fixed
- * literal so a listener on the meeting's channel (which will also see other frame shapes if this server ever
- * grows other push consumers) can cheaply recognize and skip anything that isn't one of these.
+ * One WebRTC signaling message, sent as the `data` of a `{"op":"signal"}` frame over the meeting's own signaling
+ * WebSocket (`apps/shared/signaling/SignalingClient.ts`, served by `BaseVideoMeetingRoute.signal()` and the backend's
+ * `SignalingHub`) and delivered to the other participants the same way. `type` is a fixed literal so a listener can
+ * cheaply recognize and skip anything that isn't one of these.
+ *
+ * `chat`/`whiteboard` (see `../collab/CollabSession.ts`) are broadcast like `reaction`.
  *
  * `hello`/`bye`/`presenter-claim`/`presenter-release`/`state`/`reaction`/`talking-stick` are broadcast (`to` left
- * unset - every participant is relevant); `offer`/`answer`/`ice-candidate`/`mute-request`/`kicked` are
- * point-to-point (`to` is the intended peer's uid) - a recipient that isn't `to` (when set) ignores the message,
- * since a channel's pub/sub fans every message out to every subscriber, sender included.
+ * unset - every other participant receives it); `offer`/`answer`/`ice-candidate`/`mute-request`/`kicked` are
+ * point-to-point (`to` is the intended peer's id) - the server delivers one only to the socket of that peer, so
+ * nobody else ever sees it. The sender never receives its own messages back either. (A recipient still ignores a
+ * message whose `to` isn't itself, and its own messages - harmless with this transport, and kept so
+ * `MeshConnectionManager` does not depend on how its transport routes.)
  *
  * `mute-request`/`kicked`/`talking-stick` are host moderation signals (see `MeshConnectionManager`'s doc comment) -
  * purely cooperative, like every other message here: the recipient's own client decides whether to honor one, and
@@ -56,16 +58,17 @@ export type TransportMode = "auto" | "p2p" | "relay" | "websocket";
  */
 export interface SignalMessage {
     type: "video-meeting-signal";
-    kind: "hello" | "bye" | "offer" | "answer" | "ice-candidate" | "presenter-claim" | "presenter-release" | "state" | "reaction" | "relay-fallback" | "mute-request" | "kicked" | "talking-stick" | "restart-connection";
+    kind: "hello" | "bye" | "offer" | "answer" | "ice-candidate" | "presenter-claim" | "presenter-release" | "state" | "reaction" | "relay-fallback" | "mute-request" | "kicked" | "talking-stick" | "restart-connection" | "chat" | "whiteboard" | "collab-sync-request" | "collab-sync" | "whiteboard-cursor";
     /** The sender's authenticated uid - the real caller's own uid when `join()` returned `authenticated: true`, else
-     * the `guest:<random>` uid `BaseVideoMeetingRoute.join()` minted. The server refuses a published message whose
-     * `from` isn't the authenticated caller's uid (it stops one participant speaking as another), so this must be
-     * exactly that uid. */
+     * the `guest:<random>` uid `BaseVideoMeetingRoute.join()` minted. The server overwrites whatever the sender put
+     * here with the uid its signaling socket authenticated as (it stops one participant speaking as another), so a
+     * received message's `from` is always that uid. */
     from: string;
     /** Which of the sender's tabs or devices this is: `<from>~<random>`. The same account joining from two devices is
-     * two participants, not one that ignores its own messages. A `peer` that doesn't start with `<from>~` is
-     * ignored, so it can't name someone else's tab. Absent from a sender that predates it (the participant is then
-     * identified by `from`). */
+     * two participants, not one that ignores its own messages. The server overwrites it with the peer id the sender's
+     * socket announced in its `hello` (which must be `<from>` or start with `<from>~`), so every received message
+     * carries one; a received `peer` that is neither is still ignored, so it can't name someone else's tab, and one
+     * that is absent identifies the participant by `from`. */
     peer?: string;
     /** Set only on a point-to-point message (`offer`/`answer`/`ice-candidate`/`relay-fallback`). */
     to?: string;
@@ -84,15 +87,26 @@ export interface SignalMessage {
     sdp?: RTCSessionDescriptionInit;
     /** `ice-candidate` only. */
     candidate?: RTCIceCandidateInit;
+    /** `chat` only - a `ChatPayload` (`../collab/protocol.ts`), validated by `parseChat()` before use. Typed `unknown`
+     * since it is another participant's input until then; the same goes for the next two. */
+    chat?: unknown;
+    /** `whiteboard` only - a `WhiteboardOp`, validated by `parseWhiteboardOp()`. */
+    whiteboard?: unknown;
+    /** `collab-sync` only - one `SyncPayload` part of a newcomer's catch-up, validated by `parseSync()`. `collab-sync`
+     * and `collab-sync-request` are point-to-point (`to` set) - see `CollabSession`'s doc comment. */
+    sync?: unknown;
+    /** `whiteboard-cursor` only - a `CursorPayload`, validated by `parseCursor()`; broadcast, never stored. */
+    cursor?: unknown;
 }
 /** What `MeshConnectionManager` needs from a signaling transport - implemented by
- * `apps/shared/push/GuestSignalingClient.ts` for a real call, and by an in-memory fake for `MeshConnectionManager`'s own
- * tests (see `test/webrtc/MeshConnectionManager.test.ts`), which never opens a real network connection. */
+ * `apps/shared/signaling/SignalingClient.ts` for a real call, and by an in-memory fake for `MeshConnectionManager`'s own
+ * tests (see `test/apps/shared/webrtc/MeshConnectionManager.test.ts`), which never opens a real network connection. */
 export interface SignalingChannel {
     send(message: SignalMessage): void;
-    /** Calls `handler` with every message received on the channel (including, per the pub/sub fan-out this
-     * transport is built on, this same client's own sends - `MeshConnectionManager` filters those out itself
-     * rather than relying on the transport to). Returns the function that stops listening. */
+    /** Calls `handler` with every message received on the channel. `SignalingClient` never delivers this client's own
+     * sends, nor a `to`-addressed message meant for another peer, but `MeshConnectionManager` filters both out itself
+     * rather than relying on the transport to (its tests' fake echoes everything to everyone). Returns the function
+     * that stops listening. */
     onMessage(handler: (message: SignalMessage) => void): () => void;
 }
 /** One kind's RTP stream stats, as of one sample - cumulative counters (`bytesSent`/`bytesReceived`), not a rate,

package/dist/apps/shared/webrtc/types.js

@@ -2,10 +2,9 @@
 // Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
 // SPDX-License-Identifier: MPL-2.0
 ///////////////////////////////////////////////////////////////////////////////
-/** Shared types for `MeshConnectionManager.ts` and its signaling transport (`apps/shared/push/GuestSignalingClient.ts`) -
- * kept in their own module so a test can depend on the shapes alone. `GuestSignalingClient` itself now also serves
- * an already-authenticated real caller (`VideoMeetingJoinResult.authenticated`), not only a synthetic guest - see
- * its own doc comment. */
+/** Shared types for `MeshConnectionManager.ts` and its signaling transport (`apps/shared/signaling/SignalingClient.ts`) -
+ * kept in their own module so a test can depend on the shapes alone. `SignalingClient` serves both a guest and an
+ * already-authenticated real caller (`VideoMeetingJoinResult.authenticated`) - see its own doc comment. */
 /** The emoji a participant can send during a call. A received `reaction` outside this list is ignored, so an
  * arbitrary string from another participant is never rendered. */
 export const REACTION_EMOJIS = ["👍", "👏", "❤️", "🎉", "😂", "😮", "😢", "👋"];