@tensamin/audio 0.1.1 → 0.1.3

package/dist/types.d.mts

@@ -0,0 +1,155 @@
+import { Emitter } from 'mitt';
+
+/**
+ * Configuration for the audio processing pipeline.
+ */
+interface AudioProcessingConfig {
+    /**
+     * Noise suppression configuration.
+     */
+    noiseSuppression?: {
+        enabled: boolean;
+        /**
+         * Path or URL to the RNNoise WASM binary.
+         * REQUIRED if enabled.
+         */
+        wasmUrl?: string;
+        /**
+         * Path or URL to the RNNoise SIMD WASM binary.
+         * REQUIRED if enabled.
+         */
+        simdUrl?: string;
+        /**
+         * Path or URL to the RNNoise worklet script.
+         * REQUIRED if enabled.
+         */
+        workletUrl?: string;
+        /**
+         * Plugin name to use. Defaults to 'rnnoise-ns'.
+         */
+        pluginName?: string;
+    };
+    /**
+     * Voice Activity Detection (VAD) configuration.
+     */
+    vad?: {
+        enabled: boolean;
+        /**
+         * Plugin name to use. Defaults to 'rnnoise-vad' or 'energy-vad'.
+         */
+        pluginName?: string;
+        /**
+         * Probability threshold for speech onset (0-1).
+         * Default: 0.5
+         */
+        startThreshold?: number;
+        /**
+         * Probability threshold for speech offset (0-1).
+         * Default: 0.4
+         */
+        stopThreshold?: number;
+        /**
+         * Time in ms to wait after speech stops before considering it silent.
+         * Default: 300ms
+         */
+        hangoverMs?: number;
+        /**
+         * Time in ms of audio to buffer before speech onset to avoid cutting the start.
+         * Default: 200ms
+         */
+        preRollMs?: number;
+    };
+    /**
+     * Output gain and muting configuration.
+     */
+    output?: {
+        /**
+         * Gain to apply when speaking (0-1+). Default: 1.0
+         */
+        speechGain?: number;
+        /**
+         * Gain to apply when silent (0-1). Default: 0.0 (mute)
+         */
+        silenceGain?: number;
+        /**
+         * Time in seconds to ramp gain changes. Default: 0.02
+         */
+        gainRampTime?: number;
+    };
+    /**
+     * LiveKit integration configuration.
+     */
+    livekit?: {
+        /**
+         * Whether to call track.mute()/unmute() on the LocalAudioTrack based on VAD.
+         * This saves bandwidth but has more signaling overhead.
+         * Default: false (uses gain gating only)
+         */
+        manageTrackMute?: boolean;
+    };
+}
+/**
+ * Represents the state of Voice Activity Detection.
+ */
+interface VADState {
+    /**
+     * Whether speech is currently detected (after hysteresis).
+     */
+    isSpeaking: boolean;
+    /**
+     * Raw probability of speech from the VAD model (0-1).
+     */
+    probability: number;
+    /**
+     * Current state enum.
+     */
+    state: "silent" | "speech_starting" | "speaking" | "speech_ending";
+}
+/**
+ * Events emitted by the audio pipeline.
+ */
+type AudioPipelineEvents = {
+    vadChange: VADState;
+    error: Error;
+};
+/**
+ * Handle to a running audio processing pipeline.
+ */
+interface AudioPipelineHandle {
+    /**
+     * The processed MediaStreamTrack.
+     */
+    readonly processedTrack: MediaStreamTrack;
+    /**
+     * Event emitter for VAD state and errors.
+     */
+    readonly events: Emitter<AudioPipelineEvents>;
+    /**
+     * Current VAD state.
+     */
+    readonly state: VADState;
+    /**
+     * Update configuration at runtime.
+     */
+    setConfig(config: Partial<AudioProcessingConfig>): void;
+    /**
+     * Stop processing and release resources.
+     */
+    dispose(): void;
+}
+/**
+ * Interface for a Noise Suppression Plugin.
+ */
+interface NoiseSuppressionPlugin {
+    name: string;
+    createNode(context: AudioContext, config: AudioProcessingConfig["noiseSuppression"]): Promise<AudioNode>;
+}
+/**
+ * Interface for a VAD Plugin.
+ */
+interface VADPlugin {
+    name: string;
+    createNode(context: AudioContext, config: AudioProcessingConfig["vad"], onDecision: (probability: number) => void): Promise<AudioNode>;
+}
+
+export type { AudioPipelineEvents, AudioPipelineHandle, AudioProcessingConfig, NoiseSuppressionPlugin, VADPlugin, VADState };

