@nextpa/chat-core 0.1.0

package/dist/services/signalr.js

@@ -0,0 +1,145 @@
+import * as signalR from '@microsoft/signalr';
+import { logger } from '../utils/logger';
+export class SignalRService {
+    connection = null;
+    events = {};
+    textChatHandlers = {};
+    pageInteractionHandlers = {};
+    registrationInfo = null;
+    get isConnected() {
+        return this.connection?.state === signalR.HubConnectionState.Connected;
+    }
+    setEventHandlers(events) {
+        this.events = events;
+    }
+    setTextChatHandlers(handlers) {
+        this.textChatHandlers = handlers;
+    }
+    clearTextChatHandlers() {
+        this.textChatHandlers = {};
+    }
+    setPageInteractionHandlers(handlers) {
+        this.pageInteractionHandlers = handlers;
+    }
+    clearPageInteractionHandlers() {
+        this.pageInteractionHandlers = {};
+    }
+    getConnection() {
+        return this.connection;
+    }
+    setRegistrationInfo(clientId, tenantId, userId) {
+        this.registrationInfo = { clientId, tenantId, userId };
+    }
+    async connect(baseUrl, token) {
+        if (this.connection) {
+            await this.disconnect();
+        }
+        const hubUrl = baseUrl.endsWith('/notificationHub')
+            ? baseUrl
+            : `${baseUrl.replace(/\/$/, '')}/notificationHub`;
+        logger.debug('[SignalR] Connecting to:', hubUrl);
+        this.connection = new signalR.HubConnectionBuilder()
+            .withUrl(hubUrl, {
+            accessTokenFactory: () => token,
+        })
+            .withAutomaticReconnect([2000, 5000, 10000, 30000, 60000])
+            .configureLogging(signalR.LogLevel.Information)
+            .build();
+        this.connection.serverTimeoutInMilliseconds = 60000;
+        this.connection.keepAliveIntervalInMilliseconds = 30000;
+        this.setupEventHandlers();
+        try {
+            await this.connection.start();
+            logger.debug('[SignalR] Connected');
+            await this.registerClient();
+            this.events.onConnected?.();
+        }
+        catch (error) {
+            logger.error('[SignalR] Connection failed:', error);
+            throw error;
+        }
+    }
+    async disconnect() {
+        if (this.connection) {
+            await this.connection.stop();
+            this.connection = null;
+            logger.debug('[SignalR] Disconnected');
+        }
+    }
+    async registerClient() {
+        if (!this.connection || !this.registrationInfo) {
+            logger.warn('[SignalR] Cannot register client: no connection or registration info');
+            return;
+        }
+        try {
+            await this.connection.invoke('RegisterClient', this.registrationInfo.clientId, this.registrationInfo.tenantId, this.registrationInfo.userId, 'Widget');
+            logger.debug('[SignalR] Client registered:', this.registrationInfo.clientId);
+        }
+        catch (error) {
+            logger.error('[SignalR] Failed to register client:', error);
+        }
+    }
+    setupEventHandlers() {
+        if (!this.connection)
+            return;
+        this.connection.on('ReceiveNotification', (type, payloadJson) => {
+            logger.debug('[SignalR] ReceiveNotification:', type);
+            this.handleNotification(type, payloadJson);
+        });
+        this.connection.onreconnecting((error) => {
+            logger.debug('[SignalR] Reconnecting...', error);
+        });
+        this.connection.onreconnected(async () => {
+            logger.debug('[SignalR] Reconnected');
+            await this.registerClient();
+            this.events.onConnected?.();
+        });
+        this.connection.onclose((error) => {
+            logger.debug('[SignalR] Connection closed', error);
+            this.events.onDisconnected?.();
+        });
+    }
+    handleNotification(type, payloadJson) {
+        try {
+            const payload = JSON.parse(payloadJson);
+            switch (type) {
+                case 'conversation.stop':
+                    logger.debug('[SignalR] StopConversation received');
+                    this.events.onStopConversation?.();
+                    break;
+                case 'navigation.openurl':
+                    logger.debug('[SignalR] OpenUrl received:', payload.url);
+                    this.events.onOpenUrl?.(payload.url);
+                    break;
+                case 'navigation.openfile':
+                    logger.debug('[SignalR] OpenFile received:', payload.url);
+                    this.events.onOpenFile?.(payload.url);
+                    break;
+                case 'navigation.error':
+                    logger.error('[SignalR] Error received:', payload.title, payload.message);
+                    this.events.onError?.(payload.title, payload.message);
+                    break;
+                case 'textchat.stream_delta':
+                    this.textChatHandlers.onStreamDelta?.(payload.delta, payload.messageId);
+                    break;
+                case 'textchat.stream_completed':
+                    logger.debug('[SignalR] TextChat stream completed, messageId:', payload.messageId);
+                    this.textChatHandlers.onStreamCompleted?.(payload.fullText, payload.messageId);
+                    break;
+                case 'textchat.tool_call':
+                    logger.debug('[SignalR] TextChat tool call:', payload.toolName, payload.status, payload.agentLabel);
+                    this.textChatHandlers.onToolCall?.(payload.toolName, payload.status, payload.result, payload.agentLabel);
+                    break;
+                case 'pageinteraction.request':
+                    logger.debug('[SignalR] PageInteraction request received');
+                    this.pageInteractionHandlers.onPageInteractionRequest?.(payloadJson);
+                    break;
+                default:
+                    logger.debug('[SignalR] Unhandled notification type:', type, payload);
+            }
+        }
+        catch (error) {
+            logger.error('[SignalR] Failed to parse notification:', error);
+        }
+    }
+}

