vantiv.io 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vantiv.io",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Enterprise WebSocket infrastructure for Highrise featuring spatial intelligence systems, memory-optimized architecture, and production-grade reliability for scalable application development",
   "keywords": [
     "highrise",

package/src/classes/Actions/Inventory.js

@@ -1,4 +1,4 @@
-const { payment_methods, default_skin } = require("highrise-core/src/constants/TypesConstants");
+const { payment_methods, default_skin } = require("vantiv.io/src/constants/TypesConstants");
 
 class InventoryClass {
     constructor(bot) {

package/src/classes/Actions/Music.js

@@ -33,7 +33,7 @@ class MusicClass extends EventEmitter {
     initializeStreamer() {
         try {
             this.streamer = new IcecastStreamer(this.config.icecast);
-            this.queue = new IcecastQueue(this.streamer, this.config.queue);
+            this.queue = new IcecastQueue(this.streamer, { ...this.config.queue, ...this.config.icecast});
             
             this.streamer.on('playbackStart', (track) => {
                 this.emit('playbackStart', track);

package/src/classes/Actions/Utils.js

@@ -1,7 +1,7 @@
-const PermissionManager = require("highrise-core/src/classes/Managers/PermissionManager");
-const CooldownManager = require("highrise-core/src/classes/Managers/Networking/CooldownManager");
-const DanceFloor = require("highrise-core/src/classes/Managers/DanceFloorManagers");
-const { Logger } = require("highrise-core/src/classes/Managers/Helpers/LoggerManager")
+const PermissionManager = require("vantiv.io/src/classes/Managers/PermissionManager");
+const CooldownManager = require("vantiv.io/src/classes/Managers/Networking/CooldownManager");
+const DanceFloor = require("vantiv.io/src/classes/Managers/DanceFloorManagers");
+const { Logger } = require("vantiv.io/src/classes/Managers/Helpers/LoggerManager")
 
 class Utils {
     constructor(bot, options) {

package/src/classes/Actions/lib/AudioStreaming.js

@@ -10,22 +10,25 @@ class IcecastStreamer extends EventEmitter {
             port: config.port || 8000,
             mount: config.mount || '/stream',
             sourcePassword: config.sourcePassword || 'hackme',
+            fallbackUrl: config.fallbackUrl || '',
+            fallbackEnabled: config.fallbackEnabled || false,
             audioFormat: config.audioFormat || 'mp3',
             audioBitrate: config.audioBitrate || '192k',
             audioSampleRate: config.audioSampleRate || 48000,
             audioChannels: config.audioChannels || 2,
             contentType: config.contentType || 'audio/mpeg'
         };
-        
+
         this.ffmpegProcess = null;
-        this.isStreaming = false;
+        this.fallbackProcess = null;
+        this.isStreaming = false; // Only for actual music
+        this.isFallbackActive = false; // Separate flag for fallback
         this.currentTrack = null;
-        
+
         this.icecastUrl = `icecast://source:${this.config.sourcePassword}@${this.config.server}:${this.config.port}${this.config.mount}`;
         this.publicStreamUrl = `http://${this.config.server}:${this.config.port}${this.config.mount}`;
-        
     }
-    
+
     getFFmpegArgs(url) {
         return [
             '-re',
@@ -39,17 +42,34 @@ class IcecastStreamer extends EventEmitter {
             this.icecastUrl
         ];
     }
-    
+
+    getFallbackFFmpegArgs() {
+        return [
+            '-re',
+            '-i', this.config.fallbackUrl,
+            '-f', this.config.audioFormat,
+            '-content_type', this.config.contentType,
+            '-vn',
+            '-ar', this.config.audioSampleRate.toString(),
+            '-ac', this.config.audioChannels.toString(),
+            '-b:a', this.config.audioBitrate,
+            this.icecastUrl
+        ];
+    }
+
     async streamToIcecast(url, metadata = {}) {
+        if (this.isFallbackActive) {
+            this.stopFallback();
+            await this.delay(200);
+        }
+
         if (this.ffmpegProcess) {
             this.stop();
             await this.delay(200);
         }
-        
+
         return new Promise((resolve, reject) => {
-            console.log(`Starting Icecast stream for: ${metadata.title || 'Unknown track'}`);
-            
-            this.currentTrack = {
+            this.currentTrack = new Track({
                 url,
                 title: metadata.title || 'Unknown Track',
                 duration: metadata.duration || 0,
@@ -58,16 +78,17 @@ class IcecastStreamer extends EventEmitter {
                 thumbnail: metadata.thumbnail,
                 source: metadata.source || 'stream',
                 startedAt: Date.now()
-            };
-            
+            });
+
             this.isStreaming = true;
-            
+            this.isFallbackActive = false;
+
             const args = this.getFFmpegArgs(url);
             this.ffmpegProcess = spawn('ffmpeg', args);
-            
+
             this.ffmpegProcess.stderr.on('data', (data) => {
                 const message = data.toString();
-                
+
                 const durationMatch = message.match(/Duration: (\d+):(\d+):(\d+\.\d+)/);
                 if (durationMatch) {
                     const hours = parseInt(durationMatch[1]);
@@ -75,46 +96,44 @@ class IcecastStreamer extends EventEmitter {
                     const seconds = parseFloat(durationMatch[3]);
                     this.currentTrack.duration = hours * 3600 + minutes * 60 + seconds;
                 }
-                
+
                 const timeMatch = message.match(/time=(\d+):(\d+):(\d+\.\d+)/);
                 if (timeMatch) {
                     const hours = parseInt(timeMatch[1]);
                     const minutes = parseInt(timeMatch[2]);
                     const seconds = parseFloat(timeMatch[3]);
                     this.currentTrack.position = hours * 3600 + minutes * 60 + seconds;
-                    
+
                     this.emit('progress', {
                         position: this.currentTrack.position,
                         duration: this.currentTrack.duration,
-                        progress: this.currentTrack.duration > 0 ? 
+                        progress: this.currentTrack.duration > 0 ?
                             (this.currentTrack.position / this.currentTrack.duration) * 100 : 0
                     });
                 }
-                
+
                 if (message.includes('Stream mapping') || message.includes('Output')) {
-                    console.log('Icecast stream started successfully');
                     this.emit('playbackStart', this.currentTrack);
                     resolve();
                 }
-                
+
                 if (message.includes('Error') || message.includes('Failed')) {
                     console.error('FFmpeg error:', message.trim());
                     this.emit('error', new Error(message.trim()));
                 }
             });
-            
+
             this.ffmpegProcess.on('close', (code) => {
-                console.log(`Icecast stream ended with code ${code}`);
                 const endedTrack = this.currentTrack;
-                
+
                 this.isStreaming = false;
                 this.currentTrack = null;
                 this.ffmpegProcess = null;
-                
+
                 this.emit('playbackEnd', endedTrack);
                 this.emit('streamEnd', { code, track: endedTrack });
             });
-            
+
             this.ffmpegProcess.on('error', (err) => {
                 console.error('FFmpeg process error:', err);
                 this.isStreaming = false;
@@ -124,26 +143,96 @@ class IcecastStreamer extends EventEmitter {
             });
         });
     }
-    
+
+    startFallback() {
+        if (!this.config.fallbackUrl || this.isFallbackActive || this.isStreaming) {
+            return false;
+        }
+        
+        if (this.ffmpegProcess) {
+            this.ffmpegProcess.kill('SIGKILL');
+            this.ffmpegProcess = null;
+        }
+
+        const args = this.getFallbackFFmpegArgs();
+        this.fallbackProcess = spawn('ffmpeg', args);
+        
+        this.isFallbackActive = true;
+        this.isStreaming = false;
+        
+        this.currentTrack = new Track({
+            url: this.config.fallbackUrl,
+            title: 'Fallback Music',
+            duration: 0,
+            requester: 'System',
+            requesterId: 'system',
+            source: 'fallback',
+            startedAt: Date.now(),
+            isFallback: true
+        });
+
+        this.fallbackProcess.stderr.on('data', (data) => {
+            const message = data.toString();
+            
+            if (message.includes('Stream mapping') || message.includes('Output')) {
+                this.emit('fallbackStart', this.currentTrack);
+            }
+            
+            if (message.includes('Error') || message.includes('Failed')) {
+                console.error('Fallback FFmpeg error:', message.trim());
+            }
+        });
+
+        this.fallbackProcess.on('close', (code) => {
+            this.isFallbackActive = false;
+            this.currentTrack = null;
+            this.fallbackProcess = null;
+            
+            this.emit('fallbackEnd', { code });
+        });
+
+        this.fallbackProcess.on('error', (err) => {
+            console.error('Fallback FFmpeg process error:', err);
+            this.isFallbackActive = false;
+            this.currentTrack = null;
+        });
+
+        return true;
+    }
+
+    stopFallback() {
+        if (this.fallbackProcess) {
+            this.fallbackProcess.kill('SIGKILL');
+            this.fallbackProcess = null;
+            this.isFallbackActive = false;
+            this.currentTrack = null;
+            this.emit('fallbackStopped');
+            return true;
+        }
+        return false;
+    }
+
     stop() {
         if (this.ffmpegProcess) {
-            console.log('Stopping Icecast stream...');
             this.ffmpegProcess.kill('SIGKILL');
             this.ffmpegProcess = null;
             this.isStreaming = false;
             this.emit('streamStopped');
         }
+        
+        this.stopFallback();
     }
-    
+
     getStatus() {
         return {
             isStreaming: this.isStreaming,
+            isFallbackActive: this.isFallbackActive,
             currentTrack: this.currentTrack,
             config: this.config,
             publicStreamUrl: this.publicStreamUrl
         };
     }
-    
+
     getNowPlaying() {
         if (!this.currentTrack) return null;
 
@@ -151,15 +240,15 @@ class IcecastStreamer extends EventEmitter {
             track: this.currentTrack,
             position: this.currentTrack.position || 0,
             duration: this.currentTrack.duration || 0,
-            progress: this.currentTrack.duration > 0 ? 
+            progress: this.currentTrack.duration > 0 ?
                 ((this.currentTrack.position || 0) / this.currentTrack.duration) * 100 : 0,
-            remaining: this.currentTrack.duration > 0 ? 
+            remaining: this.currentTrack.duration > 0 ?
                 this.currentTrack.duration - (this.currentTrack.position || 0) : 0,
-            elapsed: this.currentTrack.startedAt ? 
+            elapsed: this.currentTrack.startedAt ?
                 Math.floor((Date.now() - this.currentTrack.startedAt) / 1000) : 0
         };
     }
-    
+
     updateConfig(newConfig) {
         this.config = { ...this.config, ...newConfig };
         this.icecastUrl = `icecast://source:${this.config.sourcePassword}@${this.config.server}:${this.config.port}${this.config.mount}`;
@@ -167,7 +256,7 @@ class IcecastStreamer extends EventEmitter {
         console.log('Icecast config updated');
         return this.config;
     }
-    
+
     async delay(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
@@ -184,6 +273,7 @@ class Track {
         this.addedAt = Date.now();
         this.thumbnail = data.thumbnail;
         this.source = data.source;
+        this.isFallback = data.isFallback || false;
     }
 
     getFormattedDuration() {
@@ -211,34 +301,65 @@ class IcecastQueue {
         this.maxHistory = config.maxHistory || 50;
         this.skipRequested = false;
         
+        this.fallbackEnabled = config.fallbackEnabled || false;
+        this.fallbackUrl = config.fallbackUrl || '';
+
         this.setupEventListeners();
+        
+        this.checkAndStartFallback();
     }
-    
+
     setupEventListeners() {
         this.streamer.on('playbackEnd', (track) => {
-            if (track) {
+            if (track && !track.isFallback) {
                 this.addToHistory(track, true);
             }
-            
+
             if (this.skipRequested) {
                 this.skipRequested = false;
                 return;
             }
-            
-            if (this.loopMode === 'track' && track) {
+
+            if (this.loopMode === 'track' && track && !track.isFallback) {
                 this.queue.unshift(new Track({ ...track }));
-            } else if (this.loopMode === 'queue' && track) {
+            } else if (this.loopMode === 'queue' && track && !track.isFallback) {
                 this.queue.push(new Track({ ...track }));
             }
-            
+
             setTimeout(() => this.playNext(), 300);
         });
-        
+
         this.streamer.on('playbackStart', (track) => {
             this.currentTrack = track;
         });
+        
+        this.streamer.on('fallbackStart', (track) => {
+            this.currentTrack = track;
+        });
+        
+        this.streamer.on('fallbackEnd', () => {
+            this.currentTrack = null;
+            this.checkAndStartFallback();
+        });
     }
     
+    checkAndStartFallback() {
+        if (this.queue.length === 0 && 
+            !this.streamer.isStreaming &&
+            !this.streamer.isFallbackActive &&
+            this.fallbackEnabled && 
+            this.fallbackUrl) {
+            
+            setTimeout(() => {
+                if (this.queue.length === 0 && 
+                    !this.streamer.isStreaming && 
+                    !this.streamer.isFallbackActive) {
+                    this.streamer.startFallback();
+                }
+            }, 1000);
+        }
+    }
+
     async add(track) {
         const isNewTrack = !this.queue.some(q => q.id === track.id);
         if (!isNewTrack) {
@@ -255,34 +376,42 @@ class IcecastQueue {
 
         return { position, added: true, isNowPlaying: false };
     }
-    
+
     async addImmediate(track) {
-        if (this.currentTrack) {
+        if (this.currentTrack && !this.currentTrack.isFallback) {
             this.queue.unshift(new Track({ ...this.currentTrack }));
         }
-        
+
         this.queue.unshift(track);
         await this.skip();
         return { position: 1, added: true, isNowPlaying: true };
     }
-    
+
     async playNext() {
-        if (this.isProcessing || this.queue.length === 0) {
+        if (this.isProcessing) {
             return false;
         }
-        
+
         this.isProcessing = true;
-        
+
         try {
+            if (this.streamer.isFallbackActive) {
+                this.streamer.stopFallback();
+                await this.delay(200);
+            }
+
+            if (this.queue.length === 0) {
+                this.checkAndStartFallback();
+                return false;
+            }
+
             const nextTrack = this.queue.shift();
-            
+
             if (!nextTrack?.url) {
                 setTimeout(() => this.playNext(), 1000);
                 return false;
             }
-            
-            console.log(`🎵 Playing on Icecast: ${nextTrack.title}`);
-            
+
             await this.streamer.streamToIcecast(nextTrack.url, {
                 title: nextTrack.title,
                 duration: nextTrack.duration,
@@ -291,32 +420,31 @@ class IcecastQueue {
                 thumbnail: nextTrack.thumbnail,
                 source: nextTrack.source
             });
-            
+
             return true;
         } catch (error) {
             console.error('Error playing next track:', error);
-            // Retry with next track
             setTimeout(() => this.playNext(), 1000);
             return false;
         } finally {
             this.isProcessing = false;
         }
     }
-    
+
     async skip() {
-        if (!this.streamer.isStreaming) {
+        if (!this.streamer.isStreaming && this.streamer.isFallbackActive) {
             return false;
         }
-        
+
         this.skipRequested = true;
         this.streamer.stop();
-        
+
         await this.delay(100);
         await this.playNext();
-        
+
         return true;
     }
-    
+
     remove(position) {
         if (position < 1 || position > this.queue.length) {
             return null;
@@ -324,14 +452,19 @@ class IcecastQueue {
 
         return this.queue.splice(position - 1, 1)[0];
     }
-    
+
     clear() {
         const cleared = [...this.queue];
         this.queue = [];
+        
+        this.checkAndStartFallback();
+        
         return cleared;
     }
-    
+
     addToHistory(track, success = true) {
+        if (track.isFallback) return;
+        
         const historyEntry = {
             ...track,
             playedAt: Date.now(),
@@ -345,14 +478,16 @@ class IcecastQueue {
             this.history.pop();
         }
     }
-    
+
     getQueue() {
         return [...this.queue];
     }
-    
+
     getStatus() {
         return {
-            isPlaying: this.streamer.isStreaming,
+            isPlaying: this.streamer.isStreaming || this.streamer.isFallbackActive,
+            isMusicPlaying: this.streamer.isStreaming,
+            isFallbackActive: this.streamer.isFallbackActive,
             currentTrack: this.currentTrack,
             queueLength: this.queue.length,
             loopMode: this.loopMode,
@@ -360,10 +495,21 @@ class IcecastQueue {
             upcoming: this.queue.slice(0, 10)
         };
     }
-    
+
     async delay(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
+    
+    startFallback() {
+        if (this.fallbackEnabled && this.fallbackUrl) {
+            return this.streamer.startFallback();
+        }
+        return false;
+    }
+    
+    stopFallback() {
+        return this.streamer.stopFallback();
+    }
 }
 
 class YouTubeExtractor {
@@ -421,15 +567,15 @@ class IcecastServer {
         this.logger = config.logger
         this.setupExpress();
     }
-    
+
     setupExpress() {
         this.app.use(express.json());
-        
+
         this.app.get('/stream', (req, res) => {
             res.redirect(this.config.publicStreamUrl);
         });
     }
-    
+
     start() {
         this.app.listen(this.port, () => {
             this.logger.success(`IcecastServer.start`, `running: http://localhost:${this.port}`);

package/src/classes/Handlers/EventHandlers.js

@@ -1,5 +1,5 @@
-const ModelPool = require("highrise-core/src/utils/ModelPool");
-const { User, Position, Message, AnchorPosition, SessionMetadata, Voice, Direct, HiddenChannel, Tip, RoomModerate } = require('highrise-core/src/utils/Models')
+const ModelPool = require("vantiv.io/src/utils/ModelPool");
+const { User, Position, Message, AnchorPosition, SessionMetadata, Voice, Direct, HiddenChannel, Tip, RoomModerate } = require('vantiv.io/src/utils/Models')
 
 const modelPool = new ModelPool()
 

package/src/classes/Handlers/WebSocketHandlers.js

@@ -1,4 +1,4 @@
-const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants');
 
 class WebSocketHandlers {
     constructor(server) {

package/src/classes/Managers/Helpers/MetricsManager.js

@@ -1,4 +1,4 @@
-const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants');
 
 class MetricsManager {
     constructor() {

package/src/classes/Managers/Networking/ConnectionManager.js

@@ -1,4 +1,4 @@
-const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants');
 const EventEmitter = require('events');
 const WebSocket = require('ws');
 
@@ -109,37 +109,10 @@ class ConnectionManager extends EventEmitter {
         this.reconnecting = false;
 
         if (this.autoReconnect && !this.isManualDisconnect && !wasReconnecting) {
-            const shouldReconnect = this._shouldReconnect(code, reasonStr);
-            
-            if (shouldReconnect) {
-                this._scheduleReconnect();
-            } else {
-                this.logger.warn('ConnectionManager', 'Not reconnecting due to close code or reason', {
-                    code,
-                    reason: reasonStr
-                });
-            }
+            this._scheduleReconnect();
         }
     }
 
-    _shouldReconnect(code, reason) {
-        if (code === 1000 && reason.includes('Manual disconnect')) {
-            return false;
-        }
-        
-        if (code === 4001 || code === 4003 || code === 4004) {
-            this.logger.error('ConnectionManager', 'Authentication failed, not reconnecting', { code, reason });
-            return false;
-        }
-        
-        if (code === 4009 || code === 4029) {
-            this.logger.error('ConnectionManager', 'Rate limited or banned, not reconnecting', { code, reason });
-            return false;
-        }
-        
-        return true;
-    }
-
     _handleError(error) {
         this.emit('error', error);
         this.logger.error('ConnectionManager', 'WebSocket error', {
@@ -162,19 +135,6 @@ class ConnectionManager extends EventEmitter {
             return;
         }
 
-        const maxAttempts = WebSocketConstants.MAX_RECONNECT_ATTEMPTS || 10;
-        if (this.reconnectAttempts >= maxAttempts) {
-            this.logger.error('ConnectionManager', 'Max reconnection attempts reached', {
-                attempts: this.reconnectAttempts,
-                maxAttempts
-            });
-            this.emit('reconnectFailed', {
-                attempts: this.reconnectAttempts,
-                maxAttempts
-            });
-            return;
-        }
-
         this._clearReconnectTimeout();
 
         const delay = Math.min(

package/src/classes/Managers/Networking/EventsManager.js

@@ -9,7 +9,7 @@ const {
     RoomModerateHandler,
     HiddenChannelHandler,
     SessionMetadataHandler,
-} = require('highrise-core/src/classes/Handlers/EventHandlers');
+} = require('vantiv.io/src/classes/Handlers/EventHandlers');
 
 class EventsManager {
     constructor(server) {

package/src/classes/Managers/Networking/KeepAliveManager.js

@@ -1,4 +1,4 @@
-const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants');
+const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants');
 const crypto = require('crypto');
 
 class KeepAliveManager {
@@ -7,18 +7,11 @@ class KeepAliveManager {
         this.logger = logger;
         
         this.interval = null;
-        this.lastKeepaliveSent = 0;
-        this.lastPongReceived = 0;
-        this.consecutiveNoPong = 0;
-        this.maxConsecutiveNoPong = 3;
-        this.firstKeepaliveSent = false;
     }
     
     start() {
         this.stop();
         
-        this.firstKeepaliveSent = false;
-        
         this._sendKeepAlive();
         
         this.interval = setInterval(() => {
@@ -33,13 +26,11 @@ class KeepAliveManager {
             clearInterval(this.interval);
             this.interval = null;
         }
-        this.consecutiveNoPong = 0;
-        this.firstKeepaliveSent = false;
     }
     
     _sendKeepAlive() {
         if (!this.connectionManager.isConnected()) {
-            this.logger.debug('KeepAliveManager', 'Skipping keepalive');
+            this.logger.debug('KeepAliveManager', 'Skipping keepalive - not connected');
             return;
         }
         
@@ -50,13 +41,6 @@ class KeepAliveManager {
             };
             
             this.connectionManager.send(keepalive);
-            this.lastKeepaliveSent = Date.now();
-            
-            if (!this.firstKeepaliveSent) {
-                this.firstKeepaliveSent = true;
-                this.lastPongReceived = Date.now();
-                return;
-            }
             
         } catch (error) {
             this.logger.error('KeepAliveManager', 'Failed to send keepalive', {
@@ -65,41 +49,6 @@ class KeepAliveManager {
         }
     }
     
-    _forceReconnect() {
-        if (this.connectionManager.isConnected()) {
-            this.connectionManager.disconnect(
-                WebSocketConstants.ERROR_CODES.ABNORMAL_CLOSURE,
-                'Keepalive timeout'
-            );
-        }
-        this.consecutiveNoPong = 0;
-    }
-    
-    handlePong() {
-        this.lastPongReceived = Date.now();
-        this.consecutiveNoPong = 0;
-        
-        const latency = this.lastPongReceived - this.lastKeepaliveSent;
-        if (latency > 10000) {
-            this.logger.warn('KeepAliveManager', `High latency: ${latency}ms`);
-        }
-    }
-    
-    getStats() {
-        const timeSinceLastPong = Date.now() - this.lastPongReceived;
-        const timeSinceLastKeepalive = Date.now() - this.lastKeepaliveSent;
-        
-        return {
-            isActive: this.interval !== null,
-            lastKeepaliveSent: this.lastKeepaliveSent,
-            lastPongReceived: this.lastPongReceived,
-            timeSinceLastPong: timeSinceLastPong,
-            timeSinceLastKeepalive: timeSinceLastKeepalive,
-            consecutiveNoPong: this.consecutiveNoPong,
-            healthStatus: this.firstKeepaliveSent ? (timeSinceLastPong < 45000 ? 'healthy' : 'degraded') : 'initializing'
-        };
-    }
-    
     forceKeepAlive() {
         this._sendKeepAlive();
         this.logger.info('KeepAliveManager', 'Manual keepalive sent');

package/src/classes/Managers/Networking/Request.js

@@ -1,4 +1,4 @@
-const WebSocketConstants = require("highrise-core/src/constants/WebSocketConstants");
+const WebSocketConstants = require("vantiv.io/src/constants/WebSocketConstants");
 
 class FireAndForgetSender {
     constructor(websocket) {

package/src/constants/WebSocketConstants.js

@@ -2,11 +2,10 @@ const WebSocketConstants = {
     // Connection
     KEEPALIVE_INTERVAL: 15000,
     MAX_RECONNECT_DELAY: 300000, // 5 minutes
-    RECONNECT_BACKOFF_FACTOR: 1.5,
+    RECONNECT_BACKOFF_FACTOR: 1.1,
     DEFAULT_RECONNECT_DELAY: 5000,
     DEFAULT_AUTO_RECONNECT: true,
     MAX_RECONNECT_ATTEMPTS: 10,
-    RECONNECT_BACKOFF_FACTOR: 1.5,
 
     // Logger Options
     DEFAULT_LOGGER_OPTIONS: {

package/src/core/Highrise.js

@@ -1,8 +1,8 @@
-const HighriseWebsocket = require('highrise-core/src/core/HighriseWebsocket');
-const { ConfigValidator } = require('highrise-core/src/validators/ConfigValidator');
-const { checkVersion } = require('highrise-core/src/utils/versionCheck');
-const WebSocketConstants = require('highrise-core/src/constants/WebSocketConstants')
-const Utils = require('highrise-core/src/classes/Actions/Utils');
+const HighriseWebsocket = require('vantiv.io/src/core/HighriseWebsocket');
+const { ConfigValidator } = require('vantiv.io/src/validators/ConfigValidator');
+const { checkVersion } = require('vantiv.io/src/utils/versionCheck');
+const WebSocketConstants = require('vantiv.io/src/constants/WebSocketConstants')
+const Utils = require('vantiv.io/src/classes/Actions/Utils');
 
 class Highrise extends HighriseWebsocket {
     constructor(events, userOptions = {}) {
@@ -35,9 +35,9 @@ class Highrise extends HighriseWebsocket {
                 ? userOptions.customRoles
                 : [],
 
-            music: {
-                enabled: userOptions.music.enabled || false,
-            }
+            music: userOptions.music !== undefined
+            ? userOptions.music
+            : {}
         };
 
         const eventsValidation = ConfigValidator.validateEvents(events);

package/src/core/HighriseWebsocket.js

@@ -1,22 +1,22 @@
 const EventEmitter = require('events');
 
-const ConnectionManager = require('highrise-core/src/classes/Managers/Networking/ConnectionManager');
-const KeepAliveManager = require('highrise-core/src/classes/Managers/Networking/KeepAliveManager');
-const MessageHandler = require('highrise-core/src/classes/Managers/Networking/MessageHandler');
-const EventsManager = require('highrise-core/src/classes/Managers/Networking/EventsManager');
-const { FireAndForgetSender, RequestResponseSender } = require('highrise-core/src/classes/Managers/Networking/Request');
-
-const MetricsManager = require('highrise-core/src/classes/Managers/Helpers/MetricsManager');
-const CleanupManager = require('highrise-core/src/classes/Managers/Helpers/CleanupManager');
-
-const ChannelManager = require('highrise-core/src/classes/Managers/ChannelManager');
-const ConnectionValidator = require('highrise-core/src/validators/ConnectionValidator');
-const WebSocketHandlers = require('highrise-core/src/classes/Handlers/WebSocketHandlers');
-
-const { DirectClass } = require('highrise-core/src/classes/Actions/Direct');
-const { MovementCache } = require('highrise-core/src/classes/Caches/MovementCache');
-const AwaitClass = require('highrise-core/src/classes/Actions/Awaiter');
-const { Logger } = require('highrise-core/src/classes/Managers/Helpers/LoggerManager');
+const ConnectionManager = require('vantiv.io/src/classes/Managers/Networking/ConnectionManager');
+const KeepAliveManager = require('vantiv.io/src/classes/Managers/Networking/KeepAliveManager');
+const MessageHandler = require('vantiv.io/src/classes/Managers/Networking/MessageHandler');
+const EventsManager = require('vantiv.io/src/classes/Managers/Networking/EventsManager');
+const { FireAndForgetSender, RequestResponseSender } = require('vantiv.io/src/classes/Managers/Networking/Request');
+
+const MetricsManager = require('vantiv.io/src/classes/Managers/Helpers/MetricsManager');
+const CleanupManager = require('vantiv.io/src/classes/Managers/Helpers/CleanupManager');
+
+const ChannelManager = require('vantiv.io/src/classes/Managers/ChannelManager');
+const ConnectionValidator = require('vantiv.io/src/validators/ConnectionValidator');
+const WebSocketHandlers = require('vantiv.io/src/classes/Handlers/WebSocketHandlers');
+
+const { DirectClass } = require('vantiv.io/src/classes/Actions/Direct');
+const { MovementCache } = require('vantiv.io/src/classes/Caches/MovementCache');
+const AwaitClass = require('vantiv.io/src/classes/Actions/Awaiter');
+const { Logger } = require('vantiv.io/src/classes/Managers/Helpers/LoggerManager');
 
 class HighriseWebsocket extends EventEmitter {
     constructor(events, options = {}) {