react-native-audio-browser 0.1.1 → 0.2.0-next.2

package/lib/module/web/NativeAudioBrowser.js

@@ -1,6 +1,7 @@
 "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';
@@ -8,13 +9,15 @@ import { HttpClient } from './http/HttpClient';
 import { RequestConfigBuilder } from './http/RequestConfigBuilder';
 import { NowPlayingManager } from './player/NowPlayingManager';
 import { OptionsManager } from './player/OptionsManager';
-import { PlaylistPlayer, SleepTimerManager } from './TrackPlayer';
-import { BrowserPathHelper } from './util/BrowserPathHelper';
+import { RemoteCommandController } from './player/RemoteCommandController';
+import { QueuePlayer, SleepTimerManager, VolumeFader } from './TrackPlayer';
+import { PlaybackTimer } from './TrackPlayer/PlaybackTimer';
+import { derivePlayingState } from './TrackPlayer/PlayingStateFactory';
 
 /**
  * Web implementation of AudioBrowser (unified browser + player)
  */
-export class NativeAudioBrowser extends PlaylistPlayer {
+export class NativeAudioBrowser extends QueuePlayer {
   // HybridObject stuff
   name = 'WebAudioBrowser';
   equals() {
@@ -22,6 +25,8 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   }
   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);
@@ -35,17 +40,26 @@ export class NativeAudioBrowser extends PlaylistPlayer {
 
   // 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, stopping playback');
-      this.parent.stop();
+      console.log('Sleep timer completed, pausing playback');
+      this.parent.sleepFader.resolve(() => this.parent.pause());
       this.parent.onSleepTimerChanged(null);
     }
+    onFadeStart(durationSeconds) {
+      this.parent.sleepFader.start(durationSeconds);
+    }
+    onFadeCancel() {
+      this.parent.sleepFader.cancel(true);
+    }
   }(this);
 
   // MARK: Browser properties
@@ -84,17 +98,15 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   onPlaybackPlayWhenReadyChanged = () => {};
   onPlaybackPlayingState = () => {};
   onPlaybackProgressUpdated = () => {};
+  onPlaybackInterval = () => {};
   onPlaybackQueueEnded = () => {};
   onPlaybackQueueChanged = () => {};
   onPlaybackRepeatModeChanged = () => {};
   onPlaybackShuffleModeChanged = () => {};
   onSleepTimerChanged = () => {};
   onPlaybackChanged = () => {};
-  onRemoteBookmark = () => {};
-  onRemoteDislike = () => {};
   onRemoteJumpBackward = () => {};
   onRemoteJumpForward = () => {};
-  onRemoteLike = () => {};
   onRemoteNext = () => {};
   onRemotePause = () => {};
   onRemotePlay = () => {};
@@ -102,7 +114,6 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   onRemotePlaySearch = () => {};
   onRemotePrevious = () => {};
   onRemoteSeek = () => {};
-  onRemoteSetRating = () => {};
   onRemoteSkip = () => {};
   onRemoteStop = () => {};
   onOptionsChanged = () => {};
@@ -113,14 +124,19 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   onBatteryWarningPendingChanged = () => {};
   onBatteryOptimizationStatusChanged = () => {};
   onSystemVolumeChanged = () => {};
-  onIosOutputChanged = () => {};
+  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 = () => {};
 
   // MARK: Remote handlers
-  handleRemoteBookmark = undefined;
-  handleRemoteDislike = undefined;
   handleRemoteJumpBackward = undefined;
   handleRemoteJumpForward = undefined;
-  handleRemoteLike = undefined;
   handleRemoteNext = undefined;
   handleRemotePause = undefined;
   handleRemotePlay = undefined;
@@ -128,7 +144,6 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   handleRemotePlaySearch = undefined;
   handleRemotePrevious = undefined;
   handleRemoteSeek = undefined;
-  handleRemoteSetRating = undefined;
   handleRemoteSkip = undefined;
   handleRemoteStop = undefined;
 
@@ -142,8 +157,9 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     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.httpClient);
+    this.searchManager = new SearchManager(this.browserManager);
 
     // Wire up event callbacks from managers to class callbacks
     this.browserManager.onPathChanged = path => this.onPathChanged(path);