package/dist/services/thinking-audio-pulse.d.ts

@@ -0,0 +1,2 @@
+export declare function startThinkingAudio(): void;
+export declare function stopThinkingAudio(): void;

package/dist/services/thinking-audio-pulse.js

@@ -0,0 +1,72 @@
+const INITIAL_DELAY_MS = 10_000;
+const VOLUME = 0.06;
+const BREATH_IN_S = 0.2;
+const BREATH_HOLD_S = 0.1;
+const BREATH_OUT_S = 0.4;
+const PAUSE_BETWEEN_S = 4;
+const CHORD_FREQUENCIES = [60, 50];
+let audioContext = null;
+let masterGain = null;
+let isActive = false;
+let delayTimer = null;
+let breathTimer = null;
+function playBreath() {
+    if (!audioContext || !masterGain || !isActive)
+        return;
+    const now = audioContext.currentTime;
+    const breathEnvelope = audioContext.createGain();
+    breathEnvelope.gain.setValueAtTime(0, now);
+    breathEnvelope.gain.linearRampToValueAtTime(1, now + BREATH_IN_S);
+    breathEnvelope.gain.setValueAtTime(1, now + BREATH_IN_S + BREATH_HOLD_S);
+    breathEnvelope.gain.linearRampToValueAtTime(0, now + BREATH_IN_S + BREATH_HOLD_S + BREATH_OUT_S);
+    const totalDuration = BREATH_IN_S + BREATH_HOLD_S + BREATH_OUT_S;
+    for (const freq of CHORD_FREQUENCIES) {
+        const osc = audioContext.createOscillator();
+        osc.type = 'sine';
+        osc.frequency.value = freq;
+        osc.connect(breathEnvelope);
+        osc.start(now);
+        osc.stop(now + totalDuration + 0.1);
+    }
+    breathEnvelope.connect(masterGain);
+    const nextBreathMs = (totalDuration + PAUSE_BETWEEN_S) * 1000;
+    breathTimer = setTimeout(() => playBreath(), nextBreathMs);
+}
+export function startThinkingAudio() {
+    if (isActive)
+        return;
+    isActive = true;
+    delayTimer = setTimeout(() => {
+        if (!isActive)
+            return;
+        audioContext = new AudioContext();
+        masterGain = audioContext.createGain();
+        masterGain.gain.value = VOLUME;
+        masterGain.connect(audioContext.destination);
+        if (audioContext.state === 'suspended') {
+            void audioContext.resume();
+        }
+        playBreath();
+    }, INITIAL_DELAY_MS);
+}
+export function stopThinkingAudio() {
+    isActive = false;
+    if (delayTimer) {
+        clearTimeout(delayTimer);
+        delayTimer = null;
+    }
+    if (breathTimer) {
+        clearTimeout(breathTimer);
+        breathTimer = null;
+    }
+    if (masterGain && audioContext) {
+        masterGain.gain.linearRampToValueAtTime(0, audioContext.currentTime + 0.3);
+    }
+    setTimeout(() => {
+        if (audioContext) {
+            void audioContext.close();
+            audioContext = null;
+            masterGain = null;
+        }
+    }, 400);
+}

