@tensamin/audio 0.1.4 → 0.1.5

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

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

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

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

package/dist/{chunk-NMHKX64G.mjs → chunk-VEJXAEMM.mjs}

@@ -18,6 +18,13 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.isSpeaking = false;
+    
+    this.port.onmessage = (event) => {
+      if (event.data && event.data.isSpeaking !== undefined) {
+        this.isSpeaking = event.data.isSpeaking;
+      }
+    };
   }
 
   process(inputs, outputs, parameters) {
@@ -32,14 +39,18 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation
-    // When signal is quiet, adapt quickly to find new noise floor
-    // When signal is loud (speech), adapt slowly to avoid raising noise floor
-    if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-    } else {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
+    // 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;
+      }
     }
+    // During speech, freeze the noise floor to maintain consistent detection
 
     // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
@@ -60,6 +71,7 @@ registerProcessor('energy-vad-processor', EnergyVadProcessor);
 };
 var EnergyVADPlugin = class {
   name = "energy-vad";
+  workletNode = null;
   async createNode(context, config, onDecision) {
     if (!config?.enabled) {
       console.log("VAD disabled, using passthrough node");
@@ -86,6 +98,7 @@ var EnergyVADPlugin = class {
     let node;
     try {
       node = new AudioWorkletNode(context, "energy-vad-processor");
+      this.workletNode = node;
       console.log("Energy VAD node created successfully");
     } catch (e) {
       const error = new Error(
@@ -111,6 +124,11 @@ var EnergyVADPlugin = class {
     };
     return node;
   }
+  updateSpeakingState(isSpeaking) {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage({ isSpeaking });
+    }
+  }
 };
 
 export {

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

@@ -9,7 +9,7 @@ import {
 import {
   getNoiseSuppressionPlugin,
   getVADPlugin
-} from "./chunk-YOSTLLCS.mjs";
+} from "./chunk-H5UKZU2Y.mjs";
 
 // src/pipeline/audio-pipeline.ts
 import mitt from "mitt";
@@ -93,12 +93,16 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     throw err;
   }
   const vadStateMachine = new VADStateMachine(fullConfig.vad);
+  let vadPlugin;
   try {
-    const vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
+    vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
     vadNode = await vadPlugin.createNode(context, fullConfig.vad, (prob) => {
       try {
         const timestamp = context.currentTime * 1e3;
         const newState = vadStateMachine.processFrame(prob, timestamp);
+        if (vadPlugin && typeof vadPlugin.updateSpeakingState === "function") {
+          vadPlugin.updateSpeakingState(newState.isSpeaking);
+        }
         if (newState.state !== lastVadState.state || Math.abs(newState.probability - lastVadState.probability) > 0.1) {
           emitter.emit("vadChange", newState);
           lastVadState = newState;

package/dist/extensibility/plugins.js

@@ -121,6 +121,13 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.isSpeaking = false;
+    
+    this.port.onmessage = (event) => {
+      if (event.data && event.data.isSpeaking !== undefined) {
+        this.isSpeaking = event.data.isSpeaking;
+      }
+    };
   }
 
   process(inputs, outputs, parameters) {
@@ -135,14 +142,18 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation
-    // When signal is quiet, adapt quickly to find new noise floor
-    // When signal is loud (speech), adapt slowly to avoid raising noise floor
-    if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-    } else {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
+    // 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;
+      }
     }
+    // During speech, freeze the noise floor to maintain consistent detection
 
     // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
@@ -163,6 +174,7 @@ registerProcessor('energy-vad-processor', EnergyVadProcessor);
 };
 var EnergyVADPlugin = class {
   name = "energy-vad";
+  workletNode = null;
   async createNode(context, config, onDecision) {
     if (!config?.enabled) {
       console.log("VAD disabled, using passthrough node");
@@ -189,6 +201,7 @@ var EnergyVADPlugin = class {
     let node;
     try {
       node = new AudioWorkletNode(context, "energy-vad-processor");
+      this.workletNode = node;
       console.log("Energy VAD node created successfully");
     } catch (e) {
       const error = new Error(
@@ -214,6 +227,11 @@ var EnergyVADPlugin = class {
     };
     return node;
   }
+  updateSpeakingState(isSpeaking) {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage({ isSpeaking });
+    }
+  }
 };
 
 // src/extensibility/plugins.ts

package/dist/extensibility/plugins.mjs

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

package/dist/index.js

@@ -173,6 +173,13 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.isSpeaking = false;
+    
+    this.port.onmessage = (event) => {
+      if (event.data && event.data.isSpeaking !== undefined) {
+        this.isSpeaking = event.data.isSpeaking;
+      }
+    };
   }
 
   process(inputs, outputs, parameters) {
@@ -187,14 +194,18 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation
-    // When signal is quiet, adapt quickly to find new noise floor
-    // When signal is loud (speech), adapt slowly to avoid raising noise floor
-    if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-    } else {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
+    // 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;
+      }
     }
+    // During speech, freeze the noise floor to maintain consistent detection
 
     // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
@@ -215,6 +226,7 @@ registerProcessor('energy-vad-processor', EnergyVadProcessor);
 };
 var EnergyVADPlugin = class {
   name = "energy-vad";
+  workletNode = null;
   async createNode(context, config, onDecision) {
     if (!config?.enabled) {
       console.log("VAD disabled, using passthrough node");
@@ -241,6 +253,7 @@ var EnergyVADPlugin = class {
     let node;
     try {
       node = new AudioWorkletNode(context, "energy-vad-processor");
+      this.workletNode = node;
       console.log("Energy VAD node created successfully");
     } catch (e) {
       const error = new Error(
@@ -266,6 +279,11 @@ var EnergyVADPlugin = class {
     };
     return node;
   }
+  updateSpeakingState(isSpeaking) {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage({ isSpeaking });
+    }
+  }
 };
 
 // src/extensibility/plugins.ts
@@ -473,12 +491,16 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     throw err;
   }
   const vadStateMachine = new VADStateMachine(fullConfig.vad);
+  let vadPlugin;
   try {
-    const vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
+    vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
     vadNode = await vadPlugin.createNode(context, fullConfig.vad, (prob) => {
       try {
         const timestamp = context.currentTime * 1e3;
         const newState = vadStateMachine.processFrame(prob, timestamp);
+        if (vadPlugin && typeof vadPlugin.updateSpeakingState === "function") {
+          vadPlugin.updateSpeakingState(newState.isSpeaking);
+        }
         if (newState.state !== lastVadState.state || Math.abs(newState.probability - lastVadState.probability) > 0.1) {
           emitter.emit("vadChange", newState);
           lastVadState = newState;

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import "./chunk-WBQAMGXK.mjs";
 import {
   attachProcessingToTrack
-} from "./chunk-ERJVV5JR.mjs";
+} from "./chunk-GVKCBKW6.mjs";
 import {
   createAudioPipeline
-} from "./chunk-AHBRT4RD.mjs";
+} from "./chunk-XXTNAUYX.mjs";
 import {
   VADStateMachine
 } from "./chunk-N553RHTI.mjs";
@@ -21,13 +21,13 @@ import {
   getVADPlugin,
   registerNoiseSuppressionPlugin,
   registerVADPlugin
-} from "./chunk-YOSTLLCS.mjs";
+} from "./chunk-H5UKZU2Y.mjs";
 import {
   RNNoisePlugin
 } from "./chunk-XO6B3D4A.mjs";
 import {
   EnergyVADPlugin
-} from "./chunk-NMHKX64G.mjs";
+} from "./chunk-VEJXAEMM.mjs";
 export {
   EnergyVADPlugin,
   RNNoisePlugin,

package/dist/livekit/integration.js

@@ -142,6 +142,13 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.isSpeaking = false;
+    
+    this.port.onmessage = (event) => {
+      if (event.data && event.data.isSpeaking !== undefined) {
+        this.isSpeaking = event.data.isSpeaking;
+      }
+    };
   }
 
   process(inputs, outputs, parameters) {
@@ -156,14 +163,18 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation
-    // When signal is quiet, adapt quickly to find new noise floor
-    // When signal is loud (speech), adapt slowly to avoid raising noise floor
-    if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-    } else {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
+    // 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;
+      }
     }
+    // During speech, freeze the noise floor to maintain consistent detection
 
     // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
@@ -184,6 +195,7 @@ registerProcessor('energy-vad-processor', EnergyVadProcessor);
 };
 var EnergyVADPlugin = class {
   name = "energy-vad";
+  workletNode = null;
   async createNode(context, config, onDecision) {
     if (!config?.enabled) {
       console.log("VAD disabled, using passthrough node");
@@ -210,6 +222,7 @@ var EnergyVADPlugin = class {
     let node;
     try {
       node = new AudioWorkletNode(context, "energy-vad-processor");
+      this.workletNode = node;
       console.log("Energy VAD node created successfully");
     } catch (e) {
       const error = new Error(
@@ -235,6 +248,11 @@ var EnergyVADPlugin = class {
     };
     return node;
   }
+  updateSpeakingState(isSpeaking) {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage({ isSpeaking });
+    }
+  }
 };
 
 // src/extensibility/plugins.ts
@@ -436,12 +454,16 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     throw err;
   }
   const vadStateMachine = new VADStateMachine(fullConfig.vad);
+  let vadPlugin;
   try {
-    const vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
+    vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
     vadNode = await vadPlugin.createNode(context, fullConfig.vad, (prob) => {
       try {
         const timestamp = context.currentTime * 1e3;
         const newState = vadStateMachine.processFrame(prob, timestamp);
+        if (vadPlugin && typeof vadPlugin.updateSpeakingState === "function") {
+          vadPlugin.updateSpeakingState(newState.isSpeaking);
+        }
         if (newState.state !== lastVadState.state || Math.abs(newState.probability - lastVadState.probability) > 0.1) {
           emitter.emit("vadChange", newState);
           lastVadState = newState;

package/dist/livekit/integration.mjs

@@ -1,12 +1,12 @@
 import {
   attachProcessingToTrack
-} from "../chunk-ERJVV5JR.mjs";
-import "../chunk-AHBRT4RD.mjs";
+} from "../chunk-GVKCBKW6.mjs";
+import "../chunk-XXTNAUYX.mjs";
 import "../chunk-N553RHTI.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-YOSTLLCS.mjs";
+import "../chunk-H5UKZU2Y.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-NMHKX64G.mjs";
+import "../chunk-VEJXAEMM.mjs";
 export {
   attachProcessingToTrack
 };

package/dist/pipeline/audio-pipeline.js

@@ -140,6 +140,13 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.isSpeaking = false;
+    
+    this.port.onmessage = (event) => {
+      if (event.data && event.data.isSpeaking !== undefined) {
+        this.isSpeaking = event.data.isSpeaking;
+      }
+    };
   }
 
   process(inputs, outputs, parameters) {
@@ -154,14 +161,18 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation
-    // When signal is quiet, adapt quickly to find new noise floor
-    // When signal is loud (speech), adapt slowly to avoid raising noise floor
-    if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-    } else {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
+    // 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;
+      }
     }
+    // During speech, freeze the noise floor to maintain consistent detection
 
     // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
@@ -182,6 +193,7 @@ registerProcessor('energy-vad-processor', EnergyVadProcessor);
 };
 var EnergyVADPlugin = class {
   name = "energy-vad";
+  workletNode = null;
   async createNode(context, config, onDecision) {
     if (!config?.enabled) {
       console.log("VAD disabled, using passthrough node");
@@ -208,6 +220,7 @@ var EnergyVADPlugin = class {
     let node;
     try {
       node = new AudioWorkletNode(context, "energy-vad-processor");
+      this.workletNode = node;
       console.log("Energy VAD node created successfully");
     } catch (e) {
       const error = new Error(
@@ -233,6 +246,11 @@ var EnergyVADPlugin = class {
     };
     return node;
   }
+  updateSpeakingState(isSpeaking) {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage({ isSpeaking });
+    }
+  }
 };
 
 // src/extensibility/plugins.ts
@@ -434,12 +452,16 @@ async function createAudioPipeline(sourceTrack, config = {}) {
     throw err;
   }
   const vadStateMachine = new VADStateMachine(fullConfig.vad);
+  let vadPlugin;
   try {
-    const vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
+    vadPlugin = getVADPlugin(fullConfig.vad?.pluginName);
     vadNode = await vadPlugin.createNode(context, fullConfig.vad, (prob) => {
       try {
         const timestamp = context.currentTime * 1e3;
         const newState = vadStateMachine.processFrame(prob, timestamp);
+        if (vadPlugin && typeof vadPlugin.updateSpeakingState === "function") {
+          vadPlugin.updateSpeakingState(newState.isSpeaking);
+        }
         if (newState.state !== lastVadState.state || Math.abs(newState.probability - lastVadState.probability) > 0.1) {
           emitter.emit("vadChange", newState);
           lastVadState = newState;

package/dist/pipeline/audio-pipeline.mjs

@@ -1,11 +1,11 @@
 import {
   createAudioPipeline
-} from "../chunk-AHBRT4RD.mjs";
+} from "../chunk-XXTNAUYX.mjs";
 import "../chunk-N553RHTI.mjs";
 import "../chunk-OZ7KMC4S.mjs";
-import "../chunk-YOSTLLCS.mjs";
+import "../chunk-H5UKZU2Y.mjs";
 import "../chunk-XO6B3D4A.mjs";
-import "../chunk-NMHKX64G.mjs";
+import "../chunk-VEJXAEMM.mjs";
 export {
   createAudioPipeline
 };

package/dist/vad/vad-node.d.mts

@@ -3,7 +3,9 @@ import 'mitt';
 
 declare class EnergyVADPlugin implements VADPlugin {
     name: string;
+    private workletNode;
     createNode(context: AudioContext, config: AudioProcessingConfig["vad"], onDecision: (probability: number) => void): Promise<AudioNode>;
+    updateSpeakingState(isSpeaking: boolean): void;
 }
 
 export { EnergyVADPlugin };

package/dist/vad/vad-node.d.ts

@@ -3,7 +3,9 @@ import 'mitt';
 
 declare class EnergyVADPlugin implements VADPlugin {
     name: string;
+    private workletNode;
     createNode(context: AudioContext, config: AudioProcessingConfig["vad"], onDecision: (probability: number) => void): Promise<AudioNode>;
+    updateSpeakingState(isSpeaking: boolean): void;
 }
 
 export { EnergyVADPlugin };

package/dist/vad/vad-node.js

@@ -42,6 +42,13 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
     this.minSNR = ${minSNR};
     this.snrRange = ${snrRange};
+    this.isSpeaking = false;
+    
+    this.port.onmessage = (event) => {
+      if (event.data && event.data.isSpeaking !== undefined) {
+        this.isSpeaking = event.data.isSpeaking;
+      }
+    };
   }
 
   process(inputs, outputs, parameters) {
@@ -56,14 +63,18 @@ class EnergyVadProcessor extends AudioWorkletProcessor {
     }
     const rms = Math.sqrt(sum / channel.length);
 
-    // Adaptive noise floor estimation
-    // When signal is quiet, adapt quickly to find new noise floor
-    // When signal is loud (speech), adapt slowly to avoid raising noise floor
-    if (rms < this.noiseFloor) {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + rms * this.noiseFloorAdaptRateQuiet;
-    } else {
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + rms * this.noiseFloorAdaptRateLoud;
+    // 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;
+      }
     }
+    // During speech, freeze the noise floor to maintain consistent detection
 
     // Calculate Signal-to-Noise Ratio (SNR)
     const snr = rms / (this.noiseFloor + 1e-6);
@@ -84,6 +95,7 @@ registerProcessor('energy-vad-processor', EnergyVadProcessor);
 };
 var EnergyVADPlugin = class {
   name = "energy-vad";
+  workletNode = null;
   async createNode(context, config, onDecision) {
     if (!config?.enabled) {
       console.log("VAD disabled, using passthrough node");
@@ -110,6 +122,7 @@ var EnergyVADPlugin = class {
     let node;
     try {
       node = new AudioWorkletNode(context, "energy-vad-processor");
+      this.workletNode = node;
       console.log("Energy VAD node created successfully");
     } catch (e) {
       const error = new Error(
@@ -135,6 +148,11 @@ var EnergyVADPlugin = class {
     };
     return node;
   }
+  updateSpeakingState(isSpeaking) {
+    if (this.workletNode) {
+      this.workletNode.port.postMessage({ isSpeaking });
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/vad/vad-node.mjs

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

package/package.json

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