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

package/lib/commonjs/web/NativeAudioBrowser.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.NativeAudioBrowser = void 0;
 var _BrowserManager = require("./browser/BrowserManager");
+var _classifyTrackNavigation = require("./browser/classifyTrackNavigation");
 var _FavoriteManager = require("./browser/FavoriteManager");
 var _NavigationErrorManager = require("./browser/NavigationErrorManager");
 var _SearchManager = require("./browser/SearchManager");
@@ -12,12 +13,14 @@ var _HttpClient = require("./http/HttpClient");
 var _RequestConfigBuilder = require("./http/RequestConfigBuilder");
 var _NowPlayingManager = require("./player/NowPlayingManager");
 var _OptionsManager = require("./player/OptionsManager");
+var _RemoteCommandController = require("./player/RemoteCommandController");
 var _TrackPlayer = require("./TrackPlayer");
-var _BrowserPathHelper = require("./util/BrowserPathHelper");
+var _PlaybackTimer = require("./TrackPlayer/PlaybackTimer");
+var _PlayingStateFactory = require("./TrackPlayer/PlayingStateFactory");
 /**
  * Web implementation of AudioBrowser (unified browser + player)
  */
-class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
+class NativeAudioBrowser extends _TrackPlayer.QueuePlayer {
   // HybridObject stuff
   name = 'WebAudioBrowser';
   equals() {
@@ -25,6 +28,8 @@ class NativeAudioBrowser extends _TrackPlayer.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);
@@ -38,17 +43,26 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
 
   // Player state
   currentLoadId = 0;
+  progressTimer = new _PlaybackTimer.PlaybackTimer();
+  intervalTimer = new _PlaybackTimer.PlaybackTimer();
   _online = typeof navigator !== 'undefined' ? navigator.onLine : true;
+  sleepFader = new _TrackPlayer.VolumeFader(() => this.getVolume(), volume => this.setVolume(volume));
   sleepTimer = new class extends _TrackPlayer.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
@@ -87,17 +101,15 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
   onPlaybackPlayWhenReadyChanged = () => {};
   onPlaybackPlayingState = () => {};
   onPlaybackProgressUpdated = () => {};
+  onPlaybackInterval = () => {};
   onPlaybackQueueEnded = () => {};
   onPlaybackQueueChanged = () => {};
   onPlaybackRepeatModeChanged = () => {};
   onPlaybackShuffleModeChanged = () => {};
   onSleepTimerChanged = () => {};
   onPlaybackChanged = () => {};
-  onRemoteBookmark = () => {};
-  onRemoteDislike = () => {};
   onRemoteJumpBackward = () => {};
   onRemoteJumpForward = () => {};
-  onRemoteLike = () => {};
   onRemoteNext = () => {};
   onRemotePause = () => {};
   onRemotePlay = () => {};
@@ -105,7 +117,6 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
   onRemotePlaySearch = () => {};
   onRemotePrevious = () => {};
   onRemoteSeek = () => {};
-  onRemoteSetRating = () => {};
   onRemoteSkip = () => {};
   onRemoteStop = () => {};
   onOptionsChanged = () => {};
@@ -116,14 +127,19 @@ class NativeAudioBrowser extends _TrackPlayer.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;
@@ -131,7 +147,6 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
   handleRemotePlaySearch = undefined;
   handleRemotePrevious = undefined;
   handleRemoteSeek = undefined;
-  handleRemoteSetRating = undefined;
   handleRemoteSkip = undefined;
   handleRemoteStop = undefined;
 
@@ -145,8 +160,9 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
     this.navigationErrorManager = new _NavigationErrorManager.NavigationErrorManager();
     this.optionsManager = new _OptionsManager.OptionsManager();
     this.nowPlayingManager = new _NowPlayingManager.NowPlayingManager();
+    this.remoteCommands = new _RemoteCommandController.RemoteCommandController(this);
     this.browserManager = new _BrowserManager.BrowserManager(this.httpClient, this.favoriteManager, this.navigationErrorManager);
-    this.searchManager = new _SearchManager.SearchManager(this.browserManager, this.httpClient);
+    this.searchManager = new _SearchManager.SearchManager(this.browserManager);
 
     // Wire up event callbacks from managers to class callbacks
     this.browserManager.onPathChanged = path => this.onPathChanged(path);
@@ -155,7 +171,7 @@ class NativeAudioBrowser extends _TrackPlayer.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') {
@@ -187,52 +203,61 @@ class NativeAudioBrowser extends _TrackPlayer.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 = (0, _PlayingStateFactory.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
     });
   }