package/dist/services/thinking-audio.d.ts

@@ -0,0 +1,2 @@
+export declare function startThinkingAudio(): void;
+export declare function stopThinkingAudio(): void;

package/dist/services/thinking-audio.js

@@ -0,0 +1,105 @@
+// --- Timing ---
+const INITIAL_DELAY_MS = 10_000;
+const MIN_KEY_INTERVAL_MS = 60;
+const MAX_KEY_INTERVAL_MS = 180;
+const MIN_BURST_KEYS = 8;
+const MAX_BURST_KEYS = 25;
+const MIN_PAUSE_MS = 3_000;
+const MAX_PAUSE_MS = 8_000;
+// --- Sound shaping ---
+const CLICK_DURATION_S = 0.012;
+const CLICK_VOLUME = 0.08;
+const NOISE_BUFFER_SIZE = 2048;
+let audioContext = null;
+let masterGain = null;
+let noiseBuffer = null;
+let isActive = false;
+const pendingTimers = [];
+function randomBetween(min, max) {
+    return min + Math.random() * (max - min);
+}
+function addTimer(callback, delayMs) {
+    const timer = setTimeout(callback, delayMs);
+    pendingTimers.push(timer);
+}
+function clearAllTimers() {
+    for (const timer of pendingTimers) {
+        clearTimeout(timer);
+    }
+    pendingTimers.length = 0;
+}
+function createNoiseBuffer(ctx) {
+    const buffer = ctx.createBuffer(1, NOISE_BUFFER_SIZE, ctx.sampleRate);
+    const data = buffer.getChannelData(0);
+    for (let i = 0; i < NOISE_BUFFER_SIZE; i++) {
+        data[i] = Math.random() * 2 - 1;
+    }
+    return buffer;
+}
+function playKeystroke() {
+    if (!audioContext || !masterGain || !noiseBuffer)
+        return;
+    const now = audioContext.currentTime;
+    const source = audioContext.createBufferSource();
+    source.buffer = noiseBuffer;
+    const bandpass = audioContext.createBiquadFilter();
+    bandpass.type = 'bandpass';
+    bandpass.frequency.value = 2000 + Math.random() * 2000;
+    bandpass.Q.value = 1.5 + Math.random();
+    const envelope = audioContext.createGain();
+    envelope.gain.setValueAtTime(0, now);
+    envelope.gain.linearRampToValueAtTime(0.6 + Math.random() * 0.4, now + 0.001);
+    envelope.gain.exponentialRampToValueAtTime(0.001, now + CLICK_DURATION_S);
+    source.connect(bandpass);
+    bandpass.connect(envelope);
+    envelope.connect(masterGain);
+    source.start(now);
+    source.stop(now + CLICK_DURATION_S);
+}
+function scheduleTypingBurst() {
+    if (!isActive)
+        return;
+    const keyCount = Math.floor(randomBetween(MIN_BURST_KEYS, MAX_BURST_KEYS));
+    let delay = 0;
+    for (let i = 0; i < keyCount; i++) {
+        const keyDelay = delay;
+        addTimer(() => {
+            if (!isActive)
+                return;
+            playKeystroke();
+        }, keyDelay);
+        delay += randomBetween(MIN_KEY_INTERVAL_MS, MAX_KEY_INTERVAL_MS);
+    }
+    const pauseAfterBurst = delay + randomBetween(MIN_PAUSE_MS, MAX_PAUSE_MS);
+    addTimer(() => scheduleTypingBurst(), pauseAfterBurst);
+}
+export function startThinkingAudio() {
+    if (isActive)
+        return;
+    isActive = true;
+    addTimer(() => {
+        if (!isActive)
+            return;
+        audioContext = new AudioContext();
+        masterGain = audioContext.createGain();
+        masterGain.gain.value = CLICK_VOLUME;
+        masterGain.connect(audioContext.destination);
+        noiseBuffer = createNoiseBuffer(audioContext);
+        scheduleTypingBurst();
+    }, INITIAL_DELAY_MS);
+}
+export function stopThinkingAudio() {
+    isActive = false;
+    clearAllTimers();
+    if (masterGain && audioContext) {
+        masterGain.gain.linearRampToValueAtTime(0, audioContext.currentTime + 0.05);
+    }
+    setTimeout(() => {
+        if (audioContext) {
+            void audioContext.close();
+            audioContext = null;
+            masterGain = null;
+            noiseBuffer = null;
+        }
+    }, 150);
+}

