openwakeword-js 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,62 @@
+# openWakeWord-JS
+
+A high-accuracy, 100% logic-aligned JavaScript/TypeScript port of [openWakeWord](https://github.com/dscripka/openWakeWord). Designed for browser-first execution using ONNX Runtime Web, with Node.js support.
+
+## Credits & Acknowledgments
+This package is a JavaScript port of the excellent work by **David Scripka**. For the full Python implementation, training scripts, and model details, please visit the original repository:
+👉 **[Original openWakeWord Repository](https://github.com/dscripka/openWakeWord)**
+
+## Key Features
+- **Bit-Perfect Parity**: Matches the original Python implementation's Mel spectrogram transforms, sliding windows, and VAD gating logic.
+- **Privacy First**: Voice processing runs **entirely on the user's local machine** (browser/Node.js). No audio data is ever sent to a server.
+- **High Performance**: Leverages WebAssembly (WASM) with SIMD for hardware-accelerated inference.
+- **Customizable**: Load any openWakeWord ONNX models directly.
+
+## Installation
+
+```bash
+npm install @openwakeword/js onnxruntime-web
+```
+
+## Required Assets
+To run wake word detection, you need the following ONNX models (available in the original repo):
+1.  `melspectrogram.onnx`: Audio feature extractor.
+2.  `embedding_model.onnx`: Feature embedding generator.
+3.  **Your Wake Word Model**: (e.g., `alexa.onnx`, `hey_deepa.onnx`).
+
+### Browser Requirements
+When running in a browser, ensure you serve the ONNX Runtime WASM files or point to a CDN:
+```typescript
+const model = new Model({
+  // ...
+  wasmPaths: 'https://cdn.jsdelivr.net/npm/onnxruntime-web/dist/' 
+});
+```
+
+## Quick Start
+
+```typescript
+import { Model } from '@openwakeword/js';
+
+// 1. Initialize the model
+const model = new Model({
+  wakewordModels: ['./models/my_wakeword.onnx'],
+  melspectrogramModelPath: './models/melspectrogram.onnx',
+  embeddingModelPath: './models/embedding_model.onnx',
+  vadModelPath: './models/silero_vad.onnx', // Optional
+  vadThreshold: 0.5, // Optional
+  inferenceFramework: 'onnx'
+});
+
+await model.init();
+
+// 2. Feed audio chunks (16kHz, mono, Float32Array or Int16Array)
+// Recommended chunk size: 1280 samples (80ms)
+const audioChunk = ...; 
+const scores = await model.predict(audioChunk);
+
+console.log(scores); // { "my_wakeword": 0.82 }
+```
+
+## License
+Apache-2.0 (Matched with the original openWakeWord license)

package/dist/index.cjs

@@ -0,0 +1,277 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Model: () => Model
+});
+module.exports = __toCommonJS(index_exports);
+var ort = __toESM(require("onnxruntime-web"), 1);
+var Model = class {
+  constructor(options) {
+    this.options = options;
+    const runtime = ort.env ? ort : globalThis.ort;
+    if (runtime && options.wasmPaths) {
+      runtime.env.wasm.wasmPaths = options.wasmPaths;
+    }
+    this.melContextBuffer = new Float32Array(this.MEL_CONTEXT).fill(0);
+  }
+  melSession = null;
+  embeddingSession = null;
+  vadSession = null;
+  customSessions = /* @__PURE__ */ new Map();
+  // Buffers
+  melBuffer = [];
+  embeddingBuffers = /* @__PURE__ */ new Map();
+  predictionBuffers = /* @__PURE__ */ new Map();
+  vadBuffer = [];
+  rawAudioRemainder = new Float32Array(0);
+  melContextBuffer;
+  // Seeding history
+  noiseSeededEmbeddings = /* @__PURE__ */ new Map();
+  // Constants
+  CHUNK_SIZE = 1280;
+  MEL_CONTEXT = 480;
+  SAMPLE_RATE = 16e3;
+  MEL_BINS = 32;
+  FRAMES_PER_CHUNK = 8;
+  MEL_WINDOW_SIZE = 76;
+  EMBEDDING_WINDOW_SIZE = 24;
+  MAX_MEL_FRAMES = 970;
+  INITIAL_FRAMES_SUPPRESS = 5;
+  PREDICTION_BUFFER_MAX = 30;
+  // VAD State (Silero VAD)
+  vadStateH = new Float32Array(2 * 1 * 64).fill(0);
+  vadStateC = new Float32Array(2 * 1 * 64).fill(0);
+  isLoaded = false;
+  async init() {
+    try {
+      this.melSession = await ort.InferenceSession.create(this.options.melspectrogramModelPath);
+      this.embeddingSession = await ort.InferenceSession.create(this.options.embeddingModelPath);
+      if (this.options.vadModelPath && this.options.vadThreshold && this.options.vadThreshold > 0) {
+        this.vadSession = await ort.InferenceSession.create(this.options.vadModelPath);
+      }
+      this.melBuffer = Array(this.MEL_WINDOW_SIZE).fill(0).map(() => new Float32Array(this.MEL_BINS).fill(1));
+      const warmNoise = new Float32Array(this.SAMPLE_RATE * 4);
+      for (let i = 0; i < warmNoise.length; i++) warmNoise[i] = Math.random() * 2e3 - 1e3;
+      const tempMelContext = new Float32Array(this.MEL_CONTEXT).fill(0);
+      const generatedEmbeddings = [];
+      for (let i = 0; i <= warmNoise.length - this.CHUNK_SIZE; i += this.CHUNK_SIZE) {
+        const chunk = warmNoise.subarray(i, i + this.CHUNK_SIZE);
+        const melInput = new Float32Array(this.CHUNK_SIZE + this.MEL_CONTEXT);
+        melInput.set(tempMelContext);
+        melInput.set(chunk, this.MEL_CONTEXT);
+        tempMelContext.set(chunk.subarray(this.CHUNK_SIZE - this.MEL_CONTEXT));
+        const melOutput = await this.runMelSpectrogram(melInput);
+        for (let f = 0; f < this.FRAMES_PER_CHUNK; f++) {
+          const frame = new Float32Array(this.MEL_BINS);
+          for (let b = 0; b < this.MEL_BINS; b++) {
+            const idx = f * this.MEL_BINS + b;
+            frame[b] = melOutput[idx] / 10 + 2;
+          }
+          this.melBuffer.push(frame);
+        }
+        while (this.melBuffer.length > this.MAX_MEL_FRAMES) this.melBuffer.shift();
+        const emb = await this.runEmbeddingModel();
+        generatedEmbeddings.push(emb);
+      }
+      for (const modelPath of this.options.wakewordModels) {
+        const session = await ort.InferenceSession.create(modelPath);
+        const name = this.extractModelName(modelPath);
+        this.customSessions.set(name, session);
+        const history = generatedEmbeddings.slice(-this.EMBEDDING_WINDOW_SIZE).map((e) => new Float32Array(e));
+        this.noiseSeededEmbeddings.set(name, history);
+        this.embeddingBuffers.set(name, history.map((e) => new Float32Array(e)));
+        this.predictionBuffers.set(name, []);
+      }
+      this.isLoaded = true;
+      console.log("OpenWakeWord models loaded and bit-perfectly aligned");
+    } catch (error) {
+      console.error("Failed to initialize OpenWakeWord models:", error);
+      throw error;
+    }
+  }
+  async predict(audio) {
+    if (!this.isLoaded) throw new Error("Model not initialized");
+    let pcmAudio;
+    if (audio instanceof Int16Array) {
+      pcmAudio = new Float32Array(audio.length);
+      for (let i = 0; i < audio.length; i++) pcmAudio[i] = audio[i];
+    } else {
+      let max = 0;
+      for (let i = 0; i < Math.min(audio.length, 1e3); i++) {
+        const abs = Math.abs(audio[i]);
+        if (abs > max) max = abs;
+      }
+      if (max <= 1) {
+        pcmAudio = new Float32Array(audio.length);
+        for (let i = 0; i < audio.length; i++) pcmAudio[i] = audio[i] * 32768;
+      } else {
+        pcmAudio = audio;
+      }
+    }
+    let combinedAudio = new Float32Array(this.rawAudioRemainder.length + pcmAudio.length);
+    combinedAudio.set(this.rawAudioRemainder);
+    combinedAudio.set(pcmAudio, this.rawAudioRemainder.length);
+    const scores = {};
+    for (const name of this.customSessions.keys()) scores[name] = 0;
+    let offset = 0;
+    while (offset + this.CHUNK_SIZE <= combinedAudio.length) {
+      const chunk = combinedAudio.subarray(offset, offset + this.CHUNK_SIZE);
+      offset += this.CHUNK_SIZE;
+      const melInput = new Float32Array(this.CHUNK_SIZE + this.MEL_CONTEXT);
+      melInput.set(this.melContextBuffer);
+      melInput.set(chunk, this.MEL_CONTEXT);
+      this.melContextBuffer.set(chunk.subarray(this.CHUNK_SIZE - this.MEL_CONTEXT));
+      if (this.vadSession && this.options.vadThreshold) {
+        const vadScore = await this.runVAD(chunk);
+        this.vadBuffer.push(vadScore);
+        while (this.vadBuffer.length > 30) this.vadBuffer.shift();
+      }
+      const melOutput = await this.runMelSpectrogram(melInput);
+      for (let f = 0; f < this.FRAMES_PER_CHUNK; f++) {
+        const frame = new Float32Array(this.MEL_BINS);
+        for (let b = 0; b < this.MEL_BINS; b++) {
+          const idx = f * this.MEL_BINS + b;
+          frame[b] = melOutput[idx] / 10 + 2;
+        }
+        this.melBuffer.push(frame);
+      }
+      while (this.melBuffer.length > this.MAX_MEL_FRAMES) this.melBuffer.shift();
+      const embedding = await this.runEmbeddingModel();
+      for (const [name, session] of this.customSessions.entries()) {
+        const embBuf = this.embeddingBuffers.get(name);
+        embBuf.shift();
+        embBuf.push(embedding);
+        let score = await this.runClassifier(name, session);
+        if (this.vadSession && this.options.vadThreshold) {
+          const window = this.vadBuffer.slice(-7, -4);
+          const maxVAD = window.length > 0 ? Math.max(...window) : 0;
+          if (maxVAD < this.options.vadThreshold) score = 0;
+        }
+        const predBuf = this.predictionBuffers.get(name);
+        predBuf.push(score);
+        while (predBuf.length > this.PREDICTION_BUFFER_MAX) predBuf.shift();
+        if (predBuf.length < this.INITIAL_FRAMES_SUPPRESS) {
+          score = 0;
+        } else if (this.options.patience?.[name] || this.options.debounceTime && this.options.debounceTime > 0) {
+          const threshold = this.options.thresholds?.[name] ?? 0.5;
+          if (this.options.patience?.[name]) {
+            const p = this.options.patience[name];
+            const recentScores = predBuf.slice(-p);
+            const countAbove = recentScores.filter((s) => s >= threshold).length;
+            if (countAbove < p) score = 0;
+          } else if (this.options.debounceTime) {
+            const framesToWait = Math.ceil(this.options.debounceTime / 0.08);
+            const recentScores = predBuf.slice(-framesToWait - 1, -1);
+            const alreadyTriggered = recentScores.some((s) => s >= threshold);
+            if (score >= threshold && alreadyTriggered) score = 0;
+          }
+        }
+        scores[name] = Math.max(scores[name], score);
+      }
+    }
+    this.rawAudioRemainder = combinedAudio.slice(offset);
+    return scores;
+  }
+  async runMelSpectrogram(input) {
+    const inputTensor = new ort.Tensor("float32", input, [1, input.length]);
+    const results = await this.melSession.run({ [this.melSession.inputNames[0]]: inputTensor });
+    return results[this.melSession.outputNames[0]].data;
+  }
+  async runEmbeddingModel() {
+    const windowData = new Float32Array(this.MEL_WINDOW_SIZE * this.MEL_BINS);
+    const startIdx = this.melBuffer.length - this.MEL_WINDOW_SIZE;
+    for (let t = 0; t < this.MEL_WINDOW_SIZE; t++) {
+      windowData.set(this.melBuffer[startIdx + t], t * this.MEL_BINS);
+    }
+    const windowTensor = new ort.Tensor("float32", windowData, [1, this.MEL_WINDOW_SIZE, this.MEL_BINS, 1]);
+    const results = await this.embeddingSession.run({ [this.embeddingSession.inputNames[0]]: windowTensor });
+    const output = results[this.embeddingSession.outputNames[0]].data;
+    const embedding = new Float32Array(96);
+    for (let i = 0; i < 96; i++) {
+      let v = output[i] ?? 0;
+      if (isNaN(v) || !isFinite(v)) v = 0;
+      embedding[i] = v;
+    }
+    return embedding;
+  }
+  async runClassifier(name, session) {
+    const embBuf = this.embeddingBuffers.get(name);
+    const predData = new Float32Array(this.EMBEDDING_WINDOW_SIZE * 96);
+    for (let t = 0; t < this.EMBEDDING_WINDOW_SIZE; t++) predData.set(embBuf[t], t * 96);
+    const predTensor = new ort.Tensor("float32", predData, [1, this.EMBEDDING_WINDOW_SIZE, 96]);
+    const results = await session.run({ [session.inputNames[0]]: predTensor });
+    return results[session.outputNames[0]].data[0];
+  }
+  async runVAD(chunk) {
+    const normalized = new Float32Array(chunk.length);
+    for (let i = 0; i < chunk.length; i++) normalized[i] = chunk[i] / 32768;
+    const srTensor = new ort.Tensor("int64", BigInt64Array.from([BigInt(this.SAMPLE_RATE)]), [1]);
+    const hTensor = new ort.Tensor("float32", this.vadStateH, [2, 1, 64]);
+    const cTensor = new ort.Tensor("float32", this.vadStateC, [2, 1, 64]);
+    const inputTensor = new ort.Tensor("float32", normalized, [1, chunk.length]);
+    const feeds = {
+      [this.vadSession.inputNames[0]]: inputTensor,
+      [this.vadSession.inputNames[1]]: srTensor,
+      [this.vadSession.inputNames[2]]: hTensor,
+      [this.vadSession.inputNames[3]]: cTensor
+    };
+    const results = await this.vadSession.run(feeds);
+    this.vadStateH = results[this.vadSession.outputNames[1]].data;
+    this.vadStateC = results[this.vadSession.outputNames[2]].data;
+    return results[this.vadSession.outputNames[0]].data[0];
+  }
+  extractModelName(path) {
+    const base = path.split("/").pop() || path;
+    return base.replace(".onnx", "").replace(".tflite", "");
+  }
+  reset() {
+    this.melBuffer = Array(this.MEL_WINDOW_SIZE).fill(0).map(() => new Float32Array(this.MEL_BINS).fill(1));
+    this.rawAudioRemainder = new Float32Array(0);
+    this.melContextBuffer.fill(0);
+    this.vadBuffer = [];
+    this.vadStateH.fill(0);
+    this.vadStateC.fill(0);
+    for (const name of this.embeddingBuffers.keys()) {
+      this.predictionBuffers.set(name, []);
+      const seeded = this.noiseSeededEmbeddings.get(name);
+      if (seeded) {
+        this.embeddingBuffers.set(name, seeded.map((e) => new Float32Array(e)));
+      } else {
+        this.embeddingBuffers.set(name, Array(this.EMBEDDING_WINDOW_SIZE).fill(0).map(() => new Float32Array(96).fill(0)));
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Model
+});

package/dist/index.d.cts

@@ -0,0 +1,70 @@
+/**
+ * Configuration options for the OpenWakeWord model.
+ */
+interface ModelOptions {
+    /** Paths or URLs to the custom wake word ONNX models */
+    wakewordModels: string[];
+    /** Path or URL to the mel spectrogram ONNX model */
+    melspectrogramModelPath: string;
+    /** Path or URL to the embedding ONNX model */
+    embeddingModelPath: string;
+    /** Path or URL to the Silero VAD ONNX model (optional) */
+    vadModelPath?: string;
+    /** VAD threshold (0-1). 0 disables VAD. */
+    vadThreshold?: number;
+    /** Patience: How many consecutive frames above threshold before trigger */
+    patience?: Record<string, number>;
+    /** Thresholds for each model (required if patience or debounce is used) */
+    thresholds?: Record<string, number>;
+    /** Minimum time between detections in seconds */
+    debounceTime?: number;
+    /** Inference framework (only 'onnx' supported in this port) */
+    inferenceFramework: 'onnx';
+    /** Path to WASM files for onnxruntime-web if needed */
+    wasmPaths?: string;
+}
+/**
+ * Result of a prediction.
+ */
+type PredictionResult = Record<string, number>;
+/**
+ * OpenWakeWord Core Implementation in TypeScript.
+ */
+declare class Model {
+    private options;
+    private melSession;
+    private embeddingSession;
+    private vadSession;
+    private customSessions;
+    private melBuffer;
+    private embeddingBuffers;
+    private predictionBuffers;
+    private vadBuffer;
+    private rawAudioRemainder;
+    private melContextBuffer;
+    private noiseSeededEmbeddings;
+    private readonly CHUNK_SIZE;
+    private readonly MEL_CONTEXT;
+    private readonly SAMPLE_RATE;
+    private readonly MEL_BINS;
+    private readonly FRAMES_PER_CHUNK;
+    private readonly MEL_WINDOW_SIZE;
+    private readonly EMBEDDING_WINDOW_SIZE;
+    private readonly MAX_MEL_FRAMES;
+    private readonly INITIAL_FRAMES_SUPPRESS;
+    private readonly PREDICTION_BUFFER_MAX;
+    private vadStateH;
+    private vadStateC;
+    private isLoaded;
+    constructor(options: ModelOptions);
+    init(): Promise<void>;
+    predict(audio: Float32Array | Int16Array): Promise<PredictionResult>;
+    private runMelSpectrogram;
+    private runEmbeddingModel;
+    private runClassifier;
+    private runVAD;
+    private extractModelName;
+    reset(): void;
+}
+
+export { Model, type ModelOptions, type PredictionResult };

package/dist/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Configuration options for the OpenWakeWord model.
+ */
+interface ModelOptions {
+    /** Paths or URLs to the custom wake word ONNX models */
+    wakewordModels: string[];
+    /** Path or URL to the mel spectrogram ONNX model */
+    melspectrogramModelPath: string;
+    /** Path or URL to the embedding ONNX model */
+    embeddingModelPath: string;
+    /** Path or URL to the Silero VAD ONNX model (optional) */
+    vadModelPath?: string;
+    /** VAD threshold (0-1). 0 disables VAD. */
+    vadThreshold?: number;
+    /** Patience: How many consecutive frames above threshold before trigger */
+    patience?: Record<string, number>;
+    /** Thresholds for each model (required if patience or debounce is used) */
+    thresholds?: Record<string, number>;
+    /** Minimum time between detections in seconds */
+    debounceTime?: number;
+    /** Inference framework (only 'onnx' supported in this port) */
+    inferenceFramework: 'onnx';
+    /** Path to WASM files for onnxruntime-web if needed */
+    wasmPaths?: string;
+}
+/**
+ * Result of a prediction.
+ */
+type PredictionResult = Record<string, number>;
+/**
+ * OpenWakeWord Core Implementation in TypeScript.
+ */
+declare class Model {
+    private options;
+    private melSession;
+    private embeddingSession;
+    private vadSession;
+    private customSessions;
+    private melBuffer;
+    private embeddingBuffers;
+    private predictionBuffers;
+    private vadBuffer;
+    private rawAudioRemainder;
+    private melContextBuffer;
+    private noiseSeededEmbeddings;
+    private readonly CHUNK_SIZE;
+    private readonly MEL_CONTEXT;
+    private readonly SAMPLE_RATE;
+    private readonly MEL_BINS;
+    private readonly FRAMES_PER_CHUNK;
+    private readonly MEL_WINDOW_SIZE;
+    private readonly EMBEDDING_WINDOW_SIZE;
+    private readonly MAX_MEL_FRAMES;
+    private readonly INITIAL_FRAMES_SUPPRESS;
+    private readonly PREDICTION_BUFFER_MAX;
+    private vadStateH;
+    private vadStateC;
+    private isLoaded;
+    constructor(options: ModelOptions);
+    init(): Promise<void>;
+    predict(audio: Float32Array | Int16Array): Promise<PredictionResult>;
+    private runMelSpectrogram;
+    private runEmbeddingModel;
+    private runClassifier;
+    private runVAD;
+    private extractModelName;
+    reset(): void;
+}
+
+export { Model, type ModelOptions, type PredictionResult };

package/dist/index.js

@@ -0,0 +1,242 @@
+// src/index.ts
+import * as ort from "onnxruntime-web";
+var Model = class {
+  constructor(options) {
+    this.options = options;
+    const runtime = ort.env ? ort : globalThis.ort;
+    if (runtime && options.wasmPaths) {
+      runtime.env.wasm.wasmPaths = options.wasmPaths;
+    }
+    this.melContextBuffer = new Float32Array(this.MEL_CONTEXT).fill(0);
+  }
+  melSession = null;
+  embeddingSession = null;
+  vadSession = null;
+  customSessions = /* @__PURE__ */ new Map();
+  // Buffers
+  melBuffer = [];
+  embeddingBuffers = /* @__PURE__ */ new Map();
+  predictionBuffers = /* @__PURE__ */ new Map();
+  vadBuffer = [];
+  rawAudioRemainder = new Float32Array(0);
+  melContextBuffer;
+  // Seeding history
+  noiseSeededEmbeddings = /* @__PURE__ */ new Map();
+  // Constants
+  CHUNK_SIZE = 1280;
+  MEL_CONTEXT = 480;
+  SAMPLE_RATE = 16e3;
+  MEL_BINS = 32;
+  FRAMES_PER_CHUNK = 8;
+  MEL_WINDOW_SIZE = 76;
+  EMBEDDING_WINDOW_SIZE = 24;
+  MAX_MEL_FRAMES = 970;
+  INITIAL_FRAMES_SUPPRESS = 5;
+  PREDICTION_BUFFER_MAX = 30;
+  // VAD State (Silero VAD)
+  vadStateH = new Float32Array(2 * 1 * 64).fill(0);
+  vadStateC = new Float32Array(2 * 1 * 64).fill(0);
+  isLoaded = false;
+  async init() {
+    try {
+      this.melSession = await ort.InferenceSession.create(this.options.melspectrogramModelPath);
+      this.embeddingSession = await ort.InferenceSession.create(this.options.embeddingModelPath);
+      if (this.options.vadModelPath && this.options.vadThreshold && this.options.vadThreshold > 0) {
+        this.vadSession = await ort.InferenceSession.create(this.options.vadModelPath);
+      }
+      this.melBuffer = Array(this.MEL_WINDOW_SIZE).fill(0).map(() => new Float32Array(this.MEL_BINS).fill(1));
+      const warmNoise = new Float32Array(this.SAMPLE_RATE * 4);
+      for (let i = 0; i < warmNoise.length; i++) warmNoise[i] = Math.random() * 2e3 - 1e3;
+      const tempMelContext = new Float32Array(this.MEL_CONTEXT).fill(0);
+      const generatedEmbeddings = [];
+      for (let i = 0; i <= warmNoise.length - this.CHUNK_SIZE; i += this.CHUNK_SIZE) {
+        const chunk = warmNoise.subarray(i, i + this.CHUNK_SIZE);
+        const melInput = new Float32Array(this.CHUNK_SIZE + this.MEL_CONTEXT);
+        melInput.set(tempMelContext);
+        melInput.set(chunk, this.MEL_CONTEXT);
+        tempMelContext.set(chunk.subarray(this.CHUNK_SIZE - this.MEL_CONTEXT));
+        const melOutput = await this.runMelSpectrogram(melInput);
+        for (let f = 0; f < this.FRAMES_PER_CHUNK; f++) {
+          const frame = new Float32Array(this.MEL_BINS);
+          for (let b = 0; b < this.MEL_BINS; b++) {
+            const idx = f * this.MEL_BINS + b;
+            frame[b] = melOutput[idx] / 10 + 2;
+          }
+          this.melBuffer.push(frame);
+        }
+        while (this.melBuffer.length > this.MAX_MEL_FRAMES) this.melBuffer.shift();
+        const emb = await this.runEmbeddingModel();
+        generatedEmbeddings.push(emb);
+      }
+      for (const modelPath of this.options.wakewordModels) {
+        const session = await ort.InferenceSession.create(modelPath);
+        const name = this.extractModelName(modelPath);
+        this.customSessions.set(name, session);
+        const history = generatedEmbeddings.slice(-this.EMBEDDING_WINDOW_SIZE).map((e) => new Float32Array(e));
+        this.noiseSeededEmbeddings.set(name, history);
+        this.embeddingBuffers.set(name, history.map((e) => new Float32Array(e)));
+        this.predictionBuffers.set(name, []);
+      }
+      this.isLoaded = true;
+      console.log("OpenWakeWord models loaded and bit-perfectly aligned");
+    } catch (error) {
+      console.error("Failed to initialize OpenWakeWord models:", error);
+      throw error;
+    }
+  }
+  async predict(audio) {
+    if (!this.isLoaded) throw new Error("Model not initialized");
+    let pcmAudio;
+    if (audio instanceof Int16Array) {
+      pcmAudio = new Float32Array(audio.length);
+      for (let i = 0; i < audio.length; i++) pcmAudio[i] = audio[i];
+    } else {
+      let max = 0;
+      for (let i = 0; i < Math.min(audio.length, 1e3); i++) {
+        const abs = Math.abs(audio[i]);
+        if (abs > max) max = abs;
+      }
+      if (max <= 1) {
+        pcmAudio = new Float32Array(audio.length);
+        for (let i = 0; i < audio.length; i++) pcmAudio[i] = audio[i] * 32768;
+      } else {
+        pcmAudio = audio;
+      }
+    }
+    let combinedAudio = new Float32Array(this.rawAudioRemainder.length + pcmAudio.length);
+    combinedAudio.set(this.rawAudioRemainder);
+    combinedAudio.set(pcmAudio, this.rawAudioRemainder.length);
+    const scores = {};
+    for (const name of this.customSessions.keys()) scores[name] = 0;
+    let offset = 0;
+    while (offset + this.CHUNK_SIZE <= combinedAudio.length) {
+      const chunk = combinedAudio.subarray(offset, offset + this.CHUNK_SIZE);
+      offset += this.CHUNK_SIZE;
+      const melInput = new Float32Array(this.CHUNK_SIZE + this.MEL_CONTEXT);
+      melInput.set(this.melContextBuffer);
+      melInput.set(chunk, this.MEL_CONTEXT);
+      this.melContextBuffer.set(chunk.subarray(this.CHUNK_SIZE - this.MEL_CONTEXT));
+      if (this.vadSession && this.options.vadThreshold) {
+        const vadScore = await this.runVAD(chunk);
+        this.vadBuffer.push(vadScore);
+        while (this.vadBuffer.length > 30) this.vadBuffer.shift();
+      }
+      const melOutput = await this.runMelSpectrogram(melInput);
+      for (let f = 0; f < this.FRAMES_PER_CHUNK; f++) {
+        const frame = new Float32Array(this.MEL_BINS);
+        for (let b = 0; b < this.MEL_BINS; b++) {
+          const idx = f * this.MEL_BINS + b;
+          frame[b] = melOutput[idx] / 10 + 2;
+        }
+        this.melBuffer.push(frame);
+      }
+      while (this.melBuffer.length > this.MAX_MEL_FRAMES) this.melBuffer.shift();
+      const embedding = await this.runEmbeddingModel();
+      for (const [name, session] of this.customSessions.entries()) {
+        const embBuf = this.embeddingBuffers.get(name);
+        embBuf.shift();
+        embBuf.push(embedding);
+        let score = await this.runClassifier(name, session);
+        if (this.vadSession && this.options.vadThreshold) {
+          const window = this.vadBuffer.slice(-7, -4);
+          const maxVAD = window.length > 0 ? Math.max(...window) : 0;
+          if (maxVAD < this.options.vadThreshold) score = 0;
+        }
+        const predBuf = this.predictionBuffers.get(name);
+        predBuf.push(score);
+        while (predBuf.length > this.PREDICTION_BUFFER_MAX) predBuf.shift();
+        if (predBuf.length < this.INITIAL_FRAMES_SUPPRESS) {
+          score = 0;
+        } else if (this.options.patience?.[name] || this.options.debounceTime && this.options.debounceTime > 0) {
+          const threshold = this.options.thresholds?.[name] ?? 0.5;
+          if (this.options.patience?.[name]) {
+            const p = this.options.patience[name];
+            const recentScores = predBuf.slice(-p);
+            const countAbove = recentScores.filter((s) => s >= threshold).length;
+            if (countAbove < p) score = 0;
+          } else if (this.options.debounceTime) {
+            const framesToWait = Math.ceil(this.options.debounceTime / 0.08);
+            const recentScores = predBuf.slice(-framesToWait - 1, -1);
+            const alreadyTriggered = recentScores.some((s) => s >= threshold);
+            if (score >= threshold && alreadyTriggered) score = 0;
+          }
+        }
+        scores[name] = Math.max(scores[name], score);
+      }
+    }
+    this.rawAudioRemainder = combinedAudio.slice(offset);
+    return scores;
+  }
+  async runMelSpectrogram(input) {
+    const inputTensor = new ort.Tensor("float32", input, [1, input.length]);
+    const results = await this.melSession.run({ [this.melSession.inputNames[0]]: inputTensor });
+    return results[this.melSession.outputNames[0]].data;
+  }
+  async runEmbeddingModel() {
+    const windowData = new Float32Array(this.MEL_WINDOW_SIZE * this.MEL_BINS);
+    const startIdx = this.melBuffer.length - this.MEL_WINDOW_SIZE;
+    for (let t = 0; t < this.MEL_WINDOW_SIZE; t++) {
+      windowData.set(this.melBuffer[startIdx + t], t * this.MEL_BINS);
+    }
+    const windowTensor = new ort.Tensor("float32", windowData, [1, this.MEL_WINDOW_SIZE, this.MEL_BINS, 1]);
+    const results = await this.embeddingSession.run({ [this.embeddingSession.inputNames[0]]: windowTensor });
+    const output = results[this.embeddingSession.outputNames[0]].data;
+    const embedding = new Float32Array(96);
+    for (let i = 0; i < 96; i++) {
+      let v = output[i] ?? 0;
+      if (isNaN(v) || !isFinite(v)) v = 0;
+      embedding[i] = v;
+    }
+    return embedding;
+  }
+  async runClassifier(name, session) {
+    const embBuf = this.embeddingBuffers.get(name);
+    const predData = new Float32Array(this.EMBEDDING_WINDOW_SIZE * 96);
+    for (let t = 0; t < this.EMBEDDING_WINDOW_SIZE; t++) predData.set(embBuf[t], t * 96);
+    const predTensor = new ort.Tensor("float32", predData, [1, this.EMBEDDING_WINDOW_SIZE, 96]);
+    const results = await session.run({ [session.inputNames[0]]: predTensor });
+    return results[session.outputNames[0]].data[0];
+  }
+  async runVAD(chunk) {
+    const normalized = new Float32Array(chunk.length);
+    for (let i = 0; i < chunk.length; i++) normalized[i] = chunk[i] / 32768;
+    const srTensor = new ort.Tensor("int64", BigInt64Array.from([BigInt(this.SAMPLE_RATE)]), [1]);
+    const hTensor = new ort.Tensor("float32", this.vadStateH, [2, 1, 64]);
+    const cTensor = new ort.Tensor("float32", this.vadStateC, [2, 1, 64]);
+    const inputTensor = new ort.Tensor("float32", normalized, [1, chunk.length]);
+    const feeds = {
+      [this.vadSession.inputNames[0]]: inputTensor,
+      [this.vadSession.inputNames[1]]: srTensor,
+      [this.vadSession.inputNames[2]]: hTensor,
+      [this.vadSession.inputNames[3]]: cTensor
+    };
+    const results = await this.vadSession.run(feeds);
+    this.vadStateH = results[this.vadSession.outputNames[1]].data;
+    this.vadStateC = results[this.vadSession.outputNames[2]].data;
+    return results[this.vadSession.outputNames[0]].data[0];
+  }
+  extractModelName(path) {
+    const base = path.split("/").pop() || path;
+    return base.replace(".onnx", "").replace(".tflite", "");
+  }
+  reset() {
+    this.melBuffer = Array(this.MEL_WINDOW_SIZE).fill(0).map(() => new Float32Array(this.MEL_BINS).fill(1));
+    this.rawAudioRemainder = new Float32Array(0);
+    this.melContextBuffer.fill(0);
+    this.vadBuffer = [];
+    this.vadStateH.fill(0);
+    this.vadStateC.fill(0);
+    for (const name of this.embeddingBuffers.keys()) {
+      this.predictionBuffers.set(name, []);
+      const seeded = this.noiseSeededEmbeddings.get(name);
+      if (seeded) {
+        this.embeddingBuffers.set(name, seeded.map((e) => new Float32Array(e)));
+      } else {
+        this.embeddingBuffers.set(name, Array(this.EMBEDDING_WINDOW_SIZE).fill(0).map(() => new Float32Array(96).fill(0)));
+      }
+    }
+  }
+};
+export {
+  Model
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "openwakeword-js",
+    "version": "0.1.0",
+    "description": "Port of openWakeWord to JavaScript/TypeScript using ONNX Runtime",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "files": [
+        "dist",
+        "src",
+        "README.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "onnxruntime-web": "^1.19.0"
+    },
+    "devDependencies": {
+        "typescript": "^5.0.0",
+        "tsup": "^8.0.0"
+    },
+    "scripts": {
+        "build": "tsup src/index.ts --format esm,cjs --dts",
+        "dev": "tsup src/index.ts --format esm,cjs --watch --dts"
+    },
+    "keywords": [
+        "wakeword",
+        "keyword detection",
+        "audio",
+        "ml",
+        "onnx",
+        "javascript",
+        "browser"
+    ],
+    "homepage": "https://github.com/dscripka/openWakeWord",
+    "bugs": {
+        "url": "https://github.com/dscripka/openWakeWord/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Firojpaudel/OpenWakeWord_npm_porting.git"
+    },
+    "author": "David Scripka (Original), Firojpaudel (JS Port)",
+    "license": "Apache-2.0"
+}

package/src/index.ts

@@ -0,0 +1,316 @@
+import * as ort from 'onnxruntime-web';
+
+/**
+ * Configuration options for the OpenWakeWord model.
+ */
+export interface ModelOptions {
+    /** Paths or URLs to the custom wake word ONNX models */
+    wakewordModels: string[];
+    /** Path or URL to the mel spectrogram ONNX model */
+    melspectrogramModelPath: string;
+    /** Path or URL to the embedding ONNX model */
+    embeddingModelPath: string;
+    /** Path or URL to the Silero VAD ONNX model (optional) */
+    vadModelPath?: string;
+    /** VAD threshold (0-1). 0 disables VAD. */
+    vadThreshold?: number;
+    /** Patience: How many consecutive frames above threshold before trigger */
+    patience?: Record<string, number>;
+    /** Thresholds for each model (required if patience or debounce is used) */
+    thresholds?: Record<string, number>;
+    /** Minimum time between detections in seconds */
+    debounceTime?: number;
+    /** Inference framework (only 'onnx' supported in this port) */
+    inferenceFramework: 'onnx';
+    /** Path to WASM files for onnxruntime-web if needed */
+    wasmPaths?: string;
+}
+
+/**
+ * Result of a prediction.
+ */
+export type PredictionResult = Record<string, number>;
+
+/**
+ * OpenWakeWord Core Implementation in TypeScript.
+ */
+export class Model {
+    private melSession: ort.InferenceSession | null = null;
+    private embeddingSession: ort.InferenceSession | null = null;
+    private vadSession: ort.InferenceSession | null = null;
+    private customSessions: Map<string, ort.InferenceSession> = new Map();
+
+    // Buffers
+    private melBuffer: Float32Array[] = [];
+    private embeddingBuffers: Map<string, Float32Array[]> = new Map();
+    private predictionBuffers: Map<string, number[]> = new Map();
+    private vadBuffer: number[] = [];
+    private rawAudioRemainder: Float32Array = new Float32Array(0);
+    private melContextBuffer: Float32Array;
+
+    // Seeding history
+    private noiseSeededEmbeddings: Map<string, Float32Array[]> = new Map();
+
+    // Constants
+    private readonly CHUNK_SIZE = 1280;
+    private readonly MEL_CONTEXT = 480;
+    private readonly SAMPLE_RATE = 16000;
+    private readonly MEL_BINS = 32;
+    private readonly FRAMES_PER_CHUNK = 8;
+    private readonly MEL_WINDOW_SIZE = 76;
+    private readonly EMBEDDING_WINDOW_SIZE = 24;
+    private readonly MAX_MEL_FRAMES = 970;
+    private readonly INITIAL_FRAMES_SUPPRESS = 5;
+    private readonly PREDICTION_BUFFER_MAX = 30;
+
+    // VAD State (Silero VAD)
+    private vadStateH = new Float32Array(2 * 1 * 64).fill(0);
+    private vadStateC = new Float32Array(2 * 1 * 64).fill(0);
+
+    private isLoaded = false;
+
+    constructor(private options: ModelOptions) {
+        // Handle environments where 'ort' might be a global (some browser setups)
+        const runtime = (ort as any).env ? ort : (globalThis as any).ort;
+        if (runtime && options.wasmPaths) {
+            runtime.env.wasm.wasmPaths = options.wasmPaths;
+        }
+        this.melContextBuffer = new Float32Array(this.MEL_CONTEXT).fill(0);
+    }
+
+    async init() {
+        try {
+            this.melSession = await ort.InferenceSession.create(this.options.melspectrogramModelPath);
+            this.embeddingSession = await ort.InferenceSession.create(this.options.embeddingModelPath);
+
+            if (this.options.vadModelPath && this.options.vadThreshold && this.options.vadThreshold > 0) {
+                this.vadSession = await ort.InferenceSession.create(this.options.vadModelPath);
+            }
+
+            // 1. Initialize Mel buffer with ones as in Python
+            this.melBuffer = Array(this.MEL_WINDOW_SIZE).fill(0).map(() => new Float32Array(this.MEL_BINS).fill(1.0));
+
+            // 2. Generate noise-seeded history for parity
+            const warmNoise = new Float32Array(this.SAMPLE_RATE * 4);
+            for (let i = 0; i < warmNoise.length; i++) warmNoise[i] = (Math.random() * 2000 - 1000);
+
+            const tempMelContext = new Float32Array(this.MEL_CONTEXT).fill(0);
+            const generatedEmbeddings: Float32Array[] = [];
+
+            for (let i = 0; i <= warmNoise.length - this.CHUNK_SIZE; i += this.CHUNK_SIZE) {
+                const chunk = warmNoise.subarray(i, i + this.CHUNK_SIZE);
+                const melInput = new Float32Array(this.CHUNK_SIZE + this.MEL_CONTEXT);
+                melInput.set(tempMelContext);
+                melInput.set(chunk, this.MEL_CONTEXT);
+                tempMelContext.set(chunk.subarray(this.CHUNK_SIZE - this.MEL_CONTEXT));
+
+                const melOutput = await this.runMelSpectrogram(melInput);
+                for (let f = 0; f < this.FRAMES_PER_CHUNK; f++) {
+                    const frame = new Float32Array(this.MEL_BINS);
+                    for (let b = 0; b < this.MEL_BINS; b++) {
+                        const idx = f * this.MEL_BINS + b;
+                        frame[b] = melOutput[idx] / 10.0 + 2.0;
+                    }
+                    this.melBuffer.push(frame);
+                }
+                while (this.melBuffer.length > this.MAX_MEL_FRAMES) this.melBuffer.shift();
+
+                const emb = await this.runEmbeddingModel();
+                generatedEmbeddings.push(emb);
+            }
+
+            for (const modelPath of this.options.wakewordModels) {
+                const session = await ort.InferenceSession.create(modelPath);
+                const name = this.extractModelName(modelPath);
+                this.customSessions.set(name, session);
+
+                // Store seeded history to be used during initial prediction and resets
+                const history = generatedEmbeddings.slice(-this.EMBEDDING_WINDOW_SIZE).map(e => new Float32Array(e));
+                this.noiseSeededEmbeddings.set(name, history);
+                this.embeddingBuffers.set(name, history.map(e => new Float32Array(e)));
+                this.predictionBuffers.set(name, []);
+            }
+
+            // Final sync: don't call reset() here as it would wipe what we just did
+            this.isLoaded = true;
+            console.log('OpenWakeWord models loaded and bit-perfectly aligned');
+        } catch (error) {
+            console.error('Failed to initialize OpenWakeWord models:', error);
+            throw error;
+        }
+    }
+
+    async predict(audio: Float32Array | Int16Array): Promise<PredictionResult> {
+        if (!this.isLoaded) throw new Error('Model not initialized');
+
+        let pcmAudio: Float32Array;
+        if (audio instanceof Int16Array) {
+            pcmAudio = new Float32Array(audio.length);
+            for (let i = 0; i < audio.length; i++) pcmAudio[i] = audio[i];
+        } else {
+            let max = 0;
+            for (let i = 0; i < Math.min(audio.length, 1000); i++) {
+                const abs = Math.abs(audio[i]);
+                if (abs > max) max = abs;
+            }
+            if (max <= 1.0) {
+                pcmAudio = new Float32Array(audio.length);
+                for (let i = 0; i < audio.length; i++) pcmAudio[i] = audio[i] * 32768.0;
+            } else {
+                pcmAudio = audio;
+            }
+        }
+
+        let combinedAudio = new Float32Array(this.rawAudioRemainder.length + pcmAudio.length);
+        combinedAudio.set(this.rawAudioRemainder);
+        combinedAudio.set(pcmAudio, this.rawAudioRemainder.length);
+
+        const scores: PredictionResult = {};
+        for (const name of this.customSessions.keys()) scores[name] = 0.0;
+
+        let offset = 0;
+        while (offset + this.CHUNK_SIZE <= combinedAudio.length) {
+            const chunk = combinedAudio.subarray(offset, offset + this.CHUNK_SIZE);
+            offset += this.CHUNK_SIZE;
+
+            // PRECISE SLIDING WINDOW: 1280 new samples + 480 context samples
+            const melInput = new Float32Array(this.CHUNK_SIZE + this.MEL_CONTEXT);
+            melInput.set(this.melContextBuffer);
+            melInput.set(chunk, this.MEL_CONTEXT);
+            this.melContextBuffer.set(chunk.subarray(this.CHUNK_SIZE - this.MEL_CONTEXT));
+
+            if (this.vadSession && this.options.vadThreshold) {
+                const vadScore = await this.runVAD(chunk);
+                this.vadBuffer.push(vadScore);
+                while (this.vadBuffer.length > 30) this.vadBuffer.shift();
+            }
+
+            const melOutput = await this.runMelSpectrogram(melInput);
+            for (let f = 0; f < this.FRAMES_PER_CHUNK; f++) {
+                const frame = new Float32Array(this.MEL_BINS);
+                for (let b = 0; b < this.MEL_BINS; b++) {
+                    const idx = f * this.MEL_BINS + b;
+                    frame[b] = melOutput[idx] / 10.0 + 2.0;
+                }
+                this.melBuffer.push(frame);
+            }
+            while (this.melBuffer.length > this.MAX_MEL_FRAMES) this.melBuffer.shift();
+
+            const embedding = await this.runEmbeddingModel();
+            for (const [name, session] of this.customSessions.entries()) {
+                const embBuf = this.embeddingBuffers.get(name)!;
+                embBuf.shift();
+                embBuf.push(embedding);
+
+                let score = await this.runClassifier(name, session);
+
+                if (this.vadSession && this.options.vadThreshold) {
+                    const window = this.vadBuffer.slice(-7, -4);
+                    const maxVAD = window.length > 0 ? Math.max(...window) : 0;
+                    if (maxVAD < this.options.vadThreshold) score = 0.0;
+                }
+
+                const predBuf = this.predictionBuffers.get(name)!;
+                predBuf.push(score);
+                while (predBuf.length > this.PREDICTION_BUFFER_MAX) predBuf.shift();
+
+                if (predBuf.length < this.INITIAL_FRAMES_SUPPRESS) {
+                    score = 0.0;
+                } else if (this.options.patience?.[name] || (this.options.debounceTime && this.options.debounceTime > 0)) {
+                    const threshold = this.options.thresholds?.[name] ?? 0.5;
+                    if (this.options.patience?.[name]) {
+                        const p = this.options.patience[name];
+                        const recentScores = predBuf.slice(-p);
+                        const countAbove = recentScores.filter(s => s >= threshold).length;
+                        if (countAbove < p) score = 0.0;
+                    } else if (this.options.debounceTime) {
+                        const framesToWait = Math.ceil(this.options.debounceTime / 0.08);
+                        const recentScores = predBuf.slice(-framesToWait - 1, -1);
+                        const alreadyTriggered = recentScores.some(s => s >= threshold);
+                        if (score >= threshold && alreadyTriggered) score = 0.0;
+                    }
+                }
+                scores[name] = Math.max(scores[name], score);
+            }
+        }
+
+        this.rawAudioRemainder = combinedAudio.slice(offset);
+        return scores;
+    }
+
+    private async runMelSpectrogram(input: Float32Array): Promise<Float32Array> {
+        const inputTensor = new ort.Tensor('float32', input, [1, input.length]);
+        const results = await this.melSession!.run({ [this.melSession!.inputNames[0]]: inputTensor });
+        return results[this.melSession!.outputNames[0]].data as Float32Array;
+    }
+
+    private async runEmbeddingModel(): Promise<Float32Array> {
+        const windowData = new Float32Array(this.MEL_WINDOW_SIZE * this.MEL_BINS);
+        const startIdx = this.melBuffer.length - this.MEL_WINDOW_SIZE;
+        for (let t = 0; t < this.MEL_WINDOW_SIZE; t++) {
+            windowData.set(this.melBuffer[startIdx + t], t * this.MEL_BINS);
+        }
+        const windowTensor = new ort.Tensor('float32', windowData, [1, this.MEL_WINDOW_SIZE, this.MEL_BINS, 1]);
+        const results = await this.embeddingSession!.run({ [this.embeddingSession!.inputNames[0]]: windowTensor });
+        const output = results[this.embeddingSession!.outputNames[0]].data as Float32Array;
+        const embedding = new Float32Array(96);
+        for (let i = 0; i < 96; i++) {
+            let v = output[i] ?? 0;
+            if (isNaN(v) || !isFinite(v)) v = 0;
+            embedding[i] = v;
+        }
+        return embedding;
+    }
+
+    private async runClassifier(name: string, session: ort.InferenceSession): Promise<number> {
+        const embBuf = this.embeddingBuffers.get(name)!;
+        const predData = new Float32Array(this.EMBEDDING_WINDOW_SIZE * 96);
+        for (let t = 0; t < this.EMBEDDING_WINDOW_SIZE; t++) predData.set(embBuf[t], t * 96);
+        const predTensor = new ort.Tensor('float32', predData, [1, this.EMBEDDING_WINDOW_SIZE, 96]);
+        const results = await session.run({ [session.inputNames[0]]: predTensor });
+        return results[session.outputNames[0]].data[0] as number;
+    }
+
+    private async runVAD(chunk: Float32Array): Promise<number> {
+        const normalized = new Float32Array(chunk.length);
+        for (let i = 0; i < chunk.length; i++) normalized[i] = chunk[i] / 32768.0;
+        const srTensor = new ort.Tensor('int64', BigInt64Array.from([BigInt(this.SAMPLE_RATE)]), [1]);
+        const hTensor = new ort.Tensor('float32', this.vadStateH, [2, 1, 64]);
+        const cTensor = new ort.Tensor('float32', this.vadStateC, [2, 1, 64]);
+        const inputTensor = new ort.Tensor('float32', normalized, [1, chunk.length]);
+        const feeds = {
+            [this.vadSession!.inputNames[0]]: inputTensor,
+            [this.vadSession!.inputNames[1]]: srTensor,
+            [this.vadSession!.inputNames[2]]: hTensor,
+            [this.vadSession!.inputNames[3]]: cTensor
+        };
+
+        const results = await this.vadSession!.run(feeds);
+        this.vadStateH = results[this.vadSession!.outputNames[1]].data as any;
+        this.vadStateC = results[this.vadSession!.outputNames[2]].data as any;
+        return results[this.vadSession!.outputNames[0]].data[0] as number;
+    }
+
+    private extractModelName(path: string): string {
+        const base = path.split('/').pop() || path;
+        return base.replace('.onnx', '').replace('.tflite', '');
+    }
+
+    reset() {
+        this.melBuffer = Array(this.MEL_WINDOW_SIZE).fill(0).map(() => new Float32Array(this.MEL_BINS).fill(1.0));
+        this.rawAudioRemainder = new Float32Array(0);
+        this.melContextBuffer.fill(0);
+        this.vadBuffer = [];
+        this.vadStateH.fill(0);
+        this.vadStateC.fill(0);
+        for (const name of this.embeddingBuffers.keys()) {
+            this.predictionBuffers.set(name, []);
+            const seeded = this.noiseSeededEmbeddings.get(name);
+            if (seeded) {
+                this.embeddingBuffers.set(name, seeded.map(e => new Float32Array(e)));
+            } else {
+                this.embeddingBuffers.set(name, Array(this.EMBEDDING_WINDOW_SIZE).fill(0).map(() => new Float32Array(96).fill(0)));
+            }
+        }
+    }
+}