package/dist/types.d.ts

@@ -0,0 +1,155 @@
+import { Emitter } from 'mitt';
+
+/**
+ * Configuration for the audio processing pipeline.
+ */
+interface AudioProcessingConfig {
+    /**
+     * Noise suppression configuration.
+     */
+    noiseSuppression?: {
+        enabled: boolean;
+        /**
+         * Path or URL to the RNNoise WASM binary.
+         * REQUIRED if enabled.
+         */
+        wasmUrl?: string;
+        /**
+         * Path or URL to the RNNoise SIMD WASM binary.
+         * REQUIRED if enabled.
+         */
+        simdUrl?: string;
+        /**
+         * Path or URL to the RNNoise worklet script.
+         * REQUIRED if enabled.
+         */
+        workletUrl?: string;
+        /**
+         * Plugin name to use. Defaults to 'rnnoise-ns'.
+         */
+        pluginName?: string;
+    };
+    /**
+     * Voice Activity Detection (VAD) configuration.
+     */
+    vad?: {
+        enabled: boolean;
+        /**
+         * Plugin name to use. Defaults to 'rnnoise-vad' or 'energy-vad'.
+         */
+        pluginName?: string;
+        /**
+         * Probability threshold for speech onset (0-1).
+         * Default: 0.5
+         */
+        startThreshold?: number;
+        /**
+         * Probability threshold for speech offset (0-1).
+         * Default: 0.4
+         */
+        stopThreshold?: number;
+        /**
+         * Time in ms to wait after speech stops before considering it silent.
+         * Default: 300ms
+         */
+        hangoverMs?: number;
+        /**
+         * Time in ms of audio to buffer before speech onset to avoid cutting the start.
+         * Default: 200ms
+         */
+        preRollMs?: number;
+    };
+    /**
+     * Output gain and muting configuration.
+     */
+    output?: {
+        /**
+         * Gain to apply when speaking (0-1+). Default: 1.0
+         */
+        speechGain?: number;
+        /**
+         * Gain to apply when silent (0-1). Default: 0.0 (mute)
+         */
+        silenceGain?: number;
+        /**
+         * Time in seconds to ramp gain changes. Default: 0.02
+         */
+        gainRampTime?: number;
+    };
+    /**
+     * LiveKit integration configuration.
+     */
+    livekit?: {
+        /**
+         * Whether to call track.mute()/unmute() on the LocalAudioTrack based on VAD.
+         * This saves bandwidth but has more signaling overhead.
+         * Default: false (uses gain gating only)
+         */
+        manageTrackMute?: boolean;
+    };
+}
+/**
+ * Represents the state of Voice Activity Detection.
+ */
+interface VADState {
+    /**
+     * Whether speech is currently detected (after hysteresis).
+     */
+    isSpeaking: boolean;
+    /**
+     * Raw probability of speech from the VAD model (0-1).
+     */
+    probability: number;
+    /**
+     * Current state enum.
+     */
+    state: "silent" | "speech_starting" | "speaking" | "speech_ending";
+}
+/**
+ * Events emitted by the audio pipeline.
+ */
+type AudioPipelineEvents = {
+    vadChange: VADState;
+    error: Error;
+};
+/**
+ * Handle to a running audio processing pipeline.
+ */
+interface AudioPipelineHandle {
+    /**
+     * The processed MediaStreamTrack.
+     */
+    readonly processedTrack: MediaStreamTrack;
+    /**
+     * Event emitter for VAD state and errors.
+     */
+    readonly events: Emitter<AudioPipelineEvents>;
+    /**
+     * Current VAD state.
+     */
+    readonly state: VADState;
+    /**
+     * Update configuration at runtime.
+     */
+    setConfig(config: Partial<AudioProcessingConfig>): void;
+    /**
+     * Stop processing and release resources.
+     */
+    dispose(): void;
+}
+/**
+ * Interface for a Noise Suppression Plugin.
+ */
+interface NoiseSuppressionPlugin {
+    name: string;
+    createNode(context: AudioContext, config: AudioProcessingConfig["noiseSuppression"]): Promise<AudioNode>;
+}
+/**
+ * Interface for a VAD Plugin.
+ */
+interface VADPlugin {
+    name: string;
+    createNode(context: AudioContext, config: AudioProcessingConfig["vad"], onDecision: (probability: number) => void): Promise<AudioNode>;
+}
+
+export type { AudioPipelineEvents, AudioPipelineHandle, AudioProcessingConfig, NoiseSuppressionPlugin, VADPlugin, VADState };

