@tensamin/audio 0.1.5 → 0.1.7

package/README.md

@@ -101,18 +101,19 @@ vad: {
   energyVad?: {
     smoothing: number;                 // Default: 0.95
     initialNoiseFloor: number;         // Default: 0.001
-    noiseFloorAdaptRateQuiet: number;  // Default: 0.01
-    noiseFloorAdaptRateLoud: number;   // Default: 0.001
-    minSNR: number;                    // Default: 2.0
-    snrRange: number;                  // Default: 8.0
+    noiseFloorAdaptRateQuiet: number;  // Default: 0.05
+    noiseFloorAdaptRateLoud: number;   // Default: 0.005
+    minSNR: number;                    // Default: 6.0 (dB)
+    snrRange: number;                  // Default: 12.0 (dB)
+    minEnergy: number;                 // Default: 0.0005
   };
 }
 ```
 
 **Threshold Parameters:**
 
-- `startThreshold`: Probability threshold to unmute audio
-- `stopThreshold`: Probability threshold to mute audio (after hangover)
+- `startThreshold`: Probability threshold to unmute audio (Default: 0.6, ~13.2dB SNR)
+- `stopThreshold`: Probability threshold to mute audio (Default: 0.45, ~11.4dB SNR)
 - `hangoverMs`: Delay before muting after speech stops
 - `preRollMs`: Audio buffer duration before speech onset
 - `minSpeechDurationMs`: Minimum duration to consider as valid speech
@@ -121,8 +122,9 @@ vad: {
 **Energy VAD Parameters:**
 
 - `smoothing`: Energy calculation smoothing factor (0-1)
-- `minSNR`: Minimum signal-to-noise ratio for speech detection
-- `snrRange`: Range for probability scaling from minSNR
+- `minSNR`: Minimum signal-to-noise ratio in dB for speech detection
+- `snrRange`: Range in dB for probability scaling from minSNR
+- `minEnergy`: Minimum absolute RMS energy to consider as speech
 
 ### Output Control
 

package/dist/{chunk-N553RHTI.mjs → chunk-2EX3FXSF.mjs}

@@ -25,10 +25,11 @@ var VADStateMachine = class {
       energyVad: {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
-        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.01,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 1e-3,
-        minSNR: config?.energyVad?.minSNR ?? 2,
-        snrRange: config?.energyVad?.snrRange ?? 8
+        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.05,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 5e-3,
+        minSNR: config?.energyVad?.minSNR ?? 6,
+        snrRange: config?.energyVad?.snrRange ?? 12,
+        minEnergy: config?.energyVad?.minEnergy ?? 5e-4
       }
     };
     this.lastSilenceTime = Date.now();

package/dist/{chunk-VEJXAEMM.mjs → chunk-2TKYGFMC.mjs}

@@ -3,10 +3,11 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const energyParams = vadConfig?.energyVad || {};
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
-  const minSNR = energyParams.minSNR ?? 2;
-  const snrRange = energyParams.snrRange ?? 8;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 5e-3;
+  const minSNR = energyParams.minSNR ?? 6;
+  const snrRange = energyParams.snrRange ?? 12;
+  const minEnergy = energyParams.minEnergy ?? 5e-4;
   return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
@@ -18,6 +19,7 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.minEnergy = ${minEnergy};
     this.isSpeaking = false;
     
     this.port.onmessage = (event) => {
@@ -32,36 +34,48 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS (Root Mean Square) energy
+    // Calculate instantaneous RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
-    const rms = Math.sqrt(sum / channel.length);
+    const instantRms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation - ONLY during silence
-    // This prevents the noise floor from rising during speech
-    if (!this.isSpeaking) {
-      if (rms < this.noiseFloor) {
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-      } else {
-        // Even during silence, if we detect a loud signal, adapt very slowly
-        // This could be brief noise we haven't classified as speech yet
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
-      }
+    // Smooth the RMS energy to reduce jitter
+    // this.energy acts as the smoothed RMS value
+    this.energy = this.energy * this.smoothing + instantRms * (1 - this.smoothing);
+
+    // Adaptive noise floor estimation
+    // We use the instantaneous RMS for noise floor tracking to react quickly to silence
+    if (instantRms < this.noiseFloor) {
+      // If signal is quieter than noise floor, adapt downwards quickly
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else {
+      // If signal is louder, adapt upwards
+      // If we are currently speaking, adapt EXTREMELY slowly to avoid "chasing" speech
+      // If we are silent, adapt at the normal loud rate
+      const adaptRate = this.isSpeaking ? (this.noiseFloorAdaptRateLoud * 0.02) : this.noiseFloorAdaptRateLoud;
+      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
     }
-    // During speech, freeze the noise floor to maintain consistent detection
 
-    // Calculate Signal-to-Noise Ratio (SNR)
-    const snr = rms / (this.noiseFloor + 1e-6);
+    // Ensure noise floor doesn't drop to absolute zero
+    this.noiseFloor = Math.max(this.noiseFloor, 1e-5);
+
+    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    const snr = this.energy / (this.noiseFloor + 1e-6);
+    const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
     
-    // Map SNR to probability (0-1)
-    // Probability is 0 when SNR <= minSNR
+    // Map SNR dB to probability (0-1)
+    // Probability is 0 when snrDb <= minSNR
     // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
-    // Probability is 1 when SNR >= (minSNR + snrRange)
-    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
+    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
+
+    // Apply absolute energy threshold
+    if (this.energy < this.minEnergy) {
+      probability = 0;
+    }
 
-    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
+    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
 
     return true;
   }

package/dist/{chunk-H5UKZU2Y.mjs → chunk-BMVZ3KKG.mjs}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-XO6B3D4A.mjs";
 import {
   EnergyVADPlugin
-} from "./chunk-VEJXAEMM.mjs";
+} from "./chunk-2TKYGFMC.mjs";
 
 // src/extensibility/plugins.ts
 var nsPlugins = /* @__PURE__ */ new Map();

package/dist/{chunk-XXTNAUYX.mjs → chunk-JP6DA62Y.mjs}

@@ -1,6 +1,6 @@
 import {
   VADStateMachine
-} from "./chunk-N553RHTI.mjs";
+} from "./chunk-2EX3FXSF.mjs";
 import {
   getAudioContext,
   registerPipeline,
@@ -9,7 +9,7 @@ import {
 import {
   getNoiseSuppressionPlugin,
   getVADPlugin
-} from "./chunk-H5UKZU2Y.mjs";
+} from "./chunk-BMVZ3KKG.mjs";
 
 // src/pipeline/audio-pipeline.ts
 import mitt from "mitt";

package/dist/{chunk-GVKCBKW6.mjs → chunk-UQG6Z5W3.mjs}

@@ -1,6 +1,6 @@
 import {
   createAudioPipeline
-} from "./chunk-XXTNAUYX.mjs";
+} from "./chunk-JP6DA62Y.mjs";
 
 // src/livekit/integration.ts
 async function attachProcessingToTrack(track, config = {}) {

package/dist/extensibility/plugins.js

@@ -106,10 +106,11 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const energyParams = vadConfig?.energyVad || {};
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
-  const minSNR = energyParams.minSNR ?? 2;
-  const snrRange = energyParams.snrRange ?? 8;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 5e-3;
+  const minSNR = energyParams.minSNR ?? 6;
+  const snrRange = energyParams.snrRange ?? 12;
+  const minEnergy = energyParams.minEnergy ?? 5e-4;
   return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
@@ -121,6 +122,7 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.minEnergy = ${minEnergy};
     this.isSpeaking = false;
     
     this.port.onmessage = (event) => {
@@ -135,36 +137,48 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS (Root Mean Square) energy
+    // Calculate instantaneous RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
-    const rms = Math.sqrt(sum / channel.length);
+    const instantRms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation - ONLY during silence
-    // This prevents the noise floor from rising during speech
-    if (!this.isSpeaking) {
-      if (rms < this.noiseFloor) {
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-      } else {
-        // Even during silence, if we detect a loud signal, adapt very slowly
-        // This could be brief noise we haven't classified as speech yet
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
-      }
+    // Smooth the RMS energy to reduce jitter
+    // this.energy acts as the smoothed RMS value
+    this.energy = this.energy * this.smoothing + instantRms * (1 - this.smoothing);
+
+    // Adaptive noise floor estimation
+    // We use the instantaneous RMS for noise floor tracking to react quickly to silence
+    if (instantRms < this.noiseFloor) {
+      // If signal is quieter than noise floor, adapt downwards quickly
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else {
+      // If signal is louder, adapt upwards
+      // If we are currently speaking, adapt EXTREMELY slowly to avoid "chasing" speech
+      // If we are silent, adapt at the normal loud rate
+      const adaptRate = this.isSpeaking ? (this.noiseFloorAdaptRateLoud * 0.02) : this.noiseFloorAdaptRateLoud;
+      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
     }
-    // During speech, freeze the noise floor to maintain consistent detection
 
-    // Calculate Signal-to-Noise Ratio (SNR)
-    const snr = rms / (this.noiseFloor + 1e-6);
+    // Ensure noise floor doesn't drop to absolute zero
+    this.noiseFloor = Math.max(this.noiseFloor, 1e-5);
+
+    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    const snr = this.energy / (this.noiseFloor + 1e-6);
+    const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
     
-    // Map SNR to probability (0-1)
-    // Probability is 0 when SNR <= minSNR
+    // Map SNR dB to probability (0-1)
+    // Probability is 0 when snrDb <= minSNR
     // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
-    // Probability is 1 when SNR >= (minSNR + snrRange)
-    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
+    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
+
+    // Apply absolute energy threshold
+    if (this.energy < this.minEnergy) {
+      probability = 0;
+    }
 
-    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
+    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
 
     return true;
   }

package/dist/extensibility/plugins.mjs

@@ -3,9 +3,9 @@ import {
   getVADPlugin,
   registerNoiseSuppressionPlugin,
   registerVADPlugin
-} from "../chunk-H5UKZU2Y.mjs";
+} from "../chunk-BMVZ3KKG.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-VEJXAEMM.mjs";
+import "../chunk-2TKYGFMC.mjs";
 export {
   getNoiseSuppressionPlugin,
   getVADPlugin,

package/dist/index.js

@@ -158,10 +158,11 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const energyParams = vadConfig?.energyVad || {};
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
-  const minSNR = energyParams.minSNR ?? 2;
-  const snrRange = energyParams.snrRange ?? 8;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 5e-3;
+  const minSNR = energyParams.minSNR ?? 6;
+  const snrRange = energyParams.snrRange ?? 12;
+  const minEnergy = energyParams.minEnergy ?? 5e-4;
   return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
@@ -173,6 +174,7 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.minEnergy = ${minEnergy};
     this.isSpeaking = false;
     
     this.port.onmessage = (event) => {
@@ -187,36 +189,48 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS (Root Mean Square) energy
+    // Calculate instantaneous RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
-    const rms = Math.sqrt(sum / channel.length);
+    const instantRms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation - ONLY during silence
-    // This prevents the noise floor from rising during speech
-    if (!this.isSpeaking) {
-      if (rms < this.noiseFloor) {
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-      } else {
-        // Even during silence, if we detect a loud signal, adapt very slowly
-        // This could be brief noise we haven't classified as speech yet
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
-      }
+    // Smooth the RMS energy to reduce jitter
+    // this.energy acts as the smoothed RMS value
+    this.energy = this.energy * this.smoothing + instantRms * (1 - this.smoothing);
+
+    // Adaptive noise floor estimation
+    // We use the instantaneous RMS for noise floor tracking to react quickly to silence
+    if (instantRms < this.noiseFloor) {
+      // If signal is quieter than noise floor, adapt downwards quickly
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else {
+      // If signal is louder, adapt upwards
+      // If we are currently speaking, adapt EXTREMELY slowly to avoid "chasing" speech
+      // If we are silent, adapt at the normal loud rate
+      const adaptRate = this.isSpeaking ? (this.noiseFloorAdaptRateLoud * 0.02) : this.noiseFloorAdaptRateLoud;
+      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
     }
-    // During speech, freeze the noise floor to maintain consistent detection
 
-    // Calculate Signal-to-Noise Ratio (SNR)
-    const snr = rms / (this.noiseFloor + 1e-6);
+    // Ensure noise floor doesn't drop to absolute zero
+    this.noiseFloor = Math.max(this.noiseFloor, 1e-5);
+
+    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    const snr = this.energy / (this.noiseFloor + 1e-6);
+    const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
     
-    // Map SNR to probability (0-1)
-    // Probability is 0 when SNR <= minSNR
+    // Map SNR dB to probability (0-1)
+    // Probability is 0 when snrDb <= minSNR
     // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
-    // Probability is 1 when SNR >= (minSNR + snrRange)
-    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
+    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
+
+    // Apply absolute energy threshold
+    if (this.energy < this.minEnergy) {
+      probability = 0;
+    }
 
-    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
+    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
 
     return true;
   }
@@ -347,10 +361,11 @@ var VADStateMachine = class {
       energyVad: {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
-        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.01,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 1e-3,
-        minSNR: config?.energyVad?.minSNR ?? 2,
-        snrRange: config?.energyVad?.snrRange ?? 8
+        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.05,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 5e-3,
+        minSNR: config?.energyVad?.minSNR ?? 6,
+        snrRange: config?.energyVad?.snrRange ?? 12,
+        minEnergy: config?.energyVad?.minEnergy ?? 5e-4
       }
     };
     this.lastSilenceTime = Date.now();

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import "./chunk-WBQAMGXK.mjs";
 import {
   attachProcessingToTrack
-} from "./chunk-GVKCBKW6.mjs";
+} from "./chunk-UQG6Z5W3.mjs";
 import {
   createAudioPipeline
-} from "./chunk-XXTNAUYX.mjs";
+} from "./chunk-JP6DA62Y.mjs";
 import {
   VADStateMachine
-} from "./chunk-N553RHTI.mjs";
+} from "./chunk-2EX3FXSF.mjs";
 import {
   closeAudioContext,
   getAudioContext,
@@ -21,13 +21,13 @@ import {
   getVADPlugin,
   registerNoiseSuppressionPlugin,
   registerVADPlugin
-} from "./chunk-H5UKZU2Y.mjs";
+} from "./chunk-BMVZ3KKG.mjs";
 import {
   RNNoisePlugin
 } from "./chunk-XO6B3D4A.mjs";
 import {
   EnergyVADPlugin
-} from "./chunk-VEJXAEMM.mjs";
+} from "./chunk-2TKYGFMC.mjs";
 export {
   EnergyVADPlugin,
   RNNoisePlugin,

package/dist/livekit/integration.js

@@ -127,10 +127,11 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const energyParams = vadConfig?.energyVad || {};
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
-  const minSNR = energyParams.minSNR ?? 2;
-  const snrRange = energyParams.snrRange ?? 8;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 5e-3;
+  const minSNR = energyParams.minSNR ?? 6;
+  const snrRange = energyParams.snrRange ?? 12;
+  const minEnergy = energyParams.minEnergy ?? 5e-4;
   return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
@@ -142,6 +143,7 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.minEnergy = ${minEnergy};
     this.isSpeaking = false;
     
     this.port.onmessage = (event) => {
@@ -156,36 +158,48 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS (Root Mean Square) energy
+    // Calculate instantaneous RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
-    const rms = Math.sqrt(sum / channel.length);
+    const instantRms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation - ONLY during silence
-    // This prevents the noise floor from rising during speech
-    if (!this.isSpeaking) {
-      if (rms < this.noiseFloor) {
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-      } else {
-        // Even during silence, if we detect a loud signal, adapt very slowly
-        // This could be brief noise we haven't classified as speech yet
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
-      }
+    // Smooth the RMS energy to reduce jitter
+    // this.energy acts as the smoothed RMS value
+    this.energy = this.energy * this.smoothing + instantRms * (1 - this.smoothing);
+
+    // Adaptive noise floor estimation
+    // We use the instantaneous RMS for noise floor tracking to react quickly to silence
+    if (instantRms < this.noiseFloor) {
+      // If signal is quieter than noise floor, adapt downwards quickly
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else {
+      // If signal is louder, adapt upwards
+      // If we are currently speaking, adapt EXTREMELY slowly to avoid "chasing" speech
+      // If we are silent, adapt at the normal loud rate
+      const adaptRate = this.isSpeaking ? (this.noiseFloorAdaptRateLoud * 0.02) : this.noiseFloorAdaptRateLoud;
+      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
     }
-    // During speech, freeze the noise floor to maintain consistent detection
 
-    // Calculate Signal-to-Noise Ratio (SNR)
-    const snr = rms / (this.noiseFloor + 1e-6);
+    // Ensure noise floor doesn't drop to absolute zero
+    this.noiseFloor = Math.max(this.noiseFloor, 1e-5);
+
+    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    const snr = this.energy / (this.noiseFloor + 1e-6);
+    const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
     
-    // Map SNR to probability (0-1)
-    // Probability is 0 when SNR <= minSNR
+    // Map SNR dB to probability (0-1)
+    // Probability is 0 when snrDb <= minSNR
     // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
-    // Probability is 1 when SNR >= (minSNR + snrRange)
-    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
+    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
+
+    // Apply absolute energy threshold
+    if (this.energy < this.minEnergy) {
+      probability = 0;
+    }
 
-    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
+    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
 
     return true;
   }
@@ -310,10 +324,11 @@ var VADStateMachine = class {
       energyVad: {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
-        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.01,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 1e-3,
-        minSNR: config?.energyVad?.minSNR ?? 2,
-        snrRange: config?.energyVad?.snrRange ?? 8
+        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.05,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 5e-3,
+        minSNR: config?.energyVad?.minSNR ?? 6,
+        snrRange: config?.energyVad?.snrRange ?? 12,
+        minEnergy: config?.energyVad?.minEnergy ?? 5e-4
       }
     };
     this.lastSilenceTime = Date.now();

package/dist/livekit/integration.mjs

@@ -1,12 +1,12 @@
 import {
   attachProcessingToTrack
-} from "../chunk-GVKCBKW6.mjs";
-import "../chunk-XXTNAUYX.mjs";
-import "../chunk-N553RHTI.mjs";
+} from "../chunk-UQG6Z5W3.mjs";
+import "../chunk-JP6DA62Y.mjs";
+import "../chunk-2EX3FXSF.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-H5UKZU2Y.mjs";
+import "../chunk-BMVZ3KKG.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-VEJXAEMM.mjs";
+import "../chunk-2TKYGFMC.mjs";
 export {
   attachProcessingToTrack
 };

package/dist/pipeline/audio-pipeline.js

@@ -125,10 +125,11 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const energyParams = vadConfig?.energyVad || {};
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
-  const minSNR = energyParams.minSNR ?? 2;
-  const snrRange = energyParams.snrRange ?? 8;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 5e-3;
+  const minSNR = energyParams.minSNR ?? 6;
+  const snrRange = energyParams.snrRange ?? 12;
+  const minEnergy = energyParams.minEnergy ?? 5e-4;
   return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
@@ -140,6 +141,7 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.minEnergy = ${minEnergy};
     this.isSpeaking = false;
     
     this.port.onmessage = (event) => {
@@ -154,36 +156,48 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS (Root Mean Square) energy
+    // Calculate instantaneous RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
-    const rms = Math.sqrt(sum / channel.length);
+    const instantRms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation - ONLY during silence
-    // This prevents the noise floor from rising during speech
-    if (!this.isSpeaking) {
-      if (rms < this.noiseFloor) {
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-      } else {
-        // Even during silence, if we detect a loud signal, adapt very slowly
-        // This could be brief noise we haven't classified as speech yet
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
-      }
+    // Smooth the RMS energy to reduce jitter
+    // this.energy acts as the smoothed RMS value
+    this.energy = this.energy * this.smoothing + instantRms * (1 - this.smoothing);
+
+    // Adaptive noise floor estimation
+    // We use the instantaneous RMS for noise floor tracking to react quickly to silence
+    if (instantRms < this.noiseFloor) {
+      // If signal is quieter than noise floor, adapt downwards quickly
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else {
+      // If signal is louder, adapt upwards
+      // If we are currently speaking, adapt EXTREMELY slowly to avoid "chasing" speech
+      // If we are silent, adapt at the normal loud rate
+      const adaptRate = this.isSpeaking ? (this.noiseFloorAdaptRateLoud * 0.02) : this.noiseFloorAdaptRateLoud;
+      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
     }
-    // During speech, freeze the noise floor to maintain consistent detection
 
-    // Calculate Signal-to-Noise Ratio (SNR)
-    const snr = rms / (this.noiseFloor + 1e-6);
+    // Ensure noise floor doesn't drop to absolute zero
+    this.noiseFloor = Math.max(this.noiseFloor, 1e-5);
+
+    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    const snr = this.energy / (this.noiseFloor + 1e-6);
+    const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
     
-    // Map SNR to probability (0-1)
-    // Probability is 0 when SNR <= minSNR
+    // Map SNR dB to probability (0-1)
+    // Probability is 0 when snrDb <= minSNR
     // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
-    // Probability is 1 when SNR >= (minSNR + snrRange)
-    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
+    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
+
+    // Apply absolute energy threshold
+    if (this.energy < this.minEnergy) {
+      probability = 0;
+    }
 
-    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
+    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
 
     return true;
   }
@@ -308,10 +322,11 @@ var VADStateMachine = class {
       energyVad: {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
-        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.01,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 1e-3,
-        minSNR: config?.energyVad?.minSNR ?? 2,
-        snrRange: config?.energyVad?.snrRange ?? 8
+        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.05,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 5e-3,
+        minSNR: config?.energyVad?.minSNR ?? 6,
+        snrRange: config?.energyVad?.snrRange ?? 12,
+        minEnergy: config?.energyVad?.minEnergy ?? 5e-4
       }
     };
     this.lastSilenceTime = Date.now();

package/dist/pipeline/audio-pipeline.mjs

@@ -1,11 +1,11 @@
 import {
   createAudioPipeline
-} from "../chunk-XXTNAUYX.mjs";
-import "../chunk-N553RHTI.mjs";
+} from "../chunk-JP6DA62Y.mjs";
+import "../chunk-2EX3FXSF.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-H5UKZU2Y.mjs";
+import "../chunk-BMVZ3KKG.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-VEJXAEMM.mjs";
+import "../chunk-2TKYGFMC.mjs";
 export {
   createAudioPipeline
 };

package/dist/types.d.mts

@@ -97,24 +97,30 @@ interface AudioProcessingConfig {
             initialNoiseFloor?: number;
             /**
              * Rate at which noise floor adapts to quiet signals (0-1).
-             * Default: 0.01
+             * Default: 0.05
              */
             noiseFloorAdaptRateQuiet?: number;
             /**
              * Rate at which noise floor adapts to loud signals (0-1).
-             * Default: 0.001 (slower adaptation for speech)
+             * Default: 0.005 (slower adaptation for speech)
              */
             noiseFloorAdaptRateLoud?: number;
             /**
-             * Minimum SNR (Signal-to-Noise Ratio) for speech detection.
-             * Default: 2.0 (voice is 2x louder than noise floor)
+             * Minimum SNR (Signal-to-Noise Ratio) in dB for speech detection.
+             * Default: 6.0 (voice is ~2x louder than noise floor)
              */
             minSNR?: number;
             /**
-             * SNR range for probability scaling.
-             * Default: 8.0 (probability scales from minSNR to minSNR+snrRange)
+             * SNR range in dB for probability scaling.
+             * Default: 12.0 (probability scales from minSNR to minSNR+snrRange)
              */
             snrRange?: number;
+            /**
+             * Minimum absolute RMS energy to consider as speech.
+             * Prevents triggering on very quiet background noise in silent rooms.
+             * Default: 0.0005
+             */
+            minEnergy?: number;
         };
     };
     /**

package/dist/types.d.ts

@@ -97,24 +97,30 @@ interface AudioProcessingConfig {
             initialNoiseFloor?: number;
             /**
              * Rate at which noise floor adapts to quiet signals (0-1).
-             * Default: 0.01
+             * Default: 0.05
              */
             noiseFloorAdaptRateQuiet?: number;
             /**
              * Rate at which noise floor adapts to loud signals (0-1).
-             * Default: 0.001 (slower adaptation for speech)
+             * Default: 0.005 (slower adaptation for speech)
              */
             noiseFloorAdaptRateLoud?: number;
             /**
-             * Minimum SNR (Signal-to-Noise Ratio) for speech detection.
-             * Default: 2.0 (voice is 2x louder than noise floor)
+             * Minimum SNR (Signal-to-Noise Ratio) in dB for speech detection.
+             * Default: 6.0 (voice is ~2x louder than noise floor)
              */
             minSNR?: number;
             /**
-             * SNR range for probability scaling.
-             * Default: 8.0 (probability scales from minSNR to minSNR+snrRange)
+             * SNR range in dB for probability scaling.
+             * Default: 12.0 (probability scales from minSNR to minSNR+snrRange)
              */
             snrRange?: number;
+            /**
+             * Minimum absolute RMS energy to consider as speech.
+             * Prevents triggering on very quiet background noise in silent rooms.
+             * Default: 0.0005
+             */
+            minEnergy?: number;
         };
     };
     /**

package/dist/vad/vad-node.js

@@ -27,10 +27,11 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const energyParams = vadConfig?.energyVad || {};
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 1e-3;
-  const minSNR = energyParams.minSNR ?? 2;
-  const snrRange = energyParams.snrRange ?? 8;
+  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 5e-3;
+  const minSNR = energyParams.minSNR ?? 6;
+  const snrRange = energyParams.snrRange ?? 12;
+  const minEnergy = energyParams.minEnergy ?? 5e-4;
   return `
 class EnergyVadProcessor extends AudioWorkletProcessor {
   constructor() {
@@ -42,6 +43,7 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.minEnergy = ${minEnergy};
     this.isSpeaking = false;
     
     this.port.onmessage = (event) => {
@@ -56,36 +58,48 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     if (!input || !input.length) return true;
     const channel = input[0];
     
-    // Calculate RMS (Root Mean Square) energy
+    // Calculate instantaneous RMS (Root Mean Square) energy
     let sum = 0;
     for (let i = 0; i < channel.length; i++) {
       sum += channel[i] * channel[i];
     }
-    const rms = Math.sqrt(sum / channel.length);
+    const instantRms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation - ONLY during silence
-    // This prevents the noise floor from rising during speech
-    if (!this.isSpeaking) {
-      if (rms < this.noiseFloor) {
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-      } else {
-        // Even during silence, if we detect a loud signal, adapt very slowly
-        // This could be brief noise we haven't classified as speech yet
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
-      }
+    // Smooth the RMS energy to reduce jitter
+    // this.energy acts as the smoothed RMS value
+    this.energy = this.energy * this.smoothing + instantRms * (1 - this.smoothing);
+
+    // Adaptive noise floor estimation
+    // We use the instantaneous RMS for noise floor tracking to react quickly to silence
+    if (instantRms < this.noiseFloor) {
+      // If signal is quieter than noise floor, adapt downwards quickly
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else {
+      // If signal is louder, adapt upwards
+      // If we are currently speaking, adapt EXTREMELY slowly to avoid "chasing" speech
+      // If we are silent, adapt at the normal loud rate
+      const adaptRate = this.isSpeaking ? (this.noiseFloorAdaptRateLoud * 0.02) : this.noiseFloorAdaptRateLoud;
+      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
     }
-    // During speech, freeze the noise floor to maintain consistent detection
 
-    // Calculate Signal-to-Noise Ratio (SNR)
-    const snr = rms / (this.noiseFloor + 1e-6);
+    // Ensure noise floor doesn't drop to absolute zero
+    this.noiseFloor = Math.max(this.noiseFloor, 1e-5);
+
+    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    const snr = this.energy / (this.noiseFloor + 1e-6);
+    const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
     
-    // Map SNR to probability (0-1)
-    // Probability is 0 when SNR <= minSNR
+    // Map SNR dB to probability (0-1)
+    // Probability is 0 when snrDb <= minSNR
     // Probability scales linearly from 0 to 1 between minSNR and (minSNR + snrRange)
-    // Probability is 1 when SNR >= (minSNR + snrRange)
-    const probability = Math.min(1, Math.max(0, (snr - this.minSNR) / this.snrRange));
+    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
+
+    // Apply absolute energy threshold
+    if (this.energy < this.minEnergy) {
+      probability = 0;
+    }
 
-    this.port.postMessage({ probability, snr, noiseFloor: this.noiseFloor, rms });
+    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
 
     return true;
   }

package/dist/vad/vad-node.mjs

@@ -1,6 +1,6 @@
 import {
   EnergyVADPlugin
-} from "../chunk-VEJXAEMM.mjs";
+} from "../chunk-2TKYGFMC.mjs";
 export {
   EnergyVADPlugin
 };

package/dist/vad/vad-state.js

@@ -49,10 +49,11 @@ var VADStateMachine = class {
       energyVad: {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
-        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.01,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 1e-3,
-        minSNR: config?.energyVad?.minSNR ?? 2,
-        snrRange: config?.energyVad?.snrRange ?? 8
+        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 0.05,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 5e-3,
+        minSNR: config?.energyVad?.minSNR ?? 6,
+        snrRange: config?.energyVad?.snrRange ?? 12,
+        minEnergy: config?.energyVad?.minEnergy ?? 5e-4
       }
     };
     this.lastSilenceTime = Date.now();

package/dist/vad/vad-state.mjs

@@ -1,6 +1,6 @@
 import {
   VADStateMachine
-} from "../chunk-N553RHTI.mjs";
+} from "../chunk-2EX3FXSF.mjs";
 export {
   VADStateMachine
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensamin/audio",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",