@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.257 → 1.0.259

package/dist/SpatialAudioManager.js

@@ -1,1537 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpatialAudioManager = void 0;
-const EventManager_1 = require("./EventManager");
-const MLNoiseSuppressor_1 = require("./MLNoiseSuppressor");
-class SpatialAudioManager extends EventManager_1.EventManager {
-    constructor(options) {
-        super();
-        this.participantNodes = new Map();
-        this.monitoringIntervals = new Map();
-        this.denoiseWorkletReady = null;
-        this.listenerPosition = { x: 0, y: 0, z: 0 };
-        this.listenerInitialized = false;
-        this.listenerDirection = {
-            forward: { x: 0, y: 1, z: 0 },
-            up: { x: 0, y: 0, z: 1 },
-        };
-        // Unit right-vector derived from listener yaw; used to project sources into listener space.
-        this.listenerRight = { x: 1, z: 0 };
-        this.localParticipantId = ''; // Local participant ID (listener)
-        // MASTER MUTE: Mutes all incoming audio (used before "Join Space" is clicked)
-        this.isMasterMuted = false;
-        // PAN SMOOTHING: Prevents random left/right jumping
-        // Stores the previous smoothed pan value for each participant
-        this.smoothedPanValues = new Map();
-        // PAN SMOOTHING: Tracks last applied pan value to skip micro-changes
-        this.lastPanValue = new Map();
-        // UPDATE THROTTLE: Tracks last spatial update time to prevent too-frequent updates
-        this.lastSpatialUpdateTime = new Map();
-        // DEBUG: Throttle spatial audio debug logs
-        this._spatialDebugTimes = new Map();
-        // Smoothing factor: 0.0 = no smoothing (instant), 1.0 = infinite smoothing (never changes)
-        // 0.35 provides good stability without feeling sluggish
-        this.panSmoothingFactor = 0.35;
-        // Minimum pan change threshold - changes smaller than this are ignored to prevent jitter
-        // 0.02 = 2% of pan range must change to trigger update (filters network jitter)
-        this.panChangeThreshold = 0.02;
-        // Dead-zone around center (0) to prevent oscillation when nearly face-to-face
-        this.panCenterDeadZone = 0.03;
-        // POSITION SNAPPING: Prevents jitter from micro-movements when "stationary"
-        // Caches last known "snapped" position for each speaker
-        this.cachedSpeakerPositions = new Map();
-        // Cache for last snapped listener position
-        this.cachedListenerPosition = { x: 0, y: 0, z: 0 };
-        // Minimum position change (in meters) to trigger recalculation
-        // 0.30m = 30cm - ignores pixel streaming jitter, physics wobble, breathing
-        // ALIGNED with server-side 100cm filter - this catches smaller jitter
-        this.positionSnapThreshold = 0.30;
-        // GAIN STABILIZATION: Prevents gain fluctuations when distance is stable
-        // Caches last calculated gain value for each participant
-        this.cachedGainValues = new Map();
-        // Minimum gain change (0-1 scale) to trigger update
-        // 0.05 = 5% change required - filters out tiny distance jitter
-        this.gainChangeThreshold = 0.05;
-        // NOTE: Rate limiting variables removed - setTargetAtTime provides sufficient smoothing
-        // The smoothPanValue() and position snapping handle jitter reduction
-        // ML Noise Suppressor (TensorFlow.js-based)
-        this.mlSuppressor = null;
-        // NOTE: We currently LOAD the TFJS model, but we do not yet run it inside the
-        // real-time WebAudio graph (AudioWorklet). This flag only indicates the model
-        // is ready to be used.
-        this.mlModelReady = false;
-        this.options = this.resolveOptions(options);
-        // Use high sample rate for best audio quality
-        this.audioContext = new AudioContext({ sampleRate: 48000 });
-        // Master gain - REDUCED to prevent echo/feedback
-        this.masterGainNode = this.audioContext.createGain();
-        this.masterGainNode.gain.value = 1.0; // Unity gain for crystal clear audio (was 2.5)
-        // Compressor for dynamic range control - VERY GENTLE to prevent pumping/echo
-        this.compressor = this.audioContext.createDynamicsCompressor();
-        this.compressor.threshold.value = -15; // Even higher threshold = less compression
-        this.compressor.knee.value = 40; // Soft knee for natural sound
-        this.compressor.ratio.value = 2.5; // Very gentle ratio (was 3)
-        this.compressor.attack.value = 0.02; // 20ms attack - very gentle
-        this.compressor.release.value = 0.25; // 250ms release - smooth recovery
-        // Connect master chain: masterGain -> compressor -> destination
-        this.masterGainNode.connect(this.compressor);
-        this.compressor.connect(this.audioContext.destination);
-    }
-    getAudioContext() {
-        return this.audioContext;
-    }
-    /**
-     * Initialize ML-based noise suppression (TensorFlow.js)
-     * Falls back to AudioWorklet denoiser if ML initialization fails
-     */
-    async initializeMLNoiseSuppression(modelUrl) {
-        try {
-            this.mlSuppressor = new MLNoiseSuppressor_1.MLNoiseSuppressor();
-            await this.mlSuppressor.initialize(modelUrl);
-            if (this.mlSuppressor.isReady()) {
-                this.mlModelReady = true;
-            }
-            else {
-                throw new Error('ML processor not ready after initialization');
-            }
-        }
-        catch (error) {
-            this.mlSuppressor = null;
-            this.mlModelReady = false;
-            // AudioWorklet denoiser will be used as fallback (existing behavior)
-        }
-    }
-    /**
-     * Get current noise suppression mode
-     */
-    getNoiseSuppressionMode() {
-        if (this.isDenoiserEnabled()) {
-            return 'audioworklet';
-        }
-        return 'none';
-    }
-    /**
-     * True if the TFJS model assets were loaded and the model is ready.
-     * This does NOT mean it is currently processing the live WebAudio stream.
-     */
-    isMLModelLoaded() {
-        return this.mlModelReady && !!this.mlSuppressor?.isReady();
-    }
-    /**
-     * Setup spatial audio for a participant
-     *
-     * CRITICAL: Each participant gets their OWN audio processing chain:
-     * Stream -> Source -> Panner -> Analyser -> Gain -> Compressor -> Output
-     *
-     * This ensures:
-     * - Each voice is positioned independently in 3D space
-     * - No server-side mixing required
-     * - Scalable to unlimited participants (browser handles the mixing)
-     *
-     * @param participantId Unique ID for this participant
-     * @param track Audio track from MediaSoup consumer
-     * @param bypassSpatialization For testing - bypasses 3D positioning
-     */
-    async setupSpatialAudioForParticipant(participantId, track, bypassSpatialization = false // Default to false
-    ) {
-        if (this.audioContext.state === "suspended") {
-            await this.audioContext.resume();
-        }
-        // Create stream with noise suppression constraints
-        const stream = new MediaStream([track]);
-        const source = this.audioContext.createMediaStreamSource(stream);
-        const panner = this.audioContext.createPanner();
-        const stereoPanner = this.audioContext.createStereoPanner(); // For stable L/R panning
-        // Force a predictable mono signal before applying StereoPannerNode.
-        // If the inbound track is stereo (or becomes stereo in the graph), StereoPannerNode can
-        // still leak energy into both ears. Downmixing prevents that.
-        const monoSplitter = this.audioContext.createChannelSplitter(2);
-        const monoMerger = this.audioContext.createChannelMerger(1);
-        const monoGainL = this.audioContext.createGain();
-        const monoGainR = this.audioContext.createGain();
-        monoGainL.gain.value = 0.5;
-        monoGainR.gain.value = 0.5;
-        // CRITICAL: Convert mono back to stereo for StereoPanner
-        // monoMerger outputs 1 channel, but StereoPanner needs 2 channels
-        const stereoUpmixer = this.audioContext.createChannelMerger(2);
-        const analyser = this.audioContext.createAnalyser();
-        const gain = this.audioContext.createGain();
-        const proximityGain = this.audioContext.createGain();
-        let denoiseNode;
-        // ML-based denoising: Currently prepared but requires AudioWorklet integration
-        // For now, using traditional AudioWorklet denoiser as it provides real-time processing
-        // TODO: Integrate ML processor into AudioWorklet for hybrid ML+DSP approach
-        if (this.isDenoiserEnabled() && typeof this.audioContext.audioWorklet !== "undefined") {
-            try {
-                await this.ensureDenoiseWorklet();
-                denoiseNode = new AudioWorkletNode(this.audioContext, "odyssey-denoise", {
-                    numberOfInputs: 1,
-                    numberOfOutputs: 1,
-                    processorOptions: {
-                        enabled: this.options.denoiser?.enabled !== false,
-                        threshold: this.options.denoiser?.threshold,
-                        noiseFloor: this.options.denoiser?.noiseFloor,
-                        release: this.options.denoiser?.release,
-                        attack: this.options.denoiser?.attack,
-                        holdMs: this.options.denoiser?.holdMs,
-                        maxReduction: this.options.denoiser?.maxReduction,
-                        hissCut: this.options.denoiser?.hissCut,
-                        expansionRatio: this.options.denoiser?.expansionRatio,
-                        learnRate: this.options.denoiser?.learnRate,
-                        voiceBoost: this.options.denoiser?.voiceBoost,
-                        voiceSensitivity: this.options.denoiser?.voiceSensitivity,
-                        voiceEnhancement: this.options.denoiser?.voiceEnhancement,
-                        silenceFloor: this.options.denoiser?.silenceFloor,
-                        silenceHoldMs: this.options.denoiser?.silenceHoldMs,
-                        silenceReleaseMs: this.options.denoiser?.silenceReleaseMs,
-                        speechBoost: this.options.denoiser?.speechBoost,
-                        highBandGate: this.options.denoiser?.highBandGate,
-                        highBandAttack: this.options.denoiser?.highBandAttack,
-                        highBandRelease: this.options.denoiser?.highBandRelease,
-                    },
-                });
-            }
-            catch (error) {
-                denoiseNode = undefined;
-            }
-        }
-        // Create BiquadFilter nodes for static/noise reduction
-        // Based on: https://tagdiwalaviral.medium.com/struggles-of-noise-reduction-in-rtc-part-2-2526f8179442
-        // HIGHPASS FILTER: Remove low-frequency rumble and plosives
-        // Higher cutoff (100Hz) reduces room boom/echo effect
-        const highpassFilter = this.audioContext.createBiquadFilter();
-        highpassFilter.type = "highpass";
-        highpassFilter.frequency.value = 100; // Cut below 100Hz (removes room boom/rumble)
-        highpassFilter.Q.value = 0.5; // Very gentle slope - prevents resonance
-        // LOWPASS FILTER: Remove high-frequency hiss
-        // Slightly higher for clearer voice
-        const lowpassFilter = this.audioContext.createBiquadFilter();
-        lowpassFilter.type = "lowpass";
-        lowpassFilter.frequency.value = 10000; // Cut above 10kHz (more open sound)
-        lowpassFilter.Q.value = 0.5; // Low Q prevents ringing/echo
-        // VOICE BAND EMPHASIS: DISABLED - was causing resonance/bathroom effect
-        // The peaking filter at 180Hz can cause room-like coloration
-        const voiceBandFilter = this.audioContext.createBiquadFilter();
-        voiceBandFilter.type = "peaking";
-        voiceBandFilter.frequency.value = 180;
-        voiceBandFilter.Q.value = 0.5;
-        voiceBandFilter.gain.value = 0; // DISABLED - no boost (was 1dB causing echo)
-        const dynamicLowpass = this.audioContext.createBiquadFilter();
-        dynamicLowpass.type = "lowpass";
-        dynamicLowpass.frequency.value = 12000; // Higher = more natural (was 7500)
-        dynamicLowpass.Q.value = 0.5; // Low Q prevents ringing
-        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
-        panner.distanceModel = "inverse"; // Natural distance falloff
-        panner.refDistance = distanceConfig.refDistance ?? 1.2;
-        panner.maxDistance = distanceConfig.maxDistance ?? 15; // Cannot hear beyond 15 meters
-        panner.rolloffFactor = distanceConfig.rolloffFactor ?? 1.35; // How quickly sound fades with distance
-        panner.coneInnerAngle = 360; // Omnidirectional sound source
-        panner.coneOuterAngle = 360;
-        panner.coneOuterGain = 0.3; // Some sound even outside cone
-        // Configure gain for individual participant volume control
-        gain.gain.value = 1.0; // Unity gain for clean audio
-        // Per-participant LIMITER (not compressor) - only catches peaks
-        // Compressors can cause pumping/echo - limiter is transparent until clipping
-        const participantCompressor = this.audioContext.createDynamicsCompressor();
-        participantCompressor.threshold.value = -6; // Only activate near clipping (was -40!)
-        participantCompressor.knee.value = 3; // Hard knee = limiter behavior (was 20)
-        participantCompressor.ratio.value = 20; // High ratio = limiter (was 1.5)
-        participantCompressor.attack.value = 0.001; // 1ms - catch peaks fast
-        participantCompressor.release.value = 0.05; // 50ms - fast release prevents pumping
-        let currentNode = source;
-        // First apply compressor to tame initial transients (CRITICAL for preventing pops)
-        currentNode.connect(participantCompressor);
-        currentNode = participantCompressor;
-        if (denoiseNode) {
-            currentNode.connect(denoiseNode);
-            currentNode = denoiseNode;
-        }
-        // Audio chain with voice optimization filters
-        // Chain: source -> compressor -> [denoise] -> highpass -> voiceBand -> lowpass -> dynamicLowpass -> proximityGain -> panner -> analyser -> gain -> masterGain
-        currentNode.connect(highpassFilter);
-        highpassFilter.connect(voiceBandFilter);
-        voiceBandFilter.connect(lowpassFilter);
-        lowpassFilter.connect(dynamicLowpass);
-        dynamicLowpass.connect(proximityGain);
-        // Base routing (always): proximityGain -> mono downmix -> stereo upmix -> analyser
-        proximityGain.connect(monoSplitter);
-        monoSplitter.connect(monoGainL, 0);
-        monoSplitter.connect(monoGainR, 1);
-        monoGainL.connect(monoMerger, 0, 0);
-        monoGainR.connect(monoMerger, 0, 0);
-        // Convert mono to stereo (same signal on both channels) for StereoPanner
-        monoMerger.connect(stereoUpmixer, 0, 0); // mono -> left channel
-        monoMerger.connect(stereoUpmixer, 0, 1); // mono -> right channel
-        stereoUpmixer.connect(analyser);
-        // Output routing depends on spatialization mode:
-        // - Spatial: analyser -> stereoPanner -> gain -> master
-        // - Non-spatial: analyser -> gain -> master
-        if (bypassSpatialization) {
-            analyser.connect(gain);
-        }
-        else {
-            analyser.connect(stereoPanner);
-            stereoPanner.connect(gain);
-        }
-        gain.connect(this.masterGainNode);
-        this.participantNodes.set(participantId, {
-            source,
-            panner,
-            stereoPanner,
-            monoSplitter,
-            monoGainL,
-            monoGainR,
-            monoMerger,
-            stereoUpmixer,
-            analyser,
-            gain,
-            proximityGain,
-            compressor: participantCompressor,
-            highpassFilter,
-            lowpassFilter,
-            voiceBandFilter,
-            dynamicLowpass,
-            denoiseNode,
-            stream,
-        });
-        // Start monitoring audio levels
-        this.startMonitoring(participantId);
-    }
-    startMonitoring(participantId) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes)
-            return;
-        const { analyser, stream } = nodes;
-        const dataArray = new Uint8Array(analyser.frequencyBinCount);
-        // Clear any existing interval for this participant
-        if (this.monitoringIntervals.has(participantId)) {
-            clearInterval(this.monitoringIntervals.get(participantId));
-        }
-        const interval = setInterval(() => {
-            analyser.getByteTimeDomainData(dataArray);
-            let sum = 0;
-            for (const amplitude of dataArray) {
-                sum += Math.abs(amplitude - 128);
-            }
-            const average = sum / dataArray.length;
-            const audioLevel = (average / 128) * 255; // Scale to 0-255
-            // Silent monitoring - no logs needed
-        }, 2000); // Check every 2 seconds
-        this.monitoringIntervals.set(participantId, interval);
-    }
-    /**
-     * Toggle spatialization for a participant (for huddle/spatial switching)
-     * @param participantId The participant to update
-     * @param enableSpatialization True for spatial audio, false for non-spatial (huddle)
-     */
-    setParticipantSpatialization(participantId, enableSpatialization) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes) {
-            return;
-        }
-        try {
-            // Keep input side unchanged; only re-route analyser output.
-            nodes.analyser.disconnect();
-            nodes.stereoPanner.disconnect();
-            if (enableSpatialization) {
-                nodes.analyser.connect(nodes.stereoPanner);
-                nodes.stereoPanner.connect(nodes.gain);
-            }
-            else {
-                nodes.analyser.connect(nodes.gain);
-            }
-        }
-        catch (error) {
-            // Error toggling spatialization - fail silently
-        }
-    }
-    /**
-     * Update spatial audio position and orientation for a participant
-     *
-     * This is called every time we receive position/direction updates from the server.
-     *
-     * Position: Where the participant is in 3D space (their location)
-     * Direction: Which way they're facing (their forward vector)
-     *
-     * Example:
-     * - Position: (x: -200, y: 0, z: 100) = 2m to your left
-     * - Direction: (x: 0, y: 1, z: 0) = facing forward (away from you)
-     * - Result: Sound comes from your left, oriented as if speaking away
-     *
-     * The Web Audio API's PannerNode uses HRTF to create realistic 3D audio
-     * based on these parameters plus the listener's position/orientation.
-     *
-     * @param participantId Who to update
-     * @param position Where they are (from socket data)
-     * @param direction Which way they're facing (from socket data)
-     */
-    updateSpatialAudio(participantId, position, direction, _spatialMeta) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes) {
-            return;
-        }
-        if (!nodes.panner) {
-            return;
-        }
-        // NOTE: Removed throttle - it was causing audio dropouts
-        // The smoothing in applyStereoPanning and gain ramping handles click prevention
-        if (nodes?.panner) {
-            // POSITION-BASED SPATIAL AUDIO
-            // All calculations are in world space (datum at 0,0,0)
-            // 
-            // Step 1: Get speaker head position (with jitter reduction)
-            const normalizedBodyPosition = this.normalizePositionUnits(position);
-            // SNAP: Reduce jitter by ignoring micro-movements (<15cm)
-            const snappedSpeakerPos = this.snapPosition(normalizedBodyPosition, participantId);
-            const speakerHeadPosition = this.computeHeadPosition(snappedSpeakerPos);
-            // SNAP: Use cached listener position to reduce jitter
-            const listenerPos = this.cachedListenerPosition.x !== 0 || this.cachedListenerPosition.z !== 0
-                ? this.cachedListenerPosition
-                : this.listenerPosition;
-            // DEBUG: Log positions for troubleshooting distance issues
-            const distX = speakerHeadPosition.x - listenerPos.x;
-            const distY = speakerHeadPosition.y - listenerPos.y;
-            const distZ = speakerHeadPosition.z - listenerPos.z;
-            // Step 2: Calculate 3D distance (Euclidean distance from datum-based positions)
-            // distance = √(Δx² + Δy² + Δz²)
-            const distance = this.getDistanceBetween(listenerPos, speakerHeadPosition);
-            // HARD CUTOFF: Fade out completely if beyond max distance (15m)
-            // This prevents any audio processing for distant participants
-            const maxDistance = 15.0;
-            if (distance >= maxDistance) {
-                // Smooth fade to zero - prevents click (100ms fade)
-                nodes.gain.gain.setTargetAtTime(0, this.audioContext.currentTime, 0.033);
-                this.cachedGainValues.set(participantId, 0);
-                return; // Skip all other processing
-            }
-            // Step 3: Calculate relative vector (speaker relative to listener)
-            // vecToSource = speaker.pos - listener.pos
-            const vecToSource = {
-                x: speakerHeadPosition.x - listenerPos.x,
-                z: speakerHeadPosition.z - listenerPos.z,
-            };
-            // Step 4: Project onto listener's right-ear axis using dot product
-            // dxLocal = vecToSource · listenerRight
-            // Positive = sound is to the RIGHT of listener
-            // Negative = sound is to the LEFT of listener
-            // Near zero = sound is FRONT or BACK (center)
-            const dxLocal = vecToSource.x * this.listenerRight.x + vecToSource.z * this.listenerRight.z;
-            // Calculate dzLocal (forward/back component)
-            // For CLOCKWISE rotation: Forward = right rotated 90° CW: (x,z) -> (-z,x)
-            // At yaw=0°: right=(1,0) → forward=(0,1)=+Z ✓
-            // At yaw=90°: right=(0,-1) → forward=(1,0)=+X ✓
-            const listenerForward = { x: -this.listenerRight.z, z: this.listenerRight.x };
-            const dzLocal = vecToSource.x * listenerForward.x + vecToSource.z * listenerForward.z;
-            // TRUE 360° SPATIAL AUDIO PANNING
-            // Calculate angle from listener to source using atan2
-            // This gives full left/right separation:
-            // - 90° (right side) = pan +1.0 (100% RIGHT ear, 0% LEFT ear)
-            // - 270° (left side) = pan -1.0 (100% LEFT ear, 0% RIGHT ear)
-            // - 0° (front) or 180° (back) = pan 0.0 (CENTER)
-            const angleToSource = Math.atan2(dxLocal, dzLocal); // Radians: -π to +π
-            const rawPanValue = Math.sin(angleToSource); // -1 to +1
-            // SMOOTH THE PAN VALUE to prevent random left/right jumping
-            const smoothedPanValue = this.smoothPanValue(participantId, rawPanValue);
-            const panning = this.panningFromPanValue(smoothedPanValue, dxLocal);
-            // Calculate gain based on distance
-            const calculatedGain = this.calculateLogarithmicGain(distance);
-            const newGainValue = calculatedGain / 100; // Convert to 0-1 range
-            // SIMPLE GAIN STABILIZATION: Only update if change exceeds threshold
-            const cachedGain = this.cachedGainValues.get(participantId);
-            let finalGainValue = newGainValue;
-            if (cachedGain !== undefined) {
-                const gainChange = Math.abs(newGainValue - cachedGain);
-                if (gainChange < this.gainChangeThreshold) {
-                    // Change too small - keep cached value for stability
-                    finalGainValue = cachedGain;
-                }
-                else {
-                    // Significant change - update cache
-                    this.cachedGainValues.set(participantId, newGainValue);
-                }
-            }
-            else {
-                // First time - cache the value
-                this.cachedGainValues.set(participantId, newGainValue);
-            }
-            // Apply panning
-            this.applyStereoPanning(participantId, panning);
-            // Apply gain with Web Audio's built-in smoothing (setTargetAtTime)
-            const currentTime = this.audioContext.currentTime;
-            try {
-                // setTargetAtTime provides smooth exponential interpolation
-                // Time constant 0.1 = ~300ms to settle
-                nodes.gain.gain.setTargetAtTime(finalGainValue, currentTime, 0.1);
-            }
-            catch (err) {
-                // Fallback: If scheduling fails, set value directly (rare edge case)
-                nodes.gain.gain.value = finalGainValue;
-            }
-        }
-    }
-    /**
-     * Mute or unmute a participant's audio
-     * Used for channel-based audio routing (huddle vs spatial)
-     * @param participantId The participant to mute/unmute
-     * @param muted True to mute, false to unmute
-     */
-    setParticipantMuted(participantId, muted) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes) {
-            // Audio nodes don't exist yet - this is normal if called before consumer is set up
-            return;
-        }
-        if (nodes.gain) {
-            // Smooth ramp to 0 (muted) or 1 (unmuted) - prevents click
-            // Time constant 0.05 = ~150ms to reach target (3 time constants)
-            nodes.gain.gain.setTargetAtTime(muted ? 0 : 1, this.audioContext.currentTime, 0.05);
-            // Update cached gain value when muting/unmuting
-            this.cachedGainValues.set(participantId, muted ? 0 : 1);
-        }
-    }
-    /**
-     * Master mute/unmute for ALL audio output
-     * Use this to prevent audio from playing until user explicitly joins the space.
-     * @param muted True to mute all audio, false to unmute
-     */
-    setMasterMuted(muted) {
-        this.isMasterMuted = muted;
-        // Smooth transition for master gain to prevent clicks
-        const targetGain = muted ? 0 : 1;
-        this.masterGainNode.gain.setTargetAtTime(targetGain, this.audioContext.currentTime, 0.05 // ~150ms transition
-        );
-    }
-    /**
-     * Get current master mute state
-     * @returns True if master mute is enabled
-     */
-    getMasterMuted() {
-        return this.isMasterMuted;
-    }
-    /**
-     * Update listener position and orientation
-     * The \"listener\" is YOU - where your ears/head are positioned
-     *
-     * @param position Your HEAD position (camera position), not body position!
-     * @param orientation Which way your head is facing (forward and up vectors)
-     */
-    setListenerPosition(position, orientation) {
-        const normalizedPosition = this.normalizePositionUnits(position);
-        this.applyListenerTransform(normalizedPosition, orientation);
-    }
-    /**
-     * POSITION-ONLY MODE: Set listener HEAD position (no direction needed)
-     * IMPORTANT: Uses CAMERA position (head) as listener, not body position!
-     *
-     * @param listenerPos Player body position (for reference, not used as listener)
-     * @param cameraPos Camera/HEAD position - THIS is the actual listener position for audio
-     * @param lookAtPos Look-at position (where camera is pointing) - stored but not used for panning
-     * @param rot Rotation data (pitch, yaw, roll) - stored but not used for panning
-     */
-    setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot, localParticipantId) {
-        // Store local participant ID for logging
-        if (localParticipantId && !this.localParticipantId) {
-            this.localParticipantId = localParticipantId;
-        }
-        // USE CAMERA POSITION AS LISTENER (head position, not body!)
-        const normalizedListener = this.normalizePositionUnits(cameraPos);
-        // SNAP: Reduce jitter by ignoring micro-movements (<15cm)
-        // This prevents gain/pan fluctuation when listener is "stationary"
-        const snappedListener = this.snapPosition(normalizedListener, 'listener');
-        // Store listener position (used for X-axis panning and distance calculation)
-        this.listenerPosition = snappedListener;
-        // CRITICAL: Derive listener right-vector from yaw (rot.y in degrees)
-        // This determines which ear hears the sound based on 360-degree rotation
-        // 
-        // COORDINATE SYSTEM: X=right, Y=up, Z=forward (datum at 0,0,0)
-        // 
-        // Rotation convention (right-hand rule around Y-axis):
-        //   rot.y = 0°   → facing +Z (forward/north), right ear points to +X
-        //   rot.y = 90°  → facing +X (right/east),    right ear points to -Z
-        //   rot.y = 180° → facing -Z (backward/south), right ear points to -X
-        //   rot.y = 270° → facing -X (left/west),     right ear points to +Z
-        if (rot && typeof rot.y === "number") {
-            const yawRad = (rot.y * Math.PI) / 180;
-            // Right ear vector - CLOCKWISE rotation (standard game engine convention)
-            // At yaw=0: facing +Z, right ear at +X → (1, 0)
-            // At yaw=90: facing +X, right ear at -Z → (0, -1)
-            // At yaw=180: facing -Z, right ear at -X → (-1, 0)
-            // At yaw=270: facing -X, right ear at +Z → (0, 1)
-            this.listenerRight = {
-                x: Math.cos(yawRad),
-                z: -Math.sin(yawRad), // NEGATIVE for clockwise rotation
-            };
-        }
-        else {
-            // Fallback: assume facing forward with right ear to +X
-            this.listenerRight = { x: 1, z: 0 };
-        }
-        // Position-only mode: No forward vector calculations needed
-        // Panning is calculated purely from X-axis position difference in updateSpatialAudio()
-        // LEGACY CODE BELOW - Kept for reference but not executed
-        if (false) {
-            const normalizedCamera = this.normalizePositionUnits(cameraPos);
-            const normalizedLookAt = this.normalizePositionUnits(lookAtPos);
-            // Calculate forward vector (from camera to look-at point)
-            const forwardX = normalizedLookAt.x - normalizedCamera.x;
-            const forwardY = normalizedLookAt.y - normalizedCamera.y;
-            const forwardZ = normalizedLookAt.z - normalizedCamera.z;
-            // Normalize forward vector
-            const forwardLen = Math.sqrt(forwardX * forwardX + forwardY * forwardY + forwardZ * forwardZ);
-            if (forwardLen < 0.001) {
-                return;
-            }
-            const fwdX = forwardX / forwardLen;
-            const fwdY = forwardY / forwardLen;
-            const fwdZ = forwardZ / forwardLen;
-            // Calculate right vector (cross product of world up and forward)
-            // Web Audio API uses Y-up coordinate system, Unreal uses Z-up
-            // We need to transform: Unreal (X,Y,Z) -> WebAudio (X,Z,-Y)
-            const worldUp = { x: 0, y: 1, z: 0 }; // Web Audio Y-up
-            const rightX = worldUp.y * fwdZ - worldUp.z * fwdY;
-            const rightY = worldUp.z * fwdX - worldUp.x * fwdZ;
-            const rightZ = worldUp.x * fwdY - worldUp.y * fwdX;
-            const rightLen = Math.sqrt(rightX * rightX + rightY * rightY + rightZ * rightZ);
-            if (rightLen < 0.001) {
-                // Forward is parallel to world up, use fallback
-                this.applyListenerTransform(normalizedListener, {
-                    forwardX: fwdX,
-                    forwardY: fwdY,
-                    forwardZ: fwdZ,
-                    upX: 0,
-                    upY: 1,
-                    upZ: 0,
-                });
-                return;
-            }
-            const rX = rightX / rightLen;
-            const rY = rightY / rightLen;
-            const rZ = rightZ / rightLen;
-            // Calculate true up vector (cross product of forward and right)
-            const upX = fwdY * rZ - fwdZ * rY;
-            const upY = fwdZ * rX - fwdX * rZ;
-            const upZ = fwdX * rY - fwdY * rX;
-            this.applyListenerTransform(normalizedListener, {
-                forwardX: fwdX,
-                forwardY: fwdY,
-                forwardZ: fwdZ,
-                upX,
-                upY,
-                upZ,
-            });
-        } // End of legacy code block
-    }
-    applyListenerTransform(normalizedPosition, orientation) {
-        const { listener } = this.audioContext;
-        if (!listener) {
-            return;
-        }
-        this.listenerPosition = { ...normalizedPosition };
-        this.listenerInitialized = true;
-        this.listenerDirection = {
-            forward: {
-                x: orientation.forwardX,
-                y: orientation.forwardY,
-                z: orientation.forwardZ,
-            },
-            up: {
-                x: orientation.upX,
-                y: orientation.upY,
-                z: orientation.upZ,
-            },
-        };
-        if (listener.positionX) {
-            listener.positionX.setValueAtTime(normalizedPosition.x, this.audioContext.currentTime);
-            listener.positionY.setValueAtTime(normalizedPosition.y, this.audioContext.currentTime);
-            listener.positionZ.setValueAtTime(normalizedPosition.z, this.audioContext.currentTime);
-        }
-        if (listener.forwardX) {
-            listener.forwardX.setValueAtTime(orientation.forwardX, this.audioContext.currentTime);
-            listener.forwardY.setValueAtTime(orientation.forwardY, this.audioContext.currentTime);
-            listener.forwardZ.setValueAtTime(orientation.forwardZ, this.audioContext.currentTime);
-            listener.upX.setValueAtTime(orientation.upX, this.audioContext.currentTime);
-            listener.upY.setValueAtTime(orientation.upY, this.audioContext.currentTime);
-            listener.upZ.setValueAtTime(orientation.upZ, this.audioContext.currentTime);
-        }
-    }
-    removeParticipant(participantId) {
-        // Stop monitoring
-        if (this.monitoringIntervals.has(participantId)) {
-            clearInterval(this.monitoringIntervals.get(participantId));
-            this.monitoringIntervals.delete(participantId);
-        }
-        const nodes = this.participantNodes.get(participantId);
-        if (nodes) {
-            nodes.source.disconnect();
-            nodes.panner.disconnect();
-            nodes.proximityGain.disconnect();
-            nodes.monoSplitter.disconnect();
-            nodes.monoGainL.disconnect();
-            nodes.monoGainR.disconnect();
-            nodes.monoMerger.disconnect();
-            nodes.stereoUpmixer.disconnect();
-            nodes.stereoPanner.disconnect();
-            nodes.analyser.disconnect();
-            nodes.gain.disconnect();
-            if (nodes.denoiseNode) {
-                nodes.denoiseNode.disconnect();
-            }
-            // DON'T stop tracks - they're managed by MediaSoup
-            // Just disconnect the audio nodes from the graph
-            // nodes.stream.getTracks().forEach((track) => track.stop());
-            this.participantNodes.delete(participantId);
-            // Clean up smoothed pan value tracking
-            this.smoothedPanValues.delete(participantId);
-            // Clean up cached gain values
-            this.cachedGainValues.delete(participantId);
-            // Clean up cached speaker position
-            this.cachedSpeakerPositions.delete(participantId);
-        }
-    }
-    async resumeAudioContext() {
-        if (this.audioContext.state === "suspended") {
-            await this.audioContext.resume();
-        }
-    }
-    getAudioContextState() {
-        return this.audioContext.state;
-    }
-    getDistanceConfig() {
-        return {
-            refDistance: this.options.distance?.refDistance ?? 0.5, // Normal volume within 0.5m (very close)
-            maxDistance: this.options.distance?.maxDistance ?? 15, // Cannot hear after 15 meters
-            rolloffFactor: this.options.distance?.rolloffFactor ?? 2.5, // Aggressive falloff for realistic distance attenuation
-            unit: this.options.distance?.unit ?? "auto",
-        };
-    }
-    applySpatialBoostIfNeeded(position) {
-        if (!this.listenerInitialized) {
-            return position;
-        }
-        const boost = (this.options.distance?.rolloffFactor || 1) * 0.85;
-        if (!isFinite(boost) || boost <= 1.01) {
-            return position;
-        }
-        const listener = this.listenerPosition;
-        return {
-            x: listener.x + (position.x - listener.x) * boost,
-            y: listener.y + (position.y - listener.y) * Math.min(boost, 1.2),
-            z: listener.z + (position.z - listener.z) * boost,
-        };
-    }
-    getDistanceBetween(a, b) {
-        const dx = b.x - a.x;
-        const dy = b.y - a.y;
-        const dz = b.z - a.z;
-        return Math.sqrt(dx * dx + dy * dy + dz * dz);
-    }
-    calculateDistanceGain(config, distance) {
-        if (!this.listenerInitialized) {
-            return 1;
-        }
-        if (distance <= config.refDistance) {
-            return 1;
-        }
-        if (distance >= config.maxDistance) {
-            return 0;
-        }
-        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.01, shaped));
-    }
-    normalizePositionUnits(position) {
-        const distanceConfig = this.getDistanceConfig();
-        if (distanceConfig.unit === "meters") {
-            return { ...position };
-        }
-        if (distanceConfig.unit === "centimeters") {
-            return {
-                x: position.x / 100,
-                y: position.y / 100,
-                z: position.z / 100,
-            };
-        }
-        const maxAxis = Math.max(Math.abs(position.x), Math.abs(position.y), Math.abs(position.z));
-        if (maxAxis > 50) {
-            // Likely centimeters coming from server
-            return {
-                x: position.x / 100,
-                y: position.y / 100,
-                z: position.z / 100,
-            };
-        }
-        return { ...position };
-    }
-    /**
-     * Snap position to grid to prevent jitter from micro-movements
-     * If the position hasn't changed significantly, return the cached position
-     * This prevents gain/pan fluctuation when users are "stationary"
-     *
-     * @param position New incoming position
-     * @param participantId Participant ID for caching (use 'listener' for listener)
-     * @returns Snapped position (either new or cached)
-     */
-    snapPosition(position, participantId) {
-        const isListener = participantId === 'listener';
-        const cached = isListener
-            ? this.cachedListenerPosition
-            : this.cachedSpeakerPositions.get(participantId);
-        // If no cached position, use this one as the baseline
-        if (!cached || (cached.x === 0 && cached.y === 0 && cached.z === 0)) {
-            if (isListener) {
-                this.cachedListenerPosition = { ...position };
-            }
-            else {
-                this.cachedSpeakerPositions.set(participantId, { ...position });
-            }
-            return position;
-        }
-        // Calculate how far the position has moved
-        const dx = position.x - cached.x;
-        const dy = position.y - cached.y;
-        const dz = position.z - cached.z;
-        const movedDistance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-        // If moved more than threshold, update cache and use new position
-        if (movedDistance > this.positionSnapThreshold) {
-            if (isListener) {
-                this.cachedListenerPosition = { ...position };
-            }
-            else {
-                this.cachedSpeakerPositions.set(participantId, { ...position });
-            }
-            return position;
-        }
-        // Position hasn't changed significantly - return cached position
-        // This prevents jitter in gain/pan calculations
-        return cached;
-    }
-    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,
-        };
-    }
-    applyDirectionalSuppression(participantId, distance, vectorToSource) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes) {
-            return;
-        }
-        const clarityScore = this.calculateClarityScore(distance, vectorToSource);
-        const targetGain = 0.48 + clarityScore * 0.72; // 0.48 → 1.20
-        // Only adjust gain based on angle, not frequency
-        nodes.proximityGain.gain.setTargetAtTime(targetGain, this.audioContext.currentTime, 0.08);
-        // Analyze voice and adjust highpass filter dynamically (85-300Hz)
-        this.adjustVoiceAdaptiveFilter(participantId);
-    }
-    /**
-     * Dynamically adjust highpass filter based on voice characteristics
-     * Analyzes audio spectrum and sets filter between 85-300Hz
-     */
-    adjustVoiceAdaptiveFilter(participantId) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes?.analyser) {
-            return;
-        }
-        const bufferLength = nodes.analyser.frequencyBinCount;
-        const dataArray = new Uint8Array(bufferLength);
-        nodes.analyser.getByteFrequencyData(dataArray);
-        // Calculate spectral centroid in low frequency range (0-500Hz)
-        const sampleRate = this.audioContext.sampleRate;
-        const nyquist = sampleRate / 2;
-        const binWidth = nyquist / bufferLength;
-        let weightedSum = 0;
-        let totalEnergy = 0;
-        const maxBin = Math.floor(500 / binWidth); // Only analyze up to 500Hz
-        for (let i = 0; i < Math.min(maxBin, bufferLength); i++) {
-            const frequency = i * binWidth;
-            const magnitude = dataArray[i] / 255.0;
-            weightedSum += frequency * magnitude;
-            totalEnergy += magnitude;
-        }
-        if (totalEnergy > 0.01) {
-            const centroid = weightedSum / totalEnergy;
-            // Map centroid to highpass frequency (85-300Hz)
-            // Lower centroid = deeper voice = use lower highpass (preserve bass)
-            // Higher centroid = higher voice = use higher highpass (remove mud)
-            const targetFreq = Math.max(85, Math.min(300, 85 + (centroid - 100) * 0.5));
-            nodes.highpassFilter.frequency.setTargetAtTime(targetFreq, this.audioContext.currentTime, 0.15 // Smooth transition
-            );
-        }
-    }
-    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 = 0.85;
-        const fadeRange = 18;
-        if (distance <= closeRange) {
-            return 1;
-        }
-        if (distance >= fadeRange) {
-            return 0;
-        }
-        return 1 - (distance - closeRange) / (fadeRange - closeRange);
-    }
-    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);
-    }
-    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,
-        };
-    }
-    clamp(value, min, max) {
-        return Math.min(max, Math.max(min, value));
-    }
-    isDenoiserEnabled() {
-        // DISABLED BY DEFAULT: The AudioWorklet denoiser causes "chit-chit/pit" noise artifacts
-        // Set options.denoiser.enabled = true explicitly to enable
-        return this.options.denoiser?.enabled === true;
-    }
-    /**
-     * Compute estimated head/mouth position from body position
-     * Body position is typically at feet/base - add head height offset
-     * Average human head height: 1.6m (adjustable based on avatar)
-     */
-    computeHeadPosition(bodyPosition) {
-        return {
-            x: bodyPosition.x,
-            y: bodyPosition.y + 1.6, // Add typical head height in meters
-            z: bodyPosition.z,
-        };
-    }
-    calculatePanning(angle) {
-        const rad = (angle * Math.PI) / 180;
-        const panValue = Math.sin(rad);
-        return this.panningFromPanValue(panValue);
-    }
-    panningFromPanValue(pan, dxLocal) {
-        const clamped = this.clamp(pan, -1, 1);
-        // Map pan to asymmetric gains while keeping center at 100/100
-        const left = 100 * (1 - Math.max(0, clamped));
-        const right = 100 * (1 + Math.min(0, clamped));
-        return {
-            left: this.clamp(left, 0, 100),
-            right: this.clamp(right, 0, 100),
-        };
-    }
-    /**
-     * SMOOTH PAN VALUE to prevent random left/right jumping
-     * Uses exponential moving average (EMA) to smooth out jittery position data
-     * With SNAP behavior for large direction changes (e.g., turning around)
-     * With DEAD-ZONE around center to prevent face-to-face oscillation
-     * @param participantId The participant to smooth pan for
-     * @param newPanValue The new calculated pan value (-1 to +1)
-     * @returns Smoothed pan value
-     */
-    smoothPanValue(participantId, newPanValue) {
-        const previousPan = this.smoothedPanValues.get(participantId);
-        // DEAD-ZONE: If new pan is very close to center, snap to exactly 0
-        // This prevents left/right oscillation when standing face-to-face
-        let targetPan = newPanValue;
-        if (Math.abs(newPanValue) < this.panCenterDeadZone) {
-            targetPan = 0;
-        }
-        // If no previous value, initialize with current value
-        if (previousPan === undefined) {
-            this.smoothedPanValues.set(participantId, targetPan);
-            return targetPan;
-        }
-        // Calculate the change from previous pan
-        const panChange = Math.abs(targetPan - previousPan);
-        // If change is below threshold, keep previous value (prevents micro-jitter)
-        if (panChange < this.panChangeThreshold) {
-            return previousPan;
-        }
-        // HEAVY SMOOTHING: Always use high smoothing factor to prevent audio disruption
-        // Even for large changes, we want smooth transitions to avoid audio dropouts
-        // The StereoPannerNode's setTargetAtTime provides additional smoothing
-        let effectiveSmoothingFactor = 0.7; // High smoothing = slow response but stable audio
-        const signFlipped = (previousPan > 0 && targetPan < 0) || (previousPan < 0 && targetPan > 0);
-        const bothNearCenter = Math.abs(previousPan) < 0.2 && Math.abs(targetPan) < 0.2;
-        // Only reduce smoothing for center transitions (natural movement)
-        if (bothNearCenter) {
-            // Near center - use moderate smoothing
-            effectiveSmoothingFactor = 0.5;
-        }
-        else if (signFlipped && panChange > 1.0) {
-            // FULL FLIP (e.g., +0.67 to -0.82) - this is likely jitter, use HEAVY smoothing
-            // to reject the outlier and keep audio stable
-            effectiveSmoothingFactor = 0.85; // Very heavy smoothing for suspected jitter
-        }
-        // Apply exponential moving average smoothing
-        // smoothedValue = previousValue * factor + newValue * (1 - factor)
-        // Higher factor = more smoothing (slower response)
-        const smoothedPan = previousPan * effectiveSmoothingFactor + targetPan * (1 - effectiveSmoothingFactor);
-        // Apply dead-zone to final smoothed value as well
-        const finalPan = Math.abs(smoothedPan) < this.panCenterDeadZone ? 0 : smoothedPan;
-        // Store for next update
-        this.smoothedPanValues.set(participantId, finalPan);
-        return finalPan;
-    }
-    computeAzimuthFromPositions(listener, source) {
-        const vx = source.x - listener.x;
-        const vz = source.z - listener.z;
-        const angleRad = Math.atan2(vx, vz); // 0° = forward (Z+), 90° = right (X+)
-        const deg = (angleRad * 180) / Math.PI;
-        const normalized = (deg + 360) % 360;
-        return normalized;
-    }
-    /**
-     * OLD METHOD - Kept for reference but not used in position-only mode
-     * Calculate angle between listener and sound source in degrees (0-360)
-     * 0° = front, 90° = right, 180° = back, 270° = left
-     */
-    calculateAngle(listenerPos, sourcePos, listenerForward) {
-        // IMPORTANT: In Odyssey runtime coords, Y behaves like height.
-        // Use X/Z as the horizontal plane for 360° panning.
-        const vx = sourcePos.x - listenerPos.x;
-        const vz = sourcePos.z - listenerPos.z;
-        // Project listener forward onto X/Z plane (prevents flips when looking up/down).
-        let fx = listenerForward.x;
-        let fz = listenerForward.z;
-        const fLen = Math.hypot(fx, fz);
-        if (fLen < 1e-4) {
-            // Fallback: if forward is nearly vertical/invalid, assume world-forward.
-            fx = 0;
-            fz = 1;
-        }
-        else {
-            fx /= fLen;
-            fz /= fLen;
-        }
-        const vLen = Math.hypot(vx, vz);
-        if (vLen < 1e-4) {
-            return 0;
-        }
-        const nx = vx / vLen;
-        const nz = vz / vLen;
-        // Signed angle from forward->source.
-        // cross(forward, source) sign determines left/right.
-        // We want: 0°=front, 90°=right, 180°=back, 270°=left.
-        const dot = fx * nx + fz * nz;
-        const cross = fx * nz - fz * nx;
-        let radians = Math.atan2(cross, dot);
-        // atan2 gives [-π, π]; map to [0, 2π)
-        if (radians < 0) {
-            radians += Math.PI * 2;
-        }
-        const degrees = (radians * 180) / Math.PI;
-        // Convert to our convention where +90 is to the right.
-        // The cross sign above produces +90 for left in a standard XZ system,
-        // so we invert.
-        const angle = (360 - degrees) % 360;
-        return angle;
-    }
-    /**
-     * Calculate gain based on distance using logarithmic scale
-     * Distance range: 0.5m to 15m
-     * Gain range: 100% to 20% (reduced minimum for audibility at distance)
-     * Uses smoother curve for more consistent audio across distances
-     *
-     * TUNED FOR CONSISTENT VOICE CLARITY:
-     * - Near range (0-3m): Full volume for clear conversation
-     * - Medium range (3-8m): Gradual falloff, still easily audible
-     * - Far range (8-15m): Soft but still present
-     */
-    /**
-     * Calculate gain based on distance - AGGRESSIVE FALLOFF
-     *
-     * Uses inverse-square law (realistic sound propagation) with floor:
-     * Gain = 1 / (1 + k * distance²)
-     *
-     * Distance → Gain mapping:
-     * - 0-1m → 100% (full volume, very close)
-     * - 2m → ~80%
-     * - 3m → ~55%
-     * - 5m → ~30%
-     * - 8m → ~15%
-     * - 10m+ → 5% (minimum, barely audible)
-     */
-    calculateLogarithmicGain(distance) {
-        const minDistance = 1.0; // Full volume at 1m or closer
-        const minGain = 15; // Minimum 15% at far distances (still audible)
-        const falloffRate = 0.12; // Controls how fast volume drops (gentler)
-        // Full volume within minimum distance
-        if (distance <= minDistance)
-            return 100;
-        // Inverse square falloff: gain = 1 / (1 + k * d²)
-        // This models realistic sound propagation in air
-        const effectiveDistance = distance - minDistance;
-        const attenuation = 1 / (1 + falloffRate * effectiveDistance * effectiveDistance);
-        // Scale to percentage range: minGain to 100
-        const gain = minGain + attenuation * (100 - minGain);
-        return Math.round(gain);
-    }
-    // NOTE: smoothGainValue removed - Web Audio's setTargetAtTime provides sufficient smoothing
-    // The previous rate-limiting approach was causing gain to get stuck at low values
-    /**
-     * Apply stereo panning to participant audio using StereoPannerNode
-     * This provides STABLE left-right panning without jitter
-     */
-    applyStereoPanning(participantId, panning) {
-        const nodes = this.participantNodes.get(participantId);
-        if (!nodes?.stereoPanner)
-            return;
-        // Convert left/right percentages to pan value (-1 to +1)
-        // If left=100, right=0 → pan = -1 (full left)
-        // If left=0, right=100 → pan = +1 (full right)
-        // If left=100, right=100 → pan = 0 (center)
-        const leftRatio = panning.left / 100;
-        const rightRatio = panning.right / 100;
-        // Calculate pan position
-        let panValue = 0;
-        if (leftRatio + rightRatio > 0) {
-            panValue = (rightRatio - leftRatio);
-        }
-        // NO RATE LIMITING - setTargetAtTime provides smooth transitions
-        // Rate limiting was causing sluggish panning when turning quickly
-        // The smoothPanValue() function already handles jitter reduction
-        // Apply pan with smooth transition
-        const currentTime = this.audioContext.currentTime;
-        // Use shorter time constant (0.05 = ~150ms to settle) for responsive panning
-        // This is smooth enough to prevent clicks but fast enough to track movement
-        nodes.stereoPanner.pan.setTargetAtTime(panValue, currentTime, 0.05);
-    }
-    async ensureDenoiseWorklet() {
-        if (!this.isDenoiserEnabled()) {
-            return;
-        }
-        if (!("audioWorklet" in this.audioContext)) {
-            this.options.denoiser = {
-                ...(this.options.denoiser || {}),
-                enabled: false,
-            };
-            return;
-        }
-        if (this.denoiseWorkletReady) {
-            return this.denoiseWorkletReady;
-        }
-        const processorSource = `class OdysseyDenoiseProcessor extends AudioWorkletProcessor {
-  constructor(options) {
-    super();
-    const cfg = (options && options.processorOptions) || {};
-    this.enabled = cfg.enabled !== false;
-    // TUNED FOR MAXIMUM VOICE CLARITY: Extremely gentle - NEVER cut speech
-    this.threshold = this._sanitize(cfg.threshold, 0.0005, 0.05, 0.002); // Very low threshold
-    this.noiseFloor = this._sanitize(cfg.noiseFloor, 0.0001, 0.02, 0.0005); // Very low noise floor
-    this.attack = this._sanitize(cfg.attack, 0.01, 0.9, 0.15); // Faster attack to catch speech onset
-    this.release = this._sanitize(cfg.release, 0.01, 0.95, 0.35); // Slower release - CRITICAL for word endings
-    this.holdSamples = Math.max(
-      8,
-      Math.round(
-        sampleRate * this._sanitize(cfg.holdMs, 10, 600, 200) / 1000 // LONGER hold (200ms) - prevents mid-word cuts
-      )
-    );
-    // maxReduction: VERY GENTLE - only reduce obvious noise, never speech
-    this.maxReduction = this._sanitize(cfg.maxReduction, 0.05, 0.5, 0.15); // CRITICAL: Very low = preserve all speech
-    this.hissCut = this._sanitize(cfg.hissCut, 0, 1, 0.2); // Less aggressive hiss cut
-    this.expansionRatio = this._sanitize(cfg.expansionRatio, 1.05, 3, 1.1); // Very gentle expansion
-    this.learnRate = this._sanitize(cfg.learnRate, 0.001, 0.2, 0.04); // Slower learning
-    this.voiceBoost = this._sanitize(cfg.voiceBoost, 0, 1, 0.3);
-    this.voiceSensitivity = this._sanitize(cfg.voiceSensitivity, 0.02, 0.9, 0.15); // More sensitive to voice
-    this.voiceEnhancement = cfg.voiceEnhancement === true;
-    this.speechBoost = this._sanitize(cfg.speechBoost, 0, 1.5, 0.2);
-    this.highBandGate = this._sanitize(cfg.highBandGate, 0, 1, 0.25); // Less aggressive high band gate
-    this.highBandAttack = this._sanitize(cfg.highBandAttack, 0.01, 1, 0.1);
-    this.highBandRelease = this._sanitize(cfg.highBandRelease, 0.01, 1, 0.05);
-    this.silenceFloor = this._sanitize(cfg.silenceFloor, 0.0001, 0.01, 0.0004); // Much lower
-    this.gateGraceSamples = Math.round(sampleRate * 0.4); // Longer grace period (400ms)
-    this.postSpeechHoldSamples = Math.round(sampleRate * 0.35); // Longer post-speech hold (350ms)
-    this.silenceHoldSamples = Math.max(
-      8,
-      Math.round(
-        sampleRate * this._sanitize(cfg.silenceHoldMs, 80, 2000, 300) / 1000 // Much longer silence hold
-      )
-    );
-    this.silenceReleaseSamples = Math.max(
-      8,
-      Math.round(
-        sampleRate * this._sanitize(cfg.silenceReleaseMs, 50, 1000, 150) / 1000 // Longer release
-      )
-    );
-    this.historySize = this.voiceEnhancement ? 512 : 0;
-    this.channelState = [];
-    this.hfAlpha = Math.exp(-2 * Math.PI * 3200 / sampleRate);
-    this.feedbackDetectionWindow = Math.round(sampleRate * 0.8); // Longer feedback window
-    this.feedbackSamples = 0;
-    this.feedbackActive = false;
-    // NEW: Minimum gain floor to NEVER completely mute
-    // RAISED from 0.25 to 0.5 to preserve ALL speech
-    this.minGainFloor = 0.5; // Always let at least 50% through - preserves soft consonants
-  }
-
-  _sanitize(value, min, max, fallback) {
-    if (typeof value !== 'number' || !isFinite(value)) {
-      return fallback;
-    }
-    return Math.min(max, Math.max(min, value));
-  }
-
-  _ensureState(index) {
-    if (!this.channelState[index]) {
-      this.channelState[index] = {
-        envelope: this.noiseFloor,
-        noise: this.noiseFloor,
-        gain: 1,
-        quietSamples: 0,
-        lpState: 0,
-        history: this.voiceEnhancement ? new Float32Array(this.historySize) : null,
-        historyIndex: 0,
-        historyFilled: 0,
-        tempBuffer: this.voiceEnhancement ? new Float32Array(this.historySize) : null,
-        voiceConfidence: 0,
-        silenceSamples: 0,
-        silenceReleaseCounter: 0,
-        isSilenced: false,
-        muteGain: 1,
-        graceSamplesRemaining: this.gateGraceSamples,
-        postSpeechHold: 0,
-        highBandEnv: this.silenceFloor,
-        broadbandEnv: this.silenceFloor,
-        feedbackCounter: 0,
-        feedbackSuppress: 1.0,
-        avgLevel: 0,
-        levelVariance: 0,
-      };
-    }
-    return this.channelState[index];
-  }
-
-  _pushHistory(state, sample) {
-    if (!this.voiceEnhancement || !state.history) {
-      return;
-    }
-    state.history[state.historyIndex] = sample;
-    state.historyIndex = (state.historyIndex + 1) % state.history.length;
-    if (state.historyFilled < state.history.length) {
-      state.historyFilled++;
-    }
-  }
-
-  _updateVoiceConfidence(state) {
-    if (!this.voiceEnhancement || !state.history || !state.tempBuffer) {
-      state.voiceConfidence += (0 - state.voiceConfidence) * 0.2;
-      return state.voiceConfidence;
-    }
-
-    if (state.historyFilled < state.history.length * 0.6) {
-      state.voiceConfidence += (0 - state.voiceConfidence) * 0.15;
-      return state.voiceConfidence;
-    }
-
-    const len = state.history.length;
-    let writeIndex = state.historyIndex;
-    for (let i = 0; i < len; i++) {
-      state.tempBuffer[i] = state.history[writeIndex];
-      writeIndex = (writeIndex + 1) % len;
-    }
-
-    const minLag = 30;
-    const maxLag = 240;
-    let best = 0;
-    for (let lag = minLag; lag <= maxLag; lag += 2) {
-      let sum = 0;
-      let energyA = 0;
-      let energyB = 0;
-      for (let i = lag; i < len; i++) {
-        const a = state.tempBuffer[i];
-        const b = state.tempBuffer[i - lag];
-        sum += a * b;
-        energyA += a * a;
-        energyB += b * b;
-      }
-      const denom = Math.sqrt(energyA * energyB) + 1e-8;
-      const corr = Math.abs(sum) / denom;
-      if (corr > best) {
-        best = corr;
-      }
-    }
-
-    const normalized = Math.max(
-      0,
-      Math.min(1, (best - this.voiceSensitivity) / (1 - this.voiceSensitivity))
-    );
-    state.voiceConfidence += (normalized - state.voiceConfidence) * 0.2;
-    return state.voiceConfidence;
-  }
-
-  process(inputs, outputs) {
-    const input = inputs[0];
-    const output = outputs[0];
-    if (!input || !output) {
-      return true;
-    }
-
-    for (let channel = 0; channel < output.length; channel++) {
-      const inChannel = input[channel];
-      const outChannel = output[channel];
-      if (!inChannel || !outChannel) {
-        continue;
-      }
-
-      if (!this.enabled) {
-        for (let i = 0; i < inChannel.length; i++) {
-          outChannel[i] = inChannel[i];
-        }
-        continue;
-      }
-
-      const state = this._ensureState(channel);
-      const speechPresence = this.voiceEnhancement
-        ? this.voiceBoost * state.voiceConfidence
-        : 0;
-
-      for (let i = 0; i < inChannel.length; i++) {
-        const sample = inChannel[i];
-        this._pushHistory(state, sample);
-        const magnitude = Math.abs(sample);
-
-        state.envelope += (magnitude - state.envelope) * this.attack;
-
-        if (speechPresence > 0.12 || state.envelope > this.threshold * 1.1) {
-          state.graceSamplesRemaining = this.gateGraceSamples;
-          state.postSpeechHold = this.postSpeechHoldSamples;
-        } else if (state.postSpeechHold > 0) {
-          state.postSpeechHold--;
-        }
-
-        if (state.envelope < this.threshold) {
-          state.noise += (state.envelope - state.noise) * this.learnRate;
-          state.quietSamples++;
-        } else {
-          state.quietSamples = 0;
-        }
-
-        if (state.graceSamplesRemaining > 0 || state.postSpeechHold > 0) {
-          state.graceSamplesRemaining--;
-          state.isSilenced = false;
-          state.silenceSamples = 0;
-          state.silenceReleaseCounter = 0;
-        } else {
-          const belowFloor = state.envelope < this.silenceFloor;
-          if (belowFloor && speechPresence < 0.15) {
-            state.silenceSamples++;
-          } else {
-            state.silenceSamples = Math.max(0, state.silenceSamples - 3);
-          }
-
-          if (!state.isSilenced && state.silenceSamples > this.silenceHoldSamples) {
-            state.isSilenced = true;
-            state.silenceReleaseCounter = 0;
-          }
-
-          if (state.isSilenced) {
-            const wakeFromEnergy = state.envelope > this.silenceFloor * 1.2;
-            const wakeFromVoice = speechPresence > 0.15;
-            if (wakeFromEnergy || wakeFromVoice) {
-              state.isSilenced = false;
-              state.silenceSamples = 0;
-              state.silenceReleaseCounter = 0;
-              state.postSpeechHold = this.postSpeechHoldSamples;
-              state.graceSamplesRemaining = this.gateGraceSamples;
-            } else {
-              state.silenceReleaseCounter++;
-              if (state.silenceReleaseCounter > this.silenceReleaseSamples) {
-                state.isSilenced = false;
-                state.silenceSamples = 0;
-                state.silenceReleaseCounter = 0;
-              }
-            }
-          } else {
-            state.silenceReleaseCounter = 0;
-          }
-        }
-
-        const ratio = state.noise / Math.max(state.envelope, 1e-6);
-        let gainTarget = 1 - Math.min(0.75, Math.pow(ratio, this.expansionRatio)); // Less aggressive
-        gainTarget = Math.max(this.minGainFloor, Math.min(1, gainTarget)); // NEVER below minGainFloor
-
-        if (state.quietSamples > this.holdSamples) {
-          // Very gentle reduction during quiet - preserve soft speech
-          gainTarget = Math.max(this.minGainFloor, gainTarget * (1 - this.maxReduction * 0.2));
-        }
-
-        const isLowLevelNoise = state.envelope > this.silenceFloor * 2.0 && 
-                                 state.envelope < this.threshold * 0.6;
-        const noVoicePresent = speechPresence < 0.08; // More strict voice check
-        
-        if (isLowLevelNoise && noVoicePresent) {
-          state.feedbackCounter++;
-          state.avgLevel = state.avgLevel * 0.98 + state.envelope * 0.02; // Slower averaging
-          const diff = Math.abs(state.envelope - state.avgLevel);
-          state.levelVariance = state.levelVariance * 0.98 + diff * 0.02;
-          
-          // Only suppress if VERY consistent (feedback is very steady)
-          if (state.feedbackCounter > this.feedbackDetectionWindow && 
-              state.levelVariance < state.avgLevel * 0.15) {
-            state.feedbackSuppress = Math.max(0.3, state.feedbackSuppress - 0.01); // Less aggressive
-          }
-        } else {
-          state.feedbackCounter = Math.max(0, state.feedbackCounter - 5);
-          state.feedbackSuppress = Math.min(1.0, state.feedbackSuppress + 0.05);
-        }
-
-        const reductionFloor = this.voiceEnhancement
-          ? 1 - this.maxReduction * (1 - Math.min(1, speechPresence * 0.9))
-          : 1 - this.maxReduction;
-        // CRITICAL: Never go below minGainFloor
-        if (gainTarget < Math.max(reductionFloor, this.minGainFloor)) {
-          gainTarget = Math.max(reductionFloor, this.minGainFloor);
-        }
-
-        gainTarget *= state.feedbackSuppress;
-        // Ensure gainTarget never goes below floor after feedback suppression
-        gainTarget = Math.max(gainTarget, this.minGainFloor);
-
-        const dynamicRelease = this.release *
-          (this.voiceEnhancement && speechPresence > 0.1 ? 0.7 : 1);
-        state.gain += (gainTarget - state.gain) * dynamicRelease;
-        // Final gain floor check
-        state.gain = Math.max(state.gain, this.minGainFloor * 0.8);
-        let processed = sample * state.gain;
-
-        state.lpState = this.hfAlpha * state.lpState + (1 - this.hfAlpha) * processed;
-        const lowComponent = state.lpState;
-        const highComponent = processed - lowComponent;
-
-        state.broadbandEnv += (Math.abs(processed) - state.broadbandEnv) * 0.08; // Slower tracking
-        const highEnvDelta = Math.abs(highComponent) - state.highBandEnv;
-        const highEnvCoef = highEnvDelta > 0 ? this.highBandAttack : this.highBandRelease;
-        state.highBandEnv += highEnvDelta * highEnvCoef;
-
-        const hissRatio = Math.min(
-          1,
-          Math.abs(highComponent) / (Math.abs(lowComponent) + 1e-5)
-        );
-        // Less aggressive hiss removal - preserve consonants (S, T, F, etc.)
-        const hissGain = 1 - hissRatio * (this.hissCut * (1 - 0.6 * speechPresence));
-
-        const highEnvRatio = state.highBandEnv / (state.broadbandEnv + 1e-5);
-        const gateAmount = this.highBandGate * Math.max(0, highEnvRatio - speechPresence * 0.6);
-        const gatedHigh = highComponent * hissGain * (1 - gateAmount * 0.7); // Less gate
-
-        const speechLift = 1 + this.speechBoost * speechPresence;
-        processed = lowComponent * speechLift + gatedHigh;
-
-        // CRITICAL FIX: Much higher minimum muteGain - never mute below 50%
-        // This ensures soft speech and consonants are ALWAYS audible
-        const muteTarget = state.isSilenced ? 0.5 : 1;
-        const smoothing = state.isSilenced ? 0.03 : 0.25; // Even slower mute transition
-        state.muteGain += (muteTarget - state.muteGain) * smoothing;
-        processed *= state.muteGain;
-
-        outChannel[i] = processed;
-      }
-
-      this._updateVoiceConfidence(state);
-    }
-
-    return true;
-  }
-}
-
-registerProcessor('odyssey-denoise', OdysseyDenoiseProcessor);
-`;
-        const blob = new Blob([processorSource], {
-            type: "application/javascript",
-        });
-        this.denoiseWorkletUrl = URL.createObjectURL(blob);
-        this.denoiseWorkletReady = this.audioContext.audioWorklet
-            .addModule(this.denoiseWorkletUrl)
-            .catch((error) => {
-            this.options.denoiser = {
-                ...(this.options.denoiser || {}),
-                enabled: false,
-            };
-            throw error;
-        });
-        return this.denoiseWorkletReady;
-    }
-    resolveOptions(options) {
-        const distanceDefaults = {
-            refDistance: 1.2,
-            maxDistance: 15, // Cannot hear beyond 15 meters
-            rolloffFactor: 1.35,
-            unit: "auto",
-        };
-        const denoiserDefaults = {
-            enabled: false, // DISABLED BY DEFAULT - test to see if denoiser causes audio cutting
-            // TUNED FOR MAXIMUM SPEECH CLARITY: Extremely gentle - only remove obvious noise
-            // These settings GUARANTEE no speech cutting - minGainFloor=0.5 means at least 50% always passes
-            threshold: 0.002, // Very low threshold - catch even soft speech
-            noiseFloor: 0.0005, // Very low noise floor
-            release: 0.4, // Slower release - preserve word endings completely
-            attack: 0.1, // Faster attack - catch speech onset instantly
-            holdMs: 200, // Long hold (200ms) - prevent mid-word cuts
-            maxReduction: 0.15, // VERY GENTLE - max 15% reduction, never cut speech
-            hissCut: 0.15, // Less hiss cut - preserve S, T, F consonants
-            expansionRatio: 1.05, // Almost no expansion
-            learnRate: 0.03, // Slower learning - don't adapt to speech as noise
-            voiceBoost: 0.35,
-            voiceSensitivity: 0.1, // Very sensitive to voice detection
-            voiceEnhancement: false,
-            silenceFloor: 0.0002, // Very low silence floor
-            silenceHoldMs: 400, // Much longer before silence gate (400ms)
-            silenceReleaseMs: 200, // Slower release from silence
-            speechBoost: 0.25,
-            highBandGate: 0.15, // Much less aggressive high band gate
-            highBandAttack: 0.08,
-            highBandRelease: 0.03,
-        };
-        return {
-            distance: {
-                refDistance: options?.distance?.refDistance ?? distanceDefaults.refDistance,
-                maxDistance: options?.distance?.maxDistance ?? distanceDefaults.maxDistance,
-                rolloffFactor: options?.distance?.rolloffFactor ?? distanceDefaults.rolloffFactor,
-                unit: options?.distance?.unit ?? distanceDefaults.unit,
-            },
-            denoiser: {
-                enabled: options?.denoiser?.enabled ?? denoiserDefaults.enabled,
-                threshold: options?.denoiser?.threshold ?? denoiserDefaults.threshold,
-                noiseFloor: options?.denoiser?.noiseFloor ?? denoiserDefaults.noiseFloor,
-                release: options?.denoiser?.release ?? denoiserDefaults.release,
-                attack: options?.denoiser?.attack ?? denoiserDefaults.attack,
-                holdMs: options?.denoiser?.holdMs ?? denoiserDefaults.holdMs,
-                maxReduction: options?.denoiser?.maxReduction ?? denoiserDefaults.maxReduction,
-                hissCut: options?.denoiser?.hissCut ?? denoiserDefaults.hissCut,
-                expansionRatio: options?.denoiser?.expansionRatio ?? denoiserDefaults.expansionRatio,
-                learnRate: options?.denoiser?.learnRate ?? denoiserDefaults.learnRate,
-                voiceBoost: options?.denoiser?.voiceBoost ?? denoiserDefaults.voiceBoost,
-                voiceSensitivity: options?.denoiser?.voiceSensitivity ?? denoiserDefaults.voiceSensitivity,
-                voiceEnhancement: options?.denoiser?.voiceEnhancement ?? denoiserDefaults.voiceEnhancement,
-                silenceFloor: options?.denoiser?.silenceFloor ?? denoiserDefaults.silenceFloor,
-                silenceHoldMs: options?.denoiser?.silenceHoldMs ?? denoiserDefaults.silenceHoldMs,
-                silenceReleaseMs: options?.denoiser?.silenceReleaseMs ?? denoiserDefaults.silenceReleaseMs,
-                speechBoost: options?.denoiser?.speechBoost ?? denoiserDefaults.speechBoost,
-                highBandGate: options?.denoiser?.highBandGate ?? denoiserDefaults.highBandGate,
-                highBandAttack: options?.denoiser?.highBandAttack ?? denoiserDefaults.highBandAttack,
-                highBandRelease: options?.denoiser?.highBandRelease ?? denoiserDefaults.highBandRelease,
-            },
-        };
-    }
-}
-exports.SpatialAudioManager = SpatialAudioManager;
-SpatialAudioManager.BUILD_STAMP = "2026-01-07";