react-native-audio-browser 0.0.1 → 0.1.0-next.1

package/lib/module/web/TrackPlayer/SleepTimer.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * Manages a sleep timer that calls a completion callback after a specified duration.
+ *
+ * The timer stores the expiration time as a timestamp and uses setTimeout to schedule the completion
+ * callback. Supports both time-based and end-of-track modes.
+ */
+export class SleepTimerManager {
+  time = null;
+  sleepWhenPlayedToEnd = false;
+  timeoutId = null;
+  get isRunning() {
+    return this.time !== null || this.sleepWhenPlayedToEnd;
+  }
+
+  /**
+   * Sets a timer to complete after the specified number of seconds.
+   *
+   * @param seconds Number of seconds until the timer completes
+   */
+  sleepAfter(seconds) {
+    this.stopTimer();
+    this.sleepWhenPlayedToEnd = false;
+    this.timeoutId = setTimeout(() => {
+      this.complete();
+    }, seconds * 1000);
+    this.time = Date.now() + seconds * 1000;
+  }
+
+  /**
+   * Sets the timer to complete when the current track finishes playing. Note: The actual completion
+   * logic must be handled by the caller when the track ends.
+   */
+  setToEndOfTrack() {
+    this.stopTimer();
+    this.time = null;
+    this.sleepWhenPlayedToEnd = true;
+  }
+
+  /**
+   * Clears the active timer.
+   *
+   * @return true if a timer was running and was cleared, false otherwise
+   */
+  clear() {
+    const wasRunning = this.isRunning;
+    this.stopTimer();
+    this.time = null;
+    this.sleepWhenPlayedToEnd = false;
+    return wasRunning;
+  }
+
+  /** Override this method to handle timer completion. */
+  onComplete() {
+    // Default implementation does nothing - override in subclass
+  }
+  complete() {
+    if (!this.isRunning) return;
+    this.clear();
+    this.onComplete();
+  }
+  stopTimer() {
+    if (this.timeoutId !== null) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+}
+//# sourceMappingURL=SleepTimer.js.map

package/lib/module/web/TrackPlayer/SleepTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SleepTimerManager","time","sleepWhenPlayedToEnd","timeoutId","isRunning","sleepAfter","seconds","stopTimer","setTimeout","complete","Date","now","setToEndOfTrack","clear","wasRunning","onComplete","clearTimeout"],"sourceRoot":"../../../../src","sources":["web/TrackPlayer/SleepTimer.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,iBAAiB,CAAC;EACtBC,IAAI,GAAkB,IAAI;EAC1BC,oBAAoB,GAAY,KAAK;EACpCC,SAAS,GAA0B,IAAI;EAE/C,IAAIC,SAASA,CAAA,EAAY;IACvB,OAAO,IAAI,CAACH,IAAI,KAAK,IAAI,IAAI,IAAI,CAACC,oBAAoB;EACxD;;EAEA;AACF;AACA;AACA;AACA;EACEG,UAAUA,CAACC,OAAe,EAAQ;IAChC,IAAI,CAACC,SAAS,CAAC,CAAC;IAChB,IAAI,CAACL,oBAAoB,GAAG,KAAK;IAEjC,IAAI,CAACC,SAAS,GAAGK,UAAU,CAAC,MAAM;MAChC,IAAI,CAACC,QAAQ,CAAC,CAAC;IACjB,CAAC,EAAEH,OAAO,GAAG,IAAI,CAAC;IAClB,IAAI,CAACL,IAAI,GAAGS,IAAI,CAACC,GAAG,CAAC,CAAC,GAAGL,OAAO,GAAG,IAAI;EACzC;;EAEA;AACF;AACA;AACA;EACEM,eAAeA,CAAA,EAAS;IACtB,IAAI,CAACL,SAAS,CAAC,CAAC;IAChB,IAAI,CAACN,IAAI,GAAG,IAAI;IAChB,IAAI,CAACC,oBAAoB,GAAG,IAAI;EAClC;;EAEA;AACF;AACA;AACA;AACA;EACEW,KAAKA,CAAA,EAAY;IACf,MAAMC,UAAU,GAAG,IAAI,CAACV,SAAS;IACjC,IAAI,CAACG,SAAS,CAAC,CAAC;IAChB,IAAI,CAACN,IAAI,GAAG,IAAI;IAChB,IAAI,CAACC,oBAAoB,GAAG,KAAK;IACjC,OAAOY,UAAU;EACnB;;EAEA;EACUC,UAAUA,CAAA,EAAS;IAC3B;EAAA;EAGMN,QAAQA,CAAA,EAAS;IACvB,IAAI,CAAC,IAAI,CAACL,SAAS,EAAE;IACrB,IAAI,CAACS,KAAK,CAAC,CAAC;IACZ,IAAI,CAACE,UAAU,CAAC,CAAC;EACnB;EAEQR,SAASA,CAAA,EAAS;IACxB,IAAI,IAAI,CAACJ,SAAS,KAAK,IAAI,EAAE;MAC3Ba,YAAY,CAAC,IAAI,CAACb,SAAS,CAAC;MAC5B,IAAI,CAACA,SAAS,GAAG,IAAI;IACvB;EACF;AACF","ignoreList":[]}

package/lib/module/web/TrackPlayer/State.js

@@ -0,0 +1,14 @@
+"use strict";
+
+export const State = {
+  None: 'none',
+  Ready: 'ready',
+  Playing: 'playing',
+  Paused: 'paused',
+  Stopped: 'stopped',
+  Loading: 'loading',
+  Buffering: 'buffering',
+  Error: 'error',
+  Ended: 'ended'
+};
+//# sourceMappingURL=State.js.map

package/lib/module/web/TrackPlayer/State.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["State","None","Ready","Playing","Paused","Stopped","Loading","Buffering","Error","Ended"],"sourceRoot":"../../../../src","sources":["web/TrackPlayer/State.ts"],"mappings":";;AAEA,OAAO,MAAMA,KAAK,GAAG;EACnBC,IAAI,EAAE,MAAM;EACZC,KAAK,EAAE,OAAO;EACdC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE,QAAQ;EAChBC,OAAO,EAAE,SAAS;EAClBC,OAAO,EAAE,SAAS;EAClBC,SAAS,EAAE,WAAW;EACtBC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE;AACT,CAAyC","ignoreList":[]}

