@droponair/sdk-js 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,29 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.4.0], 2026-04-21
+
+### Added
+- **Message edit (E2EE + cleartext):** `editMessage(originalMessageId, toUserId, newText)` and `editCleartextMessage(originalMessageId, toUserId, newText)`. Edits are re-encrypted per-device with the same shared key as the original message; the server stores them as immutable separate records and forwards opaquely.
+- **Message delete:** `deleteMessage(originalMessageId, toUserId, scope)` with `scope` of `"FOR_EVERYONE"` (recipient receives tombstone, cleartext plaintext is also wiped server-side) or `"FOR_ME"` (only sender's other devices receive the tombstone).
+- **New event types:** `MessageEditEvent` and `MessageDeleteEvent` with `onMessageEdit()` / `onMessageDelete()` listeners.
+- **Offline catch-up:** Pending edits and tombstones are now replayed alongside offline messages when the client reconnects (`pendingEdits` and `pendingTombstones` returned by `/api/messages/offline`).
+- **PROTOCOL_VERSION = 3** and `features` now advertises `message_edit` + `message_delete` from `GET /api/info`.
+
+### Notes
+- Each edit and each `FOR_EVERYONE` delete counts as **one** MESSAGE usage record (subject to plan quotas + rate limits).
+- Wire-level additive: legacy 0.3.x clients ignore unknown frame types (proto3 forwards-compat), so existing TwinFlame and CrowdSyncer apps continue to work unchanged.
+- Requires sdk-be `0.4.0` server.
+
+---
+
+## [0.3.1], 2026-04-19
+
+### Changed
+- Patch version bump for npm publish alignment
+
+---
+
 ## [0.3.0], 2026-04-04
 
 ### Added

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, GroupCallEventCallback, GroupInfo, GroupMessageCallback, InitializeOptions, MessageCallback, TurnCredentials } from './types';
+import { BroadcastCallback, CallEventCallback, DropOnAirClient, EventCallback, GroupCallEventCallback, GroupInfo, GroupMessageCallback, InitializeOptions, MessageCallback, MessageDeleteCallback, MessageEditCallback, TurnCredentials } from './types';
 export declare class MessagingClient implements DropOnAirClient {
     private readonly options;
     private readonly cryptoService;
@@ -68,6 +68,8 @@ export declare class MessagingClient implements DropOnAirClient {
     private readonly messageListeners;
     private readonly eventListeners;
     private readonly broadcastListeners;
+    private readonly messageEditListeners;
+    private readonly messageDeleteListeners;
     /** ------------------------------------------------------------------
      * Lightweight structured logger. Only active when options.debug === true.
      * Fields are safe to log: no plaintext, no private keys, no full JWTs.
@@ -90,6 +92,17 @@ export declare class MessagingClient implements DropOnAirClient {
     ack(messageId: string): Promise<void>;
     onMessage(callback: MessageCallback): () => void;
     onEvent(callback: EventCallback): () => void;
+    onMessageEdit(callback: MessageEditCallback): () => void;
+    onMessageDelete(callback: MessageDeleteCallback): () => void;
+    editMessage(originalMessageId: string, toUserId: string, newPlaintext: string): Promise<{
+        editId: string;
+    }>;
+    editCleartextMessage(originalMessageId: string, toUserId: string, newPlaintext: string): Promise<{
+        editId: string;
+    }>;
+    deleteMessage(originalMessageId: string, toUserId: string, scope: 'FOR_EVERYONE' | 'FOR_ME'): Promise<{
+        deleteId: string;
+    }>;
     sendCleartextMessage(toUserId: string, plaintext: string): Promise<{
         messageId: string;
     }>;
@@ -137,6 +150,8 @@ export declare class MessagingClient implements DropOnAirClient {
     private handleIncomingGroupMessage;
     private emitGroupCallEvent;
     private connectWebSocket;
+    private handleIncomingMessageEdit;
+    private handleIncomingMessageDelete;
     private handleIncomingEnvelope;
     private getPeerSharedKey;
     /** Get or create a persistent device UUID for this SDK instance. */

package/dist/core/messaging-client.js

@@ -218,6 +218,8 @@ class MessagingClient {
         this.messageListeners = new Set();
         this.eventListeners = new Set();
         this.broadcastListeners = new Set();
+        this.messageEditListeners = new Set();
+        this.messageDeleteListeners = 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';
@@ -363,6 +365,129 @@ class MessagingClient {
         this.eventListeners.add(callback);
         return () => this.eventListeners.delete(callback);
     }
+    onMessageEdit(callback) {
+        this.messageEditListeners.add(callback);
+        return () => this.messageEditListeners.delete(callback);
+    }
+    onMessageDelete(callback) {
+        this.messageDeleteListeners.add(callback);
+        return () => this.messageDeleteListeners.delete(callback);
+    }
+    // ---------------------------------------------------------------------------
+    // Message edit and delete (PROTOCOL_VERSION 3+)
+    // ---------------------------------------------------------------------------
+    async editMessage(originalMessageId, toUserId, newPlaintext) {
+        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 editId = crypto.randomUUID();
+        const timestamp = Date.now();
+        // Encrypt new content for all recipient devices + sender's other devices,
+        // exactly mirroring sendMessage. The relay never sees plaintext.
+        const myIdentity = await this.cryptoService.getOrCreateIdentity();
+        const myPublicKeyBytes = (0, bytes_1.fromBase64)(myIdentity.publicKey);
+        const peerDeviceKeys = await this.fetchDeviceKeys(toUserId);
+        const myOtherDeviceKeys = await this.fetchMyOtherDeviceKeys(myDeviceId);
+        const allTargetKeys = [
+            ...peerDeviceKeys.map(dk => ({ ...dk, isRecipient: true })),
+            ...myOtherDeviceKeys.map(dk => ({ ...dk, isRecipient: false })),
+        ];
+        if (allTargetKeys.length === 0) {
+            throw new Error('No recipient device keys available for edit');
+        }
+        const devicePayloads = [];
+        for (const target of allTargetKeys) {
+            const peerUserIdForHkdf = target.isRecipient ? toUserId : this.currentUserId;
+            const sharedKey = await this.cryptoService.deriveSharedSecret(peerUserIdForHkdf, target.publicKey, this.currentUserId);
+            const encrypted = await this.cryptoService.encrypt(newPlaintext, sharedKey, {
+                messageId: editId,
+                senderId: this.currentUserId,
+                recipientId: toUserId,
+                timestamp,
+            });
+            devicePayloads.push({
+                deviceId: target.deviceId,
+                encryptedPayload: encrypted,
+                senderPublicKey: myPublicKeyBytes,
+            });
+        }
+        const frame = {
+            type: 'MESSAGE_EDIT',
+            editId,
+            originalMessageId,
+            appId: this.options.appId,
+            fromUserId: this.currentUserId,
+            toUserId,
+            timestamp,
+            encryptionType: 0, // E2EE
+            devicePayloads,
+            senderDeviceId: myDeviceId,
+            clientEditId: editId,
+        };
+        this.ws.send(this.codec.encodeMessageEditFrame(frame));
+        return { editId };
+    }
+    async editCleartextMessage(originalMessageId, toUserId, newPlaintext) {
+        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.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,
+            timestamp: Date.now(),
+            encryptionType: 1, // CLEARTEXT
+            plaintextPayload: newPlaintext,
+            clientEditId: editId,
+        };
+        this.ws.send(this.codec.encodeMessageEditFrame(frame));
+        return { editId };
+    }
+    async deleteMessage(originalMessageId, toUserId, scope) {
+        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.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,
+            timestamp: Date.now(),
+            scope,
+            clientDeleteId: deleteId,
+        };
+        this.ws.send(this.codec.encodeMessageDeleteFrame(frame));
+        return { deleteId };
+    }
     // ---------------------------------------------------------------------------
     // Cleartext messaging (no E2EE key exchange required)
     // ---------------------------------------------------------------------------
@@ -910,10 +1035,112 @@ class MessagingClient {
                     this.emitBroadcast(frame.data);
                     return;
                 }
-                await this.handleIncomingEnvelope(frame.data);
+                if (frame.kind === 'messageEdit') {
+                    await this.handleIncomingMessageEdit(frame.data);
+                    return;
+                }
+                if (frame.kind === 'messageDelete') {
+                    this.handleIncomingMessageDelete(frame.data);
+                    return;
+                }
+                if (frame.kind === 'envelope') {
+                    await this.handleIncomingEnvelope(frame.data);
+                }
             };
         });
     }
