@droponair/sdk-js 0.32.1 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.34.0
+
+### Added
+
+- **Files in group messages.** `sendGroupMessage(groupId, text, memberUserIds, { attachments })`
+  now carries attachment references, and a received `DecryptedGroupMessage` carries
+  `attachments`. Each member is handed the pointer and only the file keys wrapped for
+  their own devices. A file sent while a member was away arrives with the message when
+  they catch up, which previously carried nothing.
+- **A lifetime per file.** `retentionSeconds` on an upload session asks for one file to
+  live a set time. Never longer than the app's own retention.
+- **`deleteWhenEveryoneHasIt`.** The platform deletes the stored bytes as soon as every
+  recipient has fetched them, and answers a later request with "no longer available"
+  rather than a broken link.
+
+## 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

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);
 });
@@ -328,6 +346,8 @@ client.onMessage(async (msg) => {
 | `prepareAttachmentAndUpload(bytes, options)` | `Promise<AttachmentRef>` | Encrypt (E2EE), upload, finalize, return ref |
 | `createUploadSession(options)` | `Promise<UploadSession>` | Low-level: presigned PUT URL only |
 | `finalizeAttachment(attachmentId, sha256)` | `Promise<void>` | Low-level: commit integrity hash |
+| `retentionSeconds` (upload option) | | How long this one file should live. Never granted longer than your own retention. |
+| `deleteWhenEveryoneHasIt` (upload option) | | Delete the stored bytes as soon as every recipient has fetched them. A later request is answered "no longer available". |
 | `downloadAttachment(ref)` | `Promise<DownloadedAttachment>` | Get presigned URL + download + decrypt |
 | `revokeAttachment(attachmentId \| ref)` | `Promise<void>` | Revoke an attachment you sent; recipients get `ATTACHMENT_REVOKED` |
 | `sendMessage(toUserId, text, { attachments })` | `Promise<{ messageId }>` | Send with attachments |

package/dist/attachment/attachment-client.js

@@ -46,6 +46,10 @@ class AttachmentClient {
             conversationId: opts.conversationId ?? '',
             recipientUserIds: opts.recipientUserIds ?? [],
         };
+        if (opts.retentionSeconds !== undefined)
+            body.retentionSeconds = opts.retentionSeconds;
+        if (opts.deleteWhenEveryoneHasIt)
+            body.deleteWhenEveryoneHasIt = true;
         const resp = await this.deps.fetchFn(`${this.deps.httpUrl}/v1/attachments/upload-session`, {
             method: 'POST',
             headers: { Authorization: `Bearer ${jwt}`, 'Content-Type': 'application/json' },

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

@@ -44,6 +44,17 @@ export interface CreateUploadSessionOptions {
     conversationId?: string;
     /** Recipient user IDs (used by the server for download authorization). */
     recipientUserIds?: string[];
+    /**
+     * How long this one file should live, in seconds. Optional, and never granted
+     * longer than the app's own retention. An app that works out a window per file
+     * sets it here instead of living with one number for everything.
+     */
+    retentionSeconds?: number;
+    /**
+     * Delete the stored bytes as soon as every recipient has fetched them. The
+     * file then exists only on the devices it was sent to.
+     */
+    deleteWhenEveryoneHasIt?: boolean;
 }
 /** Result of reserving an upload session. */
 export interface UploadSession {

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

@@ -292,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';
@@ -521,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();
@@ -653,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+)
     // ---------------------------------------------------------------------------
@@ -1712,6 +1863,7 @@ class MessagingClient {
                 fromUserId: notif.fromUserId,
                 timestamp: notif.timestamp,
                 plaintext,
+                attachments: (notif.attachments ?? []).map(a => attachment_client_1.AttachmentClient.fromWire(a)),
             };
             for (const listener of this.groupMessageListeners) {
                 listener(msg);
@@ -2011,7 +2163,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,
@@ -2083,6 +2295,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,
@@ -2382,6 +2608,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`, {
@@ -2398,6 +2627,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,
@@ -2412,6 +2644,24 @@ class MessagingClient {
                         encryptedPayload: (0, bytes_1.fromBase64)(dp.encryptedPayloadBase64),
                         senderPublicKey: (0, bytes_1.fromBase64)(dp.senderPublicKeyBase64),
                     })),
+                    // Files travel with a late message too. Without this, somebody who was
+                    // away came back to a message that mentioned nothing at all: the live
+                    // path carried the pointer and the catch-up did not.
+                    attachments: (offline.attachments ?? []).map(a => ({
+                        attachmentId: a.attachmentId,
+                        storageHint: a.storageHint ?? '',
+                        mimeType: a.mimeType ?? '',
+                        sizeBytes: a.sizeBytes ?? 0,
+                        sha256: a.sha256 ?? '',
+                        encryptionType: a.encryptionType === 'CLEARTEXT' ? 1 : 0,
+                        thumbnailAttachmentId: a.thumbnailAttachmentId ?? '',
+                        wrappedKeys: (a.wrappedKeys ?? []).map(k => ({
+                            deviceId: k.deviceId,
+                            wrappedKey: (0, bytes_1.fromBase64)(k.wrappedKeyBase64 ?? ''),
+                            senderPublicKey: (0, bytes_1.fromBase64)(k.senderPublicKeyBase64 ?? ''),
+                            nonce: (0, bytes_1.fromBase64)(k.nonceBase64 ?? ''),
+                        })),
+                    })),
                 };
                 // The same path a live message takes, so decryption, de-duplication and
                 // the callback behave identically.
@@ -2420,7 +2670,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.
@@ -194,6 +222,12 @@ export interface DecryptedGroupMessage {
     fromUserId: string;
     timestamp: number;
     plaintext: string;
+    /**
+     * Files this message points at, if any. The bytes are fetched separately with
+     * `downloadAttachment`; what arrives here is the pointer and the file key
+     * wrapped for this device.
+     */
+    attachments?: import('../attachment/attachment-types').AttachmentRef[];
 }
 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_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' | 'GROUP_CALL_JOINED' | 'GROUP_CALL_WAITING_ROOM_PENDING' | 'GROUP_CALL_HOST_REQUIRED' | 'GROUP_CALL_ROOM_CLOSED' | 'GROUP_CALL_STAGE_HAND_RAISED' | 'GROUP_CALL_STAGE_HAND_LOWERED' | 'GROUP_CALL_STAGE_PROMOTE' | 'GROUP_CALL_STAGE_DEMOTE' | 'GROUP_CALL_STAGE_QUESTION' | 'GROUP_CALL_RECORDING_STARTED' | 'GROUP_CALL_RECORDING_STOPPED' | 'GROUP_CALL_RECORDING_AVAILABLE';
@@ -664,6 +698,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.1";
+export declare const SDK_VERSION = "0.34.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.1';
+exports.SDK_VERSION = '0.34.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.1",
+  "version": "0.34.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",