package/dist/services/voice-health-watchdog.d.ts

@@ -0,0 +1,42 @@
+import type { RealtimeProviderClient } from './realtime/types';
+export type VoiceUnhealthyReason = 'no-setup' | 'no-greeting-response';
+/**
+ * Watches a freshly-connected realtime voice session and reports when it is
+ * "connected but dead": the provider socket is up, yet the session never
+ * reaches a working state. The intermittent suspended-AudioContext / lost-setup
+ * races surface exactly like this — no disconnect event fires, so the existing
+ * unexpected-disconnect reconnect path never triggers and the user sees a mute
+ * assistant + unrecognised speech until a manual reset.
+ *
+ * Two phases after connect:
+ *  1. setup — expect `sessionReady` (provider setup complete) within
+ *     SETUP_TIMEOUT_MS, else trip `no-setup`.
+ *  2. greeting — only when a greeting is expected: after setup, expect a sign
+ *     the model actually started responding (`assistantTranscriptDelta` OR
+ *     `audioDone`) within GREETING_RESPONSE_TIMEOUT_MS, else trip
+ *     `no-greeting-response`. Keyed on response *start*, not finish, so a long
+ *     greeting never trips it.
+ *
+ * On a trip it calls `onUnhealthy(reason)`; the owner recovers by tearing the
+ * session down and reconnecting (like a manual reset). It calls `onHealthy()`
+ * once the session proves alive so the owner can reset its recovery budget.
+ * The watchdog never closes the connection itself — it only observes + reports.
+ */
+export declare class VoiceHealthWatchdog {
+    private readonly client;
+    private readonly expectGreeting;
+    private readonly onUnhealthy;
+    private readonly onHealthy;
+    private setupTimer;
+    private greetingTimer;
+    private readonly unsubscribers;
+    private settled;
+    constructor(client: RealtimeProviderClient, expectGreeting: boolean, onUnhealthy: (reason: VoiceUnhealthyReason) => void, onHealthy: () => void);
+    start(): void;
+    stop(): void;
+    private handleSessionReady;
+    private markHealthy;
+    private trip;
+    private clearTimers;
+    private clearTimer;
+}

package/dist/services/voice-health-watchdog.js

