@mieweb/ui 0.6.1-dev.165 → 0.6.1-dev.166

package/dist/hey-buddy-CLUVAY2X.cjs

@@ -0,0 +1,1133 @@
+'use strict';
+
+var chunkUVSODK6V_cjs = require('./chunk-UVSODK6V.cjs');
+
+// src/components/AI/HeyOzwell/WakeWord/lib/helpers.js
+var sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/onnx.js
+var initialized = false;
+var initError = null;
+var Tensor;
+var InferenceSession;
+if (typeof ort !== "undefined") {
+  initialized = true;
+  Tensor = ort.Tensor;
+  InferenceSession = ort.InferenceSession;
+} else {
+  import('onnxruntime-web').then((module) => {
+    try {
+      if (!module.env.wasm.wasmPaths) {
+        const v = module.env && module.env.versions && module.env.versions.web || "";
+        module.env.wasm.wasmPaths = "https://cdn.jsdelivr.net/npm/onnxruntime-web" + (v ? "@" + v : "") + "/dist/";
+      }
+      module.env.wasm.numThreads = 1;
+    } catch (e) {
+    }
+    initialized = true;
+    Tensor = module.Tensor;
+    InferenceSession = module.InferenceSession;
+  }).catch((e) => {
+    initError = e instanceof Error ? e : new Error(String(e));
+  });
+}
+var ONNX = class _ONNX {
+  /**
+   * Wait for the ONNX Runtime Web API to be initialized.
+   * @returns {Promise<void>} A promise that resolves when the ONNX Runtime Web API is initialized.
+   */
+  static async waitForInitialization() {
+    while (!initialized) {
+      if (initError) throw new Error("ONNX Runtime Web failed to load: " + initError.message);
+      await sleep(10);
+    }
+  }
+  /**
+   * Create a new tensor.
+   * @param {string} dtype The data type of the tensor.
+   * @param {Array<number>} data The data of the tensor.
+   * @param {Array<number>} dims The dimensions of the tensor.
+   * @returns {Promise<Tensor>} A promise that resolves to a new tensor.
+   */
+  static async createTensor(dtype, data, dims) {
+    await _ONNX.waitForInitialization();
+    return new Tensor(dtype, data, dims);
+  }
+  /**
+   * Create a new inference session.
+   * @param {ArrayBuffer} model The model to load.
+   * @param {Object} [options] The options for the inference session.
+   * @returns {Promise<InferenceSession>} A promise that resolves to a new inference session.
+   */
+  static async createInferenceSession(model, options = {}) {
+    await _ONNX.waitForInitialization();
+    return await InferenceSession.create(model, options);
+  }
+};
+ONNX.waitForInitialization().then(() => {
+  ONNX.createTensor = (dtype, data, dims) => new Tensor(dtype, data, dims);
+  ONNX.createInferenceSession = (model, options = {}) => InferenceSession.create(model, options);
+}).catch(() => {
+});
+
+// src/components/AI/HeyOzwell/WakeWord/lib/audio.js
+var workletName = "hey-buddy";
+var workletBlob = new Blob([`(()=>{class t extends AudioWorkletProcessor{constructor(t){super(t),this.targetSampleRate=t.processorOptions.targetSampleRate,this.inputBuffer=new Float32Array(this.inputFrameSize),this.inputBufferSize=0,this.outputBuffer=new Float32Array(this.targetFrameSize)}get inputFrameSize(){return Math.round(sampleRate/50)}get targetFrameSize(){return Math.round(this.targetSampleRate/50)}async flush(){const t=sampleRate/this.targetSampleRate;this.outputBuffer.fill(0);for(let e=0;e<this.targetFrameSize;e++){const i=e*t,r=Math.floor(i),s=Math.min(r+1,this.inputFrameSize-1),u=i-r;this.outputBuffer[e]=this.inputBuffer[r]*(1-u)+this.inputBuffer[s]*u}await this.port.postMessage(this.outputBuffer)}pushAudio(t){const e=t.length,i=this.inputFrameSize-this.inputBufferSize;if(e<i)return this.inputBuffer.set(t,this.inputBufferSize),void(this.inputBufferSize+=e);this.inputBuffer.set(t.subarray(0,i),this.inputBufferSize),this.flush(),this.inputBufferSize=0,this.pushAudio(t.subarray(i))}process(t,e,i){return this.pushAudio(t[0][0]),!0}}registerProcessor("${workletName}",t)})();`], { type: "application/javascript" });
+var workletUrl = URL.createObjectURL(workletBlob);
+var AudioBatcher = class {
+  /**
+   * @param {number} batchSeconds - The number of seconds to batch.
+   * @param {number} batchIntervalSeconds - The number of seconds to wait before calling the callback.
+   * @param {number} targetSampleRate - The target sample rate of the worklet.
+   */
+  constructor(batchSeconds = 2, batchIntervalSeconds = 0.05, targetSampleRate = 16e3) {
+    this.initialized = false;
+    this.initError = null;
+    this.callbacks = [];
+    this.batchSeconds = batchSeconds;
+    this.batchIntervalSeconds = batchIntervalSeconds;
+    this.batchIntervalCount = 0;
+    this.targetSampleRate = targetSampleRate;
+    this.buffer = new Float32Array(this.batchSamples);
+    this.buffer.fill(0);
+    this.initialize().catch((e) => {
+      this.initError = e;
+      console.error("[AudioBatcher] initialization failed", e);
+    });
+  }
+  /**
+   * The number of samples in a batch.
+   * @type {number}
+   */
+  get batchSamples() {
+    return Math.floor(this.batchSeconds * this.targetSampleRate);
+  }
+  /**
+   * The number of samples in a batch interval.
+   * @type {number}
+   */
+  get batchIntervalSamples() {
+    return Math.floor(this.batchIntervalSeconds * this.targetSampleRate);
+  }
+  /**
+   * Clears the buffer.
+   */
+  clearBuffer() {
+    this.buffer.fill(0);
+  }
+  /**
+   * Pushes new audio samples into the buffer.
+   * @param {Float32Array} data - The new audio samples.
+   */
+  push(data) {
+    const dataLength = data.length;
+    if (dataLength >= this.buffer.length) {
+      this.buffer.set(data.subarray(dataLength - this.buffer.length));
+    } else {
+      this.buffer.set(this.buffer.subarray(dataLength));
+      this.buffer.set(data, this.buffer.length - dataLength);
+    }
+    this.batchIntervalCount += dataLength;
+    if (this.batchIntervalCount >= this.batchIntervalSamples) {
+      this.callbacks.forEach((callback) => callback(this.buffer));
+      this.batchIntervalCount = 0;
+    }
+  }
+  /**
+   * Adds a callback to be called with each batch.
+   * @param {Function} callback - The callback to add.
+   */
+  onBatch(callback) {
+    this.callbacks.push(callback);
+  }
+  /**
+   * Removes a callback from the list of callbacks.
+   * @param {Function} callback - The callback to remove.
+   */
+  offBatch(callback) {
+    this.callbacks = this.callbacks.filter((c) => c !== callback);
+  }
+  /**
+   * Initializes the audio batcher.
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.stream = await navigator.mediaDevices.getUserMedia({
+      audio: {
+        channelCount: 1,
+        echoCancellation: true,
+        autoGainControl: true,
+        noiseSuppression: true
+      }
+    });
+    this.audioContext = new AudioContext();
+    this.audioContext.resume().catch(() => {
+    });
+    this.sourceNode = new MediaStreamAudioSourceNode(
+      this.audioContext,
+      { mediaStream: this.stream }
+    );
+    this.workerNode = await AudioNode.create(
+      this.audioContext,
+      this.targetSampleRate
+    );
+    this.sourceNode.connect(this.workerNode.worker);
+    this.workerNode.worker.port.onmessage = (event) => {
+      this.push(event.data);
+    };
+    this.clearBuffer();
+    this.initialized = true;
+  }
+};
+var AudioNode = class _AudioNode {
+  /**
+   * @param {AudioContext} context - The audio context.
+   * @param {AudioWorkletNode} worker - The audio worklet node.
+   */
+  constructor(context, worker) {
+    this.context = context;
+    this.worker = worker;
+  }
+  /**
+   * Creates an AudioNode.
+   * @param {AudioContext} context - The audio context.
+   * @param {number} targetSampleRate - The target sample rate of the worklet.
+   * @returns {Promise<AudioNode>} The created AudioNode.
+   */
+  static async create(context, targetSampleRate) {
+    await context.audioWorklet.addModule(workletUrl);
+    const workletOptions = {
+      processorOptions: {
+        targetSampleRate
+      }
+    };
+    const worker = new AudioWorkletNode(context, workletName, workletOptions);
+    return new _AudioNode(context, worker);
+  }
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/models/base.js
+var ONNXModel = class {
+  /**
+   * Constructor
+   * @param {string} modelPath - Path to the ONNX model
+   * @param {Object} options - Options
+   */
+  constructor(modelPath, power = 0, webnn = 1, webgpu = 2, webgl = 3, wasm = 4) {
+    this.modelPath = modelPath;
+    this.session = null;
+    this.loadError = null;
+    this.duration = 0;
+    this.ema = 0.1;
+    this.lastTime = 0;
+    this.webnn = webnn;
+    this.webgpu = webgpu;
+    this.webgl = webgl;
+    this.wasm = wasm;
+    this.power = power;
+    this.loadPromise = this.load().catch((e) => {
+      this.loadError = e;
+      console.warn("[ONNXModel] load failed:", e);
+    });
+  }
+  /**
+   * Get the power preference
+   * @returns {string} - Power preference
+   */
+  get powerPreference() {
+    switch (this.power) {
+      case -1:
+        return "low-power";
+      case 1:
+        return "high-performance";
+      default:
+        return "default";
+    }
+  }
+  /**
+   * Get the execution providers
+   * @returns {Array} - Execution providers
+   */
+  get executionProviders() {
+    const providerIndexes = [];
+    if (Number.isInteger(this.webnn)) {
+      providerIndexes.push([{
+        name: "webnn",
+        device: "gpu",
+        powerPreference: this.powerPreference
+      }, this.webnn]);
+    }
+    if (Number.isInteger(this.webgpu)) {
+      providerIndexes.push(["webgpu", this.webgpu]);
+    }
+    if (Number.isInteger(this.webgl)) {
+      providerIndexes.push(["webgl", this.webgl]);
+    }
+    if (Number.isInteger(this.wasm)) {
+      providerIndexes.push(["wasm", this.wasm]);
+    }
+    providerIndexes.sort((a, b) => a[1] - b[1]);
+    return providerIndexes.map((providerIndex) => providerIndex[0]);
+  }
+  /**
+   * Get the session options
+   * @returns {Object} - Session options
+   * @see https://onnxruntime.ai/docs/tutorials/web/env-flags-and-session-options.html#session-options
+   */
+  get sessionOptions() {
+    return {
+      executionProviders: ["wasm"]
+    };
+  }
+  /**
+   * Initialize the model
+   */
+  async load() {
+    const bytes = await chunkUVSODK6V_cjs.getModelBytes(this.modelPath);
+    this.session = await ONNX.createInferenceSession(bytes, this.sessionOptions);
+  }
+  /**
+   * Waits until the model is loaded
+   */
+  async waitUntilLoaded() {
+    await this.loadPromise;
+    if (this.loadError) throw this.loadError;
+  }
+  /**
+   * Execute the model
+   * @param {Mixed} input - Input data
+   * @returns {Promise} - Promise that resolves with the output of the model
+   * @throws {Error} - If the method is not implemented
+   */
+  async execute(input) {
+    throw new Error("Not Implemented");
+  }
+  /**
+   * Run the model
+   * @param {Mixed} input - Input data
+   * @returns {Promise} - Promise that resolves with the output of the model
+   */
+  async run(input) {
+    await this.waitUntilLoaded();
+    const currentTime = (/* @__PURE__ */ new Date()).getTime();
+    const result = await this.execute(input);
+    const executionDuration = (/* @__PURE__ */ new Date()).getTime() - currentTime;
+    if (this.duration === 0) {
+      this.duration = executionDuration;
+    } else {
+      this.duration = (1 - this.ema) * this.duration + this.ema * executionDuration;
+    }
+    this.lastTime = currentTime;
+    return result;
+  }
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/models/vad.js
+var SileroVAD = class extends ONNXModel {
+  /**
+   * Constructor
+   * @param {string} modelPath - Path to the ONNX model
+   * @param {number} sampleRate - Sample rate of the input audio
+   * @param {number} speechVadThreshold - Threshold for speech detection (default: 0.65)
+   * @param {number} silenceVadThreshold - Threshold for silence detection (default: 0.4)
+   * @param {number} silentFramesCount - Number of silent frames to consider speech ended (default: 10)
+   */
+  constructor(modelPath = "/pretrained/silero-vad.onnx", sampleRate = 16e3, speechVadThreshold = 0.65, silenceVadThreshold = 0.4, silentFramesCount = 10, power = 0, webnn = 1, webgpu = 2, webgl = 3, wasm = 4) {
+    super(
+      modelPath,
+      power,
+      webnn,
+      webgpu,
+      webgl,
+      wasm
+    );
+    this.sampleRate = sampleRate || 16e3;
+    this.speechVadThreshold = speechVadThreshold;
+    this.silenceVadThreshold = silenceVadThreshold;
+    this.silentFramesCount = silentFramesCount;
+    this.silentFrames = 0;
+    this.isSpeaking = false;
+  }
+  /**
+   * Test the model
+   * @param {boolean} debug - If true, log the result to the console
+   * @throws {Error} - If the model fails the test
+   */
+  async test(debug = false) {
+    let result = await this.run(new Float32Array(16e3).fill(0));
+    if (!isNaN(result) && 0 <= result && result <= 1) {
+      if (debug) {
+        console.log(`VAD model OK, executed in ${this.duration} ms`);
+      }
+    } else {
+      throw new Error(`VAD model failed - got ${result}`);
+    }
+  }
+  /**
+   * Execute the model
+   * @param {Float32Array} input - Input data
+   * @returns {Promise} - Promise that resolves with the output of the model, which is a single float
+   * @throws {Error} - If the input data is not a Float32Array
+   */
+  async execute(input) {
+    if (this.h === void 0 || this.c === void 0 || this.sr === void 0) {
+      this.sr = await ONNX.createTensor("int64", [this.sampleRate], [1]);
+      this.h = await ONNX.createTensor("float32", new Array(128).fill(0), [2, 1, 64]);
+      this.c = await ONNX.createTensor("float32", new Array(128).fill(0), [2, 1, 64]);
+    }
+    const inputTensor = await ONNX.createTensor("float32", input, [1, input.length]);
+    const output = await this.session.run({
+      input: inputTensor,
+      h: this.h,
+      c: this.c,
+      sr: this.sr
+    });
+    this.c = output.cn;
+    this.h = output.hn;
+    return output.output.data[0];
+  }
+  /**
+   * Determines if speech is present in the audio, with debouncing logic so a brief pause between
+   * words doesn't split one utterance into two: if speech is followed by a short silence and then
+   * more speech, the whole span (including the gap) is still treated as speech.
+   *
+   * @param {Float32Array} audio - Audio data to check for speech
+   * @returns {Promise<Object>} - Promise that resolves with an object containing:
+   *   - isSpeaking: boolean - true if speech is detected, false otherwise
+   *   - probability: number - the raw VAD probability score (0-1)
+   */
+  async hasSpeechAudio(audio) {
+    const speechProbability = await this.run(audio);
+    const hasSpeech = speechProbability > this.speechVadThreshold;
+    const hasSilence = speechProbability < this.silenceVadThreshold;
+    let justStoppedSpeaking = false;
+    let justStartedSpeaking = false;
+    if (!hasSpeech) {
+      if (hasSilence) {
+        this.silentFrames += 1;
+        if (this.isSpeaking && this.silentFrames > this.silentFramesCount) {
+          this.isSpeaking = false;
+          justStoppedSpeaking = true;
+        }
+      }
+    } else {
+      this.silentFrames = 0;
+      if (!this.isSpeaking) {
+        this.isSpeaking = true;
+        justStartedSpeaking = true;
+      }
+    }
+    return {
+      isSpeaking: this.isSpeaking,
+      speechProbability,
+      justStoppedSpeaking,
+      justStartedSpeaking
+    };
+  }
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/models/mel-spectrogram.js
+var MelSpectrogram = class extends ONNXModel {
+  /**
+   * Constructor
+   * @param {string} modelPath - Path to the ONNX model
+   */
+  constructor(modelPath = "/pretrained/mel-spectrogram.onnx", power = 0, webnn = 1, webgpu = 2, webgl = 3, wasm = 4) {
+    super(
+      modelPath,
+      power,
+      webnn,
+      webgpu,
+      webgl,
+      wasm
+    );
+  }
+  /**
+   * Test the model
+   * @param {boolean} debug - If true, print debug information
+   * @throws {Error} - If the model fails the test
+   */
+  async test(debug = false) {
+    let result = await this.run(new Float32Array(12640).fill(1));
+    if (result.dims.length === 4 && result.dims[2] === 76 && result.dims[3] === 32) {
+      if (debug) {
+        console.log(`Mel spectrogram model OK, executed in ${this.duration} ms`);
+      }
+    } else {
+      throw new Error("Mel spectrogram model failed");
+    }
+  }
+  /**
+   * Execute the model
+   * @param {Float32Array} input - Input data
+   * @returns {Promise} - Promise that resolves with the output of the model, which is a 2D array
+   * @throws {Error} - If the input data is not a Float32Array
+   */
+  async execute(input) {
+    let peak = 0;
+    for (let i = 0; i < input.length; i++) {
+      const a = Math.abs(input[i]);
+      if (a > peak) peak = a;
+    }
+    if (peak > 1e-5) {
+      const normed = new Float32Array(input.length);
+      for (let i = 0; i < input.length; i++) normed[i] = input[i] / peak;
+      input = normed;
+    }
+    const inputTensor = await ONNX.createTensor(
+      "float32",
+      input,
+      [1, input.length]
+    );
+    const output = await this.session.run({ input: inputTensor });
+    const data = output.output.data;
+    for (let i = 0; i < data.length; i++) data[i] = data[i] / 10 + 2;
+    return await ONNX.createTensor("float32", data, output.output.dims);
+  }
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/models/speech-embedding.js
+var SpeechEmbedding = class extends ONNXModel {
+  /**
+   * Constructor
+   * @param {string} modelPath - Path to the ONNX model
+   * @param {MelSpectrogram} spectrogramModel - Mel spectrogram model
+   * @param {number} spectrogramMelBins - Number of Mel bins for the Mel spectrogram model
+   * @param {number} embeddingDim - Dimension of the embeddings
+   * @param {number} windowSize - Size of the window
+   * @param {number} windowStride - Stride of the window
+   */
+  constructor(modelPath, embeddingDim = 96, windowSize = 76, windowStride = 8, power = 0, webnn = 1, webgpu = 2, webgl = 3, wasm = 4) {
+    super(
+      modelPath,
+      power,
+      webnn,
+      webgpu,
+      webgl,
+      wasm
+    );
+    this.embeddingDim = embeddingDim;
+    this.windowSize = windowSize;
+    this.windowStride = windowStride;
+  }
+  /** 
+   * Test the model
+   * @param {boolean} debug - Debug mode
+   * @throws {Error} - If the model fails the test
+   */
+  async test(debug = false) {
+    const melTensor = await ONNX.createTensor(
+      "float32",
+      new Float32Array(100 * 32),
+      // already zero-initialized
+      [100, 32]
+    );
+    let result = await this.run(melTensor);
+    if (result.dims.length === 2 && result.dims[0] === 4 && result.dims[1] === 96) {
+      if (debug) {
+        console.log(`Speech embedding model OK, executed in ${this.duration} ms`);
+      }
+    } else {
+      console.error("Unexpected speech embedding result", result);
+      throw new Error("Speech embedding model failed");
+    }
+  }
+  /**
+   * Extracts speech embeddings from a mel spectrogram output
+   * 
+   * This function takes the output from a mel spectrogram model, creates an ONNX tensor
+   * with the appropriate dimensions, and runs it through the speech embedding model to
+   * generate embeddings that can be used for wake word detection.
+   * 
+   * @param {Object} melSpectogramOutput - The output tensor from a mel spectrogram model
+   * @param {Float32Array} melSpectogramOutput.data - The raw data from the mel spectrogram
+   * @param {Array<number>} melSpectogramOutput.dims - The dimensions of the mel spectrogram output
+   * @returns {Promise<Object>} - A promise that resolves to an ONNX tensor containing the speech embeddings
+   */
+  async getEmbeddingFromMelSpectrogramOutput(melSpectogramOutput) {
+    const spectogramBuffer = await ONNX.createTensor(
+      "float32",
+      melSpectogramOutput.data,
+      melSpectogramOutput.dims.slice(2)
+    );
+    return this.run(spectogramBuffer);
+  }
+  /**
+   * Execute the model
+   * @param {Float32Array} input - Input data
+   * @returns {Promise} - Promise that resolves with the output of the model, which is a 2D array
+   * @throws {Error} - If the input data is not a Float32Array
+   */
+  async execute(spectrograms) {
+    const [numFrames, melBins] = spectrograms.dims;
+    if (numFrames < this.windowSize) {
+      throw new Error(`Audio is too short to process - require ${this.windowSize} samples, got ${numFrames}`);
+    }
+    const numTruncatedFrames = numFrames - (numFrames - this.windowSize) % this.windowStride;
+    const numBatches = (numTruncatedFrames - this.windowSize) / this.windowStride + 1;
+    const embeddings = await ONNX.createTensor(
+      "float32",
+      new Array(numBatches * this.embeddingDim).fill(0),
+      [numBatches, this.embeddingDim]
+    );
+    const windowBatches = [];
+    for (let windowStart = 0; windowStart < numTruncatedFrames - this.windowSize + this.windowStride; windowStart += this.windowStride) {
+      const windowEnd = windowStart + this.windowSize;
+      const windowTensor = await ONNX.createTensor(
+        "float32",
+        spectrograms.data.slice(windowStart * melBins, windowEnd * melBins),
+        [this.windowSize, melBins, 1]
+      );
+      windowBatches.push([windowStart, windowEnd, windowTensor]);
+    }
+    const stackedWindowTensor = await ONNX.createTensor(
+      "float32",
+      new Float32Array(numBatches * this.windowSize * melBins),
+      [numBatches, this.windowSize, melBins, 1]
+    );
+    for (let i = 0; i < numBatches; i++) {
+      stackedWindowTensor.data.set(windowBatches[i][2].data, i * this.windowSize * melBins);
+    }
+    const output = await this.session.run({ input_1: stackedWindowTensor });
+    for (let i = 0; i < numBatches; i++) {
+      embeddings.data.set(
+        output.conv2d_19.data.slice(
+          i * this.embeddingDim,
+          (i + 1) * this.embeddingDim
+        ),
+        i * this.embeddingDim
+      );
+    }
+    return embeddings;
+  }
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/models/wake-word.js
+var WakeWord = class extends ONNXModel {
+  /**
+   * Constructor
+   * @param {string} modelPath - Path to the ONNX model
+   * @param {number} threshold - Threshold for wake word detection (default: 0.5)
+   */
+  constructor(modelPath, threshold, power = 0, webnn = 1, webgpu = 2, webgl = 3, wasm = 4) {
+    super(modelPath, power, webnn, webgpu, webgl, wasm);
+    this.threshold = threshold;
+  }
+  /**
+   * Test the model
+   * @param {boolean} debug - Whether to log debug messages
+   * @throws {Error} - If the model test fails
+   */
+  async test(debug = false) {
+    const embeddings = await ONNX.createTensor(
+      "float32",
+      new Float32Array(16 * 96).fill(0),
+      [1, 16, 96]
+    );
+    const output = await this.run(embeddings);
+    if (0 <= output && output <= 1) {
+      if (debug) {
+        console.log(`Wake Word model OK, executed in ${this.duration} ms`);
+      }
+    } else {
+      throw new Error(`Wake Word model test failed - expected 0 <= x <= 1, got ${output}`);
+    }
+  }
+  /**
+   * Execute the model
+   * @param {Float32Array} embeddings - Input embeddings
+   * @returns {Promise} - Promise that resolves with the output of the model, which is a single float
+   * @throws {Error} - If the input data is not a Float32Array
+   */
+  async execute(embeddings) {
+    const input = {};
+    if (embeddings.dims.length === 3) {
+      input.input = embeddings;
+    } else {
+      input.input = await ONNX.createTensor(
+        "float32",
+        embeddings.data,
+        [1, embeddings.dims[0], embeddings.dims[1]]
+      );
+    }
+    const output = await this.session.run(input);
+    return output.output.data[0] * 1;
+  }
+  /**
+   * Check if the wake word is detected based on the threshold
+   * @param {Float32Array} embeddings - Input embeddings
+   * @returns {Promise<Object>} - Promise that resolves with an object containing probability and detected status
+   */
+  async checkWakeWordCalled(embeddings) {
+    const probability = await this.run(embeddings);
+    let thr = this.threshold;
+    const ov = typeof window !== "undefined" ? window.__baseThr : void 0;
+    if (typeof ov === "number") thr = ov;
+    else if (ov && this.name && typeof ov[this.name] === "number") thr = ov[this.name];
+    return {
+      probability,
+      detected: probability >= thr
+    };
+  }
+  /**
+   * Run wake word detection on audio.
+   * @param {Float32Array} embeddings - Input embeddings
+   * @returns {Promise} - Promise that resolves when wake word detection is complete.
+   */
+  async checkWakeWordPresent(embeddings) {
+    return await this.execute(embeddings);
+  }
+};
+
+// src/components/AI/HeyOzwell/WakeWord/lib/hey-buddy.js
+async function embeddingBufferArrayToEmbedding(embeddingBufferArray, numFramesPerEmbedding, embeddingDim) {
+  const combinedEmptyData = new Float32Array(numFramesPerEmbedding * embeddingBufferArray.length * embeddingDim);
+  const embeddingBuffer = await ONNX.createTensor(
+    "float32",
+    combinedEmptyData,
+    [numFramesPerEmbedding * embeddingBufferArray.length, embeddingDim]
+  );
+  for (let i = 0; i < embeddingBufferArray.length; i++) {
+    const embedding = embeddingBufferArray[i];
+    embeddingBuffer.data.set(embedding.data, i * numFramesPerEmbedding * embeddingDim);
+  }
+  return embeddingBuffer;
+}
+var HeyBuddy = class {
+  /**
+   * Create a HeyBuddy instance.
+   * @param {Object} [options] - Options object.
+   * @param {number} [options.positiveVadThreshold=0.5] - VAD threshold for speech.
+   * @param {number} [options.negativeVadThreshold=0.25] - VAD threshold for silence.
+   * @param {number} [options.negativeVadCount=8] - Number of negative VADs to trigger silence.
+   * @param {number} [options.wakeWordThreads=4] - Number of threads for wake word detection.
+   * @param {number} [options.wakeWordThreshold=0.5] - Wake word detection threshold.
+   * @param {string|string[]} [options.modelPath="/models/hey-buddy.onnx"] - Path to wake word model.
+   * @param {string} [options.vadModelPath="/pretrained/silero-vad.onnx"] - Path to VAD model.
+   * @param {string} [options.embeddingModelPath="/pretrained/speech-embedding.onnx"] - Path to speech embedding model.
+   * @param {string} [options.spectrogramModelPath="/pretrained/mel-spectrogram.onnx"] - Path to mel spectrogram model.
+   * @param {number} [options.batchSeconds=1.08] - Number of seconds per batch.
+   * @param {number} [options.batchIntervalSeconds=0.12] - Number of seconds between batches.
+   * @param {number} [options.targetSampleRate=16000] - Target sample rate for audio.
+   * @param {number} [options.spectrogramMelBins=32] - Number of mel bins for spectrogram.
+   * @param {number} [options.embeddingDim=96] - Dimension of speech embedding.
+   * @param {number} [options.embeddingWindowSize=76] - Window size for speech embedding.
+   * @param {number} [options.embeddingWindowStride=8] - Window stride for speech embedding.
+   */
+  constructor(options) {
+    options = options || {};
+    this.debug = options.debug || false;
+    options.positiveVadThreshold = options.positiveVadThreshold || 0.65;
+    options.negativeVadThreshold = options.negativeVadThreshold || 0.4;
+    options.negativeVadCount = options.negativeVadCount || 8;
+    this.wakeWordThreads = options.wakeWordThreads || 4;
+    this.wakeWordThreshold = options.wakeWordThreshold || 0.5;
+    this.wakeWordThresholds = options.wakeWordThresholds || {};
+    this.wakeWordInterval = options.wakeWordInterval || 2;
+    const modelPath = options.modelPath || "/models/hey-buddy.onnx";
+    const modelArray = Array.isArray(modelPath) ? modelPath : [modelPath];
+    const vadModelPath = options.vadModelPath || "/pretrained/silero-vad.onnx";
+    const embeddingModelPath = options.embeddingModelPath || "/pretrained/speech-embedding.onnx";
+    const spectrogramModelPath = options.spectrogramModelPath || "/pretrained/mel-spectrogram.onnx";
+    const batchSeconds = options.batchSeconds || 1.08;
+    const batchIntervalSeconds = options.batchIntervalSeconds || 0.12;
+    const targetSampleRate = options.targetSampleRate || 16e3;
+    const spectrogramMelBins = options.spectrogramMelBins || 32;
+    const embeddingDim = options.embeddingDim || 96;
+    const embeddingWindowSize = options.embeddingWindowSize || 76;
+    const embeddingWindowStride = options.embeddingWindowStride || 8;
+    const wakeWordEmbeddingFrames = options.wakeWordEmbeddingFrames || 16;
+    this.vad = new SileroVAD(vadModelPath, targetSampleRate, options.positiveVadThreshold, options.negativeVadThreshold, options.negativeVadCount);
+    this.vad.test(this.debug).catch((e) => console.warn("[HeyBuddy] vad.test failed", e));
+    this.spectrogram = new MelSpectrogram(spectrogramModelPath);
+    this.spectrogram.test(this.debug).catch((e) => console.warn("[HeyBuddy] spectrogram.test failed", e));
+    this.spectrogramMelBins = spectrogramMelBins;
+    this.embedding = new SpeechEmbedding(
+      embeddingModelPath,
+      embeddingDim,
+      embeddingWindowSize,
+      embeddingWindowStride
+    );
+    this.embedding.test(this.debug).catch((e) => console.warn("[HeyBuddy] embedding.test failed", e));
+    this.embeddingDim = embeddingDim;
+    this.embeddingWindowSize = embeddingWindowSize;
+    this.embeddingWindowStride = embeddingWindowStride;
+    this.embeddingBuffer = null;
+    this.embeddingBufferArray = [];
+    this.voiceprints = {};
+    this.voiceprintThreshold = options.voiceprintThreshold ?? 0.85;
+    this.voiceprintThresholds = options.voiceprintThresholds || {};
+    this.voiceprintGate = options.voiceprintGate ?? 0.3;
+    this.embeddingMean = null;
+    this.voiceprintRecall = options.voiceprintRecall ?? true;
+    this.debounceFrames = options.debounceFrames ?? 1;
+    this._consec = {};
+    this.lastWakeProb = 0;
+    this._peakProb = {};
+    this._peakEmb = {};
+    this.lastWakeEmbedding = null;
+    this.wakeWords = {};
+    this.wakeWordTimes = {};
+    this.wakeWordEmbeddingFrames = wakeWordEmbeddingFrames;
+    for (let model of modelArray) {
+      let modelName = model.split("/").pop().split(".")[0];
+      let modelThreshold = this.wakeWordThresholds[modelName] ?? this.wakeWordThreshold;
+      this.wakeWords[modelName] = new WakeWord(model, modelThreshold);
+      this.wakeWords[modelName].name = modelName;
+      this.wakeWords[modelName].test(this.debug).catch((e) => console.warn(`[HeyBuddy] ${modelName}.test failed`, e));
+    }
+    this.recording = false;
+    this.audioBuffer = null;
+    this.frameIntervalEma = 0;
+    this.frameIntervalEmaWeight = 0.1;
+    this.frameTimeEma = 0;
+    this.frameTimeEmaWeight = 0.1;
+    this.speechStartCallbacks = [];
+    this.speechEndCallbacks = [];
+    this.recordingCallbacks = [];
+    this.processedCallbacks = [];
+    this.detectedCallbacks = [];
+    this.batcher = new AudioBatcher(
+      batchSeconds,
+      batchIntervalSeconds,
+      targetSampleRate
+    );
+    this.batcher.onBatch((batch) => this.process(batch));
+  }
+  /**
+   * Set a user's enrolled voiceprint for a wake word.
+   * @param {string} name - Wake-word name (e.g. "hey-ozwell").
+   * @param {Float32Array[]} vectors - Flattened embedding windows captured at enrollment.
+   */
+  setVoiceprint(name, vectors) {
+    this.voiceprints[name] = vectors || [];
+  }
+  clearVoiceprint(name) {
+    delete this.voiceprints[name];
+  }
+  hasVoiceprint(name) {
+    return Array.isArray(this.voiceprints[name]) && this.voiceprints[name].length > 0;
+  }
+  /**
+   * Max cosine similarity between a live embedding window and the stored voiceprint set.
+   * Cosine compares DIRECTION not magnitude, so it ignores loudness and keys on what the
+   * sound actually is. Returns 0..1 (1 = near-identical).
+   */
+  voiceprintSimilarity(name, liveVec) {
+    const set = this.voiceprints[name];
+    if (!Array.isArray(set) || set.length === 0 || !liveVec) return 0;
+    const mean = this.embeddingMean;
+    let best = -1;
+    for (const ref of set) {
+      let dot = 0, na = 0, nb = 0;
+      const n = Math.min(ref.length, liveVec.length);
+      for (let i = 0; i < n; i++) {
+        const a = mean ? ref[i] - mean[i] : ref[i];
+        const b = mean ? liveVec[i] - mean[i] : liveVec[i];
+        dot += a * b;
+        na += a * a;
+        nb += b * b;
+      }
+      if (na > 0 && nb > 0) {
+        const s = dot / (Math.sqrt(na) * Math.sqrt(nb));
+        if (s > best) best = s;
+      }
+    }
+    return best;
+  }
+  /**
+   * Gets the names of wake words, chunked for threaded wake word detection.
+   * @returns {string[][]} - Names of wake words.
+   */
+  get chunkedWakeWords() {
+    return Object.keys(this.wakeWords).reduce((carry, name, i) => {
+      const chunkIndex = Math.floor(i / this.wakeWordThreads);
+      if (!carry[chunkIndex]) {
+        carry[chunkIndex] = [];
+      }
+      carry[chunkIndex].push(name);
+      return carry;
+    }, []);
+  }
+  /**
+   * Add a callback for when a wake word is detected.
+   * @param {string|string[]} names - Name of wake word.
+   * @param {Function} callback - Callback function.
+   */
+  onDetected(names, callback) {
+    this.detectedCallbacks.push({ names, callback });
+  }
+  /**
+   * Add a callback for processed data.
+   * @param {Function} callback - Callback function.
+   */
+  onProcessed(callback) {
+    this.processedCallbacks.push(callback);
+  }
+  /**
+   * Add a callback for speech start.
+   * @param {Function} callback - Callback function.
+   */
+  onSpeechStart(callback) {
+    this.speechStartCallbacks.push(callback);
+  }
+  /**
+   * Add a callback for speech end.
+   * @param {Function} callback - Callback function.
+   */
+  onSpeechEnd(callback) {
+    this.speechEndCallbacks.push(callback);
+  }
+  /**
+   * Add a callback for recording.
+   * @param {Function} callback - Callback function.
+   */
+  onRecording(callback) {
+    this.recordingCallbacks.push(callback);
+  }
+  /**
+   * Trigger speech start event.
+   */
+  speechStart() {
+    if (this.debug) {
+      console.log("Speech start");
+    }
+    for (let callback of this.speechStartCallbacks) {
+      callback();
+    }
+  }
+  /**
+   * Trigger speech end event.
+   */
+  speechEnd() {
+    if (this.debug) {
+      console.log("Speech end");
+    }
+    for (let callback of this.speechEndCallbacks) {
+      callback();
+    }
+    if (this.recording) {
+      this.dispatchRecording();
+      this.recording = false;
+    }
+  }
+  /**
+   * Dispatch recording to all recording callbacks.
+   */
+  dispatchRecording() {
+    if (this.audioBuffer === null) {
+      console.error("No recording to dispatch");
+      return;
+    }
+    if (this.debug) {
+      const recordingLength = this.audioBuffer.length;
+      const recordedDuration = recordingLength / this.batcher.targetSampleRate;
+      console.log(`Dispatching recording with ${recordingLength} frames (${recordedDuration} s)`);
+    }
+    for (let callback of this.recordingCallbacks) {
+      callback(this.audioBuffer);
+    }
+    this.audioBuffer = null;
+  }
+  /**
+   * Trigger wake word detection event.
+   * @param {string} name - Name of wake word.
+   */
+  wakeWordDetected(name) {
+    const now = Date.now();
+    if (this.wakeWordTimes[name] && now - this.wakeWordTimes[name] < this.wakeWordInterval * 1e3) {
+      return;
+    }
+    if (this.debug) {
+      console.log("Wake word detected:", name);
+    }
+    this.recording = true;
+    this.wakeWordTimes[name] = now;
+    const frameSec = this.batcher && this.batcher.batchIntervalSamples && this.batcher.targetSampleRate ? this.batcher.batchIntervalSamples / this.batcher.targetSampleRate : 0.12;
+    this.lastWakeDurationSec = (this._consec[name] || 0) * frameSec;
+    this.lastWakeEmbedding = this._peakEmb && this._peakEmb[name] ? this._peakEmb[name] : this.embeddingBuffer && this.embeddingBuffer.data ? Float32Array.from(this.embeddingBuffer.data) : null;
+    this.lastWakeProb = this._peakProb && this._peakProb[name] ? this._peakProb[name] : 0;
+    for (let { names, callback } of this.detectedCallbacks) {
+      if (Array.isArray(names) && names.includes(name) || names === name) {
+        callback();
+      }
+    }
+  }
+  /**
+   * Trigger processed event.
+   * @param {Object} data - Processed data.
+   */
+  processed(data) {
+    for (let callback of this.processedCallbacks) {
+      callback(data);
+    }
+  }
+  /**
+   * Runs wake word detection on a subset of wake words.
+   * @param {string[]} wakeWordNames - Names of wake words to check.
+   * @returns {Promise} - Promise that resolves when wake word detection is complete.
+   */
+  async checkWakeWordSubset(wakeWordNames) {
+    return await Promise.all(
+      wakeWordNames.map((name) => this.wakeWords[name].checkWakeWordCalled(this.embeddingBuffer))
+    );
+  }
+  /**
+   * Run wake word detection on audio.
+   * @returns {Promise} - Promise that resolves when wake word detection is complete.
+   */
+  async checkWakeWords() {
+    const returnMap = {};
+    for (let nameChunk of this.chunkedWakeWords) {
+      const wakeWordsCalled = await this.checkWakeWordSubset(nameChunk);
+      for (let i = 0; i < nameChunk.length; i++) {
+        const name = nameChunk[i];
+        const wordCalled = wakeWordsCalled[i];
+        returnMap[name] = wordCalled;
+      }
+    }
+    const liveVec = this.embeddingBuffer ? this.embeddingBuffer.data : null;
+    for (let name in returnMap) {
+      returnMap[name].voiceprintSim = this.hasVoiceprint(name) ? this.voiceprintSimilarity(name, liveVec) : 0;
+    }
+    for (let name in returnMap) {
+      if (returnMap[name].detected) {
+        this._consec[name] = (this._consec[name] || 0) + 1;
+        if (returnMap[name].probability > (this._peakProb[name] || 0) && this.embeddingBuffer && this.embeddingBuffer.data) {
+          this._peakProb[name] = returnMap[name].probability;
+          this._peakEmb[name] = Float32Array.from(this.embeddingBuffer.data);
+        }
+      } else {
+        this._consec[name] = 0;
+        this._peakProb[name] = 0;
+        this._peakEmb[name] = null;
+      }
+    }
+    const minRunFor = (name) => {
+      if (typeof window.__debounceFrames === "number") return window.__debounceFrames;
+      if (this.debounceFrames && typeof this.debounceFrames === "object") return this.debounceFrames[name] ?? 1;
+      return this.debounceFrames || 1;
+    };
+    let best = null;
+    for (let name in returnMap) {
+      if (returnMap[name].detected && this._consec[name] >= minRunFor(name)) {
+        const prob = returnMap[name].probability;
+        if (best === null || prob > best.prob) {
+          best = { name, prob };
+        }
+      }
+    }
+    if (best !== null) {
+      this.wakeWordDetected(best.name);
+    } else if (this.voiceprintRecall) {
+      let vbest = null;
+      for (let name in returnMap) {
+        const sim = returnMap[name].voiceprintSim;
+        const vt = this.voiceprintThresholds[name] ?? this.voiceprintThreshold;
+        const modelLit = returnMap[name].probability >= this.voiceprintGate;
+        if (sim >= vt && modelLit && (vbest === null || sim > vbest.sim)) vbest = { name, sim };
+      }
+      if (vbest !== null) {
+        this.wakeWordDetected(vbest.name);
+      }
+    }
+    return returnMap;
+  }
+  /**
+   * Process audio batch.
+   * @param {Float32Array} audio - Audio samples.
+   */
+  async process(audio) {
+    this.frameStart = (/* @__PURE__ */ new Date()).getTime();
+    if (this.frameEnd !== void 0 && this.frameEnd !== null) {
+      this.frameInterval = this.frameStart - this.frameEnd;
+    } else {
+      this.frameInterval = 0;
+    }
+    if (this.frameIntervalEma === 0) {
+      this.frameIntervalEma = this.frameInterval;
+    } else {
+      this.frameIntervalEma = this.frameIntervalEma * (1 - this.frameIntervalEmaWeight) + this.frameInterval * this.frameIntervalEmaWeight;
+    }
+    const lastBatch = audio.subarray(audio.length - this.batcher.batchIntervalSamples);
+    const spectrograms = await this.spectrogram.run(audio);
+    const embedding = await this.embedding.getEmbeddingFromMelSpectrogramOutput(spectrograms);
+    const numFramesPerEmbedding = embedding.dims[0];
+    const maxEmbeddings = this.wakeWordEmbeddingFrames / numFramesPerEmbedding;
+    this.embeddingBufferArray.push(embedding);
+    if (this.embeddingBufferArray.length > maxEmbeddings) this.embeddingBufferArray.shift();
+    this.embeddingBuffer = await embeddingBufferArrayToEmbedding(this.embeddingBufferArray, numFramesPerEmbedding, this.embeddingDim);
+    const { isSpeaking, speechProbability, justStoppedSpeaking, justStartedSpeaking } = await this.vad.hasSpeechAudio(lastBatch);
+    if (!isSpeaking && this.embeddingBuffer && this.embeddingBuffer.data) {
+      const d = this.embeddingBuffer.data;
+      if (!this.embeddingMean || this.embeddingMean.length !== d.length) this.embeddingMean = Float32Array.from(d);
+      else for (let i = 0; i < d.length; i++) this.embeddingMean[i] += 0.02 * (d[i] - this.embeddingMean[i]);
+    }
+    if (justStartedSpeaking) this.speechStart();
+    if (justStoppedSpeaking) this.speechEnd();
+    if (isSpeaking && this.embeddingBuffer.dims[0] === this.wakeWordEmbeddingFrames && !this._wakeBusy) {
+      this._wakeBusy = true;
+      let wakeWordsCalled;
+      try {
+        wakeWordsCalled = await this.checkWakeWords();
+      } finally {
+        this._wakeBusy = false;
+      }
+      this.processed({
+        listening: true,
+        recording: this.recording,
+        speech: { probability: speechProbability, active: isSpeaking },
+        wakeWords: wakeWordsCalled,
+        // Live [16x96] embedding window (flattened) — what enrollment captures and
+        // what the voiceprint layer matches against. Present only while listening.
+        embedding: this.embeddingBuffer ? this.embeddingBuffer.data : null
+      });
+    } else {
+      this.processed({
+        listening: false,
+        recording: this.recording,
+        speech: { probability: speechProbability, active: isSpeaking },
+        wakeWords: Object.entries(this.wakeWords).reduce(
+          (carry, [name, model]) => {
+            carry[name] = {
+              probability: 0,
+              active: false
+            };
+            return carry;
+          },
+          {}
+        ),
+        embedding: this.embeddingBuffer ? this.embeddingBuffer.data : null
+      });
+    }
+    if (this.recording) {
+      if (this.audioBuffer === null) {
+        this.audioBuffer = new Float32Array(audio.length);
+        this.audioBuffer.set(audio);
+      } else {
+        const concatenated = new Float32Array(this.audioBuffer.length + lastBatch.length);
+        concatenated.set(this.audioBuffer);
+        concatenated.set(lastBatch, this.audioBuffer.length);
+        this.audioBuffer = concatenated;
+      }
+    }
+    this.frameEnd = (/* @__PURE__ */ new Date()).getTime();
+    this.frameTime = this.frameEnd - this.frameStart;
+    if (this.frameTimeEma === 0) {
+      this.frameTimeEma = this.frameTime;
+    } else {
+      this.frameTimeEma = this.frameTimeEma * (1 - this.frameTimeEmaWeight) + this.frameTime * this.frameTimeEmaWeight;
+    }
+  }
+};
+if (typeof window !== "undefined") {
+  window.HeyBuddy = HeyBuddy;
+}
+
+exports.HeyBuddy = HeyBuddy;
+//# sourceMappingURL=hey-buddy-CLUVAY2X.cjs.map
+//# sourceMappingURL=hey-buddy-CLUVAY2X.cjs.map