@droponair/sdk-js 0.32.0 → 0.33.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 0.33.0
+
+### Added
+
+- **Edit and delete group messages.** `editGroupMessage(groupId, originalMessageId,
+  newText, memberUserIds)`, `editCleartextGroupMessage` and `deleteGroupMessage`
+  (scope `FOR_EVERYONE` by default, or `FOR_ME`). An E2EE edit is encrypted for each
+  member and device, as a group message is. Only the sender of a message can change it.
+- **`onGroupMessageEdit` and `onGroupMessageDelete`.** Fired live, and again from
+  the offline fetch for a member who was away, after that member's messages, so
+  applying one twice must be harmless. A member who fetches after a delete for
+  everyone is not handed the message.
+
+## 0.32.1
+
+### Fixed
+
+- **A sender reported an error for every message it sent.** A message is echoed
+  back to every device of the sender, including the one that sent it, and what it
+  carries is encrypted for the recipients. The sending device tried to decrypt it,
+  which cannot work, and reported the failure each time. Such an echo is now
+  recognised and skipped. Nothing was lost before; the error was always wrong,
+  and an error that is always wrong hides the ones that are not.
+
+- **Reconnecting could stop for good.** A reconnect attempt that failed before a
+  socket existed, typically fetching a token with no network, emitted
+  `RECONNECT_FAILED` and scheduled nothing further, so the client stayed offline.
+  It now schedules the next attempt while reconnecting is still wanted.
+
 ## 0.32.0
 
 ### Added

package/README.md

@@ -93,6 +93,11 @@ const client = await initialize(options);
 | `editCleartextMessage(originalMessageId, toUserId, newText)` | `Promise<{ editId }>` | Edit a previously sent cleartext message |
 | `onMessage(callback)` | `() => void` | Listen for incoming messages. Returns unsubscribe function |
 | `onMessageEdit(callback)` | `() => void` | Listen for inbound edits to 1:1 messages |
+| `editGroupMessage(groupId, originalMessageId, newText, memberUserIds)` | `Promise<{ editId }>` | Edit a message you sent to a group, encrypted per member |
+| `editCleartextGroupMessage(groupId, originalMessageId, newText)` | `Promise<{ editId }>` | Edit a cleartext message you sent to a group |
+| `deleteGroupMessage(groupId, originalMessageId, scope?)` | `Promise<{ deleteId }>` | Delete a message you sent to a group. `scope` defaults to `FOR_EVERYONE` |
+| `onGroupMessageEdit(callback)` | `() => void` | Listen for edits to group messages |
+| `onGroupMessageDelete(callback)` | `() => void` | Listen for deletes of group messages |
 | `onMessageDelete(callback)` | `() => void` | Listen for inbound delete tombstones for 1:1 messages |
 | `onEvent(callback)` | `() => void` | Listen for system events (CONNECTED, DELIVERED, ERROR, etc.) |
 | `ack(messageId)` | `Promise<void>` | Manually acknowledge a message |
