@rapidmx/meet-plugin 0.3.0 → 0.3.1

package/apps/meet/_CallView.tsx

@@ -93,8 +93,9 @@ export function computeMainUid(options: {
     return options.otherUids[0];
 }
 
-/** This tab's identity on the signaling channel: the account (or guest) uid plus a random suffix, so the same
- * account joining from two devices - or two tabs - is two participants rather than one that ignores itself. */
+/** This tab's identity in the call: the account (or guest) uid plus a random suffix, so the same account joining
+ * from two devices - or two tabs - is two participants rather than one that ignores itself. It travels as the
+ * `peer` of each message; `from` stays the exact authenticated uid, which the server requires. */
 export function newPeerId(selfUid: string): string {
     return `${selfUid}~${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
 }
@@ -137,7 +138,8 @@ export default function CallView({ channel, token, selfUid, selfName, meetingTit
         let cancelled = false;
         const client = new GuestSignalingClient({ channel, token });
         const manager = new MeshConnectionManager({
-            selfUid: peerId,
+            selfUid,
+            peerId,
             selfName,
             iceServers,
             channel: client,

package/apps/shared/webrtc/MeshConnectionManager.ts

@@ -75,8 +75,8 @@ import {
 } from "./types.js";
 
 /** The lexicographically smaller uid is always the offerer for that pair - see this module's doc comment. */
-export function isOfferer(selfUid: string, peerUid: string): boolean {
-    return selfUid < peerUid;
+export function isOfferer(selfId: string, peerId: string): boolean {
+    return selfId < peerId;
 }
 
 /** How many peers' worth of early ICE candidates are held, and how many candidates per peer - bounds the memory a
@@ -96,7 +96,11 @@ interface PeerState extends MeshParticipant {
 }
 
 export interface MeshConnectionManagerOptions {
+    /** The authenticated uid - what `from` must be on the wire (see `SignalMessage.from`). */
     selfUid: string;
+    /** This tab's identity in the call, `<selfUid>~<random>` - defaults to `selfUid`. Everything the manager keys on
+     * (the roster, who offers, who presents) is a peer id, so two tabs of one account are two participants. */
+    peerId?: string;
     selfName: string;
     iceServers: RTCIceServer[];
     channel: SignalingChannel;
@@ -122,8 +126,10 @@ export class MeshConnectionManager {
     private started = false;
     private stopped = false;
     private currentPresenterUid: string | undefined;
+    private readonly selfId: string;
 
     constructor(private readonly options: MeshConnectionManagerOptions) {
+        this.selfId = options.peerId ?? options.selfUid;
         this.localTracks = { audio: options.localAudioTrack ?? null, video: options.localVideoTrack ?? null };
         this.localState = {
             audioOn: !!options.localAudioTrack,
@@ -213,10 +219,10 @@ export class MeshConnectionManager {
      * else already presents - the caller (`_CallView.tsx`) uses this to disable its own "share screen" control
      * rather than let a claim silently do nothing. */
     claimPresenter(): boolean {
-        if (this.currentPresenterUid !== undefined && this.currentPresenterUid !== this.options.selfUid) {
+        if (this.currentPresenterUid !== undefined && this.currentPresenterUid !== this.selfId) {
             return false;
         }
-        this.currentPresenterUid = this.options.selfUid;
+        this.currentPresenterUid = this.selfId;
         this.send({ kind: "presenter-claim" });
         this.emit({ type: "presenter-changed", uid: this.currentPresenterUid });
         return true;
@@ -224,7 +230,7 @@ export class MeshConnectionManager {
 
     /** Releases presenter status - a no-op unless the local participant currently holds it. */
     releasePresenter(): void {
-        if (this.currentPresenterUid !== this.options.selfUid) {
+        if (this.currentPresenterUid !== this.selfId) {
             return;
         }
         this.currentPresenterUid = undefined;
@@ -237,7 +243,7 @@ export class MeshConnectionManager {
     }
 
     private send(partial: Omit<SignalMessage, "type" | "from">): void {
-        this.options.channel.send({ type: "video-meeting-signal", from: this.options.selfUid, ...partial });
+        this.options.channel.send({ type: "video-meeting-signal", from: this.options.selfUid, peer: this.selfId, ...partial });
     }
 
     private emit(event: MeshEvent): void {
@@ -246,11 +252,19 @@ export class MeshConnectionManager {
         }
     }
 
-    private handleMessage(message: SignalMessage): void {
-        if (message.type !== "video-meeting-signal" || message.from === this.options.selfUid) {
+    private handleMessage(raw: SignalMessage): void {
+        if (raw.type !== "video-meeting-signal") {
             return;
         }
-        if (message.to !== undefined && message.to !== this.options.selfUid) {
+        // From here on `from` is the sender's peer id - see `SignalMessage.peer`.
+        if (raw.peer !== undefined && raw.peer !== raw.from && !raw.peer.startsWith(`${raw.from}~`)) {
+            return;
+        }
+        const message: SignalMessage = { ...raw, from: raw.peer ?? raw.from };
+        if (message.from === this.selfId) {
+            return;
+        }
+        if (message.to !== undefined && message.to !== this.selfId) {
             return;
         }
         switch (message.kind) {
@@ -291,7 +305,7 @@ export class MeshConnectionManager {
             this.updatePeer(known, message.name, message.state);
             return;
         }
-        const offerer = isOfferer(this.options.selfUid, message.from);
+        const offerer = isOfferer(this.selfId, message.from);
         const peer = this.createPeer(message.from, message.name ?? message.from, message.state, offerer);
         this.emit({ type: "participant-joined", participant: toParticipant(peer) });
         // Let a newcomer who couldn't have seen our own original `hello` learn about us too - see this module's
@@ -481,12 +495,12 @@ export class MeshConnectionManager {
         // Collision: a claim from someone other than the presenter we already recorded. Resolve deterministically
         // - see this module's doc comment - so every participant converges on the same winner. When the
         // already-recorded presenter has the smaller uid, it wins and nothing changes here - including when that
-        // presenter is `this.options.selfUid` itself, whose own optimistic claim simply stays in place.
+        // presenter is this participant itself, whose own optimistic claim simply stays in place.
         if (from < this.currentPresenterUid) {
             const loser = this.currentPresenterUid;
             this.currentPresenterUid = from;
             this.emit({ type: "presenter-changed", uid: from });
-            if (loser === this.options.selfUid) {
+            if (loser === this.selfId) {
                 this.send({ kind: "presenter-release" });
             }
         }

package/apps/shared/webrtc/types.ts

@@ -45,10 +45,16 @@ export interface SignalMessage {
         | "presenter-release"
         | "state"
         | "reaction";
-    /** The sender's per-call peer id - `CallView` derives it from `VideoMeetingJoinResult.selfUid` plus a random
-     * suffix, so the same account joining from two devices (or two tabs) is two participants, not one that ignores
-     * its own messages. */
+    /** 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. */
     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`). */
+    peer?: string;
     /** Set only on a point-to-point message (`offer`/`answer`/`ice-candidate`). */
     to?: string;
     /** `hello` only - the display name the sender chose in the lobby. */

package/dist/apps/meet/_CallView.d.ts

@@ -54,7 +54,8 @@ export declare function computeMainUid(options: {
     activeSpeakerUid?: string;
     otherUids: readonly string[];
 }): string | undefined;
-/** This tab's identity on the signaling channel: the account (or guest) uid plus a random suffix, so the same
- * account joining from two devices - or two tabs - is two participants rather than one that ignores itself. */
+/** This tab's identity in the call: the account (or guest) uid plus a random suffix, so the same account joining
+ * from two devices - or two tabs - is two participants rather than one that ignores itself. It travels as the
+ * `peer` of each message; `from` stays the exact authenticated uid, which the server requires. */
 export declare function newPeerId(selfUid: string): string;
 export default function CallView({ channel, token, selfUid, selfName, meetingTitle, iceServers, media, onLeave }: CallViewProps): React.JSX.Element;

package/dist/apps/meet/_CallView.js

@@ -63,8 +63,9 @@ export function computeMainUid(options) {
     }
     return options.otherUids[0];
 }
