covekit 0.1.0

package/README.md

@@ -0,0 +1,139 @@
+# covekit
+
+The official JavaScript/TypeScript SDK for the **CoveKit Media Suite**. This package provides headless WebRTC meeting orchestration, media transport handshakes, and signaling channel loops.
+
+---
+
+## Installation
+
+```bash
+npm install covekit
+```
+
+---
+
+## Integration Paths
+
+Developers can integrate CoveKit in two ways:
+
+1. **Option A: Direct Embed (Low-Code / Complete UI)**: Embed our pre-built responsive UI widget inside an iframe.
+2. **Option B: Headless SDK (Pro-Code / Custom UI)**: Orchestrate WebRTC connections and media tracks programmatically to build a custom interface.
+
+---
+
+### Option A: Direct Embed
+
+Render an `<iframe>` referencing the CoveKit meeting URL with specific query parameters to hide standard menus/headers and automatically enter the room:
+
+```html
+<iframe
+  src="https://meet.covekit.com/m/lobby?embed=true&autoJoin=true&displayName=Satoshi&mic=on&cam=off"
+  allow="camera; microphone; display-capture; fullscreen"
+  style="width: 100%; height: 600px; border: none; border-radius: 8px;"
+></iframe>
+```
+
+#### Supported Query Parameters:
+* `embed=true` (Required): Strips out header spacing, navigation menus, and lobby wrappers.
+* `autoJoin=true` (Optional): Skips the lobby settings stage and joins automatically.
+* `displayName` (Optional): Prepopulates the user's name (required if `autoJoin` is active).
+* `passcode` (Optional): Prepopulates the password.
+* `mic=on|off` (Optional): Defaults the starting microphone state.
+* `cam=on|off` (Optional): Defaults the starting camera state.
+
+---
+
+### Option B: Headless SDK
+
+Orchestrate the WebRTC media transports programmatically to build a custom UI.
+
+```typescript
+import { CoveKitClient, CoveKitRoom } from 'covekit';
+
+// Initialize the client with your custom API and Media server endpoints
+const client = new CoveKitClient(
+  'https://api.covekit.com', // Control Plane API
+  'wss://media.covekit.com/v1/media/ws' // Real-Time Signaling WS
+);
+
+// 1. Get meeting token
+const session = await client.joinPublicMeeting('lobby-room', 'Alice');
+
+// 2. Initialize connection
+const room = new CoveKitRoom(client, {
+  onConnected: (info) => {
+    console.log('Connected! Session ID:', info.sessionId);
+    // Request permission & publish mic/cam tracks
+    room.publishLocalMedia(true, true);
+  },
+  onLocalStream: (stream) => {
+    // Render local preview player
+    const localVideo = document.getElementById('local-video') as HTMLVideoElement;
+    localVideo.srcObject = stream;
+  },
+  onRemoteTrack: (track, peerId, kind) => {
+    // Handle remote participant video/audio tracks
+    const mediaStream = new MediaStream([track]);
+    const remoteVideo = document.getElementById(`peer-${peerId}`) as HTMLVideoElement;
+    if (remoteVideo) {
+      remoteVideo.srcObject = mediaStream;
+    }
+  },
+  onPeerJoin: (peer) => {
+    console.log(`${peer.displayName} joined the call`);
+  },
+  onPeerLeave: (peerId) => {
+    console.log(`Peer ${peerId} left`);
+  },
+  onPeerMuteStateChanged: (peerId, kind, muted) => {
+    console.log(`Peer ${peerId} ${kind} is ${muted ? 'muted' : 'unmuted'}`);
+  },
+  onWhiteboardUpdate: (peerId, elements) => {
+    console.log('Received whiteboard vector sync chunk:', elements);
+  },
+  onError: (error) => {
+    console.error('Room signaling error:', error);
+  }
+});
+
+// 3. Connect WebRTC media loops
+await room.join(session.token, session.ice_servers);
+```
+
+---
+
+## API Reference
+
+### `CoveKitClient`
+Main client class for talking to the CoveKit Control Plane.
+
+#### Constructor
+```typescript
+new CoveKitClient(apiBaseUrl: string, mediaWsUrl: string)
+```
+
+#### Methods
+* `joinPublicMeeting(publicId: string, displayName: string, passcode?: string, hostToken?: string)`: Establishes a session token and connects to waiting rooms.
+* `getPublicMeeting(publicId: string)`: Retrieves meeting metadata (e.g. title, status, meeting mode).
+* `pollSessionStatus(publicId: string, sessionId: string)`: Checks if the host has admitted the user from the waiting room.
+
+---
+
+### `CoveKitRoom`
+Handles room-wide media track lifecycle events and WebRTC connection pipelines.
+
+#### Constructor
+```typescript
+new CoveKitRoom(client: CoveKitClient, events: CoveKitRoomEvents)
+```
+
+#### Methods
+* `join(token: string, iceServers?: any[])`: Connects the WebRTC signaling WebSocket.
+* `leave()`: Stops all local streams, closes active producers, and tears down signaling.
+* `publishLocalMedia(audio: boolean, video: boolean, audioDeviceId?: string, existingStream?: MediaStream)`: Invokes the user's browser device permissions and publishes selected tracks.
+* `publishTrack(kind: 'audio' | 'video', track: MediaStreamTrack, appData?: any)`: Publishes a custom track.
+* `replaceTrack(kind: 'audio' | 'video', track: MediaStreamTrack | null, appData?: any)`: Swaps an active track in-place on the current WebRTC producer.
+* `toggleMute(kind: 'audio' | 'video', muted: boolean)`: Mutes/unmutes media tracks and broadcasts state to peers.
+* `sendWhiteboardUpdate(elements: any)`: Broadcasts real-time collaborative whiteboard updates to peers.
+* `kickParticipant(peerId: string)`: *[Host Only]* Evicts a participant from the room.
+* `endMeetingRoom()`: *[Host Only]* Terminates the meeting session for everyone.

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { ServerMessage } from './protocol';
+export declare class CoveKitClient {
+    private apiBaseUrl;
+    private mediaWsUrl;
+    private ws;
+    constructor(apiBaseUrl: string, mediaWsUrl: string);
+    /**
+     * Control Plane REST: Fetch public meeting minimal info
+     */
+    getPublicMeeting(publicId: string): Promise<any>;
+    /**
+     * Control Plane REST: Creates an ephemeral anonymous participant session
+     */
+    joinPublicMeeting(publicId: string, displayName: string, passcode?: string, hostToken?: string): Promise<any>;
+    /**
+     * Control Plane REST: Polls session status for waiting room approval
+     */
+    pollSessionStatus(publicId: string, sessionId: string): Promise<any>;
+    /**
+     * Control Plane REST: Fetch waiting room participants (Host only)
+     */
+    getWaitingRoom(publicId: string, hostToken: string): Promise<any>;
+    /**
+     * Control Plane REST: Admit participant (Host only)
+     */
+    admitParticipant(publicId: string, sessionId: string, hostToken: string): Promise<void>;
+    /**
+     * Control Plane REST: Deny participant (Host only)
+     */
+    denyParticipant(publicId: string, sessionId: string, hostToken: string): Promise<void>;
+    /**
+     * Real-Time Plane WS: Initiates native signaling channel loops
+     */
+    connectMediaServer(token: string, onMessage: (msg: ServerMessage) => void): Promise<WebSocket>;
+    private sendSignal;
+    requestCapabilities(): void;
+    createWebRtcTransport(direction: 'send' | 'recv'): void;
+    connectWebRtcTransport(transportId: string, dtlsParameters: any): void;
+    produce(transportId: string, kind: 'audio' | 'video', rtpParameters: any, appData?: any): void;
+    consume(producerId: string, rtpCapabilities: any): void;
+    grantScreenShare(peerId: string): void;
+    revokeScreenShare(peerId: string): void;
+    closeProducer(producerId: string): void;
+    pauseConsumer(consumerId: string): void;
+    resumeConsumer(consumerId: string): void;
+    endMeetingRoom(): void;
+    kickParticipant(peerId: string): void;
+    toggleMute(kind: 'audio' | 'video', muted: boolean): void;
+    sendTranscriptChunk(text: string): void;
+    sendWhiteboardUpdate(elements: any): void;
+    sendPing(): void;
+    disconnect(): void;
+}
+export { CoveKitRoom, CoveKitRoomEvents } from './room';