@@ -286,6 +291,19 @@ await client.deleteMessage(originalMessageId, 'recipient-user-id', 'FOR_EVERYONE
 // Delete only on the sender's own devices
 await client.deleteMessage(originalMessageId, 'recipient-user-id', 'FOR_ME');
 
+// A group message: name the group, and pass the members you sent to
+await client.editGroupMessage(groupId, messageId, 'Updated text', memberUserIds);
+await client.deleteGroupMessage(groupId, messageId); // FOR_EVERYONE by default
+
+client.onGroupMessageEdit((edit) => {
+  console.log('group edit', edit.groupId, edit.originalMessageId, edit.plaintext);
+});
+client.onGroupMessageDelete((del) => {
+  console.log('group delete', del.groupId, del.originalMessageId);
+});
+// Group edits and deletes also arrive after an absence, so applying one twice
+// must be harmless, and a delete can name a message this device never received.
+
 client.onMessageEdit((edit) => {
   console.log('edited', edit.originalMessageId, edit.text);
 });

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

@@ -1,6 +1,6 @@
 import { CryptoService } from '../crypto/crypto-service';
 import { SessionManager } from './session-manager';
-import { BroadcastCallback, CallEventCallback, DropOnAirClient, EventCallback, CreateRoomOptions, GroupCallEventCallback, GroupInfo, GroupMessageCallback, Room, UpdateRoomOptions, SfuToken, SfuRecording, InitializeOptions, MessageCallback, MessageDeleteCallback, MessageEditCallback, TurnCredentials, DeviceInfo, ReadReceiptCallback, TypingCallback, NotificationClearCallback, DraftSyncCallback, KeyCustody, PushPayload } from './types';
+import { BroadcastCallback, CallEventCallback, DropOnAirClient, EventCallback, CreateRoomOptions, GroupCallEventCallback, GroupInfo, GroupMessageCallback, GroupMessageDeleteCallback, GroupMessageEditCallback, Room, UpdateRoomOptions, SfuToken, SfuRecording, InitializeOptions, MessageCallback, MessageDeleteCallback, MessageEditCallback, TurnCredentials, DeviceInfo, ReadReceiptCallback, TypingCallback, NotificationClearCallback, DraftSyncCallback, KeyCustody, PushPayload } from './types';
 import { AttachmentRef, CreateUploadSessionOptions, DownloadedAttachment, PrepareAttachmentOptions, UploadSession } from '../attachment/attachment-types';
 export declare class MessagingClient implements DropOnAirClient {
     private readonly options;
@@ -94,6 +94,8 @@ export declare class MessagingClient implements DropOnAirClient {
     private readonly notificationClearListeners;
     private readonly draftSyncListeners;
     private readonly messageDeleteListeners;
+    private readonly groupMessageEditListeners;
+    private readonly groupMessageDeleteListeners;
     /** ------------------------------------------------------------------
      * Lightweight structured logger. Only active when options.debug === true.
      * Fields are safe to log: no plaintext, no private keys, no full JWTs.
@@ -142,6 +144,16 @@ export declare class MessagingClient implements DropOnAirClient {
     onEvent(callback: EventCallback): () => void;
     onMessageEdit(callback: MessageEditCallback): () => void;
     onMessageDelete(callback: MessageDeleteCallback): () => void;
+    /**
+     * Listen for edits of group messages. An edit arrives live and again from the
+     * offline fetch, so applying one twice must be harmless.
+     */
+    onGroupMessageEdit(callback: GroupMessageEditCallback): () => void;
+    /**
+     * Listen for deletes of group messages. A delete arrives live and again from
+     * the offline fetch, and can name a message this device never received.
+     */
+    onGroupMessageDelete(callback: GroupMessageDeleteCallback): () => void;
     /**
      * Register a listener for read receipts that this user's OTHER devices
      * reported. Fires when another device of the same user calls markRead();
@@ -162,6 +174,26 @@ export declare class MessagingClient implements DropOnAirClient {
     deleteMessage(originalMessageId: string, toUserId: string, scope: 'FOR_EVERYONE' | 'FOR_ME'): Promise<{
         deleteId: string;
     }>;
+    /**
+     * Edit a message you sent to a group. Encrypted per member and per device with
+     * the edit id, exactly as {@link sendGroupMessage} encrypts with the message id,
+     * so pass the same members. Only the sender of a message can edit it.
+     */
+    editGroupMessage(groupId: string, originalMessageId: string, newPlaintext: string, memberUserIds: string[]): Promise<{
+        editId: string;
+    }>;
+    /** Edit a cleartext message you sent to a group. */
+    editCleartextGroupMessage(groupId: string, originalMessageId: string, newPlaintext: string): Promise<{
+        editId: string;
+    }>;
+    /**
+     * Delete a message you sent to a group. FOR_EVERYONE tells every member, and a
+     * member who fetches later is not handed the message. FOR_ME tells only your
+     * other devices. Only the sender of a message can delete it.
+     */
+    deleteGroupMessage(groupId: string, originalMessageId: string, scope?: 'FOR_EVERYONE' | 'FOR_ME'): Promise<{
+        deleteId: string;
+    }>;
     /**
      * Register this device's push notification token with the DropOnAir platform.
      * The token is opaque to the server; the platform fans out push notifications
@@ -378,6 +410,11 @@ export declare class MessagingClient implements DropOnAirClient {
     private emitGroupCallEvent;
     private resolveTransport;
     private connectWebSocket;
+    /**
+     * One group edit, live or from the offline fetch. Decrypted exactly as a group
+     * message is, with the edit id in place of the message id.
+     */
+    private handleIncomingGroupEdit;
     private handleIncomingMessageEdit;
     private handleIncomingMessageDelete;
     private handleIncomingEnvelope;

package/dist/core/messaging-client.js

@@ -56,6 +56,12 @@ class MessagingClient {
             this.reconnectTimer = null;
             this.connectWebSocket().catch(() => {
                 this.emitEvent({ type: 'ERROR', reason: 'RECONNECT_FAILED' });
+                // An attempt that fails before a socket exists, typically the token exchange
+                // with no network, has no close event to schedule the next one. Without this
+                // the first such failure ended reconnecting for good.
+                if (this.shouldReconnect) {
+                    this.scheduleReconnect();
+                }
             });
         }, delay);
     }
@@ -286,6 +292,8 @@ class MessagingClient {
         this.notificationClearListeners = new Set();
         this.draftSyncListeners = new Set();
         this.messageDeleteListeners = new Set();
+        this.groupMessageEditListeners = new Set();
+        this.groupMessageDeleteListeners = new Set();
         this.wsUrl = options.messagingWsUrl ?? 'wss://sdk.droponair.com/ws';
         this.httpUrl = options.messagingHttpUrl ?? 'https://sdk.droponair.com';
         this.tokenExchangeEndpoint = options.tokenExchangeEndpoint ?? '/api/messaging/token-exchange';
@@ -515,6 +523,22 @@ class MessagingClient {
         this.messageDeleteListeners.add(callback);
         return () => this.messageDeleteListeners.delete(callback);
     }
+    /**
+     * Listen for edits of group messages. An edit arrives live and again from the
+     * offline fetch, so applying one twice must be harmless.
+     */
+    onGroupMessageEdit(callback) {
+        this.groupMessageEditListeners.add(callback);
+        return () => this.groupMessageEditListeners.delete(callback);
+    }
+    /**
+     * Listen for deletes of group messages. A delete arrives live and again from
+     * the offline fetch, and can name a message this device never received.
+     */
+    onGroupMessageDelete(callback) {
+        this.groupMessageDeleteListeners.add(callback);
+        return () => this.groupMessageDeleteListeners.delete(callback);
+    }
     /**
      * Register a listener for read receipts that this user's OTHER devices
      * reported. Fires when another device of the same user calls markRead();
@@ -647,6 +671,139 @@ class MessagingClient {
         this.transport.send(this.codec.encodeMessageDeleteFrame(frame));
         return { deleteId };
     }
+    /**
+     * Edit a message you sent to a group. Encrypted per member and per device with
+     * the edit id, exactly as {@link sendGroupMessage} encrypts with the message id,
+     * so pass the same members. Only the sender of a message can edit it.
+     */
+    async editGroupMessage(groupId, originalMessageId, newPlaintext, memberUserIds) {
+        if (!this.transport?.isOpen()) {
+            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');
+        }
+        if (!memberUserIds || memberUserIds.length === 0) {
+            throw new Error('editGroupMessage requires at least one recipient userId in memberUserIds');
+        }
+        const myDeviceId = this.deviceId ?? await this.getOrCreateDeviceId();
+        const editId = crypto.randomUUID();
+        const timestamp = Date.now();
+        const myIdentity = await this.cryptoService.getOrCreateIdentity();
+        const myPublicKeyBytes = (0, bytes_1.fromBase64)(myIdentity.publicKey);
+        const memberPayloads = [];
+        for (const memberId of memberUserIds) {
+            if (memberId === this.currentUserId)
+                continue; // skip self, as sendGroupMessage does
+            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(newPlaintext, sharedKey, {
+                        messageId: editId,
+                        senderId: this.currentUserId,
+                        recipientId: memberId,
+                        timestamp,
+                    });
+                    devicePayloads.push({ deviceId: dk.deviceId, encryptedPayload: encrypted, senderPublicKey: myPublicKeyBytes });
+                }
+            }
+            else {
+                const sharedKey = await this.getPeerSharedKey(memberId);
+                const encrypted = await this.cryptoService.encrypt(newPlaintext, sharedKey, {
+                    messageId: editId,
+                    senderId: this.currentUserId,
+                    recipientId: memberId,
+                    timestamp,
+                });
+                devicePayloads.push({ deviceId: 'default', encryptedPayload: encrypted, senderPublicKey: myPublicKeyBytes });
+            }
+            memberPayloads.push({ userId: memberId, devicePayloads });
+        }
+        const frame = {
+            type: 'MESSAGE_EDIT',
+            editId,
+            originalMessageId,
+            appId: this.options.appId,
+            fromUserId: this.currentUserId,
+            toUserId: '',
+            groupId,
+            timestamp,
+            encryptionType: 0, // E2EE
+            memberPayloads,
+            senderDeviceId: myDeviceId,
+            clientEditId: editId,
+        };
+        this.transport.send(this.codec.encodeMessageEditFrame(frame));
+        return { editId };
+    }
+    /** Edit a cleartext message you sent to a group. */
+    async editCleartextGroupMessage(groupId, originalMessageId, newPlaintext) {
+        if (!this.transport?.isOpen()) {
+            throw new Error('DropOnAir websocket is not connected');
+        }
+        if (!this.currentUserId) {
+            throw new Error('Missing sender identity from DropOnAir JWT subject');
+        }
+        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 editId = crypto.randomUUID();
+        const frame = {
+            type: 'MESSAGE_EDIT',
+            editId,
+            originalMessageId,
+            appId: this.options.appId,
+            fromUserId: this.currentUserId,
+            toUserId: '',
+            groupId,
+            timestamp: Date.now(),
+            encryptionType: 1, // CLEARTEXT
+            plaintextPayload: newPlaintext,
+            senderDeviceId: this.deviceId ?? await this.getOrCreateDeviceId(),
+            clientEditId: editId,
+        };
+        this.transport.send(this.codec.encodeMessageEditFrame(frame));
+        return { editId };
+    }
+    /**
+     * Delete a message you sent to a group. FOR_EVERYONE tells every member, and a
+     * member who fetches later is not handed the message. FOR_ME tells only your
+     * other devices. Only the sender of a message can delete it.
+     */
+    async deleteGroupMessage(groupId, originalMessageId, scope = 'FOR_EVERYONE') {
+        if (!this.transport?.isOpen()) {
+            throw new Error('DropOnAir websocket is not connected');
+        }
+        if (!this.currentUserId) {
+            throw new Error('Missing sender identity from DropOnAir JWT subject');
+        }
+        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 deleteId = crypto.randomUUID();
+        const frame = {
+            type: 'MESSAGE_DELETE',
+            deleteId,
+            originalMessageId,
+            appId: this.options.appId,
+            fromUserId: this.currentUserId,
+            toUserId: '',
+            groupId,
+            timestamp: Date.now(),
+            scope,
+            clientDeleteId: deleteId,
+        };
+        this.transport.send(this.codec.encodeMessageDeleteFrame(frame));
+        return { deleteId };
+    }
     // ---------------------------------------------------------------------------
     // Push notification token registration (PROTOCOL_VERSION 5+)
     // ---------------------------------------------------------------------------
