fix: Resolve listener playback initialization loop │

│                                                                                                                                        │
│   - Add duplicate command prevention for loadVideoById to stop repeated queueing                                                       │
│   - Update player state when loading videos to track current video properly                                                            │
│   - Fix heartbeat sync logic to only sync when video actually changes                                                                  │
│   - Skip sync operations while player is still initializing                                                                            │
│   - Add 3-second timeout for duplicate load command detection                                                                          │
│   - Ensure video state comparison only happens when heartbeat contains video ID                                                        │
│                                                                                                                                        │
│   This fixes the issue where listeners would get stuck in endless loadVideoById                                                        │
│   loops preventing them from joining playback properly.

Author: journeyjt

src/main.ts

@@ -193,6 +193,9 @@ Hooks.once('ready', async () => {
   const savedQueuesManager = new SavedQueuesManager(store, queueManager);
   logger.info('YouTube DJ SavedQueuesManager initialized globally');
 
+  // Connect QueueManager to SavedQueuesManager for queue modification tracking
+  queueManager.setSavedQueuesManager(savedQueuesManager);
+  
   // Store global references for access across components
   (globalThis as any).youtubeDJSocketManager = socketManager;
   (globalThis as any).youtubeDJSessionManager = sessionManager;

src/services/PlayerManager.ts

@@ -775,11 +775,18 @@ export class PlayerManager {
       return; // DJ doesn't sync to their own heartbeat
     }
 
+    // Skip sync if player is still initializing
+    const playerState = this.store.getPlayerState();
+    if (playerState.isInitializing) {
+      logger.debug('🎵 YouTube DJ | Skipping heartbeat sync - player still initializing');
+      return;
+    }
+
     // Only sync if we have a different video or significant time difference
-    const currentVideo = this.store.getPlayerState().currentVideo;
+    const currentVideo = playerState.currentVideo;
 
-    // Check if video changed
-    if (currentVideo?.videoId !== heartbeat.videoId) {
+    // Check if video changed (only if heartbeat has a video)
+    if (heartbeat.videoId && currentVideo?.videoId !== heartbeat.videoId) {
       logger.debug('🎵 YouTube DJ | Syncing to new video from heartbeat:', heartbeat.videoId);
       // Send load command to widget
       Hooks.callAll('youtubeDJ.playerCommand', { 

src/services/QueueManager.ts

@@ -16,6 +16,7 @@ export interface YouTubeDJMessage {
 
 export class QueueManager {
   private store: SessionStore;
+  private savedQueuesManager?: any; // Will be set after initialization
 
   constructor(store: SessionStore) {
     this.store = store;
@@ -36,6 +37,22 @@ export class QueueManager {
     Hooks.on('youtubeDJ.playlistEmbedError', this.onPlaylistEmbedError.bind(this));
   }
 
+  /**
+   * Set reference to SavedQueuesManager (called after initialization)
+   */
+  setSavedQueuesManager(savedQueuesManager: any): void {
+    this.savedQueuesManager = savedQueuesManager;
+  }
+
+  /**
+   * Mark queue as modified if there's a currently loaded saved queue
+   */
+  private markQueueAsModified(): void {
+    if (this.savedQueuesManager) {
+      this.savedQueuesManager.markQueueAsModified();
+    }
+  }
+
   /**
    * Check if user can add videos to queue
    */
@@ -215,6 +232,9 @@ export class QueueManager {
       }
     });
 
+    // Mark queue as modified if there's a loaded saved queue
+    this.markQueueAsModified();
+
     // Broadcast queue update
     this.broadcastMessage({
       type: 'QUEUE_ADD',
@@ -279,6 +299,9 @@ export class QueueManager {
       }
     });
 
+    // Mark queue as modified if there's a loaded saved queue
+    this.markQueueAsModified();
+
     // Broadcast queue update
     this.broadcastMessage({
       type: 'QUEUE_REMOVE',
@@ -338,6 +361,9 @@ export class QueueManager {
       }
     });
 
+    // Mark queue as modified if there's a loaded saved queue
+    this.markQueueAsModified();
+
     // Broadcast queue update
     this.broadcastMessage({
       type: 'QUEUE_UPDATE',
@@ -611,7 +637,10 @@ export class QueueManager {
         items: [],
         currentIndex: -1,
         mode: 'single-dj',
-        djUserId: this.store.getSessionState().djUserId
+        djUserId: this.store.getSessionState().djUserId,
+        savedQueues: this.store.getQueueState().savedQueues,
+        currentlyLoadedQueueId: null, // Clear loaded queue tracking
+        isModifiedFromSaved: false
       },
       player: {
         ...this.store.getPlayerState(),

src/services/SavedQueuesManager.ts

@@ -115,6 +115,15 @@ export class SavedQueuesManager {
     // Save to world settings
     await game.settings.set('core', 'youtubeDJ.savedQueues', updatedQueues);
 
+    // Update queue state to track this as the currently loaded queue
+    this.store.updateState({
+      queue: {
+        ...currentQueue,
+        currentlyLoadedQueueId: savedQueue.id,
+        isModifiedFromSaved: false
+      }
+    });
+
     // Broadcast save event
     this.broadcastMessage({
       type: 'QUEUE_SAVED',
@@ -160,12 +169,15 @@ export class SavedQueuesManager {
       newItems = [...currentQueue.items, ...savedQueue.items];
     }
 
-    // Update queue state
+    // Update queue state with tracking
     this.store.updateState({
       queue: {
         ...currentQueue,
         items: newItems,
-        currentIndex: replace && newItems.length > 0 ? 0 : currentQueue.currentIndex
+        currentIndex: replace && newItems.length > 0 ? 0 : currentQueue.currentIndex,
+        // Track the loaded queue only if we replaced (not if we appended)
+        currentlyLoadedQueueId: replace ? queueId : null,
+        isModifiedFromSaved: false
       }
     });
 
@@ -324,6 +336,134 @@ export class SavedQueuesManager {
     ui.notifications?.success(`Queue renamed to "${trimmedName}"`);
   }
 
+  /**
+   * Save changes to the currently loaded saved queue
+   */
+  async saveChangesToCurrentQueue(): Promise<SavedQueue | null> {
+    if (!this.store.isDJ()) {
+      throw new Error('Only the DJ can save queue changes');
+    }
+
+    const currentQueue = this.store.getQueueState();
+    
+    // Check if there's a currently loaded saved queue
+    if (!currentQueue.currentlyLoadedQueueId) {
+      throw new Error('No saved queue is currently loaded. Use "Save Queue" to create a new saved queue.');
+    }
+
+    // Check if the queue has been modified
+    if (!currentQueue.isModifiedFromSaved) {
+      ui.notifications?.info('No changes to save - queue is already up to date');
+      return null;
+    }
+
+    const savedQueue = this.getSavedQueue(currentQueue.currentlyLoadedQueueId);
+    if (!savedQueue) {
+      throw new Error('Currently loaded saved queue not found');
+    }
+
+    if (currentQueue.items.length === 0) {
+      throw new Error('Cannot save an empty queue');
+    }
+
+    logger.debug('🎵 YouTube DJ | Saving changes to currently loaded queue:', savedQueue.name);
+
+    // Create updated saved queue
+    const updatedQueue: SavedQueue = {
+      ...savedQueue,
+      items: [...currentQueue.items], // Deep copy current items
+      updatedAt: Date.now()
+    };
+
+    // Update saved queues list
+    const savedQueues = this.getSavedQueues();
+    const updatedQueues = savedQueues.map(q => 
+      q.id === currentQueue.currentlyLoadedQueueId ? updatedQueue : q
+    );
+
+    // Save to world settings
+    await game.settings.set('core', 'youtubeDJ.savedQueues', updatedQueues);
+
+    // Update queue state to reflect saved changes
+    this.store.updateState({
+      queue: {
+        ...currentQueue,
+        isModifiedFromSaved: false
+      }
+    });
+
+    // Broadcast save event
+    this.broadcastMessage({
+      type: 'QUEUE_SAVED',
+      userId: game.user?.id || '',
+      timestamp: Date.now(),
+      data: { 
+        savedQueue: updatedQueue,
+        isOverwrite: true,
+        isCurrentQueueUpdate: true
+      }
+    });
+
+    logger.info('🎵 YouTube DJ | Changes saved to queue:', savedQueue.name);
+    ui.notifications?.success(`Changes saved to "${savedQueue.name}"`);
+    
+    return updatedQueue;
+  }
+
+  /**
+   * Get information about the currently loaded saved queue
+   */
+  getCurrentlyLoadedQueue(): { savedQueue: SavedQueue | null; hasChanges: boolean } {
+    const currentQueue = this.store.getQueueState();
+    
+    if (!currentQueue.currentlyLoadedQueueId) {
+      return { savedQueue: null, hasChanges: false };
+    }
+
+    const savedQueue = this.getSavedQueue(currentQueue.currentlyLoadedQueueId);
+    return { 
+      savedQueue, 
+      hasChanges: currentQueue.isModifiedFromSaved 
+    };
+  }
+
+  /**
+   * Mark the current queue as modified from the saved version
+   */
+  markQueueAsModified(): void {
+    const currentQueue = this.store.getQueueState();
+    
+    if (currentQueue.currentlyLoadedQueueId && !currentQueue.isModifiedFromSaved) {
+      this.store.updateState({
+        queue: {
+          ...currentQueue,
+          isModifiedFromSaved: true
+        }
+      });
+      
+      logger.debug('🎵 YouTube DJ | Queue marked as modified from saved version');
+    }
+  }
+
+  /**
+   * Clear the currently loaded queue tracking (when creating a new queue from scratch)
+   */
+  clearCurrentlyLoadedQueue(): void {
+    const currentQueue = this.store.getQueueState();
+    
+    if (currentQueue.currentlyLoadedQueueId || currentQueue.isModifiedFromSaved) {
+      this.store.updateState({
+        queue: {
+          ...currentQueue,
+          currentlyLoadedQueueId: null,
+          isModifiedFromSaved: false
+        }
+      });
+      
+      logger.debug('🎵 YouTube DJ | Cleared currently loaded queue tracking');
+    }
+  }
+
   /**
    * Export a saved queue to JSON
    */

src/state/StateTypes.ts

@@ -109,6 +109,9 @@ export interface QueueState {
   mode: 'single-dj' | 'collaborative';
   djUserId: string | null;
   savedQueues: SavedQueue[];
+  // Track the currently loaded saved queue (if any)
+  currentlyLoadedQueueId: string | null;
+  isModifiedFromSaved: boolean; // Track if current queue differs from the loaded saved queue
 }
 
 export interface UIState {
@@ -171,7 +174,9 @@ export function createDefaultQueueState(): QueueState {
     currentIndex: -1,
     mode: 'single-dj',
     djUserId: null,
-    savedQueues: []
+    savedQueues: [],
+    currentlyLoadedQueueId: null,
+    isModifiedFromSaved: false
   };
 }