package/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/types.mjs

@@ -0,0 +1 @@
+import "./chunk-WBQAMGXK.mjs";

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

@@ -0,0 +1,9 @@
+import { VADPlugin, AudioProcessingConfig } from '../types.mjs';
+import 'mitt';
+
+declare class EnergyVADPlugin implements VADPlugin {
+    name: string;
+    createNode(context: AudioContext, config: AudioProcessingConfig["vad"], onDecision: (probability: number) => void): Promise<AudioNode>;
+}
+
+export { EnergyVADPlugin };

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

@@ -0,0 +1,9 @@
+import { VADPlugin, AudioProcessingConfig } from '../types.js';
+import 'mitt';
+
+declare class EnergyVADPlugin implements VADPlugin {
+    name: string;
+    createNode(context: AudioContext, config: AudioProcessingConfig["vad"], onDecision: (probability: number) => void): Promise<AudioNode>;
+}
+
+export { EnergyVADPlugin };

package/dist/vad/vad-node.js

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vad/vad-node.ts
+var vad_node_exports = {};
+__export(vad_node_exports, {
+  EnergyVADPlugin: () => EnergyVADPlugin
+});
+module.exports = __toCommonJS(vad_node_exports);
+var energyVadWorkletCode = `
+class EnergyVadProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.smoothing = 0.95;
+    this.energy = 0;
+    this.noiseFloor = 0.001;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    if (!input || !input.length) return true;
+    const channel = input[0];
+    
+    // Calculate RMS
+    let sum = 0;
+    for (let i = 0; i < channel.length; i++) {
+      sum += channel[i] * channel[i];
+    }
+    const rms = Math.sqrt(sum / channel.length);
+
+    // Simple adaptive noise floor (very basic)
+    if (rms < this.noiseFloor) {
+      this.noiseFloor = this.noiseFloor * 0.99 + rms * 0.01;
+    } else {
+      this.noiseFloor = this.noiseFloor * 0.999 + rms * 0.001;
+    }
+
+    // Calculate "probability" based on SNR
+    // This is a heuristic mapping from energy to 0-1
+    const snr = rms / (this.noiseFloor + 1e-6);
+    const probability = Math.min(1, Math.max(0, (snr - 1.5) / 10)); // Arbitrary scaling
+
+    this.port.postMessage({ probability });
+
+    return true;
+  }
+}
+registerProcessor('energy-vad-processor', EnergyVadProcessor);
+`;
+var EnergyVADPlugin = class {
+  name = "energy-vad";
+  async createNode(context, config, onDecision) {
+    if (!config?.enabled) {
+      console.log("VAD disabled, using passthrough node");
+      const pass = context.createGain();
+      return pass;
+    }
+    const blob = new Blob([energyVadWorkletCode], {
+      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;
+    }
+    URL.revokeObjectURL(url);
+    let node;
+    try {
+      node = new AudioWorkletNode(context, "energy-vad-processor");
+      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;
+    }
+    node.port.onmessage = (event) => {
+      try {
+        const { probability } = event.data;
+        if (typeof probability === "number" && !isNaN(probability)) {
+          onDecision(probability);
+        } else {
+          console.warn("Invalid VAD probability received:", event.data);
+        }
+      } catch (error) {
+        console.error("Error in VAD message handler:", error);
+      }
+    };
+    node.port.onmessageerror = (event) => {
+      console.error("VAD port message error:", event);
+    };
+    return node;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnergyVADPlugin
+});

package/dist/vad/vad-node.mjs

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

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

@@ -0,0 +1,15 @@
+import { AudioProcessingConfig, VADState } from '../types.mjs';
+import 'mitt';
+
+declare class VADStateMachine {
+    private config;
+    private currentState;
+    private lastSpeechTime;
+    private speechStartTime;
+    private frameDurationMs;
+    constructor(config: AudioProcessingConfig["vad"]);
+    updateConfig(config: Partial<AudioProcessingConfig["vad"]>): void;
+    processFrame(probability: number, timestamp: number): VADState;
+}
+
+export { VADStateMachine };

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

@@ -0,0 +1,15 @@
+import { AudioProcessingConfig, VADState } from '../types.js';
+import 'mitt';
+
+declare class VADStateMachine {
+    private config;
+    private currentState;
+    private lastSpeechTime;
+    private speechStartTime;
+    private frameDurationMs;
+    constructor(config: AudioProcessingConfig["vad"]);
+    updateConfig(config: Partial<AudioProcessingConfig["vad"]>): void;
+    processFrame(probability: number, timestamp: number): VADState;
+}
+
+export { VADStateMachine };

package/dist/vad/vad-state.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/vad/vad-state.ts
+var vad_state_exports = {};
+__export(vad_state_exports, {
+  VADStateMachine: () => VADStateMachine
+});
+module.exports = __toCommonJS(vad_state_exports);
+var VADStateMachine = class {
+  config;
+  currentState = "silent";
+  lastSpeechTime = 0;
+  speechStartTime = 0;
+  frameDurationMs = 20;
+  // Assumed frame duration, updated by calls
+  constructor(config) {
+    this.config = {
+      enabled: config?.enabled ?? true,
+      pluginName: config?.pluginName ?? "energy-vad",
+      startThreshold: config?.startThreshold ?? 0.5,
+      stopThreshold: config?.stopThreshold ?? 0.4,
+      hangoverMs: config?.hangoverMs ?? 300,
+      preRollMs: config?.preRollMs ?? 200
+    };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  processFrame(probability, timestamp) {
+    const { startThreshold, stopThreshold, hangoverMs } = this.config;
+    let newState = this.currentState;
+    if (this.currentState === "silent" || this.currentState === "speech_ending") {
+      if (probability >= startThreshold) {
+        newState = "speech_starting";
+        this.speechStartTime = timestamp;
+        this.lastSpeechTime = timestamp;
+      } else {
+        newState = "silent";
+      }
+    } else if (this.currentState === "speech_starting" || 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";
+        }
+      }
+    }
+    if (newState === "speech_starting") newState = "speaking";
+    if (newState === "speech_ending") newState = "silent";
+    this.currentState = newState;
+    return {
+      isSpeaking: newState === "speaking",
+      probability,
+      state: newState
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VADStateMachine
+});

package/dist/vad/vad-state.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensamin/audio",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,22 +17,25 @@
   },
   "license": "MIT",
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --out-dir dist --clean",
+    "build": "tsup src/ --format cjs,esm --dts --out-dir dist --clean",
     "format": "bunx prettier --write .",
     "lint": "tsc"
   },
   "dependencies": {
     "@sapphi-red/web-noise-suppressor": "^0.3.5",
-    "mitt": "^3.0.1",
-    "tsup": "^8.5.1"
+    "mitt": "^3.0.1"
   },
   "peerDependencies": {
     "livekit-client": "^2.0.0"
   },
   "devDependencies": {
+    "tsup": "^8.5.1",
     "@types/bun": "latest",
     "@types/web": "^0.0.298",
     "livekit-client": "^2.16.0",
     "typescript": "^5.9.3"
-  }
+  },
+  "files": [
+    "dist"
+  ]
 }

package/.github/workflows/publish.yml

@@ -1,29 +0,0 @@
-name: Publish
-
-on:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  id-token: write
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "24.x"
-          registry-url: https://registry.npmjs.org/
-
-      - name: Build
-        run: |
-          bun install --frozen-lockfile
-          bun run lint
-          bun run build
-          bun audit signatures
-
-      - name: Publish
-        run: npm publish --access public