@prabhjeet.me/wakeywakey 1.0.0

package/fesm2022/prabhjeet.me-wakeywakey.mjs

@@ -0,0 +1,1411 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, PLATFORM_ID, HostListener, ViewChild, Component, EventEmitter, Output, provideAppInitializer } from '@angular/core';
+import { Subject, withLatestFrom, concatMap, filter, map, distinctUntilChanged, switchMap, EMPTY, tap, ignoreElements, timer, merge, take, throttleTime, share, delay, takeUntil, scan } from 'rxjs';
+import { SubSink } from 'subsink';
+import * as THREE from 'three';
+import { Tensor, env, InferenceSession } from 'onnxruntime-web';
+import { loadRnnoise, RnnoiseWorkletNode } from '@sapphi-red/web-noise-suppressor';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
+
+/**
+ * Audio sample rate
+ */
+const SAMPLE_RATE = 16000;
+/**
+ * Audio worklet name
+ */
+const MICROPHONE_PROCESSOR_NAME = 'microphone-buffer-processor';
+/**
+ * Audio worklet processor
+ */
+const MICROPHONE_PROCESSOR = `
+  class MicrophoneBufferProcessor extends AudioWorkletProcessor {
+    // collect 1280 samples before sending them to the main thread
+    // Web Audio processes 128 frames per call
+    // batching 10 small chunks into 1 bigger chunk
+    frameBlockSize = 128 * 10; // total samples per emitted chunk
+
+    // for storing small chunks
+    accumulatedSamples = new Float32Array(this.frameBlockSize);
+
+    // cursor
+    writeIndex = 0;
+
+    constructor() {
+      super();
+    }
+
+    dbNormalized(db) {
+      const minDb = -60;
+      const maxDb = 0;
+
+      const clamped = Math.max(minDb, Math.min(db, maxDb));
+      return (clamped - minDb) / (maxDb - minDb);
+    }
+
+    // runs every 128 frames. ~ every 2.67 ms (at 48kHz), ~ 8ms (at 16KHz)
+    process(inputList) {
+      const firstInput = inputList[0];
+
+      // no input connected
+      if (!firstInput || firstInput.length === 0) {
+        return true;
+      }
+
+      // raw waveform values
+      const firstChannelSamples = firstInput[0]; // Float32Array(128)
+
+      let sum = 0;
+
+      // 0 -> 128
+      for (let i = 0; i < firstChannelSamples.length; i++) {
+        // dump each sample in accumulated sample array
+        this.accumulatedSamples[this.writeIndex++] = firstChannelSamples[i];
+        sum += firstChannelSamples[i] * firstChannelSamples[i];
+      }
+
+      // once buffer is full, break
+      if (this.writeIndex === this.frameBlockSize) {
+        const rms = Math.sqrt(sum / firstChannelSamples.length);
+        const db = 20 * Math.log10(rms ?? 0.00001);
+        this.writeIndex = 0;
+
+        // send to main thread
+        this.port.postMessage({
+          sample: this.accumulatedSamples.slice(),
+          rms,
+          db,
+          dbNormalized: this.dbNormalized(db),
+        });
+      }
+
+      return true;
+    }
+}
+
+registerProcessor("${MICROPHONE_PROCESSOR_NAME}", MicrophoneBufferProcessor);
+  `;
+
+/**
+ * Audio utility
+ */
+class AudioUtil {
+    /**
+     * Create wav blob url from audio chunk
+     *
+     * @param chunks Audio chunk
+     * @param sampleRate Sample rate
+     * @returns
+     */
+    static createWavBlob(chunks, sampleRate = SAMPLE_RATE) {
+        const totalLength = chunks.reduce((len, chunk) => len + chunk.length, 0);
+        if (!totalLength)
+            return null;
+        // Merge chunks
+        const combined = new Float32Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            combined.set(chunk, offset);
+            offset += chunk.length;
+        }
+        // Convert to 16-bit PCM
+        const pcmData = new Int16Array(totalLength);
+        for (let i = 0; i < totalLength; i++) {
+            const s = Math.max(-1, Math.min(1, combined[i]));
+            pcmData[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+        }
+        const wavHeader = new ArrayBuffer(44);
+        const view = new DataView(wavHeader);
+        const channels = 1;
+        const bitsPerSample = 16;
+        const byteRate = sampleRate * channels * (bitsPerSample / 8);
+        const blockAlign = channels * (bitsPerSample / 8);
+        const writeString = (offset, str) => {
+            for (let i = 0; i < str.length; i++) {
+                view.setUint8(offset + i, str.charCodeAt(i));
+            }
+        };
+        writeString(0, 'RIFF');
+        view.setUint32(4, 36 + pcmData.byteLength, true);
+        writeString(8, 'WAVE');
+        writeString(12, 'fmt ');
+        view.setUint32(16, 16, true);
+        view.setUint16(20, 1, true); // PCM
+        view.setUint16(22, channels, true);
+        view.setUint32(24, sampleRate, true);
+        view.setUint32(28, byteRate, true);
+        view.setUint16(32, blockAlign, true);
+        view.setUint16(34, bitsPerSample, true);
+        writeString(36, 'data');
+        view.setUint32(40, pcmData.byteLength, true);
+        const wavBlob = new Blob([wavHeader, pcmData], { type: 'audio/wav' });
+        return URL.createObjectURL(wavBlob);
+    }
+}
+
+/**
+ * Wakey wakey config token
+ */
+const CONFIG = new InjectionToken('WAKEYWAKEY_CONFIG');
+
+class ConfigService {
+    constructor() {
+        this._config = inject(CONFIG);
+    }
+    /**
+     * Audio config
+     */
+    get audio() {
+        return this._config.audio;
+    }
+    /**
+     * Onnx config
+     */
+    get onnx() {
+        return this._config.onnx;
+    }
+    /**
+     * Orb config
+     */
+    get orb() {
+        return this._config.orb;
+    }
+    /**
+     * Throttle time
+     */
+    get throttleTime() {
+        return this._config.throttleTime;
+    }
+    /**
+     * Mode
+     */
+    get mode() {
+        return this._config.mode;
+    }
+    /**
+     * Base path of assets
+     */
+    get basePath() {
+        return this._config.basePath || '/wakeywakey';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ConfigService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ConfigService, decorators: [{
+            type: Injectable
+        }] });
+
+class EventService {
+    constructor() {
+        /**
+         * Fires when library loaded
+         */
+        this.ready = new Subject();
+        /**
+         * Fires when there is a message to log
+         */
+        this.log = new Subject();
+        /**
+         * Fires when there is an error
+         */
+        this.exception = new Subject();
+        /**
+         * Fires when speech is detected
+         */
+        this.speech = new Subject();
+        /**
+         * Fires when wake word is detected
+         */
+        this.wakeword = new Subject();
+        /**
+         * Fires when recording starts (after wake word detection)
+         */
+        this.recording = new Subject();
+        /**
+         * Fires silence is detected
+         */
+        this.silence = new Subject();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: EventService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: EventService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: EventService, decorators: [{
+            type: Injectable
+        }] });
+
+const DEFAULT_INFERENCE_SCORE = 0.5;
+
+const VAD_HANGOVER_FRAMES = 12;
+
+class ModelService {
+    constructor() {
+        /**
+         * Inference session
+         */
+        this._inferenceSession = {
+            melspectrogram: undefined,
+            embedding_model: undefined,
+            silero_vad: undefined,
+            wakeword: undefined,
+        };
+    }
+    /**
+     * Get melspectrogram inference session
+     */
+    get melSpectrogram() {
+        return this._inferenceSession['melspectrogram'];
+    }
+    /**
+     * Get embedding inference session
+     */
+    get embedding() {
+        return this._inferenceSession['embedding_model'];
+    }
+    /**
+     * Get Silero VAD inference session
+     */
+    get sileroVAD() {
+        return this._inferenceSession['silero_vad'];
+    }
+    /**
+     * Get wakeword inference session
+     */
+    get wakeword() {
+        return this._inferenceSession['wakeword'];
+    }
+    /**
+     * Set session instance
+     */
+    set session(sessions) {
+        this._inferenceSession = sessions;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ModelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ModelService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: ModelService, decorators: [{
+            type: Injectable
+        }] });
+
+class PipelineService {
+    constructor() {
+        /**
+         * Dependencies
+         */
+        this._model = inject(ModelService);
+        // Configuration Constants
+        this.MEL_WINDOW_SIZE = 76; // Number of mel frames needed for one embedding
+        this.MEL_HOP_SIZE = 8; // How many frames to skip (the slide) after inference
+        this.EMBEDDING_COUNT = 16; // Number of embeddings kept in memory (temporal context)
+        this.FEATURE_DIM = 96; // Size of each embedding vector
+        this.MEL_BINS = 32; // Number of frequency bins per mel frame
+        /**
+         * Historical buffer of embeddings representing the last ~1-2 seconds of audio context.
+         * Initialized with empty (zero) vectors.
+         */
+        this._embeddingQueue = Array.from({ length: this.EMBEDDING_COUNT }, () => new Float32Array(this.FEATURE_DIM).fill(0));
+        /**
+         * Buffer of calculated Mel Spectrogram frames waiting to be processed.
+         */
+        this._melFrameQueue = [];
+    }
+    /**
+     * Main entry point: Processes a new chunk of audio and returns a detection score.
+     */
+    async run(speech) {
+        // 1. Convert raw PCM audio into Mel Spectrogram frames and add to queue
+        await this._generateMelSpectrogram(speech.sample);
+        let latestScore = 0;
+        // 2. Process the queue using a sliding window approach
+        // While we have enough frames to form a full input window (76 frames)...
+        while (this._melFrameQueue.length >= this.MEL_WINDOW_SIZE) {
+            // Extract a single feature vector (embedding) from the current window
+            const combinedEmbeddings = await this._processWindowToEmbeddings();
+            // Classify the sequence of embeddings to see if the wake-word is present
+            latestScore = await this._getWakeWordScore(combinedEmbeddings);
+            // Slide the window: Remove the oldest 8 frames to make room for new audio
+            this._melFrameQueue.splice(0, this.MEL_HOP_SIZE);
+        }
+        return latestScore;
+    }
+    /**
+     * STAGE 1: Converts raw audio samples into Mel Frequency bins.
+     */
+    async _generateMelSpectrogram(samples) {
+        const session = this._model.melSpectrogram;
+        // Wrap raw audio in an ONNX Tensor [Batch: 1, Samples: N]
+        const inputTensor = new Tensor('float32', samples, [1, samples.length]);
+        // Run the Mel-Spectrogram model
+        const output = await session.run({ [session.inputNames[0]]: inputTensor });
+        const rawMelData = output[session.outputNames[0]].data;
+        /**
+         * Post-processing & Normalization:
+         * The model output is scaled to fit the expected input range of the embedding model.
+         * Logic: (value / 10) + 2.0
+         */
+        const normalizedMel = rawMelData.map((val) => val / 10.0 + 2.0);
+        // Slice the flat output array into individual frames of 32 bins and queue them
+        // Each inference usually produces 5 frames for the given 1280 audio samples
+        for (let i = 0; i < 5; i++) {
+            const start = i * this.MEL_BINS;
+            const end = start + this.MEL_BINS;
+            this._melFrameQueue.push(normalizedMel.subarray(start, end));
+        }
+    }
+    /**
+     * STAGE 2: Extracts features (embeddings) from a window of Mel frames.
+     */
+    async _processWindowToEmbeddings() {
+        const session = this._model.embedding;
+        // Take the first 76 frames from our queue
+        const windowFrames = this._melFrameQueue.slice(0, this.MEL_WINDOW_SIZE);
+        // Flatten the frames into a single continuous array for the Tensor
+        const flattenedInput = new Float32Array(this.MEL_WINDOW_SIZE * this.MEL_BINS);
+        windowFrames.forEach((frame, i) => {
+            flattenedInput.set(frame, i * this.MEL_BINS);
+        });
+        // Run the Embedding model [1, 76, 32, 1]
+        const inputTensor = new Tensor('float32', flattenedInput, [1, 76, 32, 1]);
+        const output = await session.run({ [session.inputNames[0]]: inputTensor });
+        const newEmbedding = output[session.outputNames[0]].data;
+        // Update the rolling embedding queue (First-In, First-Out)
+        this._embeddingQueue.shift();
+        this._embeddingQueue.push(new Float32Array(newEmbedding));
+        // Flatten the last 16 embeddings into one large vector for the final classifier
+        const combinedBuffer = new Float32Array(this.EMBEDDING_COUNT * this.FEATURE_DIM);
+        this._embeddingQueue.forEach((emb, i) => {
+            combinedBuffer.set(emb, i * this.FEATURE_DIM);
+        });
+        return combinedBuffer;
+    }
+    /**
+     * STAGE 3: Final classification score based on temporal embedding sequence.
+     */
+    async _getWakeWordScore(embeddings) {
+        const session = this._model.wakeword;
+        // Shape: [Batch: 1, Sequence: 16, Features: 96]
+        const inputTensor = new Tensor('float32', embeddings, [
+            1,
+            this.EMBEDDING_COUNT,
+            this.FEATURE_DIM,
+        ]);
+        const results = await session.run({ [session.inputNames[0]]: inputTensor });
+        // Extract the scalar probability score from the output tensor
+        return results[session.outputNames[0]].data[0];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: PipelineService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: PipelineService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: PipelineService, decorators: [{
+            type: Injectable
+        }] });
+
+const DEFAULT_SILENCE_DURATION = 1000;
+
+class MicrophoneService {
+    constructor() {
+        /**
+         * Dependencies
+         */
+        this._event = inject(EventService);
+        this._config = inject(ConfigService);
+        /**
+         * Audio data subject
+         */
+        this._data = new Subject();
+        /**
+         * List of available microphones
+         */
+        this._microphones = [];
+        // Init mic
+        this._init();
+    }
+    /**
+     * List of available microphones
+     */
+    get microphones() {
+        return this._microphones;
+    }
+    /**
+     * Microphone data
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * Set input source
+     */
+    set source(deviceId) {
+        this._init(deviceId);
+    }
+    ngOnDestroy() {
+        // close audio context
+        this._audioContext?.close();
+    }
+    /**
+     * Initialize
+     *
+     * @param deviceId Input device id (from microphone list)
+     */
+    async _init(deviceId) {
+        try {
+            // cleanup
+            this.ngOnDestroy();
+            // request permission
+            this._stream = await navigator.mediaDevices.getUserMedia({
+                audio: !deviceId
+                    ? {
+                        noiseSuppression: false,
+                        echoCancellation: false,
+                    }
+                    : { deviceId: { exact: deviceId } },
+            });
+            this._event.log.next(`${MicrophoneService.name}: Microphone permission granted (deviceid: '${deviceId ?? 'default'}')!`);
+            // save list of microphones
+            this._microphones = await this._microphoneList();
+            // monitor audio
+            this._monitor();
+            return true;
+        }
+        catch (error) {
+            this._event.exception.next(error);
+        }
+        return false;
+    }
+    /**
+     * Monitor audio
+     *
+     * @returns chunk subject
+     */
+    async _monitor() {
+        const worklet = await this._workletNode();
+        // on message
+        worklet.port.onmessage = async (event) => {
+            const data = event.data ?? null;
+            if (!data)
+                return;
+            // emit chunk
+            this._data.next(data);
+        };
+        return this._data;
+    }
+    /**
+     * Save microphones
+     */
+    async _microphoneList() {
+        const devices = await navigator.mediaDevices.enumerateDevices();
+        return devices.filter((device) => device.kind === 'audioinput');
+    }
+    /**
+     * Prepare worklet node
+     */
+    async _workletNode() {
+        // Create audio context
+        this._audioContext = new AudioContext({ sampleRate: SAMPLE_RATE });
+        if (this._config.audio.noiseSuppression) {
+            await this._audioContext.audioWorklet.addModule(this._config.audio.noiseSuppression.worklet ??
+                `${this._config.basePath}/worklets/workletProcessor.js`);
+        }
+        // Load custom worklet
+        const blob = new Blob([MICROPHONE_PROCESSOR], { type: 'application/javascript' });
+        const workletURL = URL.createObjectURL(blob);
+        await this._audioContext.audioWorklet.addModule(workletURL);
+        URL.revokeObjectURL(workletURL);
+        // Create Nodes
+        const source = this._audioContext.createMediaStreamSource(this._stream);
+        // Gain Node
+        const gainNode = this._audioContext.createGain();
+        gainNode.gain.value = this._config.audio.gain;
+        if (this._config.audio.noiseSuppression) {
+            // Load RNNoise dependencies
+            const rnnoiseWasmBinary = await loadRnnoise({
+                url: this._config.audio.noiseSuppression.rnnoise ??
+                    `${this._config.basePath}/wasm/rnnoise.wasm`,
+                simdUrl: this._config.audio.noiseSuppression.rnnoise_simd ??
+                    `${this._config.basePath}/wasm/rnnoise_simd.wasm`,
+            });
+            // RNNoise Node
+            const rnnoiseNode = new RnnoiseWorkletNode(this._audioContext, {
+                wasmBinary: rnnoiseWasmBinary,
+                maxChannels: 1, // Standard for mono microphone input
+            });
+            source.connect(rnnoiseNode);
+            rnnoiseNode.connect(gainNode);
+        }
+        else {
+            source.connect(gainNode);
+        }
+        // Custom Worklet Node
+        const workletNode = new AudioWorkletNode(this._audioContext, MICROPHONE_PROCESSOR_NAME);
+        // Connect the Graph: Source -> RNNoise (if noise suppression) -> Gain -> Custom Worklet
+        gainNode.connect(workletNode);
+        return workletNode;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: MicrophoneService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: MicrophoneService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: MicrophoneService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class PlatformService {
+    constructor() {
+        this._platform = inject(PLATFORM_ID);
+    }
+    /**
+     * Is browser
+     */
+    get isBrowser() {
+        return isPlatformBrowser(this._platform);
+    }
+    /**
+     * Is server
+     */
+    get isServer() {
+        return isPlatformServer(this._platform);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: PlatformService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: PlatformService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: PlatformService, decorators: [{
+            type: Injectable
+        }] });
+
+class SpeakerService {
+    constructor() {
+        /**
+         * Dependencies
+         */
+        this._config = inject(ConfigService);
+        this._platform = inject(PlatformService);
+        this._event = inject(EventService);
+        this._subs = new SubSink();
+        if (this._config.audio.sound?.enable === false)
+            return;
+        // Audio is only available in browser context
+        if (this._platform.isBrowser) {
+            this._upSound = new Audio(this._config.audio.sound?.up ?? `${this._config.basePath}/sounds/up.mp3`);
+            this._downSound = new Audio(this._config.audio.sound?.down ?? `${this._config.basePath}/sounds/down.mp3`);
+            this._upSound.preload = this._downSound.preload = 'auto';
+            this._loadSubscriptions();
+        }
+    }
+    ngOnDestroy() {
+        this._subs.unsubscribe();
+    }
+    /**
+     * Play on sound
+     */
+    playUp() {
+        if (this._config.audio.sound?.enable === false)
+            return;
+        this._upSound.play();
+    }
+    /**
+     * Play off sound
+     */
+    playDown() {
+        if (this._config.audio.sound?.enable === false)
+            return;
+        this._downSound.play();
+    }
+    /**
+     * Load subscriptions
+     */
+    _loadSubscriptions() {
+        this._subs.sink = this._event.wakeword.subscribe(() => {
+            this.playUp();
+        });
+        // If default, on silence, play down
+        this._subs.sink = this._event.silence.subscribe((ev) => {
+            if (!ev.interimResponse)
+                this.playDown();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SpeakerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SpeakerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SpeakerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class SpeechRecognitionService {
+    constructor() {
+        /**
+         * Dependencies
+         */
+        this._event = inject(EventService);
+        this._platform = inject(PlatformService);
+        /**
+         * Transcript
+         */
+        this._transcript = '';
+    }
+    /**
+     * Get transcript
+     */
+    get transcript() {
+        return this._transcript;
+    }
+    ngOnDestroy() {
+        this.reset(); // clear transcript
+        if (this._platform.isBrowser)
+            this._recognition.stop();
+    }
+    /**
+     * Clear transcript
+     */
+    reset() {
+        this._transcript = '';
+    }
+    init() {
+        this._recognitionClass = window.SpeechRecognition || window.webkitSpeechRecognition;
+        if (!SpeechRecognition) {
+            this._event.exception.next(new Error('Speech recognition is not supported'));
+            return;
+        }
+        this._recognition = new this._recognitionClass(); // initialize
+        // 2. Configuration
+        this._recognition.lang = 'en-US'; // Set language
+        this._recognition.continuous = true; // Keep listening even if the user pauses
+        this._recognition.interimResults = true; // Show results while the user is still speaking
+        // 3. Handle Results
+        this._recognition.onresult = (event) => {
+            this._transcript = '';
+            for (let i = event.resultIndex; i < event.results.length; i++)
+                this._transcript += event.results[i][0].transcript;
+        };
+        this._recognition.start(); // start
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SpeechRecognitionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SpeechRecognitionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SpeechRecognitionService, decorators: [{
+            type: Injectable
+        }] });
+
+class VadService {
+    constructor() {
+        /**
+         * Dependencies
+         */
+        this._event = inject(EventService);
+        this._model = inject(ModelService);
+        /**
+         * VAD Shape
+         */
+        this._shape = [];
+        /**
+         * VAD LSTM hidden & cell state
+         */
+        this._state = null;
+    }
+    /**
+     * Get session
+     */
+    get _session() {
+        return this._model.sileroVAD;
+    }
+    /**
+     * Initialize
+     */
+    init() {
+        this._shape = this._getShape();
+        this._state = {
+            hidden: new Tensor('float32', new Float32Array(128).fill(0), this._shape),
+            cell: new Tensor('float32', new Float32Array(128).fill(0), this._shape),
+        };
+    }
+    /**
+     * Get VAD score
+     *
+     * @param chunk
+     * @returns
+     */
+    async score(sample) {
+        if (!this._state)
+            throw new Error(`${VadService.name}: Undefined LSTM state.`);
+        try {
+            const tensor = new Tensor('float32', sample, [1, sample.length]);
+            const sampleRate = new Tensor('int64', [BigInt(SAMPLE_RATE)], []);
+            // run inference
+            const response = await this._session.run({
+                input: tensor,
+                sr: sampleRate,
+                h: this._state.hidden,
+                c: this._state.cell,
+            });
+            // Update memory
+            this._state.hidden = response['hn'];
+            this._state.cell = response['cn'];
+            return response['output'].data[0];
+        }
+        catch (error) {
+            this._event.exception.next(error);
+            return 0;
+        }
+    }
+    /**
+     * Get shape of vad session
+     *
+     * Ex: [2, 1, 64]
+     */
+    _getShape() {
+        const { shape } = (this._session.inputMetadata.find((e) => e.name === 'h') ??
+            {});
+        const vadState = [];
+        if (shape) {
+            for (const sh of shape) {
+                if (typeof sh === 'string')
+                    vadState.push(1);
+                else
+                    vadState.push(sh);
+            }
+            return vadState;
+        }
+        throw new Error(`${VadService.name}: Unable to identify shape of the session.`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: VadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: VadService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: VadService, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * DefaulT VAD threshold
+ */
+const DEFAULT_VAD_THRESHOLD = 0.5;
+
+class AudioService {
+    constructor() {
+        /**
+         * Dependencies
+         */
+        this.__speaker = inject(SpeakerService); // Initialize
+        this._config = inject(ConfigService);
+        this._event = inject(EventService);
+        this._mic = inject(MicrophoneService);
+        this._vad = inject(VadService);
+        this._pipeline = inject(PipelineService);
+        this._speechRecognition = inject(SpeechRecognitionService);
+        this._subs = new SubSink();
+        this._endCurrentRecording = false;
+        /**
+         * Recording state
+         */
+        this._isRecording = false;
+        /**
+         * Is process is initialized (detected wakeword)
+         */
+        this._isInitialized = false;
+    }
+    get isRecording() {
+        return this._isRecording;
+    }
+    ngOnDestroy() {
+        this._subs.unsubscribe();
+    }
+    /**
+     * Initialize audio
+     */
+    async init() {
+        const data = await this._mic.data;
+        // Init VAD
+        this._vad.init();
+        this._speechRecognition.init();
+        // Fire ready event
+        this._event.ready.next();
+        data.subscribe(async (data) => {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const that = this;
+            // Fire a speech event
+            this._event.speech.next({
+                ...data,
+                vadScore: await this._vad.score(data.sample),
+                get hasVoiceActivity() {
+                    return this.vadScore > (that._config.audio.vadThreshold ?? DEFAULT_VAD_THRESHOLD);
+                },
+            });
+        });
+        this._listenForWakeword();
+        this._captureCommandAfterWakeword();
+    }
+    /**
+     * Force start recording (without wakeword)
+     */
+    forceStartRecording() {
+        this._isInitialized = true;
+        this._endCurrentRecording = false;
+        // this._speechRecognition.reset(); // reset transcript
+        this._event.wakeword.next({
+            inferenceScore: 0,
+            chunk: [],
+            vadScore: 0,
+            hasVoiceActivity: false,
+            sample: new Float32Array(),
+            rms: 0,
+            db: 0,
+            dbNormalized: 0,
+        });
+    }
+    /**
+     * Force end recording
+     */
+    forceEndRecording() {
+        this._endCurrentRecording = true;
+        this._event.silence.next({
+            chunk: new Float32Array(),
+            transcript: '',
+            interimResponse: false, // final response
+        });
+    }
+    /**
+     * Toggle recording
+     */
+    toggleRecording() {
+        if (this._isInitialized) {
+            this._isInitialized = false;
+            this.forceEndRecording();
+        }
+        else
+            this.forceStartRecording();
+    }
+    /**
+     * Identifies the wakeword and emits the event
+     */
+    _listenForWakeword() {
+        const vad$ = this._getWakeWordStream();
+        this._subs.sink = this._event.speech
+            .pipe(withLatestFrom(vad$), concatMap(async ([speech, vadState]) => {
+            const score = await this._pipeline.run(speech);
+            return { speech, score, chunk: vadState.buffer };
+        }), filter(({ score }) => score > (this._config.onnx.wakewordInferenceThreshold ?? DEFAULT_INFERENCE_SCORE)))
+            .subscribe(({ speech, score, chunk }) => {
+            this._event.wakeword.next({ ...speech, inferenceScore: score, chunk });
+        });
+    }
+    /**
+     * New logic: Captures the full command audio after a wakeword
+     */
+    _captureCommandAfterWakeword() {
+        const SILENCE_DURATION = this._config.audio.silenceDuration ?? DEFAULT_SILENCE_DURATION;
+        const VAD_THRESHOLD = this._config.audio.vadThreshold ?? DEFAULT_VAD_THRESHOLD;
+        // --- TRIGGER 1: Wakeword ---
+        const wakewordTrigger$ = this._event.wakeword.pipe(filter(() => !this._isRecording), // Ignore wakeword if already recording
+        map(() => []));
+        // --- TRIGGER 2: Continuous VAD > THRESHOLD for 1 second ---
+        const continuousVadTrigger$ = this._event.speech.pipe(map((s) => s.vadScore > VAD_THRESHOLD), filter(() => !this._isRecording && this._isInitialized), // Ignore and prevent background buffering if already recording
+        distinctUntilChanged(), switchMap((isVoiceActive) => {
+            if (!isVoiceActive)
+                return EMPTY; // Cancel if voice stops
+            this._speechRecognition.reset();
+            const bufferedChunks = [];
+            // 1. Accumulate audio chunks silently
+            const buffer$ = this._event.speech.pipe(tap((s) => bufferedChunks.push(s.sample)), ignoreElements());
+            // 2. Timer that emits the accumulated chunks after 1 second
+            const timer$ = timer(300).pipe(map(() => bufferedChunks));
+            // Merge both. If the timer fires, take(1) stops the buffer$ stream.
+            // If isVoiceActive turns false before 1s, switchMap cancels both.
+            return merge(buffer$, timer$).pipe(take(1));
+        }));
+        // --- COMBINE TRIGGERS ---
+        const startRecordingTrigger$ = merge(wakewordTrigger$.pipe(tap(() => {
+            if (!this._isInitialized)
+                this._isInitialized = true; // initialized
+        })), continuousVadTrigger$).pipe(throttleTime(1000));
+        // --- MAIN RECORDING PIPELINE ---
+        this._subs.sink = startRecordingTrigger$
+            .pipe(tap(() => {
+            this._isRecording = true;
+            this._speechRecognition.reset();
+            this._event.recording.next(); // recording event
+        }), switchMap((bufferedChunks) => {
+            // Initialize our command chunks with anything captured during the 1s VAD wait
+            const commandChunks = [...bufferedChunks];
+            const speech$ = this._event.speech.pipe(tap((speech) => commandChunks.push(speech.sample)), share());
+            const silence$ = speech$.pipe(map((s) => s.vadScore < VAD_THRESHOLD), distinctUntilChanged());
+            // 1. Normal silence timeout logic
+            const normalSilenceTimeout$ = silence$.pipe(delay(500), switchMap((isSilent) => {
+                if (!isSilent) {
+                    return EMPTY; // if voice cancel the timer
+                }
+                // silence started, start timer
+                return timer(SILENCE_DURATION).pipe(takeUntil(silence$.pipe(filter((silent) => !silent))));
+            }));
+            // 2. Force complete logic checking the variable
+            const forceComplete$ = speech$.pipe(filter(() => this._endCurrentRecording));
+            // 3. Complete whenever the timer fires OR the flag is set to true
+            return merge(normalSilenceTimeout$, forceComplete$).pipe(take(1), map(() => this._flatten(commandChunks)));
+        }))
+            .subscribe({
+            next: (chunk) => {
+                const interimResponse = this._config.mode === 'DEFAULT' ? false : true;
+                this._event.silence.next({
+                    chunk,
+                    transcript: this._speechRecognition.transcript,
+                    interimResponse,
+                }); // emit silence event
+                // Default case
+                if (this._config.mode === 'DEFAULT') {
+                    this._isInitialized = false;
+                    this._endCurrentRecording = false; // reset flag after recording ends
+                }
+                this._isRecording = false;
+            },
+            error: (err) => {
+                this._event.exception.next(err);
+            },
+        });
+    }
+    /**
+     * Helper to flatten array of buffers into a single Float32Array
+     */
+    _flatten(chunks) {
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Float32Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    /**
+     * Wakeword stream
+     * @returns
+     */
+    _getWakeWordStream() {
+        return this._event.speech.pipe(scan((state, speech) => {
+            const { hasVoiceActivity, sample } = speech;
+            let { isActive, hangoverCounter, buffer } = state;
+            if (hasVoiceActivity) {
+                // If we were idle, start a fresh buffer
+                if (!isActive) {
+                    buffer = [];
+                    isActive = true;
+                }
+                // Reset silence tracker to 0 because we hear a voice
+                hangoverCounter = 0;
+            }
+            else if (isActive) {
+                // Increment silence tracker
+                hangoverCounter++;
+                // If we've reached the limit of allowed silent frames
+                if (hangoverCounter >= VAD_HANGOVER_FRAMES) {
+                    isActive = false;
+                }
+            }
+            // Add sample if we are in an active speech window
+            if (isActive) {
+                buffer = [...buffer, sample];
+            }
+            return { buffer, hangoverCounter, isActive };
+        }, { buffer: [], hangoverCounter: -1, isActive: false }), 
+        // Only share the state when it is actively collecting
+        share());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AudioService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AudioService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: AudioService, decorators: [{
+            type: Injectable
+        }] });
+
+class OrbComponent {
+    constructor() {
+        this._config = inject(ConfigService);
+        this._platform = inject(PlatformService);
+        this._audio = inject(AudioService);
+        this._event = inject(EventService);
+        this._subs = new SubSink();
+        this.originalVertices = null;
+        this.targetIntensity = 0;
+        this.currentIntensity = 0;
+        this.clock = new THREE.Timer();
+        this.elapsedTime = 0;
+        /**
+         * Should orb be reacting to speech
+         */
+        this._isActive = false;
+        /**
+         * Animate
+         */
+        this._animate = () => {
+            this.animationId = requestAnimationFrame(this._animate);
+            // 1. Get the time passed since the last frame (delta)
+            const delta = this.clock.getDelta();
+            // 2. Smoothly update currentIntensity
+            this.currentIntensity += (this.targetIntensity - this.currentIntensity) * 0.05;
+            // 3. Increment our own elapsedTime ticker.
+            // We multiply delta by intensity so the pulse speeds up when busy,
+            // but it won't "run away" as performance.now() grows.
+            const speedFactor = 1 + this.currentIntensity / 20;
+            this.elapsedTime += delta * speedFactor;
+            // 4. Rotation (Constant per frame, scaled by intensity)
+            this.orb.rotation.y += 0.005 + this.currentIntensity / 5000;
+            this.orb.rotation.z += 0.002;
+            // 5. Vertex Displacement
+            const positionAttribute = this.orb.geometry.getAttribute('position');
+            for (let i = 0; i < positionAttribute.count; i++) {
+                const ix = i * 3;
+                const iy = i * 3 + 1;
+                const iz = i * 3 + 2;
+                const x = this.originalVertices[ix];
+                const y = this.originalVertices[iy];
+                const z = this.originalVertices[iz];
+                // We use this.elapsedTime instead of performance.now()
+                // This creates a stable frequency regardless of how long the app has been open
+                const wave = Math.sin(x * 2 + this.elapsedTime) *
+                    Math.cos(y * 2 + this.elapsedTime) *
+                    (this.currentIntensity / 300);
+                const currentRadius = Math.sqrt(x * x + y * y + z * z) + wave;
+                const finalScale = Math.min(currentRadius, 2.5) / 1.5;
+                positionAttribute.setXYZ(i, x * finalScale, y * finalScale, z * finalScale);
+            }
+            positionAttribute.needsUpdate = true;
+            // Optional: Update material feedback based on intensity
+            const material = this.orb.material;
+            material.emissiveIntensity = 0.2 + this.currentIntensity / 100;
+            material.opacity = 0.3 + this.currentIntensity / 200;
+            this.renderer.render(this.scene, this.camera);
+        };
+    }
+    get isRecording() {
+        return this._audio.isRecording;
+    }
+    get orbSize() {
+        return this._config.orb?.size ?? 400;
+    }
+    /**
+     * Change color or orb
+     *
+     * @param color
+     * @param emissive
+     */
+    changeColor(color, emissive) {
+        const material = this.orb.material;
+        material.color = color;
+        material.emissive = emissive;
+    }
+    /**
+     * Toggle recording
+     */
+    toggleRecording() {
+        this._audio.toggleRecording();
+    }
+    ngOnInit() {
+        if (this._platform.isServer)
+            return;
+        this._init();
+        this._animate();
+        this._loadSubscribers();
+    }
+    ngOnChanges(changes) {
+        if (this._platform.isServer)
+            return;
+        if (changes['intensity']) {
+            this.targetIntensity = changes['intensity'].currentValue;
+        }
+    }
+    ngOnDestroy() {
+        if (this._platform.isServer)
+            return;
+        cancelAnimationFrame(this.animationId);
+        this.renderer.dispose();
+        this.orb.geometry.dispose();
+        this.orb.material.dispose();
+        this._subs.unsubscribe();
+    }
+    handleSpacebarPress(event) {
+        event.preventDefault(); // Prevents the default space bar action (e.g., scrolling)
+        this.toggleRecording();
+    }
+    /**
+     * Initialize
+     */
+    _init() {
+        this.scene = new THREE.Scene();
+        this.camera = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
+        this.camera.position.z = 3;
+        this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+        this.renderer.setPixelRatio(window.devicePixelRatio);
+        this.rendererContainer.nativeElement.appendChild(this.renderer.domElement);
+        // Initial resize to fit container
+        this._resize();
+        // Orb Geometry (Icosahedron for organic detail)
+        const geometry = new THREE.IcosahedronGeometry(1.2, 32);
+        this.originalVertices = geometry.attributes['position'].array.slice();
+        const material = new THREE.MeshStandardMaterial({
+            color: 'red',
+            wireframe: true,
+            transparent: true,
+            opacity: 0.6,
+            emissive: 'red',
+            emissiveIntensity: 0.5,
+        });
+        this.orb = new THREE.Mesh(geometry, material);
+        this.scene.add(this.orb);
+        const light = new THREE.PointLight(0xffffff, 15, 10);
+        light.position.set(2, 2, 2);
+        this.scene.add(light);
+        this.scene.add(new THREE.AmbientLight(0x404040));
+    }
+    /**
+     * Resize container
+     */
+    _resize() {
+        const width = this.orbSize ?? this.rendererContainer.nativeElement.clientWidth;
+        const height = this.orbSize ?? this.rendererContainer.nativeElement.clientHeight;
+        this.renderer.setSize(width, height);
+        this.camera.aspect = width / height;
+        this.camera.updateProjectionMatrix();
+    }
+    /**
+     * Subscriptions
+     */
+    _loadSubscribers() {
+        // Speech event
+        this._subs.sink = this._event.speech.subscribe((e) => {
+            if (this._isActive)
+                this.targetIntensity = e.dbNormalized * 100;
+            else
+                this.targetIntensity = 0;
+        });
+        // Wake word event
+        this._subs.sink = this._event.wakeword.subscribe(() => {
+            this.changeColor(new THREE.Color(0x00d2ff), new THREE.Color(0x0066ff));
+            this._isActive = true;
+        });
+        // Silence
+        this._subs.sink = this._event.silence.subscribe((ev) => {
+            if (!ev.interimResponse) {
+                // on silence, set color to red
+                this.changeColor(new THREE.Color('red'), new THREE.Color('red'));
+                this._isActive = false;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: OrbComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: OrbComponent, isStandalone: true, selector: "app-orb-component", host: { listeners: { "window:keydown.Space": "handleSpacebarPress($event)" } }, viewQueries: [{ propertyName: "rendererContainer", first: true, predicate: ["rendererContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `<div
+    #rendererContainer
+    tabindex="0"
+    role="button"
+    class="orb-viewport"
+    [style.height]="orbSize"
+    [style.width]="orbSize"
+    (click)="toggleRecording()"
+    (keypress)="toggleRecording()"
+  ></div>`, isInline: true, styles: [".orb-viewport{background:transparent;cursor:pointer}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: OrbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-orb-component', standalone: true, template: `<div
+    #rendererContainer
+    tabindex="0"
+    role="button"
+    class="orb-viewport"
+    [style.height]="orbSize"
+    [style.width]="orbSize"
+    (click)="toggleRecording()"
+    (keypress)="toggleRecording()"
+  ></div>`, styles: [".orb-viewport{background:transparent;cursor:pointer}\n"] }]
+        }], propDecorators: { rendererContainer: [{
+                type: ViewChild,
+                args: ['rendererContainer', { static: true }]
+            }], handleSpacebarPress: [{
+                type: HostListener,
+                args: ['window:keydown.Space', ['$event']]
+            }] } });
+
+const DEFAULT_THROTTLE_TIME = 1000;
+class WakeyWakeyComponent {
+    constructor() {
+        /**
+         * Fires when library loaded
+         */
+        this.ready = new EventEmitter();
+        /**
+         * Fires when there is an error
+         */
+        this.exception = new EventEmitter();
+        /**
+         * Fires when speech is detected
+         */
+        this.speech = new EventEmitter();
+        /**
+         * Fires when wake word is detected
+         */
+        this.wakeword = new EventEmitter();
+        /**
+         * Fires when recording starts (after wake word detection)
+         */
+        this.recording = new EventEmitter();
+        /**
+         * Fires silence is detected
+         */
+        this.silence = new EventEmitter();
+        /**
+         * Dependencies
+         */
+        this._config = inject(ConfigService);
+        /**
+         * Dependencies
+         */
+        this._platform = inject(PlatformService);
+        this._event = inject(EventService);
+        this._audio = inject(AudioService);
+        this._model = inject(ModelService);
+        /**
+         * Subscriptions
+         */
+        this._subs = new SubSink();
+    }
+    ngOnInit() {
+        // Execute pipeline
+        this._execute();
+    }
+    /**
+     * Fire face wakeword event
+     */
+    fireWakeWord() {
+        this._event.wakeword.next({
+            inferenceScore: 1,
+            chunk: [],
+            vadScore: 1,
+            hasVoiceActivity: false,
+            sample: new Float32Array(),
+            rms: 0,
+            db: 0,
+            dbNormalized: 0,
+        });
+    }
+    ngOnDestroy() {
+        this._subs.unsubscribe();
+    }
+    /**
+     * Execute
+     */
+    async _execute() {
+        // Check if browser
+        if (this._platform.isServer)
+            return;
+        // Listen events
+        this._listenEvents();
+        // Init audio
+        await this._audio.init();
+    }
+    /**
+     * Listen events
+     */
+    _listenEvents() {
+        // Ready event
+        this._subs.sink = this._event.ready.subscribe((e) => {
+            this.ready.emit(e);
+        });
+        // Exception event
+        this._subs.sink = this._event.exception.subscribe((e) => {
+            this.exception.emit(e);
+        });
+        // Speech event
+        this._subs.sink = this._event.speech.subscribe((e) => {
+            this.speech.emit(e);
+        });
+        // Wake word event
+        this._subs.sink = this._event.wakeword
+            .pipe(throttleTime(this._config.throttleTime ?? DEFAULT_THROTTLE_TIME))
+            .subscribe((e) => {
+            this.wakeword.emit(e);
+        });
+        // Recording event
+        this._subs.sink = this._event.recording.subscribe((e) => {
+            this.recording.emit(e);
+        });
+        // Silence event
+        this._subs.sink = this._event.silence.subscribe((e) => {
+            this.silence.emit(e);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: WakeyWakeyComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.16", type: WakeyWakeyComponent, isStandalone: true, selector: "wakeywakey", outputs: { ready: "ready", exception: "exception", speech: "speech", wakeword: "wakeword", recording: "recording", silence: "silence" }, providers: [], ngImport: i0, template: '<app-orb-component (orbClick)="fireWakeWord()" />', isInline: true, dependencies: [{ kind: "component", type: OrbComponent, selector: "app-orb-component" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: WakeyWakeyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'wakeywakey',
+                    imports: [OrbComponent],
+                    template: '<app-orb-component (orbClick)="fireWakeWord()" />',
+                    providers: [],
+                }]
+        }], propDecorators: { ready: [{
+                type: Output
+            }], exception: [{
+                type: Output
+            }], speech: [{
+                type: Output
+            }], wakeword: [{
+                type: Output
+            }], recording: [{
+                type: Output
+            }], silence: [{
+                type: Output
+            }] } });
+
+/**
+ * Provide wakey wakey configuration
+ *
+ * @param config Wakey Wakey configuration
+ * @returns
+ */
+function provideWakeyWakey(config) {
+    return [
+        {
+            provide: CONFIG,
+            useValue: config,
+        },
+        ConfigService,
+        MicrophoneService,
+        SpeakerService,
+        VadService,
+        AudioService,
+        PlatformService,
+        EventService,
+        PipelineService,
+        SpeechRecognitionService,
+        ModelService,
+        provideAppInitializer(async () => {
+            const _config = inject(ConfigService);
+            const _model = inject(ModelService);
+            const _platform = inject(PlatformService);
+            if (_platform.isServer)
+                return;
+            // Set wasm path
+            env.wasm.wasmPaths = _config.onnx.runtimePath ?? `${_config.basePath}/wasm/`;
+            const modelPath = [
+                _config.onnx.model.melspectrogram ?? `${_config.basePath}/models/melspectrogram.onnx`,
+                _config.onnx.model.embedding_model ?? `${_config.basePath}/models/embedding_model.onnx`,
+                _config.onnx.model.silero_vad ?? `${_config.basePath}/models/silero_vad_v4.onnx`,
+                _config.onnx.model.wakeword,
+            ];
+            // Create sessions
+            const sessions = await Promise.all(Object.values(modelPath).map((path) => InferenceSession.create(path, { executionProviders: ['wasm'] })));
+            // set sessions
+            _model.session = {
+                melspectrogram: sessions[0],
+                embedding_model: sessions[1],
+                silero_vad: sessions[2],
+                wakeword: sessions[3],
+            };
+        }),
+    ];
+}
+
+/*
+ * Public API Surface of wakeywakey
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CONFIG as WAKEYWAKEY_CONFIG, AudioUtil as WakeyWakeyAudioUtil, WakeyWakeyComponent, provideWakeyWakey };
+//# sourceMappingURL=prabhjeet.me-wakeywakey.mjs.map