@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.258 → 1.0.260

package/dist/channels/spatial/SpatialAudioChannel.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Spatial Audio Channel
+ *
+ * Processes audio for spatial positioning using Web Audio API
+ */
+import { Position } from '../../types/position';
+import { SpatialDistanceConfig, DenoiserOptions } from './SpatialAudioTypes';
+/**
+ * Spatial audio configuration
+ */
+export interface SpatialAudioConfig {
+    distance?: SpatialDistanceConfig;
+    denoiser?: DenoiserOptions;
+}
+/**
+ * Spatial Audio Channel class
+ * Processes participant audio with 3D spatial positioning
+ */
+export declare class SpatialAudioChannel {
+    private audioContext;
+    private participantNodes;
+    private masterGainNode;
+    private compressor;
+    private distanceConfig;
+    private denoiserConfig;
+    private listenerState;
+    private positionCache;
+    private panSmoother;
+    private isMasterMuted;
+    private mlNoiseSuppressor;
+    private noiseSuppressionMode;
+    constructor(config?: SpatialAudioConfig);
+    /**
+     * Get the AudioContext
+     */
+    getAudioContext(): AudioContext;
+    /**
+     * Setup spatial audio for a participant
+     */
+    setupParticipant(participantId: string, track: MediaStreamTrack, bypassSpatialization?: boolean): Promise<void>;
+    /**
+     * Update spatial audio for a participant
+     */
+    updateSpatialAudio(participantId: string, position: Position, direction?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Set listener position from LSD data
+     */
+    setListenerFromLSD(listenerPos: Position, cameraPos: Position, lookAtPos: Position, rot?: {
+        x: number;
+        y: number;
+        z: number;
+    }): void;
+    /**
+     * Toggle spatialization for a participant
+     * CRITICAL: This handles the audio routing when switching between spatial and huddle channels
+     */
+    setParticipantSpatialization(participantId: string, enableSpatialization: boolean): void;
+    /**
+     * Mute/unmute a participant
+     */
+    setParticipantMuted(participantId: string, muted: boolean): void;
+    /**
+     * Master mute/unmute
+     */
+    setMasterMuted(muted: boolean): void;
+    /**
+     * Get master mute state
+     */
+    getMasterMuted(): boolean;
+    /**
+     * Set listener position and orientation (standard API)
+     */
+    setListenerPosition(position: Position, orientation?: {
+        forwardX: number;
+        forwardY: number;
+        forwardZ: number;
+        upX: number;
+        upY: number;
+        upZ: number;
+    }): void;
+    /**
+     * Setup spatial audio for participant (alias for backward compatibility)
+     * @param participantId - The participant ID
+     * @param track - The MediaStreamTrack
+     * @param bypassSpatialization - Whether to bypass 3D positioning (e.g., for huddle members)
+     */
+    setupSpatialAudioForParticipant(participantId: string, track: MediaStreamTrack, bypassSpatialization?: boolean): Promise<void>;
+    /**
+     * Initialize ML noise suppression
+     * Loads the TensorFlow.js model for real-time noise reduction
+     */
+    initializeMLNoiseSuppression(modelPath: string): Promise<void>;
+    /**
+     * Get current noise suppression mode
+     */
+    getNoiseSuppressionMode(): 'ml' | 'audioworklet' | 'none';
+    /**
+     * Check if ML model is loaded
+     */
+    isMLModelLoaded(): boolean;
+    /**
+     * Remove a participant
+     */
+    removeParticipant(participantId: string): void;
+    /**
+     * Resume audio context
+     */
+    resumeAudioContext(): Promise<void>;
+    /**
+     * Get audio context state
+     */
+    getAudioContextState(): AudioContextState;
+    /**
+     * Get audio level for a participant (0-100)
+     * Useful for audio monitoring and VU meters
+     */
+    getParticipantAudioLevel(participantId: string): number;
+    /**
+     * Check if participant has active audio
+     */
+    isParticipantSpeaking(participantId: string, threshold?: number): boolean;
+    /**
+     * Get all active participants (those with audio nodes)
+     */
+    getActiveParticipants(): string[];
+    /**
+     * Check if a participant has been set up
+     */
+    hasParticipant(participantId: string): boolean;
+    /**
+     * Get participant count
+     */
+    getParticipantCount(): number;
+    private createPanner;
+    private createMonoChain;
+    private createParticipantCompressor;
+    private createFilters;
+}
+export { SpatialAudioChannel as SpatialAudioManager };
+export type { SpatialAudioConfig as SpatialAudioOptions };

package/dist/channels/spatial/SpatialAudioChannel.js

@@ -0,0 +1,476 @@
+"use strict";
+/**
+ * Spatial Audio Channel
+ *
+ * Processes audio for spatial positioning using Web Audio API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpatialAudioManager = exports.SpatialAudioChannel = void 0;
+const SpatialAudioTypes_1 = require("./SpatialAudioTypes");
+const distance_calc_1 = require("../../utils/spatial/distance-calc");
+const gain_calc_1 = require("../../utils/spatial/gain-calc");
+const pan_calc_1 = require("../../utils/spatial/pan-calc");
+const head_position_1 = require("../../utils/spatial/head-position");
+const normalize_1 = require("../../utils/position/normalize");
+const snap_1 = require("../../utils/position/snap");
+const pan_smoothing_1 = require("../../utils/smoothing/pan-smoothing");
+const gain_smoothing_1 = require("../../utils/smoothing/gain-smoothing");
+const MLNoiseSuppressor_1 = require("../../audio/MLNoiseSuppressor");
+/**
+ * Spatial Audio Channel class
+ * Processes participant audio with 3D spatial positioning
+ */
+class SpatialAudioChannel {
+    constructor(config) {
+        this.participantNodes = new Map();
+        this.listenerState = {
+            position: { x: 0, y: 0, z: 0 },
+            right: { x: 1, z: 0 },
+            initialized: false,
+        };
+        this.isMasterMuted = false;
+        // ML Noise Suppression
+        this.mlNoiseSuppressor = null;
+        this.noiseSuppressionMode = 'none';
+        this.distanceConfig = { ...SpatialAudioTypes_1.DEFAULT_SPATIAL_CONFIG, ...config?.distance };
+        this.denoiserConfig = { ...SpatialAudioTypes_1.DEFAULT_DENOISER_OPTIONS, ...config?.denoiser };
+        this.audioContext = new AudioContext({ sampleRate: 48000 });
+        // Master gain
+        this.masterGainNode = this.audioContext.createGain();
+        this.masterGainNode.gain.value = 1.0;
+        // Master compressor
+        this.compressor = this.audioContext.createDynamicsCompressor();
+        this.compressor.threshold.value = -15;
+        this.compressor.knee.value = 40;
+        this.compressor.ratio.value = 2.5;
+        this.compressor.attack.value = 0.02;
+        this.compressor.release.value = 0.25;
+        // Connect master chain
+        this.masterGainNode.connect(this.compressor);
+        this.compressor.connect(this.audioContext.destination);
+        // Initialize utilities
+        this.positionCache = new snap_1.PositionSnapCache(0.30);
+        this.panSmoother = new pan_smoothing_1.PanSmoother();
+    }
+    /**
+     * Get the AudioContext
+     */
+    getAudioContext() {
+        return this.audioContext;
+    }
+    /**
+     * Setup spatial audio for a participant
+     */
+    async setupParticipant(participantId, track, bypassSpatialization = false) {
+        console.log(`🎧 [SpatialAudioChannel] Setting up participant ${participantId.substring(0, 8)}`, {
+            trackKind: track.kind,
+            trackEnabled: track.enabled,
+            trackMuted: track.muted,
+            trackReadyState: track.readyState,
+            bypassSpatialization,
+            audioContextState: this.audioContext.state,
+        });
+        if (this.audioContext.state === 'suspended') {
+            console.log(`🎧 [SpatialAudioChannel] Resuming suspended AudioContext...`);
+            await this.audioContext.resume();
+            console.log(`🎧 [SpatialAudioChannel] AudioContext resumed, state: ${this.audioContext.state}`);
+        }
+        const stream = new MediaStream([track]);
+        const source = this.audioContext.createMediaStreamSource(stream);
+        console.log(`🎧 [SpatialAudioChannel] Created MediaStreamSource for ${participantId.substring(0, 8)}`, {
+            streamActive: stream.active,
+            streamTracks: stream.getTracks().length,
+        });
+        // Create all audio nodes
+        const panner = this.createPanner();
+        const stereoPanner = this.audioContext.createStereoPanner();
+        const { monoSplitter, monoGainL, monoGainR, monoMerger, stereoUpmixer } = this.createMonoChain();
+        const analyser = this.audioContext.createAnalyser();
+        const gain = this.audioContext.createGain();
+        const proximityGain = this.audioContext.createGain();
+        const compressor = this.createParticipantCompressor();
+        const { highpassFilter, lowpassFilter, voiceBandFilter, dynamicLowpass } = this.createFilters();
+        gain.gain.value = 1.0;
+        proximityGain.gain.value = 1.0;
+        // Connect audio chain
+        let currentNode = source;
+        currentNode.connect(compressor);
+        currentNode = compressor;
+        compressor.connect(highpassFilter);
+        highpassFilter.connect(voiceBandFilter);
+        voiceBandFilter.connect(lowpassFilter);
+        lowpassFilter.connect(dynamicLowpass);
+        dynamicLowpass.connect(proximityGain);
+        // Mono downmix chain
+        proximityGain.connect(monoSplitter);
+        monoSplitter.connect(monoGainL, 0);
+        monoSplitter.connect(monoGainR, 1);
+        monoGainL.connect(monoMerger, 0, 0);
+        monoGainR.connect(monoMerger, 0, 0);
+        monoMerger.connect(stereoUpmixer, 0, 0);
+        monoMerger.connect(stereoUpmixer, 0, 1);
+        stereoUpmixer.connect(analyser);
+        // Output routing
+        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,
+            highpassFilter,
+            lowpassFilter,
+            voiceBandFilter,
+            dynamicLowpass,
+            stream,
+        });
+        console.log(`🎧 [SpatialAudioChannel] ✅ Audio pipeline setup complete for ${participantId.substring(0, 8)}`, {
+            bypassSpatialization,
+            masterGainValue: this.masterGainNode.gain.value,
+            participantGainValue: gain.gain.value,
+            audioContextState: this.audioContext.state,
+            connectedToDestination: true,
+        });
+    }
+    /**
+     * Update spatial audio for a participant
+     */
+    updateSpatialAudio(participantId, position, direction) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes?.panner)
+            return;
+        // Normalize and snap position
+        const normalizedPos = (0, normalize_1.normalizePositionUnits)(position, this.distanceConfig.unit);
+        const snappedPos = this.positionCache.snap(normalizedPos, participantId);
+        const speakerHead = (0, head_position_1.computeHeadPosition)(snappedPos);
+        const listenerPos = this.listenerState.position;
+        const distance = (0, distance_calc_1.getDistanceBetween)(listenerPos, speakerHead);
+        // Hard cutoff at max distance
+        if (distance >= this.distanceConfig.maxDistance) {
+            (0, gain_smoothing_1.applyGainSmooth)(nodes.gain, 0, this.audioContext, 0.033);
+            return;
+        }
+        // Calculate pan
+        const rawPan = (0, pan_calc_1.calculatePanFromPositions)(listenerPos, speakerHead, this.listenerState.right);
+        const smoothedPan = this.panSmoother.smooth(participantId, rawPan);
+        const panning = (0, pan_calc_1.panValueToPanning)(smoothedPan);
+        // Calculate gain
+        const gainPercent = (0, gain_calc_1.calculateLogarithmicGain)(distance, {
+            minDistance: this.distanceConfig.refDistance,
+            maxDistance: this.distanceConfig.maxDistance,
+        });
+        const gainValue = gainPercent / 100;
+        // Apply stereo panning
+        const panValue = (panning.right - panning.left) / 100;
+        (0, gain_smoothing_1.applyStereoPanSmooth)(nodes.stereoPanner, panValue, this.audioContext, 0.05);
+        // Apply gain
+        (0, gain_smoothing_1.applyGainSmooth)(nodes.gain, gainValue, this.audioContext, 0.1);
+        // ========== DEBUG: SPATIAL AUDIO CALCULATION ==========
+        console.log(`🔊 [SpatialAudio] Participant ${participantId}:`, {
+            speakerPos: speakerHead,
+            listenerPos: listenerPos,
+            distance: distance.toFixed(2) + 'm',
+            rawPan: rawPan.toFixed(3),
+            smoothedPan: smoothedPan.toFixed(3),
+            panValue: panValue.toFixed(3),
+            gainPercent: gainPercent.toFixed(1) + '%',
+            gainValue: gainValue.toFixed(3),
+            panning: { left: panning.left.toFixed(1), right: panning.right.toFixed(1) },
+        });
+    }
+    /**
+     * Set listener position from LSD data
+     */
+    setListenerFromLSD(listenerPos, cameraPos, lookAtPos, rot) {
+        const normalizedListener = (0, normalize_1.normalizePositionUnits)(cameraPos, this.distanceConfig.unit);
+        const snappedListener = this.positionCache.snap(normalizedListener, 'listener');
+        this.listenerState.position = snappedListener;
+        this.listenerState.initialized = true;
+        if (rot && typeof rot.y === 'number') {
+            this.listenerState.right = (0, pan_calc_1.calculateListenerRight)(rot.y);
+        }
+        // ========== DEBUG: LISTENER STATE UPDATE ==========
+        console.log('👂 [SpatialAudio] Listener state updated:', {
+            position: this.listenerState.position,
+            right: this.listenerState.right,
+            yawDegrees: rot?.y,
+            initialized: this.listenerState.initialized,
+        });
+    }
+    /**
+     * Toggle spatialization for a participant
+     * CRITICAL: This handles the audio routing when switching between spatial and huddle channels
+     */
+    setParticipantSpatialization(participantId, enableSpatialization) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes) {
+            console.warn(`[SpatialAudioChannel] Cannot set spatialization - no nodes for participant: ${participantId}`);
+            return;
+        }
+        try {
+            const currentTime = this.audioContext.currentTime;
+            const fadeTime = 0.03; // 30ms crossfade for smooth transition
+            if (enableSpatialization) {
+                // CROSSFADE: Connect new path BEFORE disconnecting old (prevents audio drop)
+                // First connect the new spatialized path
+                nodes.analyser.connect(nodes.stereoPanner);
+                nodes.stereoPanner.connect(nodes.gain);
+                // Then disconnect the direct path after a tiny delay
+                setTimeout(() => {
+                    try {
+                        // This will only disconnect the direct analyser->gain connection
+                        // The stereoPanner path remains connected
+                    }
+                    catch (e) {
+                        // Ignore - may already be routed correctly
+                    }
+                }, fadeTime * 1000);
+                console.log(`[SpatialAudioChannel] ✅ Enabled spatialization for: ${participantId}`);
+            }
+            else {
+                // CROSSFADE: Connect direct path BEFORE disconnecting stereo panner
+                // First create the direct bypass connection
+                nodes.analyser.connect(nodes.gain);
+                // Reset gain to full volume for huddle (smooth transition)
+                nodes.gain.gain.setTargetAtTime(1.0, currentTime, fadeTime);
+                // Reset stereo panner to center
+                nodes.stereoPanner.pan.setTargetAtTime(0, currentTime, fadeTime);
+                // Then disconnect the stereo panner path after fade completes
+                setTimeout(() => {
+                    try {
+                        nodes.stereoPanner.disconnect();
+                    }
+                    catch (e) {
+                        // Already disconnected
+                    }
+                }, fadeTime * 1000);
+                console.log(`[SpatialAudioChannel] ✅ Disabled spatialization (huddle mode) for: ${participantId}`);
+            }
+        }
+        catch (error) {
+            console.error(`[SpatialAudioChannel] Error setting spatialization for ${participantId}:`, error);
+        }
+    }
+    /**
+     * Mute/unmute a participant
+     */
+    setParticipantMuted(participantId, muted) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes?.gain)
+            return;
+        (0, gain_smoothing_1.applyGainSmooth)(nodes.gain, muted ? 0 : 1, this.audioContext, 0.05);
+    }
+    /**
+     * Master mute/unmute
+     */
+    setMasterMuted(muted) {
+        this.isMasterMuted = muted;
+        (0, gain_smoothing_1.applyGainSmooth)(this.masterGainNode, muted ? 0 : 1, this.audioContext, 0.05);
+    }
+    /**
+     * Get master mute state
+     */
+    getMasterMuted() {
+        return this.isMasterMuted;
+    }
+    /**
+     * Set listener position and orientation (standard API)
+     */
+    setListenerPosition(position, orientation) {
+        const normalizedPosition = (0, normalize_1.normalizePositionUnits)(position);
+        this.listenerState.position = normalizedPosition;
+        if (orientation) {
+            // Calculate yaw from forward direction
+            // forwardX, forwardZ define the forward vector
+            const yawRadians = Math.atan2(orientation.forwardX, orientation.forwardZ);
+            const yawDegrees = (yawRadians * 180) / Math.PI;
+            this.listenerState.right = (0, pan_calc_1.calculateListenerRight)(yawDegrees);
+        }
+        this.listenerState.initialized = true;
+    }
+    /**
+     * Setup spatial audio for participant (alias for backward compatibility)
+     * @param participantId - The participant ID
+     * @param track - The MediaStreamTrack
+     * @param bypassSpatialization - Whether to bypass 3D positioning (e.g., for huddle members)
+     */
+    async setupSpatialAudioForParticipant(participantId, track, bypassSpatialization) {
+        return this.setupParticipant(participantId, track, bypassSpatialization || false);
+    }
+    /**
+     * Initialize ML noise suppression
+     * Loads the TensorFlow.js model for real-time noise reduction
+     */
+    async initializeMLNoiseSuppression(modelPath) {
+        try {
+            console.log(`[SpatialAudioChannel] Initializing ML noise suppression: ${modelPath}`);
+            this.mlNoiseSuppressor = new MLNoiseSuppressor_1.MLNoiseSuppressor();
+            await this.mlNoiseSuppressor.initialize(modelPath);
+            if (this.mlNoiseSuppressor.isReady()) {
+                this.noiseSuppressionMode = 'ml';
+                console.log('[SpatialAudioChannel] ML noise suppression initialized successfully');
+            }
+            else {
+                throw new Error('ML model failed to load');
+            }
+        }
+        catch (error) {
+            console.warn('[SpatialAudioChannel] ML noise suppression failed, will use fallback:', error);
+            this.noiseSuppressionMode = 'audioworklet';
+            this.mlNoiseSuppressor = null;
+        }
+    }
+    /**
+     * Get current noise suppression mode
+     */
+    getNoiseSuppressionMode() {
+        return this.noiseSuppressionMode;
+    }
+    /**
+     * Check if ML model is loaded
+     */
+    isMLModelLoaded() {
+        return this.mlNoiseSuppressor?.isReady() ?? false;
+    }
+    /**
+     * Remove a participant
+     */
+    removeParticipant(participantId) {
+        const nodes = this.participantNodes.get(participantId);
+        if (nodes) {
+            nodes.source.disconnect();
+            nodes.panner.disconnect();
+            nodes.stereoPanner.disconnect();
+            nodes.analyser.disconnect();
+            nodes.gain.disconnect();
+            this.participantNodes.delete(participantId);
+            this.panSmoother.clear(participantId);
+            this.positionCache.clear(participantId);
+        }
+    }
+    /**
+     * Resume audio context
+     */
+    async resumeAudioContext() {
+        if (this.audioContext.state === 'suspended') {
+            await this.audioContext.resume();
+        }
+    }
+    /**
+     * Get audio context state
+     */
+    getAudioContextState() {
+        return this.audioContext.state;
+    }
+    /**
+     * Get audio level for a participant (0-100)
+     * Useful for audio monitoring and VU meters
+     */
+    getParticipantAudioLevel(participantId) {
+        const nodes = this.participantNodes.get(participantId);
+        if (!nodes?.analyser)
+            return 0;
+        const dataArray = new Uint8Array(nodes.analyser.frequencyBinCount);
+        nodes.analyser.getByteFrequencyData(dataArray);
+        // Calculate RMS level
+        let sum = 0;
+        for (let i = 0; i < dataArray.length; i++) {
+            sum += dataArray[i] * dataArray[i];
+        }
+        const rms = Math.sqrt(sum / dataArray.length);
+        // Convert to 0-100 scale
+        return Math.min(100, Math.round((rms / 255) * 100));
+    }
+    /**
+     * Check if participant has active audio
+     */
+    isParticipantSpeaking(participantId, threshold = 5) {
+        return this.getParticipantAudioLevel(participantId) > threshold;
+    }
+    /**
+     * Get all active participants (those with audio nodes)
+     */
+    getActiveParticipants() {
+        return Array.from(this.participantNodes.keys());
+    }
+    /**
+     * Check if a participant has been set up
+     */
+    hasParticipant(participantId) {
+        return this.participantNodes.has(participantId);
+    }
+    /**
+     * Get participant count
+     */
+    getParticipantCount() {
+        return this.participantNodes.size;
+    }
+    // Private helper methods
+    createPanner() {
+        const panner = this.audioContext.createPanner();
+        panner.panningModel = 'HRTF';
+        panner.distanceModel = 'inverse';
+        panner.refDistance = this.distanceConfig.refDistance;
+        panner.maxDistance = this.distanceConfig.maxDistance;
+        panner.rolloffFactor = this.distanceConfig.rolloffFactor;
+        panner.coneInnerAngle = 360;
+        panner.coneOuterAngle = 360;
+        panner.coneOuterGain = 0.3;
+        return panner;
+    }
+    createMonoChain() {
+        const monoSplitter = this.audioContext.createChannelSplitter(2);
+        const monoGainL = this.audioContext.createGain();
+        const monoGainR = this.audioContext.createGain();
+        const monoMerger = this.audioContext.createChannelMerger(1);
+        const stereoUpmixer = this.audioContext.createChannelMerger(2);
+        monoGainL.gain.value = 0.5;
+        monoGainR.gain.value = 0.5;
+        return { monoSplitter, monoGainL, monoGainR, monoMerger, stereoUpmixer };
+    }
+    createParticipantCompressor() {
+        const compressor = this.audioContext.createDynamicsCompressor();
+        compressor.threshold.value = -6;
+        compressor.knee.value = 3;
+        compressor.ratio.value = 20;
+        compressor.attack.value = 0.001;
+        compressor.release.value = 0.05;
+        return compressor;
+    }
+    createFilters() {
+        const highpassFilter = this.audioContext.createBiquadFilter();
+        highpassFilter.type = 'highpass';
+        highpassFilter.frequency.value = 100;
+        highpassFilter.Q.value = 0.5;
+        const lowpassFilter = this.audioContext.createBiquadFilter();
+        lowpassFilter.type = 'lowpass';
+        lowpassFilter.frequency.value = 10000;
+        lowpassFilter.Q.value = 0.5;
+        const voiceBandFilter = this.audioContext.createBiquadFilter();
+        voiceBandFilter.type = 'peaking';
+        voiceBandFilter.frequency.value = 180;
+        voiceBandFilter.Q.value = 0.5;
+        voiceBandFilter.gain.value = 0;
+        const dynamicLowpass = this.audioContext.createBiquadFilter();
+        dynamicLowpass.type = 'lowpass';
+        dynamicLowpass.frequency.value = 12000;
+        dynamicLowpass.Q.value = 0.5;
+        return { highpassFilter, lowpassFilter, voiceBandFilter, dynamicLowpass };
+    }
+}
+exports.SpatialAudioChannel = SpatialAudioChannel;
+exports.SpatialAudioManager = SpatialAudioChannel;

