@bobfrankston/msger 0.1.74 → 0.1.75

package/msger-native/bin/msgernative.exe.WebView2/EBWebView/Default/Cache/Cache_Data/f_000005

@@ -0,0 +1,626 @@
+// Voice Controller Module - Handles wake word detection and speech recognition
+// @ts-ignore - Module resolution for browser ES modules
+import { TensorFlowWakeWord, TENSORFLOW_WAKE_WORD_CONFIGS } from './tensorflow-wake-word-simple.js';
+export class VoiceController {
+    constructor(config, events = {}) {
+        this.isListening = false;
+        this.speechRecognition = null;
+        this.tensorflowModel = null;
+        this.audioContext = null;
+        this.mediaStream = null;
+        this.isInitialized = false;
+        this.currentState = 'idle';
+        this.wakeWordBuffer = [];
+        this.speechBuffer = [];
+        this.lastCommandTime = 0;
+        this.commandCooldown = 2000;
+        this.selectedMicrophoneId = null;
+        this.lastWakePhrase = '';
+        this.wakePhraseTimeout = 0;
+        this.consecutiveErrors = 0;
+        this.lastErrorType = '';
+        this.backoffDelay = 0;
+        this.maxConsecutiveErrors = 5;
+        this.isMicrophoneDead = false;
+        // Use null coalescing for cleaner backward compatibility
+        this.config = {
+            ...config,
+            timeoutMs: config.timeoutMs ?? config.commandTimeoutMs ?? 5000,
+            useTensorFlow: config.useTensorFlow ?? config.enableTensorFlow ?? false,
+            useWebSpeech: config.useWebSpeech ?? config.enableWebSpeech ?? true,
+            wakeWords: config.wakeWords ?? (config.wakeWord ? [config.wakeWord] : ['Computer']),
+            tabletMode: config.tabletMode ?? this.detectTablet()
+        };
+        this.events = events;
+        this.selectedMicrophoneId = localStorage.getItem('wallclock-selected-microphone');
+    }
+    detectTablet() {
+        const userAgent = navigator.userAgent.toLowerCase();
+        const isTouchDevice = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+        const isTabletUA = /tablet|ipad|android(?!.*mobile)/i.test(userAgent);
+        const isSmallScreen = window.innerWidth <= 1024; // Typical tablet breakpoint
+        return isTouchDevice && (isTabletUA || isSmallScreen);
+    }
+    isNativeWakePhrase(transcript) {
+        // Only match complete wake phrases to avoid false matches
+        const wakePatterns = [
+            /\b(go|hey)\s+(timer|time)\b/i, // "go timer" or "hey timer" ONLY
+            /\b(go|hey)\s*timer\b/i, // Handle missing space: "gotimer" or "heytimer"
+            /\b(go|hey)\s+(timer|time)r?\b/i, // Handle "timers" or slight variations
+        ];
+        const isMatch = wakePatterns.some(pattern => pattern.test(transcript));
+        console.log(`[VoiceController] Wake phrase check: "${transcript}" -> ${isMatch ? 'MATCHED' : 'NO MATCH'}`);
+        return isMatch;
+    }
+    async initialize() {
+        try {
+            this.log('Initializing voice controller...');
+            this.log(`Tablet mode: ${this.config.tabletMode}`);
+            this.log(`Using TensorFlow: ${this.config.useTensorFlow}`);
+            // For non-tablets, prefer native speech recognition
+            if (!this.config.tabletMode) {
+                this.config.useTensorFlow = false;
+                this.config.useWebSpeech = true;
+                this.log('Desktop detected: Using native speech recognition');
+            }
+            // Request microphone permission first
+            await this.requestMicrophonePermission();
+            // Initialize audio context
+            await this.initializeAudioContext();
+            // Initialize recognition engines based on config
+            if (this.config.useTensorFlow) {
+                await this.initializeTensorFlow();
+            }
+            if (this.config.useWebSpeech) {
+                this.initializeWebSpeech();
+            }
+            this.isInitialized = true;
+            this.events.statusChanged?.('Initialized successfully');
+            this.log('Voice controller initialized successfully');
+        }
+        catch (error) {
+            this.log(`Failed to initialize voice controller: ${error.message}`);
+            this.events.error?.(`Initialization failed: ${error.message}`);
+            throw error;
+        }
+    }
+    async getAvailableMicrophones() {
+        try {
+            this.log('Getting available microphones...');
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            this.log(`Total devices found: ${devices.length}`);
+            const microphones = devices
+                .filter(device => device.kind === 'audioinput')
+                .map(device => ({
+                deviceId: device.deviceId,
+                label: device.label || `Microphone ${device.deviceId.substr(0, 8)}`
+            }));
+            this.log(`Found ${microphones.length} microphones:`);
+            microphones.forEach(mic => {
+                this.log(`  - ${mic.label} (${mic.deviceId})`);
+            });
+            return microphones;
+        }
+        catch (error) {
+            this.log(`Failed to enumerate microphones: ${error.message}`);
+            console.error('[VOICE] Microphone enumeration error:', error);
+            return [];
+        }
+    }
+    setSelectedMicrophone(deviceId) {
+        this.selectedMicrophoneId = deviceId;
+        if (deviceId) {
+            localStorage.setItem('wallclock-selected-microphone', deviceId);
+        }
+        else {
+            localStorage.removeItem('wallclock-selected-microphone');
+        }
+        this.log(`Selected microphone: ${deviceId || 'default'}`);
+    }
+    getMicrophoneConstraints() {
+        const constraints = {
+            echoCancellation: true,
+            noiseSuppression: true,
+            autoGainControl: true,
+            sampleRate: this.config.mobileOptimized ? 16000 : 44100,
+            channelCount: 1
+        };
+        // Use optional chaining
+        if (this.selectedMicrophoneId) {
+            constraints.deviceId = { exact: this.selectedMicrophoneId };
+        }
+        return constraints;
+    }
+    async requestMicrophonePermission() {
+        try {
+            const constraints = {
+                audio: this.getMicrophoneConstraints()
+            };
+            this.mediaStream = await navigator.mediaDevices.getUserMedia(constraints);
+            this.log('Microphone permission granted');
+        }
+        catch (error) {
+            if (error.name === 'NotAllowedError') {
+                throw new Error('Microphone permission denied');
+            }
+            else if (error.name === 'NotFoundError') {
+                throw new Error('No microphone found');
+            }
+            else if (error.name === 'OverconstrainedError') {
+                // Retry with default device if selected device fails
+                if (this.selectedMicrophoneId) {
+                    this.log('Selected microphone failed, trying default...');
+                    this.setSelectedMicrophone('');
+                    return this.requestMicrophonePermission();
+                }
+                throw new Error('Microphone constraints not supported');
+            }
+            else {
+                throw new Error(`Microphone access failed: ${error.message}`);
+            }
+        }
+    }
+    async initializeAudioContext() {
+        try {
+            this.audioContext = new (window.AudioContext || window.webkitAudioContext)();
+            if (this.audioContext.state === 'suspended') {
+                await this.audioContext.resume();
+            }
+            this.log('Audio context initialized');
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize audio context: ${error.message}`);
+        }
+    }
+    async initializeTensorFlow() {
+        try {
+            this.log('Initializing TensorFlow.js wake word detection...');
+            const tfConfig = this.config.tensorFlowConfig ?? TENSORFLOW_WAKE_WORD_CONFIGS.GO_WAKE_WORD;
+            const tfEvents = {
+                onWakeWordDetected: (word, confidence) => {
+                    this.log(`🎯 TensorFlow wake word detected: "${word}" (${confidence.toFixed(3)})`);
+                    this.events.wakeWordDetected?.();
+                },
+                onListeningStarted: () => {
+                    this.log('TensorFlow wake word listening started');
+                },
+                onListeningStopped: () => {
+                    this.log('TensorFlow wake word listening stopped');
+                },
+                onError: (error) => {
+                    this.log(`TensorFlow error: ${error.message}`);
+                    this.events.error?.(error.message);
+                },
+                onLog: (message) => {
+                    this.events.onLog?.(message);
+                }
+            };
+            this.tensorflowModel = new TensorFlowWakeWord(tfConfig, tfEvents);
+            await this.tensorflowModel.initialize();
+            await this.tensorflowModel.startListening();
+            this.log('TensorFlow wake word detection active');
+        }
+        catch (error) {
+            this.log(`TensorFlow initialization failed: ${error.message ?? error}`);
+            this.log(`TensorFlow error type: ${error.constructor.name}`);
+            this.events.error?.(error);
+        }
+    }
+    handleSpeechResult(event) {
+        console.log('[VoiceController] handleSpeechResult called', event);
+        console.log(`[VoiceController] Current state: ${this.currentState}`);
+        if (!event.results || event.results.length === 0) {
+            console.log('[VoiceController] No results in event');
+            this.log('Speech result received but no results available');
+            return;
+        }
+        const result = event.results[event.results.length - 1];
+        console.log('[VoiceController] Result:', result);
+        if (!result || result.length === 0) {
+            console.log('[VoiceController] No alternatives in result');
+            this.log('Speech result received but no alternatives available');
+            return;
+        }
+        // Web Speech API structure: result[0] contains the transcript and confidence
+        const transcript = result[0].transcript?.trim().toLowerCase() || '';
+        const confidence = result[0].confidence ?? 1.0; // Default to 1.0 if not provided
+        console.log(`[VoiceController] Transcript: "${transcript}", Confidence: ${confidence}`);
+        console.log(`[VoiceController] Is final: ${result.isFinal}`);
+        if (transcript) {
+            this.log(`Speech result: "${transcript}" (confidence: ${confidence.toFixed(2)}, final: ${result.isFinal})`);
+        }
+        // For command listening, wait longer before considering a result "final" to allow compound phrases
+        if (this.currentState === 'command-listening') {
+            // Only process truly final results during command listening to avoid cutting off compound phrases
+            if (!result.isFinal) {
+                return; // Wait for the final result
+            }
+        }
+        if (result.isFinal && confidence >= this.config.confidenceThreshold) {
+            console.log(`[VoiceController] Processing final result, currentState: ${this.currentState}`);
+            // Native wake phrase detection (desktop mode)
+            if (!this.config.tabletMode) {
+                // If we're already in command-listening mode, treat everything as a command
+                if (this.currentState === 'command-listening') {
+                    // Check if this is the same wake phrase we just detected (ignore it)
+                    if (transcript === this.lastWakePhrase && Date.now() < this.wakePhraseTimeout) {
+                        console.log(`[VoiceController] Ignoring repeated wake phrase in command mode: "${transcript}"`);
+                        return;
+                    }
+                    console.log(`[VoiceController] In command-listening mode, sending as command: "${transcript}"`);
+                    this.events.commandReceived?.(transcript, confidence);
+                    return;
+                }
+                // Otherwise check for wake phrases
+                if (this.isNativeWakePhrase(transcript)) {
+                    console.log(`[VoiceController] Native wake phrase detected: "${transcript}"`);
+                    // Check if it's just a wake phrase or includes command
+                    const hasCommand = /\b(go|hey)\s*(?:timer|time)s?\s+(?:\d|\w+)/i.test(transcript);
+                    if (hasCommand) {
+                        console.log('[VoiceController] Complete command detected, sending to commandReceived');
+                        // Complete command in one phrase
+                        this.events.commandReceived?.(transcript, confidence);
+                    }
+                    else {
+                        console.log('[VoiceController] Just wake phrase detected, triggering wakeWordDetected');
+                        // Store the wake phrase and set timeout to ignore it if it comes through again
+                        this.lastWakePhrase = transcript;
+                        this.wakePhraseTimeout = Date.now() + 2000; // Ignore for 2 seconds
+                        // Just wake phrase, trigger wake word detection
+                        this.events.wakeWordDetected?.();
+                    }
+                    return;
+                }
+            }
+            else {
+                // Traditional two-stage mode (tablet mode)
+                // If we're in command-listening mode, send the transcript as a command
+                if (this.currentState === 'command-listening') {
+                    console.log(`[VoiceController] Sending command: "${transcript}"`);
+                    this.events.commandReceived?.(transcript, confidence);
+                }
+                else {
+                    // Check for wake words only if not in command-listening mode
+                    const containsWakeWord = this.config.wakeWords.some(word => transcript.includes(word.toLowerCase()));
+                    if (containsWakeWord) {
+                        this.events.wakeWordDetected?.();
+                        const command = this.extractCommand(transcript);
+                        if (command) {
+                            this.events.commandReceived?.(command, confidence);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    destroy() {
+        this.stopListening();
+        this.mediaStream?.getTracks().forEach(track => track.stop());
+        this.mediaStream = null;
+        if (this.audioContext?.state !== 'closed') {
+            this.audioContext?.close();
+            this.audioContext = null;
+        }
+        this.speechRecognition = null;
+        this.tensorflowModel = null;
+        this.isInitialized = false;
+        this.log('Voice controller destroyed');
+    }
+    getWakeWordLabel() {
+        return this.config.wakeWords?.[0] ?? 'Computer';
+    }
+    isWebSpeechListening() {
+        return this.isListening && this.speechRecognition !== null;
+    }
+    // Add missing methods that clock.ts expects
+    getSelectedMicrophoneId() {
+        return this.selectedMicrophoneId ?? '';
+    }
+    hasActiveWakeWordDetection() {
+        return this.isListening && this.currentState === 'wake-listening';
+    }
+    startCommandListening() {
+        console.log('[VoiceController] startCommandListening called');
+        console.log('[VoiceController] Previous state:', this.currentState);
+        console.log('[VoiceController] isListening:', this.isListening);
+        console.log('[VoiceController] speechRecognition exists:', !!this.speechRecognition);
+        this.currentState = 'command-listening';
+        console.log('[VoiceController] Switched to command-listening mode');
+        if (!this.isListening && this.speechRecognition) {
+            // Speech recognition not running - start it
+            try {
+                this.isListening = true;
+                this.speechRecognition.start();
+                this.log('Started listening for commands');
+                console.log('[VoiceController] Speech recognition started for commands');
+            }
+            catch (error) {
+                this.log(`Failed to start command listening: ${error.message}`);
+                console.error('[VoiceController] Failed to start speech recognition:', error);
+            }
+        }
+        else if (this.isListening) {
+            // Speech recognition already running from wake word detection
+            // Just fire the listeningStarted event since we're now in command mode
+            this.log('Speech recognition already running, switching to command mode');
+            console.log('[VoiceController] Speech recognition already active, firing listeningStarted event');
+            this.events.listeningStarted?.();
+        }
+        else {
+            console.log('[VoiceController] No speech recognition available');
+        }
+    }
+    shutdown() {
+        this.destroy();
+    }
+    async logAvailableMicrophones() {
+        const microphones = await this.getAvailableMicrophones();
+        this.log('Available microphones:');
+        microphones.forEach((mic, index) => {
+            const selected = mic.deviceId === this.selectedMicrophoneId ? ' (SELECTED)' : '';
+            this.log(`  ${index + 1}. ${mic.label}${selected}`);
+        });
+    }
+    // Add missing Web Speech initialization and handlers
+    initializeWebSpeech() {
+        if (!('webkitSpeechRecognition' in window) && !('SpeechRecognition' in window)) {
+            this.log('Web Speech API not supported');
+            return;
+        }
+        const SpeechRecognition = window.SpeechRecognition ?? window.webkitSpeechRecognition;
+        this.speechRecognition = new SpeechRecognition();
+        // Configure for native wake phrases (no TensorFlow needed)
+        if (!this.config.tabletMode) {
+            this.speechRecognition.continuous = true; // Always listening for wake phrases
+            this.speechRecognition.interimResults = true; // Enable interim results for better responsiveness
+            this.speechRecognition.maxAlternatives = 3; // More alternatives for better matching
+            this.speechRecognition.lang = 'en-US';
+            this.log('Configured for native wake phrase detection');
+        }
+        else {
+            // Traditional two-stage mode for tablets
+            this.speechRecognition.continuous = false;
+            this.speechRecognition.interimResults = true;
+            this.speechRecognition.maxAlternatives = 1;
+            this.speechRecognition.lang = 'en-US';
+            this.log('Configured for two-stage recognition');
+        }
+        this.speechRecognition.onstart = () => {
+            this.log(`Speech recognition started - currentState: ${this.currentState}`);
+            // Only fire listeningStarted event when in command-listening mode
+            // Don't fire it when just waiting for wake words
+            if (this.currentState === 'command-listening') {
+                this.log('Firing listeningStarted event');
+                this.events.listeningStarted?.();
+            }
+            else {
+                this.log('Not firing listeningStarted - state is not command-listening');
+            }
+        };
+        this.speechRecognition.onresult = (event) => {
+            this.handleSpeechResult(event);
+        };
+        this.speechRecognition.onerror = (event) => {
+            this.handleSpeechError(event);
+        };
+        this.speechRecognition.onend = () => {
+            const willAutoRestart = this.currentState === 'wake-listening' && !this.isMicrophoneDead;
+            if (willAutoRestart) {
+                // Don't fire listeningEnded or log for natural restarts - this is normal behavior
+                this.isListening = false;
+                // Apply backoff delay if we have consecutive errors
+                const restartDelay = this.backoffDelay > 0 ? this.backoffDelay : 100;
+                setTimeout(() => {
+                    if (!this.isListening && this.currentState === 'wake-listening' && !this.isMicrophoneDead) {
+                        this.startListening();
+                    }
+                }, restartDelay);
+            }
+            else {
+                // Only fire listeningEnded when actually stopping (not auto-restarting)
+                this.log(`Speech recognition ended - currentState: ${this.currentState}, micDead: ${this.isMicrophoneDead}`);
+                this.events.listeningEnded?.();
+                this.isListening = false;
+            }
+        };
+        this.log('Web Speech API initialized');
+    }
+    extractCommand(transcript) {
+        let command = transcript;
+        this.config.wakeWords.forEach(wakeWord => {
+            const regex = new RegExp(wakeWord.toLowerCase(), 'gi');
+            command = command.replace(regex, '').trim();
+        });
+        return command;
+    }
+    handleSpeechError(event) {
+        const error = event.error;
+        // Track consecutive errors for backoff
+        if (error === this.lastErrorType) {
+            this.consecutiveErrors++;
+        }
+        else {
+            this.consecutiveErrors = 1;
+            this.lastErrorType = error;
+        }
+        // Log error with consecutive count
+        this.log(`Speech recognition error: ${error} (consecutive: ${this.consecutiveErrors})`);
+        // Check for microphone death - "aborted" errors in rapid succession
+        if (error === 'aborted' && this.consecutiveErrors >= this.maxConsecutiveErrors) {
+            this.isMicrophoneDead = true;
+            this.isListening = false;
+            this.events.error?.('Microphone unavailable - too many consecutive errors. Please check system permissions.');
+            this.log('MICROPHONE DEAD: Stopping restart attempts');
+            return;
+        }
+        // Calculate exponential backoff delay
+        if (this.consecutiveErrors > 1) {
+            this.backoffDelay = Math.min(1000 * Math.pow(2, this.consecutiveErrors - 1), 30000); // Max 30 seconds
+            this.log(`Applying backoff delay: ${this.backoffDelay}ms`);
+        }
+        else {
+            this.backoffDelay = 0;
+        }
+        if (error === 'no-speech') {
+            this.log('No speech detected');
+            this.consecutiveErrors = 0; // Reset on benign errors
+        }
+        else if (error === 'network') {
+            this.events.error?.('Network error during speech recognition');
+        }
+        else if (error === 'not-allowed') {
+            this.isMicrophoneDead = true;
+            this.isListening = false;
+            this.events.error?.('Microphone permission denied');
+        }
+        else {
+            this.events.error?.(`Speech recognition error: ${error}`);
+        }
+    }
+    async startListening() {
+        if (!this.isInitialized) {
+            throw new Error('Voice controller not initialized');
+        }
+        // Don't restart if microphone is dead
+        if (this.isMicrophoneDead) {
+            this.log('Microphone is dead - not attempting to restart');
+            return;
+        }
+        if (this.isListening) {
+            this.log('Already listening');
+            return;
+        }
+        try {
+            this.isListening = true;
+            this.currentState = 'wake-listening';
+            this.speechRecognition?.start();
+            // Reset error tracking on successful start
+            this.consecutiveErrors = 0;
+            this.lastErrorType = '';
+            this.backoffDelay = 0;
+            this.log('Started listening for wake words');
+            this.events.statusChanged?.('Listening for wake words...');
+        }
+        catch (error) {
+            this.isListening = false;
+            this.log(`Failed to start listening: ${error.message}`);
+            this.events.error?.(`Failed to start listening: ${error.message}`);
+            throw error;
+        }
+    }
+    stopListening() {
+        if (!this.isListening) {
+            return;
+        }
+        this.isListening = false;
+        this.currentState = 'idle';
+        this.speechRecognition?.stop();
+        this.log('Stopped listening');
+        this.events.statusChanged?.('Stopped listening');
+    }
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        this.log('Configuration updated');
+    }
+    getState() {
+        return this.currentState;
+    }
+    isActive() {
+        return this.isListening;
+    }
+    log(message) {
+        const logMessage = typeof message === 'string' ? message : message.message;
+        if (this.config.debugMode) {
+            console.log(`[VoiceController] ${logMessage}`);
+        }
+        this.events.onLog?.(logMessage);
+    }
+    checkBrowserCompatibility() {
+        try {
+            // Check for WebAssembly support
+            if (typeof WebAssembly === 'undefined') {
+                this.log('WebAssembly not supported');
+                return false;
+            }
+            // Check for Web Workers support
+            if (typeof Worker === 'undefined') {
+                this.log('Web Workers not supported');
+                return false;
+            }
+            // Check for Promises support
+            if (typeof Promise === 'undefined') {
+                this.log('Promises not supported');
+                return false;
+            }
+            // Check for Web Audio API
+            if (typeof window !== 'undefined' && !window.AudioContext && !window.webkitAudioContext) {
+                this.log('Web Audio API not supported');
+                return false;
+            }
+            // Check for navigator and getUserMedia
+            if (typeof navigator === 'undefined' || !navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+                this.log('MediaDevices API not supported');
+                return false;
+            }
+            this.log('Browser compatibility check passed');
+            return true;
+        }
+        catch (error) {
+            this.log(`Compatibility check failed: ${error.message}`);
+            return false;
+        }
+    }
+}
+// Default configurations for easy setup
+export const DEFAULT_VOICE_CONFIG = {
+    accessKey: "uurGHRfD6i555eNVTcSIAi6ciiYgq9EiELQMzgCckAA0XU3DiE3aww==",
+    wakeWords: ['Computer'],
+    timeoutMs: 15000,
+    useWebSpeech: true,
+    useTensorFlow: false, // Disabled by default - use native approach
+    enableAIFallback: false,
+    aiService: 'openai',
+    confidenceThreshold: 0.0,
+    mobileOptimized: true,
+    tabletMode: false, // Auto-detected in constructor
+    debugMode: true
+};
+// Alternative configurations for experimentation
+export const VOICE_CONFIGS = {
+    TENSORFLOW_ONLY: {
+        ...DEFAULT_VOICE_CONFIG,
+        useTensorFlow: true,
+        useWebSpeech: true,
+        wakeWords: ['go'],
+        tensorFlowConfig: TENSORFLOW_WAKE_WORD_CONFIGS.GO_OPTIMIZED
+    },
+    // Tablet-optimized configuration for better mobile device performance
+    TENSORFLOW_TABLET: {
+        ...DEFAULT_VOICE_CONFIG,
+        useTensorFlow: true,
+        useWebSpeech: true,
+        wakeWords: ['go'],
+        timeoutMs: 20000, // Longer timeout for tablets (20 seconds vs default 15)
+        tensorFlowConfig: TENSORFLOW_WAKE_WORD_CONFIGS.TABLET_OPTIMIZED
+    },
+    TENSORFLOW_GO_STOP: {
+        ...DEFAULT_VOICE_CONFIG,
+        useTensorFlow: true,
+        useWebSpeech: true,
+        wakeWords: ['go', 'stop'],
+        tensorFlowConfig: TENSORFLOW_WAKE_WORD_CONFIGS.GO_STOP_WAKE_WORDS
+    },
+    WEB_SPEECH_ONLY: {
+        ...DEFAULT_VOICE_CONFIG,
+        wakeWords: ['timer'], // Will match "hey timer" or "go timer"
+        useTensorFlow: false
+    },
+    TENSORFLOW_NUMBERS: {
+        ...DEFAULT_VOICE_CONFIG,
+        useTensorFlow: true,
+        useWebSpeech: true,
+        wakeWords: ['three', 'five'],
+        tensorFlowConfig: TENSORFLOW_WAKE_WORD_CONFIGS.NUMBER_WAKE_WORDS
+    }
+};
+//# sourceMappingURL=voice-controller.js.map