package/dist/index.js

@@ -0,0 +1,197 @@
+/**
+ * Rust serde's `rename_all = "camelCase"` on an enum only renames variant
+ * names, NOT the field names within struct variants. The server therefore
+ * sends snake_case keys inside every payload object (e.g. `rtp_capabilities`,
+ * `session_id`, `ice_parameters`). This helper does a shallow conversion so
+ * the rest of the client can use the camelCase names defined in protocol.ts.
+ */
+function shallowCamelizeKeys(obj) {
+    const out = {};
+    for (const key of Object.keys(obj)) {
+        const camel = key.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase());
+        out[camel] = obj[key];
+    }
+    return out;
+}
+export class CoveKitClient {
+    constructor(apiBaseUrl, mediaWsUrl) {
+        this.ws = null;
+        this.apiBaseUrl = apiBaseUrl;
+        this.mediaWsUrl = mediaWsUrl;
+    }
+    /**
+     * Control Plane REST: Fetch public meeting minimal info
+     */
+    async getPublicMeeting(publicId) {
+        const response = await fetch(`${this.apiBaseUrl}/v1/public/meetings/${publicId}`, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch public meeting details: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Control Plane REST: Creates an ephemeral anonymous participant session
+     */
+    async joinPublicMeeting(publicId, displayName, passcode, hostToken) {
+        const url = new URL(`${this.apiBaseUrl}/v1/public/meetings/${publicId}/join`);
+        if (hostToken) {
+            url.searchParams.set('host_token', hostToken);
+        }
+        const response = await fetch(url.toString(), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ display_name: displayName, passcode }),
+        });
+        if (!response.ok) {
+            const errPayload = await response.json().catch(() => ({}));
+            throw new Error(errPayload.error || `Failed public room entry: ${response.statusText}`);
+        }
+        // Returns payload containing short-lived JWT Join Token
+        return response.json();
+    }
+    /**
+     * Control Plane REST: Polls session status for waiting room approval
+     */
+    async pollSessionStatus(publicId, sessionId) {
+        const response = await fetch(`${this.apiBaseUrl}/v1/public/meetings/${publicId}/session/${sessionId}/status`, {
+            method: 'GET',
+        });
+        if (!response.ok) {
+            const errPayload = await response.json().catch(() => ({}));
+            throw new Error(errPayload.error || `Failed to check session status: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Control Plane REST: Fetch waiting room participants (Host only)
+     */
+    async getWaitingRoom(publicId, hostToken) {
+        const response = await fetch(`${this.apiBaseUrl}/v1/public/meetings/${publicId}/waiting-room?host_token=${hostToken}`, {
+            method: 'GET',
+        });
+        if (!response.ok)
+            throw new Error(`Failed to fetch waiting room: ${response.statusText}`);
+        return response.json();
+    }
+    /**
+     * Control Plane REST: Admit participant (Host only)
+     */
+    async admitParticipant(publicId, sessionId, hostToken) {
+        const response = await fetch(`${this.apiBaseUrl}/v1/public/meetings/${publicId}/waiting-room/${sessionId}/admit?host_token=${hostToken}`, {
+            method: 'POST',
+        });
+        if (!response.ok)
+            throw new Error(`Failed to admit participant: ${response.statusText}`);
+    }
+    /**
+     * Control Plane REST: Deny participant (Host only)
+     */
+    async denyParticipant(publicId, sessionId, hostToken) {
+        const response = await fetch(`${this.apiBaseUrl}/v1/public/meetings/${publicId}/waiting-room/${sessionId}/deny?host_token=${hostToken}`, {
+            method: 'POST',
+        });
+        if (!response.ok)
+            throw new Error(`Failed to deny participant: ${response.statusText}`);
+    }
+    /**
+     * Real-Time Plane WS: Initiates native signaling channel loops
+     */
+    connectMediaServer(token, onMessage) {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(this.mediaWsUrl);
+            this.ws.onopen = () => {
+                console.log('Signaling pipe open. Launching cryptographic token validation handshake.');
+                this.sendSignal('init', { token });
+                resolve(this.ws);
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const parsed = JSON.parse(event.data);
+                    // Shallow-camelize the payload so snake_case Rust field names
+                    // (rtp_capabilities, session_id, …) map to the camelCase names
+                    // used in protocol.ts and room.ts.
+                    const camelPayload = parsed.payload && typeof parsed.payload === 'object'
+                        ? shallowCamelizeKeys(parsed.payload)
+                        : null;
+                    const flatMsg = camelPayload
+                        ? { type: parsed.type, ...camelPayload }
+                        : { type: parsed.type };
+                    onMessage(flatMsg);
+                }
+                catch (err) {
+                    console.error('Failed processing raw incoming WebSocket event frame:', err);
+                }
+            };
+            this.ws.onerror = (err) => reject(err);
+            this.ws.onclose = () => {
+                console.log('Signaling WebSocket closed.');
+                // If this.ws is still set, it means we didn't call .disconnect() manually
+                if (this.ws) {
+                    onMessage({ type: 'error', message: 'Connection to server lost.' });
+                }
+            };
+        });
+    }
+    sendSignal(type, payload) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ type, payload }));
+        }
+    }
+    requestCapabilities() {
+        this.sendSignal('getRouterRtpCapabilities');
+    }
+    createWebRtcTransport(direction) {
+        this.sendSignal('createWebRtcTransport', { direction });
+    }
+    connectWebRtcTransport(transportId, dtlsParameters) {
+        this.sendSignal('connectWebRtcTransport', { transportId, dtlsParameters });
+    }
+    produce(transportId, kind, rtpParameters, appData) {
+        this.sendSignal('produce', { transportId, kind, rtpParameters, appData });
+    }
+    consume(producerId, rtpCapabilities) {
+        this.sendSignal('consume', { producerId, rtpCapabilities });
+    }
+    grantScreenShare(peerId) {
+        this.sendSignal('grantScreenShare', { peerId });
+    }
+    revokeScreenShare(peerId) {
+        this.sendSignal('revokeScreenShare', { peerId });
+    }
+    closeProducer(producerId) {
+        this.sendSignal('closeProducer', { producerId });
+    }
+    pauseConsumer(consumerId) {
+        this.sendSignal('pauseConsumer', { consumerId });
+    }
+    resumeConsumer(consumerId) {
+        this.sendSignal('resumeConsumer', { consumerId });
+    }
+    endMeetingRoom() {
+        this.sendSignal('endMeeting');
+    }
+    kickParticipant(peerId) {
+        this.sendSignal('kickPeer', { peerId });
+    }
+    toggleMute(kind, muted) {
+        this.sendSignal('toggleMute', { kind, muted });
+    }
+    sendTranscriptChunk(text) {
+        this.sendSignal('transcriptChunk', { text });
+    }
+    sendWhiteboardUpdate(elements) {
+        this.sendSignal('whiteboardUpdate', { elements });
+    }
+    sendPing() {
+        this.sendSignal('ping');
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+export { CoveKitRoom } from './room';

package/dist/protocol.d.ts

@@ -0,0 +1,123 @@
+export type ClientMessage = {
+    type: 'init';
+    token: string;
+} | {
+    type: 'getRouterRtpCapabilities';
+} | {
+    type: 'createWebRtcTransport';
+    direction: 'send' | 'recv';
+} | {
+    type: 'connectWebRtcTransport';
+    transportId: string;
+    dtlsParameters: any;
+} | {
+    type: 'produce';
+    transportId: string;
+    kind: 'audio' | 'video';
+    rtpParameters: any;
+    appData?: any;
+} | {
+    type: 'consume';
+    producerId: string;
+    rtpCapabilities: any;
+} | {
+    type: 'endMeeting';
+} | {
+    type: 'kickPeer';
+    peerId: string;
+} | {
+    type: 'toggleMute';
+    kind: 'audio' | 'video';
+    muted: boolean;
+} | {
+    type: 'grantScreenShare';
+    peerId: string;
+} | {
+    type: 'revokeScreenShare';
+    peerId: string;
+} | {
+    type: 'closeProducer';
+    producerId: string;
+} | {
+    type: 'pauseConsumer';
+    consumerId: string;
+} | {
+    type: 'resumeConsumer';
+    consumerId: string;
+} | {
+    type: 'transcriptChunk';
+    text: string;
+} | {
+    type: 'whiteboardUpdate';
+    elements: any;
+} | {
+    type: 'ping';
+};
+export type ServerMessage = {
+    type: 'connected';
+    sessionId: string;
+    role: 'host' | 'participant';
+    displayName: string;
+    isRecording: boolean;
+    autoRecord: boolean;
+} | {
+    type: 'routerRtpCapabilities';
+    rtpCapabilities: any;
+} | {
+    type: 'transportCreated';
+    id: string;
+    direction: 'send' | 'recv';
+    iceParameters: any;
+    iceCandidates: any[];
+    dtlsParameters: any;
+} | {
+    type: 'producerCreated';
+    id: string;
+} | {
+    type: 'consumerCreated';
+    id: string;
+    producerId: string;
+    kind: 'audio' | 'video';
+    rtpParameters: any;
+    appData?: any;
+} | {
+    type: 'newProducer';
+    producerId: string;
+    peerId: string;
+    kind: 'audio' | 'video';
+    appData?: any;
+} | {
+    type: 'producerClosed';
+    producerId: string;
+    peerId: string;
+} | {
+    type: 'peerJoined';
+    peerId: string;
+    displayName: string;
+    role: 'host' | 'participant';
+} | {
+    type: 'peerLeft';
+    peerId: string;
+} | {
+    type: 'peerMuteStateChanged';
+    peerId: string;
+    kind: 'audio' | 'video';
+    muted: boolean;
+} | {
+    type: 'screenSharePermissionUpdated';
+    peerId: string;
+    canShare: boolean;
+} | {
+    type: 'recordingStarted';
+} | {
+    type: 'recordingStopped';
+} | {
+    type: 'whiteboardUpdate';
+    peerId: string;
+    elements: any;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'pong';
+};

package/dist/protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/room.d.ts

@@ -0,0 +1,65 @@
+import { CoveKitClient } from './index';
+export interface CoveKitRoomEvents {
+    onConnected?: (info: {
+        sessionId: string;
+        role: string;
+        displayName: string;
+        isRecording: boolean;
+        autoRecord: boolean;
+    }) => void;
+    onLocalStream?: (stream: MediaStream) => void;
+    onRemoteTrack?: (track: MediaStreamTrack, peerId: string, kind: 'audio' | 'video', appData?: any) => void;
+    onPeerJoin?: (peer: {
+        peerId: string;
+        displayName: string;
+        role: string;
+    }) => void;
+    onPeerLeave?: (peerId: string) => void;
+    onPeerMuteStateChanged?: (peerId: string, kind: 'audio' | 'video', muted: boolean) => void;
+    onScreenSharePermissionUpdated?: (peerId: string, canShare: boolean) => void;
+    onRecordingStarted?: () => void;
+    onRecordingStopped?: () => void;
+    onWhiteboardUpdate?: (peerId: string, elements: any) => void;
+    onError?: (err: Error) => void;
+}
+export declare class CoveKitRoom {
+    private client;
+    private device;
+    private sendTransport;
+    private recvTransport;
+    private producers;
+    private consumers;
+    private producerToPeerMap;
+    private events;
+    private pendingProduceCallback;
+    private pendingPublishAudio;
+    private pendingPublishVideo;
+    private pendingPublishAudioDeviceId;
+    private pendingExistingStream;
+    private transportsReady;
+    private pendingConsumes;
+    private iceServers?;
+    private pingInterval;
+    constructor(client: CoveKitClient, events: CoveKitRoomEvents);
+    join(token: string, iceServers?: any[]): Promise<void>;
+    publishLocalMedia(audio: boolean, video: boolean, audioDeviceId?: string, existingStream?: MediaStream): Promise<void>;
+    private handleSignal;
+    private initializeTransport;
+    private consumeMutex;
+    private initializeConsumer;
+    endMeeting(): void;
+    sendTranscriptChunk(text: string): void;
+    sendWhiteboardUpdate(elements: any): void;
+    kickParticipant(peerId: string): void;
+    toggleMute(kind: 'audio' | 'video', muted: boolean): void;
+    publishTrack(kind: 'audio' | 'video', track: MediaStreamTrack, appData?: any): Promise<void>;
+    replaceTrack(kind: 'audio' | 'video', track: MediaStreamTrack | null, appData?: any): Promise<void>;
+    unpublishTrack(kind: 'audio' | 'video', appData?: any): Promise<void>;
+    closeProducer(producerId: string): void;
+    grantScreenShare(peerId: string): void;
+    revokeScreenShare(peerId: string): void;
+    pausePeerVideo(peerId: string): void;
+    resumePeerVideo(peerId: string): void;
+    resumeAllVideos(): void;
+    leave(): void;
+}

package/dist/room.js

@@ -0,0 +1,386 @@
+import { Device } from 'mediasoup-client';
+export class CoveKitRoom {
+    constructor(client, events) {
+        this.device = null;
+        this.sendTransport = null;
+        this.recvTransport = null;
+        this.producers = new Map();
+        this.consumers = new Map();
+        this.producerToPeerMap = new Map();
+        this.pendingProduceCallback = null;
+        this.pendingPublishAudio = false;
+        this.pendingPublishVideo = false;
+        this.pendingPublishAudioDeviceId = undefined;
+        this.pendingExistingStream = undefined;
+        this.transportsReady = { send: false, recv: false };
+        // newProducer events that arrive before the device/transports are ready
+        // are queued here and flushed once both transports are initialized.
+        this.pendingConsumes = [];
+        this.pingInterval = null;
+        this.consumeMutex = Promise.resolve();
+        this.client = client;
+        this.events = events;
+    }
+    async join(token, iceServers) {
+        try {
+            this.iceServers = iceServers;
+            this.device = new Device();
+            // Connect to WebSocket signaling server
+            await this.client.connectMediaServer(token, (msg) => this.handleSignal(msg));
+            // Start heartbeat every 15 seconds
+            this.pingInterval = window.setInterval(() => {
+                this.client.sendPing();
+            }, 15000);
+            // Request Router RTP capabilities
+            this.client.requestCapabilities();
+        }
+        catch (err) {
+            this.events.onError?.(err);
+        }
+    }
+    async publishLocalMedia(audio, video, audioDeviceId, existingStream) {
+        // If the send transport isn't ready yet, queue the request — it will be
+        // fulfilled automatically once both transports have been initialized.
+        if (!this.sendTransport) {
+            this.pendingPublishAudio = audio;
+            this.pendingPublishVideo = video;
+            this.pendingPublishAudioDeviceId = audioDeviceId;
+            this.pendingExistingStream = existingStream;
+            return;
+        }
+        try {
+            const stream = existingStream || await navigator.mediaDevices.getUserMedia({
+                audio: audio
+                    ? (audioDeviceId ? { deviceId: { exact: audioDeviceId } } : true)
+                    : false,
+                video: video ? { width: 1280, height: 720 } : false,
+            });
+            this.events.onLocalStream?.(stream);
+            if (!this.sendTransport) {
+                throw new Error('Send transport not initialized yet.');
+            }
+            if (audio) {
+                const audioTrack = stream.getAudioTracks()[0];
+                if (audioTrack) {
+                    const producer = await this.sendTransport.produce({ track: audioTrack });
+                    this.producers.set('audio-camera', producer);
+                }
+            }
+            if (video) {
+                const videoTrack = stream.getVideoTracks()[0];
+                if (videoTrack) {
+                    const producer = await this.sendTransport.produce({
+                        track: videoTrack,
+                        encodings: [
+                            { maxBitrate: 100000, scaleResolutionDownBy: 4 }, // Low: 180p
+                            { maxBitrate: 300000, scaleResolutionDownBy: 2 }, // Medium: 360p
+                            { maxBitrate: 1500000 }, // High: 720p
+                        ],
+                    });
+                    this.producers.set('video-camera', producer);
+                }
+            }
+        }
+        catch (err) {
+            this.events.onError?.(err);
+        }
+    }
+    async handleSignal(msg) {
+        try {
+            switch (msg.type) {
+                case 'connected':
+                    this.events.onConnected?.({
+                        sessionId: msg.sessionId,
+                        role: msg.role,
+                        displayName: msg.displayName,
+                        isRecording: msg.isRecording,
+                        autoRecord: msg.autoRecord,
+                    });
+                    break;
+                case 'recordingStarted':
+                    this.events.onRecordingStarted?.();
+                    break;
+                case 'recordingStopped':
+                    this.events.onRecordingStopped?.();
+                    break;
+                case 'whiteboardUpdate':
+                    this.events.onWhiteboardUpdate?.(msg.peerId, msg.elements);
+                    break;
+                case 'routerRtpCapabilities': {
+                    const caps = msg.rtpCapabilities;
+                    if (!caps || typeof caps !== 'object') {
+                        throw new Error(`Invalid routerRtpCapabilities received from server: ${JSON.stringify(caps)}`);
+                    }
+                    await this.device?.load({ routerRtpCapabilities: caps });
+                    // Create send and recv transports
+                    this.client.createWebRtcTransport('send');
+                    this.client.createWebRtcTransport('recv');
+                    break;
+                }
+                case 'transportCreated':
+                    await this.initializeTransport(msg);
+                    break;
+                case 'producerCreated':
+                    if (this.pendingProduceCallback) {
+                        this.pendingProduceCallback.callback({ id: msg.id });
+                        this.pendingProduceCallback = null;
+                    }
+                    break;
+                case 'consumerCreated':
+                    await this.initializeConsumer(msg);
+                    break;
+                case 'newProducer':
+                    // Map producerId to peerId
+                    this.producerToPeerMap.set(msg.producerId, msg.peerId);
+                    // If transports aren't ready yet (e.g. this is a late-joiner sync
+                    // notification that arrived before device.load / createWebRtcTransport
+                    // completed), queue the consume for later.
+                    if (!this.transportsReady.send || !this.transportsReady.recv) {
+                        this.pendingConsumes.push({ producerId: msg.producerId, peerId: msg.peerId });
+                    }
+                    else {
+                        this.client.consume(msg.producerId, this.device?.rtpCapabilities);
+                    }
+                    break;
+                case 'peerJoined':
+                    this.events.onPeerJoin?.(msg);
+                    break;
+                case 'peerLeft':
+                    this.events.onPeerLeave?.(msg.peerId);
+                    break;
+                case 'peerMuteStateChanged':
+                    this.events.onPeerMuteStateChanged?.(msg.peerId, msg.kind, msg.muted);
+                    break;
+                case 'screenSharePermissionUpdated':
+                    this.events.onScreenSharePermissionUpdated?.(msg.peerId, msg.canShare);
+                    break;
+                case 'producerClosed': {
+                    const consumer = Array.from(this.consumers.values()).find(c => c.producerId === msg.producerId);
+                    if (consumer) {
+                        consumer.close();
+                        this.consumers.delete(consumer.id);
+                        const peerId = this.producerToPeerMap.get(msg.producerId) || msg.peerId;
+                        this.events.onRemoteTrack?.(null, peerId, consumer.kind, consumer.appData);
+                    }
+                    break;
+                }
+                case 'error':
+                    this.events.onError?.(new Error(msg.message));
+                    break;
+            }
+        }
+        catch (err) {
+            this.events.onError?.(err);
+        }
+    }
+    async initializeTransport(msg) {
+        if (!this.device)
+            return;
+        const { id, direction, iceParameters, iceCandidates, dtlsParameters } = msg;
+        const transportOptions = {
+            id,
+            iceParameters,
+            iceCandidates,
+            dtlsParameters,
+            iceServers: this.iceServers,
+        };
+        const transport = direction === 'send'
+            ? this.device.createSendTransport(transportOptions)
+            : this.device.createRecvTransport(transportOptions);
+        transport.on('connect', ({ dtlsParameters }, callback, errback) => {
+            try {
+                this.client.connectWebRtcTransport(transport.id, dtlsParameters);
+                callback();
+            }
+            catch (err) {
+                errback(err);
+            }
+        });
+        if (direction === 'send') {
+            transport.on('produce', ({ kind, rtpParameters, appData }, callback, errback) => {
+                try {
+                    this.client.produce(transport.id, kind, rtpParameters, appData);
+                    this.pendingProduceCallback = { callback, errback };
+                }
+                catch (err) {
+                    errback(err);
+                }
+            });
+            this.sendTransport = transport;
+            this.transportsReady.send = true;
+        }
+        else {
+            this.recvTransport = transport;
+            this.transportsReady.recv = true;
+        }
+        // Once both transports are up, flush queued publish and consume requests.
+        if (this.transportsReady.send && this.transportsReady.recv) {
+            // Flush pending local media publish
+            const audio = this.pendingPublishAudio;
+            const video = this.pendingPublishVideo;
+            const audioDeviceId = this.pendingPublishAudioDeviceId;
+            const existingStream = this.pendingExistingStream;
+            this.pendingPublishAudio = false;
+            this.pendingPublishVideo = false;
+            this.pendingPublishAudioDeviceId = undefined;
+            this.pendingExistingStream = undefined;
+            if (audio || video) {
+                await this.publishLocalMedia(audio, video, audioDeviceId, existingStream);
+            }
+            // Flush newProducer events that arrived before transports were ready
+            // (late-joiner sync from the server)
+            const toConsume = this.pendingConsumes.splice(0);
+            for (const { producerId } of toConsume) {
+                this.client.consume(producerId, this.device?.rtpCapabilities);
+            }
+        }
+    }
+    async initializeConsumer(msg) {
+        if (!this.recvTransport)
+            return;
+        const { id, producerId, kind, rtpParameters, appData } = msg;
+        // Queue the consume calls to avoid duplicate mid SDP errors when multiple consumers are created simultaneously
+        const consumer = await new Promise((resolve, reject) => {
+            this.consumeMutex = this.consumeMutex.then(async () => {
+                try {
+                    if (!this.recvTransport)
+                        throw new Error("No recv transport");
+                    const c = await this.recvTransport.consume({
+                        id,
+                        producerId,
+                        kind,
+                        rtpParameters,
+                        appData,
+                    });
+                    resolve(c);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        this.consumers.set(consumer.id, consumer);
+        const peerId = this.producerToPeerMap.get(producerId) || producerId;
+        this.events.onRemoteTrack?.(consumer.track, peerId, kind, appData);
+    }
+    endMeeting() {
+        this.client.endMeetingRoom();
+    }
+    sendTranscriptChunk(text) {
+        this.client.sendTranscriptChunk(text);
+    }
+    sendWhiteboardUpdate(elements) {
+        this.client.sendWhiteboardUpdate(elements);
+    }
+    kickParticipant(peerId) {
+        this.client.kickParticipant(peerId);
+    }
+    toggleMute(kind, muted) {
+        this.client.toggleMute(kind, muted);
+    }
+    async publishTrack(kind, track, appData) {
+        if (!this.sendTransport) {
+            throw new Error('Send transport not initialized yet.');
+        }
+        const producerKey = `${kind}-${appData?.source || 'camera'}`;
+        const existing = this.producers.get(producerKey);
+        if (existing) {
+            await existing.replaceTrack({ track });
+        }
+        else {
+            const producer = await this.sendTransport.produce({
+                track,
+                encodings: kind === 'video'
+                    ? (appData?.source === 'screen'
+                        ? [{ maxBitrate: 3500000 }] // Single high-quality layer for screen sharing (up to 3.5 Mbps)
+                        : [
+                            { maxBitrate: 100000, scaleResolutionDownBy: 4 }, // Low: 180p
+                            { maxBitrate: 300000, scaleResolutionDownBy: 2 }, // Medium: 360p
+                            { maxBitrate: 1500000 }, // High: 720p
+                        ])
+                    : undefined,
+                appData,
+            });
+            this.producers.set(producerKey, producer);
+        }
+    }
+    async replaceTrack(kind, track, appData) {
+        const producerKey = `${kind}-${appData?.source || 'camera'}`;
+        const producer = this.producers.get(producerKey);
+        if (producer) {
+            await producer.replaceTrack({ track });
+        }
+    }
+    async unpublishTrack(kind, appData) {
+        const producerKey = `${kind}-${appData?.source || 'camera'}`;
+        const producer = this.producers.get(producerKey);
+        if (producer) {
+            this.closeProducer(producer.id);
+            producer.close();
+            this.producers.delete(producerKey);
+        }
+    }
+    closeProducer(producerId) {
+        this.client.closeProducer(producerId);
+    }
+    grantScreenShare(peerId) {
+        this.client.grantScreenShare(peerId);
+    }
+    revokeScreenShare(peerId) {
+        this.client.revokeScreenShare(peerId);
+    }
+    pausePeerVideo(peerId) {
+        const consumer = Array.from(this.consumers.values()).find(c => {
+            const pId = this.producerToPeerMap.get(c.producerId);
+            return pId === peerId && c.kind === 'video' && c.appData?.source !== 'screen';
+        });
+        if (consumer && !consumer.paused) {
+            this.client.pauseConsumer(consumer.id);
+            consumer.pause();
+        }
+    }
+    resumePeerVideo(peerId) {
+        const consumer = Array.from(this.consumers.values()).find(c => {
+            const pId = this.producerToPeerMap.get(c.producerId);
+            return pId === peerId && c.kind === 'video' && c.appData?.source !== 'screen';
+        });
+        if (consumer && consumer.paused) {
+            this.client.resumeConsumer(consumer.id);
+            consumer.resume();
+        }
+    }
+    resumeAllVideos() {
+        for (const consumer of this.consumers.values()) {
+            if (consumer.kind === 'video' && consumer.appData?.source !== 'screen') {
+                if (consumer.paused) {
+                    this.client.resumeConsumer(consumer.id);
+                    consumer.resume();
+                }
+            }
+        }
+    }
+    leave() {
+        if (this.pingInterval) {
+            window.clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        this.client.disconnect();
+        // Transport.close() throws AwaitQueueStoppedError if called while
+        // produce/consume operations are still pending in the internal queue.
+        // Swallow it — the transport is being torn down regardless.
+        try {
+            this.sendTransport?.close();
+        }
+        catch (_) { }
+        try {
+            this.recvTransport?.close();
+        }
+        catch (_) { }
+        this.sendTransport = null;
+        this.recvTransport = null;
+        this.producers.clear();
+        this.consumers.clear();
+        this.producerToPeerMap.clear();
+        this.transportsReady = { send: false, recv: false };
+    }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "covekit",
+  "version": "0.1.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "mediasoup-client": "^3.7.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}