@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.56 → 1.0.58

package/README.md

@@ -11,69 +11,12 @@ It mirrors the production SDK used by Odyssey V2 and ships ready-to-drop into an
 ## Feature Highlights
 - 🔌 **One class to rule it all** – `OdysseySpatialComms` wires transports, producers, consumers, and room state.
 - 🧭 **Accurate pose propagation** – `updatePosition()` streams listener pose to the SFU while `participant-position-updated` keeps the local store in sync.
-- 🤖 **AI-Powered Noise Suppression** – Deep learning model (TensorFlow.js) runs client-side to remove background noise BEFORE audio reaches MediaSoup. Uses trained LSTM-based mask prediction for superior noise cancellation without affecting voice quality.
 - 🎧 **Studio-grade spatial audio** – each remote participant gets a dedicated Web Audio graph: denoiser → high-pass → low-pass → HRTF `PannerNode` → adaptive gain → master compressor. Uses Web Audio API's HRTF panning model for accurate left/right/front/back positioning based on distance and direction, with custom AudioWorklet processors for noise cancellation and voice tuning.
 - 🎥 **Camera-ready streams** – video tracks are exposed separately so UI layers can render muted `<video>` tags while audio stays inside Web Audio.
 - 🔁 **EventEmitter contract** – subscribe to `room-joined`, `consumer-created`, `participant-position-updated`, etc., without touching Socket.IO directly.
 
 ## Quick Start
 
-### With ML Noise Suppression (Recommended)
-
-```ts
-import {
-	OdysseySpatialComms,
-	Direction,
-	Position,
-} from "@newgameplusinc/odyssey-audio-video-sdk-dev";
-
-const sdk = new OdysseySpatialComms("https://mediasoup-server.example.com");
-
-// 1) Initialize ML noise suppression (place model files in public/models/)
-await sdk.initializeMLNoiseSuppression(
-	'/models/odyssey_noise_suppressor_v1/model.json'
-);
-
-// 2) Join a room
-await sdk.joinRoom({
-	roomId: "demo-room",
-	userId: "user-123",
-	deviceId: "device-123",
-	position: { x: 0, y: 0, z: 0 },
-	direction: { x: 0, y: 1, z: 0 },
-});
-
-// 3) Produce local media (ML cleaning applied automatically to audio)
-const stream = await navigator.mediaDevices.getUserMedia({ 
-	audio: {
-		echoCancellation: true,
-		noiseSuppression: false, // Disable browser NS, use ML instead!
-		autoGainControl: true,
-		sampleRate: 48000,
-	},
-	video: true 
-});
-for (const track of stream.getTracks()) {
-	await sdk.produceTrack(track); // ML processes audio tracks automatically
-}
-
-// 4) Toggle ML noise suppression on/off
-sdk.toggleMLNoiseSuppression(true); // or false
-
-// 5) Handle remote tracks
-sdk.on("consumer-created", async ({ participant, track }) => {
-	if (track.kind === "video") {
-		attachVideo(track, participant.participantId);
-	}
-});
-
-// 6) Keep spatial audio honest
-sdk.updatePosition(currentPos, currentDir);
-sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
-```
-
-### Without ML Noise Suppression (Legacy)
-
 ```ts
 import {
 	OdysseySpatialComms,
@@ -113,83 +56,23 @@ sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
 ## Audio Flow (Server ↔ Browser)
 
 ```