package/lib/module/web/TrackPlayer/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export * from './Player';
+export * from './PlaylistPlayer';
+export * from './RepeatMode';
+export { SleepTimerManager } from './SleepTimer';
+//# sourceMappingURL=index.js.map

package/lib/module/web/TrackPlayer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SleepTimerManager"],"sourceRoot":"../../../../src","sources":["web/TrackPlayer/index.ts"],"mappings":";;AAAA,cAAc,UAAU;AACxB,cAAc,kBAAkB;AAChC,cAAc,cAAc;AAC5B,SAASA,iBAAiB,QAAQ,cAAc","ignoreList":[]}

package/lib/module/web/browser/BrowserManager.js

@@ -0,0 +1,583 @@
+"use strict";
+
+import { assertedNotNullish } from '../../utils/validation';
+import { RequestConfigBuilder } from '../http/RequestConfigBuilder';
+import { SimpleRouter } from '../SimpleRouter';
+import { BrowserPathHelper } from '../util/BrowserPathHelper';
+
+/**
+ * Manages browser navigation, route resolution, and content loading.
+ * Coordinates between HTTP client, favorite manager, and error manager.
+ * Matches Android's BrowserManager architecture.
+ */
+export class BrowserManager {
+  _configuration = {};
+  router = new SimpleRouter();
+
+  // Navigation tracking to prevent race conditions (matches Android's @Volatile currentNavigationId)
+  currentNavigationId = 0;
+
+  // Queue expansion tracking (matches Android's queueSourcePath)
+
+  // Event callbacks
+  onPathChanged = () => {};
+  onContentChanged = () => {};
+  onTabsChanged = () => {};
+  constructor(httpClient, favoriteManager, navigationErrorManager) {
+    this.httpClient = httpClient;
+    this.favoriteManager = favoriteManager;
+    this.navigationErrorManager = navigationErrorManager;
+  }
+
+  /**
+   * Handles navigation errors by extracting error details and setting the navigation error.
+   * Extracts code, message, and statusCode from typed errors, or falls back to generic network error.
+   */
+  handleNavigationError(error, path) {
+    if (error && typeof error === 'object' && 'code' in error && 'message' in error && typeof error.message === 'string') {
+      const navError = error;
+      this.navigationErrorManager.setNavigationError(navError.code, navError.message, path, navError.statusCode);
+    } else {
+      this.navigationErrorManager.setNavigationError('network-error', 'Failed to load content', path);
+    }
+  }
+
+  /**
+   * Gets the current navigation path.
+   */
+  get path() {
+    return this._path;
+  }
+
+  /**
+   * Sets the navigation path and triggers navigation.
+   */
+  set path(value) {
+    if (this.hasValidConfiguration()) {
+      this.navigationErrorManager.clearNavigationError();
+      const pathToNavigate = value ?? this._configuration.path ?? this.getDefaultPath();
+      if (pathToNavigate) {
+        void this.navigate(pathToNavigate);
+      }
+    }
+  }
+
+  /**
+   * Gets the current tabs.
+   */
+  get tabs() {
+    return this._tabs;
+  }
+
+  /**
+   * Gets the current content.
+   */
+  get content() {
+    return this._content;
+  }
+
+  /**
+   * Gets the current browser configuration.
+   */
+  get configuration() {
+    return this._configuration;
+  }
+
+  /**
+   * Gets the current queue source path.
+   * Used to track where the current playback queue came from.
+   */
+  get queueSourcePath() {
+    return this._queueSourcePath;
+  }
+
+  /**
+   * Sets the queue source path.
+   */
+  set queueSourcePath(value) {
+    this._queueSourcePath = value;
+  }
+
+  /**
+   * Sets the browser configuration and triggers initial navigation.
+   */
+  set configuration(value) {
+    this._configuration = value;
+    this.navigationErrorManager.clearNavigationError();
+    this.navigationErrorManager.setFormatCallback(value.formatNavigationError);
+
+    // Update HTTP client base config
+    if (value.request) {
+      this.httpClient.setBaseRequestConfig(value.request);
+    }
+
+    // Determine initial path
+    let initialPath = value.path;
+
+    // If no path specified, try to get first tab URL
+    if (!initialPath) {
+      const tabsRoute = value.routes?.find(r => r.path === '__tabs__');
+      if (tabsRoute?.browseStatic?.children?.[0]?.url) {
+        initialPath = tabsRoute.browseStatic.children[0].url;
+      } else {
+        initialPath = '/';
+      }
+    }
+    if (initialPath) {
+      void this.navigate(initialPath);
+    }
+  }
+
+  /**
+   * Navigates to a specific path.
+   */
+  async navigatePath(path) {
+    this.navigationErrorManager.clearNavigationError();
+    await this.navigate(path);
+  }
+
+  /**
+   * Navigates to a track's URL.
+   */
+  async navigateTrack(track) {
+    this.navigationErrorManager.clearNavigationError();
+    const url = track.url;
+    if (!url) {
+      console.warn('Track has no URL to navigate to');
+      return;
+    }
+    await this.navigate(url);
+  }
+
+  /**
+   * Notifies that content at a specific path has changed.
+   * If the path is currently displayed, triggers a refresh.
+   */
+  notifyContentChanged(path) {
+    if (this._path === path) {
+      void this.navigate(path);
+    }
+  }
+
+  /**
+   * Main navigation logic.
+   * Resolves content for the given path and updates state.
+   * Uses navigation ID to prevent race conditions (matches Android's BrowserManager.kt:586-607).
+   */
+  async navigate(path) {
+    // Increment navigation ID and capture for this navigation
+    // This prevents stale responses from overwriting newer ones
+    const navigationId = ++this.currentNavigationId;
+    try {
+      // Update path and clear content immediately to show loading state
+      this._path = path;
+      this._content = undefined;
+      this.onPathChanged(path);
+      this.onContentChanged(undefined);
+
+      // Resolve content for this path
+      // Search paths use a separate code path that doesn't add contextual URLs
+      // This matches Android where search() bypasses resolve() entirely
+      const isSearchPath = path.startsWith(BrowserPathHelper.SEARCH_PATH_PREFIX);
+      let content = isSearchPath ? await this.resolveSearchContent(path) : await this.resolveContent(path);
+
+      // Check if this is still the current navigation before applying result
+      if (navigationId !== this.currentNavigationId) {
+        // A newer navigation started - discard this result
+        return;
+      }
+
+      // Add contextual URLs to non-search content (matches Android behavior where
+      // search() bypasses the resolve() contextual URL logic).
+      // Shallow copy to avoid mutating the original config object (e.g., browseStatic
+      // from routes), which would break search that reads from the same source.
+      if (content?.children && !isSearchPath) {
+        content = {
+          ...content,
+          children: content.children.map(track => {
+            // If track has src, always add/update contextual URL with current path context
+            // This matches Android's BrowserManager.kt:436-441
+            if (track.src) {
+              const contextualUrl = `${path}?__trackId=${encodeURIComponent(track.src)}`;
+              return {
+                ...track,
+                url: contextualUrl
+              };
+            }
+            // Return a shallow copy in attempt to avoid mutating original config objects
+            return {
+              ...track
+            };
+          })
+        };
+      }
+
+      // Hydrate favorites on all children
+      if (content) {
+        content = this.favoriteManager.hydrateChildren(content);
+      }
+
+      // Transform artwork URLs (populates artworkSource)
+      if (content) {
+        content = await this.transformArtworkForContent(content);
+      }
+
+      // Final check before applying result
+      if (navigationId !== this.currentNavigationId) {
+        return;
+      }
+      this._content = content;
+      this.onContentChanged(content);
+
+      // Query and update tabs if configuration has __tabs__ route
+      const tabsRoute = this._configuration.routes?.find(r => r.path === '__tabs__');
+      if (tabsRoute) {
+        const tabs = await this.queryTabs();
+
+        // Check again before applying tabs
+        if (navigationId !== this.currentNavigationId) {
+          return;
+        }
+        this._tabs = tabs;
+        this.onTabsChanged(tabs);
+      }
+    } catch (error) {
+      // Only apply error if this is still the current navigation
+      if (navigationId !== this.currentNavigationId) {
+        return;
+      }
+      console.error('Navigation failed:', error);
+      this._content = undefined;
+      this.onContentChanged(undefined);
+      this.handleNavigationError(error, path);
+    }
+  }
+
+  /**
+   * Resolves search content from a search path.
+   * Returns a ResolvedTrack with raw children (no contextual URLs).
+   * Matches Android's BrowserManager.search() which bypasses resolve() entirely.
+   *
+   * @param searchPath The search path (format: /__search?q=query)
+   * @returns ResolvedTrack containing search results as children
+   */
+  async resolveSearchContent(searchPath) {
+    // Extract query from search path
+    const queryMatch = searchPath.match(/[?&]q=([^&]*)/);
+    if (!queryMatch) {
+      console.warn('Invalid search path, missing query parameter:', searchPath);
+      return undefined;
+    }
+    const query = decodeURIComponent(queryMatch[1] ?? '');
+
+    // Find __search__ route entry
+    const searchRoute = this._configuration.routes?.find(r => r.path === '__search__');
+    if (!searchRoute) {
+      console.warn('No __search__ route configured');
+      return undefined;
+    }
+    let searchResults = [];
+
+    // Handle callback-based search
+    if (searchRoute.searchCallback) {
+      searchResults = await searchRoute.searchCallback({
+        query
+      });
+    }
+    // Handle request config-based search
+    else if (searchRoute.searchConfig) {
+      const searchQueryParams = {
+        q: query
+      };
+      const requestConfig = this.httpClient.mergeRequestConfig(searchRoute.searchConfig, {
+        query: searchQueryParams
+      });
+      try {
+        const response = await this.httpClient.executeRequest(requestConfig);
+        searchResults = Array.isArray(response) ? response : [];
+      } catch (error) {
+        console.error('Search failed:', error);
+        return undefined;
+      }
+    }
+
+    // Create ResolvedTrack with raw children
+    // Search callbacks should return fresh tracks without contextual URLs (like Android)
+    return {
+      url: searchPath,
+      title: `Search: ${query}`,
+      children: searchResults
+    };
+  }
+
+  /**
+   * Transforms artwork URLs for content and its children.
+   * Supports both static config and resolve/transform callbacks.
+   * Matches Android's artwork URL transformation with full Track access.
+   */
+  async transformArtworkForContent(content) {
+    const artworkConfig = this._configuration.artwork;
+    if (!artworkConfig) {
+      return content;
+    }
+
+    // Transform parent artwork
+    const parentArtworkSource = await RequestConfigBuilder.resolveArtworkSourceAsync(content, artworkConfig);
+
+    // Transform children artwork
+    let transformedChildren;
+    if (content.children) {
+      transformedChildren = await Promise.all(content.children.map(async track => {
+        const artworkSource = await RequestConfigBuilder.resolveArtworkSourceAsync(track, artworkConfig);
+        if (artworkSource && !track.artworkSource) {
+          return {
+            ...track,
+            artworkSource
+          };
+        }
+        return track;
+      }));
+    }
+    return {
+      ...content,
+      artworkSource: parentArtworkSource ?? content.artworkSource,
+      children: transformedChildren ?? content.children
+    };
+  }
+
+  /**
+   * Resolves content from a route using browseCallback, browseStatic, or browseConfig.
+   * Single source of truth for route resolution logic.
+   *
+   * @param route The route configuration to resolve
+   * @param path The path being navigated to
+   * @param routeParams Extracted route parameters
+   * @param errorContext Context string for error logging
+   * @returns ResolvedTrack or undefined if resolution fails
+   */
+  async resolveRouteContent(route, path, routeParams, errorContext) {
+    // Handle callback-based route
+    if (route.browseCallback) {
+      const result = await route.browseCallback({
+        path,
+        routeParams
+      });
+      if ('error' in result) {
+        console.error(`${errorContext} browse error:`, result.error);
+        this.navigationErrorManager.setNavigationError('callback-error', result.error, path);
+        return undefined;
+      }
+      return result;
+    }
+
+    // Handle static ResolvedTrack route
+    if (route.browseStatic) {
+      return route.browseStatic;
+    }
+
+    // Handle request config-based route
+    if (route.browseConfig) {
+      const requestConfig = this.httpClient.mergeRequestConfig(route.browseConfig, {
+        path
+      });
+      try {
+        const response = await this.httpClient.executeRequest(requestConfig);
+        return response;
+      } catch (error) {
+        console.error(`Failed to resolve ${errorContext}:`, error);
+        this.handleNavigationError(error, path);
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Resolves content for a specific path using configured routes.
+   */
+  async resolveContent(path) {
+    const routes = this._configuration.routes;
+    if (!routes || routes.length === 0) {
+      return undefined;
+    }
+
+    // Convert routes array to record for SimpleRouter
+    const routePatterns = {};
+    for (const route of routes) {
+      // Skip special routes
+      if (route.path.startsWith('__')) continue;
+      routePatterns[route.path] = {
+        browseCallback: route.browseCallback,
+        browseConfig: route.browseConfig,
+        browseStatic: route.browseStatic
+      };
+    }
+
+    // Try to match route
+    const match = this.router.findBestMatch(path, routePatterns);
+    if (match) {
+      const [matchedPattern, routeMatch] = match;
+      const matchedRoute = routes.find(r => r.path === matchedPattern);
+      if (matchedRoute) {
+        return this.resolveRouteContent(matchedRoute, path, routeMatch.params, 'Route');
+      }
+    }
+
+    // Fall back to __default__ route
+    const defaultRoute = routes.find(r => r.path === '__default__');
+    if (defaultRoute) {
+      return this.resolveRouteContent(defaultRoute, path, {}, 'Default route');
+    }
+    return undefined;
+  }
+
+  /**
+   * Queries tabs from the __tabs__ route.
+   */
+  async queryTabs() {
+    const tabsRoute = this._configuration.routes?.find(r => r.path === '__tabs__');
+    if (!tabsRoute) {
+      return [];
+    }
+    const result = await this.resolveRouteContent(tabsRoute, '/', {}, 'Tabs');
+    const tabs = result?.children ?? [];
+
+    // Transform artwork URLs on tabs
+    return RequestConfigBuilder.transformTracksArtwork(tabs, this._configuration.artwork);
+  }
+
+  /**
+   * Checks if the configuration has valid routes.
+   */
+  hasValidConfiguration() {
+    return this._configuration.routes !== undefined && this._configuration.routes.length > 0;
+  }
+
+  /**
+   * Expands a queue from a contextual URL.
+   * Resolves the parent container to get all siblings.
+   * Matches Android's BrowserManager.expandQueueFromContextualUrl() behavior.
+   *
+   * @param contextualUrl The contextual URL (format: /path?__trackId=trackSrc)
+   * @returns Object with tracks and selectedIndex, or undefined if expansion fails
+   */
+  async expandQueueFromContextualUrl(contextualUrl) {
+    const trackId = BrowserPathHelper.extractTrackId(contextualUrl);
+    if (!trackId) return undefined;
+    try {
+      // Resolve the parent container to get all siblings
+      const parentPath = BrowserPathHelper.stripTrackId(contextualUrl);
+      const parentResolvedTrack = await this.resolveContent(parentPath);
+      const children = parentResolvedTrack?.children;
+      if (!children || children.length === 0) {
+        console.warn('Parent has no children, cannot expand queue');
+        return undefined;
+      }
+
+      // Filter to only playable tracks (tracks with src)
+      const playableTracks = children.filter(track => track.src != null);
+      if (playableTracks.length === 0) {
+        console.warn('Parent has no playable tracks, cannot expand queue');
+        return undefined;
+      }
+
+      // Find the index of the selected track in the playable tracks array
+      const selectedIndex = playableTracks.findIndex(track => track.src === trackId);
+      if (selectedIndex < 0) {
+        console.warn(`Track with src='${trackId}' not found in playable children`);
+        return undefined;
+      }
+
+      // Check singleTrack setting - if true, return only the selected track
+      if (this._configuration.singleTrack) {
+        return {
+          tracks: [assertedNotNullish(playableTracks[selectedIndex])],
+          selectedIndex: 0
+        };
+      }
+      return {
+        tracks: playableTracks,
+        selectedIndex
+      };
+    } catch (error) {
+      console.error(`Error expanding queue from contextual URL: ${contextualUrl}`, error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Resolves media items for playback with queue expansion support.
+   * Handles search results, contextual URLs, and fallback to single track.
+   * Matches Android's BrowserManager.resolveMediaItemsForPlayback() behavior.
+   *
+   * @param tracks The tracks to resolve
+   * @param startIndex The starting index
+   * @param startPositionMs The starting position in milliseconds
+   * @param searchQuery Optional search query that generated these tracks
+   * @returns Object with expanded tracks and starting index
+   */
+  async resolveMediaItemsForPlayback(tracks, startIndex, startPositionMs, searchQuery) {
+    // Single track: check for search context or contextual URL
+    if (tracks.length === 1) {
+      const track = assertedNotNullish(tracks[0]);
+      const trackUrl = track.url;
+
+      // If search query present, expand search results
+      if (searchQuery) {
+        // Execute search (will hit cache if already performed)
+        const searchResults = await this.resolveSearchContent(BrowserPathHelper.createSearchPath(searchQuery));
+        const searchTracks = searchResults?.children;
+        if (searchTracks && searchTracks.length > 0) {
+          // Find the selected track in search results
+          const selectedIdx = searchTracks.findIndex(t => t.url === trackUrl || t.src === track.src);
+          if (selectedIdx >= 0) {
+            return {
+              tracks: searchTracks,
+              startIndex: selectedIdx,
+              startPositionMs
+            };
+          }
+        }
+      }
+
+      // Check if contextual URL - expand from parent
+      // Note: The queueSourcePath optimization is handled by the caller (NativeAudioBrowser.navigateTrackAsync)
+      // which has access to the existing queue and can skip to the track directly.
+      // This matches Android where MediaSessionCallback handles the optimization before calling
+      // BrowserManager.resolveMediaItemsForPlayback.
+      if (trackUrl && BrowserPathHelper.isContextual(trackUrl)) {
+        const parentPath = BrowserPathHelper.stripTrackId(trackUrl);
+        const expanded = await this.expandQueueFromContextualUrl(trackUrl);
+        if (expanded) {
+          // Store source path for optimization by caller on next invocation
+          this._queueSourcePath = parentPath;
+          return {
+            tracks: expanded.tracks,
+            startIndex: expanded.selectedIndex,
+            startPositionMs
+          };
+        }
+      }
+    }
+
+    // No expansion - use tracks as-is
+    return {
+      tracks,
+      startIndex,
+      startPositionMs
+    };
+  }
+
+  /**
+   * Gets the default navigation path (first tab URL or '/').
+   */
+  getDefaultPath() {
+    // Try to get first tab as default path
+    if (this._tabs && this._tabs.length > 0) {
+      const firstTab = this._tabs[0];
+      return firstTab?.url ?? '/';
+    }
+    return '/';
+  }
+}
+//# sourceMappingURL=BrowserManager.js.map