@@ -152,7 +168,7 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     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.onNowPlayingChanged(metadata);
+    this.nowPlayingManager.onNowPlayingChanged = metadata => this.publishNowPlaying(metadata);
 
     // Setup online/offline listeners
     if (typeof window !== 'undefined') {
@@ -184,52 +200,61 @@ export class NativeAudioBrowser extends PlaylistPlayer {
 
     // Call callbacks
     this.onPlaybackChanged(newState);
-    this.onPlaybackPlayingState(this.getPlayingStateFromPlayback(newState));
+    this.refreshPlayingState();
+    this.remoteCommands.syncPlaybackState();
     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);
+  }
 
   /**
-   * Derives PlayingState from playback state and playWhenReady.
-   * Matches Android's PlayingStateFactory.derive() logic.
+   * Emits now-playing metadata to JS consumers and mirrors it to the OS media
+   * controls (lockscreen / notification / media keys).
    */
-  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')
-    };
+  publishNowPlaying(metadata) {
+    this.onNowPlayingChanged(metadata);
+    this.remoteCommands.setMetadata(metadata);
   }
   setupProgressUpdates(interval) {
-    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);
-    }
+    // 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();
+    });
   }
   clearUpdateEventInterval() {
-    if (this.progressUpdateEventInterval) {
-      clearInterval(this.progressUpdateEventInterval);
-    }
+    this.progressTimer.stop();
   }
-  onPlaylistEnded() {
-    super.onPlaylistEnded();
+  setPlaybackIntervalEnabled(enabled) {
+    this.intervalTimer.start(enabled ? 1000 : 0, () => this.state.state === 'playing', () => this.onPlaybackInterval());
+  }
+  onQueueEnded() {
+    super.onQueueEnded();
     this.onPlaybackQueueEnded({
-      track: this.currentIndex ?? 0,
+      track: this.queue.currentIndex ?? 0,
       position: this.element?.currentTime ?? 0
     });
   }
@@ -239,9 +264,8 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     void this.browserManager.navigatePath(path);
   }
   navigateTrack(track) {
-    const url = track.url;
     // Execute async navigation logic without blocking
-    void this.navigateTrackAsync(track, url);
+    void this.navigateTrackAsync(track);
   }
 
   /**
@@ -301,7 +325,12 @@ export class NativeAudioBrowser extends PlaylistPlayer {
       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;
   }
@@ -310,51 +339,49 @@ export class NativeAudioBrowser extends PlaylistPlayer {
    * Async implementation of track navigation with queue expansion support.
    * Matches Android's MediaSessionCallback behavior.
    */
