@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.16 → 1.0.18

package/README.md

@@ -13,7 +13,6 @@ It mirrors the production SDK used by Odyssey V2 and ships ready-to-drop into an
 - 🧭 **Accurate pose propagation** – `updatePosition()` streams listener pose to the SFU while `participant-position-updated` keeps the local store in sync.
 - 🎧 **Studio-grade spatial audio** – each remote participant gets a dedicated Web Audio graph: denoiser → high-pass → low-pass → HRTF `PannerNode` → adaptive gain → master compressor.
 - 🎥 **Camera-ready streams** – video tracks are exposed separately so UI layers can render muted `<video>` tags while audio stays inside Web Audio.
-- 🎙️ **Clean microphone uplink (opt‑in)** – when `outboundTuning.enabled=true`, `enhanceOutgoingAudioTrack` runs mic input through denoiser + EQ + compressor before hitting the SFU.
 - 🔁 **EventEmitter contract** – subscribe to `room-joined`, `consumer-created`, `participant-position-updated`, etc., without touching Socket.IO directly.
 
 ## Quick Start
@@ -81,7 +80,6 @@ sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
 - **Orientation math** – `setListenerFromLSD()` builds forward/right/up vectors from camera/LookAt to keep the listener aligned with head movement.
 - **Dynamic distance gain** – `updateSpatialAudio()` measures distance from listener → source and applies a smooth rolloff curve, so distant avatars fade to silence.
 - **Noise handling** – optional AudioWorklet denoiser plus high/low-pass filters trim rumble & hiss before HRTF processing.
-- **Dynamic gate (opt-in)** – enable via `noiseGate.enabled=true` to let the SDK automatically clamp remote tracks when they’re idle.
 
 #### How Spatial Audio Is Built
 1. **Telemetry ingestion** – each LSD packet is passed through `setListenerFromLSD(listenerPos, cameraPos, lookAtPos)` so the Web Audio listener matches the player’s real head/camera pose.
@@ -91,13 +89,6 @@ sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
 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.
 
