react-native-audio-browser 0.2.0-next.8 → 0.2.0

package/lib/module/web/NativeAudioBrowser.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import { BrowserManager } from './browser/BrowserManager';
-import { classifyTrackNavigation } from './browser/classifyTrackNavigation';
 import { FavoriteManager } from './browser/FavoriteManager';
 import { NavigationErrorManager } from './browser/NavigationErrorManager';
 import { SearchManager } from './browser/SearchManager';
@@ -9,15 +8,13 @@ import { HttpClient } from './http/HttpClient';
 import { RequestConfigBuilder } from './http/RequestConfigBuilder';
 import { NowPlayingManager } from './player/NowPlayingManager';
 import { OptionsManager } from './player/OptionsManager';
-import { RemoteCommandController } from './player/RemoteCommandController';
-import { QueuePlayer, SleepTimerManager, VolumeFader } from './TrackPlayer';
-import { PlaybackTimer } from './TrackPlayer/PlaybackTimer';
-import { derivePlayingState } from './TrackPlayer/PlayingStateFactory';
+import { PlaylistPlayer, SleepTimerManager } from './TrackPlayer';
+import { BrowserPathHelper } from './util/BrowserPathHelper';
 
 /**
  * Web implementation of AudioBrowser (unified browser + player)
  */
