@aether-stack-dev/client-sdk 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,2245 @@
+import { EventEmitter } from 'eventemitter3';
+import { createClient } from '@supabase/supabase-js';
+
+class WebRTCManager extends EventEmitter {
+    constructor(config) {
+        super();
+        this.localStream = null;
+        this.config = config;
+    }
+    async initialize() {
+        this.emit('initialized');
+    }
+    async getStats() {
+        return null;
+    }
+    async getUserMedia() {
+        const constraints = {
+            audio: this.config.enableAudio !== false ? {
+                echoCancellation: this.config.audio?.echoCancellation ?? true,
+                noiseSuppression: this.config.audio?.noiseSuppression ?? true,
+                autoGainControl: this.config.audio?.autoGainControl ?? true
+            } : false
+        };
+        return navigator.mediaDevices.getUserMedia(constraints);
+    }
+    async addLocalStream(stream) {
+        this.localStream = stream;
+        this.emit('localStreamAdded', stream);
+    }
+    removeLocalStream(streamId) {
+        if (this.localStream) {
+            this.localStream.getTracks().forEach(track => {
+                if (track.id === streamId)
+                    track.stop();
+            });
+        }
+    }
+    getLocalStreams() {
+        if (!this.localStream)
+            return [];
+        return this.localStream.getTracks().map(track => ({
+            id: track.id,
+            kind: track.kind,
+            active: track.enabled,
+            track
+        }));
+    }
+    getRemoteStreams() {
+        return [];
+    }
+    async getMediaDevices() {
+        return navigator.mediaDevices.enumerateDevices();
+    }
+    async switchAudioInput(deviceId) {
+        if (this.localStream) {
+            this.localStream.getAudioTracks().forEach(track => track.stop());
+        }
+        const stream = await navigator.mediaDevices.getUserMedia({
+            audio: { deviceId: { exact: deviceId } }
+        });
+        this.localStream = stream;
+        this.emit('localStreamAdded', stream);
+    }
+    muteAudio() {
+        if (this.localStream) {
+            this.localStream.getAudioTracks().forEach(track => { track.enabled = false; });
+        }
+    }
+    unmuteAudio() {
+        if (this.localStream) {
+            this.localStream.getAudioTracks().forEach(track => { track.enabled = true; });
+        }
+    }
+    muteVideo() {
+        if (this.localStream) {
+            this.localStream.getVideoTracks().forEach(track => { track.enabled = false; });
+        }
+    }
+    unmuteVideo() {
+        if (this.localStream) {
+            this.localStream.getVideoTracks().forEach(track => { track.enabled = true; });
+        }
+    }
+    async createOffer() {
+        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
+        return { type: 'offer', sdp: '' };
+    }
+    async createAnswer(remoteSdp) {
+        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
+        return { type: 'answer', sdp: '' };
+    }
+    async handleAnswer(answer) {
+        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
+    }
+    async addIceCandidate(candidate) {
+        console.warn('WebRTC is deprecated. Use WebSocket-based AStackCSRClient instead.');
+    }
+    async close() {
+        if (this.localStream) {
+            this.localStream.getTracks().forEach(track => track.stop());
+            this.localStream = null;
+        }
+        this.emit('closed');
+    }
+}
+
+class AStackError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = 'AStackError';
+        this.code = code;
+    }
+}
+const ErrorCodes = {
+    INVALID_API_KEY: 'INVALID_API_KEY',
+    INVALID_TOKEN: 'INVALID_TOKEN',
+    AUTHENTICATION_FAILED: 'AUTHENTICATION_FAILED',
+    SESSION_EXPIRED: 'SESSION_EXPIRED',
+    SESSION_CREATION_FAILED: 'SESSION_CREATION_FAILED',
+    CONNECTION_LOST: 'CONNECTION_LOST',
+    SIGNALING_ERROR: 'SIGNALING_ERROR',
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    MEDIA_ACCESS_DENIED: 'MEDIA_ACCESS_DENIED',
+    AUDIO_ERROR: 'AUDIO_ERROR',
+    RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
+    INSUFFICIENT_CREDITS: 'INSUFFICIENT_CREDITS',
+    BILLING_ERROR: 'BILLING_ERROR'
+};
+
+class SupabaseSignalingClient extends EventEmitter {
+    constructor(config) {
+        super();
+        this.channel = null;
+        this.sessionId = null;
+        this.channelName = null;
+        this.wsToken = null;
+        this.channelId = null;
+        this.connected = false;
+        this.reconnectAttempts = 0;
+        this.heartbeatInterval = null;
+        this.config = config;
+        this.maxReconnectAttempts = config.maxRetries || 3;
+        this.reconnectDelay = config.reconnectDelay || 1000;
+        this.supabase = createClient(config.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || '', config.supabaseAnonKey || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || '', {
+            realtime: {
+                params: {
+                    eventsPerSecond: 10
+                }
+            }
+        });
+    }
+    async connect(sessionId, channelName, wsToken) {
+        this.sessionId = sessionId;
+        this.channelName = channelName;
+        this.wsToken = wsToken;
+        return new Promise(async (resolve, reject) => {
+            try {
+                const { data: channelData, error } = await this.supabase
+                    .from('signaling_channels')
+                    .select('id')
+                    .eq('channel_name', channelName)
+                    .eq('ws_token', wsToken)
+                    .single();
+                if (error || !channelData) {
+                    throw new AStackError('Invalid channel credentials', ErrorCodes.SIGNALING_ERROR);
+                }
+                this.channelId = channelData.id;
+                this.channel = this.supabase.channel(channelName);
+                this.channel
+                    .on('postgres_changes', {
+                    event: 'INSERT',
+                    schema: 'public',
+                    table: 'signaling_messages',
+                    filter: `channel_id=eq.${this.channelId}`
+                }, (payload) => {
+                    this.handleSignalingMessage(payload.new);
+                })
+                    .on('presence', { event: 'sync' }, () => {
+                    const state = this.channel?.presenceState();
+                    this.handlePresenceSync(state);
+                })
+                    .on('presence', { event: 'join' }, ({ key, newPresences }) => {
+                    this.emit('userJoined', { key, presences: newPresences });
+                })
+                    .on('presence', { event: 'leave' }, ({ key, leftPresences }) => {
+                    this.emit('userLeft', { key, presences: leftPresences });
+                })
+                    .subscribe(async (status) => {
+                    if (status === 'SUBSCRIBED') {
+                        this.connected = true;
+                        this.reconnectAttempts = 0;
+                        await this.updateChannelStatus(true);
+                        await this.channel.track({
+                            user_type: 'client',
+                            user_id: sessionId,
+                            status: 'online',
+                            last_seen: new Date().toISOString(),
+                            metadata: {
+                                userAgent: navigator.userAgent,
+                                capabilities: {
+                                    audio: this.config.enableAudio !== false,
+                                    video: this.config.enableVideo === true,
+                                    text: this.config.enableText !== false
+                                }
+                            }
+                        });
+                        this.startHeartbeat();
+                        this.emit('sessionJoined', { sessionId, channelName });
+                        resolve();
+                    }
+                    else if (status === 'CHANNEL_ERROR') {
+                        reject(new AStackError('Failed to subscribe to signaling channel', ErrorCodes.SIGNALING_ERROR));
+                    }
+                });
+            }
+            catch (error) {
+                reject(new AStackError(`Failed to connect to signaling: ${error}`, ErrorCodes.SIGNALING_ERROR));
+            }
+        });
+    }
+    async handleSignalingMessage(message) {
+        if (message.sender_type === 'client') {
+            return;
+        }
+        switch (message.message_type) {
+            case 'audio':
+                this.emit('audioResponse', message.payload);
+                break;
+            case 'text':
+                this.emit('textResponse', message.payload);
+                break;
+            case 'control':
+                this.emit('controlMessage', message.payload);
+                break;
+            case 'ready':
+                this.emit('workerReady', message.payload);
+                break;
+            case 'error':
+                this.emit('error', new AStackError(message.payload.message || 'Worker error', ErrorCodes.SIGNALING_ERROR));
+                break;
+        }
+    }
+    handlePresenceSync(state) {
+        if (!state)
+            return;
+        const presences = Object.values(state);
+        const workerPresent = presences.some((presence) => presence.user_type === 'worker' && presence.status === 'online');
+        if (workerPresent) {
+            this.emit('workerConnected');
+        }
+        else {
+            this.emit('workerDisconnected');
+        }
+    }
+    async updateChannelStatus(connected) {
+        if (!this.channelId)
+            return;
+        try {
+            await this.supabase
+                .from('signaling_channels')
+                .update({ client_connected: connected })
+                .eq('id', this.channelId);
+        }
+        catch (error) { }
+    }
+    async sendText(text) {
+        await this.sendSignalingMessage('text', { text });
+    }
+    async sendAudio(audioData, metadata) {
+        await this.sendSignalingMessage('audio', { audio: audioData, ...metadata });
+    }
+    async sendControl(action, data) {
+        await this.sendSignalingMessage('control', { action, ...data });
+    }
+    async sendSignalingMessage(messageType, payload) {
+        if (!this.channelId || !this.connected) {
+            throw new AStackError('Not connected to signaling channel', ErrorCodes.SIGNALING_ERROR);
+        }
+        try {
+            const { error } = await this.supabase
+                .from('signaling_messages')
+                .insert({
+                channel_id: this.channelId,
+                sender_type: 'client',
+                message_type: messageType,
+                payload
+            });
+            if (error) {
+                throw new AStackError(`Failed to send ${messageType}: ${error.message}`, ErrorCodes.SIGNALING_ERROR);
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    sendTextMessage(text) {
+        this.sendText(text).catch(() => { });
+    }
+    sendAudioData(audioBlob) {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const base64 = reader.result.split(',')[1];
+            this.sendAudio(base64).catch(() => { });
+        };
+        reader.readAsDataURL(audioBlob);
+    }
+    startHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        const interval = this.config.heartbeatInterval || 30000;
+        this.heartbeatInterval = setInterval(async () => {
+            if (this.channel && this.connected) {
+                try {
+                    await this.channel.track({
+                        user_type: 'client',
+                        user_id: this.sessionId,
+                        status: 'online',
+                        last_seen: new Date().toISOString()
+                    });
+                }
+                catch (error) { }
+            }
+        }, interval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    async attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            this.emit('error', new AStackError('Maximum reconnection attempts reached', ErrorCodes.CONNECTION_LOST));
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+        this.emit('reconnecting', this.reconnectAttempts);
+        setTimeout(async () => {
+            if (!this.connected && this.sessionId && this.channelName && this.wsToken) {
+                try {
+                    await this.connect(this.sessionId, this.channelName, this.wsToken);
+                    this.emit('reconnected');
+                }
+                catch (error) {
+                    this.attemptReconnect();
+                }
+            }
+        }, delay);
+    }
+    async leaveSession() {
+        if (this.channel) {
+            try {
+                await this.channel.untrack();
+                await this.updateChannelStatus(false);
+            }
+            catch (error) { }
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.stopHeartbeat();
+        if (this.channel) {
+            await this.leaveSession();
+            await this.channel.unsubscribe();
+            this.channel = null;
+        }
+        this.removeAllListeners();
+    }
+}
+
+class SessionManager {
+    constructor(apiEndpoint, sessionExpirationWarning = 1, onSessionExpiring) {
+        this.sessionCredentials = null;
+        this.workerInfo = null;
+        this.expirationTimer = null;
+        this.apiEndpoint = apiEndpoint;
+        this.sessionExpirationWarning = sessionExpirationWarning;
+        this.onSessionExpiring = onSessionExpiring;
+    }
+    async createSession(request) {
+        try {
+            const response = await fetch(`${this.apiEndpoint}/functions/v1/session`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${request.apiKey}`
+                },
+                body: JSON.stringify({
+                    organizationId: request.organizationId,
+                    endUserId: request.endUserId,
+                    metadata: request.metadata,
+                    workerPreferences: request.workerPreferences
+                })
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+                if (response.status === 401) {
+                    throw new AStackError('Invalid API key', ErrorCodes.INVALID_API_KEY);
+                }
+                else if (response.status === 429) {
+                    throw new AStackError('Rate limit exceeded', ErrorCodes.RATE_LIMIT_EXCEEDED);
+                }
+                else if (response.status === 402) {
+                    throw new AStackError('Insufficient credits', ErrorCodes.INSUFFICIENT_CREDITS);
+                }
+                throw new AStackError(errorData.error || 'Session creation failed', ErrorCodes.SESSION_CREATION_FAILED);
+            }
+            const data = await response.json();
+            const expiresAt = new Date(Date.now() + (data.expiresIn * 1000));
+            this.sessionCredentials = {
+                sessionId: data.sessionId,
+                wsToken: data.wsToken,
+                channelName: data.channelName,
+                workerUrl: data.workerUrl,
+                expiresAt
+            };
+            if (data.workerInfo) {
+                this.workerInfo = data.workerInfo;
+            }
+            this.scheduleExpirationWarning();
+            return this.sessionCredentials;
+        }
+        catch (error) {
+            if (error instanceof AStackError) {
+                throw error;
+            }
+            throw new AStackError(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`, ErrorCodes.SESSION_CREATION_FAILED);
+        }
+    }
+    async renewSession(apiKey) {
+        if (!this.sessionCredentials) {
+            throw new AStackError('No active session to renew', ErrorCodes.SESSION_EXPIRED);
+        }
+        const request = {
+            apiKey,
+            organizationId: this.sessionCredentials.sessionId.split('-')[0],
+            endUserId: undefined,
+            metadata: { previousSessionId: this.sessionCredentials.sessionId }
+        };
+        return this.createSession(request);
+    }
+    scheduleExpirationWarning() {
+        if (this.expirationTimer) {
+            clearTimeout(this.expirationTimer);
+        }
+        if (!this.sessionCredentials || !this.onSessionExpiring) {
+            return;
+        }
+        const now = Date.now();
+        const expirationTime = this.sessionCredentials.expiresAt.getTime();
+        const warningTime = expirationTime - (this.sessionExpirationWarning * 60 * 1000);
+        if (warningTime > now) {
+            this.expirationTimer = setTimeout(() => {
+                if (this.onSessionExpiring && this.sessionCredentials) {
+                    const minutesRemaining = Math.floor((this.sessionCredentials.expiresAt.getTime() - Date.now()) / 60000);
+                    this.onSessionExpiring(minutesRemaining);
+                }
+            }, warningTime - now);
+        }
+    }
+    getCredentials() {
+        return this.sessionCredentials;
+    }
+    isSessionValid() {
+        if (!this.sessionCredentials) {
+            return false;
+        }
+        return this.sessionCredentials.expiresAt.getTime() > Date.now();
+    }
+    getTimeUntilExpiration() {
+        if (!this.sessionCredentials) {
+            return 0;
+        }
+        const remaining = this.sessionCredentials.expiresAt.getTime() - Date.now();
+        return Math.max(0, remaining);
+    }
+    clearSession() {
+        this.sessionCredentials = null;
+        this.workerInfo = null;
+        if (this.expirationTimer) {
+            clearTimeout(this.expirationTimer);
+            this.expirationTimer = null;
+        }
+    }
+    getWorkerInfo() {
+        return this.workerInfo;
+    }
+    destroy() {
+        this.clearSession();
+    }
+}
+
+class BillingMonitor {
+    constructor(apiEndpoint, apiKey) {
+        this.apiEndpoint = apiEndpoint;
+        this.apiKey = apiKey;
+        this.updateCallbacks = [];
+        this.alertCallbacks = [];
+        this.warningThresholds = {
+            creditBalance: 10, // Warn when credits drop below 10
+            usagePercentage: 80 // Warn when usage reaches 80% of rate limit
+        };
+    }
+    async fetchBillingInfo() {
+        try {
+            const response = await fetch(`${this.apiEndpoint}/billing/info`, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch billing info: ${response.statusText}`);
+            }
+            const info = await response.json();
+            this.updateBillingInfo(info);
+            return info;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    updateBillingInfo(info) {
+        const previousInfo = this.billingInfo;
+        this.billingInfo = info;
+        this.updateCallbacks.forEach(callback => callback(info));
+        this.checkForAlerts(info, previousInfo);
+    }
+    checkForAlerts(current, previous) {
+        if (current.creditBalance < this.warningThresholds.creditBalance) {
+            this.triggerAlert({
+                type: 'low_balance',
+                details: {
+                    currentBalance: current.creditBalance,
+                    threshold: this.warningThresholds.creditBalance
+                }
+            });
+        }
+        const usagePercentage = (current.currentUsage / current.rateLimit) * 100;
+        if (usagePercentage >= this.warningThresholds.usagePercentage) {
+            this.triggerAlert({
+                type: 'limit_exceeded',
+                details: {
+                    currentUsage: current.currentUsage,
+                    rateLimit: current.rateLimit,
+                    percentage: usagePercentage
+                }
+            });
+        }
+        if (previous && previous.creditBalance - current.creditBalance > 100) {
+            this.triggerAlert({
+                type: 'low_balance',
+                details: {
+                    previousBalance: previous.creditBalance,
+                    currentBalance: current.creditBalance,
+                    spent: previous.creditBalance - current.creditBalance
+                }
+            });
+        }
+    }
+    triggerAlert(alert) {
+        this.alertCallbacks.forEach(callback => callback(alert));
+    }
+    startMonitoring(intervalMs = 60000) {
+        this.stopMonitoring();
+        this.fetchBillingInfo().catch(() => { });
+        this.checkInterval = setInterval(() => {
+            this.fetchBillingInfo().catch(() => { });
+        }, intervalMs);
+    }
+    stopMonitoring() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = undefined;
+        }
+    }
+    onUpdate(callback) {
+        this.updateCallbacks.push(callback);
+    }
+    onAlert(callback) {
+        this.alertCallbacks.push(callback);
+    }
+    removeUpdateCallback(callback) {
+        this.updateCallbacks = this.updateCallbacks.filter(cb => cb !== callback);
+    }
+    removeAlertCallback(callback) {
+        this.alertCallbacks = this.alertCallbacks.filter(cb => cb !== callback);
+    }
+    getCurrentBillingInfo() {
+        return this.billingInfo;
+    }
+    setWarningThresholds(thresholds) {
+        this.warningThresholds = { ...this.warningThresholds, ...thresholds };
+    }
+    async checkRateLimit() {
+        const info = await this.fetchBillingInfo();
+        return info.currentUsage < info.rateLimit;
+    }
+    destroy() {
+        this.stopMonitoring();
+        this.updateCallbacks = [];
+        this.alertCallbacks = [];
+    }
+}
+
+class SecurityLogger {
+    constructor(config) {
+        this.eventQueue = [];
+        this.config = {
+            enableLocalLogging: true,
+            batchSize: 10,
+            flushInterval: 5000,
+            sessionId: '',
+            organizationId: '',
+            ...config
+        };
+        if (this.config.flushInterval > 0) {
+            this.startAutoFlush();
+        }
+    }
+    setSessionId(sessionId) {
+        this.config.sessionId = sessionId;
+    }
+    logEvent(eventType, severity, details) {
+        const event = {
+            eventType,
+            severity,
+            details: {
+                ...details,
+                sessionId: this.config.sessionId,
+                organizationId: this.config.organizationId,
+                userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
+                timestamp: new Date().toISOString()
+            },
+            timestamp: new Date()
+        };
+        if (this.config.enableLocalLogging) {
+            this.logToConsole(event);
+        }
+        this.eventQueue.push(event);
+        if (this.eventQueue.length >= this.config.batchSize) {
+            this.flush().catch(() => { });
+        }
+    }
+    logAuthFailure(reason, details) {
+        this.logEvent('auth_failure', 'warning', {
+            reason,
+            ...details
+        });
+    }
+    logRateLimit(limit, current, endpoint) {
+        this.logEvent('rate_limit', 'warning', {
+            limit,
+            current,
+            endpoint,
+            exceeded: current >= limit
+        });
+    }
+    logInvalidRequest(reason, request) {
+        this.logEvent('invalid_request', 'warning', {
+            reason,
+            request: this.sanitizeRequest(request)
+        });
+    }
+    logSessionHijackAttempt(details) {
+        this.logEvent('session_hijack', 'critical', details);
+    }
+    sanitizeRequest(request) {
+        if (!request)
+            return undefined;
+        const sanitized = { ...request };
+        const sensitiveFields = ['password', 'token', 'apiKey', 'secret', 'credential'];
+        for (const field of sensitiveFields) {
+            if (sanitized[field]) {
+                sanitized[field] = '[REDACTED]';
+            }
+        }
+        return sanitized;
+    }
+    logToConsole(event) {
+    }
+    getConsoleLogLevel(severity) {
+        switch (severity) {
+            case 'info':
+                return 'log';
+            case 'warning':
+                return 'warn';
+            case 'error':
+            case 'critical':
+                return 'error';
+            default:
+                return 'log';
+        }
+    }
+    async flush() {
+        if (this.eventQueue.length === 0)
+            return;
+        const events = [...this.eventQueue];
+        this.eventQueue = [];
+        try {
+            const response = await fetch(`${this.config.apiEndpoint}/security/events`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ events })
+            });
+            if (!response.ok) {
+                this.eventQueue.unshift(...events);
+            }
+        }
+        catch (error) {
+            this.eventQueue.unshift(...events);
+        }
+    }
+    startAutoFlush() {
+        this.flushInterval = setInterval(() => {
+            this.flush().catch(() => { });
+        }, this.config.flushInterval);
+    }
+    stopAutoFlush() {
+        if (this.flushInterval) {
+            clearInterval(this.flushInterval);
+            this.flushInterval = undefined;
+        }
+    }
+    async destroy() {
+        this.stopAutoFlush();
+        await this.flush();
+    }
+}
+
+class ConnectionStateManager extends EventEmitter {
+    constructor() {
+        super();
+        this.stateHistory = [];
+        this.maxHistorySize = 100;
+        this.state = {
+            signaling: 'disconnected',
+            websocket: 'new',
+            overall: 'disconnected',
+            lastActivity: new Date(),
+            reconnectAttempts: 0,
+            errors: []
+        };
+        this.quality = {
+            qualityScore: 1.0
+        };
+    }
+    updateSignalingState(state) {
+        const previousState = this.state.signaling;
+        this.state.signaling = state;
+        this.state.lastActivity = new Date();
+        if (state === 'connected') {
+            this.state.reconnectAttempts = 0;
+        }
+        else if (state === 'reconnecting') {
+            this.state.reconnectAttempts++;
+        }
+        this.updateOverallState();
+        this.addToHistory();
+        if (previousState !== state) {
+            this.emit('signalingStateChange', state, previousState);
+        }
+    }
+    updateWebSocketState(state) {
+        const previousState = this.state.websocket;
+        this.state.websocket = state;
+        this.state.lastActivity = new Date();
+        this.updateOverallState();
+        this.addToHistory();
+        if (previousState !== state) {
+            this.emit('websocketStateChange', state, previousState);
+        }
+    }
+    updateWebRTCState(state) {
+        this.updateWebSocketState(state);
+    }
+    updateICEState(state) {
+        // No-op for backwards compatibility
+    }
+    updateOverallState() {
+        const previousOverall = this.state.overall;
+        if (this.state.signaling === 'disconnected' || this.state.websocket === 'failed' || this.state.websocket === 'closed') {
+            this.state.overall = 'disconnected';
+        }
+        else if (this.state.signaling === 'connecting' || this.state.websocket === 'connecting') {
+            this.state.overall = 'connecting';
+        }
+        else if (this.state.signaling === 'connected' && this.state.websocket === 'connected') {
+            this.state.overall = 'connected';
+        }
+        else if (this.state.signaling === 'reconnecting' || this.state.websocket === 'disconnected') {
+            this.state.overall = 'degraded';
+        }
+        else if (this.state.errors.length > 0) {
+            this.state.overall = 'error';
+        }
+        else {
+            this.state.overall = 'connecting';
+        }
+        if (previousOverall !== this.state.overall) {
+            this.emit('overallStateChange', this.state.overall, previousOverall);
+        }
+    }
+    addError(error) {
+        this.state.errors.push(error);
+        if (this.state.errors.length > 10) {
+            this.state.errors = this.state.errors.slice(-10);
+        }
+        this.updateOverallState();
+        this.emit('error', error);
+    }
+    clearErrors() {
+        this.state.errors = [];
+        this.updateOverallState();
+    }
+    updateConnectionQuality(stats) {
+        const previousScore = this.quality.qualityScore;
+        if (stats.latency !== undefined)
+            this.quality.latency = stats.latency;
+        if (stats.jitter !== undefined)
+            this.quality.jitter = stats.jitter;
+        if (stats.packetLoss !== undefined)
+            this.quality.packetLoss = stats.packetLoss;
+        if (stats.bandwidth !== undefined)
+            this.quality.bandwidth = stats.bandwidth;
+        this.quality.qualityScore = this.calculateQualityScore();
+        if (Math.abs(previousScore - this.quality.qualityScore) > 0.1) {
+            this.emit('qualityChange', this.quality);
+        }
+    }
+    calculateQualityScore() {
+        let score = 1.0;
+        if (this.quality.latency !== undefined) {
+            if (this.quality.latency < 150) ;
+            else if (this.quality.latency < 300) {
+                score -= 0.1;
+            }
+            else if (this.quality.latency < 500) {
+                score -= 0.3;
+            }
+            else {
+                score -= 0.5;
+            }
+        }
+        if (this.quality.packetLoss !== undefined) {
+            if (this.quality.packetLoss < 1) ;
+            else if (this.quality.packetLoss < 3) {
+                score -= 0.2;
+            }
+            else if (this.quality.packetLoss < 5) {
+                score -= 0.4;
+            }
+            else {
+                score -= 0.6;
+            }
+        }
+        if (this.quality.jitter !== undefined) {
+            if (this.quality.jitter < 30) ;
+            else if (this.quality.jitter < 50) {
+                score -= 0.1;
+            }
+            else if (this.quality.jitter < 100) {
+                score -= 0.2;
+            }
+            else {
+                score -= 0.3;
+            }
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    startHealthCheck(intervalMs = 5000) {
+        this.stopHealthCheck();
+        this.healthCheckInterval = setInterval(() => {
+            const timeSinceLastActivity = Date.now() - this.state.lastActivity.getTime();
+            if (timeSinceLastActivity > 30000 && this.state.overall === 'connected') {
+                this.emit('healthCheckFailed', timeSinceLastActivity);
+            }
+        }, intervalMs);
+    }
+    stopHealthCheck() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = undefined;
+        }
+    }
+    addToHistory() {
+        this.stateHistory.push({
+            state: { ...this.state },
+            timestamp: new Date()
+        });
+        if (this.stateHistory.length > this.maxHistorySize) {
+            this.stateHistory = this.stateHistory.slice(-this.maxHistorySize);
+        }
+    }
+    getState() {
+        return { ...this.state };
+    }
+    getQuality() {
+        return { ...this.quality };
+    }
+    getStateHistory() {
+        return [...this.stateHistory];
+    }
+    isConnected() {
+        return this.state.overall === 'connected';
+    }
+    isHealthy() {
+        return this.state.overall === 'connected' &&
+            this.quality.qualityScore > 0.5 &&
+            this.state.errors.length === 0;
+    }
+    getReconnectAttempts() {
+        return this.state.reconnectAttempts;
+    }
+    reset() {
+        this.state = {
+            signaling: 'disconnected',
+            websocket: 'new',
+            overall: 'disconnected',
+            lastActivity: new Date(),
+            reconnectAttempts: 0,
+            errors: []
+        };
+        this.quality = {
+            qualityScore: 1.0
+        };
+        this.stateHistory = [];
+        this.emit('reset');
+    }
+    destroy() {
+        this.stopHealthCheck();
+        this.removeAllListeners();
+    }
+}
+
+class PerformanceMonitor extends EventEmitter {
+    constructor(config) {
+        super();
+        this.benchmarks = [];
+        this.isCollecting = false;
+        this.config = {
+            collectionInterval: 5000,
+            enableAutoReport: true,
+            reportingInterval: 30000,
+            sessionId: '',
+            ...config
+        };
+        this.startTime = Date.now();
+        this.metrics = this.initializeMetrics();
+    }
+    initializeMetrics() {
+        return {
+            latency: {
+                signaling: { avg: 0, min: Infinity, max: 0, samples: [] },
+                websocket: { avg: 0, min: Infinity, max: 0, samples: [] },
+                audio: { avg: 0, min: Infinity, max: 0, samples: [] }
+            },
+            throughput: {
+                audio: { inbound: 0, outbound: 0 },
+                data: { inbound: 0, outbound: 0 }
+            },
+            quality: {
+                audioQuality: 1.0,
+                connectionQuality: 1.0
+            },
+            resources: {
+                cpuUsage: 0,
+                memoryUsage: 0,
+                bandwidth: { upload: 0, download: 0 }
+            }
+        };
+    }
+    startCollection(sessionId) {
+        if (this.isCollecting)
+            return;
+        this.isCollecting = true;
+        if (sessionId) {
+            this.config.sessionId = sessionId;
+        }
+        this.collectionTimer = setInterval(() => {
+            this.collectMetrics();
+        }, this.config.collectionInterval);
+        if (this.config.enableAutoReport) {
+            this.reportingTimer = setInterval(() => {
+                this.reportMetrics();
+            }, this.config.reportingInterval);
+        }
+        this.emit('collectionStarted');
+    }
+    stopCollection() {
+        if (!this.isCollecting)
+            return;
+        this.isCollecting = false;
+        if (this.collectionTimer) {
+            clearInterval(this.collectionTimer);
+            this.collectionTimer = undefined;
+        }
+        if (this.reportingTimer) {
+            clearInterval(this.reportingTimer);
+            this.reportingTimer = undefined;
+        }
+        if (this.config.enableAutoReport) {
+            this.reportMetrics();
+        }
+        this.emit('collectionStopped');
+    }
+    recordLatency(type, latency) {
+        const key = type === 'webrtc' ? 'websocket' : type === 'video' ? 'audio' : type;
+        const metric = this.metrics.latency[key];
+        if (!metric)
+            return;
+        metric.samples.push(latency);
+        if (metric.samples.length > 100) {
+            metric.samples.shift();
+        }
+        metric.min = Math.min(metric.min, latency);
+        metric.max = Math.max(metric.max, latency);
+        metric.avg = metric.samples.reduce((a, b) => a + b, 0) / metric.samples.length;
+    }
+    updateThroughput(type, direction, bytesPerSecond) {
+        const key = type === 'video' ? 'audio' : type;
+        if (this.metrics.throughput[key]) {
+            this.metrics.throughput[key][direction] = bytesPerSecond;
+        }
+    }
+    updateQuality(quality) {
+        this.metrics.quality = { ...this.metrics.quality, ...quality };
+    }
+    updateResources(resources) {
+        this.metrics.resources = { ...this.metrics.resources, ...resources };
+    }
+    recordBenchmark(benchmark) {
+        const fullBenchmark = {
+            ...benchmark,
+            timestamp: new Date()
+        };
+        this.benchmarks.push(fullBenchmark);
+        if (this.benchmarks.length > 50) {
+            this.benchmarks.shift();
+        }
+        this.emit('benchmarkRecorded', fullBenchmark);
+    }
+    getMetrics() {
+        return JSON.parse(JSON.stringify(this.metrics));
+    }
+    getBenchmarks() {
+        return [...this.benchmarks];
+    }
+    getLatencyStats(type) {
+        if (type) {
+            const key = type === 'webrtc' ? 'websocket' : type === 'video' ? 'audio' : type;
+            return { ...this.metrics.latency[key] };
+        }
+        return JSON.parse(JSON.stringify(this.metrics.latency));
+    }
+    async reportMetrics() {
+        if (!this.config.sessionId)
+            return;
+        try {
+            const report = {
+                sessionId: this.config.sessionId,
+                timestamp: new Date(),
+                duration: Date.now() - this.startTime,
+                metrics: this.getMetrics(),
+                benchmarks: this.getBenchmarks()
+            };
+            const response = await fetch(`${this.config.apiEndpoint}/performance/report`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(report)
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to report metrics: ${response.statusText}`);
+            }
+            this.emit('metricsReported', report);
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+    collectMetrics() {
+        this.emit('collectMetrics', {
+            timestamp: Date.now(),
+            metrics: this.metrics
+        });
+    }
+    destroy() {
+        this.stopCollection();
+        this.removeAllListeners();
+        this.benchmarks = [];
+    }
+}
+
+class AnalyticsCollector extends EventEmitter {
+    constructor(config) {
+        super();
+        this.events = [];
+        this.sessionAnalytics = null;
+        this.isCollecting = false;
+        this.config = {
+            enableAutoFlush: true,
+            flushInterval: 60000, // 1 minute
+            batchSize: 100,
+            sessionId: '',
+            userId: '',
+            organizationId: '',
+            ...config
+        };
+    }
+    startSession(sessionId) {
+        if (this.isCollecting) {
+            this.endSession();
+        }
+        this.isCollecting = true;
+        this.config.sessionId = sessionId;
+        this.sessionAnalytics = {
+            sessionId,
+            startTime: new Date(),
+            duration: 0,
+            eventsCount: 0,
+            errorCount: 0,
+            mediaTypes: [],
+            connectionQuality: 1.0,
+            dataTransferred: {
+                audio: { sent: 0, received: 0 },
+                video: { sent: 0, received: 0 },
+                text: { sent: 0, received: 0 }
+            }
+        };
+        if (this.config.enableAutoFlush) {
+            this.flushTimer = setInterval(() => {
+                this.flush();
+            }, this.config.flushInterval);
+        }
+        this.trackEvent('session_started', {});
+    }
+    endSession() {
+        if (!this.isCollecting || !this.sessionAnalytics)
+            return;
+        this.isCollecting = false;
+        this.sessionAnalytics.endTime = new Date();
+        this.sessionAnalytics.duration =
+            (this.sessionAnalytics.endTime.getTime() - this.sessionAnalytics.startTime.getTime()) / 1000;
+        this.trackEvent('session_ended', {
+            duration: this.sessionAnalytics.duration
+        });
+        this.flush();
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.sendSessionAnalytics();
+    }
+    trackEvent(eventType, metadata = {}) {
+        const event = {
+            eventType,
+            timestamp: new Date(),
+            sessionId: this.config.sessionId,
+            userId: this.config.userId,
+            organizationId: this.config.organizationId,
+            metadata
+        };
+        this.events.push(event);
+        if (this.sessionAnalytics) {
+            this.sessionAnalytics.eventsCount++;
+            if (eventType.includes('error') || metadata.error) {
+                this.sessionAnalytics.errorCount++;
+            }
+        }
+        if (this.events.length >= this.config.batchSize) {
+            this.flush();
+        }
+        this.emit('eventTracked', event);
+    }
+    updateMediaTypes(mediaTypes) {
+        if (this.sessionAnalytics) {
+            this.sessionAnalytics.mediaTypes = [...new Set(mediaTypes)];
+        }
+    }
+    updateConnectionQuality(quality) {
+        if (this.sessionAnalytics) {
+            const weight = 0.1;
+            this.sessionAnalytics.connectionQuality =
+                this.sessionAnalytics.connectionQuality * (1 - weight) + quality * weight;
+        }
+    }
+    updateDataTransferred(type, direction, bytes) {
+        if (this.sessionAnalytics) {
+            this.sessionAnalytics.dataTransferred[type][direction] += bytes;
+        }
+    }
+    getSessionAnalytics() {
+        if (!this.sessionAnalytics)
+            return null;
+        return {
+            ...this.sessionAnalytics,
+            duration: this.isCollecting
+                ? (Date.now() - this.sessionAnalytics.startTime.getTime()) / 1000
+                : this.sessionAnalytics.duration
+        };
+    }
+    getEvents() {
+        return [...this.events];
+    }
+    async flush() {
+        if (this.events.length === 0)
+            return;
+        const eventsToSend = [...this.events];
+        this.events = [];
+        try {
+            const response = await fetch(`${this.config.apiEndpoint}/analytics/events`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`
+                },
+                body: JSON.stringify({
+                    events: eventsToSend
+                })
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to send analytics: ${response.statusText}`);
+            }
+            this.emit('eventsFlushed', eventsToSend.length);
+        }
+        catch (error) {
+            this.events.unshift(...eventsToSend);
+            this.emit('error', error);
+        }
+    }
+    async sendSessionAnalytics() {
+        if (!this.sessionAnalytics)
+            return;
+        try {
+            const response = await fetch(`${this.config.apiEndpoint}/analytics/sessions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`
+                },
+                body: JSON.stringify(this.sessionAnalytics)
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to send session analytics: ${response.statusText}`);
+            }
+            this.emit('sessionAnalyticsSent', this.sessionAnalytics);
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+    destroy() {
+        if (this.isCollecting) {
+            this.endSession();
+        }
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.removeAllListeners();
+        this.events = [];
+        this.sessionAnalytics = null;
+    }
+}
+
+class UsageTracker {
+    constructor(sessionId) {
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+        this.errorCount = 0;
+        this.qualityScores = [];
+        this.sessionId = sessionId;
+        this.startTime = new Date();
+    }
+    start() {
+        this.startTime = new Date();
+    }
+    stop() {
+        this.endTime = new Date();
+    }
+    trackInputTokens(tokens) {
+        this.inputTokens += tokens;
+    }
+    trackOutputTokens(tokens) {
+        this.outputTokens += tokens;
+    }
+    trackError() {
+        this.errorCount++;
+    }
+    trackQualityScore(score) {
+        if (score >= 0 && score <= 1) {
+            this.qualityScores.push(score);
+        }
+    }
+    getDuration() {
+        const end = this.endTime || new Date();
+        return Math.floor((end.getTime() - this.startTime.getTime()) / 1000);
+    }
+    getAverageQualityScore() {
+        if (this.qualityScores.length === 0)
+            return undefined;
+        const sum = this.qualityScores.reduce((acc, score) => acc + score, 0);
+        return sum / this.qualityScores.length;
+    }
+    getMetrics() {
+        return {
+            sessionId: this.sessionId,
+            duration: this.getDuration(),
+            inputTokens: this.inputTokens > 0 ? this.inputTokens : undefined,
+            outputTokens: this.outputTokens > 0 ? this.outputTokens : undefined,
+            errorCount: this.errorCount,
+            qualityScore: this.getAverageQualityScore()
+        };
+    }
+    reset() {
+        this.startTime = new Date();
+        this.endTime = undefined;
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+        this.errorCount = 0;
+        this.qualityScores = [];
+    }
+}
+
+/**
+ * @deprecated This module is deprecated. Use AStackCSRClient for WebSocket-based communication.
+ * This file is kept for backwards compatibility only.
+ */
+/**
+ * @deprecated Use AStackCSRClient instead. This function is kept for backwards compatibility.
+ */
+function setupEventHandlers(emitter, deps) {
+    console.warn('setupEventHandlers is deprecated. Use AStackCSRClient for WebSocket-based communication.');
+    const { signaling, connectionStateManager, securityLogger } = deps;
+    signaling.on('sessionJoined', () => {
+        const sessionId = deps.getSessionId();
+        const usageTracker = new UsageTracker(sessionId);
+        usageTracker.start();
+        deps.setUsageTracker(usageTracker);
+        securityLogger.setSessionId(sessionId);
+        connectionStateManager.updateSignalingState('connected');
+        connectionStateManager.startHealthCheck();
+        emitter.emit('sessionReady', sessionId);
+    });
+    signaling.on('aiResponse', (data) => {
+        const response = {
+            type: 'text',
+            content: data.text || data.message,
+            timestamp: data.timestamp || Date.now(),
+            messageId: data.messageId
+        };
+        emitter.emit('messageReceived', response);
+    });
+    signaling.on('audioResponse', (data) => {
+        if (data.audio) {
+            try {
+                const binaryString = atob(data.audio.split(',')[1]);
+                const bytes = new Uint8Array(binaryString.length);
+                for (let i = 0; i < binaryString.length; i++) {
+                    bytes[i] = binaryString.charCodeAt(i);
+                }
+                const audioBlob = new Blob([bytes], { type: 'audio/wav' });
+                const response = {
+                    type: 'audio',
+                    content: audioBlob,
+                    timestamp: data.timestamp || Date.now(),
+                    messageId: data.messageId
+                };
+                emitter.emit('messageReceived', response);
+            }
+            catch (error) { }
+        }
+    });
+    signaling.on('textResponse', (data) => {
+        emitter.emit('text-response', data);
+    });
+    signaling.on('disconnected', () => {
+        deps.setStatus({ status: 'disconnected' });
+        connectionStateManager.updateSignalingState('disconnected');
+        emitter.emit('disconnected');
+    });
+    signaling.on('reconnecting', (attempt) => {
+        connectionStateManager.updateSignalingState('reconnecting');
+        emitter.emit('reconnecting', attempt);
+    });
+    signaling.on('error', (error) => {
+        const usageTracker = deps.getUsageTracker();
+        if (usageTracker) {
+            usageTracker.trackError();
+        }
+        connectionStateManager.addError(error);
+        if (error.code === ErrorCodes.AUTHENTICATION_FAILED || error.code === ErrorCodes.INVALID_API_KEY) {
+            securityLogger.logAuthFailure(error.message, { code: error.code });
+        }
+        else if (error.code === ErrorCodes.RATE_LIMIT_EXCEEDED) {
+            securityLogger.logRateLimit(0, 0, 'signaling');
+        }
+        emitter.emit('error', error);
+    });
+}
+
+class AStackMediaController {
+    constructor(webrtc, signaling, analyticsCollector, config, emitter) {
+        this.audioRecorder = null;
+        this.isRecording = false;
+        this.webrtc = webrtc;
+        this.signaling = signaling;
+        this.analyticsCollector = analyticsCollector;
+        this.config = config;
+        this.emitter = emitter;
+    }
+    async startVideo() {
+        if (!this.config.enableVideo) {
+            throw new AStackError('Video is disabled in configuration', ErrorCodes.VIDEO_ERROR);
+        }
+        try {
+            const stream = await this.webrtc.getUserMedia();
+            this.webrtc.addLocalStream(stream);
+            this.emitter.emit('videoStarted');
+            this.analyticsCollector.trackEvent('video_started');
+            this.analyticsCollector.updateMediaTypes(['video']);
+            return stream;
+        }
+        catch (error) {
+            throw new AStackError(`Failed to start video: ${error}`, ErrorCodes.VIDEO_ERROR);
+        }
+    }
+    async stopVideo(localVideoRef) {
+        const localStreams = this.webrtc.getLocalStreams();
+        localStreams.forEach(stream => {
+            if (stream.kind === 'video') {
+                this.webrtc.removeLocalStream(stream.id);
+            }
+        });
+        if (localVideoRef) {
+            localVideoRef.srcObject = null;
+        }
+        this.emitter.emit('videoStopped');
+    }
+    async startAudio() {
+        if (this.config.enableAudio === false) {
+            throw new AStackError('Audio is disabled in configuration', ErrorCodes.AUDIO_ERROR);
+        }
+        try {
+            const stream = await this.webrtc.getUserMedia();
+            this.webrtc.addLocalStream(stream);
+            this.emitter.emit('audioStarted');
+            this.analyticsCollector.trackEvent('audio_started');
+            this.analyticsCollector.updateMediaTypes(['audio']);
+            return stream;
+        }
+        catch (error) {
+            throw new AStackError(`Failed to start audio: ${error}`, ErrorCodes.AUDIO_ERROR);
+        }
+    }
+    async stopAudio() {
+        const localStreams = this.webrtc.getLocalStreams();
+        localStreams.forEach(stream => {
+            if (stream.kind === 'audio') {
+                this.webrtc.removeLocalStream(stream.id);
+            }
+        });
+        if (this.isRecording) {
+            this.stopRecording();
+        }
+        this.emitter.emit('audioStopped');
+    }
+    async sendText(message) {
+        if (!this.signaling.isConnected()) {
+            throw new AStackError('Not connected to AStack', ErrorCodes.CONNECTION_LOST);
+        }
+        try {
+            this.signaling.sendTextMessage(message);
+            this.emitter.emit('messageSent', message);
+        }
+        catch (error) {
+            throw new AStackError(`Failed to send text message: ${error}`, ErrorCodes.SIGNALING_ERROR);
+        }
+    }
+    async sendAudio(audioBlob) {
+        if (!this.signaling.isConnected()) {
+            throw new AStackError('Not connected to AStack', ErrorCodes.CONNECTION_LOST);
+        }
+        try {
+            this.signaling.sendAudioData(audioBlob);
+            this.emitter.emit('messageSent', audioBlob);
+        }
+        catch (error) {
+            throw new AStackError(`Failed to send audio: ${error}`, ErrorCodes.AUDIO_ERROR);
+        }
+    }
+    startRecording() {
+        const localStreams = this.webrtc.getLocalStreams();
+        const audioStream = localStreams.find(s => s.kind === 'audio');
+        if (!audioStream?.track) {
+            throw new AStackError('No audio stream available for recording', ErrorCodes.AUDIO_ERROR);
+        }
+        const stream = new MediaStream([audioStream.track]);
+        this.audioRecorder = new MediaRecorder(stream, { mimeType: 'audio/webm' });
+        const audioChunks = [];
+        this.audioRecorder.ondataavailable = (event) => {
+            if (event.data.size > 0) {
+                audioChunks.push(event.data);
+            }
+        };
+        this.audioRecorder.onstop = () => {
+            const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
+            this.sendAudio(audioBlob);
+        };
+        this.audioRecorder.start();
+        this.isRecording = true;
+    }
+    stopRecording() {
+        if (this.audioRecorder && this.isRecording) {
+            this.audioRecorder.stop();
+            this.isRecording = false;
+        }
+    }
+    getIsRecording() {
+        return this.isRecording;
+    }
+    async getDevices() {
+        return this.webrtc.getMediaDevices();
+    }
+    async switchCamera(deviceId) {
+        throw new AStackError('Camera switching not yet implemented', ErrorCodes.VIDEO_ERROR);
+    }
+    async switchMicrophone(deviceId) {
+        return this.webrtc.switchAudioInput(deviceId);
+    }
+    muteAudio() {
+        this.webrtc.muteAudio();
+    }
+    unmuteAudio() {
+        this.webrtc.unmuteAudio();
+    }
+    pauseVideo() {
+        this.webrtc.muteVideo();
+    }
+    resumeVideo() {
+        this.webrtc.unmuteVideo();
+    }
+    getLocalStreams() {
+        return this.webrtc.getLocalStreams();
+    }
+    getRemoteStreams() {
+        return this.webrtc.getRemoteStreams();
+    }
+}
+
+/**
+ * @deprecated AStackClient is deprecated. Use AStackCSRClient for WebSocket-based communication.
+ * This class is kept for backwards compatibility only.
+ *
+ * Example:
+ * ```typescript
+ * import { AStackCSRClient } from '@astack/client-sdk';
+ * const client = new AStackCSRClient({ apiEndpoint: 'https://api.astack.com' });
+ * ```
+ */
+class AStackClient extends EventEmitter {
+    constructor(config) {
+        super();
+        this.usageTracker = null;
+        this.sessionId = null;
+        this.localVideoRef = null;
+        this.remoteVideoRef = null;
+        if (!config.apiKey) {
+            throw new AStackError('API key is required', ErrorCodes.INVALID_API_KEY);
+        }
+        if (!config.supabaseUrl || !config.supabaseAnonKey) {
+            throw new AStackError('Supabase URL and Anon Key are required', ErrorCodes.AUTHENTICATION_FAILED);
+        }
+        this.config = {
+            enableVideo: false, enableAudio: true, enableText: true, autoReconnect: true,
+            maxRetries: 3, reconnectDelay: 1000, heartbeatInterval: 30000, connectionTimeout: 10000,
+            sessionExpirationWarning: 1, apiEndpoint: `${config.supabaseUrl}/functions/v1`, ...config
+        };
+        this.webrtc = new WebRTCManager(this.config);
+        this.signaling = new SupabaseSignalingClient(this.config);
+        this.sessionManager = new SessionManager(this.config.apiEndpoint, this.config.sessionExpirationWarning, (minutesRemaining) => this.emit('sessionExpiring', minutesRemaining));
+        this.billingMonitor = new BillingMonitor(this.config.apiEndpoint, this.config.apiKey);
+        this.billingMonitor.onAlert((alert) => this.emit('billingAlert', alert));
+        this.securityLogger = new SecurityLogger({
+            apiEndpoint: this.config.apiEndpoint, apiKey: this.config.apiKey,
+            organizationId: this.config.organizationId, enableLocalLogging: true
+        });
+        this.connectionStateManager = new ConnectionStateManager();
+        this.connectionStateManager.on('qualityChange', (quality) => {
+            this.analyticsCollector.updateConnectionQuality(quality.qualityScore);
+        });
+        this.performanceMonitor = new PerformanceMonitor({
+            apiEndpoint: this.config.apiEndpoint,
+            enableAutoReport: this.config.enablePerformanceReporting ?? true,
+            collectionInterval: this.config.performanceCollectionInterval ?? 5000,
+            reportingInterval: this.config.performanceReportingInterval ?? 30000
+        });
+        this.analyticsCollector = new AnalyticsCollector({
+            apiEndpoint: this.config.apiEndpoint, apiKey: this.config.apiKey,
+            organizationId: this.config.organizationId, userId: this.config.endUserId,
+            enableAutoFlush: this.config.enableAnalytics ?? true
+        });
+        this.mediaController = new AStackMediaController(this.webrtc, this.signaling, this.analyticsCollector, this.config, this);
+        this.status = { id: '', status: 'pending', connectionState: 'disconnected', iceConnectionState: 'new' };
+        this.initEventHandlers();
+    }
+    initEventHandlers() {
+        setupEventHandlers(this, {
+            webrtc: this.webrtc, signaling: this.signaling,
+            connectionStateManager: this.connectionStateManager, analyticsCollector: this.analyticsCollector,
+            securityLogger: this.securityLogger, performanceMonitor: this.performanceMonitor,
+            getUsageTracker: () => this.usageTracker, setUsageTracker: (t) => { this.usageTracker = t; },
+            getSessionId: () => this.sessionId, getStatus: () => this.status,
+            setStatus: (s) => { this.status = { ...this.status, ...s }; },
+            localVideoRef: this.localVideoRef, remoteVideoRef: this.remoteVideoRef,
+            startWebRTCStatsCollection: () => this.startWebRTCStatsCollection(),
+            stopWebRTCStatsCollection: () => this.stopWebRTCStatsCollection()
+        });
+    }
+    startWebRTCStatsCollection() {
+        this.stopWebRTCStatsCollection();
+        this.statsCollectionTimer = setInterval(async () => {
+            try {
+                const stats = await this.webrtc.getStats();
+                if (stats) {
+                    const processed = this.processWebRTCStats(stats);
+                    if (processed.audioLatency !== undefined)
+                        this.performanceMonitor.recordLatency('audio', processed.audioLatency);
+                    if (processed.videoLatency !== undefined)
+                        this.performanceMonitor.recordLatency('video', processed.videoLatency);
+                    if (processed.throughput) {
+                        this.performanceMonitor.updateThroughput('audio', 'inbound', processed.throughput.audio.inbound);
+                        this.performanceMonitor.updateThroughput('audio', 'outbound', processed.throughput.audio.outbound);
+                        this.performanceMonitor.updateThroughput('video', 'inbound', processed.throughput.video.inbound);
+                        this.performanceMonitor.updateThroughput('video', 'outbound', processed.throughput.video.outbound);
+                    }
+                    if (processed.quality)
+                        this.performanceMonitor.updateQuality(processed.quality);
+                }
+            }
+            catch (error) { }
+        }, 5000);
+    }
+    stopWebRTCStatsCollection() {
+        if (this.statsCollectionTimer) {
+            clearInterval(this.statsCollectionTimer);
+            this.statsCollectionTimer = undefined;
+        }
+    }
+    processWebRTCStats(stats) {
+        return { throughput: { audio: { inbound: 0, outbound: 0 }, video: { inbound: 0, outbound: 0 } }, quality: {} };
+    }
+    async connect() {
+        try {
+            this.connectionStateManager.updateSignalingState('connecting');
+            const sessionRequest = {
+                apiKey: this.config.apiKey, organizationId: this.config.organizationId,
+                endUserId: this.config.endUserId,
+                metadata: { enableVideo: this.config.enableVideo, enableAudio: this.config.enableAudio },
+                workerPreferences: this.config.workerPreferences
+            };
+            const credentials = await this.sessionManager.createSession(sessionRequest);
+            this.sessionId = credentials.sessionId;
+            this.status = {
+                id: this.sessionId, status: 'connecting', connectionState: 'disconnected',
+                iceConnectionState: 'new', startTime: new Date()
+            };
+            this.billingMonitor.startMonitoring();
+            this.performanceMonitor.startCollection(this.sessionId);
+            this.analyticsCollector.startSession(this.sessionId);
+            await this.webrtc.initialize();
+            await this.signaling.connect(credentials.sessionId, credentials.channelName, credentials.wsToken);
+        }
+        catch (error) {
+            this.status.status = 'error';
+            this.status.lastError = error;
+            if (error instanceof AStackError) {
+                if (error.code === ErrorCodes.INSUFFICIENT_CREDITS) {
+                    this.emit('billingAlert', { type: 'limit_exceeded', details: { error: error.message } });
+                }
+                else if (error.code === ErrorCodes.RATE_LIMIT_EXCEEDED) {
+                    this.emit('rateLimitWarning', { limit: 0, current: 0, resetIn: 60 });
+                }
+            }
+            throw error;
+        }
+    }
+    async startVideo() { return this.mediaController.startVideo(); }
+    async stopVideo() { return this.mediaController.stopVideo(this.localVideoRef); }
+    async startAudio() { return this.mediaController.startAudio(); }
+    async stopAudio() { return this.mediaController.stopAudio(); }
+    async sendText(message) { return this.mediaController.sendText(message); }
+    async sendAudio(audioBlob) { return this.mediaController.sendAudio(audioBlob); }
+    startRecording() { this.mediaController.startRecording(); }
+    stopRecording() { this.mediaController.stopRecording(); }
+    async getDevices() { return this.mediaController.getDevices(); }
+    async switchCamera(deviceId) { return this.mediaController.switchCamera(deviceId); }
+    async switchMicrophone(deviceId) { return this.mediaController.switchMicrophone(deviceId); }
+    muteAudio() { this.mediaController.muteAudio(); }
+    unmuteAudio() { this.mediaController.unmuteAudio(); }
+    pauseVideo() { this.mediaController.pauseVideo(); }
+    resumeVideo() { this.mediaController.resumeVideo(); }
+    getSessionStatus() { return { ...this.status }; }
+    getLocalStreams() { return this.mediaController.getLocalStreams(); }
+    getRemoteStreams() { return this.mediaController.getRemoteStreams(); }
+    attachVideo(localVideo, remoteVideo) {
+        this.localVideoRef = localVideo;
+        this.remoteVideoRef = remoteVideo;
+    }
+    addEventListener(event, listener) {
+        return super.on(event, listener);
+    }
+    removeEventListener(event, listener) {
+        return super.off(event, listener);
+    }
+    async disconnect() {
+        this.status.status = 'disconnected';
+        if (this.mediaController.getIsRecording())
+            this.mediaController.stopRecording();
+        if (this.usageTracker) {
+            this.usageTracker.stop();
+            this.usageTracker.getMetrics();
+        }
+        this.billingMonitor.stopMonitoring();
+        this.performanceMonitor.stopCollection();
+        this.analyticsCollector.endSession();
+        this.connectionStateManager.stopHealthCheck();
+        this.connectionStateManager.updateSignalingState('disconnected');
+        await this.webrtc.close();
+        await this.signaling.disconnect();
+        this.sessionManager.clearSession();
+        if (this.localVideoRef)
+            this.localVideoRef.srcObject = null;
+        if (this.remoteVideoRef)
+            this.remoteVideoRef.srcObject = null;
+        this.emit('sessionEnded', this.sessionId);
+        this.sessionId = null;
+        this.usageTracker = null;
+    }
+    async renewSession() {
+        if (!this.sessionManager.isSessionValid()) {
+            throw new AStackError('No active session to renew', ErrorCodes.SESSION_EXPIRED);
+        }
+        try {
+            const credentials = await this.sessionManager.renewSession(this.config.apiKey);
+            await this.signaling.disconnect();
+            await this.signaling.connect(credentials.sessionId, credentials.channelName, credentials.wsToken);
+            this.sessionId = credentials.sessionId;
+            this.emit('sessionReady', this.sessionId);
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    getSessionTimeRemaining() { return this.sessionManager.getTimeUntilExpiration(); }
+    isSessionValid() { return this.sessionManager.isSessionValid(); }
+    getUsageMetrics() { return this.usageTracker?.getMetrics() || null; }
+    trackQualityScore(score) { this.usageTracker?.trackQualityScore(score); }
+    async getBillingInfo() { return this.billingMonitor.fetchBillingInfo(); }
+    getCurrentBillingInfo() { return this.billingMonitor.getCurrentBillingInfo(); }
+    setBillingWarningThresholds(thresholds) {
+        this.billingMonitor.setWarningThresholds(thresholds);
+    }
+    getConnectionState() { return this.connectionStateManager.getState(); }
+    getConnectionQuality() { return this.connectionStateManager.getQuality(); }
+    isHealthy() { return this.connectionStateManager.isHealthy(); }
+    getConnectionHistory() {
+        return this.connectionStateManager.getStateHistory();
+    }
+    getPerformanceMetrics() { return this.performanceMonitor.getMetrics(); }
+    getPerformanceBenchmarks() { return this.performanceMonitor.getBenchmarks(); }
+    recordPerformanceBenchmark(benchmark) {
+        this.performanceMonitor.recordBenchmark(benchmark);
+    }
+    recordLatency(type, latency) {
+        this.performanceMonitor.recordLatency(type, latency);
+    }
+    async reportPerformanceMetrics() { await this.performanceMonitor.reportMetrics(); }
+    setWorkerPreferences(preferences) { this.config.workerPreferences = preferences; }
+    getWorkerPreferences() { return this.config.workerPreferences; }
+    getAssignedWorkerInfo() { return this.sessionManager.getWorkerInfo() || undefined; }
+    trackEvent(eventType, metadata) {
+        this.analyticsCollector.trackEvent(eventType, metadata);
+    }
+    getSessionAnalytics() { return this.analyticsCollector.getSessionAnalytics(); }
+    async flushAnalytics() { await this.analyticsCollector.flush(); }
+    async destroy() {
+        await this.disconnect();
+        this.sessionManager.destroy();
+        this.billingMonitor.destroy();
+        this.connectionStateManager.destroy();
+        this.performanceMonitor.destroy();
+        this.analyticsCollector.destroy();
+        await this.securityLogger.destroy();
+        this.removeAllListeners();
+    }
+}
+
+const ARKIT_BLENDSHAPES = [
+    'jawOpen', 'jawForward', 'jawLeft', 'jawRight',
+    'mouthClose', 'mouthFunnel', 'mouthPucker', 'mouthLeft', 'mouthRight',
+    'mouthSmileLeft', 'mouthSmileRight', 'mouthFrownLeft', 'mouthFrownRight',
+    'mouthDimpleLeft', 'mouthDimpleRight', 'mouthStretchLeft', 'mouthStretchRight',
+    'mouthRollLower', 'mouthRollUpper', 'mouthShrugLower', 'mouthShrugUpper',
+    'mouthPressLeft', 'mouthPressRight', 'mouthLowerDownLeft', 'mouthLowerDownRight',
+    'mouthUpperUpLeft', 'mouthUpperUpRight',
+    'tongueOut',
+    'cheekPuff', 'cheekSquintLeft', 'cheekSquintRight',
+    'noseSneerLeft', 'noseSneerRight',
+    'eyeBlinkLeft', 'eyeBlinkRight',
+    'eyeLookDownLeft', 'eyeLookDownRight', 'eyeLookInLeft', 'eyeLookInRight',
+    'eyeLookOutLeft', 'eyeLookOutRight', 'eyeLookUpLeft', 'eyeLookUpRight',
+    'eyeSquintLeft', 'eyeSquintRight', 'eyeWideLeft', 'eyeWideRight',
+    'browDownLeft', 'browDownRight', 'browInnerUp', 'browOuterUpLeft', 'browOuterUpRight'
+];
+const BLENDSHAPE_COUNT = 52;
+
+class AudioPlayer extends EventEmitter {
+    constructor(sampleRate = 24000) {
+        super();
+        this.audioContext = null;
+        this.audioQueue = [];
+        this.isPlaying = false;
+        this.sampleRate = sampleRate;
+    }
+    async ensureAudioContext() {
+        if (!this.audioContext || this.audioContext.state === 'closed') {
+            this.audioContext = new AudioContext({ sampleRate: this.sampleRate });
+        }
+        if (this.audioContext.state === 'suspended') {
+            await this.audioContext.resume();
+        }
+        return this.audioContext;
+    }
+    enqueue(chunk) {
+        console.log('[AudioPlayer] Enqueue called, queue length before:', this.audioQueue.length, 'isPlaying:', this.isPlaying);
+        this.audioQueue.push(chunk);
+        if (!this.isPlaying) {
+            console.log('[AudioPlayer] Not playing, starting playNext');
+            this.playNext();
+        }
+    }
+    clearQueue() {
+        this.audioQueue = [];
+        this.isPlaying = false;
+        this.emit('blendshapeUpdate', new Array(BLENDSHAPE_COUNT).fill(0));
+    }
+    async playNext() {
+        if (this.audioQueue.length === 0) {
+            this.isPlaying = false;
+            this.emit('queueEmpty');
+            return;
+        }
+        const chunk = this.audioQueue.shift();
+        await this.playChunk(chunk);
+    }
+    generateAmplitudeBlendshapes(floatArray, fps = 30) {
+        const samplesPerFrame = Math.floor(this.sampleRate / fps);
+        const frameCount = Math.ceil(floatArray.length / samplesPerFrame);
+        const blendshapes = [];
+        for (let frame = 0; frame < frameCount; frame++) {
+            const start = frame * samplesPerFrame;
+            const end = Math.min(start + samplesPerFrame, floatArray.length);
+            let sum = 0;
+            for (let i = start; i < end; i++) {
+                sum += Math.abs(floatArray[i]);
+            }
+            const amplitude = sum / (end - start);
+            const jawOpen = Math.min(amplitude * 3, 1);
+            const mouthOpen = Math.min(amplitude * 2.5, 0.8);
+            const frameData = new Array(BLENDSHAPE_COUNT).fill(0);
+            frameData[25] = jawOpen; // jawOpen
+            frameData[27] = mouthOpen; // mouthFunnel
+            frameData[29] = mouthOpen * 0.3; // mouthLowerDownLeft
+            frameData[30] = mouthOpen * 0.3; // mouthLowerDownRight
+            blendshapes.push(frameData);
+        }
+        return blendshapes;
+    }
+    async playChunk(chunk) {
+        try {
+            console.log('[AudioPlayer] playChunk called, audio byteLength:', chunk.audio.byteLength);
+            const ctx = await this.ensureAudioContext();
+            console.log('[AudioPlayer] AudioContext state:', ctx.state, 'sampleRate:', ctx.sampleRate);
+            const int16Array = new Int16Array(chunk.audio);
+            const floatArray = new Float32Array(int16Array.length);
+            for (let i = 0; i < int16Array.length; i++) {
+                floatArray[i] = int16Array[i] / 32768.0;
+            }
+            console.log('[AudioPlayer] Converted to float, samples:', floatArray.length);
+            const audioBuffer = ctx.createBuffer(1, floatArray.length, this.sampleRate);
+            audioBuffer.getChannelData(0).set(floatArray);
+            const source = ctx.createBufferSource();
+            source.buffer = audioBuffer;
+            source.connect(ctx.destination);
+            console.log('[AudioPlayer] Audio buffer duration:', audioBuffer.duration, 'seconds');
+            const hasBlendshapes = chunk.blendshapes && chunk.blendshapes.length > 0;
+            console.log('[AudioPlayer] Has blendshapes:', hasBlendshapes, 'generating amplitude fallback:', !hasBlendshapes);
+            const blendshapes = hasBlendshapes
+                ? chunk.blendshapes
+                : this.generateAmplitudeBlendshapes(floatArray);
+            const duration = audioBuffer.duration * 1000;
+            const startTime = performance.now();
+            let frameIndex = 0;
+            this.isPlaying = true;
+            this.emit('playbackStarted');
+            const animate = () => {
+                const elapsed = performance.now() - startTime;
+                if (elapsed >= duration || frameIndex >= blendshapes.length) {
+                    this.emit('blendshapeUpdate', new Array(BLENDSHAPE_COUNT).fill(0));
+                    this.emit('playbackEnded');
+                    this.playNext();
+                    return;
+                }
+                const progress = elapsed / duration;
+                const targetFrame = Math.min(Math.floor(progress * blendshapes.length), blendshapes.length - 1);
+                if (targetFrame !== frameIndex) {
+                    frameIndex = targetFrame;
+                    const frame = blendshapes[frameIndex];
+                    if (frame) {
+                        this.emit('blendshapeUpdate', frame);
+                    }
+                }
+                requestAnimationFrame(animate);
+            };
+            console.log('[AudioPlayer] Starting audio playback');
+            source.start();
+            requestAnimationFrame(animate);
+        }
+        catch (err) {
+            console.error('[AudioPlayer] Error in playChunk:', err);
+            this.emit('error', err instanceof Error ? err : new Error(String(err)));
+            this.isPlaying = false;
+            this.playNext();
+        }
+    }
+    async destroy() {
+        this.clearQueue();
+        if (this.audioContext && this.audioContext.state !== 'closed') {
+            await this.audioContext.close();
+        }
+        this.audioContext = null;
+        this.removeAllListeners();
+    }
+}
+
+class AStackCSRClient extends EventEmitter {
+    constructor(config) {
+        super();
+        this.ws = null;
+        this.audioContext = null;
+        this.audioProcessor = null;
+        this.mediaStream = null;
+        this.videoRef = null;
+        this.imageCaptureCanvas = null;
+        this.imageCaptureInterval = null;
+        this.callStatus = 'idle';
+        this.currentBlendshapes = new Array(BLENDSHAPE_COUNT).fill(0);
+        this.config = {
+            workerUrl: config.workerUrl,
+            sessionToken: config.sessionToken || '',
+            sessionId: config.sessionId || '',
+            sampleRate: config.sampleRate || 24000,
+            providers: config.providers || { asr: 'self', llm: 'self', tts: 'self' },
+            fps: config.fps || 30,
+            enableImageCapture: config.enableImageCapture ?? true,
+            imageCaptureInterval: config.imageCaptureInterval || 5000
+        };
+        this.audioPlayer = new AudioPlayer(this.config.sampleRate);
+        this.setupAudioPlayerEvents();
+    }
+    setupAudioPlayerEvents() {
+        this.audioPlayer.on('blendshapeUpdate', (blendshapes) => {
+            this.currentBlendshapes = blendshapes;
+            this.emit('blendshapeUpdate', blendshapes);
+        });
+        this.audioPlayer.on('playbackStarted', () => {
+            this.emit('playbackStarted');
+        });
+        this.audioPlayer.on('playbackEnded', () => {
+            this.emit('playbackEnded');
+        });
+        this.audioPlayer.on('error', (error) => {
+            this.emit('error', error);
+        });
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const wsUrl = this.config.workerUrl.replace(/^http/, 'ws');
+            const url = new URL(wsUrl);
+            if (this.config.sessionToken) {
+                url.searchParams.set('token', this.config.sessionToken);
+            }
+            if (this.config.sessionId) {
+                url.searchParams.set('sessionId', this.config.sessionId);
+            }
+            this.ws = new WebSocket(url.toString());
+            this.ws.onopen = () => {
+                this.emit('connected');
+                resolve();
+            };
+            this.ws.onclose = () => {
+                this.emit('disconnected');
+                this.callStatus = 'idle';
+            };
+            this.ws.onerror = (event) => {
+                const error = new Error('WebSocket connection error');
+                this.emit('error', error);
+                reject(error);
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    this.handleMessage(data);
+                }
+                catch (err) {
+                    console.error('[CSR] Failed to parse message:', err);
+                }
+            };
+        });
+    }
+    handleMessage(data) {
+        console.log('[CSR] Received message:', data.type);
+        switch (data.type) {
+            case 'a2f_call_started':
+                this.callStatus = 'active';
+                this.emit('callStarted');
+                break;
+            case 'a2f_call_stopped':
+                this.callStatus = 'idle';
+                this.emit('callStopped');
+                break;
+            case 'a2f_call_error':
+                this.callStatus = 'error';
+                this.emit('error', new Error(data.message));
+                break;
+            case 'a2f_transcript':
+                this.emit('transcript', data.text);
+                break;
+            case 'a2f_response':
+                this.emit('response', data.text);
+                break;
+            case 'call_chunk':
+            case 'a2f_call_chunk':
+                console.log('[CSR] Audio chunk received, has audio:', !!data.audio, 'has blendshapes:', !!data.blendshapes);
+                if (data.audio) {
+                    try {
+                        const binaryString = atob(data.audio);
+                        const bytes = new Uint8Array(binaryString.length);
+                        for (let i = 0; i < binaryString.length; i++) {
+                            bytes[i] = binaryString.charCodeAt(i);
+                        }
+                        console.log('[CSR] Decoded audio bytes:', bytes.length);
+                        const chunk = {
+                            audio: bytes.buffer,
+                            blendshapes: data.blendshapes
+                        };
+                        console.log('[CSR] Enqueueing audio chunk');
+                        this.audioPlayer.enqueue(chunk);
+                    }
+                    catch (err) {
+                        console.error('[CSR] Error decoding audio chunk:', err);
+                    }
+                }
+                else {
+                    console.warn('[CSR] Audio chunk missing audio data');
+                }
+                break;
+            case 'a2f_model_status':
+                this.emit('modelStatus', {
+                    model_loaded: data.model_loaded,
+                    blendshape_count: data.blendshape_count
+                });
+                break;
+        }
+    }
+    async startCall() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket not connected');
+        }
+        if (this.callStatus !== 'idle') {
+            throw new Error('Call already in progress');
+        }
+        this.callStatus = 'starting';
+        this.audioPlayer.clearQueue();
+        try {
+            this.audioContext = new AudioContext({ sampleRate: 16000 });
+            await this.audioContext.audioWorklet.addModule('/audio-processor.js');
+            this.mediaStream = await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    sampleRate: 16000,
+                    channelCount: 1,
+                    echoCancellation: true,
+                    noiseSuppression: true
+                },
+                video: this.config.enableImageCapture ? {
+                    width: { ideal: 320 },
+                    height: { ideal: 240 },
+                    facingMode: 'user'
+                } : false
+            });
+            if (this.config.enableImageCapture) {
+                const videoTrack = this.mediaStream.getVideoTracks()[0];
+                if (videoTrack) {
+                    this.videoRef = document.createElement('video');
+                    this.videoRef.autoplay = true;
+                    this.videoRef.playsInline = true;
+                    this.videoRef.muted = true;
+                    this.videoRef.srcObject = new MediaStream([videoTrack]);
+                    await this.videoRef.play();
+                    this.imageCaptureCanvas = document.createElement('canvas');
+                    this.startImageCapture();
+                }
+            }
+            this.ws.send(JSON.stringify({
+                type: 'a2f_call_start',
+                providers: this.config.providers,
+                fps: this.config.fps
+            }));
+            const source = this.audioContext.createMediaStreamSource(this.mediaStream);
+            this.audioProcessor = new AudioWorkletNode(this.audioContext, 'audio-processor');
+            this.audioProcessor.port.onmessage = (event) => {
+                if (event.data.type === 'audio_data' && this.ws?.readyState === WebSocket.OPEN) {
+                    const base64String = btoa(String.fromCharCode(...new Uint8Array(event.data.audioBuffer)));
+                    this.ws.send(JSON.stringify({
+                        type: 'a2f_call_audio',
+                        audio: base64String
+                    }));
+                }
+            };
+            source.connect(this.audioProcessor);
+            this.audioProcessor.connect(this.audioContext.destination);
+        }
+        catch (err) {
+            this.callStatus = 'error';
+            throw err;
+        }
+    }
+    startImageCapture() {
+        if (this.imageCaptureInterval) {
+            clearInterval(this.imageCaptureInterval);
+        }
+        this.imageCaptureInterval = setInterval(() => {
+            this.captureAndSendImage();
+        }, this.config.imageCaptureInterval);
+    }
+    captureAndSendImage() {
+        if (!this.videoRef || !this.imageCaptureCanvas || !this.ws)
+            return;
+        if (this.ws.readyState !== WebSocket.OPEN)
+            return;
+        if (this.videoRef.readyState < 2)
+            return;
+        const ctx = this.imageCaptureCanvas.getContext('2d');
+        if (!ctx)
+            return;
+        this.imageCaptureCanvas.width = 320;
+        this.imageCaptureCanvas.height = 240;
+        ctx.drawImage(this.videoRef, 0, 0, 320, 240);
+        const imageDataUrl = this.imageCaptureCanvas.toDataURL('image/jpeg', 0.7);
+        const base64Image = imageDataUrl.split(',')[1];
+        this.ws.send(JSON.stringify({
+            type: 'a2f_call_image',
+            image: base64Image,
+            timestamp: Date.now()
+        }));
+    }
+    stopCall() {
+        if (this.imageCaptureInterval) {
+            clearInterval(this.imageCaptureInterval);
+            this.imageCaptureInterval = null;
+        }
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ type: 'a2f_call_stop' }));
+        }
+        if (this.videoRef) {
+            this.videoRef.srcObject = null;
+            this.videoRef = null;
+        }
+        if (this.mediaStream) {
+            this.mediaStream.getTracks().forEach(track => track.stop());
+            this.mediaStream = null;
+        }
+        if (this.audioProcessor) {
+            this.audioProcessor.disconnect();
+            this.audioProcessor.port.onmessage = null;
+            this.audioProcessor = null;
+        }
+        if (this.audioContext) {
+            this.audioContext.close();
+            this.audioContext = null;
+        }
+        this.audioPlayer.clearQueue();
+        this.callStatus = 'idle';
+        this.currentBlendshapes = new Array(BLENDSHAPE_COUNT).fill(0);
+        this.emit('blendshapeUpdate', this.currentBlendshapes);
+    }
+    sendText(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket not connected');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'a2f_text_message',
+            text: message
+        }));
+    }
+    disconnect() {
+        this.stopCall();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    getCallStatus() {
+        return this.callStatus;
+    }
+    getCurrentBlendshapes() {
+        return [...this.currentBlendshapes];
+    }
+    isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    async destroy() {
+        this.disconnect();
+        await this.audioPlayer.destroy();
+        this.removeAllListeners();
+    }
+}
+
+export { ARKIT_BLENDSHAPES, AStackCSRClient, AStackClient, AStackError, AudioPlayer, BLENDSHAPE_COUNT, ErrorCodes, SupabaseSignalingClient, WebRTCManager, AStackClient as default };
+//# sourceMappingURL=index.esm.js.map