@@ -0,0 +1,90 @@
+import { logger } from '../utils/logger';
+const SETUP_TIMEOUT_MS = 6000;
+const GREETING_RESPONSE_TIMEOUT_MS = 8000;
+/**
+ * Watches a freshly-connected realtime voice session and reports when it is
+ * "connected but dead": the provider socket is up, yet the session never
+ * reaches a working state. The intermittent suspended-AudioContext / lost-setup
+ * races surface exactly like this — no disconnect event fires, so the existing
+ * unexpected-disconnect reconnect path never triggers and the user sees a mute
+ * assistant + unrecognised speech until a manual reset.
+ *
+ * Two phases after connect:
+ *  1. setup — expect `sessionReady` (provider setup complete) within
+ *     SETUP_TIMEOUT_MS, else trip `no-setup`.
+ *  2. greeting — only when a greeting is expected: after setup, expect a sign
+ *     the model actually started responding (`assistantTranscriptDelta` OR
+ *     `audioDone`) within GREETING_RESPONSE_TIMEOUT_MS, else trip
+ *     `no-greeting-response`. Keyed on response *start*, not finish, so a long
+ *     greeting never trips it.
+ *
+ * On a trip it calls `onUnhealthy(reason)`; the owner recovers by tearing the
+ * session down and reconnecting (like a manual reset). It calls `onHealthy()`
+ * once the session proves alive so the owner can reset its recovery budget.
+ * The watchdog never closes the connection itself — it only observes + reports.
+ */
+export class VoiceHealthWatchdog {
+    client;
+    expectGreeting;
+    onUnhealthy;
+    onHealthy;
+    setupTimer = null;
+    greetingTimer = null;
+    unsubscribers = [];
+    settled = false;
+    constructor(client, expectGreeting, onUnhealthy, onHealthy) {
+        this.client = client;
+        this.expectGreeting = expectGreeting;
+        this.onUnhealthy = onUnhealthy;
+        this.onHealthy = onHealthy;
+    }
+    start() {
+        this.unsubscribers.push(this.client.on('sessionReady', () => this.handleSessionReady()), this.client.on('assistantTranscriptDelta', () => this.markHealthy()), this.client.on('audioDone', () => this.markHealthy()), this.client.on('connectionStateChanged', (state) => {
+            if (state === 'disconnected')
+                this.stop();
+        }));
+        this.setupTimer = setTimeout(() => this.trip('no-setup'), SETUP_TIMEOUT_MS);
+    }
+    stop() {
+        this.settled = true;
+        this.clearTimers();
+        for (const unsubscribe of this.unsubscribers)
+            unsubscribe();
+        this.unsubscribers.length = 0;
+    }
+    handleSessionReady() {
+        if (this.settled)
+            return;
+        this.clearTimer('setupTimer');
+        if (!this.expectGreeting) {
+            this.markHealthy();
+            return;
+        }
+        this.greetingTimer = setTimeout(() => this.trip('no-greeting-response'), GREETING_RESPONSE_TIMEOUT_MS);
+    }
+    markHealthy() {
+        if (this.settled)
+            return;
+        logger.debug('[VoiceWatchdog] voice session healthy');
+        this.stop();
+        this.onHealthy();
+    }
+    trip(reason) {
+        if (this.settled)
+            return;
+        logger.warn('[VoiceWatchdog] voice session unhealthy:', reason, '— requesting recovery');
+        this.stop();
+        this.onUnhealthy(reason);
+    }
+    clearTimers() {
+        this.clearTimer('setupTimer');
+        this.clearTimer('greetingTimer');
+    }
+    clearTimer(which) {
+        const timer = this[which];
+        if (timer) {
+            clearTimeout(timer);
+            this[which] = null;
+        }
+    }
+}

package/dist/services/webrtc-event-handler.d.ts