+    async handleIncomingMessageEdit(frame) {
+        try {
+            this.log('incoming_message_edit_received', {
+                editId: frame.editId,
+                originalMessageId: frame.originalMessageId,
+                fromUserId: frame.fromUserId,
+                toUserId: frame.toUserId,
+                timestamp: frame.timestamp,
+                encryptionType: frame.encryptionType,
+                hasDevicePayloads: !!(frame.devicePayloads && frame.devicePayloads.length > 0),
+            });
+            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_message_edit_no_device_payload', {
+                        editId: frame.editId,
+                        myDeviceId,
+                        availableDeviceIds: frame.devicePayloads.map(dp => dp.deviceId),
+                    });
+                    return;
+                }
+                const senderPublicKeyBase64 = (0, bytes_1.toBase64)(myPayload.senderPublicKey);
+                const isSelfSync = frame.fromUserId === this.currentUserId;
+                const peerUserIdForHkdf = isSelfSync ? this.currentUserId : frame.fromUserId;
+                const sharedKey = await this.cryptoService.deriveSharedSecret(peerUserIdForHkdf, senderPublicKeyBase64, this.currentUserId);
+                plaintext = await this.cryptoService.decrypt(myPayload.encryptedPayload, sharedKey, {
+                    messageId: frame.editId,
+                    senderId: frame.fromUserId,
+                    recipientId: frame.toUserId,
+                    timestamp: frame.timestamp,
+                });
+            }
+            else if (frame.encryptedPayload && frame.encryptedPayload.length > 0) {
+                const sharedKey = await this.getPeerSharedKey(frame.fromUserId);
+                plaintext = await this.cryptoService.decrypt(frame.encryptedPayload, sharedKey, {
+                    messageId: frame.editId,
+                    senderId: frame.fromUserId,
+                    recipientId: frame.toUserId,
+                    timestamp: frame.timestamp,
+                });
+            }
+            else {
+                this.log('incoming_message_edit_no_payload', { editId: frame.editId });
+                return;
+            }
+            const event = {
+                editId: frame.editId,
+                originalMessageId: frame.originalMessageId,
+                fromUserId: frame.fromUserId,
+                toUserId: frame.toUserId,
+                timestamp: frame.timestamp,
+                plaintext,
+            };
+            for (const listener of this.messageEditListeners) {
+                listener(event);
+            }
+        }
+        catch (error) {
+            this.logError('incoming_message_edit_failed', {
+                editId: frame.editId,
+                originalMessageId: frame.originalMessageId,
+                error: String(error?.message ?? error),
+            });
+            this.emitEvent({ type: 'ERROR', reason: 'DECRYPT_FAILED', metadata: frame.editId });
+        }
+    }
+    handleIncomingMessageDelete(frame) {
+        this.log('incoming_message_delete_received', {
+            deleteId: frame.deleteId,
+            originalMessageId: frame.originalMessageId,
+            fromUserId: frame.fromUserId,
+            toUserId: frame.toUserId,
+            scope: frame.scope,
+            timestamp: frame.timestamp,
+        });
+        const event = {
+            deleteId: frame.deleteId,
+            originalMessageId: frame.originalMessageId,
+            fromUserId: frame.fromUserId,
+            toUserId: frame.toUserId,
+            timestamp: frame.timestamp,
+            scope: frame.scope,
+        };
+        for (const listener of this.messageDeleteListeners) {
+            listener(event);
+        }
+    }
     async handleIncomingEnvelope(envelope) {
         try {
             this.log('incoming_envelope_received', {
@@ -1190,6 +1417,48 @@ class MessagingClient {
                 await this.handleIncomingEnvelope(wireEnvelope);
                 totalProcessed += 1;
             }
+            // Replay pending edits/tombstones for this page
+            if (body.pendingEdits && body.pendingEdits.length > 0) {
+                for (const offlineEdit of body.pendingEdits) {
+                    const wireEdit = {
+                        type: 'MESSAGE_EDIT',
+                        editId: offlineEdit.editId,
+                        originalMessageId: offlineEdit.originalMessageId,
+                        appId: offlineEdit.appId,
+                        fromUserId: offlineEdit.fromUserId,
+                        toUserId: offlineEdit.toUserId,
+                        timestamp: new Date(offlineEdit.createdAt).getTime(),
+                        encryptionType: offlineEdit.encryptionType === 'CLEARTEXT' ? 1 : 0,
+                        encryptedPayload: offlineEdit.encryptedPayloadBase64
+                            ? (0, bytes_1.fromBase64)(offlineEdit.encryptedPayloadBase64)
+                            : new Uint8Array(0),
+                        plaintextPayload: offlineEdit.plaintextPayload,
+                    };
+                    if (offlineEdit.devicePayloads && offlineEdit.devicePayloads.length > 0) {
+                        wireEdit.devicePayloads = offlineEdit.devicePayloads.map(dp => ({
+                            deviceId: dp.deviceId,
+                            encryptedPayload: (0, bytes_1.fromBase64)(dp.encryptedPayloadBase64),
+                            senderPublicKey: (0, bytes_1.fromBase64)(dp.senderPublicKeyBase64),
+                        }));
+                        wireEdit.senderDeviceId = offlineEdit.senderDeviceId;
+                    }
+                    await this.handleIncomingMessageEdit(wireEdit);
+                }
+            }
+            if (body.pendingTombstones && body.pendingTombstones.length > 0) {
+                for (const offlineTomb of body.pendingTombstones) {
+                    this.handleIncomingMessageDelete({
+                        type: 'MESSAGE_DELETE',
+                        deleteId: offlineTomb.deleteId,
+                        originalMessageId: offlineTomb.originalMessageId,
+                        appId: offlineTomb.appId,
+                        fromUserId: offlineTomb.fromUserId,
+                        toUserId: offlineTomb.toUserId,
+                        timestamp: new Date(offlineTomb.createdAt).getTime(),
+                        scope: offlineTomb.scope,
+                    });
+                }
+            }
             page += 1;
         }
         this.log('offline_fetch_completed', {

package/dist/core/types.d.ts

@@ -13,6 +13,35 @@ export interface DecryptedMessage {
 }
 export type MessageCallback = (message: DecryptedMessage) => void;
 export type EventCallback = (event: DropOnAirEvent) => void;
+/**
+ * Delivered to recipient devices when a sender edits a previously sent message.
+ * For E2EE messages the SDK has already decrypted the new payload.
+ * UI is the application's responsibility, render an "edited" badge if desired.
+ */
+export interface MessageEditEvent {
+    editId: string;
+    originalMessageId: string;
+    fromUserId: string;
+    toUserId: string;
+    timestamp: number;
+    /** New plaintext for both E2EE (after decryption) and CLEARTEXT messages. */
+    plaintext: string;
+}
+/**
+ * Delivered to recipient devices when a sender deletes a previously sent message
+ * with scope FOR_EVERYONE. Application should remove or replace the displayed
+ * content with a "message deleted" placeholder.
+ */
+export interface MessageDeleteEvent {
+    deleteId: string;
+    originalMessageId: string;
+    fromUserId: string;
+    toUserId: string;
+    timestamp: number;
+    scope: 'FOR_EVERYONE' | 'FOR_ME' | string;
+}
+export type MessageEditCallback = (event: MessageEditEvent) => void;
+export type MessageDeleteCallback = (event: MessageDeleteEvent) => void;
 export interface BroadcastMessage {
     broadcastId: string;
     channelId: string;
@@ -106,6 +135,29 @@ export interface DropOnAirClient {
     onMessage(callback: MessageCallback): () => void;
     onEvent(callback: EventCallback): () => void;
     ack(messageId: string): Promise<void>;
+    /**
+     * Edit a previously sent message. For E2EE messages the new plaintext is
+     * re-encrypted per recipient device exactly like a new message. For
+     * CLEARTEXT messages the server overwrites the stored plaintext.
+     * Edit window is unlimited.
+     */
+    editMessage(originalMessageId: string, toUserId: string, newPlaintext: string): Promise<{
+        editId: string;
+    }>;
+    /**
+     * Delete a previously sent message. Scope FOR_EVERYONE records a server
+     * tombstone and fans out a notification to recipient devices. Scope FOR_ME
+     * is local-only by convention but the server still records the tombstone
+     * (without fan-out) so the deletion survives across the sender's own devices.
+     * Delete window is unlimited.
+     */
+    deleteMessage(originalMessageId: string, toUserId: string, scope: 'FOR_EVERYONE' | 'FOR_ME'): Promise<{
+        deleteId: string;
+    }>;
+    /** Register a listener for incoming message-edit notifications. */
+    onMessageEdit(callback: MessageEditCallback): () => void;
+    /** Register a listener for incoming message-delete notifications. */
+    onMessageDelete(callback: MessageDeleteCallback): () => void;
     /** Send a cleartext message to a user (no encryption). */
     sendCleartextMessage(toUserId: string, plaintext: string): Promise<{
         messageId: string;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { InitializeOptions, DropOnAirClient } from './core/types';
 export { SDK_VERSION, PROTOCOL_VERSION, PAYLOAD_FORMAT_VERSION } from './version';
 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, } 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, MessageEditEvent, MessageEditCallback, MessageDeleteEvent, MessageDeleteCallback, } from './core/types';
 declare const _default: {
     initialize: typeof initialize;
 };

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

@@ -93,6 +93,38 @@ export interface WireGroupCallFrame {
     targetUserId?: string;
     payload?: string;
 }
+/**
+ * Edit frame, sender re-encrypts new content for all recipient devices.
+ * Same shape sent in both directions, client to server (request) and
+ * server to recipient devices (notification).
+ */
+export interface WireMessageEditFrame {
+    type: string;
+    editId: string;
+    originalMessageId: string;
+    appId: string;
+    fromUserId: string;
+    toUserId: string;
+    timestamp: number;
+    encryptionType: number;
+    encryptedPayload?: Uint8Array;
+    devicePayloads?: WireDeviceEncryptedPayload[];
+    senderDeviceId?: string;
+    plaintextPayload?: string;
+    clientEditId?: string;
+}
+/** Tombstone frame, scope FOR_EVERYONE or FOR_ME. */
+export interface WireMessageDeleteFrame {
+    type: string;
+    deleteId: string;
+    originalMessageId: string;
+    appId: string;
+    fromUserId: string;
+    toUserId: string;
+    timestamp: number;
+    scope: string;
+    clientDeleteId?: string;
+}
 export type InboundFrame = {
     kind: 'envelope';
     data: WireEnvelope;
@@ -117,6 +149,12 @@ export type InboundFrame = {
 } | {
     kind: 'groupCall';
     data: WireGroupCallFrame;
+} | {
+    kind: 'messageEdit';
+    data: WireMessageEditFrame;
+} | {
+    kind: 'messageDelete';
+    data: WireMessageDeleteFrame;
 };
 export declare class ProtobufCodec {
     encodeEnvelope(value: WireEnvelope): Uint8Array;
@@ -126,6 +164,8 @@ export declare class ProtobufCodec {
     encodeGroupEnvelope(value: WireGroupEnvelope): Uint8Array;
     encodeGroupCallFrame(value: WireGroupCallFrame): Uint8Array;
     encodeGroupAck(value: WireGroupAck): Uint8Array;
+    encodeMessageEditFrame(value: WireMessageEditFrame): Uint8Array;
+    encodeMessageDeleteFrame(value: WireMessageDeleteFrame): Uint8Array;
     decodeFrame(payload: Uint8Array): InboundFrame;
     private tryDecodeEnvelope;
     private tryDecodeAck;
@@ -135,4 +175,6 @@ export declare class ProtobufCodec {
     private tryDecodeGroupMessageNotification;
     private tryDecodeGroupAck;
     private tryDecodeGroupCallFrame;
+    private tryDecodeMessageEditFrame;
+    private tryDecodeMessageDeleteFrame;
 }

package/dist/transport/protobuf-codec.js

@@ -141,6 +141,47 @@ const GroupCallFrameType = new protobuf.Type('GroupCallFrame')
     .add(new protobuf.Field('groupId', 3, 'string'))
     .add(new protobuf.Field('targetUserId', 4, 'string'))
     .add(new protobuf.Field('payload', 5, 'string'));
+// ---------------------------------------------------------------------------
+// Message Edit and Delete (PROTOCOL_VERSION 3+)
+// ---------------------------------------------------------------------------
+//
+// E2EE invariant, server never sees plaintext for E2EE edits. The same frame
+// type is sent on the wire in both directions, client to server (request) and
+// server to recipient devices (notification).
+//
+// Type discriminator at field 1 mirrors the CallFrame pattern. Probed BEFORE
+// Envelope to avoid mis-routing.
+const MessageEditDeviceType = new protobuf.Type('DeviceEncryptedPayload')
+    .add(new protobuf.Field('deviceId', 1, 'string'))
+    .add(new protobuf.Field('encryptedPayload', 2, 'bytes'))
+    .add(new protobuf.Field('senderPublicKey', 3, 'bytes'));
+const MessageEditEncryptionTypeEnum = new protobuf.Enum('EncryptionType', { E2EE: 0, CLEARTEXT: 1 });
+const MessageEditFrameType = new protobuf.Type('MessageEditFrame')
+    .add(MessageEditEncryptionTypeEnum)
+    .add(MessageEditDeviceType)
+    .add(new protobuf.Field('type', 1, 'string'))
+    .add(new protobuf.Field('editId', 2, 'string'))
+    .add(new protobuf.Field('originalMessageId', 3, 'string'))
+    .add(new protobuf.Field('appId', 4, 'string'))
+    .add(new protobuf.Field('fromUserId', 5, 'string'))
+    .add(new protobuf.Field('toUserId', 6, 'string'))
+    .add(new protobuf.Field('timestamp', 7, 'int64'))
+    .add(new protobuf.Field('encryptionType', 8, 'EncryptionType'))
+    .add(new protobuf.Field('encryptedPayload', 9, 'bytes'))
+    .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'));
+const MessageDeleteFrameType = new protobuf.Type('MessageDeleteFrame')
+    .add(new protobuf.Field('type', 1, 'string'))
+    .add(new protobuf.Field('deleteId', 2, 'string'))
+    .add(new protobuf.Field('originalMessageId', 3, 'string'))
+    .add(new protobuf.Field('appId', 4, 'string'))
+    .add(new protobuf.Field('fromUserId', 5, 'string'))
+    .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'));
 class ProtobufCodec {
     encodeEnvelope(value) {
         return EnvelopeType.encode(value).finish();
@@ -163,7 +204,24 @@ class ProtobufCodec {
     encodeGroupAck(value) {
         return GroupAckType.encode(value).finish();
     }
+    encodeMessageEditFrame(value) {
+        return MessageEditFrameType.encode(value).finish();
+    }
+    encodeMessageDeleteFrame(value) {
+        return MessageDeleteFrameType.encode(value).finish();
+    }
     decodeFrame(payload) {
+        // Edit and delete frames must be probed BEFORE Envelope, the type
+        // discriminator at field 1 ("MESSAGE_EDIT" / "MESSAGE_DELETE") would
+        // otherwise parse as Envelope.messageId and could be mis-routed.
+        const asEdit = this.tryDecodeMessageEditFrame(payload);
+        if (asEdit) {
+            return { kind: 'messageEdit', data: asEdit };
+        }
+        const asDelete = this.tryDecodeMessageDeleteFrame(payload);
+        if (asDelete) {
+            return { kind: 'messageDelete', data: asDelete };
+        }
         const asEnvelope = this.tryDecodeEnvelope(payload);
         if (asEnvelope) {
             return { kind: 'envelope', data: asEnvelope };
@@ -333,5 +391,45 @@ class ProtobufCodec {
             return null;
         }
     }
+    tryDecodeMessageEditFrame(payload) {
+        try {
+            const decoded = MessageEditFrameType.decode(payload);
+            if (decoded.type !== 'MESSAGE_EDIT') {
+                return null;
+            }
+            const result = {
+                ...decoded,
+                timestamp: Number(decoded.timestamp),
+                encryptedPayload: decoded.encryptedPayload && decoded.encryptedPayload.length > 0
+                    ? new Uint8Array(decoded.encryptedPayload) : undefined,
+            };
+            if (decoded.devicePayloads && decoded.devicePayloads.length > 0) {
+                result.devicePayloads = decoded.devicePayloads.map(dp => ({
+                    deviceId: dp.deviceId,
+                    encryptedPayload: new Uint8Array(dp.encryptedPayload),
+                    senderPublicKey: new Uint8Array(dp.senderPublicKey),
+                }));
+            }
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    tryDecodeMessageDeleteFrame(payload) {
+        try {
+            const decoded = MessageDeleteFrameType.decode(payload);
+            if (decoded.type !== 'MESSAGE_DELETE') {
+                return null;
+            }
+            return {
+                ...decoded,
+                timestamp: Number(decoded.timestamp),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
 }
 exports.ProtobufCodec = ProtobufCodec;

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.3.1";
+export declare const SDK_VERSION = "0.4.0";
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can
@@ -19,4 +19,4 @@ export declare const PAYLOAD_FORMAT_VERSION = 1;
  * Increment when adding required proto fields or changing frame semantics.
  * The server advertises its supported range via GET /api/info.
  */
-export declare const PROTOCOL_VERSION = 2;
+export declare const PROTOCOL_VERSION = 3;

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.3.1';
+exports.SDK_VERSION = '0.4.0';
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can
@@ -22,4 +22,4 @@ exports.PAYLOAD_FORMAT_VERSION = 1;
  * Increment when adding required proto fields or changing frame semantics.
  * The server advertises its supported range via GET /api/info.
  */
-exports.PROTOCOL_VERSION = 2;
+exports.PROTOCOL_VERSION = 3;

package/package.json

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