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

package/dist/{MLNoiseSuppressor.js → audio/MLNoiseSuppressor.js}

@@ -1,7 +1,9 @@
 "use strict";
 /**
  * ML Noise Suppressor - TensorFlow.js-based Real-Time Audio Enhancement
- * Integrates trained ML model for noise suppression with fallback to traditional DSP
+ *
+ * Integrates trained ML model for noise suppression
+ * Falls back to traditional DSP if ML is unavailable
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -45,9 +47,9 @@ class MLNoiseSuppressor {
         this.config = null;
         this.normStats = null;
         this.isInitialized = false;
-        // Temporal smoothing state (prevents "musical noise" artifacts)
+        // Temporal smoothing state
         this.prevMask = null;
-        this.SMOOTHING_ALPHA = 0.85; // 85% current, 15% previous
+        this.SMOOTHING_ALPHA = 0.85;
         // Voice frequency preservation
         this.VOICE_FUNDAMENTAL_MIN = 80;
         this.VOICE_FUNDAMENTAL_MAX = 500;
@@ -57,27 +59,15 @@ class MLNoiseSuppressor {
      * @param modelUrl Path to model.json file
      */
     async initialize(modelUrl) {
-        //console.log('🤖 [ML] Initializing ML Noise Suppressor...');
         try {
-            // Set TensorFlow.js backend (WebGL for GPU acceleration)
+            // Set TensorFlow.js backend
             await tf.setBackend('webgl');
             await tf.ready();
-            // HACK: Explicitly provide inputShape to fix model loading errors.
-            // The model's JSON file is missing the input layer configuration, which causes
-            // TensorFlow.js to throw a ValueError. This workaround intercepts the loading
-            // process and injects the correct input shape before the model is fully parsed.
-            const modelJson = await (await fetch(modelUrl)).json();
-            if (modelJson.modelTopology?.config?.layers?.[0]?.config
-                ?.batch_input_shape === undefined) {
-                // Model JSON is missing inputShape - apply fix
-                modelJson.modelTopology.config.layers[0].config.batch_input_shape = [
-                    null,
-                    257,
-                    1,
-                    1,
-                ];
-            }
-            this.model = await tf.loadLayersModel(tf.io.fromMemory(modelJson.modelTopology, modelJson.weightsManifest[0].weights));
+            // Load model - use standard loadLayersModel instead of fromMemory
+            // This handles weight loading automatically
+            console.log(`[MLNoiseSuppressor] Loading model from: ${modelUrl}`);
+            this.model = await tf.loadLayersModel(modelUrl);
+            console.log(`[MLNoiseSuppressor] Model loaded successfully`);
             // Load config
             const baseUrl = modelUrl.substring(0, modelUrl.lastIndexOf('/'));
             const configResponse = await fetch(`${baseUrl}/model_config.json`);
@@ -88,54 +78,43 @@ class MLNoiseSuppressor {
                 this.normStats = await normResponse.json();
             }
             catch (e) {
-                // No normalization stats found, use defaults
                 this.normStats = { mean: 0, std: 1 };
             }
             this.isInitialized = true;
+            console.log(`[MLNoiseSuppressor] Initialization complete`);
         }
         catch (error) {
+            console.error(`[MLNoiseSuppressor] Initialization failed:`, error);
             throw error;
         }
     }
     /**
      * Process audio buffer through ML model
-     * @param inputBuffer Audio samples to process
-     * @returns Denoised audio samples
      */
     async processAudio(inputBuffer) {
         if (!this.isInitialized || !this.model || !this.config || !this.normStats) {
-            // Not initialized, return original audio
             return inputBuffer;
         }
         try {
             return await tf.tidy(() => {
-                // 1. Extract features (simplified mel-spectrogram approximation)
                 const features = this.extractFeatures(inputBuffer);
-                // 2. Normalize features
                 const normalizedTensor = tf.tensor2d(features);
                 const normalized = normalizedTensor
                     .sub(this.normStats.mean)
                     .div(Math.max(this.normStats.std, 1e-8));
-                // 3. Create sequences for LSTM
                 const sequences = this.createSequences(normalized);
-                // 4. Run ML inference to get noise suppression mask
                 const maskTensor = this.model.predict(sequences);
-                // 5. Extract mask values
                 const maskArray = maskTensor.dataSync();
-                // 6. Apply temporal smoothing (critical for quality!)
                 const smoothedMask = this.applyTemporalSmoothing(Array.from(maskArray));
-                // 7. Apply mask to audio with voice preservation
-                const enhanced = this.applyMaskToAudio(inputBuffer, smoothedMask);
-                return enhanced;
+                return this.applyMaskToAudio(inputBuffer, smoothedMask);
             });
         }
         catch (error) {
-            // Return original audio on error (graceful degradation)
             return inputBuffer;
         }
     }
     /**
-     * Extract audio features (simplified mel-spectrogram approximation)
+     * Extract audio features
      */
     extractFeatures(audio) {
         if (!this.config)
@@ -148,18 +127,15 @@ class MLNoiseSuppressor {
         for (let i = 0; i < numFrames; i++) {
             const start = i * hopLength;
             const frame = audio.slice(start, Math.min(start + frameSize, audio.length));
-            // Compute simplified mel bins
             const melBins = [];
             for (let j = 0; j < nMels; j++) {
                 const binStart = Math.floor((j / nMels) * frame.length);
                 const binEnd = Math.floor(((j + 1) / nMels) * frame.length);
-                // Compute energy in this bin
                 let energy = 0;
                 for (let k = binStart; k < binEnd; k++) {
                     energy += frame[k] * frame[k];
                 }
                 energy = Math.sqrt(energy / (binEnd - binStart));
-                // Convert to log scale (dB-like)
                 const logEnergy = Math.log10(energy + 1e-10) * 10;
                 melBins.push(logEnergy);
             }
@@ -178,51 +154,42 @@ class MLNoiseSuppressor {
         const numFrames = shape[0];
         const numFeatures = shape[1];
         if (numFrames < seqLength) {
-            // Pad if needed
             const padding = tf.zeros([seqLength - numFrames, numFeatures]);
             const padded = tf.concat([featureTensor, padding], 0);
             return padded.expandDims(0);
         }
-        // Take the last seqLength frames
         const sequence = featureTensor.slice([numFrames - seqLength, 0], [seqLength, numFeatures]);
         return sequence.expandDims(0);
     }
     /**
-     * Apply temporal smoothing to mask (prevents "musical noise")
+     * Apply temporal smoothing to mask
      */
     applyTemporalSmoothing(currentMask) {
         const smoothed = new Float32Array(currentMask.length);
         if (!this.prevMask || this.prevMask.length !== currentMask.length) {
-            // First frame - no smoothing
             this.prevMask = new Float32Array(currentMask);
             return this.prevMask;
         }
-        // Exponential moving average
         for (let i = 0; i < currentMask.length; i++) {
             smoothed[i] =
                 this.SMOOTHING_ALPHA * currentMask[i] +
                     (1 - this.SMOOTHING_ALPHA) * this.prevMask[i];
-            // Clamp to valid range [0.05, 1.0]
-            // Never completely mute (min 5% to preserve voice quality)
             smoothed[i] = Math.max(0.05, Math.min(1.0, smoothed[i]));
         }
         this.prevMask = smoothed;
         return smoothed;
     }
     /**
-     * Apply noise suppression mask to audio with voice preservation
+     * Apply noise suppression mask to audio
      */
     applyMaskToAudio(audio, mask) {
         const output = new Float32Array(audio.length);
-        // Apply mask with simple interpolation
         for (let i = 0; i < audio.length; i++) {
-            // Map audio sample to mask index
             const maskIdx = Math.floor((i / audio.length) * mask.length);
             const gain = mask[Math.min(maskIdx, mask.length - 1)];
-            // Apply gain with voice frequency boost
             output[i] = audio[i] * gain;
         }
-        // Apply fade-in/out to prevent clicks at boundaries
+        // Fade edges
         const fadeLength = Math.min(128, output.length / 20);
         for (let i = 0; i < fadeLength; i++) {
             const fade = i / fadeLength;
@@ -234,7 +201,7 @@ class MLNoiseSuppressor {
         return output;
     }
     /**
-     * Reset processing state (call when switching audio streams)
+     * Reset processing state
      */
     reset() {
         this.prevMask = null;

package/dist/audio/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Audio module exports
+ */
+export * from './AudioPipeline';
+export * from './AudioNodeFactory';
+export * from './MLNoiseSuppressor';

package/dist/audio/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Audio module exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AudioPipeline"), exports);
+__exportStar(require("./AudioNodeFactory"), exports);
+__exportStar(require("./MLNoiseSuppressor"), exports);

package/dist/channels/huddle/HuddleChannel.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Huddle Channel
+ *
+ * Manages private huddle conversations between participants
+ */
+import { Socket } from 'socket.io-client';
+import { HuddleAcceptResponse, HuddleRejectResponse, HuddleResponse } from './HuddleTypes';
+/**
+ * Huddle channel configuration
+ */
+export interface HuddleChannelConfig {
+    socket: Socket;
+    localParticipantId: string;
+    roomId: string;
+}
+/**
+ * Huddle Channel class
+ * Handles all huddle-related socket communication
+ */
+export declare class HuddleChannel {
+    private socket;
+    private localParticipantId;
+    private roomId;
+    private currentChannel;
+    constructor(config: HuddleChannelConfig);
+    /**
+     * Get current channel ID
+     */
+    getCurrentChannel(): string;
+    /**
+     * Set current channel (called when channel changes)
+     */
+    setCurrentChannel(channelId: string): void;
+    /**
+     * Check if currently in a huddle
+     */
+    isInHuddle(): boolean;
+    /**
+     * Send huddle invite to another participant
+     */
+    sendInvite(toParticipantId: string): Promise<{
+        success?: boolean;
+        inviteId?: string;
+        huddleId?: string;
+        error?: string;
+    }>;
+    /**
+     * Accept a huddle invite
+     */
+    acceptInvite(inviteId: string): Promise<HuddleAcceptResponse>;
+    /**
+     * Reject a huddle invite
+     */
+    rejectInvite(inviteId: string): Promise<HuddleRejectResponse>;
+    /**
+     * Join the global huddle channel
+     */
+    join(): Promise<{
+        success?: boolean;
+        channelId?: string;
+        error?: string;
+    }>;
+    /**
+     * Leave current huddle and return to spatial audio
+     */
+    leave(): Promise<{
+        success?: boolean;
+        channelId?: string;
+        error?: string;
+    }>;
+    /**
+     * Get a participant's current channel
+     */
+    getParticipantChannel(participantId: string): Promise<string>;
+    /**
+     * Request another participant to mute (owner only)
+     */
+    muteParticipant(participantId: string, requesterId: string): Promise<HuddleResponse>;
+    /**
+     * Update local participant ID (after reconnection)
+     */
+    updateLocalParticipantId(participantId: string): void;
+    /**
+     * Update room ID (after room change)
+     */
+    updateRoomId(roomId: string): void;
+}

package/dist/channels/huddle/HuddleChannel.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Huddle Channel
+ *
+ * Manages private huddle conversations between participants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HuddleChannel = void 0;
+const HuddleTypes_1 = require("./HuddleTypes");
+/**
+ * Huddle Channel class
+ * Handles all huddle-related socket communication
+ */
+class HuddleChannel {
+    constructor(config) {
+        this.currentChannel = HuddleTypes_1.SPATIAL_CHANNEL_ID;
+        this.socket = config.socket;
+        this.localParticipantId = config.localParticipantId;
+        this.roomId = config.roomId;
+    }
+    /**
+     * Get current channel ID
+     */
+    getCurrentChannel() {
+        return this.currentChannel;
+    }
+    /**
+     * Set current channel (called when channel changes)
+     */
+    setCurrentChannel(channelId) {
+        this.currentChannel = channelId;
+    }
+    /**
+     * Check if currently in a huddle
+     */
+    isInHuddle() {
+        return this.currentChannel !== HuddleTypes_1.SPATIAL_CHANNEL_ID;
+    }
+    /**
+     * Send huddle invite to another participant
+     */
+    async sendInvite(toParticipantId) {
+        return new Promise((resolve) => {
+            this.socket.emit('send-huddle-invite', {
+                fromParticipantId: this.localParticipantId,
+                toParticipantId,
+                roomId: this.roomId,
+            }, (response) => {
+                resolve(response);
+            });
+        });
+    }
+    /**
+     * Accept a huddle invite
+     */
+    async acceptInvite(inviteId) {
+        return new Promise((resolve) => {
+            this.socket.emit('accept-huddle-invite', {
+                inviteId,
+                participantId: this.localParticipantId,
+            }, (response) => {
+                if (response.success) {
+                    // Server may send huddleId OR channelId - handle both
+                    this.currentChannel = response.channelId || response.huddleId || 'odyssey-huddle';
+                }
+                resolve(response);
+            });
+        });
+    }
+    /**
+     * Reject a huddle invite
+     */
+    async rejectInvite(inviteId) {
+        return new Promise((resolve) => {
+            this.socket.emit('reject-huddle-invite', {
+                inviteId,
+                participantId: this.localParticipantId,
+            }, (response) => {
+                resolve(response);
+            });
+        });
+    }
+    /**
+     * Join the global huddle channel
+     */
+    async join() {
+        return new Promise((resolve) => {
+            this.socket.emit('join-huddle', {
+                participantId: this.localParticipantId,
+                roomId: this.roomId,
+            }, (response) => {
+                if (response.success && response.channelId) {
+                    this.currentChannel = response.channelId;
+                }
+                resolve(response);
+            });
+        });
+    }
+    /**
+     * Leave current huddle and return to spatial audio
+     */
+    async leave() {
+        return new Promise((resolve) => {
+            this.socket.emit('leave-huddle', {
+                participantId: this.localParticipantId,
+                roomId: this.roomId,
+            }, (response) => {
+                if (response.success) {
+                    this.currentChannel = response.channelId || HuddleTypes_1.SPATIAL_CHANNEL_ID;
+                }
+                resolve(response);
+            });
+        });
+    }
+    /**
+     * Get a participant's current channel
+     */
+    async getParticipantChannel(participantId) {
+        return new Promise((resolve) => {
+            this.socket.emit('get-participant-channel', { participantId }, (response) => {
+                resolve(response.channelId || HuddleTypes_1.SPATIAL_CHANNEL_ID);
+            });
+        });
+    }
+    /**
+     * Request another participant to mute (owner only)
+     */
+    async muteParticipant(participantId, requesterId) {
+        return new Promise((resolve) => {
+            this.socket.emit('mute-participant', {
+                targetParticipantId: participantId,
+                roomId: this.roomId,
+                requesterId,
+            }, (response) => {
+                resolve(response);
+            });
+        });
+    }
+    /**
+     * Update local participant ID (after reconnection)
+     */
+    updateLocalParticipantId(participantId) {
+        this.localParticipantId = participantId;
+    }
+    /**
+     * Update room ID (after room change)
+     */
+    updateRoomId(roomId) {
+        this.roomId = roomId;
+    }
+}
+exports.HuddleChannel = HuddleChannel;

package/dist/channels/huddle/HuddleTypes.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Huddle Types
+ *
+ * Type definitions for huddle (private conversation) functionality
+ */
+/**
+ * Spatial channel ID constant
+ */
+export declare const SPATIAL_CHANNEL_ID = "spatial";
+/**
+ * Huddle channel ID prefix
+ */
+export declare const HUDDLE_CHANNEL_PREFIX = "odyssey-huddle";
+/**
+ * Check if a channel ID is a huddle channel
+ */
+export declare function isHuddleChannel(channelId?: string): boolean;
+/**
+ * Huddle invite data
+ */
+export interface HuddleInvite {
+    inviteId: string;
+    fromParticipantId: string;
+    toParticipantId: string;
+    roomId: string;
+    huddleId?: string;
+    timestamp: number;
+    fromUserName?: string;
+}
+/**
+ * Huddle response data
+ */
+export interface HuddleResponse {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Huddle accept response
+ */
+export interface HuddleAcceptResponse extends HuddleResponse {
+    huddleId?: string;
+    channelId?: string;
+    participants?: string[];
+}
+/**
+ * Huddle reject response
+ */
+export interface HuddleRejectResponse extends HuddleResponse {
+    inviteId?: string;
+}
+/**
+ * Huddle started event data
+ */
+export interface HuddleStartedEvent {
+    huddleId: string;
+    channelId: string;
+    participants: string[];
+    initiatorId: string;
+}
+/**
+ * Huddle updated event data
+ */
+export interface HuddleUpdatedEvent {
+    huddleId: string;
+    channelId: string;
+    participants: string[];
+    action: 'joined' | 'left';
+    participantId: string;
+}
+/**
+ * Huddle ended event data
+ */
+export interface HuddleEndedEvent {
+    huddleId: string;
+    channelId: string;
+    reason: 'all_left' | 'timeout' | 'forced';
+}
+/**
+ * Participant channel changed event data
+ */
+export interface ParticipantChannelChangedEvent {
+    participantId: string;
+    channelId: string;
+    previousChannel?: string;
+}

package/dist/channels/huddle/HuddleTypes.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Huddle Types
+ *
+ * Type definitions for huddle (private conversation) functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUDDLE_CHANNEL_PREFIX = exports.SPATIAL_CHANNEL_ID = void 0;
+exports.isHuddleChannel = isHuddleChannel;
+/**
+ * Spatial channel ID constant
+ */
+exports.SPATIAL_CHANNEL_ID = 'spatial';
+/**
+ * Huddle channel ID prefix
+ */
+exports.HUDDLE_CHANNEL_PREFIX = 'odyssey-huddle';
+/**
+ * Check if a channel ID is a huddle channel
+ */
+function isHuddleChannel(channelId) {
+    if (!channelId)
+        return false;
+    return channelId !== exports.SPATIAL_CHANNEL_ID && channelId.includes('huddle');
+}

package/dist/channels/huddle/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Huddle module - Re-exports huddle channel functionality
+ */
+export * from './HuddleTypes';
+export * from './HuddleChannel';

package/dist/channels/huddle/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Huddle module - Re-exports huddle channel functionality
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HuddleTypes"), exports);
+__exportStar(require("./HuddleChannel"), exports);

package/dist/channels/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Channels module - Re-exports all channel functionality
+ */
+export * from './huddle';
+export * from './spatial';

package/dist/channels/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Channels module - Re-exports all channel functionality
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./huddle"), exports);
+__exportStar(require("./spatial"), exports);