@@ -0,0 +1,4 @@
+import type { RealtimeProviderClient, ProviderUsage } from './realtime/types';
+import type { ConnectionState, ConversationEvents } from '../types';
+import type { MicrophoneManager } from './webrtc-microphone';
+export declare function setupEventHandlers(client: RealtimeProviderClient, events: ConversationEvents, microphoneManager: MicrophoneManager, setConnectionState: (state: ConnectionState) => void, onUsageUpdated?: (usage: ProviderUsage) => void): void;

package/dist/services/webrtc-event-handler.js

@@ -0,0 +1,42 @@
+export function setupEventHandlers(client, events, microphoneManager, setConnectionState, onUsageUpdated) {
+    client.on('connectionStateChanged', setConnectionState);
+    client.on('userSpeechStarted', () => {
+        if (microphoneManager.isReady)
+            events.onUserSpeechStart?.();
+    });
+    client.on('userSpeechStopped', () => {
+        if (microphoneManager.isReady)
+            events.onUserSpeechStop?.();
+    });
+    client.on('userSpeechEnded', () => {
+        if (microphoneManager.isReady)
+            events.onUserSpeechEnd?.();
+    });
+    client.on('userAudioLevel', (level) => {
+        if (microphoneManager.isReady)
+            events.onAudioLevel?.(level);
+    });
+    client.on('userTranscriptCompleted', (transcript) => {
+        if (microphoneManager.isReady)
+            events.onTranscriptReceived?.(true, transcript);
+    });
+    client.on('userTranscriptDelta', (delta) => {
+        if (microphoneManager.isReady)
+            events.onTranscriptDelta?.(true, delta);
+    });
+    client.on('assistantTranscriptDelta', (delta) => {
+        events.onTranscriptDelta?.(false, delta);
+    });
+    client.on('assistantTranscriptDone', (transcript) => {
+        events.onTranscriptReceived?.(false, transcript);
+    });
+    client.on('functionCall', (call) => {
+        events.onFunctionCall?.(call);
+    });
+    client.on('usageUpdated', (usage) => {
+        onUsageUpdated?.(usage);
+    });
+    client.on('error', (error) => {
+        events.onError?.(error.message);
+    });
+}

package/dist/services/webrtc-greeting.d.ts

@@ -0,0 +1,3 @@
+import type { RealtimeProviderClient } from './realtime/types';
+import type { MicrophoneManager } from './webrtc-microphone';
+export declare function startGreetingFlow(client: RealtimeProviderClient, microphoneManager: MicrophoneManager, onMicrophoneReady: (() => void) | undefined, skipGreeting?: boolean): void;

package/dist/services/webrtc-greeting.js

@@ -0,0 +1,62 @@
+import { logger } from '../utils/logger';
+const GREETING_TIMEOUT_MS = 30000;
+export function startGreetingFlow(client, microphoneManager, onMicrophoneReady, skipGreeting = false) {
+    // Only bail when the connection genuinely failed. A successful connect can
+    // still report 'connecting' here for a beat: the Vertex provider resolves
+    // connect() after audio capture starts, but flips to 'connected' only in
+    // ws.onopen — which can land after this runs. requestResponse() queues
+    // internally until the session is ready, so requesting now is safe; bailing
+    // on 'connecting' drops the greeting entirely (assistant stays mute).
+    if (client.status === 'disconnected') {
+        return;
+    }
+    const enableMic = () => {
+        microphoneManager.enable(client);
+        onMicrophoneReady?.();
+    };
+    if (skipGreeting) {
+        logger.debug('[WebRTC] Resumed conversation — skipping greeting, enabling microphone immediately');
+        enableMic();
+        return;
+    }
+    let cleaned = false;
+    const cleanupFns = [];
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        for (const fn of cleanupFns)
+            fn();
+    };
+    cleanupFns.push(client.on('audioDone', () => {
+        logger.debug('[WebRTC] Greeting audioDone received, monitoring audio playback...');
+        cleanup();
+        client.waitForAudioPlaybackEnd()
+            .then((reason) => {
+            logger.debug(`[WebRTC] Greeting playback complete (${reason})`);
+            enableMic();
+        })
+            .catch(() => {
+            logger.debug('[WebRTC] Greeting audio monitoring unavailable, enabling microphone');
+            enableMic();
+        });
+    }), client.on('error', (error) => {
+        if (error.code === 'conversation_already_has_active_response') {
+            logger.debug('[WebRTC] Active response already exists, waiting for greeting');
+        }
+        else {
+            logger.debug('[WebRTC] Error during greeting, enabling microphone immediately');
+            cleanup();
+            enableMic();
+        }
+    }));
+    client.requestResponse();
+    logger.debug('[WebRTC] Greeting response requested');
+    setTimeout(() => {
+        cleanup();
+        if (!microphoneManager.isReady && client.status === 'connected') {
+            logger.debug('[WebRTC] Greeting timeout, enabling microphone anyway');
+            enableMic();
+        }
+    }, GREETING_TIMEOUT_MS);
+}

