@droponair/sdk-js 0.9.1 → 0.11.0

package/CHANGELOG.md

@@ -6,6 +6,36 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.11.0], 2026-05-20
+
+### Added
+
+- **Cross-device read receipts.** New `client.markRead(messageId, conversationId?)` reports a message as read; the receipt is relayed to the user's *other* devices (never to the message's sender). New `client.onReadReceipt(callback)` listens for receipts reported by the user's other devices — use it to clear unread state your app maintains.
+- New exported `ReadReceiptEvent` type and `ReadReceiptCallback`.
+- **PROTOCOL_VERSION bumped to 6.** Additive only: new `SyncFrame` wire type. Existing 0.10.x clients keep working against the new server.
+
+### Notes
+
+- The platform is deliberately unopinionated: **your app decides when `markRead()` is called** — the server never infers read state, and unread counts stay client-side. The app owner can disable read receipts entirely from the dashboard, in which case the server silently drops the frame.
+- This release is own-device sync only: the *sender* of a message is not told when a recipient read it. Sender-side read notifications are a separate future capability.
+
+---
+
+## [0.10.0], 2026-05-20
+
+### Added
+
+- **Device trust.** New `client.listMyDevices()` returns the current user's registered devices; `client.revokeMyDevice(deviceId)` revokes one of them. A revoked device's live session is closed immediately and all future connections from it are denied (revoke is permanent — re-registering yields a fresh deviceId).
+- **`DEVICE_REVOKED` event.** When this device is revoked (from another of the user's devices, or by the app owner), the SDK stops its reconnect loop, closes the socket, and surfaces a `DEVICE_REVOKED` event through `onEvent` so the app can clear local key storage and show a re-register prompt.
+- New exported `DeviceInfo` type.
+
+### Notes
+
+- No wire-format change; PROTOCOL_VERSION stays at 5. The new surface is REST (`/v1/devices`) plus an additive event type.
+- Any device that completes a connection is implicitly trusted. There is no explicit pairing/attestation step in this release.
+
+---
+
 ## [0.9.1], 2026-05-19
 
 ### Fixed

package/README.md

@@ -98,6 +98,39 @@ const client = await initialize(options);
 | `ack(messageId)` | `Promise<void>` | Manually acknowledge a message |
 | `registerPushToken({ platform, token, voipToken? })` | `Promise<void>` | Register this device for push notifications. `platform` is `'APNS'`, `'FCM'`, or `'WEB_PUSH'`. |
 | `unregisterPushToken({ platform })` | `Promise<void>` | Unregister this device for push notifications (e.g. on logout). |
+| `listMyDevices()` | `Promise<DeviceInfo[]>` | List the current user's registered devices. |
+| `revokeMyDevice(deviceId)` | `Promise<DeviceInfo>` | Revoke one of the current user's devices. Permanent. |
+| `markRead(messageId, conversationId?)` | `void` | Mark a message as read; relays a receipt to the user's other devices. |
+| `onReadReceipt(callback)` | `() => void` | Listen for read receipts from the user's other devices. |
+
+### Cross-device read receipts
+
+Available since SDK `0.11.0`. **Your app decides when a message is read** — the platform never infers it. Call `markRead()` at that moment; the receipt syncs to the user's *other* devices so they can clear their unread UI. It is not sent to the message's sender. The app owner can switch read receipts off entirely from the dashboard.
+
+```typescript
+// When your UI decides the message has been read
+client.markRead(messageId, peerUserId);
+
+// On the user's other devices
+client.onReadReceipt(e => {
+  // e.messageId was read elsewhere — clear your unread state for it
+});
+```
+
+### Device trust
+
+Available since SDK `0.10.0`. Any device that completes a connection is implicitly trusted. `listMyDevices()` powers a "Your devices" screen; `revokeMyDevice()` cuts a device off immediately. When the *current* device is revoked, the SDK stops reconnecting and emits a `DEVICE_REVOKED` event via `onEvent` — listen for it to clear local key storage and prompt re-registration.
+
+```typescript
+const devices = await client.listMyDevices();
+await client.revokeMyDevice('old-phone-device-id');
+
+client.onEvent(e => {
+  if (e.type === 'DEVICE_REVOKED') {
+    // This device was revoked elsewhere. Clear local keys and show a re-register screen.
+  }
+});
+```
 
 ### Push notifications
 

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, MessageDeleteCallback, MessageEditCallback, TurnCredentials } from './types';
+import { BroadcastCallback, CallEventCallback, DropOnAirClient, EventCallback, GroupCallEventCallback, GroupInfo, GroupMessageCallback, InitializeOptions, MessageCallback, MessageDeleteCallback, MessageEditCallback, TurnCredentials, DeviceInfo, ReadReceiptCallback } from './types';
 import { AttachmentRef, CreateUploadSessionOptions, DownloadedAttachment, PrepareAttachmentOptions, UploadSession } from '../attachment/attachment-types';
 export declare class MessagingClient implements DropOnAirClient {
     private readonly options;
@@ -71,6 +71,7 @@ export declare class MessagingClient implements DropOnAirClient {
     private readonly eventListeners;
     private readonly broadcastListeners;
     private readonly messageEditListeners;
+    private readonly readReceiptListeners;
     private readonly messageDeleteListeners;
     /** ------------------------------------------------------------------
      * Lightweight structured logger. Only active when options.debug === true.
@@ -102,6 +103,12 @@ export declare class MessagingClient implements DropOnAirClient {
     onEvent(callback: EventCallback): () => void;
     onMessageEdit(callback: MessageEditCallback): () => void;
     onMessageDelete(callback: MessageDeleteCallback): () => void;
+    /**
+     * Register a listener for read receipts that this user's OTHER devices
+     * reported. Fires when another device of the same user calls markRead();
+     * use it to clear the unread state your app maintains for that message.
+     */
+    onReadReceipt(callback: ReadReceiptCallback): () => void;
     editMessage(originalMessageId: string, toUserId: string, newPlaintext: string): Promise<{
         editId: string;
     }>;
@@ -136,6 +143,42 @@ export declare class MessagingClient implements DropOnAirClient {
     unregisterPushToken(opts: {
         platform: 'APNS' | 'FCM' | 'WEB_PUSH';
     }): Promise<void>;
+    /**
+     * List the current user's registered devices. Each device is implicitly
+     * trusted once it has completed a connection. Useful for a "Your devices"
+     * settings screen.
+     */
+    listMyDevices(): Promise<DeviceInfo[]>;
+    /**
+     * Revoke one of the current user's devices. The revoked device's live
+     * WebSocket session (if any) is closed immediately and all future
+     * connection attempts from that device are denied. Revoke is permanent;
+     * the user must re-register the device (which yields a fresh deviceId).
+     */
+    revokeMyDevice(deviceId: string): Promise<DeviceInfo>;
+    /**
+     * Handles an inbound DEVICE_REVOKED event: this device has been revoked
+     * (by the user from another device, or by the app owner). Stops the
+     * reconnect loop and closes the socket. The DEVICE_REVOKED event is also
+     * surfaced through onEvent so the app can clear local key storage and
+     * show a re-register prompt.
+     */
+    private handleDeviceRevoked;
+    /**
+     * Mark a message as read. Call this when YOUR app decides a message has
+     * been read - the platform never infers read state for you. The receipt
+     * is relayed to this user's other devices so they can clear their unread
+     * UI for the same message; it is not delivered to the message's sender.
+     *
+     * If the app owner has disabled read receipts in the dashboard, the server
+     * silently drops the frame.
+     *
+     * @param messageId       the message that was read
+     * @param conversationId  optional peer userId / group id, echoed back to
+     *                        other devices so they can bucket the receipt
+     */
+    markRead(messageId: string, conversationId?: string): void;
+    private handleIncomingSync;
     sendCleartextMessage(toUserId: string, plaintext: string): Promise<{
         messageId: string;
     }>;

package/dist/core/messaging-client.js

@@ -220,6 +220,7 @@ class MessagingClient {
         this.eventListeners = new Set();
         this.broadcastListeners = new Set();
         this.messageEditListeners = new Set();
+        this.readReceiptListeners = new Set();
         this.messageDeleteListeners = new Set();
         this.wsUrl = options.messagingWsUrl ?? 'wss://sdk.droponair.com/ws';
         this.httpUrl = options.messagingHttpUrl ?? 'https://sdk.droponair.com';
@@ -410,6 +411,15 @@ class MessagingClient {
         this.messageDeleteListeners.add(callback);
         return () => this.messageDeleteListeners.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();
+     * use it to clear the unread state your app maintains for that message.
+     */
+    onReadReceipt(callback) {
+        this.readReceiptListeners.add(callback);
+        return () => this.readReceiptListeners.delete(callback);
+    }
     // ---------------------------------------------------------------------------
     // Message edit and delete (PROTOCOL_VERSION 3+)
     // ---------------------------------------------------------------------------
@@ -577,6 +587,102 @@ class MessagingClient {
         this.ws.send(this.codec.encodePushRegistrationFrame(frame));
     }
     // ---------------------------------------------------------------------------
+    // Device trust (PROTOCOL_VERSION 5+ / Phase 2b)
+    // ---------------------------------------------------------------------------
+    /**
+     * List the current user's registered devices. Each device is implicitly
+     * trusted once it has completed a connection. Useful for a "Your devices"
+     * settings screen.
+     */
+    async listMyDevices() {
+        const jwt = await this.getValidDropOnAirJwt(false);
+        const resp = await this.fetchFn(`${this.httpUrl}/v1/devices`, {
+            headers: { Authorization: `Bearer ${jwt}` },
+        });
+        if (!resp.ok) {
+            throw new Error(`Failed to list devices: ${resp.status}`);
+        }
+        return (await resp.json());
+    }
+    /**
+     * Revoke one of the current user's devices. The revoked device's live
+     * WebSocket session (if any) is closed immediately and all future
+     * connection attempts from that device are denied. Revoke is permanent;
+     * the user must re-register the device (which yields a fresh deviceId).
+     */
+    async revokeMyDevice(deviceId) {
+        const jwt = await this.getValidDropOnAirJwt(false);
+        const resp = await this.fetchFn(`${this.httpUrl}/v1/devices/${encodeURIComponent(deviceId)}`, {
+            method: 'DELETE',
+            headers: { Authorization: `Bearer ${jwt}` },
+        });
+        if (!resp.ok) {
+            throw new Error(`Failed to revoke device: ${resp.status}`);
+        }
+        return (await resp.json());
+    }
+    /**
+     * Handles an inbound DEVICE_REVOKED event: this device has been revoked
+     * (by the user from another device, or by the app owner). Stops the
+     * reconnect loop and closes the socket. The DEVICE_REVOKED event is also
+     * surfaced through onEvent so the app can clear local key storage and
+     * show a re-register prompt.
+     */
+    handleDeviceRevoked() {
+        this.shouldReconnect = false;
+        this.rateLimited = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.close(4001, 'DEVICE_REVOKED');
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Cross-device read receipts (PROTOCOL_VERSION 6+ / Phase 2c)
+    // ---------------------------------------------------------------------------
+    /**
+     * Mark a message as read. Call this when YOUR app decides a message has
+     * been read - the platform never infers read state for you. The receipt
+     * is relayed to this user's other devices so they can clear their unread
+     * UI for the same message; it is not delivered to the message's sender.
+     *
+     * If the app owner has disabled read receipts in the dashboard, the server
+     * silently drops the frame.
+     *
+     * @param messageId       the message that was read
+     * @param conversationId  optional peer userId / group id, echoed back to
+     *                        other devices so they can bucket the receipt
+     */
+    markRead(messageId, conversationId) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('DropOnAir websocket is not connected');
+        }
+        const frame = {
+            type: 'SYNC_READ_RECEIPT',
+            messageId,
+            conversationId: conversationId ?? '',
+            timestamp: Date.now(),
+        };
+        this.ws.send(this.codec.encodeSyncFrame(frame));
+    }
+    handleIncomingSync(frame) {
+        if (frame.type === 'SYNC_READ_RECEIPT') {
+            const event = {
+                messageId: frame.messageId,
+                conversationId: frame.conversationId || undefined,
+                timestamp: frame.timestamp,
+            };
+            for (const listener of this.readReceiptListeners) {
+                try {
+                    listener(event);
+                }
+                catch { /* listener errors must not break the socket */ }
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
     // Cleartext messaging (no E2EE key exchange required)
     // ---------------------------------------------------------------------------
     async sendCleartextMessage(toUserId, plaintext) {
@@ -1272,6 +1378,10 @@ class MessagingClient {
                     if (frame.data.type === 'LIMIT_REACHED') {
                         this.rateLimited = true;
                     }
+                    if (frame.data.type === 'DEVICE_REVOKED') {
+                        this.log('device_revoked_received', { metadata: frame.data.metadata });
+                        this.handleDeviceRevoked();
+                    }
                     if (frame.data.type === 'ERROR' && frame.data.reason === 'JWT_EXPIRED') {
                         this.dropOnAirJwt = null;
                         this.currentUserId = null;
@@ -1332,6 +1442,10 @@ class MessagingClient {
                     this.handleIncomingMessageDelete(frame.data);
                     return;
                 }
+                if (frame.kind === 'sync') {
+                    this.handleIncomingSync(frame.data);
+                    return;
+                }
                 if (frame.kind === 'envelope') {
                     await this.handleIncomingEnvelope(frame.data);
                 }

package/dist/core/types.d.ts

@@ -48,6 +48,18 @@ export interface MessageDeleteEvent {
 }
 export type MessageEditCallback = (event: MessageEditEvent) => void;
 export type MessageDeleteCallback = (event: MessageDeleteEvent) => 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.
+ * It is NOT delivered to the original sender of the message.
+ */
+export interface ReadReceiptEvent {
+    messageId: string;
+    /** Optional peer userId / group id, echoed from markRead() for bucketing. */
+    conversationId?: string;
+    timestamp: number;
+}
+export type ReadReceiptCallback = (event: ReadReceiptEvent) => void;
 export interface BroadcastMessage {
     broadcastId: string;
     channelId: string;
@@ -132,6 +144,19 @@ export interface InitializeOptions {
      */
     autoAckIncomingMessages?: boolean;
 }
+/** A registered device as returned by {@link DropOnAirClient.listMyDevices}. */
+export interface DeviceInfo {
+    deviceId: string;
+    sdkVersion?: string;
+    protocolVersion?: string;
+    platform?: string;
+    /** ISO-8601 timestamps. */
+    firstSeenAt?: string;
+    lastSeenAt?: string;
+    /** Non-null once revoked. */
+    revokedAt?: string;
+    revokedBy?: 'END_USER' | 'APP_OWNER' | 'SYSTEM';
+}
 export interface DropOnAirClient {
     connect(): Promise<void>;
     disconnect(): void;
@@ -170,6 +195,14 @@ export interface DropOnAirClient {
     onMessageEdit(callback: MessageEditCallback): () => void;
     /** Register a listener for incoming message-delete notifications. */
     onMessageDelete(callback: MessageDeleteCallback): () => void;
+    /**
+     * Mark a message as read. The integrating app decides when this is called;
+     * the platform never infers read state. The receipt is relayed to the
+     * user's other devices only, never to the message's sender.
+     */
+    markRead(messageId: string, conversationId?: string): void;
+    /** Register a listener for read receipts reported by this user's other devices. */
+    onReadReceipt(callback: ReadReceiptCallback): () => void;
     /**
      * Register this device's push notification token. The platform delivers a
      * push via APNs / FCM / Web Push when a sender attaches a pushPayload to
@@ -187,6 +220,14 @@ export interface DropOnAirClient {
     unregisterPushToken(opts: {
         platform: 'APNS' | 'FCM' | 'WEB_PUSH';
     }): Promise<void>;
+    /** List the current user's registered devices. */
+    listMyDevices(): Promise<DeviceInfo[]>;
+    /**
+     * Revoke one of the current user's devices. The revoked device's live
+     * session is closed and all future connections from it are denied.
+     * Revoke is permanent.
+     */
+    revokeMyDevice(deviceId: string): Promise<DeviceInfo>;
     /**
      * Convenience: encrypts (E2EE), uploads to the customer's bucket, finalizes,
      * and returns an AttachmentRef ready to pass into {@link sendMessage}.

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, MessageEditEvent, MessageEditCallback, MessageDeleteEvent, MessageDeleteCallback, } 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, DeviceInfo, ReadReceiptEvent, ReadReceiptCallback, } from './core/types';
 export type { AttachmentEncryptionType, AttachmentConversationType, AttachmentRef, DeviceWrappedKey, CreateUploadSessionOptions, UploadSession, PrepareAttachmentOptions, DownloadedAttachment, } from './attachment/attachment-types';
 declare const _default: {
     initialize: typeof initialize;

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

@@ -148,6 +148,16 @@ export interface WirePushRegistrationFrame {
     voipToken?: string;
     deviceId: string;
 }
+/**
+ * Cross-device state sync frame (PROTOCOL_VERSION 6+). Same shape sent
+ * client -> server and relayed server -> the user's other devices.
+ */
+export interface WireSyncFrame {
+    type: string;
+    messageId: string;
+    conversationId?: string;
+    timestamp: number;
+}
 /** Tombstone frame, scope FOR_EVERYONE or FOR_ME. */
 export interface WireMessageDeleteFrame {
     type: string;
@@ -190,6 +200,9 @@ export type InboundFrame = {
 } | {
     kind: 'messageDelete';
     data: WireMessageDeleteFrame;
+} | {
+    kind: 'sync';
+    data: WireSyncFrame;
 };
 export declare class ProtobufCodec {
     encodeEnvelope(value: WireEnvelope): Uint8Array;
@@ -202,6 +215,7 @@ export declare class ProtobufCodec {
     encodeMessageEditFrame(value: WireMessageEditFrame): Uint8Array;
     encodeMessageDeleteFrame(value: WireMessageDeleteFrame): Uint8Array;
     encodePushRegistrationFrame(value: WirePushRegistrationFrame): Uint8Array;
+    encodeSyncFrame(value: WireSyncFrame): Uint8Array;
     decodeFrame(payload: Uint8Array): InboundFrame;
     private tryDecodeEnvelope;
     private tryDecodeAck;
@@ -211,6 +225,7 @@ export declare class ProtobufCodec {
     private tryDecodeGroupMessageNotification;
     private tryDecodeGroupAck;
     private tryDecodeGroupCallFrame;
+    private tryDecodeSyncFrame;
     private tryDecodeMessageEditFrame;
     private tryDecodeMessageDeleteFrame;
 }

package/dist/transport/protobuf-codec.js

@@ -217,6 +217,14 @@ const PushRegistrationFrameType = new protobuf.Type('PushRegistrationFrame')
     .add(new protobuf.Field('token', 3, 'string'))
     .add(new protobuf.Field('voipToken', 4, 'string'))
     .add(new protobuf.Field('deviceId', 5, 'string'));
+// Cross-device state sync frame (PROTOCOL_VERSION 6+). Same shape both
+// directions: client -> server (request) and server -> the user's other
+// devices (notification). Discriminator is `type` at field 1 ("SYNC_").
+const SyncFrameType = new protobuf.Type('SyncFrame')
+    .add(new protobuf.Field('type', 1, 'string'))
+    .add(new protobuf.Field('messageId', 2, 'string'))
+    .add(new protobuf.Field('conversationId', 3, 'string'))
+    .add(new protobuf.Field('timestamp', 4, 'int64'));
 class ProtobufCodec {
     encodeEnvelope(value) {
         return EnvelopeType.encode(value).finish();
@@ -248,6 +256,9 @@ class ProtobufCodec {
     encodePushRegistrationFrame(value) {
         return PushRegistrationFrameType.encode(value).finish();
     }
+    encodeSyncFrame(value) {
+        return SyncFrameType.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
@@ -260,6 +271,11 @@ class ProtobufCodec {
         if (asDelete) {
             return { kind: 'messageDelete', data: asDelete };
         }
+        // SyncFrame: discriminator "SYNC_" at field 1, probed before Envelope.
+        const asSync = this.tryDecodeSyncFrame(payload);
+        if (asSync) {
+            return { kind: 'sync', data: asSync };
+        }
         const asEnvelope = this.tryDecodeEnvelope(payload);
         if (asEnvelope) {
             return { kind: 'envelope', data: asEnvelope };
@@ -446,6 +462,18 @@ class ProtobufCodec {
             return null;
         }
     }
+    tryDecodeSyncFrame(payload) {
+        try {
+            const decoded = SyncFrameType.decode(payload);
+            if (!decoded.type || !decoded.type.startsWith('SYNC_')) {
+                return null;
+            }
+            return { ...decoded, timestamp: Number(decoded.timestamp) };
+        }
+        catch {
+            return null;
+        }
+    }
     tryDecodeMessageEditFrame(payload) {
         try {
             const decoded = MessageEditFrameType.decode(payload);

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.9.1";
+export declare const SDK_VERSION = "0.11.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 = 5;
+export declare const PROTOCOL_VERSION = 6;

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.9.1';
+exports.SDK_VERSION = '0.11.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 = 5;
+exports.PROTOCOL_VERSION = 6;

package/package.json

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