@droponair/sdk-js 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -6,6 +6,36 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.12.0], 2026-05-20
+
+### Added
+
+- **Notification clear sync.** `client.clearNotification(conversationId)` tells the user's other devices a conversation's notifications were dismissed; `client.onNotificationCleared(cb)` listens for it. Always available (no opt-out) — it is plain own-device hygiene.
+- **Draft sync.** `client.syncDraft(conversationId, draftText)` pushes a conversation draft to the user's other devices; `client.onDraftSync(cb)` listens for it. **Opt-in:** the app owner enables it in the dashboard, and the draft text crosses the relay in cleartext (fanned out, never stored). When disabled the server drops the frame.
+- New exported types: `NotificationClearEvent` / `NotificationClearCallback`, `DraftSyncEvent` / `DraftSyncCallback`.
+
+### Notes
+
+- Both ride the existing `SyncFrame` wire type (own-device fan-out only, never delivered to a different user). No PROTOCOL_VERSION change.
+- Your app decides when to call `clearNotification()` / `syncDraft()` — the platform never infers dismissal or tracks drafts.
+
+---
+
+## [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

package/README.md

@@ -100,6 +100,38 @@ const client = await initialize(options);
 | `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. |
+| `clearNotification(conversationId)` | `void` | Tell the user's other devices a conversation's notifications were dismissed. |
+| `onNotificationCleared(callback)` | `() => void` | Listen for notification-clear syncs from the user's other devices. |
+| `syncDraft(conversationId, draftText)` | `void` | Push a conversation draft to the user's other devices (opt-in, cleartext). |
+| `onDraftSync(callback)` | `() => void` | Listen for draft syncs 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
+});
+```
+
+### Notification clear & draft sync
+
+Available since SDK `0.12.0`, both own-device only. `clearNotification()` tells your user's other devices a conversation's notifications were dismissed — always available. `syncDraft()` pushes a draft so the user can keep typing on another device — **opt-in** (the app owner enables it in the dashboard) and the draft text crosses the relay in cleartext.
+
+```typescript
+client.clearNotification(conversationId);
+client.onNotificationCleared(e => { /* clear badge for e.conversationId */ });
+
+client.syncDraft(conversationId, composerText);
+client.onDraftSync(e => { /* pre-fill composer with e.draftText */ });
+```
 
 ### Device trust
 

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, DeviceInfo } from './types';
+import { BroadcastCallback, CallEventCallback, DropOnAirClient, EventCallback, GroupCallEventCallback, GroupInfo, GroupMessageCallback, InitializeOptions, MessageCallback, MessageDeleteCallback, MessageEditCallback, TurnCredentials, DeviceInfo, ReadReceiptCallback, NotificationClearCallback, DraftSyncCallback } from './types';
 import { AttachmentRef, CreateUploadSessionOptions, DownloadedAttachment, PrepareAttachmentOptions, UploadSession } from '../attachment/attachment-types';
 export declare class MessagingClient implements DropOnAirClient {
     private readonly options;
@@ -71,6 +71,9 @@ export declare class MessagingClient implements DropOnAirClient {
     private readonly eventListeners;
     private readonly broadcastListeners;
     private readonly messageEditListeners;
+    private readonly readReceiptListeners;
+    private readonly notificationClearListeners;
+    private readonly draftSyncListeners;
     private readonly messageDeleteListeners;
     /** ------------------------------------------------------------------
      * Lightweight structured logger. Only active when options.debug === true.
@@ -102,6 +105,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;
     }>;
@@ -157,6 +166,40 @@ export declare class MessagingClient implements DropOnAirClient {
      * 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;
+    /**
+     * Tell this user's other devices that the notification(s) for a
+     * conversation have been dismissed - call this when YOUR app dismisses a
+     * notification or the user opens the conversation. The other devices clear
+     * the matching badge. The relay never decides what "dismissed" means.
+     */
+    clearNotification(conversationId: string): void;
+    /**
+     * Push the current draft text for a conversation to this user's other
+     * devices so the user can continue typing on another device. Draft sync is
+     * opt-in: the app owner must enable it in the dashboard, and the draft text
+     * crosses the relay in cleartext (it is fanned out, never stored). If the
+     * feature is disabled the server silently drops the frame.
+     */
+    syncDraft(conversationId: string, draftText: string): void;
+    /** Register a listener for notification-clear syncs from the user's other devices. */
+    onNotificationCleared(callback: NotificationClearCallback): () => void;
+    /** Register a listener for draft syncs from the user's other devices. */
+    onDraftSync(callback: DraftSyncCallback): () => void;
+    private handleIncomingSync;
     sendCleartextMessage(toUserId: string, plaintext: string): Promise<{
         messageId: string;
     }>;

package/dist/core/messaging-client.js

@@ -220,6 +220,9 @@ class MessagingClient {
         this.eventListeners = new Set();
         this.broadcastListeners = new Set();
         this.messageEditListeners = new Set();
+        this.readReceiptListeners = new Set();
+        this.notificationClearListeners = new Set();
+        this.draftSyncListeners = 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 +413,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+)
     // ---------------------------------------------------------------------------
@@ -630,6 +642,122 @@ class MessagingClient {
         }
     }
     // ---------------------------------------------------------------------------
+    // 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));
+    }
+    /**
+     * Tell this user's other devices that the notification(s) for a
+     * conversation have been dismissed - call this when YOUR app dismisses a
+     * notification or the user opens the conversation. The other devices clear
+     * the matching badge. The relay never decides what "dismissed" means.
+     */
+    clearNotification(conversationId) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('DropOnAir websocket is not connected');
+        }
+        const frame = {
+            type: 'SYNC_CLEAR_NOTIFICATION',
+            messageId: '',
+            conversationId,
+            timestamp: Date.now(),
+        };
+        this.ws.send(this.codec.encodeSyncFrame(frame));
+    }
+    /**
+     * Push the current draft text for a conversation to this user's other
+     * devices so the user can continue typing on another device. Draft sync is
+     * opt-in: the app owner must enable it in the dashboard, and the draft text
+     * crosses the relay in cleartext (it is fanned out, never stored). If the
+     * feature is disabled the server silently drops the frame.
+     */
+    syncDraft(conversationId, draftText) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('DropOnAir websocket is not connected');
+        }
+        const frame = {
+            type: 'SYNC_DRAFT',
+            messageId: '',
+            conversationId,
+            timestamp: Date.now(),
+            payload: draftText,
+        };
+        this.ws.send(this.codec.encodeSyncFrame(frame));
+    }
+    /** Register a listener for notification-clear syncs from the user's other devices. */
+    onNotificationCleared(callback) {
+        this.notificationClearListeners.add(callback);
+        return () => this.notificationClearListeners.delete(callback);
+    }
+    /** Register a listener for draft syncs from the user's other devices. */
+    onDraftSync(callback) {
+        this.draftSyncListeners.add(callback);
+        return () => this.draftSyncListeners.delete(callback);
+    }
+    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 */ }
+            }
+        }
+        else if (frame.type === 'SYNC_CLEAR_NOTIFICATION') {
+            const event = {
+                conversationId: frame.conversationId || '',
+                timestamp: frame.timestamp,
+            };
+            for (const listener of this.notificationClearListeners) {
+                try {
+                    listener(event);
+                }
+                catch { /* listener errors must not break the socket */ }
+            }
+        }
+        else if (frame.type === 'SYNC_DRAFT') {
+            const event = {
+                conversationId: frame.conversationId || '',
+                draftText: frame.payload || '',
+                timestamp: frame.timestamp,
+            };
+            for (const listener of this.draftSyncListeners) {
+                try {
+                    listener(event);
+                }
+                catch { /* listener errors must not break the socket */ }
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
     // Cleartext messaging (no E2EE key exchange required)
     // ---------------------------------------------------------------------------
     async sendCleartextMessage(toUserId, plaintext) {
@@ -1389,6 +1517,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,38 @@ 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;
+/**
+ * Delivered to the user's OTHER devices when one device calls
+ * clearNotification(). Use it to clear the conversation's notification badge.
+ */
+export interface NotificationClearEvent {
+    conversationId: string;
+    timestamp: number;
+}
+export type NotificationClearCallback = (event: NotificationClearEvent) => void;
+/**
+ * Delivered to the user's OTHER devices when one device calls syncDraft().
+ * Use it to pre-fill the message composer for that conversation. Draft sync
+ * is opt-in and the text crosses the relay in cleartext.
+ */
+export interface DraftSyncEvent {
+    conversationId: string;
+    draftText: string;
+    timestamp: number;
+}
+export type DraftSyncCallback = (event: DraftSyncEvent) => void;
 export interface BroadcastMessage {
     broadcastId: string;
     channelId: string;
@@ -183,6 +215,28 @@ 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;
+    /**
+     * Tell the user's other devices a conversation's notifications were
+     * dismissed. The app decides what "dismissed" means.
+     */
+    clearNotification(conversationId: string): void;
+    /** Listen for notification-clear syncs from the user's other devices. */
+    onNotificationCleared(callback: NotificationClearCallback): () => void;
+    /**
+     * Push a conversation draft to the user's other devices. Opt-in; the draft
+     * text crosses the relay in cleartext and is never stored.
+     */
+    syncDraft(conversationId: string, draftText: string): void;
+    /** Listen for draft syncs from the user's other devices. */
+    onDraftSync(callback: DraftSyncCallback): () => 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

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, DeviceInfo, } 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, NotificationClearEvent, NotificationClearCallback, DraftSyncEvent, DraftSyncCallback, } 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,17 @@ 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;
+    payload?: string;
+}
 /** Tombstone frame, scope FOR_EVERYONE or FOR_ME. */
 export interface WireMessageDeleteFrame {
     type: string;
@@ -190,6 +201,9 @@ export type InboundFrame = {
 } | {
     kind: 'messageDelete';
     data: WireMessageDeleteFrame;
+} | {
+    kind: 'sync';
+    data: WireSyncFrame;
 };
 export declare class ProtobufCodec {
     encodeEnvelope(value: WireEnvelope): Uint8Array;
@@ -202,6 +216,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 +226,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,15 @@ 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'))
+    .add(new protobuf.Field('payload', 5, 'string'));
 class ProtobufCodec {
     encodeEnvelope(value) {
         return EnvelopeType.encode(value).finish();
@@ -248,6 +257,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 +272,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 +463,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.10.0";
+export declare const SDK_VERSION = "0.12.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.10.0';
+exports.SDK_VERSION = '0.12.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.10.0",
+  "version": "0.12.0",
   "description": "DropOnAir SDK for end-to-end encrypted messaging",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",