package/dist/services/webrtc-microphone.d.ts

@@ -0,0 +1,15 @@
+import type { RealtimeProviderClient } from './realtime/types';
+export declare class MicrophoneManager {
+    private _isReady;
+    private pendingMuteState;
+    private audioDeviceChanged;
+    private readonly onDeviceChange;
+    get isReady(): boolean;
+    requestPermission(): Promise<'granted' | 'denied' | 'prompt'>;
+    startDeviceChangeDetection(): void;
+    stopDeviceChangeDetection(): void;
+    setMuted(muted: boolean, client: RealtimeProviderClient): void;
+    enable(client: RealtimeProviderClient): void;
+    initPendingUnmute(): void;
+    reset(): void;
+}

package/dist/services/webrtc-microphone.js

@@ -0,0 +1,64 @@
+import { logger } from '../utils/logger';
+export class MicrophoneManager {
+    _isReady = false;
+    pendingMuteState = null;
+    audioDeviceChanged = false;
+    onDeviceChange = () => {
+        this.audioDeviceChanged = true;
+        logger.debug('[WebRTC] Audio device change detected');
+    };
+    get isReady() {
+        return this._isReady;
+    }
+    async requestPermission() {
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            stream.getTracks().forEach((track) => track.stop());
+            logger.debug('[WebRTC] Microphone permission granted');
+            return 'granted';
+        }
+        catch (err) {
+            logger.warn('[WebRTC] Microphone permission denied:', err);
+            return 'denied';
+        }
+    }
+    startDeviceChangeDetection() {
+        navigator.mediaDevices.addEventListener('devicechange', this.onDeviceChange);
+    }
+    stopDeviceChangeDetection() {
+        navigator.mediaDevices.removeEventListener('devicechange', this.onDeviceChange);
+    }
+    setMuted(muted, client) {
+        if (this.pendingMuteState !== null) {
+            this.pendingMuteState = muted;
+            return;
+        }
+        if (muted || !this.audioDeviceChanged) {
+            client.mute(muted);
+            return;
+        }
+        this.audioDeviceChanged = false;
+        client.refreshAudioDevice()
+            .catch(() => { })
+            .then(() => client.mute(muted));
+    }
+    enable(client) {
+        if (client.status !== 'connected') {
+            return;
+        }
+        const shouldBeMuted = this.pendingMuteState ?? false;
+        client.mute(shouldBeMuted);
+        this.pendingMuteState = null;
+        this._isReady = true;
+        logger.debug('[WebRTC] Microphone ready');
+    }
+    initPendingUnmute() {
+        this.pendingMuteState = false;
+    }
+    reset() {
+        this.pendingMuteState = null;
+        this._isReady = false;
+        this.audioDeviceChanged = false;
+        this.stopDeviceChangeDetection();
+    }
+}