-                          ┌─────────────────────────────────────────────┐
-                          │         CLIENT-SIDE PROCESSING              │
-                          └─────────────────────────────────────────────┘
-
-┌──────────────┐   getUserMedia    ┌──────────────────────┐   ML Processing   ┌──────────────────┐
-│ Microphone   │ ────────────────▶ │ Vue: produceTrack()  │ ───────────────▶ │ SDK: ML Noise    │
-│ (Raw Audio)  │                   │ (SDK method call)    │                  │ Suppressor       │
-└──────────────┘                   └──────────────────────┘                  │ (TF.js Model)    │
-                                                                             │ • Load model.json │
-                                                                             │ • Mel-spectrogram │
-                                                                             │ • LSTM inference  │
-                                                                             │ • Mask apply      │
-                                                                             └────────┬─────────┘
-                                                                                      │
-                                                                                Clean Audio
-                                                                                      ▼
-                                                      ┌──────────────────────────────────────────┐
-                                                      │ SDK: mediasoupManager.produce()          │
-                                                      │ (Sends clean track to server)            │
-                                                      └────────┬─────────────────────────────────┘
-                                                               │
-                                                               │ WebRTC/RTP
-                                                               ▼
-                          ┌─────────────────────────────────────────────┐
-                          │         SERVER-SIDE ROUTING                 │
-                          └─────────────────────────────────────────────┘
-
-┌──────────────┐   update-position   ┌──────────────┐   route clean audio   ┌──────────────────┐
-│ Browser LSD  │ ──────────────────▶ │ MediaSoup SFU│ ───────────────────▶ │ Other Clients    │
-│ (Unreal data)│                     │ + Socket.IO  │                       │ (Receive RTP)    │
-└──────────────┘                     └──────┬───────┘                       └──────┬───────────┘
-                                            │                                       │
-                                            │ consumer-created event                │
-                                            ▼                                       ▼
-                          ┌─────────────────────────────────────────────┐
-                          │         REMOTE AUDIO PLAYBACK               │
-                          └─────────────────────────────────────────────┘
-
-                                     ┌──────────────────┐
-                                     │ SDK Event Bus    │
-                                     │ (EventManager)   │
-                                     └────────┬─────────┘
-                                              │ track + pose
-                                              ▼
-                                     ┌──────────────────┐
-                                     │ SpatialAudioMgr  │
-                                     │ (Web Audio API)  │
-                                     │ • Denoiser       │◀─── Traditional noise reduction
-                                     │ • HP/LP Filters  │     (runs on received audio)
-                                     │ • HRTF Panner    │
-                                     │ • Distance Gain  │
-                                     │ • Compressor     │
-                                     └────────┬─────────┘
-                                              │
-                                              ▼
-                                     ┌──────────────────┐
-                                     │ Web Audio Graph  │
-                                     └────────┬─────────┘
-                                              │
-                                              ▼
-                                  Listener ears (Left/Right)
-                                              │
-                                              ▼
-                                        System Output
-```
-
-### ML Noise Suppression Pipeline (Client-Side)
-```
-Mic → getUserMedia() 
-      ↓
-Vue: sdk.produceTrack(audioTrack)
-      ↓
-SDK: mlNoiseSuppressor.processMediaStream() [TensorFlow.js runs here]
-      ↓
-SDK: mediasoupManager.produce(cleanTrack)
-      ↓
-MediaSoup Server → Other participants hear clean audio ✅
+┌──────────────┐   update-position   ┌──────────────┐   pose + tracks   ┌──────────────────┐
+│ Browser LSD  │ ──────────────────▶ │ MediaSoup SFU│ ────────────────▶ │ SDK Event Bus     │
+│ (Unreal data)│                     │ + Socket.IO  │                   │ (EventManager)    │
+└──────┬───────┘                     └──────┬───────┘                   └──────────┬────────┘
+	│                                    │                                  track + pose
+	│                                    │                                       ▼
+	│                           ┌────────▼────────┐                      ┌──────────────────┐
+	│ audio RTP                 │  consumer-created│                      │ SpatialAudioMgr   │
+	└──────────────────────────▶│  setup per-user │◀──────────────────────│  (Web Audio API)  │
+					└────────┬────────┘                      │  - Denoiser       │
+						  │                               │  - HP / LP        │
+						  │                               │  - HRTF Panner    │
+						  ▼                               │  - Gain + Comp    │
+					 Web Audio Graph                         └──────────┬───────┘
+						  │                                          │
+						  ▼                                          ▼
+				      Listener ears (Left/Right)                  System Output
 ```
 
 ### Web Audio Algorithms
@@ -236,121 +119,7 @@ These layers run entirely in Web Audio, so you can ship “AirPods-style” back
 3. **Position + direction updates** – every `participant-position-updated` event calls `updateSpatialAudio(participantId, position, direction)`. The position feeds the panner’s XYZ, while the direction vector sets the source orientation so voices project forward relative to avatar facing.
 4. **Distance-aware gain** – the manager stores the latest listener pose and computes the Euclidean distance to each remote participant on every update. A custom rolloff curve adjusts gain before the compressor, giving the “someone on my left / far away” perception without blowing out master levels.
 5. **Left/right rendering** – because the panner uses `panningModel = "HRTF"`, browsers feed the processed signal into the user’s audio hardware with head-related transfer functions, producing natural interaural time/intensity differences.
-## ML Noise Suppression (Deep Learning Pre-Processing)
-
-**NEW:** The SDK now includes an optional **AI-powered noise suppression** layer that runs **BEFORE** audio reaches MediaSoup, using a trained TensorFlow.js model.
-
-### Why ML Noise Suppression?
-- **Superior noise removal** – Deep learning models learn complex noise patterns that traditional DSP can't handle (keyboard typing, paper rustling, traffic, etc.)
-- **Voice preservation** – LSTM-based mask prediction preserves natural voice quality while removing background noise
-- **Client-side processing** – Runs entirely in the browser using TensorFlow.js (WebGL/WebAssembly acceleration)
-- **Privacy-first** – Audio never leaves the user's device; processing happens locally
-- **Zero latency** – <10ms processing time per frame, suitable for real-time communication
-
-### Architecture
-```
-Raw Mic Audio → ML Model (TF.js) → Clean Audio → MediaSoup → Traditional Denoiser → Spatial Audio
-```
-
-The ML model applies **mask-based spectral subtraction** trained on diverse noise datasets:
-1. Extracts mel-spectrogram from raw audio
-2. Predicts a noise mask (0-1 per frequency bin) using Bidirectional LSTM
-3. Applies mask to remove noise while preserving speech
-4. Reconstructs clean audio waveform
-
-### Setup ML Noise Suppression
-
-**1. Place Model Files:**
-```
-YourApp/public/models/odyssey_noise_suppressor_v1/
-├── model.json                    # TF.js model architecture
-├── group1-shard*.bin             # Model weights (multiple files)
-├── normalization_stats.json      # Preprocessing parameters
-└── model_config.json             # Audio config (48kHz, n_mels, etc.)
-```
-
-**2. Initialize in Code:**
-```ts
-const sdk = new OdysseySpatialComms('wss://your-server.com');
-
-// Initialize ML noise suppression
-try {
-	await sdk.initializeMLNoiseSuppression(
-		'/models/odyssey_noise_suppressor_v1/model.json'
-	);
-	console.log('✅ ML Noise Suppression enabled');
-} catch (error) {
-	console.error('ML initialization failed:', error);
-	// Graceful degradation - SDK continues without ML
-}
-
-// Produce audio tracks (ML cleaning applied automatically)
-const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-await sdk.produceTrack(stream.getAudioTracks()[0]);
-
-// Toggle ML on/off at runtime
-sdk.toggleMLNoiseSuppression(false); // Disable
-sdk.toggleMLNoiseSuppression(true);  // Re-enable
-
-// Check ML status
-if (sdk.isMLNoiseSuppressionEnabled()) {
-	console.log('ML is active');
-}
-```
-
-**3. Recommended Audio Constraints:**
-```ts
-const stream = await navigator.mediaDevices.getUserMedia({
-	audio: {
-		echoCancellation: true,        // Keep echo cancellation
-		noiseSuppression: false,       // Disable browser NS (ML replaces it)
-		autoGainControl: true,         // Keep AGC
-		sampleRate: 48000,             // Match model training (48kHz)
-	},
-});
-```
-
-### ML Model Details
-- **Architecture:** Bidirectional LSTM (2 layers, 256 units) + Dense layers
-- **Input:** 48kHz audio → Mel-spectrogram (128 bins, 8-frame sequences)
-- **Output:** Time-frequency mask (0-1 values per bin)
-- **Latency:** ~5-8ms per chunk (AudioWorklet processing)
-- **Model Size:** ~2-3 MB (quantized to uint8)
-- **Training:** LibriSpeech (clean speech) + AudioSet (noise) datasets
-
-### When to Use ML vs Traditional Denoiser
-
-| Feature | ML Noise Suppression | Traditional Denoiser (AudioWorklet) |
-|---------|---------------------|-------------------------------------|
-| **Noise Types** | Complex (keyboard, traffic, music) | Stationary (fan, HVAC, hiss) |
-| **Voice Quality** | Excellent (learned patterns) | Good (spectral shaping) |
-| **CPU Usage** | Medium (TF.js optimized) | Low (simple DSP) |
-| **Latency** | ~5-8ms | ~1-2ms |
-| **Use Case** | Noisy environments | Quiet rooms with constant noise |
-
-**Best Practice:** Enable **both** for maximum quality:
-- ML suppresses complex noise (pre-MediaSoup)
-- Traditional denoiser handles residual stationary noise (post-receive)
-
-### Troubleshooting
-
-**Model fails to load:**
-- Ensure model files are served as static assets (check browser Network tab)
-- Verify CORS headers if serving from CDN
-- Check browser console for TensorFlow.js errors
-
-**High CPU usage:**
-- TF.js automatically uses WebGL when available (much faster)
-- Disable ML on low-end devices: `sdk.toggleMLNoiseSuppression(false)`
-
-**Voice sounds muffled:**
-- Model trained on 48kHz audio; ensure mic uses same sample rate
-- Check if browser is downsampling to 16kHz (some mobile browsers do this)
 
-**Doesn't remove all noise:**
-- ML works best on noise types seen during training
-- Combine with traditional denoiser for residual cleanup
-- Extremely loud noise (>30 dB SNR) may leak through
 ## Video Flow (Capture ↔ Rendering)
 
 ```
