@droponair/sdk-js 0.19.0 → 0.22.0

package/CHANGELOG.md

@@ -6,6 +6,44 @@ This project follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.22.0], 2026-05-25
+
+### Added
+
+- **MessagingClient transport selection.** `initialize({ transport: 'ws' | 'sse' | 'wt' | 'auto' })` lets your app choose the signaling lane at init time. Default stays `'ws'`, so existing integrations are byte-identical. `'auto'` queries `GET /api/info.transports` and picks the best available lane from what the runtime supports. WebSocket close-code semantics (1008 JWT-expiry surfacing, 4001 JWT-refresh-on-event) are preserved on the WebSocket path; SSE/WT synthesize close events.
+- **MQTT (IoT) broadcast lane (4.5b).** Broadcasts now mirror to MQTT topic `droponair/v1/broadcast/{appId}/{channelId}` on `mqtts://mqtt.droponair.com:8883`. For IoT subscribers that consume your broadcasts without our full SDK. Subscribe-only, per-app credentials, TLS only. Visible via `GET /api/info` (`transports` includes `"mqtt"`, `features` includes `"transport_mqtt"`). No SDK API change, the lane is consumed directly by MQTT clients.
+
+### Changed
+
+- `MessagingClient` now uses an internal `MessagingTransport` adapter rather than a direct `WebSocket` reference. WebSocket remains the default; no protocol change. Adapters: `WebSocketMessagingTransport` (default), `SseMessagingTransport`, `WtMessagingTransport`.
+
+---
+
+## [0.21.0], 2026-05-24
+
+### Added
+
+- **Transport auto-select helper (Phase 4.6).** New `selectTransport({ httpUrl })` reads `/api/info.transports`, intersects with the runtime's `WebTransport`/`WebSocket`/`EventSource` availability, and returns the best lane (preference: WebTransport -> WebSocket -> SSE; overridable via `preference`). Caller then constructs the corresponding primitive. Pluggable `fetchFn` for Node + tests.
+
+### Notes
+
+- Foundation for an `init({ transport: 'auto' })` shortcut once full `MessagingClient` integration lands (4.2.1b). Today it's a small standalone helper so existing customers can adopt the pattern without waiting.
+
+---
+
+## [0.20.0], 2026-05-24
+
+### Added
+
+- **WebTransport (HTTP/3) transport primitive (Phase 4.3).** New `WebTransportTransport` class uses the browser-native `WebTransport` API to ride the platform's `/v1/transport/wt` HTTP/3 endpoint, terminated by the `droponair-webtransport` sidecar. Same shape as `SseTransport`: `onFrame`, `sendEnvelope`, `connect`, `close`. Caller brings own protobuf decoder. Browser-only for v1 (Chromium 97+, Firefox 125+, Safari TP-only); Node 22+ has experimental support behind flags.
+
+### Notes
+
+- WebTransport gives multi-stream perf wins over WebSocket on flaky cellular and similar networks. WebSocket on `/ws` remains the default; this primitive is opt-in for environments that have native WebTransport.
+- The droponair.com endpoint only advertises `transports: ["webtransport"]` once the `droponair-webtransport` sidecar is up and `app.transport.webtransport-enabled` is flipped on sdk-be. Check `GET /api/info.transports` for the live list.
+
+---
+
 ## [0.19.0], 2026-05-24
 
 ### Added

package/README.md

@@ -397,6 +397,61 @@ await client.stopSfuRecording(room.roomId, rec.recordingId);
 
 Completion lands as the `sfu-recording.completed` webhook (or by polling `listSfuRecordings`) and carries `locationUri` pointing at the finalized file in your bucket. E2EE-encrypted SFU rooms cannot be server-recorded by design (the media server forwards traffic it cannot decrypt) - use the client-side `startRecording` for those.
 