-/** This tab's identity on the signaling channel: the account (or guest) uid plus a random suffix, so the same
- * account joining from two devices - or two tabs - is two participants rather than one that ignores itself. */
+/** This tab's identity in the call: the account (or guest) uid plus a random suffix, so the same account joining
+ * from two devices - or two tabs - is two participants rather than one that ignores itself. It travels as the
+ * `peer` of each message; `from` stays the exact authenticated uid, which the server requires. */
 export function newPeerId(selfUid) {
     return `${selfUid}~${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
 }
@@ -103,7 +104,8 @@ export default function CallView({ channel, token, selfUid, selfName, meetingTit
         let cancelled = false;
         const client = new GuestSignalingClient({ channel, token });
         const manager = new MeshConnectionManager({
-            selfUid: peerId,
+            selfUid,
+            peerId,
             selfName,
             iceServers,
             channel: client,

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

@@ -60,10 +60,14 @@
  */
 import { type MeshEvent, type MeshParticipant, type ParticipantState, type RTCPeerConnectionFactory, type SignalingChannel } from "./types.js";
 /** The lexicographically smaller uid is always the offerer for that pair - see this module's doc comment. */
-export declare function isOfferer(selfUid: string, peerUid: string): boolean;
+export declare function isOfferer(selfId: string, peerId: string): boolean;
 type MediaKind = "audio" | "video";
 export interface MeshConnectionManagerOptions {
+    /** The authenticated uid - what `from` must be on the wire (see `SignalMessage.from`). */
     selfUid: string;
+    /** This tab's identity in the call, `<selfUid>~<random>` - defaults to `selfUid`. Everything the manager keys on
+     * (the roster, who offers, who presents) is a peer id, so two tabs of one account are two participants. */
+    peerId?: string;
     selfName: string;
     iceServers: RTCIceServer[];
     channel: SignalingChannel;
@@ -89,6 +93,7 @@ export declare class MeshConnectionManager {
     private started;
     private stopped;
     private currentPresenterUid;
+    private readonly selfId;
     constructor(options: MeshConnectionManagerOptions);
     get participants(): MeshParticipant[];
     get presenterUid(): string | undefined;

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

@@ -64,8 +64,8 @@
  */
 import { REACTION_EMOJIS, } from "./types.js";
 /** The lexicographically smaller uid is always the offerer for that pair - see this module's doc comment. */
-export function isOfferer(selfUid, peerUid) {
-    return selfUid < peerUid;
+export function isOfferer(selfId, peerId) {
+    return selfId < peerId;
 }
 /** How many peers' worth of early ICE candidates are held, and how many candidates per peer - bounds the memory a
  * misbehaving participant could make this hold for peers that never materialize. */
@@ -79,6 +79,7 @@ export class MeshConnectionManager {
         this.orphanCandidates = new Map();
         this.started = false;
         this.stopped = false;
+        this.selfId = options.peerId ?? options.selfUid;
         this.localTracks = { audio: options.localAudioTrack ?? null, video: options.localVideoTrack ?? null };
         this.localState = {
             audioOn: !!options.localAudioTrack,
@@ -159,17 +160,17 @@ export class MeshConnectionManager {
      * else already presents - the caller (`_CallView.tsx`) uses this to disable its own "share screen" control
      * rather than let a claim silently do nothing. */
     claimPresenter() {
-        if (this.currentPresenterUid !== undefined && this.currentPresenterUid !== this.options.selfUid) {
+        if (this.currentPresenterUid !== undefined && this.currentPresenterUid !== this.selfId) {
             return false;
         }
-        this.currentPresenterUid = this.options.selfUid;
+        this.currentPresenterUid = this.selfId;
         this.send({ kind: "presenter-claim" });
         this.emit({ type: "presenter-changed", uid: this.currentPresenterUid });
         return true;
     }
     /** Releases presenter status - a no-op unless the local participant currently holds it. */
     releasePresenter() {
-        if (this.currentPresenterUid !== this.options.selfUid) {
+        if (this.currentPresenterUid !== this.selfId) {
             return;
         }
         this.currentPresenterUid = undefined;
@@ -180,18 +181,26 @@ export class MeshConnectionManager {
         this.send({ kind: "hello", name: this.options.selfName, state: this.localState });
     }
     send(partial) {
-        this.options.channel.send({ type: "video-meeting-signal", from: this.options.selfUid, ...partial });
+        this.options.channel.send({ type: "video-meeting-signal", from: this.options.selfUid, peer: this.selfId, ...partial });
     }
     emit(event) {
         for (const listener of [...this.listeners]) {
             listener(event);
         }
     }
-    handleMessage(message) {
-        if (message.type !== "video-meeting-signal" || message.from === this.options.selfUid) {
+    handleMessage(raw) {
+        if (raw.type !== "video-meeting-signal") {
             return;
         }
-        if (message.to !== undefined && message.to !== this.options.selfUid) {
+        // From here on `from` is the sender's peer id - see `SignalMessage.peer`.
+        if (raw.peer !== undefined && raw.peer !== raw.from && !raw.peer.startsWith(`${raw.from}~`)) {
+            return;
+        }
+        const message = { ...raw, from: raw.peer ?? raw.from };
+        if (message.from === this.selfId) {
+            return;
+        }
+        if (message.to !== undefined && message.to !== this.selfId) {
             return;
         }
         switch (message.kind) {
@@ -231,7 +240,7 @@ export class MeshConnectionManager {
             this.updatePeer(known, message.name, message.state);
             return;
         }
-        const offerer = isOfferer(this.options.selfUid, message.from);
+        const offerer = isOfferer(this.selfId, message.from);
         const peer = this.createPeer(message.from, message.name ?? message.from, message.state, offerer);
         this.emit({ type: "participant-joined", participant: toParticipant(peer) });
         // Let a newcomer who couldn't have seen our own original `hello` learn about us too - see this module's
@@ -411,12 +420,12 @@ export class MeshConnectionManager {
         // Collision: a claim from someone other than the presenter we already recorded. Resolve deterministically
         // - see this module's doc comment - so every participant converges on the same winner. When the
         // already-recorded presenter has the smaller uid, it wins and nothing changes here - including when that
-        // presenter is `this.options.selfUid` itself, whose own optimistic claim simply stays in place.
+        // presenter is this participant itself, whose own optimistic claim simply stays in place.
         if (from < this.currentPresenterUid) {
             const loser = this.currentPresenterUid;
             this.currentPresenterUid = from;
             this.emit({ type: "presenter-changed", uid: from });
-            if (loser === this.options.selfUid) {
+            if (loser === this.selfId) {
                 this.send({ kind: "presenter-release" });
             }
         }

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

@@ -29,10 +29,16 @@ export declare const REACTION_EMOJIS: readonly ["👍", "👏", "❤️", "🎉"
 export interface SignalMessage {
     type: "video-meeting-signal";
     kind: "hello" | "bye" | "offer" | "answer" | "ice-candidate" | "presenter-claim" | "presenter-release" | "state" | "reaction";
-    /** The sender's per-call peer id - `CallView` derives it from `VideoMeetingJoinResult.selfUid` plus a random
-     * suffix, so the same account joining from two devices (or two tabs) is two participants, not one that ignores
-     * its own messages. */
+    /** 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. */
     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`). */
+    peer?: string;
     /** Set only on a point-to-point message (`offer`/`answer`/`ice-candidate`). */
     to?: string;
     /** `hello` only - the display name the sender chose in the lobby. */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rapidmx/meet-plugin",
-    "version": "0.3.0",
+    "version": "0.3.1",
     "description": "RapidMX plugin that provides WebRTC video conferencing, joinable from a calendar invite or a shared link.",
     "repository": "https://github.com/RapidMX/meet-plugin.git",
     "author": "RapidREST <rapidrests@gmail.com>",