-  async navigateTrackAsync(track, url) {
+  async navigateTrackAsync(track) {
     try {
-      // 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))) {
+      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;
-        }
-
-        // Expand queue from contextual URL
-        if (await this.expandQueueAndPlay(track)) {
+        case 'browse':
+          this.browserManager.navigateTrack(track).catch(error => {
+            console.error('Failed to navigate to track:', error);
+          });
           return;
-        }
-
-        // 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;
+        case 'playable':
+          await this.playSingleTrack(track);
+          return;
+        case 'invalid':
+          throw new Error("Track must have either 'url' or 'src' property");
       }
-      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
+      query,
+      reference: 'unknown'
     });
   }
   getContent() {
@@ -369,6 +396,9 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   notifyContentChanged(path) {
     this.browserManager.notifyContentChanged(path);
   }
+  invalidateAllContent() {
+    this.browserManager.invalidateAllContent();
+  }
   setFavorites(favorites) {
     this.favoriteManager.setFavorites(favorites);
   }
@@ -376,6 +406,13 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   // 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
@@ -399,8 +436,27 @@ export class NativeAudioBrowser extends PlaylistPlayer {
    * Mirrors Android's MediaFactory.getMediaRequestConfig behavior.
    */
   async resolveMediaUrl(src) {
-    const mediaConfig = this.browserManager.configuration.media;
-    return RequestConfigBuilder.resolveMediaUrl(src, mediaConfig);
+    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();
+    }
   }
   load(track, callback) {
     const element = this.requireElement();
@@ -410,18 +466,18 @@ export class NativeAudioBrowser extends PlaylistPlayer {
 
     // Match Android: load() modifies the queue.
     // If queue is empty, add the track. If queue has items, replace at currentIndex.
-    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);
+    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();
     }
     const lastTrack = this.current;
     const lastPosition = element.currentTime;
-    const lastIndex = this.lastIndex;
-    const currentIndex = this.currentIndex;
+    const lastIndex = this.queue.lastIndex;
+    const currentIndex = this.queue.currentIndex;
 
     // Set loading flag early so seekTo() calls during async URL resolution
     // are captured as pending seeks rather than silently dropped
@@ -452,7 +508,7 @@ export class NativeAudioBrowser extends PlaylistPlayer {
         // Update now playing metadata
         const nowPlaying = this.getNowPlaying();
         if (nowPlaying) {
-          this.onNowPlayingChanged(nowPlaying);
+          this.publishNowPlaying(nowPlaying);
         }
 
         // Call the provided callback if any
@@ -464,11 +520,16 @@ export class NativeAudioBrowser extends PlaylistPlayer {
 
     // 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
       };
@@ -481,15 +542,82 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   togglePlayback() {
     super.togglePlayback();
   }
-  setPlayWhenReady(pwr) {
-    const didChange = pwr !== this._playWhenReady;
+
+  /**
+   * 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;
     super.playWhenReady = pwr;
     if (didChange) {
       this.onPlaybackPlayWhenReadyChanged({
-        playWhenReady: this._playWhenReady
+        playWhenReady: pwr
       });
+      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;
   }
@@ -497,13 +625,13 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     return this.state;
   }
   getPlayingState() {
-    return this.getPlayingStateFromPlayback(this.state);
+    return derivePlayingState(this._playWhenReady, this.state.state);
   }
   getRepeatMode() {
     return this.optionsManager.getRepeatMode();
   }
   setRepeatMode(mode) {
-    const didChange = this.repeatMode !== mode;
+    const didChange = this.queue.repeatMode !== mode;
     super.setRepeatMode(mode);
     this.optionsManager.setRepeatMode(mode);
     if (didChange) {
@@ -537,10 +665,32 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     }
     return null;
   }
-  setSleepTimer(seconds) {
-    this.sleepTimer.sleepAfter(seconds);
+  setSleepTimer(seconds, fadeDuration) {
+    this.sleepTimer.sleepAfter(seconds, fadeDuration);
     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());
@@ -559,9 +709,9 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   onTrackEnded() {
     // Check if sleep timer is set to end on track completion
     if (this.sleepTimer.sleepWhenPlayedToEnd) {
-      console.log('Sleep timer triggered on track end, stopping playback');
+      console.log('Sleep timer triggered on track end, pausing playback');
       this.sleepTimer.clear();
-      this.stop();
+      this.pause();
       this.onSleepTimerChanged(null);
       return;
     }
@@ -571,39 +721,37 @@ export class NativeAudioBrowser extends PlaylistPlayer {
   }
 
   // MARK: Queue management
-  setQueue(tracks, startIndex, startPositionMs) {
+  setQueue(tracks, startIndex, startPosition) {
     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 artworkConfig = this.browserManager.configuration.artwork;
-    this.playlist = tracks.map(track => {
+    const {
+      request,
+      artwork
+    } = this.browserManager.configuration;
+    this.queue.setTracks(tracks.map(track => {
       try {
         const hydratedTrack = this.favoriteManager.hydrateFavorite(track);
-        return RequestConfigBuilder.transformTrackArtwork(hydratedTrack, artworkConfig);
+        return RequestConfigBuilder.transformTrackArtwork(hydratedTrack, request, artwork);
       } catch (error) {
         console.error('Failed to transform track:', error);
         return track; // Use original track as fallback
       }
-    });
-    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);
+    }));
+    this.emitQueueChanged();
+    if (startIndex !== undefined && this.queue.getTrack(startIndex)) {
+      this.skip(startIndex, startPosition);
     }
   }
   getQueue() {
-    return this.playlist;
+    // Copy — see emitQueueChanged.
+    return [...this.queue.tracks];
   }
   getActiveTrackIndex() {
     this.requireElement();
     this.requirePlayer();
-    return this.currentIndex;
+    return this.queue.currentIndex;
   }
   getActiveTrack() {
     return this.current;
@@ -626,8 +774,8 @@ export class NativeAudioBrowser extends PlaylistPlayer {
       favorited
     };
 
-    // Replace the track in the playlist
-    this.playlist[index] = updatedTrack;
+    // Replace the track in the queue
+    this.queue.replaceTrack(index, updatedTrack);
 
     // Emit favorite changed event
     this.onFavoriteChanged({
@@ -645,7 +793,7 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     });
 
     // Emit queue changed so useQueue() hook updates
-    this.onPlaybackQueueChanged(this.playlist);
+    this.emitQueueChanged();
   }
   toggleActiveTrackFavorited() {
     const track = this.getActiveTrack();
@@ -665,6 +813,22 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     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() {
@@ -716,12 +880,25 @@ export class NativeAudioBrowser extends PlaylistPlayer {
     // No-op on web - browsers can't set system volume
   }
 
-  // MARK: iOS output (not applicable on web)
-  getIosOutput() {
+  // 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() {
     return undefined;
   }
-  openIosOutputPicker() {
+  openOutputPicker() {
     // No-op on web
   }
+  supportsOutputSwitcher() {
+    return false;
+  }
 }
 //# sourceMappingURL=NativeAudioBrowser.js.map