-export class NativeAudioBrowser extends QueuePlayer {
+export class NativeAudioBrowser extends PlaylistPlayer {
   // HybridObject stuff
   name = 'WebAudioBrowser';
   equals() {
@@ -25,8 +22,6 @@ export class NativeAudioBrowser extends QueuePlayer {
   }
   dispose() {
     this.clearUpdateEventInterval();
-    this.setPlaybackIntervalEnabled(false);
-    this.remoteCommands.dispose();
     // Remove window event listeners to prevent memory leaks
     if (typeof window !== 'undefined' && this.onlineHandler) {
       window.removeEventListener('online', this.onlineHandler);
@@ -40,26 +35,17 @@ export class NativeAudioBrowser extends QueuePlayer {
 
   // Player state
   currentLoadId = 0;
-  progressTimer = new PlaybackTimer();
-  intervalTimer = new PlaybackTimer();
   _online = typeof navigator !== 'undefined' ? navigator.onLine : true;
-  sleepFader = new VolumeFader(() => this.getVolume(), volume => this.setVolume(volume));
   sleepTimer = new class extends SleepTimerManager {
     constructor(parent) {
       super();
       this.parent = parent;
     }
     onComplete() {
-      console.log('Sleep timer completed, pausing playback');
-      this.parent.sleepFader.resolve(() => this.parent.pause());
+      console.log('Sleep timer completed, stopping playback');
+      this.parent.stop();
       this.parent.onSleepTimerChanged(null);
     }
-    onFadeStart(durationSeconds) {
-      this.parent.sleepFader.start(durationSeconds);
-    }
-    onFadeCancel() {
-      this.parent.sleepFader.cancel(true);
-    }
   }(this);
 
   // MARK: Browser properties
@@ -98,15 +84,17 @@ export class NativeAudioBrowser extends QueuePlayer {
   onPlaybackPlayWhenReadyChanged = () => {};
   onPlaybackPlayingState = () => {};
   onPlaybackProgressUpdated = () => {};
-  onPlaybackInterval = () => {};
   onPlaybackQueueEnded = () => {};
   onPlaybackQueueChanged = () => {};
   onPlaybackRepeatModeChanged = () => {};
   onPlaybackShuffleModeChanged = () => {};
   onSleepTimerChanged = () => {};
   onPlaybackChanged = () => {};
+  onRemoteBookmark = () => {};
+  onRemoteDislike = () => {};
   onRemoteJumpBackward = () => {};
   onRemoteJumpForward = () => {};
+  onRemoteLike = () => {};
   onRemoteNext = () => {};
   onRemotePause = () => {};
   onRemotePlay = () => {};
@@ -114,6 +102,7 @@ export class NativeAudioBrowser extends QueuePlayer {
   onRemotePlaySearch = () => {};
   onRemotePrevious = () => {};
   onRemoteSeek = () => {};
+  onRemoteSetRating = () => {};
   onRemoteSkip = () => {};
   onRemoteStop = () => {};
   onOptionsChanged = () => {};
@@ -124,19 +113,14 @@ export class NativeAudioBrowser extends QueuePlayer {
   onBatteryWarningPendingChanged = () => {};
   onBatteryOptimizationStatusChanged = () => {};
   onSystemVolumeChanged = () => {};
-  onOutputChanged = () => {};
-  onGate = () => {};
-  // Fail closed by default: only reachable in the init window before gate.ts
-  // re-binds resolveGate. Web has no serve sites, so this is never called in
-  // practice, but the default must agree with the fail-closed contract.
-  resolveGate = async () => ({
-    gated: true
-  });
-  onCarConnectedChanged = () => {};
+  onIosOutputChanged = () => {};
 
   // MARK: Remote handlers
+  handleRemoteBookmark = undefined;
+  handleRemoteDislike = undefined;
   handleRemoteJumpBackward = undefined;
   handleRemoteJumpForward = undefined;
+  handleRemoteLike = undefined;
   handleRemoteNext = undefined;
   handleRemotePause = undefined;
   handleRemotePlay = undefined;
@@ -144,6 +128,7 @@ export class NativeAudioBrowser extends QueuePlayer {
   handleRemotePlaySearch = undefined;
   handleRemotePrevious = undefined;
   handleRemoteSeek = undefined;
+  handleRemoteSetRating = undefined;
   handleRemoteSkip = undefined;
   handleRemoteStop = undefined;
 
@@ -157,9 +142,8 @@ export class NativeAudioBrowser extends QueuePlayer {
     this.navigationErrorManager = new NavigationErrorManager();
     this.optionsManager = new OptionsManager();
     this.nowPlayingManager = new NowPlayingManager();
-    this.remoteCommands = new RemoteCommandController(this);
     this.browserManager = new BrowserManager(this.httpClient, this.favoriteManager, this.navigationErrorManager);
-    this.searchManager = new SearchManager(this.browserManager);
+    this.searchManager = new SearchManager(this.browserManager, this.httpClient);
 
     // Wire up event callbacks from managers to class callbacks
     this.browserManager.onPathChanged = path => this.onPathChanged(path);
@@ -168,7 +152,7 @@ export class NativeAudioBrowser extends QueuePlayer {
     this.navigationErrorManager.onNavigationError = data => this.onNavigationError(data);
     this.navigationErrorManager.onFormattedNavigationError = error => this.onFormattedNavigationError(error);
     this.optionsManager.onOptionsChanged = options => this.onOptionsChanged(options);
-    this.nowPlayingManager.onNowPlayingChanged = metadata => this.publishNowPlaying(metadata);
+    this.nowPlayingManager.onNowPlayingChanged = metadata => this.onNowPlayingChanged(metadata);
 
     // Setup online/offline listeners
     if (typeof window !== 'undefined') {
@@ -200,61 +184,52 @@ export class NativeAudioBrowser extends QueuePlayer {
 
     // Call callbacks
     this.onPlaybackChanged(newState);
-    this.refreshPlayingState();
-    this.remoteCommands.syncPlaybackState();
+    this.onPlaybackPlayingState(this.getPlayingStateFromPlayback(newState));
     if (newState.state === 'error' && newState.error) {
       this.onPlaybackError({
         error: newState.error
       });
     }
   }
-  /**
-   * Re-derives the playing state and emits on change. Called from both of its
-   * inputs' change points — the state setter and the playWhenReady setter —
-   * with a dedupe so identical derivations don't double-emit (parity with
-   * Android's refreshPlayingState / iOS's PlayingStateManager).
-   */
-  refreshPlayingState() {
-    const next = derivePlayingState(this._playWhenReady, this.state.state);
-    if (this.lastPlayingState !== undefined && this.lastPlayingState.playing === next.playing && this.lastPlayingState.buffering === next.buffering) {
-      return;
-    }
-    this.lastPlayingState = next;
-    this.onPlaybackPlayingState(next);
-  }
 
   /**
-   * Emits now-playing metadata to JS consumers and mirrors it to the OS media
-   * controls (lockscreen / notification / media keys).
+   * Derives PlayingState from playback state and playWhenReady.
+   * Matches Android's PlayingStateFactory.derive() logic.
    */
-  publishNowPlaying(metadata) {
-    this.onNowPlayingChanged(metadata);
-    this.remoteCommands.setMetadata(metadata);
+  getPlayingStateFromPlayback(playback) {
+    const state = playback.state;
+    const pwr = this._playWhenReady;
+    return {
+      playing: pwr && state !== 'error' && state !== 'ended' && state !== 'none',
+      buffering: pwr && (state === 'loading' || state === 'buffering')
+    };
   }
   setupProgressUpdates(interval) {
-    // Match Android: emit progress during loading, buffering, and playing.
-    this.progressTimer.start((interval ?? 0) * 1000, () => {
-      const state = this.state.state;
-      return state === 'playing' || state === 'loading' || state === 'buffering';
-    }, () => {
-      const progress = this.getProgress();
-      this.onPlaybackProgressUpdated({
-        ...progress,
-        track: this.queue.currentIndex || 0
-      });
-      this.remoteCommands.updateProgress();
-    });
+    this.clearUpdateEventInterval();
+    if (interval) {
+      this.progressUpdateEventInterval = setInterval(() => {
+        const state = this.state.state;
+        // Match Android: emit progress during loading, buffering, and playing
+        if (state === 'playing' || state === 'loading' || state === 'buffering') {
+          const progress = this.getProgress();
+          const event = {
+            ...progress,
+            track: this.currentIndex || 0
+          };
+          this.onPlaybackProgressUpdated(event);
+        }
+      }, interval * 1000);
+    }
   }
   clearUpdateEventInterval() {
-    this.progressTimer.stop();
-  }
-  setPlaybackIntervalEnabled(enabled) {
-    this.intervalTimer.start(enabled ? 1000 : 0, () => this.state.state === 'playing', () => this.onPlaybackInterval());
+    if (this.progressUpdateEventInterval) {
+      clearInterval(this.progressUpdateEventInterval);
+    }
   }
-  onQueueEnded() {
-    super.onQueueEnded();
+  onPlaylistEnded() {
+    super.onPlaylistEnded();
     this.onPlaybackQueueEnded({
-      track: this.queue.currentIndex ?? 0,
+      track: this.currentIndex ?? 0,
       position: this.element?.currentTime ?? 0
     });
   }
@@ -264,8 +239,9 @@ export class NativeAudioBrowser extends QueuePlayer {
     void this.browserManager.navigatePath(path);
   }
   navigateTrack(track) {
+    const url = track.url;
     // Execute async navigation logic without blocking
-    void this.navigateTrackAsync(track);
+    void this.navigateTrackAsync(track, url);
   }
 
   /**
@@ -325,12 +301,7 @@ export class NativeAudioBrowser extends QueuePlayer {
       return false;
     }
     await this.handleLoad(track, result.tracks, result.startIndex, () => {
-      // setQueue keeps the current play/pause state, so start playback
-      // explicitly — selecting a track is an intent to play (matches the
-      // skip-to-existing-queue-track path). Without this the first track of a
-      // freshly expanded queue loads but stays paused.
       this.setQueue(result.tracks, result.startIndex);
-      this.play();
     });
     return true;
   }
@@ -339,49 +310,51 @@ export class NativeAudioBrowser extends QueuePlayer {
    * Async implementation of track navigation with queue expansion support.
    * Matches Android's MediaSessionCallback behavior.
    */
-  async navigateTrackAsync(track) {
+  async navigateTrackAsync(track, url) {
     try {
-      const nav = classifyTrackNavigation(track);
-      switch (nav.kind) {
-        case 'contextual':
-          // Optimization: skip to the track if it's already in the queue.
-          if (nav.trackId && (await this.trySkipToExistingQueueTrack(nav.trackId, nav.parentPath))) {
-            return;
-          }
-          // Otherwise expand the queue from the contextual URL, falling back to
-          // loading the single track if expansion yields nothing.
-          if (await this.expandQueueAndPlay(track)) return;
-          await this.playSingleTrack(track);
-          return;
-        case 'browse':
-          this.browserManager.navigateTrack(track).catch(error => {
-            console.error('Failed to navigate to track:', error);
-          });
+      // Handle contextual URL (playable track with queue context)
+      if (url && BrowserPathHelper.isContextual(url)) {
+        const parentPath = BrowserPathHelper.stripTrackId(url);
+        const trackId = BrowserPathHelper.extractTrackId(url);
+
+        // Optimization: skip to track if already in current queue
+        if (trackId && (await this.trySkipToExistingQueueTrack(trackId, parentPath))) {
           return;
-        case 'playable':
-          await this.playSingleTrack(track);
+        }
+
+        // Expand queue from contextual URL
+        if (await this.expandQueueAndPlay(track)) {
           return;
-        case 'invalid':
-          throw new Error("Track must have either 'url' or 'src' property");
+        }
+
+        // Fallback: load single track if expansion fails
+        await this.handleLoad(track, [track], 0, () => this.load(track));
+        return;
+      }
+
+      // Handle browsable track (has URL but not contextual)
+      if (url) {
+        this.browserManager.navigateTrack(track).catch(error => {
+          console.error('Failed to navigate to track:', error);
+        });
+        return;
       }
+
+      // Handle playable track (has src but no URL)
+      if (track.src) {
+        await this.handleLoad(track, [track], 0, () => this.load(track));
+        return;
+      }
+      throw new Error("Track must have either 'url' or 'src' property");
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Unknown error';
       this.navigationErrorManager.setNavigationError('unknown-error', message);
     }
   }
-
-  /** Loads a single track as its own queue and starts playback. */
-  async playSingleTrack(track) {
-    await this.handleLoad(track, [track], 0, () => {
-      this.load(track);
-      this.play();
-    });
-  }
   async onSearch(query) {
     // Wrap query string in SearchParams (matches Android's search(query: String) overload)
     return this.searchManager.search({
-      query,
-      reference: 'unknown'
+      query
     });
   }
   getContent() {
@@ -396,9 +369,6 @@ export class NativeAudioBrowser extends QueuePlayer {
   notifyContentChanged(path) {
     this.browserManager.notifyContentChanged(path);
   }
-  invalidateAllContent() {
-    this.browserManager.invalidateAllContent();
-  }
   setFavorites(favorites) {
     this.favoriteManager.setFavorites(favorites);
   }
@@ -406,13 +376,6 @@ export class NativeAudioBrowser extends QueuePlayer {
   // MARK: Player init and config
   async setupPlayer(options) {
     await super.setupPlayer(options);
-    // Apply the launch options and initial state bundled in setup — same
-    // atomic contract as the native platforms.
-    if (options.options) this.updateOptions(options.options);
-    if (options.repeatMode !== undefined) this.setRepeatMode(options.repeatMode);
-    if (options.playWhenReady !== undefined) {
-      this.setPlayWhenReady(options.playWhenReady);
-    }
   }
   updateOptions(options) {
     // Delegate to options manager
@@ -436,27 +399,8 @@ export class NativeAudioBrowser extends QueuePlayer {
    * Mirrors Android's MediaFactory.getMediaRequestConfig behavior.
    */
   async resolveMediaUrl(src) {
-    const {
-      request,
-      media
-    } = this.browserManager.configuration;
-    return RequestConfigBuilder.resolveMediaUrl(src, request, media);
-  }
-
-  /**
-   * Reload from the queue's own entry, whose `src` is still unresolved —
-   * `current` holds the resolved track, and re-feeding it into `load()` would
-   * re-resolve the resolved URL (double-applying a `transform`) and replace
-   * the queue entry with it.
-   */
-  reloadCurrent() {
-    const index = this.queue.currentIndex;
-    const sourceTrack = index !== undefined ? this.queue.getTrack(index) : undefined;
-    if (sourceTrack) {
-      this.load(sourceTrack);
-    } else {
-      super.reloadCurrent();
-    }
+    const mediaConfig = this.browserManager.configuration.media;
+    return RequestConfigBuilder.resolveMediaUrl(src, mediaConfig);
   }
   load(track, callback) {
     const element = this.requireElement();
@@ -466,18 +410,18 @@ export class NativeAudioBrowser extends QueuePlayer {
 
     // Match Android: load() modifies the queue.
     // If queue is empty, add the track. If queue has items, replace at currentIndex.
-    if (this.queue.length === 0) {
-      this.queue.setTracks([track]);
-      this.queue.currentIndex = 0;
-      this.emitQueueChanged();
-    } else if (this.queue.currentIndex !== undefined && this.queue.getTrack(this.queue.currentIndex) !== track) {
-      this.queue.replaceTrack(this.queue.currentIndex, track);
-      this.emitQueueChanged();
+    if (this.playlist.length === 0) {
+      this.playlist = [track];
+      this._currentIndex = 0;
+      this.onPlaybackQueueChanged(this.playlist);
+    } else if (this.currentIndex !== undefined && this.playlist[this.currentIndex] !== track) {
+      this.playlist[this.currentIndex] = track;
+      this.onPlaybackQueueChanged(this.playlist);
     }
     const lastTrack = this.current;
     const lastPosition = element.currentTime;
-    const lastIndex = this.queue.lastIndex;
-    const currentIndex = this.queue.currentIndex;
+    const lastIndex = this.lastIndex;
+    const currentIndex = this.currentIndex;
 
     // Set loading flag early so seekTo() calls during async URL resolution
     // are captured as pending seeks rather than silently dropped
@@ -508,7 +452,7 @@ export class NativeAudioBrowser extends QueuePlayer {
         // Update now playing metadata
         const nowPlaying = this.getNowPlaying();
         if (nowPlaying) {
-          this.publishNowPlaying(nowPlaying);
+          this.onNowPlayingChanged(nowPlaying);
         }
 
         // Call the provided callback if any
@@ -520,16 +464,11 @@ export class NativeAudioBrowser extends QueuePlayer {
 
     // Execute async load without blocking, with error handling
     doLoad().catch(error => {
-      // Only the active load may surface a resolution failure.
-      if (loadId !== this.currentLoadId) return;
       this._loadInProgress = false;
       this._pendingSeek = undefined;
       console.error('Error loading track:', error);
       const message = error instanceof Error ? error.message : 'Failed to load track';
-      // Track resolution failed before playback was ever attempted, so nothing
-      // is known about the stream itself.
       const playbackError = {
-        kind: 'unknown',
         code: 'load-error',
         message
       };
@@ -542,82 +481,15 @@ export class NativeAudioBrowser extends QueuePlayer {
   togglePlayback() {
     super.togglePlayback();
   }
-
-  /**
-   * Copies before emitting: the queue mutates in place, and handing out the
-   * live array defeats React's reference-equality change detection.
-   */
-  emitQueueChanged() {
-    this.onPlaybackQueueChanged([...this.queue.tracks]);
-  }
-
-  // Queue mutations must reach onPlaybackQueueChanged (the contract covers
-  // added/removed/reordered; Android emits via onTimelineChanged).
-  add(tracks, insertBeforeIndex) {
-    super.add(tracks, insertBeforeIndex);
-    this.emitQueueChanged();
-  }
-  remove(indexes) {
-    super.remove(indexes);
-    this.emitQueueChanged();
-  }
-  move(fromIndex, toIndex) {
-    super.move(fromIndex, toIndex);
-    this.emitQueueChanged();
-  }
-  removeUpcomingTracks() {
-    super.removeUpcomingTracks();
-    this.emitQueueChanged();
-  }
-  reset() {
-    super.reset();
-    this.emitQueueChanged();
-  }
-
-  // Override playWhenReady to emit events (mirrors the state override): the
-  // base transport methods (play/pause/stop, the queue-end intent clear)
-  // assign through this accessor, so the change event and MediaSession sync
-  // fire for every writer — not only setPlayWhenReady().
-  get playWhenReady() {
-    return super.playWhenReady;
-  }
-  set playWhenReady(pwr) {
-    const didChange = pwr !== super.playWhenReady;
+  setPlayWhenReady(pwr) {
+    const didChange = pwr !== this._playWhenReady;
     super.playWhenReady = pwr;
     if (didChange) {
       this.onPlaybackPlayWhenReadyChanged({
-        playWhenReady: pwr
+        playWhenReady: this._playWhenReady
       });
-      this.refreshPlayingState();
-      this.remoteCommands.syncPlaybackState();
     }
   }
-  setPlayWhenReady(pwr) {
-    if (!pwr) {
-      if (this.element) {
-        // pause() halts first and its override then clears a fading sleep
-        // timer — restoring the volume before the halt would let full-volume
-        // audio slip out (VolumeFader's invariant).
-        this.pause();
-      } else {
-        this.clearSleepTimerIfFading();
-        this.playWhenReady = false;
-      }
-      return;
-    }
-    // Mirror native: raising the intent restarts playback from terminal
-    // states (reload/replay via play()) and resumes a settled paused/ready
-    // player. While loading/buffering the flag alone is correct — load()'s
-    // auto-play starts playback once the source is ready.
-    const {
-      state
-    } = this.state;
-    if (this.current !== undefined && (state === 'ended' || state === 'stopped' || state === 'error' || state === 'paused' || state === 'ready')) {
-      this.play();
-      return;
-    }
-    this.playWhenReady = true;
-  }
   getPlayWhenReady() {
     return super.playWhenReady;
   }
@@ -625,13 +497,13 @@ export class NativeAudioBrowser extends QueuePlayer {
     return this.state;
   }
   getPlayingState() {
-    return derivePlayingState(this._playWhenReady, this.state.state);
+    return this.getPlayingStateFromPlayback(this.state);
   }
   getRepeatMode() {
     return this.optionsManager.getRepeatMode();
   }
   setRepeatMode(mode) {
-    const didChange = this.queue.repeatMode !== mode;
+    const didChange = this.repeatMode !== mode;
     super.setRepeatMode(mode);
     this.optionsManager.setRepeatMode(mode);
     if (didChange) {
@@ -665,32 +537,10 @@ export class NativeAudioBrowser extends QueuePlayer {
     }
     return null;
   }
-  setSleepTimer(seconds, fadeDuration) {
-    this.sleepTimer.sleepAfter(seconds, fadeDuration);
+  setSleepTimer(seconds) {
+    this.sleepTimer.sleepAfter(seconds);
     this.onSleepTimerChanged(this.getSleepTimer());
   }
-
-  /**
-   * An explicit pause intent during the sleep fade is the timer's goal
-   * arriving early: clear the timer (which restores the pre-fade volume).
-   * Called after the halt lands so the restore never precedes it. Mirrors
-   * the native playWhenReady hooks.
-   */
-  clearSleepTimerIfFading() {
-    if (this.sleepFader.isActive) this.clearSleepTimer();
-  }
-  pause() {
-    super.pause();
-    this.clearSleepTimerIfFading();
-  }
-  stop() {
-    // Invalidate any in-flight load: its post-await continuation would call
-    // super.load(), whose first line re-arms the player (_isStopped = false)
-    // and revives the state out of Stopped.
-    this.currentLoadId++;
-    super.stop();
-    this.clearSleepTimerIfFading();
-  }
   setSleepTimerToEndOfTrack() {
     this.sleepTimer.setToEndOfTrack();
     this.onSleepTimerChanged(this.getSleepTimer());
@@ -709,9 +559,9 @@ export class NativeAudioBrowser extends QueuePlayer {
   onTrackEnded() {
     // Check if sleep timer is set to end on track completion
     if (this.sleepTimer.sleepWhenPlayedToEnd) {
-      console.log('Sleep timer triggered on track end, pausing playback');
+      console.log('Sleep timer triggered on track end, stopping playback');
       this.sleepTimer.clear();
-      this.pause();
+      this.stop();
       this.onSleepTimerChanged(null);
       return;
     }
@@ -721,37 +571,39 @@ export class NativeAudioBrowser extends QueuePlayer {
   }
 
   // MARK: Queue management
-  setQueue(tracks, startIndex, startPosition) {
+  setQueue(tracks, startIndex, startPositionMs) {
     this.stop();
     // Clear stale references from previous queue
     this.current = undefined;
+    this._currentIndex = undefined;
     // Hydrate favorites and transform artwork URLs on all tracks in the queue
-    const {
-      request,
-      artwork
-    } = this.browserManager.configuration;
-    this.queue.setTracks(tracks.map(track => {
+    const artworkConfig = this.browserManager.configuration.artwork;
+    this.playlist = tracks.map(track => {
       try {
         const hydratedTrack = this.favoriteManager.hydrateFavorite(track);
-        return RequestConfigBuilder.transformTrackArtwork(hydratedTrack, request, artwork);
+        return RequestConfigBuilder.transformTrackArtwork(hydratedTrack, artworkConfig);
       } catch (error) {
         console.error('Failed to transform track:', error);
         return track; // Use original track as fallback
       }
-    }));
-    this.emitQueueChanged();
-    if (startIndex !== undefined && this.queue.getTrack(startIndex)) {
-      this.skip(startIndex, startPosition);
+    });
+    this.onPlaybackQueueChanged(this.playlist);
+
+    // Regenerate shuffle order when queue is set
+    if (super.getShuffleEnabled()) {
+      super.setShuffleEnabled(true); // Regenerates shuffle order
+    }
+    if (startIndex !== undefined && this.playlist[startIndex]) {
+      this.skip(startIndex, startPositionMs);
     }
   }
   getQueue() {
-    // Copy — see emitQueueChanged.
-    return [...this.queue.tracks];
+    return this.playlist;
   }
   getActiveTrackIndex() {
     this.requireElement();
     this.requirePlayer();
-    return this.queue.currentIndex;
+    return this.currentIndex;
   }
   getActiveTrack() {
     return this.current;
@@ -774,8 +626,8 @@ export class NativeAudioBrowser extends QueuePlayer {
       favorited
     };
 
-    // Replace the track in the queue
-    this.queue.replaceTrack(index, updatedTrack);
+    // Replace the track in the playlist
+    this.playlist[index] = updatedTrack;
 
     // Emit favorite changed event
     this.onFavoriteChanged({
@@ -793,7 +645,7 @@ export class NativeAudioBrowser extends QueuePlayer {
     });
 
     // Emit queue changed so useQueue() hook updates
-    this.emitQueueChanged();
+    this.onPlaybackQueueChanged(this.playlist);
   }
   toggleActiveTrackFavorited() {
     const track = this.getActiveTrack();
@@ -813,22 +665,6 @@ export class NativeAudioBrowser extends QueuePlayer {
     const duration = this.getProgress().duration;
     return this.nowPlayingManager.getNowPlaying(track, duration);
   }
-  flashNowPlaying(update, durationMs) {
-    // Web approximation: an override + timer is sufficient here — the
-    // background-timer and formatter-priority concerns are native-only.
-    this.updateNowPlaying(update);
-    if (this.nowPlayingFlashRevert) clearTimeout(this.nowPlayingFlashRevert);
-    this.nowPlayingFlashRevert = setTimeout(() => {
-      this.nowPlayingFlashRevert = undefined;
-      this.updateNowPlaying(undefined);
-    }, durationMs);
-  }
-  clearNowPlayingFlash() {
-    if (!this.nowPlayingFlashRevert) return;
-    clearTimeout(this.nowPlayingFlashRevert);
-    this.nowPlayingFlashRevert = undefined;
-    this.updateNowPlaying(undefined);
-  }
 
   // MARK: Network connectivity
   getOnline() {
@@ -880,25 +716,12 @@ export class NativeAudioBrowser extends QueuePlayer {
     // No-op on web - browsers can't set system volume
   }
 
-  // MARK: Gate (no-op — web has no external browse surfaces)
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  setGate(_gate, _hasResolver) {}
-  clearGate() {}
-
-  // MARK: Car connection (not applicable on web)
-  isCarConnected() {
-    return false;
-  }
-
-  // MARK: audio output (not applicable on web)
-  getOutput() {
+  // MARK: iOS output (not applicable on web)
+  getIosOutput() {
     return undefined;
   }
-  openOutputPicker() {
+  openIosOutputPicker() {
     // No-op on web
   }
-  supportsOutputSwitcher() {
-    return false;
-  }
 }
 //# sourceMappingURL=NativeAudioBrowser.js.map