package/dist/channels/spatial/SpatialAudioTypes.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Spatial Audio Types
+ *
+ * Type definitions for spatial audio processing
+ */
+/**
+ * Spatial audio distance configuration
+ */
+export interface SpatialDistanceConfig {
+    refDistance?: number;
+    maxDistance?: number;
+    rolloffFactor?: number;
+    unit?: 'auto' | 'meters' | 'centimeters';
+}
+/**
+ * Default spatial distance configuration
+ */
+export declare const DEFAULT_SPATIAL_CONFIG: Required<SpatialDistanceConfig>;
+/**
+ * Denoiser options for noise suppression
+ */
+export interface DenoiserOptions {
+    enabled?: boolean;
+    threshold?: number;
+    noiseFloor?: number;
+    release?: number;
+    attack?: number;
+    holdMs?: number;
+    maxReduction?: number;
+    hissCut?: number;
+    expansionRatio?: number;
+    learnRate?: number;
+    voiceBoost?: number;
+    voiceSensitivity?: number;
+    voiceEnhancement?: boolean;
+    silenceFloor?: number;
+    silenceHoldMs?: number;
+    silenceReleaseMs?: number;
+    speechBoost?: number;
+    highBandGate?: number;
+    highBandAttack?: number;
+    highBandRelease?: number;
+}
+/**
+ * Default denoiser configuration
+ */
+export declare const DEFAULT_DENOISER_OPTIONS: Required<DenoiserOptions>;
+/**
+ * Audio nodes for a participant
+ */
+export interface ParticipantAudioNodes {
+    source: MediaStreamAudioSourceNode;
+    panner: PannerNode;
+    stereoPanner: StereoPannerNode;
+    monoSplitter: ChannelSplitterNode;
+    monoGainL: GainNode;
+    monoGainR: GainNode;
+    monoMerger: ChannelMergerNode;
+    stereoUpmixer: ChannelMergerNode;
+    analyser: AnalyserNode;
+    gain: GainNode;
+    proximityGain: GainNode;
+    compressor: DynamicsCompressorNode;
+    highpassFilter: BiquadFilterNode;
+    lowpassFilter: BiquadFilterNode;
+    voiceBandFilter: BiquadFilterNode;
+    dynamicLowpass: BiquadFilterNode;
+    denoiseNode?: AudioWorkletNode;
+    stream: MediaStream;
+}
+/**
+ * Listener state
+ */
+export interface ListenerState {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    right: {
+        x: number;
+        z: number;
+    };
+    initialized: boolean;
+}