-#### How Microphone Audio Is Tuned Before Sending (Opt-In)
-> Disabled by default. Enable via `new SpatialAudioManager({ outboundTuning: { enabled: true } })`.
-1. **Hardware constraints first** – the SDK requests `noiseSuppression`, `echoCancellation`, and `autoGainControl` on the raw `MediaStreamTrack` (plus Chromium-specific `goog*` flags).
-2. **Web Audio pre-flight** – `enhanceOutgoingAudioTrack(track)` clones the mic into a dedicated `AudioContext` and chain: `Denoiser → 50/60 Hz notches → Low-shelf rumble cut → High-pass (95 Hz) → Low-pass (7.2 kHz) → High-shelf tame → Presence boost → Dynamics compressor → Adaptive gate`.
-3. **Adaptive gate** – a lightweight RMS monitor clamps the gate gain when only background hiss remains, but opens instantly when speech energy rises.
-4. **Clean stream to SFU** – the processed track is what you pass to `produceTrack`, so every participant receives the filtered audio (and your local store uses the same track for mute toggles). Toggle the feature off to fall back to raw WebRTC audio instantly.
-
 ## Video Flow (Capture ↔ Rendering)
 
 ```

package/dist/SpatialAudioManager.d.ts

@@ -12,17 +12,9 @@ type DenoiserOptions = {
     noiseFloor?: number;
     release?: number;
 };
-type NoiseGateOptions = {
-    enabled?: boolean;
-};
-type OutboundTuningOptions = {
-    enabled?: boolean;
-};
 type SpatialAudioOptions = {
     distance?: SpatialAudioDistanceConfig;
     denoiser?: DenoiserOptions;
-    noiseGate?: NoiseGateOptions;
-    outboundTuning?: OutboundTuningOptions;
 };
 export declare class SpatialAudioManager extends EventManager {
     private audioContext;
@@ -31,16 +23,12 @@ export declare class SpatialAudioManager extends EventManager {
     private monitoringIntervals;
     private compressor;
     private options;
+    private denoiseWorkletReady;
     private denoiseWorkletUrl?;
     private denoiserWasmBytes?;
-    private denoiseContextPromises;
     private listenerPosition;
     private listenerInitialized;
-    private stabilityState;
-    private outgoingProcessors;
     private listenerDirection;
-    private noiseGateEnabled;
-    private outboundTuningEnabled;
     constructor(options?: SpatialAudioOptions);
     getAudioContext(): AudioContext;
     /**
@@ -59,9 +47,7 @@ export declare class SpatialAudioManager extends EventManager {
      * @param bypassSpatialization For testing - bypasses 3D positioning
      */
     setupSpatialAudioForParticipant(participantId: string, track: MediaStreamTrack, bypassSpatialization?: boolean): Promise<void>;
-    enhanceOutgoingAudioTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
     private startMonitoring;
-    private handleTrackStability;
     /**
      * Update spatial audio position and orientation for a participant
      *
@@ -110,10 +96,14 @@ export declare class SpatialAudioManager extends EventManager {
     private getDistanceBetween;
     private calculateDistanceGain;
     private normalizePositionUnits;
+    private getVectorFromListener;
+    private applyDirectionalSuppression;
+    private calculateClarityScore;
+    private calculateProximityWeight;
+    private calculateDirectionFocus;
+    private normalizeVector;
+    private clamp;
     private isDenoiserEnabled;
-    private applyHardwareNoiseConstraints;
-    private startOutboundMonitor;
-    private cleanupOutboundProcessor;
     private ensureDenoiseWorklet;
     private resolveOptions;
 }

package/dist/SpatialAudioManager.js

@@ -7,23 +7,19 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         super();
         this.participantNodes = new Map();
         this.monitoringIntervals = new Map();
-        this.denoiseContextPromises = new WeakMap();
+        this.denoiseWorkletReady = null;
         this.listenerPosition = { x: 0, y: 0, z: 0 };
         this.listenerInitialized = false;
-        this.stabilityState = new Map();
-        this.outgoingProcessors = new Map();
         this.listenerDirection = {
             forward: { x: 0, y: 1, z: 0 },
             up: { x: 0, y: 0, z: 1 },
         };
         this.options = this.resolveOptions(options);
-        this.noiseGateEnabled = this.options.noiseGate?.enabled ?? false;
-        this.outboundTuningEnabled = this.options.outboundTuning?.enabled ?? false;
         // Use high sample rate for best audio quality
         this.audioContext = new AudioContext({ sampleRate: 48000 });
         // Master gain
         this.masterGainNode = this.audioContext.createGain();
-        this.masterGainNode.gain.value = 1.8; // Lower headroom to avoid hiss from boosted noise floor
+        this.masterGainNode.gain.value = 5.0;
         // Compressor for dynamic range control and preventing distortion
         this.compressor = this.audioContext.createDynamicsCompressor();
         this.compressor.threshold.value = -24; // dB
@@ -73,7 +69,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const panner = this.audioContext.createPanner();
         const analyser = this.audioContext.createAnalyser();
         const gain = this.audioContext.createGain();
-        const noiseGate = this.audioContext.createGain();
+        const proximityGain = this.audioContext.createGain();
         let denoiseNode;
         if (this.isDenoiserEnabled() && typeof this.audioContext.audioWorklet !== "undefined") {
             try {
@@ -107,8 +103,11 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         lowpassFilter.type = "lowpass";
         lowpassFilter.frequency.value = 7500; // Below 8kHz to avoid flat/muffled sound
         lowpassFilter.Q.value = 1.0; // Quality factor
-        // Adaptive noise gate defaults
-        noiseGate.gain.value = 1.0;
+        const dynamicLowpass = this.audioContext.createBiquadFilter();
+        dynamicLowpass.type = "lowpass";
+        dynamicLowpass.frequency.value = 7600;
+        dynamicLowpass.Q.value = 0.8;
+        proximityGain.gain.value = 1.0;
         // Configure Panner for realistic 3D spatial audio
         const distanceConfig = this.getDistanceConfig();
         panner.panningModel = "HRTF"; // Head-Related Transfer Function for realistic 3D
@@ -128,20 +127,17 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         }
         currentNode.connect(highpassFilter);
         highpassFilter.connect(lowpassFilter);
-        let postFilterNode = lowpassFilter;
-        if (this.noiseGateEnabled) {
-            lowpassFilter.connect(noiseGate);
-            postFilterNode = noiseGate;
-        }
+        lowpassFilter.connect(dynamicLowpass);
+        dynamicLowpass.connect(proximityGain);
         if (bypassSpatialization) {
             console.log(`🔊 TESTING: Connecting audio directly to destination (bypassing spatial audio) for ${participantId}`);
-            postFilterNode.connect(analyser);
+            proximityGain.connect(analyser);
             analyser.connect(this.masterGainNode);
         }
         else {
             // Standard spatialized path with full audio chain
-            // Audio Chain: source -> filters -> (optional gate) -> panner -> analyser -> gain -> masterGain -> compressor -> destination
-            postFilterNode.connect(panner);
+            // Audio Chain: source -> filters -> panner -> analyser -> gain -> masterGain -> compressor -> destination
+            proximityGain.connect(panner);
             panner.connect(analyser);
             analyser.connect(gain);
             gain.connect(this.masterGainNode);
@@ -151,21 +147,13 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             panner,
             analyser,
             gain,
-            noiseGate,
+            proximityGain,
             highpassFilter,
             lowpassFilter,
+            dynamicLowpass,
             denoiseNode,
             stream,
         });
-        this.stabilityState.set(participantId, {
-            smoothedLevel: 0,
-            targetGain: 1,
-            networkMuted: false,
-        });
-        if (this.noiseGateEnabled && typeof track.onmute !== "undefined") {
-            track.onmute = () => this.handleTrackStability(participantId, true);
-            track.onunmute = () => this.handleTrackStability(participantId, false);
-        }
         console.log(`🎧 Spatial audio setup complete for ${participantId}:`, {
             audioContextState: this.audioContext.state,
             sampleRate: this.audioContext.sampleRate,
@@ -182,146 +170,15 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                 rolloffFactor: panner.rolloffFactor,
             },
         });
-        // Start monitoring audio levels if gate enabled
-        if (this.noiseGateEnabled) {
-            this.startMonitoring(participantId);
-        }
-    }
-    async enhanceOutgoingAudioTrack(track) {
-        if (track.kind !== "audio" || !this.outboundTuningEnabled) {
-            return track;
-        }
-        const existingProcessor = Array.from(this.outgoingProcessors.values()).find((processor) => processor.originalTrack === track);
-        if (existingProcessor) {
-            return existingProcessor.processedTrack;
-        }
-        await this.applyHardwareNoiseConstraints(track);
-        const context = new AudioContext({ sampleRate: 48000 });
-        await context.resume();
-        const sourceStream = new MediaStream([track]);
-        const source = context.createMediaStreamSource(sourceStream);
-        let current = source;
-        let denoiseNode;
-        if (this.isDenoiserEnabled() && typeof context.audioWorklet !== "undefined") {
-            try {
-                await this.ensureDenoiseWorklet(context);
-                denoiseNode = new AudioWorkletNode(context, "odyssey-denoise", {
-                    numberOfInputs: 1,
-                    numberOfOutputs: 1,
-                    processorOptions: {
-                        enabled: true,
-                        threshold: this.options.denoiser?.threshold,
-                        noiseFloor: this.options.denoiser?.noiseFloor,
-                        release: this.options.denoiser?.release,
-                        wasmBytes: this.denoiserWasmBytes
-                            ? this.denoiserWasmBytes.slice(0)
-                            : null,
-                    },
-                });
-                current.connect(denoiseNode);
-                current = denoiseNode;
-            }
-            catch (error) {
-                console.warn("⚠️ Outgoing denoiser unavailable, continuing without it.", error);
-            }
-        }
-        const notch60 = context.createBiquadFilter();
-        notch60.type = "notch";
-        notch60.frequency.value = 60;
-        notch60.Q.value = 24;
-        current.connect(notch60);
-        current = notch60;
-        const notch50 = context.createBiquadFilter();
-        notch50.type = "notch";
-        notch50.frequency.value = 50;
-        notch50.Q.value = 24;
-        current.connect(notch50);
-        current = notch50;
-        const lowShelf = context.createBiquadFilter();
-        lowShelf.type = "lowshelf";
-        lowShelf.frequency.value = 120;
-        lowShelf.gain.value = -3;
-        current.connect(lowShelf);
-        current = lowShelf;
-        const highpassFilter = context.createBiquadFilter();
-        highpassFilter.type = "highpass";
-        highpassFilter.frequency.value = 95;
-        highpassFilter.Q.value = 0.8;
-        current.connect(highpassFilter);
-        current = highpassFilter;
-        const lowpassFilter = context.createBiquadFilter();
-        lowpassFilter.type = "lowpass";
-        lowpassFilter.frequency.value = 7200;
-        lowpassFilter.Q.value = 0.8;
-        current.connect(lowpassFilter);
-        current = lowpassFilter;
-        const hissShelf = context.createBiquadFilter();
-        hissShelf.type = "highshelf";
-        hissShelf.frequency.value = 6400;
-        hissShelf.gain.value = -4;
-        current.connect(hissShelf);
-        current = hissShelf;
-        const presenceBoost = context.createBiquadFilter();
-        presenceBoost.type = "peaking";
-        presenceBoost.frequency.value = 2400;
-        presenceBoost.Q.value = 1.1;
-        presenceBoost.gain.value = 2.4;
-        current.connect(presenceBoost);
-        current = presenceBoost;
-        const compressor = context.createDynamicsCompressor();
-        compressor.threshold.value = -18;
-        compressor.knee.value = 16;
-        compressor.ratio.value = 3.2;
-        compressor.attack.value = 0.002;
-        compressor.release.value = 0.22;
-        current.connect(compressor);
-        current = compressor;
-        const postCompressorTap = context.createGain();
-        postCompressorTap.gain.value = 1.05;
-        current.connect(postCompressorTap);
-        current = postCompressorTap;
-        const analyser = context.createAnalyser();
-        analyser.fftSize = 512;
-        current.connect(analyser);
-        const gate = context.createGain();
-        gate.gain.value = 1;
-        current.connect(gate);
-        const destination = context.createMediaStreamDestination();
-        gate.connect(destination);
-        const processedTrack = destination.stream.getAudioTracks()[0];
-        processedTrack.contentHint = "speech";
-        const processorId = processedTrack.id;
-        const monitor = this.startOutboundMonitor(processorId, analyser, gate);
-        const cleanup = () => this.cleanupOutboundProcessor(processorId);
-        processedTrack.addEventListener("ended", cleanup);
-        track.addEventListener("ended", cleanup);
-        this.outgoingProcessors.set(processorId, {
-            context,
-            sourceStream,
-            destinationStream: destination.stream,
-            analyser,
-            gate,
-            monitor,
-            originalTrack: track,
-            processedTrack,
-            cleanupListener: cleanup,
-        });
-        console.log("🎛️ [SDK] Outgoing audio tuned", {
-            originalTrackId: track.id,
-            processedTrackId: processedTrack.id,
-        });
-        return processedTrack;
+        // Start monitoring audio levels
+        this.startMonitoring(participantId);
     }
     startMonitoring(participantId) {
-        if (!this.noiseGateEnabled) {
-            return;
-        }
         const nodes = this.participantNodes.get(participantId);
         if (!nodes)
             return;
-        const { analyser, stream, noiseGate } = nodes;
+        const { analyser, stream } = nodes;
         const dataArray = new Uint8Array(analyser.frequencyBinCount);
-        let lastTrackLog = 0;
         // Clear any existing interval for this participant
         if (this.monitoringIntervals.has(participantId)) {
             clearInterval(this.monitoringIntervals.get(participantId));
@@ -334,48 +191,16 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             }
             const average = sum / dataArray.length;
             const audioLevel = (average / 128) * 255; // Scale to 0-255
-            const normalizedLevel = audioLevel / 255;
-            const stability = this.stabilityState.get(participantId);
-            if (stability) {
-                const smoothing = 0.2;
-                stability.smoothedLevel =
-                    stability.smoothedLevel * (1 - smoothing) + normalizedLevel * smoothing;
-                const gateOpenThreshold = 0.028; // tuned for speech presence
-                const gateCloseThreshold = 0.012;
-                const noiseFloorGain = 0.12;
-                let targetGain = stability.targetGain;
-                if (stability.networkMuted) {
-                    targetGain = 0;
-                }
-                else if (stability.smoothedLevel < gateCloseThreshold) {
-                    targetGain = 0;
-                }
-                else if (stability.smoothedLevel < gateOpenThreshold) {
-                    targetGain = noiseFloorGain;
-                }
-                else {
-                    targetGain = 1;
-                }
-                if (Math.abs(targetGain - stability.targetGain) > 0.05) {
-                    const ramp = targetGain > stability.targetGain ? 0.04 : 0.18;
-                    noiseGate.gain.setTargetAtTime(targetGain, this.audioContext.currentTime, ramp);
-                    stability.targetGain = targetGain;
-                }
-                if (Math.random() < 0.05) {
-                    console.log(`🎚️ [NoiseGate] ${participantId}`, {
-                        level: stability.smoothedLevel.toFixed(3),
-                        gain: stability.targetGain.toFixed(2),
-                    });
-                }
-            }
-            if (audioLevel < 1.0 && Math.random() < 0.2) {
+            console.log(`📊 Audio level for ${participantId}: ${audioLevel.toFixed(2)} (0-255 scale)`);
+            if (audioLevel < 1.0) {
                 console.warn(`⚠️ NO AUDIO DATA detected for ${participantId}! Track may be silent or not transmitting.`);
+                console.info(`💡 Check: 1) Is microphone unmuted? 2) Is correct mic selected? 3) Is mic working in system settings?`);
             }
-            if (Date.now() - lastTrackLog > 2000) {
-                lastTrackLog = Date.now();
+            // Check track status after 2 seconds
+            setTimeout(() => {
                 const track = stream.getAudioTracks()[0];
                 if (track) {
-                    console.log(`🔊 Audio track status for ${participantId}:`, {
+                    console.log(`🔊 Audio track status after 2s for ${participantId}:`, {
                         trackEnabled: track.enabled,
                         trackMuted: track.muted,
                         trackReadyState: track.readyState,
@@ -387,23 +212,10 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                         },
                     });
                 }
-            }
-        }, 250); // Adaptive monitoring ~4x per second
+            }, 2000);
+        }, 2000); // Log every 2 seconds
         this.monitoringIntervals.set(participantId, interval);
     }
-    handleTrackStability(participantId, muted) {
-        if (!this.noiseGateEnabled) {
-            return;
-        }
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes)
-            return;
-        const stability = this.stabilityState.get(participantId);
-        if (stability) {
-            stability.networkMuted = muted;
-        }
-        nodes.noiseGate.gain.setTargetAtTime(muted ? 0 : 1, this.audioContext.currentTime, muted ? 0.05 : 0.2);
-    }
     /**
      * Update spatial audio position and orientation for a participant
      *
@@ -451,7 +263,9 @@ class SpatialAudioManager extends EventManager_1.EventManager {
                 }
             }
             const listenerPos = this.listenerPosition;
+            const vectorToSource = this.getVectorFromListener(targetPosition);
             const distance = this.getDistanceBetween(listenerPos, targetPosition);
+            this.applyDirectionalSuppression(participantId, distance, vectorToSource);
             const distanceGain = this.calculateDistanceGain(distanceConfig, distance);
             nodes.gain.gain.setTargetAtTime(distanceGain, this.audioContext.currentTime, 0.05);
             if (Math.random() < 0.02) {
@@ -587,18 +401,11 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             nodes.panner.disconnect();
             nodes.analyser.disconnect();
             nodes.gain.disconnect();
-            nodes.noiseGate.disconnect();
             if (nodes.denoiseNode) {
                 nodes.denoiseNode.disconnect();
             }
-            const track = nodes.stream.getAudioTracks()[0];
-            if (track) {
-                track.onmute = null;
-                track.onunmute = null;
-            }
             nodes.stream.getTracks().forEach((track) => track.stop());
             this.participantNodes.delete(participantId);
-            this.stabilityState.delete(participantId);
             console.log(`🗑️ Removed participant ${participantId} from spatial audio.`);
         }
     }
@@ -653,7 +460,7 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         const normalized = (distance - config.refDistance) /
             Math.max(config.maxDistance - config.refDistance, 0.001);
         const shaped = Math.pow(Math.max(0, 1 - normalized), Math.max(1.2, config.rolloffFactor * 1.05));
-        return Math.min(1, Math.max(0.001, shaped));
+        return Math.min(1, Math.max(0.01, shaped));
     }
     normalizePositionUnits(position) {
         const distanceConfig = this.getDistanceConfig();
@@ -678,82 +485,83 @@ class SpatialAudioManager extends EventManager_1.EventManager {
         }
         return { ...position };
     }
-    isDenoiserEnabled() {
-        return this.options.denoiser?.enabled !== false;
+    getVectorFromListener(targetPosition) {
+        if (!this.listenerInitialized) {
+            return { ...targetPosition };
+        }
+        return {
+            x: targetPosition.x - this.listenerPosition.x,
+            y: targetPosition.y - this.listenerPosition.y,
+            z: targetPosition.z - this.listenerPosition.z,
+        };
     }
-    async applyHardwareNoiseConstraints(track) {
-        try {
-            await track.applyConstraints({
-                echoCancellation: true,
-                noiseSuppression: true,
-                autoGainControl: true,
-                advanced: [
-                    {
-                        echoCancellation: true,
-                        noiseSuppression: true,
-                        autoGainControl: true,
-                        googEchoCancellation: true,
-                        googNoiseSuppression: true,
-                        googAutoGainControl: true,
-                        googHighpassFilter: true,
-                        googTypingNoiseDetection: true,
-                    },
-                ],
+    applyDirectionalSuppression(participantId, distance, vectorToSource) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes) {
+            return;
+        }
+        const clarityScore = this.calculateClarityScore(distance, vectorToSource);
+        const targetGain = 0.55 + clarityScore * 0.6; // 0.55 → 1.15
+        const targetLowpass = 3200 + clarityScore * 4200; // 3.2kHz → ~7.4kHz
+        nodes.proximityGain.gain.setTargetAtTime(targetGain, this.audioContext.currentTime, 0.08);
+        nodes.dynamicLowpass.frequency.setTargetAtTime(targetLowpass, this.audioContext.currentTime, 0.12);
+        if (Math.random() < 0.005) {
+            console.log("🎚️ [Spatial Audio] Directional tuning", {
+                participantId,
+                distance: distance.toFixed(2),
+                clarityScore: clarityScore.toFixed(2),
+                targetGain: targetGain.toFixed(2),
+                lowpassHz: targetLowpass.toFixed(0),
             });
         }
-        catch (error) {
-            console.warn("⚠️ Unable to apply hardware audio constraints", error);
+    }
+    calculateClarityScore(distance, vectorToSource) {
+        const proximityWeight = this.calculateProximityWeight(distance);
+        const focusWeight = this.calculateDirectionFocus(vectorToSource);
+        return this.clamp(0.2 + proximityWeight * 0.6 + focusWeight * 0.2, 0, 1);
+    }
+    calculateProximityWeight(distance) {
+        const closeRange = 1.2;
+        const fadeRange = 12;
+        if (distance <= closeRange) {
+            return 1;
+        }
+        if (distance >= fadeRange) {
+            return 0;
         }
-        track.contentHint = "speech";
+        return 1 - (distance - closeRange) / (fadeRange - closeRange);
     }
-    startOutboundMonitor(processorId, analyser, gate) {
-        const dataArray = new Uint8Array(analyser.fftSize);
-        let smoothedLevel = 0;
-        return setInterval(() => {
-            analyser.getByteTimeDomainData(dataArray);
-            let sum = 0;
-            for (const value of dataArray) {
-                sum += Math.abs(value - 128);
-            }
-            const level = (sum / dataArray.length) / 128;
-            smoothedLevel = smoothedLevel * 0.7 + level * 0.3;
-            let targetGain = 1;
-            if (smoothedLevel < 0.02) {
-                targetGain = 0;
-            }
-            else if (smoothedLevel < 0.05) {
-                targetGain = 0.45;
-            }
-            else {
-                targetGain = 1;
-            }
-            gate.gain.setTargetAtTime(targetGain, gate.context.currentTime, targetGain > gate.gain.value ? 0.02 : 0.08);
-            if (Math.random() < 0.03) {
-                console.log("🎚️ [SDK] Outgoing gate", {
-                    processorId,
-                    level: smoothedLevel.toFixed(3),
-                    gain: targetGain.toFixed(2),
-                });
-            }
-        }, 200);
+    calculateDirectionFocus(vectorToSource) {
+        if (!this.listenerInitialized) {
+            return 0.5;
+        }
+        const forward = this.normalizeVector(this.listenerDirection.forward);
+        const source = this.normalizeVector(vectorToSource, { x: 0, y: 0, z: 1 });
+        const dot = forward.x * source.x + forward.y * source.y + forward.z * source.z;
+        return this.clamp((dot + 1) / 2, 0, 1);
     }
-    cleanupOutboundProcessor(processorId) {
-        const processor = this.outgoingProcessors.get(processorId);
-        if (!processor)
-            return;
-        clearInterval(processor.monitor);
-        processor.processedTrack.removeEventListener("ended", processor.cleanupListener);
-        processor.originalTrack.removeEventListener("ended", processor.cleanupListener);
-        processor.destinationStream.getTracks().forEach((t) => t.stop());
-        processor.sourceStream.getTracks().forEach((t) => t.stop());
-        processor.context.close();
-        this.outgoingProcessors.delete(processorId);
+    normalizeVector(vector, fallback = { x: 0, y: 0, z: 1 }) {
+        const length = Math.hypot(vector.x, vector.y, vector.z);
+        if (length < 1e-4) {
+            return { ...fallback };
+        }
+        return {
+            x: vector.x / length,
+            y: vector.y / length,
+            z: vector.z / length,
+        };
     }
-    async ensureDenoiseWorklet(targetContext = this.audioContext) {
+    clamp(value, min, max) {
+        return Math.min(max, Math.max(min, value));
+    }
+    isDenoiserEnabled() {
+        return this.options.denoiser?.enabled !== false;
+    }
+    async ensureDenoiseWorklet() {
         if (!this.isDenoiserEnabled()) {
             return;
         }
-        if (!("audioWorklet" in targetContext)) {
+        if (!("audioWorklet" in this.audioContext)) {
             console.warn("⚠️ AudioWorklet not supported in this browser. Disabling denoiser.");
             this.options.denoiser = {
                 ...(this.options.denoiser || {}),
@@ -761,9 +569,8 @@ class SpatialAudioManager extends EventManager_1.EventManager {
             };
             return;
         }
-        const existingPromise = this.denoiseContextPromises.get(targetContext);
-        if (existingPromise) {
-            return existingPromise;
+        if (this.denoiseWorkletReady) {
+            return this.denoiseWorkletReady;
         }
         const processorSource = `class OdysseyDenoiseProcessor extends AudioWorkletProcessor {
   constructor(options) {
@@ -820,13 +627,11 @@ class SpatialAudioManager extends EventManager_1.EventManager {
 
 registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
 `;
-        if (!this.denoiseWorkletUrl) {
-            const blob = new Blob([processorSource], {
-                type: "application/javascript",
-            });
-            this.denoiseWorkletUrl = URL.createObjectURL(blob);
-        }
-        const promise = targetContext.audioWorklet
+        const blob = new Blob([processorSource], {
+            type: "application/javascript",
+        });
+        this.denoiseWorkletUrl = URL.createObjectURL(blob);
+        this.denoiseWorkletReady = this.audioContext.audioWorklet
             .addModule(this.denoiseWorkletUrl)
             .catch((error) => {
             console.error("❌ Failed to register denoise worklet", error);
@@ -836,8 +641,7 @@ registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
             };
             throw error;
         });
-        this.denoiseContextPromises.set(targetContext, promise);
-        return promise;
+        return this.denoiseWorkletReady;
     }
     resolveOptions(options) {
         const distanceDefaults = {
@@ -852,12 +656,6 @@ registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
             noiseFloor: 0.004,
             release: 0.18,
         };
-        const noiseGateDefaults = {
-            enabled: true,
-        };
-        const outboundDefaults = {
-            enabled: false,
-        };
         return {
             distance: {
                 refDistance: options?.distance?.refDistance ?? distanceDefaults.refDistance,
@@ -871,12 +669,6 @@ registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
                 noiseFloor: options?.denoiser?.noiseFloor ?? denoiserDefaults.noiseFloor,
                 release: options?.denoiser?.release ?? denoiserDefaults.release,
             },
-            noiseGate: {
-                enabled: options?.noiseGate?.enabled ?? noiseGateDefaults.enabled,
-            },
-            outboundTuning: {
-                enabled: options?.outboundTuning?.enabled ?? outboundDefaults.enabled,
-            },
         };
     }
 }

package/dist/index.d.ts

@@ -26,7 +26,6 @@ export declare class OdysseySpatialComms extends EventManager {
     }): Promise<Participant>;
     leaveRoom(): void;
     resumeAudio(): Promise<void>;
-    enhanceOutgoingAudioTrack(track: MediaStreamTrack): Promise<MediaStreamTrack>;
     getAudioContextState(): AudioContextState;
     produceTrack(track: MediaStreamTrack): Promise<any>;
     updatePosition(position: Position, direction: Direction, spatialData?: {

package/dist/index.js

@@ -121,9 +121,6 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
     async resumeAudio() {
         await this.spatialAudioManager.resumeAudioContext();
     }
-    async enhanceOutgoingAudioTrack(track) {
-        return this.spatialAudioManager.enhanceOutgoingAudioTrack(track);
-    }
     getAudioContextState() {
         return this.spatialAudioManager.getAudioContextState();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newgameplusinc/odyssey-audio-video-sdk-dev",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",