@tensamin/audio 0.1.12 → 0.1.13

package/README.md

@@ -102,7 +102,7 @@ vad: {
     smoothing: number;                 // Default: 0.95
     initialNoiseFloor: number;         // Default: 0.001
     noiseFloorAdaptRateQuiet: number;  // Default: 0.01
-    noiseFloorAdaptRateLoud: number;   // Default: 0.05
+    noiseFloorAdaptRateLoud: number;   // Default: 0.1
     minSNR: number;                    // Default: 10.0 (dB)
     snrRange: number;                  // Default: 10.0 (dB)
     minEnergy: number;                 // Default: 0.001

package/dist/{chunk-DYY2MXMU.mjs → chunk-DLLK6K76.mjs}

@@ -27,7 +27,7 @@ var VADStateMachine = class {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
         noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 5e-3,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.01,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.1,
         minSNR: config?.energyVad?.minSNR ?? 10,
         snrRange: config?.energyVad?.snrRange ?? 10,
         minEnergy: config?.energyVad?.minEnergy ?? 1e-3

package/dist/{chunk-KEWK2OKV.mjs → chunk-FKR6NWZF.mjs}

@@ -4,7 +4,7 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
   const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.1;
   const minSNR = energyParams.minSNR ?? 10;
   const snrRange = energyParams.snrRange ?? 10;
   const minEnergy = energyParams.minEnergy ?? 1e-3;
@@ -46,35 +46,31 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     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
+    // We use a TWO-PASS approach to avoid circular dependencies:
+    // FIRST PASS: Calculate instantaneous SNR to decide how to adapt
+    const instantSnr = instantRms / (this.noiseFloor + 1e-6);
+    const instantSnrDb = 20 * Math.log10(Math.max(1e-6, instantSnr));
+    
+    // Adapt the noise floor based on instantaneous SNR
     if (instantRms < this.noiseFloor) {
-      // If signal is quieter than noise floor, adapt downwards quickly
+      // Signal is quieter than noise floor, adapt downwards quickly
       this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else if (instantSnrDb < 12) {
+      // Signal is louder but SNR is low (< 12dB) - likely just louder background noise
+      // Adapt upwards at normal rate to track rising noise
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + instantRms * this.noiseFloorAdaptRateLoud;
     } else {
-      // If signal is louder, adapt upwards
-      // We use a multi-stage adaptation rate:
-      // 1. If we are officially speaking, adapt EXTREMELY slowly (0.01x)
-      // 2. If SNR is very high (> 20dB), assume it's speech and adapt very slowly (0.1x)
-      // 3. Otherwise, adapt at the normal loud rate
-      const snr = instantRms / (this.noiseFloor + 1e-6);
-      const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
-      
-      let multiplier = 1.0;
-      if (this.isSpeaking) {
-        multiplier = 0.05;
-      } else if (snrDb > 20) {
-        multiplier = 0.2;
-      }
-      
-      const adaptRate = this.noiseFloorAdaptRateLoud * multiplier;
-      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
+      // Signal has high SNR (>= 12dB) - likely speech or transient
+      // Adapt VERY slowly to avoid "chasing" speech
+      const slowRate = this.noiseFloorAdaptRateLoud * 0.02;
+      this.noiseFloor = this.noiseFloor * (1 - slowRate) + instantRms * slowRate;
     }
 
     // Ensure noise floor doesn't drop to absolute zero
     // 0.00005 is approx -86dB, very quiet but prevents SNR explosion
     this.noiseFloor = Math.max(this.noiseFloor, 0.00005);
 
-    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    // SECOND PASS: 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));
     

package/dist/{chunk-Q2I22TJG.mjs → chunk-K6X52R7N.mjs}

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

package/dist/{chunk-XZSFQJW4.mjs → chunk-OXV7BHX5.mjs}

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

package/dist/{chunk-SMZJFNRU.mjs → chunk-RD4GDIPO.mjs}

@@ -1,6 +1,6 @@
 import {
   VADStateMachine
-} from "./chunk-DYY2MXMU.mjs";
+} from "./chunk-DLLK6K76.mjs";
 import {
   getAudioContext,
   registerPipeline,
@@ -9,7 +9,7 @@ import {
 import {
   getNoiseSuppressionPlugin,
   getVADPlugin
-} from "./chunk-XZSFQJW4.mjs";
+} from "./chunk-OXV7BHX5.mjs";
 
 // src/pipeline/audio-pipeline.ts
 import mitt from "mitt";

package/dist/extensibility/plugins.js

@@ -107,7 +107,7 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
   const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.1;
   const minSNR = energyParams.minSNR ?? 10;
   const snrRange = energyParams.snrRange ?? 10;
   const minEnergy = energyParams.minEnergy ?? 1e-3;
@@ -149,35 +149,31 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     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
+    // We use a TWO-PASS approach to avoid circular dependencies:
+    // FIRST PASS: Calculate instantaneous SNR to decide how to adapt
+    const instantSnr = instantRms / (this.noiseFloor + 1e-6);
+    const instantSnrDb = 20 * Math.log10(Math.max(1e-6, instantSnr));
+    
+    // Adapt the noise floor based on instantaneous SNR
     if (instantRms < this.noiseFloor) {
-      // If signal is quieter than noise floor, adapt downwards quickly
+      // Signal is quieter than noise floor, adapt downwards quickly
       this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else if (instantSnrDb < 12) {
+      // Signal is louder but SNR is low (< 12dB) - likely just louder background noise
+      // Adapt upwards at normal rate to track rising noise
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + instantRms * this.noiseFloorAdaptRateLoud;
     } else {
-      // If signal is louder, adapt upwards
-      // We use a multi-stage adaptation rate:
-      // 1. If we are officially speaking, adapt EXTREMELY slowly (0.01x)
-      // 2. If SNR is very high (> 20dB), assume it's speech and adapt very slowly (0.1x)
-      // 3. Otherwise, adapt at the normal loud rate
-      const snr = instantRms / (this.noiseFloor + 1e-6);
-      const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
-      
-      let multiplier = 1.0;
-      if (this.isSpeaking) {
-        multiplier = 0.05;
-      } else if (snrDb > 20) {
-        multiplier = 0.2;
-      }
-      
-      const adaptRate = this.noiseFloorAdaptRateLoud * multiplier;
-      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
+      // Signal has high SNR (>= 12dB) - likely speech or transient
+      // Adapt VERY slowly to avoid "chasing" speech
+      const slowRate = this.noiseFloorAdaptRateLoud * 0.02;
+      this.noiseFloor = this.noiseFloor * (1 - slowRate) + instantRms * slowRate;
     }
 
     // Ensure noise floor doesn't drop to absolute zero
     // 0.00005 is approx -86dB, very quiet but prevents SNR explosion
     this.noiseFloor = Math.max(this.noiseFloor, 0.00005);
 
-    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    // SECOND PASS: 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));
     

package/dist/extensibility/plugins.mjs

@@ -3,9 +3,9 @@ import {
   getVADPlugin,
   registerNoiseSuppressionPlugin,
   registerVADPlugin
-} from "../chunk-XZSFQJW4.mjs";
+} from "../chunk-OXV7BHX5.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-KEWK2OKV.mjs";
+import "../chunk-FKR6NWZF.mjs";
 export {
   getNoiseSuppressionPlugin,
   getVADPlugin,

package/dist/index.js

@@ -159,7 +159,7 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
   const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.1;
   const minSNR = energyParams.minSNR ?? 10;
   const snrRange = energyParams.snrRange ?? 10;
   const minEnergy = energyParams.minEnergy ?? 1e-3;
@@ -201,35 +201,31 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     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
+    // We use a TWO-PASS approach to avoid circular dependencies:
+    // FIRST PASS: Calculate instantaneous SNR to decide how to adapt
+    const instantSnr = instantRms / (this.noiseFloor + 1e-6);
+    const instantSnrDb = 20 * Math.log10(Math.max(1e-6, instantSnr));
+    
+    // Adapt the noise floor based on instantaneous SNR
     if (instantRms < this.noiseFloor) {
-      // If signal is quieter than noise floor, adapt downwards quickly
+      // Signal is quieter than noise floor, adapt downwards quickly
       this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else if (instantSnrDb < 12) {
+      // Signal is louder but SNR is low (< 12dB) - likely just louder background noise
+      // Adapt upwards at normal rate to track rising noise
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + instantRms * this.noiseFloorAdaptRateLoud;
     } else {
-      // If signal is louder, adapt upwards
-      // We use a multi-stage adaptation rate:
-      // 1. If we are officially speaking, adapt EXTREMELY slowly (0.01x)
-      // 2. If SNR is very high (> 20dB), assume it's speech and adapt very slowly (0.1x)
-      // 3. Otherwise, adapt at the normal loud rate
-      const snr = instantRms / (this.noiseFloor + 1e-6);
-      const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
-      
-      let multiplier = 1.0;
-      if (this.isSpeaking) {
-        multiplier = 0.05;
-      } else if (snrDb > 20) {
-        multiplier = 0.2;
-      }
-      
-      const adaptRate = this.noiseFloorAdaptRateLoud * multiplier;
-      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
+      // Signal has high SNR (>= 12dB) - likely speech or transient
+      // Adapt VERY slowly to avoid "chasing" speech
+      const slowRate = this.noiseFloorAdaptRateLoud * 0.02;
+      this.noiseFloor = this.noiseFloor * (1 - slowRate) + instantRms * slowRate;
     }
 
     // Ensure noise floor doesn't drop to absolute zero
     // 0.00005 is approx -86dB, very quiet but prevents SNR explosion
     this.noiseFloor = Math.max(this.noiseFloor, 0.00005);
 
-    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    // SECOND PASS: 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));
     
@@ -378,7 +374,7 @@ var VADStateMachine = class {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
         noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 5e-3,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.01,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.1,
         minSNR: config?.energyVad?.minSNR ?? 10,
         snrRange: config?.energyVad?.snrRange ?? 10,
         minEnergy: config?.energyVad?.minEnergy ?? 1e-3

package/dist/index.mjs

@@ -1,13 +1,13 @@
 import "./chunk-WBQAMGXK.mjs";
 import {
   attachProcessingToTrack
-} from "./chunk-Q2I22TJG.mjs";
+} from "./chunk-K6X52R7N.mjs";
 import {
   createAudioPipeline
-} from "./chunk-SMZJFNRU.mjs";
+} from "./chunk-RD4GDIPO.mjs";
 import {
   VADStateMachine
-} from "./chunk-DYY2MXMU.mjs";
+} from "./chunk-DLLK6K76.mjs";
 import {
   closeAudioContext,
   getAudioContext,
@@ -21,13 +21,13 @@ import {
   getVADPlugin,
   registerNoiseSuppressionPlugin,
   registerVADPlugin
-} from "./chunk-XZSFQJW4.mjs";
+} from "./chunk-OXV7BHX5.mjs";
 import {
   RNNoisePlugin
 } from "./chunk-XO6B3D4A.mjs";
 import {
   EnergyVADPlugin
-} from "./chunk-KEWK2OKV.mjs";
+} from "./chunk-FKR6NWZF.mjs";
 export {
   EnergyVADPlugin,
   RNNoisePlugin,

package/dist/livekit/integration.js

@@ -128,7 +128,7 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
   const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.1;
   const minSNR = energyParams.minSNR ?? 10;
   const snrRange = energyParams.snrRange ?? 10;
   const minEnergy = energyParams.minEnergy ?? 1e-3;
@@ -170,35 +170,31 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     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
+    // We use a TWO-PASS approach to avoid circular dependencies:
+    // FIRST PASS: Calculate instantaneous SNR to decide how to adapt
+    const instantSnr = instantRms / (this.noiseFloor + 1e-6);
+    const instantSnrDb = 20 * Math.log10(Math.max(1e-6, instantSnr));
+    
+    // Adapt the noise floor based on instantaneous SNR
     if (instantRms < this.noiseFloor) {
-      // If signal is quieter than noise floor, adapt downwards quickly
+      // Signal is quieter than noise floor, adapt downwards quickly
       this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else if (instantSnrDb < 12) {
+      // Signal is louder but SNR is low (< 12dB) - likely just louder background noise
+      // Adapt upwards at normal rate to track rising noise
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + instantRms * this.noiseFloorAdaptRateLoud;
     } else {
-      // If signal is louder, adapt upwards
-      // We use a multi-stage adaptation rate:
-      // 1. If we are officially speaking, adapt EXTREMELY slowly (0.01x)
-      // 2. If SNR is very high (> 20dB), assume it's speech and adapt very slowly (0.1x)
-      // 3. Otherwise, adapt at the normal loud rate
-      const snr = instantRms / (this.noiseFloor + 1e-6);
-      const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
-      
-      let multiplier = 1.0;
-      if (this.isSpeaking) {
-        multiplier = 0.05;
-      } else if (snrDb > 20) {
-        multiplier = 0.2;
-      }
-      
-      const adaptRate = this.noiseFloorAdaptRateLoud * multiplier;
-      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
+      // Signal has high SNR (>= 12dB) - likely speech or transient
+      // Adapt VERY slowly to avoid "chasing" speech
+      const slowRate = this.noiseFloorAdaptRateLoud * 0.02;
+      this.noiseFloor = this.noiseFloor * (1 - slowRate) + instantRms * slowRate;
     }
 
     // Ensure noise floor doesn't drop to absolute zero
     // 0.00005 is approx -86dB, very quiet but prevents SNR explosion
     this.noiseFloor = Math.max(this.noiseFloor, 0.00005);
 
-    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    // SECOND PASS: 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));
     
@@ -341,7 +337,7 @@ var VADStateMachine = class {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
         noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 5e-3,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.01,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.1,
         minSNR: config?.energyVad?.minSNR ?? 10,
         snrRange: config?.energyVad?.snrRange ?? 10,
         minEnergy: config?.energyVad?.minEnergy ?? 1e-3

package/dist/livekit/integration.mjs

@@ -1,12 +1,12 @@
 import {
   attachProcessingToTrack
-} from "../chunk-Q2I22TJG.mjs";
-import "../chunk-SMZJFNRU.mjs";
-import "../chunk-DYY2MXMU.mjs";
+} from "../chunk-K6X52R7N.mjs";
+import "../chunk-RD4GDIPO.mjs";
+import "../chunk-DLLK6K76.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-XZSFQJW4.mjs";
+import "../chunk-OXV7BHX5.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-KEWK2OKV.mjs";
+import "../chunk-FKR6NWZF.mjs";
 export {
   attachProcessingToTrack
 };

package/dist/pipeline/audio-pipeline.js

@@ -126,7 +126,7 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
   const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.1;
   const minSNR = energyParams.minSNR ?? 10;
   const snrRange = energyParams.snrRange ?? 10;
   const minEnergy = energyParams.minEnergy ?? 1e-3;
@@ -168,35 +168,31 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     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
+    // We use a TWO-PASS approach to avoid circular dependencies:
+    // FIRST PASS: Calculate instantaneous SNR to decide how to adapt
+    const instantSnr = instantRms / (this.noiseFloor + 1e-6);
+    const instantSnrDb = 20 * Math.log10(Math.max(1e-6, instantSnr));
+    
+    // Adapt the noise floor based on instantaneous SNR
     if (instantRms < this.noiseFloor) {
-      // If signal is quieter than noise floor, adapt downwards quickly
+      // Signal is quieter than noise floor, adapt downwards quickly
       this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else if (instantSnrDb < 12) {
+      // Signal is louder but SNR is low (< 12dB) - likely just louder background noise
+      // Adapt upwards at normal rate to track rising noise
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + instantRms * this.noiseFloorAdaptRateLoud;
     } else {
-      // If signal is louder, adapt upwards
-      // We use a multi-stage adaptation rate:
-      // 1. If we are officially speaking, adapt EXTREMELY slowly (0.01x)
-      // 2. If SNR is very high (> 20dB), assume it's speech and adapt very slowly (0.1x)
-      // 3. Otherwise, adapt at the normal loud rate
-      const snr = instantRms / (this.noiseFloor + 1e-6);
-      const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
-      
-      let multiplier = 1.0;
-      if (this.isSpeaking) {
-        multiplier = 0.05;
-      } else if (snrDb > 20) {
-        multiplier = 0.2;
-      }
-      
-      const adaptRate = this.noiseFloorAdaptRateLoud * multiplier;
-      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
+      // Signal has high SNR (>= 12dB) - likely speech or transient
+      // Adapt VERY slowly to avoid "chasing" speech
+      const slowRate = this.noiseFloorAdaptRateLoud * 0.02;
+      this.noiseFloor = this.noiseFloor * (1 - slowRate) + instantRms * slowRate;
     }
 
     // Ensure noise floor doesn't drop to absolute zero
     // 0.00005 is approx -86dB, very quiet but prevents SNR explosion
     this.noiseFloor = Math.max(this.noiseFloor, 0.00005);
 
-    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    // SECOND PASS: 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));
     
@@ -339,7 +335,7 @@ var VADStateMachine = class {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
         noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 5e-3,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.01,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.1,
         minSNR: config?.energyVad?.minSNR ?? 10,
         snrRange: config?.energyVad?.snrRange ?? 10,
         minEnergy: config?.energyVad?.minEnergy ?? 1e-3

package/dist/pipeline/audio-pipeline.mjs

@@ -1,11 +1,11 @@
 import {
   createAudioPipeline
-} from "../chunk-SMZJFNRU.mjs";
-import "../chunk-DYY2MXMU.mjs";
+} from "../chunk-RD4GDIPO.mjs";
+import "../chunk-DLLK6K76.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-XZSFQJW4.mjs";
+import "../chunk-OXV7BHX5.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-KEWK2OKV.mjs";
+import "../chunk-FKR6NWZF.mjs";
 export {
   createAudioPipeline
 };

package/dist/types.d.mts

@@ -102,7 +102,8 @@ interface AudioProcessingConfig {
             noiseFloorAdaptRateQuiet?: number;
             /**
              * Rate at which noise floor adapts to loud signals (0-1).
-             * Default: 0.05 (faster tracking of rising noise)
+             * Applied when instantaneous SNR < 12dB (background noise).
+             * Default: 0.1 (fast tracking of rising noise)
              */
             noiseFloorAdaptRateLoud?: number;
             /**

package/dist/types.d.ts

@@ -102,7 +102,8 @@ interface AudioProcessingConfig {
             noiseFloorAdaptRateQuiet?: number;
             /**
              * Rate at which noise floor adapts to loud signals (0-1).
-             * Default: 0.05 (faster tracking of rising noise)
+             * Applied when instantaneous SNR < 12dB (background noise).
+             * Default: 0.1 (fast tracking of rising noise)
              */
             noiseFloorAdaptRateLoud?: number;
             /**

package/dist/vad/vad-node.js

@@ -28,7 +28,7 @@ var createEnergyVadWorkletCode = (vadConfig) => {
   const smoothing = energyParams.smoothing ?? 0.95;
   const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
   const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 0.01;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.05;
+  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.1;
   const minSNR = energyParams.minSNR ?? 10;
   const snrRange = energyParams.snrRange ?? 10;
   const minEnergy = energyParams.minEnergy ?? 1e-3;
@@ -70,35 +70,31 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     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
+    // We use a TWO-PASS approach to avoid circular dependencies:
+    // FIRST PASS: Calculate instantaneous SNR to decide how to adapt
+    const instantSnr = instantRms / (this.noiseFloor + 1e-6);
+    const instantSnrDb = 20 * Math.log10(Math.max(1e-6, instantSnr));
+    
+    // Adapt the noise floor based on instantaneous SNR
     if (instantRms < this.noiseFloor) {
-      // If signal is quieter than noise floor, adapt downwards quickly
+      // Signal is quieter than noise floor, adapt downwards quickly
       this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + instantRms * this.noiseFloorAdaptRateQuiet;
+    } else if (instantSnrDb < 12) {
+      // Signal is louder but SNR is low (< 12dB) - likely just louder background noise
+      // Adapt upwards at normal rate to track rising noise
+      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + instantRms * this.noiseFloorAdaptRateLoud;
     } else {
-      // If signal is louder, adapt upwards
-      // We use a multi-stage adaptation rate:
-      // 1. If we are officially speaking, adapt EXTREMELY slowly (0.01x)
-      // 2. If SNR is very high (> 20dB), assume it's speech and adapt very slowly (0.1x)
-      // 3. Otherwise, adapt at the normal loud rate
-      const snr = instantRms / (this.noiseFloor + 1e-6);
-      const snrDb = 20 * Math.log10(Math.max(1e-6, snr));
-      
-      let multiplier = 1.0;
-      if (this.isSpeaking) {
-        multiplier = 0.05;
-      } else if (snrDb > 20) {
-        multiplier = 0.2;
-      }
-      
-      const adaptRate = this.noiseFloorAdaptRateLoud * multiplier;
-      this.noiseFloor = this.noiseFloor * (1 - adaptRate) + instantRms * adaptRate;
+      // Signal has high SNR (>= 12dB) - likely speech or transient
+      // Adapt VERY slowly to avoid "chasing" speech
+      const slowRate = this.noiseFloorAdaptRateLoud * 0.02;
+      this.noiseFloor = this.noiseFloor * (1 - slowRate) + instantRms * slowRate;
     }
 
     // Ensure noise floor doesn't drop to absolute zero
     // 0.00005 is approx -86dB, very quiet but prevents SNR explosion
     this.noiseFloor = Math.max(this.noiseFloor, 0.00005);
 
-    // Calculate Signal-to-Noise Ratio (SNR) in dB using smoothed energy
+    // SECOND PASS: 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));
     

package/dist/vad/vad-node.mjs

@@ -1,6 +1,6 @@
 import {
   EnergyVADPlugin
-} from "../chunk-KEWK2OKV.mjs";
+} from "../chunk-FKR6NWZF.mjs";
 export {
   EnergyVADPlugin
 };

package/dist/vad/vad-state.js

@@ -51,7 +51,7 @@ var VADStateMachine = class {
         smoothing: config?.energyVad?.smoothing ?? 0.95,
         initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
         noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 5e-3,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.01,
+        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.1,
         minSNR: config?.energyVad?.minSNR ?? 10,
         snrRange: config?.energyVad?.snrRange ?? 10,
         minEnergy: config?.energyVad?.minEnergy ?? 1e-3

package/dist/vad/vad-state.mjs

@@ -1,6 +1,6 @@
 import {
   VADStateMachine
-} from "../chunk-DYY2MXMU.mjs";
+} from "../chunk-DLLK6K76.mjs";
 export {
   VADStateMachine
 };

package/package.json

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