@@ -242,9 +267,8 @@ class NativeAudioBrowser extends _TrackPlayer.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);
   }
 
   /**
@@ -304,7 +328,12 @@ class NativeAudioBrowser extends _TrackPlayer.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;
   }
@@ -313,51 +342,49 @@ class NativeAudioBrowser extends _TrackPlayer.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.BrowserPathHelper.isContextual(url)) {
-        const parentPath = _BrowserPathHelper.BrowserPathHelper.stripTrackId(url);
-        const trackId = _BrowserPathHelper.BrowserPathHelper.extractTrackId(url);
-
-        // Optimization: skip to track if already in current queue
-        if (trackId && (await this.trySkipToExistingQueueTrack(trackId, parentPath))) {
+      const nav = (0, _classifyTrackNavigation.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() {
@@ -372,6 +399,9 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
   notifyContentChanged(path) {
     this.browserManager.notifyContentChanged(path);
   }
+  invalidateAllContent() {
+    this.browserManager.invalidateAllContent();
+  }
   setFavorites(favorites) {
     this.favoriteManager.setFavorites(favorites);
   }
@@ -379,6 +409,13 @@ class NativeAudioBrowser extends _TrackPlayer.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
@@ -402,8 +439,27 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
    * Mirrors Android's MediaFactory.getMediaRequestConfig behavior.
    */
   async resolveMediaUrl(src) {
-    const mediaConfig = this.browserManager.configuration.media;
-    return _RequestConfigBuilder.RequestConfigBuilder.resolveMediaUrl(src, mediaConfig);
+    const {
+      request,
+      media
+    } = this.browserManager.configuration;
+    return _RequestConfigBuilder.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();
@@ -413,18 +469,18 @@ class NativeAudioBrowser extends _TrackPlayer.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
@@ -455,7 +511,7 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
         // Update now playing metadata
         const nowPlaying = this.getNowPlaying();
         if (nowPlaying) {
-          this.onNowPlayingChanged(nowPlaying);
+          this.publishNowPlaying(nowPlaying);
         }
 
         // Call the provided callback if any
@@ -467,11 +523,16 @@ class NativeAudioBrowser extends _TrackPlayer.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
       };
@@ -484,15 +545,82 @@ class NativeAudioBrowser extends _TrackPlayer.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;
   }
@@ -500,13 +628,13 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
     return this.state;
   }
   getPlayingState() {
-    return this.getPlayingStateFromPlayback(this.state);
+    return (0, _PlayingStateFactory.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) {
@@ -540,10 +668,32 @@ class NativeAudioBrowser extends _TrackPlayer.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());
@@ -562,9 +712,9 @@ class NativeAudioBrowser extends _TrackPlayer.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;
     }
@@ -574,39 +724,37 @@ class NativeAudioBrowser extends _TrackPlayer.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.RequestConfigBuilder.transformTrackArtwork(hydratedTrack, artworkConfig);
+        return _RequestConfigBuilder.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;
@@ -629,8 +777,8 @@ class NativeAudioBrowser extends _TrackPlayer.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({
@@ -648,7 +796,7 @@ class NativeAudioBrowser extends _TrackPlayer.PlaylistPlayer {
     });
 
     // Emit queue changed so useQueue() hook updates
-    this.onPlaybackQueueChanged(this.playlist);
+    this.emitQueueChanged();
   }
   toggleActiveTrackFavorited() {
     const track = this.getActiveTrack();
@@ -668,6 +816,22 @@ class NativeAudioBrowser extends _TrackPlayer.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() {
@@ -719,13 +883,26 @@ class NativeAudioBrowser extends _TrackPlayer.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;
+  }
 }
 exports.NativeAudioBrowser = NativeAudioBrowser;
 //# sourceMappingURL=NativeAudioBrowser.js.map