@droponair/sdk-js 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -6,6 +6,65 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.8.0], 2026-05-19
+
+### BREAKING
+
+- `sendGroupMessage(groupId, plaintext)` is **renamed to `sendCleartextGroupMessage(groupId, plaintext)`**. The previous JS method was cleartext-only despite the name, while the Android and iOS SDKs reserved the same name for an end-to-end encrypted send. This release aligns all three SDKs on the same naming.
+  - **Update existing JS callers**: replace `client.sendGroupMessage(groupId, text)` with `client.sendCleartextGroupMessage(groupId, text)`.
+
+### Added
+
+- **End-to-end encrypted group send.** New `sendGroupMessage(groupId, plaintext, memberUserIds, options?)` that mirrors the Android and iOS SDKs: the SDK encrypts the plaintext per-recipient-per-device (sender-side fan-out) before sending. Pass `options.attachments` for E2EE group attachments.
+- **Group attachments.** Both `sendGroupMessage` and the wire `GroupEnvelope` now carry an optional `attachments` field; previously this was 1:1 only on JS.
+
+### Fixed
+
+- **JS `GroupEnvelope` / `GroupMessageNotification` protobuf field numbers** now match the source-of-truth `messaging.proto`. The previous JS schema had a field-number drift versus the Android/iOS generated proto bindings, which meant group sends from JS arrived at the server with values in the wrong fields (and were silently tolerated by proto3's unknown-field handling). With this release JS group send/receive is wire-correct.
+
+### Notes
+
+- Wire protocol unchanged (PROTOCOL_VERSION stays 4). The proto schema was already correct; only the JS hand-rolled codec was out of sync.
+- `protoFieldNumbers` for the group types are now documented in `droponair-sdk-shared/test-vectors/protobuf-vectors.json` for cross-platform reference.
+
+---
+
+## [0.7.0], 2026-05-19
+
+### Added
+- **Conference moderation and waiting room.** Host designated to the call
+  initiator and transferable mid-call; host can appoint co-hosts. Host and
+  co-host can mute and remove participants and admit / reject users from a
+  waiting room. If the host leaves without transferring, the server
+  auto-promotes the longest-joined remaining participant.
+- New `client` methods:
+  - `transferHost(callId, groupId, newHostUserId)`
+  - `appointCoHost(callId, groupId, userId)` / `revokeCoHost(callId, groupId, userId)`
+  - `muteParticipant(callId, groupId, targetUserId)` (signaling hint; the
+    target SDK applies the mute locally)
+  - `removeParticipant(callId, groupId, targetUserId)` (server-enforced; the
+    target is dropped from the call session)
+  - `requestWaitingRoomEntry(callId, groupId)` (would-be joiner side)
+  - `admitFromWaitingRoom(callId, groupId, userId)` / `rejectFromWaitingRoom(callId, groupId, userId)`
+- New `GroupCallEventType` values: `'GROUP_CALL_HOST_TRANSFER'`,
+  `'GROUP_CALL_COHOST_APPOINT'`, `'GROUP_CALL_COHOST_REVOKE'`,
+  `'GROUP_CALL_ROLE_CHANGED'`, `'GROUP_CALL_MUTE_PARTICIPANT'`,
+  `'GROUP_CALL_REMOVE_PARTICIPANT'`, `'GROUP_CALL_PARTICIPANT_REMOVED'`,
+  `'GROUP_CALL_WAITING_ROOM_REQUEST'`, `'GROUP_CALL_WAITING_ROOM_JOINED'`,
+  `'GROUP_CALL_WAITING_ROOM_ADMIT'`, `'GROUP_CALL_WAITING_ROOM_ADMITTED'`,
+  `'GROUP_CALL_WAITING_ROOM_REJECT'`, `'GROUP_CALL_WAITING_ROOM_REJECTED'`.
+- `GET /api/info` now advertises `"moderation"` in the `features` array.
+
+### Notes
+- Wire-level additive: legacy 0.6.x clients ignore the new signal type
+  strings (string discriminators on the existing `GroupCallFrame.type`).
+  No proto schema change, no `PROTOCOL_VERSION` bump.
+- Availability depends on your plan. See the
+  [pricing page](https://www.droponair.com/pricing) and your dashboard
+  Subscription page for what's enabled on your app.
+
+---
+
 ## [0.6.0], 2026-05-18
 
 ### Added

package/README.md

@@ -160,7 +160,7 @@ client.onMessage(async (msg) => {
 | `sendMessage(toUserId, text, { attachments })` | `Promise<{ messageId }>` | Send with attachments |
 
 - E2EE: a random AES-256-GCM file key encrypts the bytes; the file key is wrapped per recipient device using X25519 + HKDF (same model as message payloads). Server never sees the unwrapped file key.
-- Plan limits: `maxAttachmentSizeMb` per file + `maxAttachmentsPerMonth`. Enforced server-side before the presigned URL is issued.
+- Availability and per-file / per-month limits depend on your plan and are enforced server-side before the presigned URL is issued. See the [pricing page](https://www.droponair.com/pricing) and your dashboard Subscription page for what's enabled on your app.
 - Upload URL TTL = 15 min. Download URL TTL = 5 min. Download authorization checks that the requester is the original sender or in the captured recipient list.
 
 ### Broadcast Channels
@@ -182,7 +182,8 @@ client.onMessage(async (msg) => {
 | `addGroupMembers(groupId, userIds)` | `Promise<GroupInfo>` | Add members (owner/admin) |
 | `removeGroupMember(groupId, userId)` | `Promise<GroupInfo>` | Remove a member (owner/admin) |
 | `deleteGroup(groupId)` | `Promise<void>` | Delete a group (owner only) |
-| `sendGroupMessage(groupId, plaintext)` | `Promise<{ messageId }>` | Send a group message |
+| `sendGroupMessage(groupId, plaintext, memberUserIds, options?)` | `Promise<{ messageId }>` | Send an end-to-end encrypted group message (sender-side per-recipient fan-out). `options.attachments` for E2EE group attachments. |
+| `sendCleartextGroupMessage(groupId, plaintext)` | `Promise<{ messageId }>` | Send a plaintext (non-encrypted) group message; server fans out to every other member. |
 | `onGroupMessage(callback)` | `() => void` | Listen for group messages |
 
 ### 1-to-1 Calls
@@ -252,7 +253,46 @@ client.onGroupCallEvent((evt) => {
 
 - The server enforces **one concurrent sharer per group call**. If another participant already holds the slot when you call `startGroupScreenShare`, the SDK delivers a `GROUP_CALL_SCREEN_SHARE_STOPPED` event with the current holder's userId in `payload`, so you can roll back the optimistic UI.
 - When a sharer leaves the call, the server broadcasts a STOPPED event to remaining participants before they see `PARTICIPANT_LEFT`.
-- Plan gate: `screen_sharing` is on `PRO`/`GROWTH`/`PAYG`/`ENTERPRISE`, off on `FREE`. Read `subscription.featuresEnabled.screen_sharing` on your backend to decide whether to expose the share button.
+- Availability depends on your plan. See the [pricing page](https://www.droponair.com/pricing) and your dashboard Subscription page for what's enabled on your app.
+
+### Conference moderation and waiting room
+
+Available since SDK `0.7.0`. The call initiator is the default host; host can transfer the role mid-call or appoint co-hosts. Host and co-host can mute, remove, and gate joiners through a waiting room. If the host leaves without transferring, the server auto-promotes the longest-joined remaining participant and broadcasts `GROUP_CALL_ROLE_CHANGED`.
+
+```typescript
+// Host actions
+client.transferHost(callId, groupId, 'alice');
+client.appointCoHost(callId, groupId, 'bob');
+client.muteParticipant(callId, groupId, 'eve');           // signaling hint
+client.removeParticipant(callId, groupId, 'mallory');     // server-enforced drop
+
+// Waiting room
+client.requestWaitingRoomEntry(callId, groupId);          // would-be joiner side
+client.admitFromWaitingRoom(callId, groupId, 'newbie');   // host / co-host
+client.rejectFromWaitingRoom(callId, groupId, 'troll');
+
+client.onGroupCallEvent((evt) => {
+  if (evt.type === 'GROUP_CALL_ROLE_CHANGED')          updateHostUi(evt.payload);   // {"userId":"...","role":"HOST|CO_HOST|PARTICIPANT"}
+  if (evt.type === 'GROUP_CALL_WAITING_ROOM_JOINED')   showWaitingApprovalPrompt(evt.payload);
+  if (evt.type === 'GROUP_CALL_WAITING_ROOM_ADMITTED') joinTheCall(evt.callId, evt.groupId);
+  if (evt.type === 'GROUP_CALL_MUTE_PARTICIPANT')      muteMyMicLocally();
+  if (evt.type === 'GROUP_CALL_PARTICIPANT_REMOVED')   exitCallUi();
+});
+```
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `transferHost(callId, groupId, newHostUserId)` | `void` | Host only |
+| `appointCoHost(callId, groupId, userId)` | `void` | Host only |
+| `revokeCoHost(callId, groupId, userId)` | `void` | Host only |
+| `muteParticipant(callId, groupId, targetUserId)` | `void` | Host / co-host. Signaling hint - the target SDK mutes the local mic. |
+| `removeParticipant(callId, groupId, targetUserId)` | `void` | Host / co-host. Server drops the target from the call session. |
+| `requestWaitingRoomEntry(callId, groupId)` | `void` | Would-be joiner |
+| `admitFromWaitingRoom(callId, groupId, userId)` | `void` | Host / co-host |
+| `rejectFromWaitingRoom(callId, groupId, userId)` | `void` | Host / co-host |
+
+- Mute is intentionally a signaling hint: WebRTC media tracks can't be muted from outside the producing client. Remove is server-enforced - the target SDK receives `GROUP_CALL_PARTICIPANT_REMOVED` and the others receive `PARTICIPANT_LEFT`.
+- Availability depends on your plan. See the [pricing page](https://www.droponair.com/pricing) and your dashboard Subscription page for what's enabled on your app.
 
 ## Security
 

package/dist/attachment/attachment-client.d.ts

@@ -21,8 +21,8 @@ interface AttachmentClientDeps {
     logError: (stage: string, data?: Record<string, unknown>) => void;
 }
 /**
- * SDK-side coordinator for phase1/attachments. Handles:
- *  - createUploadSession: reserves an attachmentId + presigned PUT URL via sdk-be.
+ * SDK-side coordinator for attachments. Handles:
+ *  - createUploadSession: reserves an attachmentId + presigned PUT URL.
  *  - uploadBytes: PUTs bytes directly to the customer's bucket.
  *  - finalize: confirms upload + commits sha256.
  *  - prepareAttachmentAndUpload: convenience wrapper that does upload session,

package/dist/attachment/attachment-client.js

@@ -20,8 +20,8 @@ async function sha256Hex(bytes) {
     return hex.join('');
 }
 /**
- * SDK-side coordinator for phase1/attachments. Handles:
- *  - createUploadSession: reserves an attachmentId + presigned PUT URL via sdk-be.
+ * SDK-side coordinator for attachments. Handles:
+ *  - createUploadSession: reserves an attachmentId + presigned PUT URL.
  *  - uploadBytes: PUTs bytes directly to the customer's bucket.
  *  - finalize: confirms upload + commits sha256.
  *  - prepareAttachmentAndUpload: convenience wrapper that does upload session,

package/dist/attachment/attachment-types.js

@@ -4,7 +4,7 @@
 //
 // DropOnAir never holds file bytes. The SDK uploads/downloads directly
 // against the customer's storage bucket via short-lived presigned URLs
-// minted by sdk-be. For E2EE messages a per-attachment AES-256-GCM file
+// minted by the DropOnAir platform. For E2EE messages a per-attachment AES-256-GCM file
 // key is wrapped per recipient device using the same X25519 + HKDF path
 // used for message payloads.
 // ---------------------------------------------------------------------------

package/dist/core/messaging-client.d.ts

@@ -127,7 +127,32 @@ export declare class MessagingClient implements DropOnAirClient {
     addGroupMembers(groupId: string, userIds: string[]): Promise<GroupInfo>;
     removeGroupMember(groupId: string, userId: string): Promise<GroupInfo>;
     deleteGroup(groupId: string): Promise<void>;
-    sendGroupMessage(groupId: string, plaintext: string): Promise<{
+    /**
+     * Send an end-to-end encrypted group message. Mirrors the Android and iOS
+     * SDKs: the SDK encrypts the plaintext per recipient device (sender-side
+     * fan-out), producing one `GroupMemberPayload` per member that the server
+     * then routes to that member's devices without ever seeing the plaintext.
+     *
+     * `memberUserIds` should be the current group membership minus the sender;
+     * fetch it from your backend / `getGroup()` before calling.
+     *
+     * For unencrypted group messaging (bots, public channels), use
+     * {@link sendCleartextGroupMessage} instead.
+     */
+    sendGroupMessage(groupId: string, plaintext: string, memberUserIds: string[], options?: {
+        attachments?: AttachmentRef[];
+    }): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Send a plaintext (non-encrypted) group message. The server fans out the
+     * cleartext to every other member of the group; useful for bots and public
+     * channels where E2EE isn't required.
+     *
+     * For E2EE group messaging, use {@link sendGroupMessage} which encrypts
+     * per-recipient before sending.
+     */
+    sendCleartextGroupMessage(groupId: string, plaintext: string): Promise<{
         messageId: string;
     }>;
     onGroupMessage(callback: GroupMessageCallback): () => void;
@@ -139,6 +164,14 @@ export declare class MessagingClient implements DropOnAirClient {
     startGroupScreenShare(callId: string, groupId: string, payload?: string): void;
     stopGroupScreenShare(callId: string, groupId: string, payload?: string): void;
     onGroupCallEvent(callback: GroupCallEventCallback): () => void;
+    transferHost(callId: string, groupId: string, newHostUserId: string): void;
+    appointCoHost(callId: string, groupId: string, userId: string): void;
+    revokeCoHost(callId: string, groupId: string, userId: string): void;
+    muteParticipant(callId: string, groupId: string, targetUserId: string): void;
+    removeParticipant(callId: string, groupId: string, targetUserId: string): void;
+    requestWaitingRoomEntry(callId: string, groupId: string): void;
+    admitFromWaitingRoom(callId: string, groupId: string, userId: string): void;
+    rejectFromWaitingRoom(callId: string, groupId: string, userId: string): void;
     private sendGroupCallFrame;
     /**
      * Initiate an outgoing call.

package/dist/core/messaging-client.js

@@ -254,7 +254,7 @@ class MessagingClient {
             logError: (stage, data) => this.logError(stage, data),
         });
     }
-    // Attachment API (phase1/attachments, PROTOCOL_VERSION 4+)
+    // Attachment API (PROTOCOL_VERSION 4+)
     async prepareAttachmentAndUpload(bytes, options) {
         return this.attachmentClient.prepareAttachmentAndUpload(bytes, options);
     }
@@ -679,7 +679,19 @@ class MessagingClient {
     // ---------------------------------------------------------------------------
     // Group messaging
     // ---------------------------------------------------------------------------
-    async sendGroupMessage(groupId, plaintext) {
+    /**
+     * Send an end-to-end encrypted group message. Mirrors the Android and iOS
+     * SDKs: the SDK encrypts the plaintext per recipient device (sender-side
+     * fan-out), producing one `GroupMemberPayload` per member that the server
+     * then routes to that member's devices without ever seeing the plaintext.
+     *
+     * `memberUserIds` should be the current group membership minus the sender;
+     * fetch it from your backend / `getGroup()` before calling.
+     *
+     * For unencrypted group messaging (bots, public channels), use
+     * {@link sendCleartextGroupMessage} instead.
+     */
+    async sendGroupMessage(groupId, plaintext, memberUserIds, options) {
         if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
             throw new Error('DropOnAir websocket is not connected');
         }
@@ -692,20 +704,110 @@ class MessagingClient {
         if (this.dropOnAirJwt && (0, bytes_1.isJwtExpired)(this.dropOnAirJwt)) {
             throw new Error('JWT_EXPIRED: Secure messaging session is reconnecting; please retry in a moment');
         }
+        if (!memberUserIds || memberUserIds.length === 0) {
+            throw new Error('sendGroupMessage requires at least one recipient userId in memberUserIds');
+        }
         const myDeviceId = this.deviceId ?? await this.getOrCreateDeviceId();
         const messageId = crypto.randomUUID();
+        const clientMessageId = messageId;
         const timestamp = Date.now();
-        // For now, group messages use cleartext (E2EE group fanout requires
-        // fetching device keys for every member, which is a future enhancement).
+        const myIdentity = await this.cryptoService.getOrCreateIdentity();
+        const myPublicKeyBytes = (0, bytes_1.fromBase64)(myIdentity.publicKey);
+        // Per-member sender-side fan-out: one GroupMemberPayload per member, each
+        // containing one DeviceEncryptedPayload per device the member has registered.
+        const memberPayloads = [];
+        for (const memberId of memberUserIds) {
+            if (memberId === this.currentUserId)
+                continue; // skip self
+            const deviceKeys = await this.fetchDeviceKeys(memberId);
+            const devicePayloads = [];
+            if (deviceKeys.length > 0) {
+                for (const dk of deviceKeys) {
+                    const sharedKey = await this.cryptoService.deriveSharedSecret(memberId, dk.publicKey, this.currentUserId);
+                    const encrypted = await this.cryptoService.encrypt(plaintext, sharedKey, {
+                        messageId,
+                        senderId: this.currentUserId,
+                        recipientId: memberId,
+                        timestamp,
+                    });
+                    devicePayloads.push({
+                        deviceId: dk.deviceId,
+                        encryptedPayload: encrypted,
+                        senderPublicKey: myPublicKeyBytes,
+                    });
+                }
+            }
+            else {
+                // Legacy fallback: peer reports no multi-device keys. Encrypt once
+                // against the single legacy public key under deviceId="default", which
+                // matches the Android SDK convention.
+                const sharedKey = await this.getPeerSharedKey(memberId);
+                const encrypted = await this.cryptoService.encrypt(plaintext, sharedKey, {
+                    messageId,
+                    senderId: this.currentUserId,
+                    recipientId: memberId,
+                    timestamp,
+                });
+                devicePayloads.push({
+                    deviceId: 'default',
+                    encryptedPayload: encrypted,
+                    senderPublicKey: myPublicKeyBytes,
+                });
+            }
+            memberPayloads.push({ userId: memberId, devicePayloads });
+        }
         const frame = {
             messageId,
+            appId: this.options.appId,
             groupId,
             fromUserId: this.currentUserId,
+            timestamp,
+            clientMessageId,
+            senderDeviceId: myDeviceId,
+            encryptionType: 0, // E2EE
+            memberPayloads,
+        };
+        if (options?.attachments && options.attachments.length > 0) {
+            frame.attachments = options.attachments.map(a => this.attachmentClient.toWire(a));
+        }
+        this.ws.send(this.codec.encodeGroupEnvelope(frame));
+        return { messageId };
+    }
+    /**
+     * Send a plaintext (non-encrypted) group message. The server fans out the
+     * cleartext to every other member of the group; useful for bots and public
+     * channels where E2EE isn't required.
+     *
+     * For E2EE group messaging, use {@link sendGroupMessage} which encrypts
+     * per-recipient before sending.
+     */
+    async sendCleartextGroupMessage(groupId, plaintext) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('DropOnAir websocket is not connected');
+        }
+        if (!this.currentUserId) {
+            throw new Error('Missing sender identity from DropOnAir JWT subject');
+        }
+        if (this.rateLimited) {
+            throw new Error('Sending is temporarily blocked by LIMIT_REACHED');
+        }
+        if (this.dropOnAirJwt && (0, bytes_1.isJwtExpired)(this.dropOnAirJwt)) {
+            throw new Error('JWT_EXPIRED: Secure messaging session is reconnecting; please retry in a moment');
+        }
+        const myDeviceId = this.deviceId ?? await this.getOrCreateDeviceId();
+        const messageId = crypto.randomUUID();
+        const timestamp = Date.now();
+        const frame = {
+            messageId,
+            appId: this.options.appId,
+            groupId,
+            fromUserId: this.currentUserId,
+            timestamp,
+            clientMessageId: messageId,
             senderDeviceId: myDeviceId,
-            memberPayloads: [],
             encryptionType: 1, // CLEARTEXT
             plaintextPayload: plaintext,
-            timestamp,
+            memberPayloads: [],
         };
         this.ws.send(this.codec.encodeGroupEnvelope(frame));
         return { messageId };
@@ -762,6 +864,81 @@ class MessagingClient {
         this.groupCallListeners.add(callback);
         return () => this.groupCallListeners.delete(callback);
     }
+    // Group call moderation + waiting room. The server validates host/co-host
+    // authority and the `featuresEnabled.moderation` plan flag; on denial it
+    // emits a LIMIT_REACHED event with reason="MODERATION_NOT_ENABLED".
+    transferHost(callId, groupId, newHostUserId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_HOST_TRANSFER',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ userId: newHostUserId }),
+        });
+    }
+    appointCoHost(callId, groupId, userId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_COHOST_APPOINT',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ userId }),
+        });
+    }
+    revokeCoHost(callId, groupId, userId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_COHOST_REVOKE',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ userId }),
+        });
+    }
+    muteParticipant(callId, groupId, targetUserId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_MUTE_PARTICIPANT',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ targetUserId }),
+        });
+    }
+    removeParticipant(callId, groupId, targetUserId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_REMOVE_PARTICIPANT',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ targetUserId }),
+        });
+    }
+    requestWaitingRoomEntry(callId, groupId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_WAITING_ROOM_REQUEST',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: '',
+        });
+    }
+    admitFromWaitingRoom(callId, groupId, userId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_WAITING_ROOM_ADMIT',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ userId }),
+        });
+    }
+    rejectFromWaitingRoom(callId, groupId, userId) {
+        this.sendGroupCallFrame({
+            type: 'GROUP_CALL_WAITING_ROOM_REJECT',
+            callId,
+            groupId,
+            targetUserId: '',
+            payload: JSON.stringify({ userId }),
+        });
+    }
     sendGroupCallFrame(frame) {
         if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
             throw new Error('DropOnAir websocket is not connected');

package/dist/core/types.d.ts

@@ -11,7 +11,7 @@ export interface DecryptedMessage {
     timestamp: number;
     plaintext: string;
     /**
-     * Attachment pointers (phase1/attachments, PROTOCOL_VERSION 4+).
+     * Attachment pointers (PROTOCOL_VERSION 4+).
      * Empty/undefined for messages with no attachments. To fetch and decrypt the
      * bytes, call {@code client.downloadAttachment(ref)}.
      */
@@ -92,7 +92,7 @@ export interface DecryptedGroupMessage {
     plaintext: string;
 }
 export type GroupMessageCallback = (message: DecryptedGroupMessage) => void;
-export type GroupCallEventType = 'GROUP_CALL_INVITE' | 'GROUP_CALL_RINGING' | 'GROUP_CALL_JOIN' | 'GROUP_CALL_LEAVE' | 'GROUP_CALL_END' | 'GROUP_CALL_ENDED' | 'GROUP_CALL_PARTICIPANT_JOINED' | 'GROUP_CALL_PARTICIPANT_LEFT' | 'GROUP_CALL_ALREADY_ACTIVE' | 'GROUP_CALL_SDP_OFFER' | 'GROUP_CALL_SDP_ANSWER' | 'GROUP_CALL_ICE_CANDIDATE' | 'GROUP_CALL_SCREEN_SHARE_STARTED' | 'GROUP_CALL_SCREEN_SHARE_STOPPED';
+export type GroupCallEventType = 'GROUP_CALL_INVITE' | 'GROUP_CALL_RINGING' | 'GROUP_CALL_JOIN' | 'GROUP_CALL_LEAVE' | 'GROUP_CALL_END' | 'GROUP_CALL_ENDED' | 'GROUP_CALL_PARTICIPANT_JOINED' | 'GROUP_CALL_PARTICIPANT_LEFT' | 'GROUP_CALL_PARTICIPANT_REMOVED' | 'GROUP_CALL_ALREADY_ACTIVE' | 'GROUP_CALL_SDP_OFFER' | 'GROUP_CALL_SDP_ANSWER' | 'GROUP_CALL_ICE_CANDIDATE' | 'GROUP_CALL_SCREEN_SHARE_STARTED' | 'GROUP_CALL_SCREEN_SHARE_STOPPED' | 'GROUP_CALL_HOST_TRANSFER' | 'GROUP_CALL_COHOST_APPOINT' | 'GROUP_CALL_COHOST_REVOKE' | 'GROUP_CALL_ROLE_CHANGED' | 'GROUP_CALL_MUTE_PARTICIPANT' | 'GROUP_CALL_REMOVE_PARTICIPANT' | 'GROUP_CALL_WAITING_ROOM_REQUEST' | 'GROUP_CALL_WAITING_ROOM_JOINED' | 'GROUP_CALL_WAITING_ROOM_ADMIT' | 'GROUP_CALL_WAITING_ROOM_ADMITTED' | 'GROUP_CALL_WAITING_ROOM_REJECT' | 'GROUP_CALL_WAITING_ROOM_REJECTED';
 export interface GroupCallEvent {
     type: GroupCallEventType | string;
     callId: string;
@@ -214,7 +214,7 @@ export interface DropOnAirClient {
     sendCallSignal(type: 'CALL_SDP_OFFER' | 'CALL_SDP_ANSWER' | 'CALL_ICE_CANDIDATE', callId: string, payload: string): void;
     /**
      * Signal that this user started sharing their screen in a 1:1 call
-     * (phase1/screen-sharing, PROTOCOL_VERSION 4+). The actual screen MediaStreamTrack
+     * (PROTOCOL_VERSION 4+). The actual screen MediaStreamTrack
      * is added to the existing peer connection by the application; the SDK only
      * broadcasts the start/stop notification so the remote SDK can update its UI.
      * Optional `payload` (JSON string) can carry track-id or app-specific metadata.
@@ -238,8 +238,23 @@ export interface DropOnAirClient {
     removeGroupMember(groupId: string, userId: string): Promise<GroupInfo>;
     /** Delete a group (requires OWNER role). */
     deleteGroup(groupId: string): Promise<void>;
-    /** Send a cleartext message to a group. */
-    sendGroupMessage(groupId: string, plaintext: string): Promise<{
+    /**
+     * Send an end-to-end encrypted group message. The SDK encrypts the
+     * plaintext per recipient device (sender-side fan-out) before sending.
+     * `memberUserIds` should be the current group membership minus the sender;
+     * pass `options.attachments` for per-recipient encrypted attachment refs.
+     */
+    sendGroupMessage(groupId: string, plaintext: string, memberUserIds: string[], options?: {
+        attachments?: import('../attachment/attachment-types').AttachmentRef[];
+    }): Promise<{
+        messageId: string;
+    }>;
+    /**
+     * Send a plaintext (non-encrypted) group message. The server fans out the
+     * cleartext to every other member. Use this for bots and public channels;
+     * use {@link sendGroupMessage} for E2EE group messaging.
+     */
+    sendCleartextGroupMessage(groupId: string, plaintext: string): Promise<{
         messageId: string;
     }>;
     /** Register a listener for incoming group messages. Returns an unsubscribe function. */
@@ -266,4 +281,20 @@ export interface DropOnAirClient {
     stopGroupScreenShare(callId: string, groupId: string, payload?: string): void;
     /** Register a listener for group call events. Returns an unsubscribe function. */
     onGroupCallEvent(callback: GroupCallEventCallback): () => void;
+    /** Transfer host to another participant (current host only). */
+    transferHost(callId: string, groupId: string, newHostUserId: string): void;
+    /** Appoint a participant as co-host (host only). */
+    appointCoHost(callId: string, groupId: string, userId: string): void;
+    /** Revoke a participant's co-host status (host only). */
+    revokeCoHost(callId: string, groupId: string, userId: string): void;
+    /** Mute a participant's mic (host / co-host). Signaling hint; the target SDK applies it locally. */
+    muteParticipant(callId: string, groupId: string, targetUserId: string): void;
+    /** Remove a participant from the call (host / co-host). Server-enforced. */
+    removeParticipant(callId: string, groupId: string, targetUserId: string): void;
+    /** Request entry into a call's waiting room. Sent by would-be joiners; host receives WAITING_ROOM_JOINED. */
+    requestWaitingRoomEntry(callId: string, groupId: string): void;
+    /** Admit a user from the waiting room (host / co-host). */
+    admitFromWaitingRoom(callId: string, groupId: string, userId: string): void;
+    /** Reject a user waiting to join (host / co-host). */
+    rejectFromWaitingRoom(callId: string, groupId: string, userId: string): void;
 }

package/dist/transport/protobuf-codec.d.ts

@@ -82,23 +82,27 @@ export interface WireGroupMemberPayload {
 }
 export interface WireGroupEnvelope {
     messageId: string;
+    appId?: string;
     groupId: string;
     fromUserId: string;
+    timestamp: number;
+    clientMessageId?: string;
     senderDeviceId: string;
-    memberPayloads: WireGroupMemberPayload[];
     encryptionType: number;
     plaintextPayload?: string;
-    timestamp: number;
+    memberPayloads: WireGroupMemberPayload[];
+    attachments?: WireAttachmentRef[];
 }
 export interface WireGroupMessageNotification {
     messageId: string;
     groupId: string;
     fromUserId: string;
-    senderDeviceId: string;
-    devicePayloads: WireDeviceEncryptedPayload[];
+    timestamp: number;
     encryptionType: number;
     plaintextPayload?: string;
-    timestamp: number;
+    devicePayloads: WireDeviceEncryptedPayload[];
+    senderDeviceId: string;
+    attachments?: WireAttachmentRef[];
 }
 export interface WireGroupAck {
     messageId: string;

package/dist/transport/protobuf-codec.js

@@ -124,20 +124,22 @@ const GroupMemberPayloadType = new protobuf.Type('GroupMemberPayload')
     .add(new protobuf.Field('userId', 1, 'string'))
     .add(new protobuf.Field('devicePayloads', 2, 'DeviceEncryptedPayload', 'repeated'));
 const GroupEnvelopeEncryptionTypeEnum = new protobuf.Enum('EncryptionType', { E2EE: 0, CLEARTEXT: 1 });
-// NOTE: GroupEnvelope JS field numbers diverge from the proto contract (tracked
-// under phase 2.3 "JS encrypted group send parity"). Attachments support for
-// groups in JS will land with phase 2.3 / 2.4 once field numbers are aligned.
 const GroupEnvelopeType = new protobuf.Type('GroupEnvelope')
     .add(GroupEnvelopeEncryptionTypeEnum)
     .add(GroupMemberPayloadType)
+    .add(AttachmentRefType)
     .add(new protobuf.Field('messageId', 1, 'string'))
-    .add(new protobuf.Field('groupId', 2, 'string'))
-    .add(new protobuf.Field('fromUserId', 3, 'string'))
-    .add(new protobuf.Field('senderDeviceId', 4, 'string'))
-    .add(new protobuf.Field('memberPayloads', 5, 'GroupMemberPayload', 'repeated'))
-    .add(new protobuf.Field('encryptionType', 6, 'EncryptionType'))
-    .add(new protobuf.Field('plaintextPayload', 7, 'string'))
-    .add(new protobuf.Field('timestamp', 8, 'int64'));
+    .add(new protobuf.Field('appId', 2, 'string'))
+    .add(new protobuf.Field('groupId', 3, 'string'))
+    .add(new protobuf.Field('fromUserId', 4, 'string'))
+    .add(new protobuf.Field('timestamp', 5, 'int64'))
+    .add(new protobuf.Field('clientMessageId', 6, 'string'))
+    .add(new protobuf.Field('senderDeviceId', 7, 'string'))
+    .add(new protobuf.Field('encryptionType', 8, 'EncryptionType'))
+    .add(new protobuf.Field('plaintextPayload', 9, 'string'))
+    .add(new protobuf.Field('memberPayloads', 10, 'GroupMemberPayload', 'repeated'))
+    // field 11 reserved upstream
+    .add(new protobuf.Field('attachments', 12, 'AttachmentRef', 'repeated'));
 const GroupNotifEncryptionTypeEnum = new protobuf.Enum('EncryptionType', { E2EE: 0, CLEARTEXT: 1 });
 const GroupNotifDeviceType = new protobuf.Type('DeviceEncryptedPayload')
     .add(new protobuf.Field('deviceId', 1, 'string'))
@@ -149,11 +151,12 @@ const GroupMessageNotificationType = new protobuf.Type('GroupMessageNotification
     .add(new protobuf.Field('messageId', 1, 'string'))
     .add(new protobuf.Field('groupId', 2, 'string'))
     .add(new protobuf.Field('fromUserId', 3, 'string'))
-    .add(new protobuf.Field('senderDeviceId', 4, 'string'))
-    .add(new protobuf.Field('devicePayloads', 5, 'DeviceEncryptedPayload', 'repeated'))
-    .add(new protobuf.Field('encryptionType', 6, 'EncryptionType'))
-    .add(new protobuf.Field('plaintextPayload', 7, 'string'))
-    .add(new protobuf.Field('timestamp', 8, 'int64'));
+    .add(new protobuf.Field('timestamp', 4, 'int64'))
+    .add(new protobuf.Field('encryptionType', 5, 'EncryptionType'))
+    .add(new protobuf.Field('plaintextPayload', 6, 'string'))
+    .add(new protobuf.Field('devicePayloads', 7, 'DeviceEncryptedPayload', 'repeated'))
+    .add(new protobuf.Field('senderDeviceId', 8, 'string'))
+    .add(new protobuf.Field('attachments', 9, 'AttachmentRef', 'repeated'));
 const GroupAckType = new protobuf.Type('GroupAck')
     .add(new protobuf.Field('messageId', 1, 'string'))
     .add(new protobuf.Field('groupId', 2, 'string'))

package/dist/version.d.ts

@@ -7,7 +7,7 @@
  *   MINOR, additive feature (e.g. multi-device payloads, new call event type)
  *   PATCH, bug-fix / perf improvement with no wire or API change
  */
-export declare const SDK_VERSION = "0.6.0";
+export declare const SDK_VERSION = "0.8.0";
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can

package/dist/version.js

@@ -10,7 +10,7 @@ exports.PROTOCOL_VERSION = exports.PAYLOAD_FORMAT_VERSION = exports.SDK_VERSION
  *   MINOR, additive feature (e.g. multi-device payloads, new call event type)
  *   PATCH, bug-fix / perf improvement with no wire or API change
  */
-exports.SDK_VERSION = '0.6.0';
+exports.SDK_VERSION = '0.8.0';
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@droponair/sdk-js",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "DropOnAir SDK for end-to-end encrypted messaging",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",