@@ -2005,7 +2162,67 @@ class MessagingClient {
             });
         });
     }
+    /**
+     * One group edit, live or from the offline fetch. Decrypted exactly as a group
+     * message is, with the edit id in place of the message id.
+     */
+    async handleIncomingGroupEdit(frame) {
+        try {
+            let plaintext;
+            if (frame.encryptionType === 1) {
+                plaintext = frame.plaintextPayload ?? '';
+            }
+            else if (frame.devicePayloads && frame.devicePayloads.length > 0) {
+                const myDeviceId = this.deviceId ?? await this.getOrCreateDeviceId();
+                const myPayload = frame.devicePayloads.find(dp => dp.deviceId === myDeviceId);
+                if (!myPayload) {
+                    this.log('incoming_group_edit_no_device_payload', {
+                        editId: frame.editId,
+                        myDeviceId,
+                        availableDeviceIds: frame.devicePayloads.map(dp => dp.deviceId),
+                    });
+                    return;
+                }
+                const peerUserIdForHkdf = frame.fromUserId === this.currentUserId ? this.currentUserId : frame.fromUserId;
+                const sharedKey = await this.cryptoService.deriveSharedSecret(peerUserIdForHkdf, (0, bytes_1.toBase64)(myPayload.senderPublicKey), this.currentUserId);
+                plaintext = await this.cryptoService.decrypt(myPayload.encryptedPayload, sharedKey, {
+                    messageId: frame.editId,
+                    senderId: frame.fromUserId,
+                    recipientId: this.currentUserId,
+                    timestamp: frame.timestamp,
+                });
+            }
+            else {
+                this.log('incoming_group_edit_no_payload', { editId: frame.editId });
+                return;
+            }
+            const event = {
+                editId: frame.editId,
+                originalMessageId: frame.originalMessageId,
+                groupId: frame.groupId,
+                fromUserId: frame.fromUserId,
+                timestamp: frame.timestamp,
+                plaintext,
+            };
+            for (const listener of this.groupMessageEditListeners) {
+                listener(event);
+            }
+        }
+        catch (error) {
+            this.logError('incoming_group_edit_failed', {
+                editId: frame.editId,
+                originalMessageId: frame.originalMessageId,
+                groupId: frame.groupId,
+                error: String(error?.message ?? error),
+            });
+            this.emitEvent({ type: 'ERROR', reason: 'DECRYPT_FAILED', metadata: frame.editId });
+        }
+    }
     async handleIncomingMessageEdit(frame) {
+        if (frame.groupId) {
+            await this.handleIncomingGroupEdit(frame);
+            return;
+        }
         try {
             this.log('incoming_message_edit_received', {
                 editId: frame.editId,
@@ -2077,6 +2294,20 @@ class MessagingClient {
         }
     }
     handleIncomingMessageDelete(frame) {
+        if (frame.groupId) {
+            const event = {
+                deleteId: frame.deleteId,
+                originalMessageId: frame.originalMessageId,
+                groupId: frame.groupId,
+                fromUserId: frame.fromUserId,
+                timestamp: frame.timestamp,
+                scope: frame.scope || 'FOR_EVERYONE',
+            };
+            for (const listener of this.groupMessageDeleteListeners) {
+                listener(event);
+            }
+            return;
+        }
         this.log('incoming_message_delete_received', {
             deleteId: frame.deleteId,
             originalMessageId: frame.originalMessageId,
@@ -2138,7 +2369,17 @@ class MessagingClient {
                 });
             }
             else {
-                // Legacy single-payload path
+                // Legacy single-payload path.
+                //
+                // Our own message, sent back so our other devices can show it. This client
+                // is the one that sent it and already has it, and what it carries is
+                // encrypted for the recipient, not for us. Trying anyway fails, and a
+                // failure that happens on every single message teaches people to ignore
+                // the ones that matter. A client with something to read here finds it in
+                // the per-device payloads above.
+                if (envelope.fromUserId === this.currentUserId) {
+                    return;
+                }
                 const sharedKey = await this.getPeerSharedKey(envelope.fromUserId);
                 plaintext = await this.cryptoService.decrypt(envelope.encryptedPayload, sharedKey, {
                     messageId: envelope.messageId,
@@ -2366,6 +2607,9 @@ class MessagingClient {
         let page = 0;
         let totalPages = 1;
         let totalProcessed = 0;
+        // Edits and deletes come on the first page and are applied after every
+        // message, because a change can be about a message on a later page.
+        let changes = [];
         this.log('group_offline_fetch_started', { httpUrl: this.httpUrl, pageSize: 100 });
         while (page < totalPages) {
             const response = await this.fetchFn(`${this.httpUrl}/v1/groups/messages/offline?page=${page}&size=100`, {
@@ -2382,6 +2626,9 @@ class MessagingClient {
             }
             const body = await response.json();
             totalPages = body.totalPages ?? 0;
+            if (page === 0) {
+                changes = body.changes ?? [];
+            }
             for (const offline of body.messages) {
                 const notification = {
                     messageId: offline.messageId,
@@ -2404,7 +2651,42 @@ class MessagingClient {
             }
             page += 1;
         }
-        this.log('group_offline_fetch_done', { totalProcessed });
+        for (const change of changes) {
+            if (change.kind === 'EDIT') {
+                await this.handleIncomingGroupEdit({
+                    type: 'MESSAGE_EDIT',
+                    editId: change.changeId,
+                    originalMessageId: change.originalMessageId,
+                    appId: this.options.appId,
+                    fromUserId: change.fromUserId,
+                    toUserId: '',
+                    groupId: change.groupId,
+                    timestamp: Number(change.timestamp),
+                    encryptionType: change.encryptionType === 'CLEARTEXT' ? 1 : 0,
+                    plaintextPayload: change.plaintextPayload ?? undefined,
+                    senderDeviceId: change.senderDeviceId ?? undefined,
+                    devicePayloads: (change.devicePayloads ?? []).map(dp => ({
+                        deviceId: dp.deviceId,
+                        encryptedPayload: (0, bytes_1.fromBase64)(dp.encryptedPayloadBase64),
+                        senderPublicKey: (0, bytes_1.fromBase64)(dp.senderPublicKeyBase64 ?? ''),
+                    })),
+                });
+            }
+            else if (change.kind === 'DELETE') {
+                this.handleIncomingMessageDelete({
+                    type: 'MESSAGE_DELETE',
+                    deleteId: change.changeId,
+                    originalMessageId: change.originalMessageId,
+                    appId: this.options.appId,
+                    fromUserId: change.fromUserId,
+                    toUserId: '',
+                    groupId: change.groupId,
+                    timestamp: Number(change.timestamp),
+                    scope: change.scope || 'FOR_EVERYONE',
+                });
+            }
+        }
+        this.log('group_offline_fetch_done', { totalProcessed, changes: changes.length });
     }
     async fetchAndProcessOfflineMessages() {
         const jwt = await this.getValidDropOnAirJwt(false);

package/dist/core/types.d.ts

@@ -91,6 +91,34 @@ export interface MessageDeleteEvent {
 }
 export type MessageEditCallback = (event: MessageEditEvent) => void;
 export type MessageDeleteCallback = (event: MessageDeleteEvent) => void;
+/**
+ * A message in a group, edited by its sender. Delivered live and again from the
+ * offline fetch, so applying the same edit twice must be harmless. Two edits of
+ * one message arrive oldest first.
+ */
+export interface GroupMessageEditEvent {
+    editId: string;
+    originalMessageId: string;
+    groupId: string;
+    fromUserId: string;
+    timestamp: number;
+    /** New plaintext for both E2EE (after decryption) and CLEARTEXT messages. */
+    plaintext: string;
+}
+/**
+ * A message in a group, deleted by its sender. Delivered live and again from the
+ * offline fetch, and can name a message this device never received.
+ */
+export interface GroupMessageDeleteEvent {
+    deleteId: string;
+    originalMessageId: string;
+    groupId: string;
+    fromUserId: string;
+    timestamp: number;
+    scope: 'FOR_EVERYONE' | 'FOR_ME' | string;
+}
+export type GroupMessageEditCallback = (event: GroupMessageEditEvent) => void;
+export type GroupMessageDeleteCallback = (event: GroupMessageDeleteEvent) => void;
 /**
  * Delivered to the user's OTHER devices when one device calls markRead().
  * Use it to clear whatever unread state your app keeps for that message.
@@ -664,6 +692,29 @@ export interface DropOnAirClient {
     }>;
     /** Register a listener for incoming group messages. Returns an unsubscribe function. */
     onGroupMessage(callback: GroupMessageCallback): () => void;
+    /**
+     * Edit a message you sent to a group, encrypted per member as
+     * {@link sendGroupMessage} is. Pass the same members. Only the sender can edit.
+     */
+    editGroupMessage(groupId: string, originalMessageId: string, newPlaintext: string, memberUserIds: string[]): Promise<{
+        editId: string;
+    }>;
+    /** Edit a cleartext message you sent to a group. */
+    editCleartextGroupMessage(groupId: string, originalMessageId: string, newPlaintext: string): Promise<{
+        editId: string;
+    }>;
+    /**
+     * Delete a message you sent to a group. FOR_EVERYONE tells every member and
+     * a member who fetches later is not handed the message; FOR_ME tells only
+     * your other devices. Only the sender can delete.
+     */
+    deleteGroupMessage(groupId: string, originalMessageId: string, scope?: 'FOR_EVERYONE' | 'FOR_ME'): Promise<{
+        deleteId: string;
+    }>;
+    /** Register a listener for edits of group messages. */
+    onGroupMessageEdit(callback: GroupMessageEditCallback): () => void;
+    /** Register a listener for deletes of group messages. */
+    onGroupMessageDelete(callback: GroupMessageDeleteCallback): () => void;
     /** Initiate a group call. Returns the callId. */
     startGroupCall(groupId: string): Promise<string>;
     /** Join an active group call. */

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export { SDK_VERSION, PROTOCOL_VERSION, PAYLOAD_FORMAT_VERSION } from './version
  */
 export declare function createSecureIdentity(store?: IdentityRecordStore): Promise<WebCryptoIdentityProvider | null>;
 export declare function initialize(options: InitializeOptions): Promise<DropOnAirClient>;
-export type { InitializeOptions, DropOnAirClient, DropOnAirEvent, MessageCallback, EventCallback, DecryptedMessage, KeyStorageAdapter, CallEvent, CallEventType, CallEventCallback, TurnCredentials, BroadcastMessage, BroadcastCallback, GroupInfo, GroupMemberInfo, DecryptedGroupMessage, GroupMessageCallback, GroupCallEvent, GroupCallEventType, GroupCallEventCallback, Room, RoomPolicy, CreateRoomOptions, UpdateRoomOptions, SfuToken, SfuRecording, MessageEditEvent, MessageEditCallback, MessageDeleteEvent, MessageDeleteCallback, DeviceInfo, ReadReceiptEvent, ReadReceiptCallback, TypingEvent, TypingCallback, NotificationClearEvent, NotificationClearCallback, DraftSyncEvent, DraftSyncCallback, } from './core/types';
+export type { InitializeOptions, DropOnAirClient, DropOnAirEvent, MessageCallback, EventCallback, DecryptedMessage, KeyStorageAdapter, CallEvent, CallEventType, CallEventCallback, TurnCredentials, BroadcastMessage, BroadcastCallback, GroupInfo, GroupMemberInfo, DecryptedGroupMessage, GroupMessageCallback, GroupCallEvent, GroupCallEventType, GroupCallEventCallback, Room, RoomPolicy, CreateRoomOptions, UpdateRoomOptions, SfuToken, SfuRecording, MessageEditEvent, MessageEditCallback, MessageDeleteEvent, MessageDeleteCallback, GroupMessageEditEvent, GroupMessageEditCallback, GroupMessageDeleteEvent, GroupMessageDeleteCallback, DeviceInfo, ReadReceiptEvent, ReadReceiptCallback, TypingEvent, TypingCallback, NotificationClearEvent, NotificationClearCallback, DraftSyncEvent, DraftSyncCallback, } from './core/types';
 export type { AttachmentEncryptionType, AttachmentConversationType, AttachmentRef, DeviceWrappedKey, CreateUploadSessionOptions, UploadSession, PrepareAttachmentOptions, DownloadedAttachment, } from './attachment/attachment-types';
 export { SseTransport, type SseTransportOptions, type SseFrameHandler, type SseStateHandler, } from './transport/sse-transport';
 export { WebTransportTransport, type WebTransportTransportOptions, type WTFrameHandler, type WTStateHandler, } from './transport/webtransport-transport';

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

@@ -168,6 +168,10 @@ export interface WireMessageEditFrame {
     senderDeviceId?: string;
     plaintextPayload?: string;
     clientEditId?: string;
+    /** Set when the edited message was sent to a group. */
+    groupId?: string;
+    /** Group E2EE edits sent to the relay: one payload set per member. */
+    memberPayloads?: WireGroupMemberPayload[];
 }
 /**
  * Push token registration / unregister. Client -> server only. The server
@@ -204,6 +208,8 @@ export interface WireMessageDeleteFrame {
     timestamp: number;
     scope: string;
     clientDeleteId?: string;
+    /** Set when the deleted message was sent to a group. */
+    groupId?: string;
 }
 export type InboundFrame = {
     kind: 'envelope';

package/dist/transport/protobuf-codec.js

@@ -217,9 +217,15 @@ const MessageEditDeviceType = new protobuf.Type('DeviceEncryptedPayload')
     .add(new protobuf.Field('encryptedPayload', 2, 'bytes'))
     .add(new protobuf.Field('senderPublicKey', 3, 'bytes'));
 const MessageEditEncryptionTypeEnum = new protobuf.Enum('EncryptionType', { E2EE: 0, CLEARTEXT: 1 });
+// Its own instance, never the group envelope's. A protobuf.Type belongs to one
+// parent, and sharing one across two broke every message this SDK sent.
+const MessageEditMemberPayloadType = new protobuf.Type('GroupMemberPayload')
+    .add(new protobuf.Field('userId', 1, 'string'))
+    .add(new protobuf.Field('devicePayloads', 2, 'DeviceEncryptedPayload', 'repeated'));
 const MessageEditFrameType = new protobuf.Type('MessageEditFrame')
     .add(MessageEditEncryptionTypeEnum)
     .add(MessageEditDeviceType)
+    .add(MessageEditMemberPayloadType)
     .add(new protobuf.Field('type', 1, 'string'))
     .add(new protobuf.Field('editId', 2, 'string'))
     .add(new protobuf.Field('originalMessageId', 3, 'string'))
@@ -232,7 +238,11 @@ const MessageEditFrameType = new protobuf.Type('MessageEditFrame')
     .add(new protobuf.Field('devicePayloads', 10, 'DeviceEncryptedPayload', 'repeated'))
     .add(new protobuf.Field('senderDeviceId', 11, 'string'))
     .add(new protobuf.Field('plaintextPayload', 12, 'string'))
-    .add(new protobuf.Field('clientEditId', 13, 'string'));
+    .add(new protobuf.Field('clientEditId', 13, 'string'))
+    // Group edits: groupId names the group; an E2EE edit sent to the relay carries
+    // one payload set per member, and each member receives only their own.
+    .add(new protobuf.Field('groupId', 14, 'string'))
+    .add(new protobuf.Field('memberPayloads', 15, 'GroupMemberPayload', 'repeated'));
 const MessageDeleteFrameType = new protobuf.Type('MessageDeleteFrame')
     .add(new protobuf.Field('type', 1, 'string'))
     .add(new protobuf.Field('deleteId', 2, 'string'))
@@ -242,7 +252,8 @@ const MessageDeleteFrameType = new protobuf.Type('MessageDeleteFrame')
     .add(new protobuf.Field('toUserId', 6, 'string'))
     .add(new protobuf.Field('timestamp', 7, 'int64'))
     .add(new protobuf.Field('scope', 8, 'string'))
-    .add(new protobuf.Field('clientDeleteId', 9, 'string'));
+    .add(new protobuf.Field('clientDeleteId', 9, 'string'))
+    .add(new protobuf.Field('groupId', 10, 'string'));
 // Push token registration frame (PROTOCOL_VERSION 5+). Client to server only;
 // the server emits a PUSH_REGISTERED / PUSH_UNREGISTERED Ack back. The token
 // is opaque to the server and stored against (appId, userId, deviceId, platform).

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.32.0";
+export declare const SDK_VERSION = "0.33.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.32.0';
+exports.SDK_VERSION = '0.33.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.32.0",
+  "version": "0.33.0",
   "description": "End-to-end encrypted messaging, voice and video calling SDK. The relay never sees your keys or message content.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",