+Live call participants also receive in-band notification frames via the existing group-call event callback so a "🔴 RECORDING" UI badge stays in sync. The event types are `GROUP_CALL_SFU_RECORDING_STARTED` (payload = recordingId), `GROUP_CALL_SFU_RECORDING_STOPPED` (recordingId), and `GROUP_CALL_SFU_RECORDING_AVAILABLE` (`recordingId|locationUri`); the platform also notifies late joiners about any already-active SFU recording on the room. Plan limits (`maxSfuRecordingMinutesPerMonth`) are enforced server-side; deny at `startSfuRecording` returns HTTP 403 with a deny reason such as `MONTHLY_SFU_RECORDING_MINUTES_LIMIT_REACHED`.
+
+### HTTP fallback (SSE) transport
+
+Available since SDK `0.19.0`. For environments where WebSocket upgrades are blocked by a corporate firewall but plain HTTPS GET/POST work, the SDK exports a standalone `SseTransport` primitive that rides the platform's `/v1/transport/stream` (long-lived SSE) and `/v1/transport/send` (POST) endpoints. WebSocket on `/ws` remains the default for `client.connect()`; this primitive is opt-in for the corporate-firewall use case.
+
+```typescript
+import { SseTransport } from '@droponair/sdk-js';
+
+const sse = new SseTransport({
+  httpUrl: 'https://sdk.droponair.com',
+  getJwt: async () => jwt,
+});
+sse.onFrame((bytes) => { /* protobuf decode */ });
+await sse.connect();
+await sse.sendEnvelope(envelopeBytes);
+```
+
+EventSource-based receive (auto-reconnects + 25s keep-alives that defeat proxy idle timeouts), `fetch` POST for send. Bring your own protobuf decoder (use the codec already exported by the SDK). Verify the lane is enabled on the server via `GET /api/info`: the `transports` array includes `"sse"` and `features` includes `"transport_sse"`. v1 covers 1:1 Envelope delivery; call signaling stays on WebSocket. Full `init({ transport: 'sse' })` integration into `MessagingClient` lands in a follow-up.
+
+### WebTransport (HTTP/3) transport
+
+Available since SDK `0.20.0`. For modern browsers + environments with native HTTP/3 support, the SDK exports a `WebTransportTransport` primitive that rides the platform's `/v1/transport/wt` endpoint. Multi-stream and lower head-of-line blocking versus WebSocket; particularly useful on flaky cellular networks.
+
+```typescript
+import { WebTransportTransport } from '@droponair/sdk-js';
+
+const wt = new WebTransportTransport({
+  httpUrl: 'https://sdk.droponair.com',
+  getJwt: async () => jwt,
+});
+wt.onFrame((bytes) => { /* protobuf decode */ });
+await wt.connect();
+await wt.sendEnvelope(envelopeBytes);
+```
+
+Uses the browser-native `WebTransport` API; opens a single bidirectional stream and rides raw bytes both ways. Browser support: Chromium 97+ (stable), Firefox 125+ (stable), Safari Technology Preview only, Node 22+ behind experimental flags. The `droponair.com` endpoint advertises `transports: ["webtransport"]` only when the `droponair-webtransport` sidecar is live; check `GET /api/info.transports` and `features.transport_webtransport` to detect availability. Bring your own protobuf decoder. WebSocket remains the default; this primitive is purely opt-in.
+
+### Transport auto-select
+
+Available since SDK `0.21.0`. `selectTransport({ httpUrl })` queries `/api/info.transports`, intersects with what the runtime supports (`WebTransport` / `WebSocket` / `EventSource`), and returns the best lane for this client + platform pair. Default preference: WebTransport → WebSocket → SSE (overridable).
+
+```typescript
+import { selectTransport, WebTransportTransport, SseTransport } from '@droponair/sdk-js';
+
+const lane = await selectTransport({ httpUrl: 'https://sdk.droponair.com' });
+switch (lane) {
+  case 'webtransport': /* new WebTransportTransport(...) */ break;
+  case 'sse':          /* new SseTransport(...) */          break;
+  default:             /* fall through to your WebSocket client */
+}
+```
+
+Foundation for an `init({ transport: 'auto' })` shortcut once full `MessagingClient` integration lands (a follow-up). Today it's a small standalone helper so existing customers can adopt the pattern without waiting.
+
 ### Call Recording
 
 Available since SDK `0.16.0`. The SDK **signals** recording state on a group or room call; your app does the actual media capture (`MediaRecorder`) and uploads the file to your own storage — the platform never holds the media. The recording signal is broadcast to every participant (including anyone who joins later); that transparency is enforced server-side.

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

@@ -14,7 +14,8 @@ export declare class MessagingClient implements DropOnAirClient {
     private readonly fetchFn;
     private readonly codec;
     private attachmentClient;
-    private ws;
+    private transport;
+    private resolvedTransportName;
     private shouldReconnect;
     private reconnectTimer;
     private dropOnAirJwt;
@@ -324,6 +325,7 @@ export declare class MessagingClient implements DropOnAirClient {
     private emitBroadcast;
     private handleIncomingGroupMessage;
     private emitGroupCallEvent;
+    private resolveTransport;
     private connectWebSocket;
     private handleIncomingMessageEdit;
     private handleIncomingMessageDelete;