@tensamin/audio 0.1.14 → 0.2.0

package/dist/livekit/integration.js

@@ -30,9 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/livekit/integration.ts
 var integration_exports = {};
 __export(integration_exports, {
-  attachProcessingToTrack: () => attachProcessingToTrack
+  attachSpeakingDetectionToTrack: () => attachSpeakingDetectionToTrack
 });
 module.exports = __toCommonJS(integration_exports);
+var import_mitt2 = require("mitt");
 
 // src/pipeline/audio-pipeline.ts
 var import_mitt = __toESM(require("mitt"));
@@ -58,371 +59,171 @@ function unregisterPipeline() {
   activePipelines = Math.max(0, activePipelines - 1);
 }
 
-// src/noise-suppression/rnnoise-node.ts
-var RNNoisePlugin = class {
-  name = "rnnoise-ns";
-  wasmBuffer = null;
-  async createNode(context, config) {
-    const { loadRnnoise, RnnoiseWorkletNode } = await import("@sapphi-red/web-noise-suppressor");
-    if (!config?.enabled) {
-      console.log("Noise suppression disabled, using passthrough node");
-      const pass = context.createGain();
-      return pass;
-    }
-    if (!config?.wasmUrl || !config?.simdUrl || !config?.workletUrl) {
-      const error = new Error(
-        `RNNoisePlugin requires 'wasmUrl', 'simdUrl', and 'workletUrl' to be configured. Please download the assets from @sapphi-red/web-noise-suppressor and provide the URLs in the config. Current config: wasmUrl=${config?.wasmUrl}, simdUrl=${config?.simdUrl}, workletUrl=${config?.workletUrl}
-To disable noise suppression, set noiseSuppression.enabled to false.`
-      );
-      console.error(error.message);
-      throw error;
-    }
-    try {
-      if (!this.wasmBuffer) {
-        console.log("Loading RNNoise WASM binary...");
-        this.wasmBuffer = await loadRnnoise({
-          url: config.wasmUrl,
-          simdUrl: config.simdUrl
-        });
-        console.log("RNNoise WASM loaded successfully");
+// src/noise-suppression/deepfilternet-node.ts
+var import_deepfilternet3_noise_filter = require("deepfilternet3-noise-filter");
+async function createDeepFilterNet3Node(context, config) {
+  const processorConfig = {
+    sampleRate: context.sampleRate,
+    noiseReductionLevel: config?.noiseReductionLevel ?? 60
+  };
+  if (config?.assetConfig) {
+    processorConfig.assetConfig = config.assetConfig;
+  }
+  const processor = new import_deepfilternet3_noise_filter.DeepFilterNet3Processor(processorConfig);
+  await processor.initialize();
+  const node = await processor.createAudioWorkletNode(context);
+  const enabled = config?.enabled ?? true;
+  if (!enabled) {
+    processor.setNoiseSuppressionEnabled(false);
+  }
+  return {
+    node,
+    processor,
+    dispose: () => {
+      try {
+        processor.destroy();
+      } catch (error) {
+        console.error("Failed to dispose DeepFilterNet3 processor", error);
       }
-    } catch (error) {
-      const err = new Error(
-        `Failed to load RNNoise WASM binary: ${error instanceof Error ? error.message : String(error)}`
-      );
-      console.error(err);
-      throw err;
-    }
-    const workletUrl = config.workletUrl;
-    try {
-      await context.audioWorklet.addModule(workletUrl);
-      console.log("RNNoise worklet loaded successfully");
-    } catch (e) {
-      const error = new Error(
-        `Failed to load RNNoise worklet from ${workletUrl}: ${e instanceof Error ? e.message : String(e)}. Ensure the workletUrl points to a valid RNNoise worklet script.`
-      );
-      console.error(error.message);
-      throw error;
     }
-    try {
-      const node = new RnnoiseWorkletNode(context, {
-        wasmBinary: this.wasmBuffer,
-        maxChannels: 1
-        // Mono for now
-      });
-      console.log("RNNoise worklet node created successfully");
-      return node;
-    } catch (error) {
-      const err = new Error(
-        `Failed to create RNNoise worklet node: ${error instanceof Error ? error.message : String(error)}`
-      );
-      console.error(err);
-      throw err;
-    }
-  }
-};
+  };
+}
 
 // src/vad/vad-node.ts
-var createEnergyVadWorkletCode = (vadConfig) => {
-  const energyParams = vadConfig?.energyVad || {};
-  const smoothing = energyParams.smoothing ?? 0.95;
-  const initialNoiseFloor = energyParams.initialNoiseFloor ?? 1e-3;
-  const noiseFloorAdaptRateQuiet = energyParams.noiseFloorAdaptRateQuiet ?? 2e-3;
-  const noiseFloorAdaptRateLoud = energyParams.noiseFloorAdaptRateLoud ?? 0.02;
-  const minSNR = energyParams.minSNR ?? 12;
-  const snrRange = energyParams.snrRange ?? 10;
-  const minEnergy = energyParams.minEnergy ?? 3e-3;
+function createLevelDetectorWorkletCode(smoothing) {
   return `
-class EnergyVadProcessor extends AudioWorkletProcessor {
+class LevelDetectorProcessor extends AudioWorkletProcessor {
   constructor() {
     super();
+    this.smoothed = 0;
     this.smoothing = ${smoothing};
-    this.energy = 0;
-    this.noiseFloor = ${initialNoiseFloor};
-    this.noiseFloorAdaptRateQuiet = ${noiseFloorAdaptRateQuiet};
-    this.noiseFloorAdaptRateLoud = ${noiseFloorAdaptRateLoud};
-    this.minSNR = ${minSNR};
-    this.snrRange = ${snrRange};
-    this.minEnergy = ${minEnergy};
-    this.isSpeaking = false;
-    
-    this.port.onmessage = (event) => {
-      if (event.data && event.data.isSpeaking !== undefined) {
-        this.isSpeaking = event.data.isSpeaking;
-      }
-    };
   }
 
-  process(inputs, outputs, parameters) {
+  process(inputs) {
     const input = inputs[0];
-    if (!input || !input.length) return true;
+    if (!input || input.length === 0) return true;
     const channel = input[0];
-    
-    // Calculate instantaneous RMS (Root Mean Square) energy
+    if (!channel || channel.length === 0) return true;
+
     let sum = 0;
-    let peak = 0;
     for (let i = 0; i < channel.length; i++) {
-      const sample = Math.abs(channel[i]);
-      sum += channel[i] * channel[i];
-      peak = Math.max(peak, sample);
+      const sample = channel[i];
+      sum += sample * sample;
     }
-    const instantRms = Math.sqrt(sum / channel.length);
-
-    // 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);
-
-    // Calculate Crest Factor (peak-to-RMS ratio)
-    // Voice typically has crest factor of 2-4 (6-12dB)
-    // Keyboard clicks have crest factor of 10-30+ (20-30dB)
-    const crestFactor = peak / (instantRms + 1e-10);
-    const crestFactorDb = 20 * Math.log10(Math.max(1e-6, crestFactor));
-
-    // Adaptive noise floor estimation using SMOOTHED energy (not instantaneous)
-    // This prevents sharp transients from affecting the noise floor
-    if (this.energy < this.noiseFloor) {
-      // Signal is quieter than noise floor, adapt downwards slowly
-      this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateQuiet) + this.energy * this.noiseFloorAdaptRateQuiet;
-    } else {
-      // Calculate SNR based on smoothed energy
-      const smoothedSnr = this.energy / (this.noiseFloor + 1e-6);
-      const smoothedSnrDb = 20 * Math.log10(Math.max(1e-6, smoothedSnr));
-      
-      // Only adapt upwards if:
-      // 1. SNR is low (< 10dB) - likely just background noise
-      // 2. AND crest factor is low (< 15dB) - not a sharp transient
-      if (smoothedSnrDb < 10 && crestFactorDb < 15) {
-        // This is persistent background noise, adapt upwards
-        this.noiseFloor = this.noiseFloor * (1 - this.noiseFloorAdaptRateLoud) + this.energy * this.noiseFloorAdaptRateLoud;
-      } else {
-        // Either high SNR (speech) or high crest factor (click) - adapt very slowly
-        const slowRate = this.noiseFloorAdaptRateLoud * 0.01;
-        this.noiseFloor = this.noiseFloor * (1 - slowRate) + this.energy * slowRate;
-      }
-    }
-
-    // Ensure noise floor doesn't drop to absolute zero
-    this.noiseFloor = Math.max(this.noiseFloor, 0.0001);
-
-    // 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));
-    
-    // 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)
-    let probability = Math.min(1, Math.max(0, (snrDb - this.minSNR) / this.snrRange));
-
-    // Apply absolute energy threshold with soft knee
-    if (this.energy < this.minEnergy) {
-      const energyRatio = this.energy / (this.minEnergy + 1e-6);
-      probability *= Math.pow(energyRatio, 2);
-    }
-
-    // Apply crest factor penalty
-    // Reject signals with high crest factor (sharp transients like keyboard clicks)
-    // Voice: 6-12dB, Keyboard: 20-30dB
-    // We penalize anything above 14dB
-    if (crestFactorDb > 14) {
-      const excess = crestFactorDb - 14;
-      const penalty = Math.max(0, 1 - (excess / 10)); // Linear falloff over 10dB
-      probability *= penalty;
-    }
-
-    this.port.postMessage({ probability, snr: snrDb, noiseFloor: this.noiseFloor, rms: this.energy });
-
+    const rms = Math.sqrt(sum / channel.length);
+    this.smoothed = this.smoothed * this.smoothing + rms * (1 - this.smoothing);
+    const levelDb = 20 * Math.log10(Math.max(1e-8, this.smoothed));
+    this.port.postMessage({ levelDb });
     return true;
   }
 }
-registerProcessor('energy-vad-processor', EnergyVadProcessor);
+
+registerProcessor('level-detector-processor', LevelDetectorProcessor);
 `;
-};
-var EnergyVADPlugin = class {
-  name = "energy-vad";
-  workletNode = null;
-  async createNode(context, config, onDecision) {
-    if (!config?.enabled) {
-      console.log("VAD disabled, using passthrough node");
-      const pass = context.createGain();
-      return pass;
-    }
-    const workletCode = createEnergyVadWorkletCode(config);
-    const blob = new Blob([workletCode], {
-      type: "application/javascript"
-    });
-    const url = URL.createObjectURL(blob);
-    try {
-      await context.audioWorklet.addModule(url);
-      console.log("Energy VAD worklet loaded successfully");
-    } catch (e) {
-      const error = new Error(
-        `Failed to load Energy VAD worklet: ${e instanceof Error ? e.message : String(e)}`
-      );
-      console.error(error.message);
-      URL.revokeObjectURL(url);
-      throw error;
-    }
+}
+async function createLevelDetectorNode(context, onLevel, options) {
+  const smoothing = options?.smoothing ?? 0.9;
+  const workletCode = createLevelDetectorWorkletCode(smoothing);
+  const blob = new Blob([workletCode], { type: "application/javascript" });
+  const url = URL.createObjectURL(blob);
+  try {
+    await context.audioWorklet.addModule(url);
+  } finally {
     URL.revokeObjectURL(url);
-    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(
-        `Failed to create Energy VAD node: ${e instanceof Error ? e.message : String(e)}`
-      );
-      console.error(error.message);
-      throw error;
+  }
+  const node = new AudioWorkletNode(context, "level-detector-processor", {
+    numberOfInputs: 1,
+    numberOfOutputs: 0
+  });
+  node.port.onmessage = (event) => {
+    const { levelDb } = event.data ?? {};
+    if (typeof levelDb === "number" && !Number.isNaN(levelDb)) {
+      onLevel(levelDb);
     }
-    node.port.onmessage = (event) => {
+  };
+  node.port.onmessageerror = (event) => {
+    console.error("Level detector port error", event);
+  };
+  return {
+    node,
+    dispose: () => {
       try {
-        const { probability } = event.data;
-        if (typeof probability === "number" && !isNaN(probability)) {
-          onDecision(probability);
-        } else {
-          console.warn("Invalid VAD probability received:", event.data);
-        }
+        node.port.onmessage = null;
+        node.port.close();
       } catch (error) {
-        console.error("Error in VAD message handler:", error);
+        console.error("Failed to dispose level detector node", error);
       }
-    };
-    node.port.onmessageerror = (event) => {
-      console.error("VAD port message error:", event);
-    };
-    return node;
-  }
-  updateSpeakingState(isSpeaking) {
-    if (this.workletNode) {
-      this.workletNode.port.postMessage({ isSpeaking });
     }
-  }
-};
-
-// src/extensibility/plugins.ts
-var nsPlugins = /* @__PURE__ */ new Map();
-var vadPlugins = /* @__PURE__ */ new Map();
-var defaultNs = new RNNoisePlugin();
-nsPlugins.set(defaultNs.name, defaultNs);
-var defaultVad = new EnergyVADPlugin();
-vadPlugins.set(defaultVad.name, defaultVad);
-function getNoiseSuppressionPlugin(name) {
-  if (!name) return defaultNs;
-  const plugin = nsPlugins.get(name);
-  if (!plugin) {
-    console.warn(
-      `Noise suppression plugin '${name}' not found, falling back to default.`
-    );
-    return defaultNs;
-  }
-  return plugin;
-}
-function getVADPlugin(name) {
-  if (!name) return defaultVad;
-  const plugin = vadPlugins.get(name);
-  if (!plugin) {
-    console.warn(`VAD plugin '${name}' not found, falling back to default.`);
-    return defaultVad;
-  }
-  return plugin;
+  };
 }
 
 // src/vad/vad-state.ts
-var VADStateMachine = class {
+var LevelBasedVAD = class {
   config;
-  currentState = "silent";
-  lastSpeechTime = 0;
-  speechStartTime = 0;
-  lastSilenceTime = 0;
-  frameDurationMs = 20;
-  // Assumed frame duration, updated by calls
+  speaking = false;
+  pendingSpeechSince = null;
+  pendingSilenceSince = null;
   constructor(config) {
     this.config = {
-      enabled: config?.enabled ?? true,
-      pluginName: config?.pluginName ?? "energy-vad",
-      // Voice-optimized defaults
-      startThreshold: config?.startThreshold ?? 0.8,
-      // Higher threshold to avoid noise
-      stopThreshold: config?.stopThreshold ?? 0.3,
-      // Balanced for voice
-      hangoverMs: config?.hangoverMs ?? 300,
-      // Smooth for natural speech
-      preRollMs: config?.preRollMs ?? 250,
-      // Generous pre-roll
-      minSpeechDurationMs: config?.minSpeechDurationMs ?? 250,
-      // Aggressive transient rejection
-      minSilenceDurationMs: config?.minSilenceDurationMs ?? 150,
-      energyVad: {
-        smoothing: config?.energyVad?.smoothing ?? 0.95,
-        initialNoiseFloor: config?.energyVad?.initialNoiseFloor ?? 1e-3,
-        noiseFloorAdaptRateQuiet: config?.energyVad?.noiseFloorAdaptRateQuiet ?? 2e-3,
-        noiseFloorAdaptRateLoud: config?.energyVad?.noiseFloorAdaptRateLoud ?? 0.02,
-        minSNR: config?.energyVad?.minSNR ?? 12,
-        snrRange: config?.energyVad?.snrRange ?? 10,
-        minEnergy: config?.energyVad?.minEnergy ?? 3e-3
-      }
+      minDb: config.minDb,
+      maxDb: config.maxDb,
+      speakOnRatio: config.speakOnRatio ?? 0.6,
+      speakOffRatio: config.speakOffRatio ?? 0.3,
+      hangoverMs: config.hangoverMs ?? 350,
+      attackMs: config.attackMs ?? 50,
+      releaseMs: config.releaseMs ?? 120
     };
-    this.lastSilenceTime = Date.now();
   }
   updateConfig(config) {
-    this.config = { ...this.config, ...config };
+    this.config = {
+      ...this.config,
+      ...config,
+      speakOnRatio: config.speakOnRatio ?? this.config.speakOnRatio,
+      speakOffRatio: config.speakOffRatio ?? this.config.speakOffRatio,
+      hangoverMs: config.hangoverMs ?? this.config.hangoverMs,
+      attackMs: config.attackMs ?? this.config.attackMs,
+      releaseMs: config.releaseMs ?? this.config.releaseMs
+    };
   }
-  processFrame(probability, timestamp) {
+  process(levelDb, timestampMs) {
     const {
-      startThreshold,
-      stopThreshold,
+      minDb,
+      maxDb,
+      speakOnRatio,
+      speakOffRatio,
       hangoverMs,
-      minSpeechDurationMs,
-      minSilenceDurationMs
+      attackMs,
+      releaseMs
     } = this.config;
-    let newState = this.currentState;
-    if (this.currentState === "silent" || this.currentState === "speech_ending") {
-      if (probability >= startThreshold) {
-        const silenceDuration = timestamp - this.lastSilenceTime;
-        if (silenceDuration >= minSilenceDurationMs) {
-          newState = "speech_starting";
-          this.speechStartTime = timestamp;
-          this.lastSpeechTime = timestamp;
-        } else {
-          newState = "silent";
+    const clamped = Math.min(maxDb, Math.max(minDb, levelDb));
+    const norm = (clamped - minDb) / Math.max(1, maxDb - minDb);
+    if (!this.speaking) {
+      if (norm >= speakOnRatio) {
+        this.pendingSpeechSince = this.pendingSpeechSince ?? timestampMs;
+        if (timestampMs - this.pendingSpeechSince >= attackMs) {
+          this.speaking = true;
+          this.pendingSpeechSince = null;
+          this.pendingSilenceSince = null;
         }
       } else {
-        newState = "silent";
-        this.lastSilenceTime = timestamp;
+        this.pendingSpeechSince = null;
       }
-    } else if (this.currentState === "speech_starting") {
-      if (probability >= stopThreshold) {
-        const speechDuration = timestamp - this.speechStartTime;
-        if (speechDuration >= minSpeechDurationMs) {
-          newState = "speaking";
-        } else {
-          newState = "speech_starting";
+    } else {
+      if (norm <= speakOffRatio) {
+        this.pendingSilenceSince = this.pendingSilenceSince ?? timestampMs;
+        const releaseWindow = Math.max(releaseMs, hangoverMs);
+        if (timestampMs - this.pendingSilenceSince >= releaseWindow) {
+          this.speaking = false;
+          this.pendingSilenceSince = null;
+          this.pendingSpeechSince = null;
         }
-        this.lastSpeechTime = timestamp;
       } else {
-        newState = "silent";
-        this.lastSilenceTime = timestamp;
-      }
-    } else if (this.currentState === "speaking") {
-      if (probability >= stopThreshold) {
-        newState = "speaking";
-        this.lastSpeechTime = timestamp;
-      } else {
-        const timeSinceSpeech = timestamp - this.lastSpeechTime;
-        if (timeSinceSpeech < hangoverMs) {
-          newState = "speaking";
-        } else {
-          newState = "speech_ending";
-          this.lastSilenceTime = timestamp;
-        }
+        this.pendingSilenceSince = null;
       }
     }
-    if (newState === "speech_ending") newState = "silent";
-    this.currentState = newState;
     return {
-      isSpeaking: newState === "speaking",
-      probability,
-      state: newState
+      speaking: this.speaking,
+      levelDb: clamped
     };
   }
 };
@@ -431,58 +232,33 @@ var VADStateMachine = class {
 async function createAudioPipeline(sourceTrack, config = {}) {
   const context = getAudioContext();
   registerPipeline();
-  const nsEnabled = config.noiseSuppression?.enabled !== false && Boolean(
-    config.noiseSuppression?.wasmUrl && config.noiseSuppression?.simdUrl && config.noiseSuppression?.workletUrl
-  );
-  const vadEnabled = config.vad?.enabled !== false;
+  const nsConfig = {
+    enabled: config.noiseSuppression?.enabled ?? true,
+    noiseReductionLevel: config.noiseSuppression?.noiseReductionLevel ?? 60
+  };
+  if (config.noiseSuppression?.assetConfig) {
+    nsConfig.assetConfig = config.noiseSuppression.assetConfig;
+  }
   const fullConfig = {
-    noiseSuppression: {
-      enabled: nsEnabled,
-      ...config.noiseSuppression
-    },
-    vad: {
-      enabled: vadEnabled,
-      // Voice-optimized defaults (will be overridden by config)
-      startThreshold: 0.6,
-      stopThreshold: 0.45,
-      hangoverMs: 400,
-      preRollMs: 250,
-      minSpeechDurationMs: 100,
-      minSilenceDurationMs: 150,
-      energyVad: {
-        smoothing: 0.95,
-        initialNoiseFloor: 1e-3,
-        noiseFloorAdaptRateQuiet: 0.01,
-        noiseFloorAdaptRateLoud: 1e-3,
-        minSNR: 2,
-        snrRange: 8
-      },
-      ...config.vad
+    noiseSuppression: nsConfig,
+    speaking: {
+      minDb: config.speaking?.minDb ?? -60,
+      maxDb: config.speaking?.maxDb ?? -20,
+      speakOnRatio: config.speaking?.speakOnRatio ?? 0.6,
+      speakOffRatio: config.speaking?.speakOffRatio ?? 0.3,
+      hangoverMs: config.speaking?.hangoverMs ?? 350,
+      attackMs: config.speaking?.attackMs ?? 50,
+      releaseMs: config.speaking?.releaseMs ?? 120
     },
     output: {
-      speechGain: 1,
-      silenceGain: 0,
-      // Full mute for voice-only
-      gainRampTime: 0.015,
-      // Fast but smooth transitions
-      smoothTransitions: true,
-      maxGainDb: 6,
-      enableCompression: false,
-      compression: {
-        threshold: -24,
-        ratio: 3,
-        attack: 3e-3,
-        release: 0.05
-      },
-      ...config.output
+      speechGain: config.output?.speechGain ?? 1,
+      silenceGain: config.output?.silenceGain ?? 0,
+      gainRampTime: config.output?.gainRampTime ?? 0.015,
+      maxGainDb: config.output?.maxGainDb ?? 6,
+      smoothTransitions: config.output?.smoothTransitions ?? true
     },
-    livekit: { manageTrackMute: false, ...config.livekit }
+    muteWhenSilent: config.muteWhenSilent ?? false
   };
-  console.log("Audio pipeline config:", {
-    noiseSuppression: fullConfig.noiseSuppression?.enabled,
-    vad: fullConfig.vad?.enabled,
-    output: fullConfig.output
-  });
   if (!sourceTrack || sourceTrack.kind !== "audio") {
     throw new Error(
       "createAudioPipeline requires a valid audio MediaStreamTrack"
@@ -493,318 +269,196 @@ async function createAudioPipeline(sourceTrack, config = {}) {
   }
   const sourceStream = new MediaStream([sourceTrack]);
   const sourceNode = context.createMediaStreamSource(sourceStream);
-  let nsNode;
-  let vadNode;
   const emitter = (0, import_mitt.default)();
-  try {
-    const nsPlugin = getNoiseSuppressionPlugin(
-      fullConfig.noiseSuppression?.pluginName
-    );
-    nsNode = await nsPlugin.createNode(context, fullConfig.noiseSuppression);
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    console.error("Failed to create noise suppression node:", err);
-    emitter.emit("error", err);
-    throw err;
-  }
-  const vadStateMachine = new VADStateMachine(fullConfig.vad);
-  let vadPlugin;
-  try {
-    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;
-          updateGain(newState);
-        }
-      } catch (vadError) {
-        const err = vadError instanceof Error ? vadError : new Error(String(vadError));
-        console.error("Error in VAD callback:", err);
-        emitter.emit("error", err);
+  const vad = new LevelBasedVAD(fullConfig.speaking);
+  let lastState = { speaking: false, levelDb: -Infinity };
+  const nsHandle = await createDeepFilterNet3Node(
+    context,
+    fullConfig.noiseSuppression
+  );
+  const levelHandle = await createLevelDetectorNode(context, (levelDb) => {
+    try {
+      const timestamp = context.currentTime * 1e3;
+      const nextState = vad.process(levelDb, timestamp);
+      const speakingChanged = nextState.speaking !== lastState.speaking;
+      const levelChanged = Math.abs(nextState.levelDb - lastState.levelDb) > 0.5;
+      if (speakingChanged || levelChanged) {
+        lastState = nextState;
+        updateGain(nextState);
+        emitter.emit("speakingChange", nextState);
       }
-    });
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    console.error("Failed to create VAD node:", err);
-    emitter.emit("error", err);
-    throw err;
-  }
-  let lastVadState = {
-    isSpeaking: false,
-    probability: 0,
-    state: "silent"
-  };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      emitter.emit("error", err);
+    }
+  });
   const splitter = context.createGain();
-  sourceNode.connect(nsNode);
-  nsNode.connect(splitter);
-  splitter.connect(vadNode);
-  const delayNode = context.createDelay(1);
-  const preRollSeconds = (fullConfig.vad?.preRollMs ?? 250) / 1e3;
-  delayNode.delayTime.value = preRollSeconds;
+  sourceNode.connect(nsHandle.node);
+  nsHandle.node.connect(splitter);
+  splitter.connect(levelHandle.node);
   const gainNode = context.createGain();
   gainNode.gain.value = fullConfig.output?.silenceGain ?? 0;
-  let compressor = null;
-  if (fullConfig.output?.enableCompression) {
-    compressor = context.createDynamicsCompressor();
-    const comp = fullConfig.output.compression;
-    compressor.threshold.value = comp.threshold ?? -24;
-    compressor.ratio.value = comp.ratio ?? 3;
-    compressor.attack.value = comp.attack ?? 3e-3;
-    compressor.release.value = comp.release ?? 0.05;
-    compressor.knee.value = 10;
-  }
+  splitter.connect(gainNode);
   const destination = context.createMediaStreamDestination();
-  try {
-    splitter.connect(delayNode);
-    delayNode.connect(gainNode);
-    if (compressor) {
-      gainNode.connect(compressor);
-      compressor.connect(destination);
-      console.log("Compression enabled:", fullConfig.output?.compression);
-    } else {
-      gainNode.connect(destination);
-    }
-  } catch (error) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    console.error("Failed to wire audio pipeline:", err);
-    emitter.emit("error", err);
-    throw err;
-  }
+  gainNode.connect(destination);
   function updateGain(state) {
-    try {
-      const {
-        speechGain = 1,
-        silenceGain = 0,
-        gainRampTime = 0.015,
-        smoothTransitions = true,
-        maxGainDb = 6
-      } = fullConfig.output;
-      const maxGainLinear = Math.pow(10, maxGainDb / 20);
-      const limitedSpeechGain = Math.min(speechGain, maxGainLinear);
-      const targetGain = state.isSpeaking ? limitedSpeechGain : silenceGain;
-      const now = context.currentTime;
-      if (smoothTransitions) {
-        gainNode.gain.cancelScheduledValues(now);
-        gainNode.gain.setValueAtTime(gainNode.gain.value, now);
-        gainNode.gain.setTargetAtTime(targetGain, now, gainRampTime / 3);
-      } else {
-        gainNode.gain.setValueAtTime(targetGain, now);
-      }
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("Failed to update gain:", err);
-      emitter.emit("error", err);
+    const {
+      speechGain = 1,
+      silenceGain = 0,
+      gainRampTime = 0.015,
+      smoothTransitions = true,
+      maxGainDb = 6
+    } = fullConfig.output ?? {};
+    const maxGainLinear = Math.pow(10, maxGainDb / 20);
+    const limitedSpeechGain = Math.min(speechGain ?? 1, maxGainLinear);
+    const target = state.speaking ? limitedSpeechGain : silenceGain ?? 0;
+    const now = context.currentTime;
+    gainNode.gain.cancelScheduledValues(now);
+    gainNode.gain.setValueAtTime(gainNode.gain.value, now);
+    if (smoothTransitions) {
+      gainNode.gain.setTargetAtTime(target, now, gainRampTime / 3);
+    } else {
+      gainNode.gain.setValueAtTime(target, now);
     }
   }
   const audioTracks = destination.stream.getAudioTracks();
-  console.log("Destination stream tracks:", {
-    count: audioTracks.length,
-    tracks: audioTracks.map((t) => ({
-      id: t.id,
-      label: t.label,
-      enabled: t.enabled,
-      readyState: t.readyState
-    }))
-  });
   if (audioTracks.length === 0) {
-    const err = new Error(
-      "Failed to create processed audio track: destination stream has no audio tracks. This may indicate an issue with the audio graph connection."
-    );
-    console.error(err);
-    emitter.emit("error", err);
-    throw err;
+    nsHandle.dispose();
+    levelHandle.dispose();
+    unregisterPipeline();
+    throw new Error("Failed to create processed audio track");
   }
   const processedTrack = audioTracks[0];
-  if (!processedTrack || processedTrack.readyState === "ended") {
-    const err = new Error("Processed audio track is invalid or ended");
-    console.error(err);
-    emitter.emit("error", err);
-    throw err;
-  }
-  console.log("Audio pipeline created successfully:", {
-    sourceTrack: {
-      id: sourceTrack.id,
-      label: sourceTrack.label,
-      readyState: sourceTrack.readyState
-    },
-    processedTrack: {
-      id: processedTrack.id,
-      label: processedTrack.label,
-      readyState: processedTrack.readyState
-    },
-    config: {
-      noiseSuppression: fullConfig.noiseSuppression?.enabled,
-      vad: fullConfig.vad?.enabled
-    }
-  });
   function dispose() {
     try {
       sourceNode.disconnect();
-      nsNode.disconnect();
+      nsHandle.node.disconnect();
       splitter.disconnect();
-      vadNode.disconnect();
-      delayNode.disconnect();
+      levelHandle.node.disconnect();
       gainNode.disconnect();
-      if (compressor) {
-        compressor.disconnect();
-      }
       destination.stream.getTracks().forEach((t) => t.stop());
-      unregisterPipeline();
+      levelHandle.dispose();
+      nsHandle.dispose();
     } catch (error) {
-      console.error("Error during pipeline disposal:", error);
+      console.error("Error during pipeline disposal", error);
+    } finally {
+      unregisterPipeline();
     }
   }
-  return {
+  const handle = {
     processedTrack,
     events: emitter,
     get state() {
-      return lastVadState;
+      return lastState;
     },
-    setConfig: (newConfig) => {
+    setConfig: (next) => {
       try {
-        if (newConfig.vad) {
-          vadStateMachine.updateConfig(newConfig.vad);
-          Object.assign(fullConfig.vad, newConfig.vad);
-          if (newConfig.vad.preRollMs !== void 0) {
-            const preRollSeconds2 = newConfig.vad.preRollMs / 1e3;
-            delayNode.delayTime.setValueAtTime(
-              preRollSeconds2,
-              context.currentTime
-            );
-          }
+        if (next.speaking) {
+          vad.updateConfig(next.speaking);
+          fullConfig.speaking = { ...fullConfig.speaking, ...next.speaking };
+        }
+        if (next.output) {
+          fullConfig.output = { ...fullConfig.output, ...next.output };
+          updateGain(lastState);
         }
-        if (newConfig.output) {
-          Object.assign(fullConfig.output, newConfig.output);
-          updateGain(lastVadState);
-          if (compressor && newConfig.output.compression) {
-            const comp = newConfig.output.compression;
-            if (comp.threshold !== void 0) {
-              compressor.threshold.setValueAtTime(
-                comp.threshold,
-                context.currentTime
-              );
-            }
-            if (comp.ratio !== void 0) {
-              compressor.ratio.setValueAtTime(comp.ratio, context.currentTime);
-            }
-            if (comp.attack !== void 0) {
-              compressor.attack.setValueAtTime(
-                comp.attack,
-                context.currentTime
-              );
-            }
-            if (comp.release !== void 0) {
-              compressor.release.setValueAtTime(
-                comp.release,
-                context.currentTime
-              );
-            }
+        if (next.noiseSuppression) {
+          const ns = next.noiseSuppression;
+          fullConfig.noiseSuppression = {
+            ...fullConfig.noiseSuppression,
+            ...ns
+          };
+          if (typeof ns.noiseReductionLevel === "number") {
+            nsHandle.processor.setSuppressionLevel(ns.noiseReductionLevel);
+          }
+          if (typeof ns.enabled === "boolean") {
+            nsHandle.processor.setNoiseSuppressionEnabled(ns.enabled);
           }
         }
-        if (newConfig.livekit) {
-          Object.assign(fullConfig.livekit, newConfig.livekit);
+        if (typeof next.muteWhenSilent === "boolean") {
+          fullConfig.muteWhenSilent = next.muteWhenSilent;
         }
-        console.log("Pipeline config updated:", newConfig);
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        console.error("Failed to update config:", err);
         emitter.emit("error", err);
       }
     },
     dispose
   };
+  return handle;
 }
 
 // src/livekit/integration.ts
-async function attachProcessingToTrack(track, config = {}) {
+async function attachSpeakingDetectionToTrack(track, options = {}) {
   if (!track) {
-    throw new Error("attachProcessingToTrack requires a valid LocalAudioTrack");
-  }
-  const originalTrack = track.mediaStreamTrack;
-  if (!originalTrack) {
-    throw new Error("LocalAudioTrack has no underlying MediaStreamTrack");
-  }
-  if (originalTrack.readyState === "ended") {
-    throw new Error("Cannot attach processing to an ended MediaStreamTrack");
-  }
-  let pipeline;
-  try {
-    console.log("Creating audio processing pipeline...");
-    pipeline = await createAudioPipeline(originalTrack, config);
-    console.log("Audio processing pipeline created successfully");
-  } catch (error) {
-    const err = new Error(
-      `Failed to create audio pipeline: ${error instanceof Error ? error.message : String(error)}`
+    throw new Error(
+      "attachSpeakingDetectionToTrack requires a valid LocalAudioTrack"
     );
-    console.error(err);
-    throw err;
-  }
-  if (!pipeline.processedTrack) {
-    throw new Error("Pipeline did not return a processed track");
   }
-  try {
-    console.log("Replacing LiveKit track with processed track...");
-    await track.replaceTrack(pipeline.processedTrack);
-    console.log("LiveKit track replaced successfully");
-  } catch (error) {
-    pipeline.dispose();
-    const err = new Error(
-      `Failed to replace LiveKit track: ${error instanceof Error ? error.message : String(error)}`
-    );
-    console.error(err);
-    throw err;
+  const originalTrack = track.mediaStreamTrack;
+  if (!originalTrack || originalTrack.readyState === "ended") {
+    throw new Error("LocalAudioTrack has no live MediaStreamTrack to process");
   }
-  if (config.livekit?.manageTrackMute) {
-    let isVadMuted = false;
-    pipeline.events.on("vadChange", async (state) => {
-      try {
-        if (state.isSpeaking) {
-          if (isVadMuted) {
-            await track.unmute();
-            isVadMuted = false;
-          }
-        } else {
-          if (!track.isMuted) {
-            await track.mute();
-            isVadMuted = true;
-          }
-        }
-      } catch (error) {
-        console.error("Error handling VAD-based track muting:", error);
+  const pipeline = await createAudioPipeline(originalTrack, options);
+  await track.replaceTrack(pipeline.processedTrack);
+  const listeners = /* @__PURE__ */ new Set();
+  let mutedByController = false;
+  let currentState = pipeline.state;
+  const speakingHandler = (state) => {
+    currentState = state;
+    listeners.forEach((listener) => listener(state));
+    if (options.muteWhenSilent) {
+      if (!state.speaking && !track.isMuted) {
+        track.mute().catch((error) => console.error("mute failed", error));
+        mutedByController = true;
       }
-    });
-  }
-  pipeline.events.on("error", (error) => {
-    console.error("Audio pipeline error:", error);
-  });
-  const originalDispose = pipeline.dispose;
-  pipeline.dispose = () => {
-    try {
+      if (state.speaking && mutedByController) {
+        track.unmute().catch((error) => console.error("unmute failed", error));
+        mutedByController = false;
+      }
+    }
+  };
+  pipeline.events.on("speakingChange", speakingHandler);
+  const errorHandler = (error) => {
+    console.error("Audio pipeline error", error);
+  };
+  pipeline.events.on("error", errorHandler);
+  const controller = {
+    get speaking() {
+      return currentState.speaking;
+    },
+    get levelDb() {
+      return currentState.levelDb;
+    },
+    onChange: (listener) => {
+      listeners.add(listener);
+      listener(currentState);
+      return () => listeners.delete(listener);
+    },
+    setConfig: (config) => {
+      pipeline.setConfig(config);
+      if (typeof config.muteWhenSilent === "boolean") {
+        options.muteWhenSilent = config.muteWhenSilent;
+      }
+    },
+    dispose: () => {
+      pipeline.events.off("speakingChange", speakingHandler);
+      pipeline.events.off("error", errorHandler);
+      listeners.clear();
+      if (mutedByController && !track.isMuted) {
+        track.unmute().catch((error) => console.error("unmute failed", error));
+        mutedByController = false;
+      }
+      pipeline.dispose();
       if (originalTrack.readyState === "live") {
-        console.log("Restoring original track...");
         track.replaceTrack(originalTrack).catch((error) => {
-          console.error("Failed to restore original track:", error);
+          console.error("Failed to restore original track", error);
         });
       }
-      originalDispose();
-    } catch (error) {
-      console.error("Error during pipeline disposal:", error);
-      try {
-        originalDispose();
-      } catch (disposeError) {
-        console.error("Error calling original dispose:", disposeError);
-      }
     }
   };
-  return pipeline;
+  return controller;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  attachProcessingToTrack
+  attachSpeakingDetectionToTrack
 });