@@ -368,19 +137,17 @@ const stream = await navigator.mediaDevices.getUserMedia({
 ```
 
 ## Core Classes
-- `src/index.ts` – `OdysseySpatialComms` (socket lifecycle, producers/consumers, event surface, ML noise suppression integration).
+- `src/index.ts` – `OdysseySpatialComms` (socket lifecycle, producers/consumers, event surface).
 - `src/MediasoupManager.ts` – transport helpers for produce/consume/resume.
 - `src/SpatialAudioManager.ts` – Web Audio orchestration (listener transforms, per-participant chains, denoiser, distance math).
-- `src/MLNoiseSuppressor.ts` – TensorFlow.js-based deep learning noise suppression (mel-spectrogram extraction, LSTM inference, mask application).
 - `src/EventManager.ts` – lightweight EventEmitter used by the entire SDK.
 
 ## Integration Checklist
 1. **Instantiate once** per page/tab and keep it in a store (Vuex, Redux, Zustand, etc.).
-2. **(Optional) Initialize ML noise suppression** – Call `await sdk.initializeMLNoiseSuppression('/models/odyssey_noise_suppressor_v1/model.json')` after instantiation for AI-powered noise cancellation.
-3. **Pipe LSD/Lap data** from your rendering engine into `updatePosition()` + `setListenerFromLSD()` at ~10 Hz.
-4. **Render videos muted** – never attach remote audio tracks straight to DOM; let `SpatialAudioManager` own playback.
-5. **Push avatar telemetry back to Unreal** so `remoteSpatialData` can render minimaps/circles (see Odyssey V2 `sendMediaSoupParticipantsToUnreal`).
-6. **Monitor logs** – browser console shows `🎧 SDK`, `📍 SDK`, `🎚️ [Spatial Audio]`, and `🎤 ML` statements for every critical hop.
+2. **Pipe LSD/Lap data** from your rendering engine into `updatePosition()` + `setListenerFromLSD()` at ~10 Hz.
+3. **Render videos muted** – never attach remote audio tracks straight to DOM; let `SpatialAudioManager` own playback.
+4. **Push avatar telemetry back to Unreal** so `remoteSpatialData` can render minimaps/circles (see Odyssey V2 `sendMediaSoupParticipantsToUnreal`).
+5. **Monitor logs** – browser console shows `🎧 SDK`, `📍 SDK`, and `🎚️ [Spatial Audio]` statements for every critical hop.
 
 ## Server Contract (Socket.IO events)
 | Event | Direction | Payload |

package/dist/index.d.ts

@@ -10,8 +10,6 @@ export declare class OdysseySpatialComms extends EventManager {
     private localParticipant;
     private mediasoupManager;
     private spatialAudioManager;
-    private mlNoiseSuppressor;
-    private mlNoiseSuppressionEnabled;
     constructor(serverUrl: string, spatialOptions?: SpatialAudioOptions);
     on(event: OdysseyEvent, listener: (...args: any[]) => void): this;
     emit(event: OdysseyEvent, ...args: any[]): boolean;
@@ -30,19 +28,6 @@ export declare class OdysseySpatialComms extends EventManager {
     leaveRoom(): void;
     resumeAudio(): Promise<void>;
     getAudioContextState(): AudioContextState;
-    /**
-     * Initialize ML noise suppression
-     * @param modelUrl - URL to model.json (e.g., '/models/odyssey_noise_suppressor_v1/model.json')
-     */
-    initializeMLNoiseSuppression(modelUrl: string): Promise<void>;
-    /**
-     * Toggle ML noise suppression on/off
-     */
-    toggleMLNoiseSuppression(enabled: boolean): void;
-    /**
-     * Check if ML noise suppression is enabled
-     */
-    isMLNoiseSuppressionEnabled(): boolean;
     produceTrack(track: MediaStreamTrack, appData?: {
         isScreenshare?: boolean;
     }): Promise<any>;

package/dist/index.js

@@ -5,14 +5,11 @@ const socket_io_client_1 = require("socket.io-client");
 const EventManager_1 = require("./EventManager");
 const MediasoupManager_1 = require("./MediasoupManager");
 const SpatialAudioManager_1 = require("./SpatialAudioManager");
-const MLNoiseSuppressor_1 = require("./MLNoiseSuppressor");
 class OdysseySpatialComms extends EventManager_1.EventManager {
     constructor(serverUrl, spatialOptions) {
         super(); // Initialize the EventEmitter base class
         this.room = null;
         this.localParticipant = null;
-        this.mlNoiseSuppressor = null;
-        this.mlNoiseSuppressionEnabled = false;
         this.socket = (0, socket_io_client_1.io)(serverUrl, {
             transports: ["websocket"],
         });
@@ -104,71 +101,8 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
     getAudioContextState() {
         return this.spatialAudioManager.getAudioContextState();
     }
-    /**
-     * Initialize ML noise suppression
-     * @param modelUrl - URL to model.json (e.g., '/models/odyssey_noise_suppressor_v1/model.json')
-     */
-    async initializeMLNoiseSuppression(modelUrl) {
-        if (this.mlNoiseSuppressor) {
-            console.log('ML Noise Suppression already initialized');
-            return;
-        }
-        try {
-            console.log('🎤 Initializing ML Noise Suppression...');
-            this.mlNoiseSuppressor = new MLNoiseSuppressor_1.MLNoiseSuppressor();
-            await this.mlNoiseSuppressor.initialize(modelUrl, this.spatialAudioManager.getAudioContext());
-            this.mlNoiseSuppressionEnabled = true;
-            console.log('✅ ML Noise Suppression enabled');
-        }
-        catch (error) {
-            console.error('❌ Failed to initialize ML Noise Suppression:', error);
-            this.mlNoiseSuppressor = null;
-            this.mlNoiseSuppressionEnabled = false;
-            throw error;
-        }
-    }
-    /**
-     * Toggle ML noise suppression on/off
-     */
-    toggleMLNoiseSuppression(enabled) {
-        if (!this.mlNoiseSuppressor) {
-            console.warn('ML Noise Suppression not initialized. Call initializeMLNoiseSuppression() first.');
-            return;
-        }
-        this.mlNoiseSuppressionEnabled = enabled;
-        console.log(`🎤 ML Noise Suppression: ${enabled ? 'ON' : 'OFF'}`);
-    }
-    /**
-     * Check if ML noise suppression is enabled
-     */
-    isMLNoiseSuppressionEnabled() {
-        return this.mlNoiseSuppressionEnabled && this.mlNoiseSuppressor !== null;
-    }
     async produceTrack(track, appData) {
-        console.log(`🎬 [SDK] produceTrack called - kind: ${track.kind}, enabled: ${track.enabled}, readyState: ${track.readyState}`);
-        let processedTrack = track;
-        // Apply ML noise suppression to audio BEFORE sending to MediaSoup
-        if (track.kind === 'audio' && this.mlNoiseSuppressionEnabled && this.mlNoiseSuppressor) {
-            try {
-                console.log('🎤 [SDK] Applying ML noise suppression to audio...');
-                const inputStream = new MediaStream([track]);
-                console.log('🎤 [SDK] Created input stream with track');
-                const cleanedStream = await this.mlNoiseSuppressor.processMediaStream(inputStream);
-                console.log('🎤 [SDK] Got cleaned stream from ML');
-                processedTrack = cleanedStream.getAudioTracks()[0];
-                console.log(`✅ [SDK] ML noise suppression applied - processed track state: ${processedTrack.readyState}`);
-            }
-            catch (error) {
-                console.error('❌ [SDK] ML noise suppression failed, using original track:', error);
-                processedTrack = track; // Fallback to original track
-            }
-        }
-        else {
-            console.log(`ℹ️  [SDK] Skipping ML - kind: ${track.kind}, ML enabled: ${this.mlNoiseSuppressionEnabled}`);
-        }
-        console.log(`📤 [SDK] Producing track to MediaSoup - kind: ${processedTrack.kind}, state: ${processedTrack.readyState}`);
-        const producer = await this.mediasoupManager.produce(processedTrack, appData);
-        console.log(`✅ [SDK] Producer created - id: ${producer.id}, kind: ${producer.kind}`);
+        const producer = await this.mediasoupManager.produce(track, appData);
         if (this.localParticipant) {
             const isFirstProducer = this.localParticipant.producers.size === 0;
             this.localParticipant.producers.set(producer.id, producer);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@newgameplusinc/odyssey-audio-video-sdk-dev",
-  "version": "1.0.56",
-  "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication with AI-powered noise suppression",
+  "version": "1.0.58",
+  "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -31,8 +31,7 @@
     "socket.io-client": "^4.7.2",
     "webrtc-adapter": "^8.2.3",
     "mediasoup-client": "^3.6.90",
-    "events": "^3.3.0",
-    "@tensorflow/tfjs": "^4.22.0"
+    "events": "^3.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/MLNoiseSuppressor.d.ts

@@ -1,76 +0,0 @@
-/**
- * ML-Based Noise Suppressor for Odyssey MediaSoup SDK
- * Uses trained TensorFlow.js BiLSTM model for real-time noise suppression
- *
- * Architecture: BiLSTM (256 units x 2) + Dense layers
- * Input: Mel-spectrogram features (16 frames x 128 mels)
- * Output: Noise suppression mask (0-1 per frequency bin)
- *
- * Trained on: LibriSpeech + UrbanSound8K + MS-SNSD datasets
- * Performance: val_loss=0.038, SNR improvement ~12dB
- */
-export declare class MLNoiseSuppressor {
-    private model;
-    private config;
-    private normStats;
-    private audioContext;
-    private isInitialized;
-    private processingNode;
-    private highPassFilter;
-    private frameBuffer;
-    private prevMask;
-    private readonly SMOOTHING_ALPHA;
-    private melFilterbank;
-    private fftSize;
-    private hannWindow;
-    /**
-     * Initialize the ML noise suppressor
-     * @param modelUrl URL to the model.json file
-     * @param audioContext Web Audio API AudioContext
-     */
-    initialize(modelUrl: string, audioContext: AudioContext): Promise<void>;
-    /**
-     * Create Hann window for FFT
-     */
-    private createHannWindow;
-    /**
-     * Create mel filterbank matrix
-     */
-    private createMelFilterbank;
-    /**
-     * Compute FFT magnitude spectrum (optimized DFT for real-time)
-     */
-    private computeFFT;
-    /**
-     * Compute mel-spectrogram features from audio frame
-     */
-    private computeMelFeatures;
-    /**
-     * Process audio buffer with ML noise suppression
-     * @param inputBuffer Audio buffer to process (Float32Array)
-     * @returns Processed audio buffer
-     */
-    processAudio(inputBuffer: Float32Array): Promise<Float32Array>;
-    /**
-     * Apply temporal smoothing to reduce artifacts (Apple-style)
-     */
-    private applyTemporalSmoothing;
-    /**
-     * Apply mask with voice frequency preservation
-     */
-    private applyMaskWithVoicePreservation;
-    /**
-     * Process MediaStream with ML noise suppression
-     * @param inputStream MediaStream to process
-     * @returns Cleaned MediaStream
-     */
-    processMediaStream(inputStream: MediaStream): Promise<MediaStream>;
-    /**
-     * Cleanup resources
-     */
-    dispose(): void;
-    /**
-     * Check if initialized
-     */
-    isReady(): boolean;
-}

package/dist/MLNoiseSuppressor.js

@@ -1,439 +0,0 @@
-"use strict";
-/**
- * ML-Based Noise Suppressor for Odyssey MediaSoup SDK
- * Uses trained TensorFlow.js BiLSTM model for real-time noise suppression
- *
- * Architecture: BiLSTM (256 units x 2) + Dense layers
- * Input: Mel-spectrogram features (16 frames x 128 mels)
- * Output: Noise suppression mask (0-1 per frequency bin)
- *
- * Trained on: LibriSpeech + UrbanSound8K + MS-SNSD datasets
- * Performance: val_loss=0.038, SNR improvement ~12dB
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MLNoiseSuppressor = void 0;
-const tf = __importStar(require("@tensorflow/tfjs"));
-class MLNoiseSuppressor {
-    constructor() {
-        this.model = null;
-        this.config = null;
-        this.normStats = null;
-        this.audioContext = null;
-        this.isInitialized = false;
-        // Real-time processing state
-        this.processingNode = null;
-        this.highPassFilter = null;
-        // Frame buffer for sequence-based processing
-        this.frameBuffer = [];
-        this.prevMask = null;
-        // Temporal smoothing (CRITICAL for quality - like Apple!)
-        this.SMOOTHING_ALPHA = 0.85; // Higher = smoother transitions
-        // Mel filterbank cache
-        this.melFilterbank = null;
-        this.fftSize = 512;
-        // FFT workspace
-        this.hannWindow = null;
-    }
-    /**
-     * Initialize the ML noise suppressor
-     * @param modelUrl URL to the model.json file
-     * @param audioContext Web Audio API AudioContext
-     */
-    async initialize(modelUrl, audioContext) {
-        console.log("🚀 Initializing ML Noise Suppressor (BiLSTM v2)...");
-        this.audioContext = audioContext;
-        try {
-            // Load model
-            console.log(`📂 Loading model from ${modelUrl}`);
-            this.model = await tf.loadLayersModel(modelUrl);
-            console.log("✅ Model loaded successfully");
-            console.log(`   Parameters: ${this.model.countParams().toLocaleString()}`);
-            // Load config
-            const baseUrl = modelUrl.substring(0, modelUrl.lastIndexOf("/"));
-            const configUrl = `${baseUrl}/model_config.json`;
-            const configResponse = await fetch(configUrl);
-            this.config = await configResponse.json();
-            console.log("⚙️  Config loaded:", this.config);
-            // Load normalization stats
-            const normUrl = `${baseUrl}/normalization_stats.json`;
-            const normResponse = await fetch(normUrl);
-            this.normStats = await normResponse.json();
-            console.log(`📏 Normalization stats: mean=${this.normStats.mean.toFixed(4)}, std=${this.normStats.std.toFixed(4)}`);
-            // Initialize FFT workspace
-            this.fftSize = this.config.frame_size || 512;
-            this.hannWindow = this.createHannWindow(this.fftSize);
-            // Create mel filterbank
-            this.melFilterbank = this.createMelFilterbank(this.fftSize, this.config.sample_rate, this.config.n_mels, 20, // fmin
-            8000 // fmax for voice
-            );
-            this.isInitialized = true;
-            console.log("✅ ML Noise Suppressor initialized!");
-        }
-        catch (error) {
-            console.error("❌ Failed to initialize ML Noise Suppressor:", error);
-            throw error;
-        }
-    }
-    /**
-     * Create Hann window for FFT
-     */
-    createHannWindow(size) {
-        const window = new Float32Array(size);
-        for (let i = 0; i < size; i++) {
-            window[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (size - 1)));
-        }
-        return window;
-    }
-    /**
-     * Create mel filterbank matrix
-     */
-    createMelFilterbank(fftSize, sampleRate, nMels, fmin, fmax) {
-        const nFft = Math.floor(fftSize / 2) + 1;
-        // Convert Hz to Mel scale
-        const hzToMel = (hz) => 2595 * Math.log10(1 + hz / 700);
-        const melToHz = (mel) => 700 * (Math.pow(10, mel / 2595) - 1);
-        const melMin = hzToMel(fmin);
-        const melMax = hzToMel(fmax);
-        // Create mel center frequencies
-        const melPoints = [];
-        for (let i = 0; i < nMels + 2; i++) {
-            melPoints.push(melMin + ((melMax - melMin) * i) / (nMels + 1));
-        }
-        // Convert to Hz
-        const hzPoints = melPoints.map(melToHz);
-        // Convert to FFT bins
-        const binPoints = hzPoints.map((hz) => Math.floor(((fftSize + 1) * hz) / sampleRate));
-        // Create triangular filterbank
-        const filterbank = [];
-        for (let m = 0; m < nMels; m++) {
-            const filter = new Float32Array(nFft);
-            const left = binPoints[m];
-            const center = binPoints[m + 1];
-            const right = binPoints[m + 2];
-            // Rising slope
-            for (let k = left; k < center && k < nFft; k++) {
-                filter[k] = (k - left) / (center - left);
-            }
-            // Falling slope
-            for (let k = center; k < right && k < nFft; k++) {
-                filter[k] = (right - k) / (right - center);
-            }
-            filterbank.push(filter);
-        }
-        return filterbank;
-    }
-    /**
-     * Compute FFT magnitude spectrum (optimized DFT for real-time)
-     */
-    computeFFT(frame) {
-        const N = frame.length;
-        const magnitude = new Float32Array(Math.floor(N / 2) + 1);
-        // Apply Hann window
-        const windowed = new Float32Array(N);
-        for (let i = 0; i < N; i++) {
-            windowed[i] = frame[i] * (this.hannWindow?.[i] || 1);
-        }
-        // Compute DFT for positive frequencies only
-        for (let k = 0; k <= N / 2; k++) {
-            let real = 0;
-            let imag = 0;
-            const twoPiKOverN = (2 * Math.PI * k) / N;
-            for (let n = 0; n < N; n++) {
-                const angle = twoPiKOverN * n;
-                real += windowed[n] * Math.cos(angle);
-                imag -= windowed[n] * Math.sin(angle);
-            }
-            magnitude[k] = Math.sqrt(real * real + imag * imag);
-        }
-        return magnitude;
-    }
-    /**
-     * Compute mel-spectrogram features from audio frame
-     */
-    computeMelFeatures(audio) {
-        if (!this.config || !this.melFilterbank) {
-            throw new Error("Config or filterbank not loaded");
-        }
-        // Compute FFT magnitude
-        const spectrum = this.computeFFT(audio);
-        // Apply mel filterbank and log compression
-        const melFeatures = new Array(this.config.n_mels);
-        for (let m = 0; m < this.config.n_mels; m++) {
-            let sum = 0;
-            const filter = this.melFilterbank[m];
-            for (let k = 0; k < spectrum.length && k < filter.length; k++) {
-                sum += spectrum[k] * spectrum[k] * filter[k]; // Power spectrum
-            }
-            // Log compression (matching training)
-            melFeatures[m] = Math.log(Math.max(sum, 1e-10) + 1);
-        }
-        return melFeatures;
-    }
-    /**
-     * Process audio buffer with ML noise suppression
-     * @param inputBuffer Audio buffer to process (Float32Array)
-     * @returns Processed audio buffer
-     */
-    async processAudio(inputBuffer) {
-        if (!this.isInitialized || !this.model || !this.config || !this.normStats) {
-            return inputBuffer;
-        }
-        try {
-            const hopLength = this.config.hop_length;
-            const frameSize = this.config.frame_size || 512;
-            const numFrames = Math.floor((inputBuffer.length - frameSize) / hopLength) + 1;
-            if (numFrames < 1) {
-                return inputBuffer;
-            }
-            // Extract mel features for each frame
-            const features = [];
-            for (let i = 0; i < numFrames; i++) {
-                const start = i * hopLength;
-                const frame = inputBuffer.slice(start, start + frameSize);
-                const melFeatures = this.computeMelFeatures(frame);
-                features.push(melFeatures);
-            }
-            // Add to frame buffer for sequence processing
-            this.frameBuffer.push(...features);
-            // Keep only recent frames (2x sequence length for overlap)
-            const seqLength = this.config.sequence_length;
-            while (this.frameBuffer.length > seqLength * 2) {
-                this.frameBuffer.shift();
-            }
-            // Need enough frames for one sequence
-            if (this.frameBuffer.length < seqLength) {
-                return inputBuffer; // Not enough frames yet, pass through
-            }
-            // Create sequence from recent frames
-            const sequence = this.frameBuffer.slice(-seqLength);
-            // Normalize features (using training stats)
-            const normalizedSeq = sequence.map((frame) => frame.map((val) => (val - this.normStats.mean) / this.normStats.std));
-            // Run model inference
-            const mask = await tf.tidy(() => {
-                const inputTensor = tf.tensor3d([normalizedSeq]);
-                const output = this.model.predict(inputTensor);
-                return output.arraySync();
-            });
-            // Get mask for the last frame (most recent prediction)
-            const lastMaskFrame = mask[0][seqLength - 1];
-            const currentMask = new Float32Array(lastMaskFrame);
-            // Apply temporal smoothing (CRITICAL for Apple-quality audio!)
-            const smoothedMask = this.applyTemporalSmoothing(currentMask);
-            // Apply mask to audio with voice preservation
-            const output = this.applyMaskWithVoicePreservation(inputBuffer, smoothedMask, numFrames);
-            return output;
-        }
-        catch (error) {
-            console.error("❌ Error processing audio:", error);
-            return inputBuffer;
-        }
-    }
-    /**
-     * Apply temporal smoothing to reduce artifacts (Apple-style)
-     */
-    applyTemporalSmoothing(currentMask) {
-        if (!this.prevMask || this.prevMask.length !== currentMask.length) {
-            this.prevMask = new Float32Array(currentMask);
-            return currentMask;
-        }
-        const smoothed = new Float32Array(currentMask.length);
-        for (let i = 0; i < currentMask.length; i++) {
-            // Exponential moving average for smooth transitions
-            smoothed[i] =
-                this.SMOOTHING_ALPHA * currentMask[i] +
-                    (1 - this.SMOOTHING_ALPHA) * this.prevMask[i];
-            // Never completely mute (preserve minimum 3% - prevents artifacts)
-            smoothed[i] = Math.max(0.03, Math.min(1.0, smoothed[i]));
-        }
-        this.prevMask = smoothed;
-        return smoothed;
-    }
-    /**
-     * Apply mask with voice frequency preservation
-     */
-    applyMaskWithVoicePreservation(audio, mask, numFrames) {
-        const output = new Float32Array(audio.length);
-        const hopLength = this.config.hop_length;
-        const nMels = this.config.n_mels;
-        // Calculate frequency-weighted gain
-        // Voice fundamentals are in lower mel bins, preserve them more
-        let voiceGain = 0;
-        let noiseGain = 0;
-        // Lower 1/4 of mels = voice fundamentals (80-500Hz)
-        const voiceBins = Math.floor(nMels / 4);
-        for (let i = 0; i < voiceBins; i++) {
-            voiceGain += mask[i];
-        }
-        voiceGain /= voiceBins;
-        // Upper 3/4 = potentially noise
-        for (let i = voiceBins; i < nMels; i++) {
-            noiseGain += mask[i];
-        }
-        noiseGain /= nMels - voiceBins;
-        // Blend gains (favor voice preservation)
-        const avgGain = voiceGain * 0.7 + noiseGain * 0.3;
-        // Apply gain per sample
-        for (let i = 0; i < audio.length; i++) {
-            // Use smooth gain
-            let gain = avgGain;
-            // Boost if mask indicates strong voice (> 0.5)
-            if (avgGain > 0.5) {
-                gain = Math.min(1.0, avgGain * 1.05);
-            }
-            output[i] = audio[i] * gain;
-        }
-        // Apply soft fade at edges to prevent clicks
-        const fadeLen = Math.min(64, output.length / 10);
-        for (let i = 0; i < fadeLen; i++) {
-            const fade = i / fadeLen;
-            output[i] *= fade;
-            output[output.length - 1 - i] *= fade;
-        }
-        return output;
-    }
-    /**
-     * Process MediaStream with ML noise suppression
-     * @param inputStream MediaStream to process
-     * @returns Cleaned MediaStream
-     */
-    async processMediaStream(inputStream) {
-        if (!this.audioContext || !this.isInitialized) {
-            console.warn("⚠️  ML Noise Suppressor not initialized, returning original stream");
-            return inputStream;
-        }
-        try {
-            console.log("🎤 [ML] Setting up BiLSTM noise suppression pipeline...");
-            // Create MediaStreamSource from input
-            const source = this.audioContext.createMediaStreamSource(inputStream);
-            // Create high-pass filter (remove <80Hz rumble - like Apple)
-            this.highPassFilter = this.audioContext.createBiquadFilter();
-            this.highPassFilter.type = "highpass";
-            this.highPassFilter.frequency.value = 80;
-            this.highPassFilter.Q.value = 0.7;
-            // Create destination for output
-            const destination = this.audioContext.createMediaStreamDestination();
-            // Create ScriptProcessor for real-time ML processing
-            // Buffer size of 2048 = ~42ms latency at 48kHz (acceptable for real-time)
-            const bufferSize = 2048;
-            this.processingNode = this.audioContext.createScriptProcessor(bufferSize, 1, 1);
-            let frameCount = 0;
-            const startTime = performance.now();
-            // Double-buffering for async ML processing
-            // We store the PREVIOUS processed result and output it in the NEXT callback
-            // This adds one buffer of latency but ensures we never output zeros
-            let previousProcessedBuffer = null;
-            let processingInFlight = false;
-            // Process audio frames with ML model
-            // IMPORTANT: onaudioprocess is synchronous! We use double-buffering to handle async ML
-            this.processingNode.onaudioprocess = (event) => {
-                const inputData = event.inputBuffer.getChannelData(0);
-                const outputData = event.outputBuffer.getChannelData(0);
-                frameCount++;
-                // OUTPUT: Use previously processed audio (or passthrough if not ready yet)
-                if (previousProcessedBuffer) {
-                    outputData.set(previousProcessedBuffer);
-                }
-                else {
-                    // First frame or ML not ready - pass through original audio
-                    outputData.set(inputData);
-                }
-                // PROCESS: Start async ML processing for the NEXT frame
-                // Only start new processing if previous one is complete
-                if (!processingInFlight) {
-                    processingInFlight = true;
-                    const inputCopy = new Float32Array(inputData);
-                    // Fire-and-forget async processing
-                    this.processAudio(inputCopy)
-                        .then((processed) => {
-                        previousProcessedBuffer = processed;
-                        processingInFlight = false;
-                    })
-                        .catch((error) => {
-                        // On error, store the original audio for passthrough
-                        previousProcessedBuffer = inputCopy;
-                        processingInFlight = false;
-                    });
-                }
-                // Log performance every ~4 seconds
-                if (frameCount % 100 === 0) {
-                    const elapsed = (performance.now() - startTime) / 1000;
-                    const fps = frameCount / elapsed;
-                    console.log(`🎤 [ML] BiLSTM: ${frameCount} frames @ ${fps.toFixed(1)} fps`);
-                }
-            };
-            // Connect: source -> highpass -> BiLSTM processor -> destination
-            source.connect(this.highPassFilter);
-            this.highPassFilter.connect(this.processingNode);
-            this.processingNode.connect(destination);
-            console.log("✅ [ML] Pipeline: mic → highpass(80Hz) → BiLSTM(256x2) → output");
-            console.log("✅ [ML] Latency: ~42ms, Sample rate: 48kHz");
-            return destination.stream;
-        }
-        catch (error) {
-            console.error("❌ [ML] Failed to process MediaStream:", error);
-            return inputStream;
-        }
-    }
-    /**
-     * Cleanup resources
-     */
-    dispose() {
-        if (this.processingNode) {
-            this.processingNode.disconnect();
-            this.processingNode = null;
-        }
-        if (this.highPassFilter) {
-            this.highPassFilter.disconnect();
-            this.highPassFilter = null;
-        }
-        if (this.model) {
-            this.model.dispose();
-            this.model = null;
-        }
-        this.frameBuffer = [];
-        this.prevMask = null;
-        this.melFilterbank = null;
-        this.isInitialized = false;
-        console.log("🗑️  ML Noise Suppressor disposed");
-    }
-    /**
-     * Check if initialized
-     */
-    isReady() {
-        return this.isInitialized;
-    }
-}
-exports.MLNoiseSuppressor = MLNoiseSuppressor;

package/dist/UltimateMLNoiseSuppressor.d.ts

@@ -1,74 +0,0 @@
-/**
- * ULTIMATE ML Noise Suppressor - Enhanced for Apple/Google Meet Quality
- * Features:
- * 1. Temporal smoothing (exponential moving average)
- * 2. Voice frequency preservation (80-500 Hz)
- * 3. Sub-bass filtering (remove < 80 Hz)
- * 4. Adaptive processing
- * 5. WebAssembly acceleration
- */
-export declare class UltimateMLNoiseSuppressor {
-    private model;
-    private config;
-    private normStats;
-    private audioContext;
-    private isInitialized;
-    private prevMask;
-    private readonly SMOOTHING_ALPHA;
-    private highPassFilter;
-    private voiceBandFilter;
-    private processingQueue;
-    private isProcessing;
-    /**
-     * Initialize with enhanced setup
-     */
-    initialize(modelUrl: string, audioContext: AudioContext): Promise<void>;
-    /**
-     * Setup filters for voice frequency preservation
-     */
-    private setupVoiceFilters;
-    /**
-     * Process audio with ULTIMATE quality
-     * NOTE: This runs in the AudioWorklet thread. It must be synchronous and fast.
-     * The heavy ML inference should ideally happen in a Worker, communicating via SharedArrayBuffer.
-     * For this implementation, we use a simplified frame-based approach.
-     */
-    processAudio(inputBuffer: Float32Array): Float32Array;
-    /**
-     * Placeholder for async processing (to be moved to a Web Worker)
-     */
-    processFrameAsync(inputBuffer: Float32Array): Promise<void>;
-    /**
-     * CRITICAL: Temporal smoothing (biggest quality improvement!)
-     */
-    private applyTemporalSmoothing;
-    /**
-     * Apply high-pass filter to remove rumble
-     */
-    private applyHighPassFilter;
-    /**
-     * Apply mask with voice frequency preservation
-     */
-    private applyMaskWithVoicePreservation;
-    /**
-     * Extract mel-spectrogram features
-     */
-    private extractMelFeatures;
-    /**
-     * Compute mel bin (simplified)
-     */
-    private computeMelBin;
-    /**
-     * Create sequences for LSTM input
-     */
-    private createSequences;
-    /**
-     * Reset processing state (call when switching audio streams)
-     */
-    reset(): void;
-    /**
-     * Get processing latency
-     */
-    getLatency(): number;
-}
-export default UltimateMLNoiseSuppressor;

package/dist/UltimateMLNoiseSuppressor.js

@@ -1,309 +0,0 @@
-"use strict";
-/**
- * ULTIMATE ML Noise Suppressor - Enhanced for Apple/Google Meet Quality
- * Features:
- * 1. Temporal smoothing (exponential moving average)
- * 2. Voice frequency preservation (80-500 Hz)
- * 3. Sub-bass filtering (remove < 80 Hz)
- * 4. Adaptive processing
- * 5. WebAssembly acceleration
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UltimateMLNoiseSuppressor = void 0;
-const tf = __importStar(require("@tensorflow/tfjs"));
-class UltimateMLNoiseSuppressor {
-    constructor() {
-        this.model = null;
-        this.config = null;
-        this.normStats = null;
-        this.audioContext = null;
-        this.isInitialized = false;
-        // CRITICAL: Temporal smoothing state
-        this.prevMask = null;
-        this.SMOOTHING_ALPHA = 0.85; // 85% current, 15% previous
-        // Voice frequency preservation
-        this.highPassFilter = null;
-        this.voiceBandFilter = null;
-        // Processing optimization
-        this.processingQueue = [];
-        this.isProcessing = false;
-    }
-    /**
-     * Initialize with enhanced setup
-     */
-    async initialize(modelUrl, audioContext) {
-        console.log("🚀 Initializing ULTIMATE ML Noise Suppressor...");
-        this.audioContext = audioContext;
-        try {
-            // Load model
-            console.log(`📂 Loading model from ${modelUrl}`);
-            this.model = await tf.loadLayersModel(modelUrl);
-            console.log("✅ Model loaded");
-            // Load config
-            const baseUrl = modelUrl.substring(0, modelUrl.lastIndexOf("/"));
-            const configResponse = await fetch(`${baseUrl}/model_config.json`);
-            this.config = await configResponse.json();
-            // Load normalization stats
-            const normResponse = await fetch(`${baseUrl}/normalization_stats.json`);
-            this.normStats = await normResponse.json();
-            // Setup voice frequency filters
-            this.setupVoiceFilters();
-            this.isInitialized = true;
-            console.log("✅ ULTIMATE ML Noise Suppressor initialized!");
-        }
-        catch (error) {
-            console.error("❌ Failed to initialize:", error);
-            throw error;
-        }
-    }
-    /**
-     * Setup filters for voice frequency preservation
-     */
-    setupVoiceFilters() {
-        if (!this.audioContext)
-            return;
-        // High-pass filter: Remove sub-bass rumble (< 80 Hz)
-        this.highPassFilter = this.audioContext.createBiquadFilter();
-        this.highPassFilter.type = "highpass";
-        this.highPassFilter.frequency.value = 80; // 80 Hz cutoff
-        this.highPassFilter.Q.value = 0.7;
-        // Bandpass filter: Enhance voice fundamentals (100-300 Hz)
-        this.voiceBandFilter = this.audioContext.createBiquadFilter();
-        this.voiceBandFilter.type = "bandpass";
-        this.voiceBandFilter.frequency.value = 200; // Center at 200 Hz
-        this.voiceBandFilter.Q.value = 1.4;
-    }
-    /**
-     * Process audio with ULTIMATE quality
-     * NOTE: This runs in the AudioWorklet thread. It must be synchronous and fast.
-     * The heavy ML inference should ideally happen in a Worker, communicating via SharedArrayBuffer.
-     * For this implementation, we use a simplified frame-based approach.
-     */
-    processAudio(inputBuffer) {
-        if (!this.isInitialized || !this.model || !this.config || !this.normStats) {
-            return inputBuffer;
-        }
-        // 1. Pre-processing: Remove sub-bass rumble (High-pass)
-        // Note: In a real AudioWorklet, filters should be applied per-sample or per-block, not on the whole buffer at once if it's a stream.
-        // But assuming inputBuffer is a processing block (e.g. 128 samples):
-        const filtered = this.applyHighPassFilter(inputBuffer);
-        // ⚠️ CRITICAL ARCHITECTURE NOTE ⚠️
-        // We cannot await this.model.predict() here because this function must return immediately for real-time audio.
-        // The correct architecture is:
-        // 1. AudioWorklet writes audio to a RingBuffer (SharedArrayBuffer).
-        // 2. Web Worker reads RingBuffer, runs TFJS inference (async), writes Mask to another RingBuffer.
-        // 3. AudioWorklet reads latest Mask from RingBuffer and applies it.
-        // For now, we will return the filtered audio.
-        // To enable ML, you must implement the Worker architecture described above.
-        // Running TFJS on the main audio thread will cause stuttering.
-        return filtered;
-    }
-    /**
-     * Placeholder for async processing (to be moved to a Web Worker)
-     */
-    async processFrameAsync(inputBuffer) {
-        // This logic belongs in a Web Worker
-        try {
-            const features = await this.extractMelFeatures(inputBuffer);
-            const normalizedFeatures = tf.tidy(() => {
-                const tensor = tf.tensor2d(features);
-                return tensor.sub(this.normStats.mean).div(this.normStats.std);
-            });
-            const featuresArray = await normalizedFeatures.array();
-            const sequences = this.createSequences(featuresArray, this.config.sequence_length);
-            if (sequences.length > 0) {
-                const sequenceTensor = tf.tensor3d([sequences[0]]);
-                const maskTensor = this.model.predict(sequenceTensor);
-                const maskData = await maskTensor.data();
-                const flatMask = Array.from(maskData);
-                // Update the current mask for the AudioWorklet to use
-                this.prevMask = this.applyTemporalSmoothing(flatMask);
-                normalizedFeatures.dispose();
-                sequenceTensor.dispose();
-                maskTensor.dispose();
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-    }
-    /**
-     * CRITICAL: Temporal smoothing (biggest quality improvement!)
-     */
-    applyTemporalSmoothing(currentMask) {
-        const smoothed = new Float32Array(currentMask.length);
-        if (!this.prevMask || this.prevMask.length !== currentMask.length) {
-            // First frame - no smoothing
-            this.prevMask = new Float32Array(currentMask);
-            return this.prevMask;
-        }
-        // Exponential moving average
-        for (let i = 0; i < currentMask.length; i++) {
-            smoothed[i] =
-                this.SMOOTHING_ALPHA * currentMask[i] +
-                    (1 - this.SMOOTHING_ALPHA) * this.prevMask[i];
-            // Clamp to valid range [0.02, 1.0]
-            // Never completely mute (min 2%)
-            smoothed[i] = Math.max(0.02, Math.min(1.0, smoothed[i]));
-        }
-        this.prevMask = smoothed;
-        return smoothed;
-    }
-    /**
-     * Apply high-pass filter to remove rumble
-     */
-    applyHighPassFilter(input) {
-        // Simple IIR high-pass filter (80 Hz @ 48kHz)
-        const output = new Float32Array(input.length);
-        const alpha = 0.98; // Filter coefficient
-        output[0] = input[0];
-        for (let i = 1; i < input.length; i++) {
-            output[i] = alpha * (output[i - 1] + input[i] - input[i - 1]);
-        }
-        return output;
-    }
-    /**
-     * Apply mask with voice frequency preservation
-     */
-    applyMaskWithVoicePreservation(audio, mask, numFrames) {
-        const output = new Float32Array(audio.length);
-        // Simple overlap-add (proper implementation would use ISTFT)
-        const hopLength = Math.floor(audio.length / numFrames);
-        for (let i = 0; i < audio.length; i++) {
-            const frameIdx = Math.floor(i / hopLength);
-            const maskIdx = Math.min(frameIdx, numFrames - 1);
-            // Apply mask
-            let gain = 1.0;
-            if (maskIdx < mask.length / this.config.n_mels) {
-                // Average mask across frequency bins for this frame
-                let maskSum = 0;
-                const startBin = maskIdx * this.config.n_mels;
-                for (let j = 0; j < this.config.n_mels; j++) {
-                    maskSum += mask[startBin + j];
-                }
-                gain = maskSum / this.config.n_mels;
-            }
-            // Apply gain with minimum threshold
-            output[i] = audio[i] * Math.max(0.02, gain);
-        }
-        // Apply fade-in/out to prevent clicks
-        const fadeLength = Math.min(256, output.length / 10);
-        for (let i = 0; i < fadeLength; i++) {
-            const fade = i / fadeLength;
-            output[i] *= fade;
-            output[output.length - 1 - i] *= fade;
-        }
-        return output;
-    }
-    /**
-     * Extract mel-spectrogram features
-     */
-    async extractMelFeatures(audio) {
-        if (!this.config)
-            throw new Error("Config not loaded");
-        // Simplified feature extraction
-        // In production, use proper STFT + Mel filterbank
-        const frameLength = this.config.n_fft;
-        const hopLength = this.config.hop_length;
-        const numFrames = Math.floor((audio.length - frameLength) / hopLength) + 1;
-        const features = [];
-        for (let i = 0; i < numFrames; i++) {
-            const start = i * hopLength;
-            const frame = audio.slice(start, start + frameLength);
-            // Compute mel bins (simplified)
-            const frameFeatures = [];
-            for (let j = 0; j < this.config.n_mels; j++) {
-                const melBin = this.computeMelBin(frame, j);
-                frameFeatures.push(melBin);
-            }
-            features.push(frameFeatures);
-        }
-        return features;
-    }
-    /**
-     * Compute mel bin (simplified)
-     */
-    computeMelBin(frame, binIndex) {
-        const start = Math.floor((binIndex / this.config.n_mels) * frame.length);
-        const end = Math.floor(((binIndex + 1) / this.config.n_mels) * frame.length);
-        let sum = 0;
-        for (let i = start; i < end && i < frame.length; i++) {
-            sum += Math.abs(frame[i]);
-        }
-        const avg = sum / (end - start);
-        // Convert to log scale (dB-like)
-        return Math.log10(avg + 1e-8) * 10;
-    }
-    /**
-     * Create sequences for LSTM input
-     */
-    createSequences(features, seqLength) {
-        const sequences = [];
-        for (let i = 0; i <= features.length - seqLength; i++) {
-            sequences.push(features.slice(i, i + seqLength));
-        }
-        // If not enough frames, pad with last frame
-        if (sequences.length === 0 && features.length > 0) {
-            const paddedSeq = [];
-            for (let i = 0; i < seqLength; i++) {
-                paddedSeq.push(features[Math.min(i, features.length - 1)]);
-            }
-            sequences.push(paddedSeq);
-        }
-        return sequences;
-    }
-    /**
-     * Reset processing state (call when switching audio streams)
-     */
-    reset() {
-        this.prevMask = null;
-        this.processingQueue = [];
-    }
-    /**
-     * Get processing latency
-     */
-    getLatency() {
-        if (!this.config)
-            return 0;
-        // Approximate latency in milliseconds
-        const bufferLatency = (this.config.n_fft / this.config.sample_rate) * 1000;
-        const processingLatency = 10; // Model inference ~10ms
-        return bufferLatency + processingLatency;
-    }
-}
-exports.UltimateMLNoiseSuppressor = UltimateMLNoiseSuppressor;
-// Export for use in AudioWorklet
-exports.default = UltimateMLNoiseSuppressor;