@rapidmx/meet-plugin 0.14.0 → 0.15.0

package/dist/apps/shared/relay/RelayClient.d.ts

@@ -23,11 +23,16 @@ export declare const RELAY_BACKOFF_MAX_MS = 15000;
 /** How long a socket may take to become `ready` before it is abandoned and retried (a server that accepts the
  * upgrade but never answers the hello would otherwise hang the tier forever). */
 export declare const RELAY_HANDSHAKE_TIMEOUT_MS = 10000;
+/** How often a ready socket pings the server to time the round trip - often enough that the diagnostics panel (which
+ * polls every few seconds) always has a recent sample, rarely enough to cost nothing next to the media. */
+export declare const RELAY_PING_INTERVAL_MS = 2000;
 export interface RelayClientOptions {
     url: string;
     peerId: string;
     createSocket: (url: string) => RelaySocket;
     random: () => number;
+    /** A monotonic millisecond clock for timing pings. Defaults to `Date.now`. */
+    now?: () => number;
     /** Called with the sender's peer id (as stamped by the server) and the original payload. */
     onMedia: (peerId: string, payload: Uint8Array) => void;
 }
@@ -42,10 +47,15 @@ export declare class RelayClient {
     private wanted;
     private reconnectTimer;
     private handshakeTimer;
+    private pingTimer;
+    private lastRoundTripMs;
     private readonly decoder;
     constructor(options: RelayClientOptions);
     /** True once the server has answered the hello on the current socket, i.e. media may be sent. */
     get ready(): boolean;
+    /** The most recent ping's round trip to the server, in milliseconds - `undefined` until the first pong on the
+     * current socket (and for good on a server too old to answer pings). */
+    get roundTripMs(): number | undefined;
     /** The largest message `sendMedia()` will send: what the server announced in `ready` (validated and clamped), or
      * `MAX_MESSAGE_BYTES` before that, without one, and again after every disconnect until the next `ready`. The
      * frame fragmenter sizes its fragments from this. */
@@ -62,6 +72,12 @@ export declare class RelayClient {
     private openSocket;
     private handleMessage;
     private handleText;
+    /** Times the round trip of the ping that `t` came back from. Ignored before ready, for a `t` that isn't a number,
+     * or one from the future (nothing this client sent). */
+    private handlePong;
+    private now;
+    /** Stops pinging and forgets the last round trip - it described a socket that is gone. */
+    private stopPinging;
     private handleClose;
     /** Detaches and closes the current socket, if any, so its late events can't reach this client. */
     private detach;

package/dist/apps/shared/relay/RelayClient.js

@@ -13,6 +13,10 @@
  * older one, which accepts `MAX_MESSAGE_BYTES`). Nothing else may be sent before `ready`.
  * - `{"op":"want","peers":[...]}` REPLACES the set of senders this socket receives from (the server accepts at most
  * `MAX_WANTED_PEERS`). It has to be re-sent after every reconnect, because the server's set dies with the socket.
+ * - `{"op":"ping","t":<this client's clock>}`, every `RELAY_PING_INTERVAL_MS` once ready, is answered with
+ * `{"op":"pong","t":<the same>}`, which times the round trip to the server (`roundTripMs`) - over the same socket as
+ * the media, so it includes whatever the media has queued ahead of it. An older server ignores the ping and the
+ * round trip stays unknown.
  * - A binary message from the client is an opaque payload of at most `maxMessageBytes`. The server forwards it to
  * every socket that wants this sender as `[1 byte N][N bytes UTF-8 sender peer id][payload]`, stamping the sender
  * itself so a peer cannot speak as another.
@@ -46,6 +50,9 @@ export const RELAY_BACKOFF_MAX_MS = 15000;
 /** How long a socket may take to become `ready` before it is abandoned and retried (a server that accepts the
  * upgrade but never answers the hello would otherwise hang the tier forever). */
 export const RELAY_HANDSHAKE_TIMEOUT_MS = 10000;
+/** How often a ready socket pings the server to time the round trip - often enough that the diagnostics panel (which
+ * polls every few seconds) always has a recent sample, rarely enough to cost nothing next to the media. */
+export const RELAY_PING_INTERVAL_MS = 2000;
 const SOCKET_OPEN = 1;
 /** Views `data` as bytes when it is binary (an `ArrayBuffer` or a typed array), else `undefined`. Uses
  * `Object.prototype.toString` rather than `instanceof` so it works for a buffer from another realm too. */
@@ -73,6 +80,11 @@ export class RelayClient {
     get ready() {
         return this.isReady;
     }
+    /** The most recent ping's round trip to the server, in milliseconds - `undefined` until the first pong on the
+     * current socket (and for good on a server too old to answer pings). */
+    get roundTripMs() {
+        return this.lastRoundTripMs;
+    }
     /** The largest message `sendMedia()` will send: what the server announced in `ready` (validated and clamped), or
      * `MAX_MESSAGE_BYTES` before that, without one, and again after every disconnect until the next `ready`. The
      * frame fragmenter sizes its fragments from this. */
@@ -125,6 +137,7 @@ export class RelayClient {
         clearTimeout(this.reconnectTimer);
         clearTimeout(this.handshakeTimer);
         this.reconnectTimer = this.handshakeTimer = undefined;
+        this.stopPinging();
         this.detach();
     }
     openSocket() {
@@ -176,7 +189,15 @@ export class RelayClient {
         catch {
             return;
         }
-        if (!message || typeof message !== "object" || message.op !== "ready" || this.isReady) {
+        if (!message || typeof message !== "object") {
+            return;
+        }
+        const op = message.op;
+        if (op === "pong") {
+            this.handlePong(message.t);
+            return;
+        }
+        if (op !== "ready" || this.isReady) {
             return;
         }
         this.isReady = true;
@@ -189,12 +210,34 @@ export class RelayClient {
         this.handshakeTimer = undefined;
         // The server's wanted set is per socket, so it starts empty on every (re)connect.
         this.sendText({ op: "want", peers: this.wanted });
+        this.pingTimer = setInterval(() => this.sendText({ op: "ping", t: this.now() }), RELAY_PING_INTERVAL_MS);
+    }
+    /** Times the round trip of the ping that `t` came back from. Ignored before ready, for a `t` that isn't a number,
+     * or one from the future (nothing this client sent). */
+    handlePong(t) {
+        if (!this.isReady || typeof t !== "number") {
+            return;
+        }
+        const roundTrip = this.now() - t;
+        if (roundTrip >= 0) {
+            this.lastRoundTripMs = roundTrip;
+        }
+    }
+    now() {
+        return (this.options.now ?? Date.now)();
+    }
+    /** Stops pinging and forgets the last round trip - it described a socket that is gone. */
+    stopPinging() {
+        clearInterval(this.pingTimer);
+        this.pingTimer = undefined;
+        this.lastRoundTripMs = undefined;
     }
     handleClose(socket) {
         if (socket !== this.socket) {
             return;
         }
         this.isReady = false;
+        this.stopPinging();
         // The next server might be a different one (a rolling upgrade), so the limit is learned afresh.
         this.messageLimit = MAX_MESSAGE_BYTES;
         clearTimeout(this.handshakeTimer);

package/dist/apps/shared/relay/RelayReceiver.d.ts

@@ -1,3 +1,4 @@
+import type { RelayReceiveDiagnostics } from "../webrtc/types.js";
 import type { AudioContextLike, RelayEnv } from "./relayEnv.js";
 /**
  * One remote participant as seen through the relay: reassembles their fragments, decodes them, and exposes the result
@@ -11,11 +12,15 @@ export declare class RelayReceiver {
     readonly stream: MediaStream;
     private readonly audioFrames;
     private readonly videoFrames;
+    private readonly audioCounter;
+    private readonly videoCounter;
     private readonly audio;
     private readonly video;
     constructor(env: RelayEnv, playbackContext: AudioContextLike);
     /** Handles one relayed payload from this sender (a media fragment). Anything malformed is ignored. */
     handleMedia(payload: Uint8Array): void;
+    /** A snapshot of what has been received from this peer - see `RelayReceiveDiagnostics`. */
+    diagnostics(): RelayReceiveDiagnostics;
     /** Releases the decoders and ends the stream's tracks. */
     close(): void;
 }

package/dist/apps/shared/relay/RelayReceiver.js

@@ -1,10 +1,29 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
 import { AudioPlayer } from "./AudioPlayer.js";
-import { decodeFragment, FrameReassembler, KIND_AUDIO } from "./frames.js";
+import { decodeFragment, FrameReassembler, KIND_AUDIO, seqIsNewer } from "./frames.js";
 import { VideoPlayer } from "./VideoPlayer.js";
+const SEQ_MODULUS = 0x10000;
+/** A jump in sequence numbers bigger than this is taken for the sender restarting its counter, not for that many
+ * lost frames. Ten seconds of 20 ms audio packets - far more than any real outage the stream would survive. */
+const MAX_COUNTED_SEQ_GAP = 500;
+/** Counts one kind's frames as they complete, and the ones the sequence numbers say never did. */
+class ReceiveCounter {
+    constructor() {
+        this.stats = { framesReceived: 0, framesLost: 0, bytesReceived: 0 };
+    }
+    fragment(bytes) {
+        this.stats.bytesReceived += bytes;
+    }
+    frame(frame) {
+        this.stats.framesReceived += 1;
+        if (this.lastSeq !== undefined && seqIsNewer(frame.seq, this.lastSeq)) {
+            const missing = ((frame.seq - this.lastSeq + SEQ_MODULUS) % SEQ_MODULUS) - 1;
+            if (missing <= MAX_COUNTED_SEQ_GAP) {
+                this.stats.framesLost += missing;
+            }
+        }
+        this.lastSeq = frame.seq;
+    }
+}
 /** The canvas is sized to the first decoded picture; until then it is this size. */
 const INITIAL_CANVAS_WIDTH = 320;
 const INITIAL_CANVAS_HEIGHT = 240;
@@ -22,6 +41,8 @@ export class RelayReceiver {
     constructor(env, playbackContext) {
         this.audioFrames = new FrameReassembler();
         this.videoFrames = new FrameReassembler();
+        this.audioCounter = new ReceiveCounter();
+        this.videoCounter = new ReceiveCounter();
         const destination = playbackContext.createMediaStreamDestination();
         this.audio = new AudioPlayer(env, playbackContext, destination);
         const canvas = env.createCanvas();
@@ -37,10 +58,14 @@ export class RelayReceiver {
         if (!fragment) {
             return;
         }
-        const frame = (fragment.kind === KIND_AUDIO ? this.audioFrames : this.videoFrames).push(fragment);
+        const isAudio = fragment.kind === KIND_AUDIO;
+        const counter = isAudio ? this.audioCounter : this.videoCounter;
+        counter.fragment(payload.length);
+        const frame = (isAudio ? this.audioFrames : this.videoFrames).push(fragment);
         if (!frame) {
             return;
         }
+        counter.frame(frame);
         if (frame.kind === KIND_AUDIO) {
             this.audio.push(frame);
         }
@@ -48,6 +73,13 @@ export class RelayReceiver {
             this.video?.push(frame);
         }
     }
+    /** A snapshot of what has been received from this peer - see `RelayReceiveDiagnostics`. */
+    diagnostics() {
+        return {
+            audio: { ...this.audioCounter.stats, ...this.audio.stats() },
+            video: { ...this.videoCounter.stats },
+        };
+    }
     /** Releases the decoders and ends the stream's tracks. */
     close() {
         this.audio.close();

package/dist/apps/shared/relay/RelaySender.d.ts

@@ -1,3 +1,5 @@
+import type { RelaySendDiagnostics, RelaySendStats } from "../webrtc/types.js";
+import { type FrameKind } from "./frames.js";
 import type { RelayEnv } from "./relayEnv.js";
 import type { PublishFrame } from "./senderCommon.js";
 /** Numbers and fragments the frames of one sender. The counters belong to the transport rather than to a capture
@@ -7,6 +9,8 @@ export declare class FramePublisher {
     private readonly send;
     private readonly maxMessageBytes;
     private readonly seqs;
+    /** What happened to each kind's frames - for the diagnostics panel. */
+    readonly stats: Record<FrameKind, RelaySendStats>;
     /** `send` returns whether one message was accepted by the socket. */
     /** `maxMessageBytes` is the largest message the socket may send right now (it changes when the server's `ready`
      * announces a limit), so it is read for every frame rather than fixed at construction. */
@@ -24,9 +28,12 @@ export interface RelaySenderOptions {
 }
 /** The publishing half of the relay: the two capture paths plus the frame numbering they share. */
 export declare class RelaySender {
+    private readonly publisher;
     private readonly audio;
     private readonly video;
     constructor(options: RelaySenderOptions);
+    /** A snapshot of the sending counters - see `RelaySendDiagnostics`. */
+    diagnostics(): RelaySendDiagnostics;
     /** Starts or stops encoding whatever tracks are set. Stopping releases the encoders and audio nodes. */
     setActive(active: boolean): void;
     /** `null` sends nothing for that kind. Safe before or after `setActive`. */

package/dist/apps/shared/relay/RelaySender.js

@@ -1,7 +1,3 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
-// SPDX-License-Identifier: MPL-2.0
-///////////////////////////////////////////////////////////////////////////////
 import { AudioSender } from "./AudioSender.js";
 import { DEFAULT_MESSAGE_BYTES, fragmentFrame, KIND_AUDIO, KIND_VIDEO } from "./frames.js";
 import { VideoSender } from "./VideoSender.js";
@@ -17,20 +13,30 @@ export class FramePublisher {
         this.send = send;
         this.maxMessageBytes = maxMessageBytes;
         this.seqs = { [KIND_AUDIO]: 0, [KIND_VIDEO]: 0 };
+        /** What happened to each kind's frames - for the diagnostics panel. */
+        this.stats = {
+            [KIND_AUDIO]: { framesSent: 0, framesDropped: 0, bytesSent: 0 },
+            [KIND_VIDEO]: { framesSent: 0, framesDropped: 0, bytesSent: 0 },
+        };
         /** Fragments and sends one frame, stopping at the first fragment the socket refuses (the rest could not be
          * used without it). Returns whether the whole frame went out. */
         this.publish = (kind, keyFrame, data, timestampMs) => {
             const seq = this.seqs[kind];
             this.seqs[kind] = (seq + 1) % SEQ_MODULUS;
+            const stats = this.stats[kind];
             const fragments = fragmentFrame(kind, keyFrame, seq, timestampMs, data, this.maxMessageBytes());
             if (fragments.length === 0) {
+                stats.framesDropped += 1;
                 return false;
             }
             for (const fragment of fragments) {
                 if (!this.send(fragment)) {
+                    stats.framesDropped += 1;
                     return false;
                 }
+                stats.bytesSent += fragment.length;
             }
+            stats.framesSent += 1;
             return true;
         };
     }
@@ -38,10 +44,19 @@ export class FramePublisher {
 /** The publishing half of the relay: the two capture paths plus the frame numbering they share. */
 export class RelaySender {
     constructor(options) {
-        const deps = { env: options.env, publish: new FramePublisher(options.send, options.maxMessageBytes).publish, canSend: options.canSend };
+        this.publisher = new FramePublisher(options.send, options.maxMessageBytes);
+        const deps = { env: options.env, publish: this.publisher.publish, canSend: options.canSend };
         this.audio = new AudioSender(deps);
         this.video = new VideoSender(deps);
     }
+    /** A snapshot of the sending counters - see `RelaySendDiagnostics`. */
+    diagnostics() {
+        return {
+            ...this.audio.captureStats(),
+            audio: { ...this.publisher.stats[KIND_AUDIO] },
+            video: { ...this.publisher.stats[KIND_VIDEO] },
+        };
+    }
     /** Starts or stops encoding whatever tracks are set. Stopping releases the encoders and audio nodes. */
     setActive(active) {
         this.audio.setActive(active);

package/dist/apps/shared/relay/RelayTransport.d.ts

@@ -1,3 +1,4 @@
+import type { RelayDiagnostics } from "../webrtc/types.js";
 import { type RelayEnv } from "./relayEnv.js";
 export interface RelayTransport {
     /** false when this browser lacks WebSocket, AudioEncoder/AudioDecoder/VideoEncoder/VideoDecoder, VideoFrame,
@@ -14,6 +15,9 @@ export interface RelayTransport {
     /** Same semantics as `MeshConnectionManager.setLocalTrack`: null = send nothing for that kind. Safe to call
      * before or after `setSending`. */
     setLocalTrack(kind: "audio" | "video", track: MediaStreamTrack | null): void;
+    /** The sending counters (shared by every peer) plus what has been received from `peerId`, for the diagnostics
+     * panel - cumulative, so a caller wanting a rate keeps the previous sample. */
+    diagnostics(peerId: string): RelayDiagnostics;
     /** Closes the socket, all coders, streams and timers. Idempotent. */
     close(): void;
 }

package/dist/apps/shared/relay/RelayTransport.js

@@ -37,6 +37,16 @@ const UNSUPPORTED_TRANSPORT = {
     stopReceivingFrom: () => undefined,
     setSending: () => undefined,
     setLocalTrack: () => undefined,
+    diagnostics: () => ({
+        send: {
+            audioCapturedMs: 0,
+            audioCaptureWallMs: 0,
+            audioSilentMs: 0,
+            audioEncoderSkippedMs: 0,
+            audio: { framesSent: 0, framesDropped: 0, bytesSent: 0 },
+            video: { framesSent: 0, framesDropped: 0, bytesSent: 0 },
+        },
+    }),
     close: () => undefined,
 };
 class WebSocketRelayTransport {
@@ -50,6 +60,7 @@ class WebSocketRelayTransport {
             peerId,
             createSocket: (target) => env.createSocket(target),
             random: () => env.random(),
+            now: () => env.now(),
             onMedia: (sender, payload) => this.receivers.get(sender)?.handleMedia(payload),
         });
         this.sender = new RelaySender({
@@ -95,6 +106,9 @@ class WebSocketRelayTransport {
             this.sender.setTrack(kind, track);
         }
     }
+    diagnostics(peerId) {
+        return { roundTripMs: this.client.roundTripMs, send: this.sender.diagnostics(), receive: this.receivers.get(peerId)?.diagnostics() };
+    }
     close() {
         if (this.closed) {
             return;

package/dist/apps/shared/relay/SilenceMeter.d.ts

@@ -0,0 +1,25 @@
+/** A sample this close to zero counts as silent: about -80 dBFS, well under the noise floor of any real microphone
+ * (even through noise suppression), so only digital silence - a zero-filled block - falls below it. */
+export declare const SILENCE_THRESHOLD = 0.0001;
+/** A run of silent samples counts only once it lasts this long, so a waveform merely crossing zero never does. */
+export declare const MIN_SILENT_RUN_SECONDS = 0.005;
+/**
+ * Measures how much of a PCM stream is digital silence, for the relay's diagnostics. A live microphone always carries
+ * some noise, so stretches of exact (or near-exact) zero mean the audio was lost or zero-filled somewhere on its way,
+ * not that the room went quiet. Runs are tracked across `feed()` calls, so a gap that straddles two blocks counts in
+ * full.
+ */
+export declare class SilenceMeter {
+    private totalSeconds;
+    private silentSeconds;
+    private run;
+    private runRate;
+    /** Adds one block of `sampleRate` Hz samples. */
+    feed(samples: Float32Array, sampleRate: number): void;
+    /** Milliseconds of audio fed so far. */
+    get totalMs(): number;
+    /** Milliseconds of it that were silent - including a silent run still in progress once it is long enough. */
+    get silentMs(): number;
+    private runSeconds;
+    private endRun;
+}

package/dist/apps/shared/relay/SilenceMeter.js

@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/** A sample this close to zero counts as silent: about -80 dBFS, well under the noise floor of any real microphone
+ * (even through noise suppression), so only digital silence - a zero-filled block - falls below it. */
+export const SILENCE_THRESHOLD = 1e-4;
+/** A run of silent samples counts only once it lasts this long, so a waveform merely crossing zero never does. */
+export const MIN_SILENT_RUN_SECONDS = 0.005;
+/**
+ * Measures how much of a PCM stream is digital silence, for the relay's diagnostics. A live microphone always carries
+ * some noise, so stretches of exact (or near-exact) zero mean the audio was lost or zero-filled somewhere on its way,
+ * not that the room went quiet. Runs are tracked across `feed()` calls, so a gap that straddles two blocks counts in
+ * full.
+ */
+export class SilenceMeter {
+    constructor() {
+        this.totalSeconds = 0;
+        this.silentSeconds = 0;
+        this.run = 0;
+        this.runRate = 0;
+    }
+    /** Adds one block of `sampleRate` Hz samples. */
+    feed(samples, sampleRate) {
+        if (sampleRate !== this.runRate) {
+            this.endRun();
+            this.runRate = sampleRate;
+        }
+        for (const sample of samples) {
+            if (Math.abs(sample) < SILENCE_THRESHOLD) {
+                this.run += 1;
+            }
+            else if (this.run > 0) {
+                this.endRun();
+            }
+        }
+        this.totalSeconds += samples.length / sampleRate;
+    }
+    /** Milliseconds of audio fed so far. */
+    get totalMs() {
+        return this.totalSeconds * 1000;
+    }
+    /** Milliseconds of it that were silent - including a silent run still in progress once it is long enough. */
+    get silentMs() {
+        return (this.silentSeconds + this.runSeconds(this.run)) * 1000;
+    }
+    runSeconds(run) {
+        const seconds = this.runRate > 0 ? run / this.runRate : 0;
+        return seconds >= MIN_SILENT_RUN_SECONDS ? seconds : 0;
+    }
+    endRun() {
+        this.silentSeconds += this.runSeconds(this.run);
+        this.run = 0;
+    }
+}

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

@@ -558,7 +558,11 @@ export class MeshConnectionManager {
     async pollDiagnostics(peer) {
         let diagnostics;
         try {
-            diagnostics = await peer.pc.collectDiagnostics();
+            const relay = this.options.relay;
+            diagnostics =
+                peer.transport === "websocket" && relay?.diagnostics
+                    ? fromRelayDiagnostics(relay.diagnostics(peer.uid))
+                    : await peer.pc.collectDiagnostics();
         }
         catch {
             // Leaves whatever was last polled in place rather than blanking a momentary failure.
@@ -636,6 +640,9 @@ export class MeshConnectionManager {
         });
         this.syncRelaySending();
         this.emit({ type: "participant-updated", participant: toParticipant(peer) });
+        if (relay.diagnostics) {
+            this.startDiagnosticsPolling(peer);
+        }
         if (notify) {
             this.send({ kind: "relay-fallback", to: peer.uid });
         }
@@ -806,6 +813,18 @@ function toParticipant(peer) {
         diagnostics: peer.diagnostics,
     };
 }
+/** A relayed pair's diagnostics: the relay's own counters, with the part that maps onto RTP stats (round trip, frames
+ * lost, bytes each way) also filled into the ordinary fields, so the panel's ordinary rows show it too. The round trip
+ * is to the relay server, not to the peer - see `RelayDiagnostics.roundTripMs`. */
+function fromRelayDiagnostics(relay) {
+    const { send, receive } = relay;
+    return {
+        roundTripTimeSeconds: relay.roundTripMs === undefined ? undefined : relay.roundTripMs / 1000,
+        audio: { packetsLost: receive?.audio.framesLost, bytesSent: send.audio.bytesSent, bytesReceived: receive?.audio.bytesReceived },
+        video: { packetsLost: receive?.video.framesLost, bytesSent: send.video.bytesSent, bytesReceived: receive?.video.bytesReceived },
+        relay,
+    };
+}
 function sameState(a, b) {
     return a.audioOn === b.audioOn && a.videoOn === b.videoOn && a.handRaised === b.handRaised;
 }

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

@@ -114,6 +114,66 @@ export interface ConnectionDiagnostics {
     roundTripTimeSeconds?: number;
     audio: RtpStreamDiagnostics;
     video: RtpStreamDiagnostics;
+    /** The WebSocket relay's own counters, present only for a `"websocket"` pair - `audio`/`video` then carry the
+     * subset of them that maps onto RTP stats (frames lost, bytes each way). */
+    relay?: RelayDiagnostics;
+}
+/** What the relay's sending half did with one kind of frame, cumulative since the relay transport was created. */
+export interface RelaySendStats {
+    framesSent: number;
+    /** Frames encoded but not sent: the socket was not ready, backed up, or refused a fragment. */
+    framesDropped: number;
+    bytesSent: number;
+}
+/** What the relay's sending half has done, cumulative since the relay transport was created. It is per browser, not
+ * per peer: every relayed peer receives the same stream. */
+export interface RelaySendDiagnostics {
+    /** Milliseconds of microphone audio the capture path delivered, against `audioCaptureWallMs` - the wall-clock time
+     * it was capturing for. Well short of it means capture is losing whole blocks. */
+    audioCapturedMs: number;
+    audioCaptureWallMs: number;
+    /** How much of `audioCapturedMs` was digital silence (see `SilenceMeter`) - a live microphone always has some
+     * noise, so a large share means the capture path is handing the encoder zero-filled blocks. */
+    audioSilentMs: number;
+    /** Milliseconds of captured audio not encoded because the encoder was too far behind. */
+    audioEncoderSkippedMs: number;
+    audio: RelaySendStats;
+    video: RelaySendStats;
+}
+/** What the relay's receiving half got of one kind of frame from one peer, cumulative. */
+export interface RelayReceiveStats {
+    framesReceived: number;
+    /** Frames the sequence numbers say never arrived complete - dropped by the sender, the server or in transit. */
+    framesLost: number;
+    bytesReceived: number;
+}
+/** What the relay's receiving half has done with one peer's media, cumulative since it started receiving from them. */
+export interface RelayReceiveDiagnostics {
+    audio: RelayReceiveStats & {
+        /** Milliseconds of decoded audio scheduled for playback. */
+        playedMs: number;
+        /** How much of `playedMs` was digital silence - silence that arrived inside the packets, i.e. the sender sent
+         * it, as opposed to `gapMs`. */
+        silentMs: number;
+        /** Times playback ran dry and restarted, and the total silence that inserted. */
+        gaps: number;
+        gapMs: number;
+        /** Packets dropped on arrival because the decoder was backed up or playback was already too far ahead. */
+        droppedLate: number;
+        /** How far ahead of the clock audio is scheduled right now - the receive buffer's current depth. */
+        bufferedMs: number;
+    };
+    video: RelayReceiveStats;
+}
+/** One sample of the relay's counters for one peer. */
+export interface RelayDiagnostics {
+    /** The latest round trip from this browser to the relay server, in milliseconds - not to the peer: the relay has
+     * no direct path between the two, and each end only knows its own leg. `undefined` before the first pong, or for
+     * a server too old to answer pings. */
+    roundTripMs?: number;
+    send: RelaySendDiagnostics;
+    /** `undefined` when nothing is being received from this peer. */
+    receive?: RelayReceiveDiagnostics;
 }
 /** The subset of `RTCRtpSender` `MeshConnectionManager.setLocalTrack()` uses. Every connection carries one audio and
  * one video sender for its whole life (see `MeshConnectionManager`'s doc comment), so turning a camera on or off,
@@ -183,6 +243,9 @@ export interface RelayTransportLike {
     setSending(active: boolean): void;
     /** Same as `MeshConnectionManager.setLocalTrack()` - `null` sends nothing for that kind. */
     setLocalTrack(kind: "audio" | "video", track: MediaStreamTrack | null): void;
+    /** The relay's counters as they stand for `peerId`, for the diagnostics panel. Optional so a test's fake relay
+     * needn't provide it; the mesh then shows nothing for a relayed pair. */
+    diagnostics?(peerId: string): RelayDiagnostics;
     close(): void;
 }
 /** `iceTransportPolicy` mirrors the real `RTCConfiguration` field of the same name - `"relay"` forces ICE to use
@@ -200,8 +263,9 @@ export interface MeshParticipant extends ParticipantState {
     /** How this participant's media currently reaches the local one - see `MediaTransport`. */
     transport: MediaTransport;
     /** This connection's most recently polled quality stats, for the diagnostics panel - `undefined` until the
-     * first poll completes (shortly after `transport` first leaves `"connecting"`), and never present at all for
-     * a `"websocket"`-relayed participant (there is no `RTCPeerConnection` to poll). */
+     * first poll completes (shortly after `transport` first leaves `"connecting"`, or the pair moves to the relay).
+     * For a `"websocket"`-relayed participant they come from the relay's own counters (`relay`) rather than an
+     * `RTCPeerConnection`. */
     diagnostics?: ConnectionDiagnostics;
 }
 export type MeshEvent = {

package/dist/lib/util/RelayHub.js

@@ -211,6 +211,16 @@ class Connection {
         else if (message.op === "want") {
             this.want(message);
         }
+        else if (message.op === "ping") {
+            this.ping(message);
+        }
+    }
+    /** Echoes a `ping`'s `t` straight back as a `pong`, so the client can time the round trip on its own clock. A
+     * ping without a finite number `t` is ignored. */
+    ping(message) {
+        if (typeof message.t === "number" && Number.isFinite(message.t)) {
+            this.sendText(JSON.stringify({ op: "pong", t: message.t }));
+        }
     }
     hello(message) {
         if (message.v !== RELAY_PROTOCOL_VERSION) {
@@ -287,11 +297,14 @@ class Connection {
  * same room replaces the older one, which is closed with 1008 "Replaced.".
  *
  * After that, `{"op":"want","peers":["<peerId>", ...]}` REPLACES the socket's interest set with the valid entries, at
- * most `RELAY_MAX_WANT_PEERS` of them; every other or malformed text message is ignored. Binary messages of 1 to
+ * most `RELAY_MAX_WANT_PEERS` of them, and `{"op":"ping","t":<number>}` is answered at once with
+ * `{"op":"pong","t":<the same number>}` (the client's own clock, never interpreted here - it lets the client time its
+ * round trip to the server, on the same socket and so behind the same queues as its media); every other or malformed
+ * text message, including a ping without a finite numeric `t`, is ignored. Binary messages of 1 to
  * `RelayHubOptions.maxPayloadBytes` bytes (`RELAY_MAX_PAYLOAD_BYTES` unless the route asked for more; opaque to the hub) are forwarded to every other socket of the room whose interest
  * set contains the sender's peer id; binary before `hello`, empty and oversized messages are dropped.
  *
- * Server to client: `{"op":"ready","v":1,"maxMessageBytes":N}` once, then binary messages `[1 byte: UTF-8 length N of the sender's peer
+ * Server to client: `{"op":"ready","v":1,"maxMessageBytes":N}` once, a `pong` for each ping, then binary messages `[1 byte: UTF-8 length N of the sender's peer
  * id][N bytes: the sender's peer id][the original payload]`. The sender is stamped by the hub from the `hello`,
  * never trusted from the payload.
  *