@scarlett-player/embed 0.1.1 → 0.2.0

package/dist/embed.audio.light.js

@@ -0,0 +1,4338 @@
+class Signal {
+  constructor(initialValue) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.value = initialValue;
+  }
+  /**
+   * Get the current value and track dependency if called within an effect.
+   *
+   * @returns Current value
+   */
+  get() {
+    return this.value;
+  }
+  /**
+   * Set a new value and notify subscribers if changed.
+   *
+   * @param newValue - New value to set
+   */
+  set(newValue) {
+    if (Object.is(this.value, newValue)) {
+      return;
+    }
+    this.value = newValue;
+    this.notify();
+  }
+  /**
+   * Update the value using a function.
+   *
+   * @param updater - Function that receives current value and returns new value
+   *
+   * @example
+   * ```ts
+   * const count = new Signal(0);
+   * count.update(n => n + 1); // Increments by 1
+   * ```
+   */
+  update(updater) {
+    this.set(updater(this.value));
+  }
+  /**
+   * Subscribe to changes without automatic dependency tracking.
+   *
+   * @param callback - Function to call when value changes
+   * @returns Unsubscribe function
+   */
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+  /**
+   * Notify all subscribers of a change.
+   * @internal
+   */
+  notify() {
+    this.subscribers.forEach((subscriber) => {
+      try {
+        subscriber();
+      } catch (error) {
+        console.error("[Scarlett Player] Error in signal subscriber:", error);
+      }
+    });
+  }
+  /**
+   * Clean up all subscriptions.
+   * Call this when destroying the signal.
+   */
+  destroy() {
+    this.subscribers.clear();
+  }
+  /**
+   * Get the current number of subscribers (for debugging).
+   * @internal
+   */
+  getSubscriberCount() {
+    return this.subscribers.size;
+  }
+}
+function signal(initialValue) {
+  return new Signal(initialValue);
+}
+const DEFAULT_STATE = {
+  // Core Playback State
+  playbackState: "idle",
+  playing: false,
+  paused: true,
+  ended: false,
+  buffering: false,
+  waiting: false,
+  seeking: false,
+  // Time & Duration
+  currentTime: 0,
+  duration: NaN,
+  buffered: null,
+  bufferedAmount: 0,
+  // Media Info
+  mediaType: "unknown",
+  source: null,
+  title: "",
+  poster: "",
+  // Volume & Audio
+  volume: 1,
+  muted: false,
+  // Playback Controls
+  playbackRate: 1,
+  fullscreen: false,
+  pip: false,
+  controlsVisible: true,
+  // Quality & Tracks
+  qualities: [],
+  currentQuality: null,
+  audioTracks: [],
+  currentAudioTrack: null,
+  textTracks: [],
+  currentTextTrack: null,
+  // Live/DVR State (TSP features)
+  live: false,
+  liveEdge: true,
+  seekableRange: null,
+  liveLatency: 0,
+  lowLatencyMode: false,
+  // Chapters (TSP features)
+  chapters: [],
+  currentChapter: null,
+  // Error State
+  error: null,
+  // Network & Performance
+  bandwidth: 0,
+  autoplay: false,
+  loop: false,
+  // Casting State
+  airplayAvailable: false,
+  airplayActive: false,
+  chromecastAvailable: false,
+  chromecastActive: false,
+  // UI State
+  interacting: false,
+  hovering: false,
+  focused: false
+};
+class StateManager {
+  /**
+   * Create a new StateManager with default initial state.
+   *
+   * @param initialState - Optional partial initial state (merged with defaults)
+   */
+  constructor(initialState) {
+    this.signals = /* @__PURE__ */ new Map();
+    this.changeSubscribers = /* @__PURE__ */ new Set();
+    this.initializeSignals(initialState);
+  }
+  /**
+   * Initialize all state signals with default or provided values.
+   * @private
+   */
+  initializeSignals(overrides) {
+    const initialState = { ...DEFAULT_STATE, ...overrides };
+    for (const [key, value] of Object.entries(initialState)) {
+      const stateKey = key;
+      const stateSignal = signal(value);
+      stateSignal.subscribe(() => {
+        this.notifyChangeSubscribers(stateKey);
+      });
+      this.signals.set(stateKey, stateSignal);
+    }
+  }
+  /**
+   * Get the signal for a state property.
+   *
+   * @param key - State property key
+   * @returns Signal for the property
+   *
+   * @example
+   * ```ts
+   * const playingSignal = state.get('playing');
+   * playingSignal.get(); // false
+   * playingSignal.set(true);
+   * ```
+   */
+  get(key) {
+    const stateSignal = this.signals.get(key);
+    if (!stateSignal) {
+      throw new Error(`[StateManager] Unknown state key: ${key}`);
+    }
+    return stateSignal;
+  }
+  /**
+   * Get the current value of a state property (convenience method).
+   *
+   * @param key - State property key
+   * @returns Current value
+   *
+   * @example
+   * ```ts
+   * state.getValue('playing'); // false
+   * ```
+   */
+  getValue(key) {
+    return this.get(key).get();
+  }
+  /**
+   * Set the value of a state property.
+   *
+   * @param key - State property key
+   * @param value - New value
+   *
+   * @example
+   * ```ts
+   * state.set('playing', true);
+   * state.set('currentTime', 10.5);
+   * ```
+   */
+  set(key, value) {
+    this.get(key).set(value);
+  }
+  /**
+   * Update multiple state properties at once (batch update).
+   *
+   * More efficient than calling set() multiple times.
+   *
+   * @param updates - Partial state object with updates
+   *
+   * @example
+   * ```ts
+   * state.update({
+   *   playing: true,
+   *   currentTime: 0,
+   *   volume: 1.0,
+   * });
+   * ```
+   */
+  update(updates) {
+    for (const [key, value] of Object.entries(updates)) {
+      const stateKey = key;
+      if (this.signals.has(stateKey)) {
+        this.set(stateKey, value);
+      }
+    }
+  }
+  /**
+   * Subscribe to changes on a specific state property.
+   *
+   * @param key - State property key
+   * @param callback - Callback function receiving new value
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * const unsub = state.subscribe('playing', (value) => {
+   *   console.log('Playing:', value);
+   * });
+   * ```
+   */
+  subscribeToKey(key, callback) {
+    const stateSignal = this.get(key);
+    return stateSignal.subscribe(() => {
+      callback(stateSignal.get());
+    });
+  }
+  /**
+   * Subscribe to all state changes.
+   *
+   * Receives a StateChangeEvent for every state property change.
+   *
+   * @param callback - Callback function receiving change events
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * const unsub = state.subscribe((event) => {
+   *   console.log(`${event.key} changed:`, event.value);
+   * });
+   * ```
+   */
+  subscribe(callback) {
+    this.changeSubscribers.add(callback);
+    return () => this.changeSubscribers.delete(callback);
+  }
+  /**
+   * Notify all global change subscribers.
+   * @private
+   */
+  notifyChangeSubscribers(key) {
+    const stateSignal = this.get(key);
+    const value = stateSignal.get();
+    const event = {
+      key,
+      value,
+      previousValue: value
+      // Note: We don't track previous values in this simple impl
+    };
+    this.changeSubscribers.forEach((subscriber) => {
+      try {
+        subscriber(event);
+      } catch (error) {
+        console.error("[StateManager] Error in change subscriber:", error);
+      }
+    });
+  }
+  /**
+   * Reset all state to default values.
+   *
+   * @example
+   * ```ts
+   * state.reset();
+   * ```
+   */
+  reset() {
+    this.update(DEFAULT_STATE);
+  }
+  /**
+   * Reset a specific state property to its default value.
+   *
+   * @param key - State property key
+   *
+   * @example
+   * ```ts
+   * state.resetKey('playing');
+   * ```
+   */
+  resetKey(key) {
+    const defaultValue = DEFAULT_STATE[key];
+    this.set(key, defaultValue);
+  }
+  /**
+   * Get a snapshot of all current state values.
+   *
+   * @returns Frozen snapshot of current state
+   *
+   * @example
+   * ```ts
+   * const snapshot = state.snapshot();
+   * console.log(snapshot.playing, snapshot.currentTime);
+   * ```
+   */
+  snapshot() {
+    const snapshot = {};
+    for (const [key, stateSignal] of this.signals) {
+      snapshot[key] = stateSignal.get();
+    }
+    return Object.freeze(snapshot);
+  }
+  /**
+   * Get the number of subscribers for a state property (for debugging).
+   *
+   * @param key - State property key
+   * @returns Number of subscribers
+   * @internal
+   */
+  getSubscriberCount(key) {
+    return this.signals.get(key)?.getSubscriberCount() ?? 0;
+  }
+  /**
+   * Destroy the state manager and cleanup all signals.
+   *
+   * @example
+   * ```ts
+   * state.destroy();
+   * ```
+   */
+  destroy() {
+    this.signals.forEach((stateSignal) => stateSignal.destroy());
+    this.signals.clear();
+    this.changeSubscribers.clear();
+  }
+}
+const DEFAULT_OPTIONS = {
+  maxListeners: 100,
+  async: false,
+  interceptors: true
+};
+class EventBus {
+  /**
+   * Create a new EventBus.
+   *
+   * @param options - Optional configuration
+   */
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Map();
+    this.onceListeners = /* @__PURE__ */ new Map();
+    this.interceptors = /* @__PURE__ */ new Map();
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Subscribe to an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * const unsub = events.on('playback:play', () => {
+   *   console.log('Playing!');
+   * });
+   *
+   * // Later: unsubscribe
+   * unsub();
+   * ```
+   */
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const handlers = this.listeners.get(event);
+    handlers.add(handler);
+    this.checkMaxListeners(event);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Subscribe to an event once (auto-unsubscribe after first call).
+   *
+   * @param event - Event name
+   * @param handler - Event handler function
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * events.once('player:ready', () => {
+   *   console.log('Player ready!');
+   * });
+   * ```
+   */
+  once(event, handler) {
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const handlers = this.onceListeners.get(event);
+    handlers.add(handler);
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  /**
+   * Unsubscribe from an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler function to remove
+   *
+   * @example
+   * ```ts
+   * const handler = () => console.log('Playing!');
+   * events.on('playback:play', handler);
+   * events.off('playback:play', handler);
+   * ```
+   */
+  off(event, handler) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    }
+    const onceHandlers = this.onceListeners.get(event);
+    if (onceHandlers) {
+      onceHandlers.delete(handler);
+      if (onceHandlers.size === 0) {
+        this.onceListeners.delete(event);
+      }
+    }
+  }
+  /**
+   * Emit an event synchronously.
+   *
+   * Runs interceptors first, then calls all handlers.
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   *
+   * @example
+   * ```ts
+   * events.emit('playback:play', undefined);
+   * events.emit('playback:timeupdate', { currentTime: 10.5 });
+   * ```
+   */
+  emit(event, payload) {
+    const interceptedPayload = this.runInterceptors(event, payload);
+    if (interceptedPayload === null) {
+      return;
+    }
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      const handlersArray = Array.from(handlers);
+      handlersArray.forEach((handler) => {
+        this.safeCallHandler(handler, interceptedPayload);
+      });
+    }
+    const onceHandlers = this.onceListeners.get(event);
+    if (onceHandlers) {
+      const handlersArray = Array.from(onceHandlers);
+      handlersArray.forEach((handler) => {
+        this.safeCallHandler(handler, interceptedPayload);
+      });
+      this.onceListeners.delete(event);
+    }
+  }
+  /**
+   * Emit an event asynchronously (next tick).
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   * @returns Promise that resolves when all handlers complete
+   *
+   * @example
+   * ```ts
+   * await events.emitAsync('media:loaded', { src: 'video.mp4', type: 'video/mp4' });
+   * ```
+   */
+  async emitAsync(event, payload) {
+    const interceptedPayload = await this.runInterceptorsAsync(event, payload);
+    if (interceptedPayload === null) {
+      return;
+    }
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      const promises = Array.from(handlers).map(
+        (handler) => this.safeCallHandlerAsync(handler, interceptedPayload)
+      );
+      await Promise.all(promises);
+    }
+    const onceHandlers = this.onceListeners.get(event);
+    if (onceHandlers) {
+      const handlersArray = Array.from(onceHandlers);
+      const promises = handlersArray.map(
+        (handler) => this.safeCallHandlerAsync(handler, interceptedPayload)
+      );
+      await Promise.all(promises);
+      this.onceListeners.delete(event);
+    }
+  }
+  /**
+   * Add an event interceptor.
+   *
+   * Interceptors run before handlers and can modify or cancel events.
+   *
+   * @param event - Event name
+   * @param interceptor - Interceptor function
+   * @returns Remove interceptor function
+   *
+   * @example
+   * ```ts
+   * events.intercept('playback:timeupdate', (payload) => {
+   *   // Round time to 2 decimals
+   *   return { currentTime: Math.round(payload.currentTime * 100) / 100 };
+   * });
+   *
+   * // Cancel events
+   * events.intercept('playback:play', (payload) => {
+   *   if (notReady) return null; // Cancel event
+   *   return payload;
+   * });
+   * ```
+   */
+  intercept(event, interceptor) {
+    if (!this.options.interceptors) {
+      return () => {
+      };
+    }
+    if (!this.interceptors.has(event)) {
+      this.interceptors.set(event, /* @__PURE__ */ new Set());
+    }
+    const interceptorsSet = this.interceptors.get(event);
+    interceptorsSet.add(interceptor);
+    return () => {
+      interceptorsSet.delete(interceptor);
+      if (interceptorsSet.size === 0) {
+        this.interceptors.delete(event);
+      }
+    };
+  }
+  /**
+   * Remove all listeners for an event (or all events if no event specified).
+   *
+   * @param event - Optional event name
+   *
+   * @example
+   * ```ts
+   * events.removeAllListeners('playback:play'); // Remove all playback:play listeners
+   * events.removeAllListeners(); // Remove ALL listeners
+   * ```
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+      this.onceListeners.delete(event);
+    } else {
+      this.listeners.clear();
+      this.onceListeners.clear();
+    }
+  }
+  /**
+   * Get the number of listeners for an event.
+   *
+   * @param event - Event name
+   * @returns Number of listeners
+   *
+   * @example
+   * ```ts
+   * events.listenerCount('playback:play'); // 3
+   * ```
+   */
+  listenerCount(event) {
+    const regularCount = this.listeners.get(event)?.size ?? 0;
+    const onceCount = this.onceListeners.get(event)?.size ?? 0;
+    return regularCount + onceCount;
+  }
+  /**
+   * Destroy event bus and cleanup all listeners/interceptors.
+   *
+   * @example
+   * ```ts
+   * events.destroy();
+   * ```
+   */
+  destroy() {
+    this.listeners.clear();
+    this.onceListeners.clear();
+    this.interceptors.clear();
+  }
+  /**
+   * Run interceptors synchronously.
+   * @private
+   */
+  runInterceptors(event, payload) {
+    if (!this.options.interceptors) {
+      return payload;
+    }
+    const interceptorsSet = this.interceptors.get(event);
+    if (!interceptorsSet || interceptorsSet.size === 0) {
+      return payload;
+    }
+    let currentPayload = payload;
+    for (const interceptor of interceptorsSet) {
+      try {
+        currentPayload = interceptor(currentPayload);
+        if (currentPayload === null) {
+          return null;
+        }
+      } catch (error) {
+        console.error("[EventBus] Error in interceptor:", error);
+      }
+    }
+    return currentPayload;
+  }
+  /**
+   * Run interceptors asynchronously.
+   * @private
+   */
+  async runInterceptorsAsync(event, payload) {
+    if (!this.options.interceptors) {
+      return payload;
+    }
+    const interceptorsSet = this.interceptors.get(event);
+    if (!interceptorsSet || interceptorsSet.size === 0) {
+      return payload;
+    }
+    let currentPayload = payload;
+    for (const interceptor of interceptorsSet) {
+      try {
+        const result = interceptor(currentPayload);
+        currentPayload = result instanceof Promise ? await result : result;
+        if (currentPayload === null) {
+          return null;
+        }
+      } catch (error) {
+        console.error("[EventBus] Error in interceptor:", error);
+      }
+    }
+    return currentPayload;
+  }
+  /**
+   * Safely call a handler with error handling.
+   * @private
+   */
+  safeCallHandler(handler, payload) {
+    try {
+      handler(payload);
+    } catch (error) {
+      console.error("[EventBus] Error in event handler:", error);
+    }
+  }
+  /**
+   * Safely call a handler asynchronously with error handling.
+   * @private
+   */
+  async safeCallHandlerAsync(handler, payload) {
+    try {
+      const result = handler(payload);
+      if (result instanceof Promise) {
+        await result;
+      }
+    } catch (error) {
+      console.error("[EventBus] Error in event handler:", error);
+    }
+  }
+  /**
+   * Check if max listeners exceeded and warn.
+   * @private
+   */
+  checkMaxListeners(event) {
+    const count = this.listenerCount(event);
+    if (count > this.options.maxListeners) {
+      console.warn(
+        `[EventBus] Max listeners (${this.options.maxListeners}) exceeded for event: ${event}. Current count: ${count}. This may indicate a memory leak.`
+      );
+    }
+  }
+}
+const LOG_LEVELS = ["debug", "info", "warn", "error"];
+const defaultConsoleHandler = (entry) => {
+  const prefix = entry.scope ? `[${entry.scope}]` : "[ScarlettPlayer]";
+  const message = `${prefix} ${entry.message}`;
+  const metadata = entry.metadata ?? "";
+  switch (entry.level) {
+    case "debug":
+      console.debug(message, metadata);
+      break;
+    case "info":
+      console.info(message, metadata);
+      break;
+    case "warn":
+      console.warn(message, metadata);
+      break;
+    case "error":
+      console.error(message, metadata);
+      break;
+  }
+};
+class Logger {
+  /**
+   * Create a new Logger.
+   *
+   * @param options - Logger configuration
+   */
+  constructor(options) {
+    this.level = options?.level ?? "warn";
+    this.scope = options?.scope;
+    this.enabled = options?.enabled ?? true;
+    this.handlers = options?.handlers ?? [defaultConsoleHandler];
+  }
+  /**
+   * Create a child logger with a scope.
+   *
+   * Child loggers inherit parent settings and chain scopes.
+   *
+   * @param scope - Child logger scope
+   * @returns New child logger
+   *
+   * @example
+   * ```ts
+   * const logger = new Logger();
+   * const hlsLogger = logger.child('hls-plugin');
+   * hlsLogger.info('Loading manifest');
+   * // Output: [ScarlettPlayer:hls-plugin] Loading manifest
+   * ```
+   */
+  child(scope) {
+    return new Logger({
+      level: this.level,
+      scope: this.scope ? `${this.scope}:${scope}` : scope,
+      enabled: this.enabled,
+      handlers: this.handlers
+    });
+  }
+  /**
+   * Log a debug message.
+   *
+   * @param message - Log message
+   * @param metadata - Optional structured metadata
+   *
+   * @example
+   * ```ts
+   * logger.debug('Request sent', { url: '/api/video' });
+   * ```
+   */
+  debug(message, metadata) {
+    this.log("debug", message, metadata);
+  }
+  /**
+   * Log an info message.
+   *
+   * @param message - Log message
+   * @param metadata - Optional structured metadata
+   *
+   * @example
+   * ```ts
+   * logger.info('Player ready');
+   * ```
+   */
+  info(message, metadata) {
+    this.log("info", message, metadata);
+  }
+  /**
+   * Log a warning message.
+   *
+   * @param message - Log message
+   * @param metadata - Optional structured metadata
+   *
+   * @example
+   * ```ts
+   * logger.warn('Low buffer', { buffered: 2.5 });
+   * ```
+   */
+  warn(message, metadata) {
+    this.log("warn", message, metadata);
+  }
+  /**
+   * Log an error message.
+   *
+   * @param message - Log message
+   * @param metadata - Optional structured metadata
+   *
+   * @example
+   * ```ts
+   * logger.error('Playback failed', { code: 'MEDIA_ERR_DECODE' });
+   * ```
+   */
+  error(message, metadata) {
+    this.log("error", message, metadata);
+  }
+  /**
+   * Set the minimum log level threshold.
+   *
+   * @param level - New log level
+   *
+   * @example
+   * ```ts
+   * logger.setLevel('debug'); // Show all logs
+   * logger.setLevel('error'); // Show only errors
+   * ```
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Enable or disable logging.
+   *
+   * @param enabled - Enable flag
+   *
+   * @example
+   * ```ts
+   * logger.setEnabled(false); // Disable all logging
+   * ```
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Add a custom log handler.
+   *
+   * @param handler - Log handler function
+   *
+   * @example
+   * ```ts
+   * logger.addHandler((entry) => {
+   *   if (entry.level === 'error') {
+   *     sendToAnalytics(entry);
+   *   }
+   * });
+   * ```
+   */
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  /**
+   * Remove a custom log handler.
+   *
+   * @param handler - Log handler function to remove
+   *
+   * @example
+   * ```ts
+   * logger.removeHandler(myHandler);
+   * ```
+   */
+  removeHandler(handler) {
+    const index = this.handlers.indexOf(handler);
+    if (index !== -1) {
+      this.handlers.splice(index, 1);
+    }
+  }
+  /**
+   * Core logging implementation.
+   * @private
+   */
+  log(level, message, metadata) {
+    if (!this.enabled || !this.shouldLog(level)) {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      timestamp: Date.now(),
+      scope: this.scope,
+      metadata
+    };
+    for (const handler of this.handlers) {
+      try {
+        handler(entry);
+      } catch (error) {
+        console.error("[Logger] Handler error:", error);
+      }
+    }
+  }
+  /**
+   * Check if a log level should be output.
+   * @private
+   */
+  shouldLog(level) {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(this.level);
+  }
+}
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["SOURCE_NOT_SUPPORTED"] = "SOURCE_NOT_SUPPORTED";
+  ErrorCode2["SOURCE_LOAD_FAILED"] = "SOURCE_LOAD_FAILED";
+  ErrorCode2["PROVIDER_NOT_FOUND"] = "PROVIDER_NOT_FOUND";
+  ErrorCode2["PROVIDER_SETUP_FAILED"] = "PROVIDER_SETUP_FAILED";
+  ErrorCode2["PLUGIN_SETUP_FAILED"] = "PLUGIN_SETUP_FAILED";
+  ErrorCode2["PLUGIN_NOT_FOUND"] = "PLUGIN_NOT_FOUND";
+  ErrorCode2["PLAYBACK_FAILED"] = "PLAYBACK_FAILED";
+  ErrorCode2["MEDIA_DECODE_ERROR"] = "MEDIA_DECODE_ERROR";
+  ErrorCode2["MEDIA_NETWORK_ERROR"] = "MEDIA_NETWORK_ERROR";
+  ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return ErrorCode2;
+})(ErrorCode || {});
+class ErrorHandler {
+  /**
+   * Create a new ErrorHandler.
+   *
+   * @param eventBus - Event bus for error emission
+   * @param logger - Logger for error logging
+   * @param options - Optional configuration
+   */
+  constructor(eventBus, logger, options) {
+    this.errors = [];
+    this.eventBus = eventBus;
+    this.logger = logger;
+    this.maxHistory = options?.maxHistory ?? 10;
+  }
+  /**
+   * Handle an error.
+   *
+   * Normalizes, logs, emits, and tracks the error.
+   *
+   * @param error - Error to handle (native or PlayerError)
+   * @param context - Optional context (what was happening)
+   * @returns Normalized PlayerError
+   *
+   * @example
+   * ```ts
+   * try {
+   *   loadVideo();
+   * } catch (error) {
+   *   errorHandler.handle(error as Error, { src: 'video.mp4' });
+   * }
+   * ```
+   */
+  handle(error, context) {
+    const playerError = this.normalizeError(error, context);
+    this.addToHistory(playerError);
+    this.logError(playerError);
+    this.eventBus.emit("error", playerError);
+    return playerError;
+  }
+  /**
+   * Create and handle an error from code.
+   *
+   * @param code - Error code
+   * @param message - Error message
+   * @param options - Optional error options
+   * @returns Created PlayerError
+   *
+   * @example
+   * ```ts
+   * errorHandler.throw(
+   *   ErrorCode.SOURCE_NOT_SUPPORTED,
+   *   'MP4 not supported',
+   *   { fatal: true, context: { type: 'video/mp4' } }
+   * );
+   * ```
+   */
+  throw(code, message, options) {
+    const error = {
+      code,
+      message,
+      fatal: options?.fatal ?? this.isFatalCode(code),
+      timestamp: Date.now(),
+      context: options?.context,
+      originalError: options?.originalError
+    };
+    return this.handle(error, options?.context);
+  }
+  /**
+   * Get error history.
+   *
+   * @returns Readonly copy of error history
+   *
+   * @example
+   * ```ts
+   * const history = errorHandler.getHistory();
+   * console.log(`${history.length} errors occurred`);
+   * ```
+   */
+  getHistory() {
+    return [...this.errors];
+  }
+  /**
+   * Get last error that occurred.
+   *
+   * @returns Last error or null if none
+   *
+   * @example
+   * ```ts
+   * const lastError = errorHandler.getLastError();
+   * if (lastError?.fatal) {
+   *   showErrorMessage(lastError.message);
+   * }
+   * ```
+   */
+  getLastError() {
+    return this.errors[this.errors.length - 1] ?? null;
+  }
+  /**
+   * Clear error history.
+   *
+   * @example
+   * ```ts
+   * errorHandler.clearHistory();
+   * ```
+   */
+  clearHistory() {
+    this.errors = [];
+  }
+  /**
+   * Check if any fatal errors occurred.
+   *
+   * @returns True if any fatal error in history
+   *
+   * @example
+   * ```ts
+   * if (errorHandler.hasFatalError()) {
+   *   player.reset();
+   * }
+   * ```
+   */
+  hasFatalError() {
+    return this.errors.some((e) => e.fatal);
+  }
+  /**
+   * Normalize error to PlayerError.
+   * @private
+   */
+  normalizeError(error, context) {
+    if (this.isPlayerError(error)) {
+      return {
+        ...error,
+        context: { ...error.context, ...context }
+      };
+    }
+    return {
+      code: this.getErrorCode(error),
+      message: error.message,
+      fatal: this.isFatal(error),
+      timestamp: Date.now(),
+      context,
+      originalError: error
+    };
+  }
+  /**
+   * Determine error code from native Error.
+   * @private
+   */
+  getErrorCode(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("network")) {
+      return "MEDIA_NETWORK_ERROR";
+    }
+    if (message.includes("decode")) {
+      return "MEDIA_DECODE_ERROR";
+    }
+    if (message.includes("source")) {
+      return "SOURCE_LOAD_FAILED";
+    }
+    if (message.includes("plugin")) {
+      return "PLUGIN_SETUP_FAILED";
+    }
+    if (message.includes("provider")) {
+      return "PROVIDER_SETUP_FAILED";
+    }
+    return "UNKNOWN_ERROR";
+  }
+  /**
+   * Determine if error is fatal.
+   * @private
+   */
+  isFatal(error) {
+    return this.isFatalCode(this.getErrorCode(error));
+  }
+  /**
+   * Determine if error code is fatal.
+   * @private
+   */
+  isFatalCode(code) {
+    const fatalCodes = [
+      "SOURCE_NOT_SUPPORTED",
+      "PROVIDER_NOT_FOUND",
+      "MEDIA_DECODE_ERROR"
+      /* MEDIA_DECODE_ERROR */
+    ];
+    return fatalCodes.includes(code);
+  }
+  /**
+   * Type guard for PlayerError.
+   * @private
+   */
+  isPlayerError(error) {
+    return typeof error === "object" && error !== null && "code" in error && "message" in error && "fatal" in error && "timestamp" in error;
+  }
+  /**
+   * Add error to history.
+   * @private
+   */
+  addToHistory(error) {
+    this.errors.push(error);
+    if (this.errors.length > this.maxHistory) {
+      this.errors.shift();
+    }
+  }
+  /**
+   * Log error with appropriate level.
+   * @private
+   */
+  logError(error) {
+    const logMessage = `[${error.code}] ${error.message}`;
+    if (error.fatal) {
+      this.logger.error(logMessage, {
+        code: error.code,
+        context: error.context
+      });
+    } else {
+      this.logger.warn(logMessage, {
+        code: error.code,
+        context: error.context
+      });
+    }
+  }
+}
+class PluginAPI {
+  /**
+   * Create a new PluginAPI.
+   *
+   * @param pluginId - ID of the plugin this API belongs to
+   * @param deps - Dependencies (stateManager, eventBus, logger, container, getPlugin)
+   */
+  constructor(pluginId, deps) {
+    this.cleanupFns = [];
+    this.pluginId = pluginId;
+    this.stateManager = deps.stateManager;
+    this.eventBus = deps.eventBus;
+    this.container = deps.container;
+    this.getPluginFn = deps.getPlugin;
+    this.logger = {
+      debug: (msg, metadata) => deps.logger.debug(`[${pluginId}] ${msg}`, metadata),
+      info: (msg, metadata) => deps.logger.info(`[${pluginId}] ${msg}`, metadata),
+      warn: (msg, metadata) => deps.logger.warn(`[${pluginId}] ${msg}`, metadata),
+      error: (msg, metadata) => deps.logger.error(`[${pluginId}] ${msg}`, metadata)
+    };
+  }
+  /**
+   * Get a state value.
+   *
+   * @param key - State property key
+   * @returns Current state value
+   */
+  getState(key) {
+    return this.stateManager.getValue(key);
+  }
+  /**
+   * Set a state value.
+   *
+   * @param key - State property key
+   * @param value - New state value
+   */
+  setState(key, value) {
+    this.stateManager.set(key, value);
+  }
+  /**
+   * Subscribe to an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns Unsubscribe function
+   */
+  on(event, handler) {
+    return this.eventBus.on(event, handler);
+  }
+  /**
+   * Unsubscribe from an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler to remove
+   */
+  off(event, handler) {
+    this.eventBus.off(event, handler);
+  }
+  /**
+   * Emit an event.
+   *
+   * @param event - Event name
+   * @param payload - Event payload
+   */
+  emit(event, payload) {
+    this.eventBus.emit(event, payload);
+  }
+  /**
+   * Get another plugin by ID (if ready).
+   *
+   * @param id - Plugin ID
+   * @returns Plugin instance or null if not found/ready
+   */
+  getPlugin(id) {
+    return this.getPluginFn(id);
+  }
+  /**
+   * Register a cleanup function to run when plugin is destroyed.
+   *
+   * @param cleanup - Cleanup function
+   */
+  onDestroy(cleanup) {
+    this.cleanupFns.push(cleanup);
+  }
+  /**
+   * Subscribe to state changes.
+   *
+   * @param callback - Callback function called on any state change
+   * @returns Unsubscribe function
+   */
+  subscribeToState(callback) {
+    return this.stateManager.subscribe(callback);
+  }
+  /**
+   * Run all registered cleanup functions.
+   * Called by PluginManager when destroying the plugin.
+   *
+   * @internal
+   */
+  runCleanups() {
+    for (const cleanup of this.cleanupFns) {
+      try {
+        cleanup();
+      } catch (error) {
+        this.logger.error("Cleanup function failed", { error });
+      }
+    }
+    this.cleanupFns = [];
+  }
+  /**
+   * Get all registered cleanup functions.
+   *
+   * @returns Array of cleanup functions
+   * @internal
+   */
+  getCleanupFns() {
+    return this.cleanupFns;
+  }
+}
+class PluginManager {
+  constructor(eventBus, stateManager, logger, options) {
+    this.plugins = /* @__PURE__ */ new Map();
+    this.eventBus = eventBus;
+    this.stateManager = stateManager;
+    this.logger = logger;
+    this.container = options.container;
+  }
+  /** Register a plugin with optional configuration. */
+  register(plugin, config) {
+    if (this.plugins.has(plugin.id)) {
+      throw new Error(`Plugin "${plugin.id}" is already registered`);
+    }
+    this.validatePlugin(plugin);
+    const api = new PluginAPI(plugin.id, {
+      stateManager: this.stateManager,
+      eventBus: this.eventBus,
+      logger: this.logger,
+      container: this.container,
+      getPlugin: (id) => this.getReadyPlugin(id)
+    });
+    this.plugins.set(plugin.id, {
+      plugin,
+      state: "registered",
+      config,
+      cleanupFns: [],
+      api
+    });
+    this.logger.info(`Plugin registered: ${plugin.id}`);
+    this.eventBus.emit("plugin:registered", { name: plugin.id, type: plugin.type });
+  }
+  /** Unregister a plugin. Destroys it first if active. */
+  async unregister(id) {
+    const record = this.plugins.get(id);
+    if (!record) return;
+    if (record.state === "ready") {
+      await this.destroyPlugin(id);
+    }
+    this.plugins.delete(id);
+    this.logger.info(`Plugin unregistered: ${id}`);
+  }
+  /** Initialize all registered plugins in dependency order. */
+  async initAll() {
+    const order = this.resolveDependencyOrder();
+    for (const id of order) {
+      await this.initPlugin(id);
+    }
+  }
+  /** Initialize a specific plugin. */
+  async initPlugin(id) {
+    const record = this.plugins.get(id);
+    if (!record) {
+      throw new Error(`Plugin "${id}" not found`);
+    }
+    if (record.state === "ready") return;
+    if (record.state === "initializing") {
+      throw new Error(`Plugin "${id}" is already initializing (possible circular dependency)`);
+    }
+    for (const depId of record.plugin.dependencies || []) {
+      const dep = this.plugins.get(depId);
+      if (!dep) {
+        throw new Error(`Plugin "${id}" depends on missing plugin "${depId}"`);
+      }
+      if (dep.state !== "ready") {
+        await this.initPlugin(depId);
+      }
+    }
+    try {
+      record.state = "initializing";
+      if (record.plugin.onStateChange) {
+        const unsub = this.stateManager.subscribe(record.plugin.onStateChange.bind(record.plugin));
+        record.api.onDestroy(unsub);
+      }
+      if (record.plugin.onError) {
+        const unsub = this.eventBus.on("error", (err) => {
+          record.plugin.onError?.(err.originalError || new Error(err.message));
+        });
+        record.api.onDestroy(unsub);
+      }
+      await record.plugin.init(record.api, record.config);
+      record.state = "ready";
+      this.logger.info(`Plugin ready: ${id}`);
+      this.eventBus.emit("plugin:active", { name: id });
+    } catch (error) {
+      record.state = "error";
+      record.error = error;
+      this.logger.error(`Plugin init failed: ${id}`, { error });
+      this.eventBus.emit("plugin:error", { name: id, error });
+      throw error;
+    }
+  }
+  /** Destroy all plugins in reverse dependency order. */
+  async destroyAll() {
+    const order = this.resolveDependencyOrder().reverse();
+    for (const id of order) {
+      await this.destroyPlugin(id);
+    }
+  }
+  /** Destroy a specific plugin. */
+  async destroyPlugin(id) {
+    const record = this.plugins.get(id);
+    if (!record || record.state !== "ready") return;
+    try {
+      await record.plugin.destroy();
+      record.api.runCleanups();
+      record.state = "registered";
+      this.logger.info(`Plugin destroyed: ${id}`);
+      this.eventBus.emit("plugin:destroyed", { name: id });
+    } catch (error) {
+      this.logger.error(`Plugin destroy failed: ${id}`, { error });
+      record.state = "registered";
+    }
+  }
+  /** Get a plugin by ID (returns any registered plugin). */
+  getPlugin(id) {
+    const record = this.plugins.get(id);
+    return record ? record.plugin : null;
+  }
+  /** Get a plugin by ID only if ready (used by PluginAPI). */
+  getReadyPlugin(id) {
+    const record = this.plugins.get(id);
+    return record?.state === "ready" ? record.plugin : null;
+  }
+  /** Check if a plugin is registered. */
+  hasPlugin(id) {
+    return this.plugins.has(id);
+  }
+  /** Get plugin state. */
+  getPluginState(id) {
+    return this.plugins.get(id)?.state ?? null;
+  }
+  /** Get all registered plugin IDs. */
+  getPluginIds() {
+    return Array.from(this.plugins.keys());
+  }
+  /** Get all ready plugins. */
+  getReadyPlugins() {
+    return Array.from(this.plugins.values()).filter((r) => r.state === "ready").map((r) => r.plugin);
+  }
+  /** Get plugins by type. */
+  getPluginsByType(type) {
+    return Array.from(this.plugins.values()).filter((r) => r.plugin.type === type).map((r) => r.plugin);
+  }
+  /** Select a provider plugin that can play a source. */
+  selectProvider(source) {
+    const providers = this.getPluginsByType("provider");
+    for (const provider of providers) {
+      const canPlay = provider.canPlay;
+      if (typeof canPlay === "function" && canPlay(source)) {
+        return provider;
+      }
+    }
+    return null;
+  }
+  /** Resolve plugin initialization order using topological sort. */
+  resolveDependencyOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const sorted = [];
+    const visit = (id, path = []) => {
+      if (visited.has(id)) return;
+      if (visiting.has(id)) {
+        const cycle = [...path, id].join(" -> ");
+        throw new Error(`Circular dependency detected: ${cycle}`);
+      }
+      const record = this.plugins.get(id);
+      if (!record) return;
+      visiting.add(id);
+      for (const depId of record.plugin.dependencies || []) {
+        if (this.plugins.has(depId)) {
+          visit(depId, [...path, id]);
+        }
+      }
+      visiting.delete(id);
+      visited.add(id);
+      sorted.push(id);
+    };
+    for (const id of this.plugins.keys()) {
+      visit(id);
+    }
+    return sorted;
+  }
+  /** Validate plugin has required properties. */
+  validatePlugin(plugin) {
+    if (!plugin.id || typeof plugin.id !== "string") {
+      throw new Error("Plugin must have a valid id");
+    }
+    if (!plugin.name || typeof plugin.name !== "string") {
+      throw new Error(`Plugin "${plugin.id}" must have a valid name`);
+    }
+    if (!plugin.version || typeof plugin.version !== "string") {
+      throw new Error(`Plugin "${plugin.id}" must have a valid version`);
+    }
+    if (!plugin.type || typeof plugin.type !== "string") {
+      throw new Error(`Plugin "${plugin.id}" must have a valid type`);
+    }
+    if (typeof plugin.init !== "function") {
+      throw new Error(`Plugin "${plugin.id}" must have an init() method`);
+    }
+    if (typeof plugin.destroy !== "function") {
+      throw new Error(`Plugin "${plugin.id}" must have a destroy() method`);
+    }
+  }
+}
+class ScarlettPlayer {
+  /**
+   * Create a new ScarlettPlayer.
+   *
+   * @param options - Player configuration
+   */
+  constructor(options) {
+    this._currentProvider = null;
+    this.destroyed = false;
+    this.seekingWhilePlaying = false;
+    this.seekResumeTimeout = null;
+    if (typeof options.container === "string") {
+      const el = document.querySelector(options.container);
+      if (!el || !(el instanceof HTMLElement)) {
+        throw new Error(`ScarlettPlayer: container not found: ${options.container}`);
+      }
+      this.container = el;
+    } else if (options.container instanceof HTMLElement) {
+      this.container = options.container;
+    } else {
+      throw new Error("ScarlettPlayer requires a valid HTMLElement container or CSS selector");
+    }
+    this.initialSrc = options.src;
+    this.eventBus = new EventBus();
+    this.stateManager = new StateManager({
+      autoplay: options.autoplay ?? false,
+      loop: options.loop ?? false,
+      volume: options.volume ?? 1,
+      muted: options.muted ?? false,
+      poster: options.poster ?? ""
+    });
+    this.logger = new Logger({
+      level: options.logLevel ?? "warn",
+      scope: "ScarlettPlayer"
+    });
+    this.errorHandler = new ErrorHandler(this.eventBus, this.logger);
+    this.pluginManager = new PluginManager(
+      this.eventBus,
+      this.stateManager,
+      this.logger,
+      { container: this.container }
+    );
+    if (options.plugins) {
+      for (const plugin of options.plugins) {
+        this.pluginManager.register(plugin);
+      }
+    }
+    this.logger.info("ScarlettPlayer initialized", {
+      autoplay: options.autoplay,
+      plugins: options.plugins?.length ?? 0
+    });
+    this.eventBus.emit("player:ready", void 0);
+  }
+  /**
+   * Initialize the player asynchronously.
+   * Initializes non-provider plugins and loads initial source if provided.
+   */
+  async init() {
+    this.checkDestroyed();
+    for (const [id, record] of this.pluginManager.plugins) {
+      if (record.plugin.type !== "provider" && record.state === "registered") {
+        await this.pluginManager.initPlugin(id);
+      }
+    }
+    if (this.initialSrc) {
+      await this.load(this.initialSrc);
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Load a media source.
+   *
+   * Selects appropriate provider plugin and loads the source.
+   *
+   * @param source - Media source URL
+   * @returns Promise that resolves when source is loaded
+   *
+   * @example
+   * ```ts
+   * await player.load('video.m3u8');
+   * ```
+   */
+  async load(source) {
+    this.checkDestroyed();
+    try {
+      this.logger.info("Loading source", { source });
+      this.stateManager.update({
+        playing: false,
+        paused: true,
+        ended: false,
+        buffering: true,
+        currentTime: 0,
+        duration: 0,
+        bufferedAmount: 0,
+        playbackState: "loading"
+      });
+      if (this._currentProvider) {
+        const previousProviderId = this._currentProvider.id;
+        this.logger.info("Destroying previous provider", { provider: previousProviderId });
+        await this.pluginManager.destroyPlugin(previousProviderId);
+        this._currentProvider = null;
+      }
+      const provider = this.pluginManager.selectProvider(source);
+      if (!provider) {
+        this.errorHandler.throw(
+          ErrorCode.PROVIDER_NOT_FOUND,
+          `No provider found for source: ${source}`,
+          {
+            fatal: true,
+            context: { source }
+          }
+        );
+        return;
+      }
+      this._currentProvider = provider;
+      this.logger.info("Provider selected", { provider: provider.id });
+      await this.pluginManager.initPlugin(provider.id);
+      this.stateManager.set("source", { src: source, type: this.detectMimeType(source) });
+      if (typeof provider.loadSource === "function") {
+        await provider.loadSource(source);
+      }
+      if (this.stateManager.getValue("autoplay")) {
+        await this.play();
+      }
+    } catch (error) {
+      this.errorHandler.handle(error, {
+        operation: "load",
+        source
+      });
+    }
+  }
+  /**
+   * Start playback.
+   *
+   * @returns Promise that resolves when playback starts
+   *
+   * @example
+   * ```ts
+   * await player.play();
+   * ```
+   */
+  async play() {
+    this.checkDestroyed();
+    try {
+      this.logger.debug("Play requested");
+      this.eventBus.emit("playback:play", void 0);
+    } catch (error) {
+      this.errorHandler.handle(error, { operation: "play" });
+    }
+  }
+  /**
+   * Pause playback.
+   *
+   * @example
+   * ```ts
+   * player.pause();
+   * ```
+   */
+  pause() {
+    this.checkDestroyed();
+    try {
+      this.logger.debug("Pause requested");
+      this.seekingWhilePlaying = false;
+      if (this.seekResumeTimeout !== null) {
+        clearTimeout(this.seekResumeTimeout);
+        this.seekResumeTimeout = null;
+      }
+      this.eventBus.emit("playback:pause", void 0);
+    } catch (error) {
+      this.errorHandler.handle(error, { operation: "pause" });
+    }
+  }
+  /**
+   * Seek to a specific time.
+   *
+   * @param time - Time in seconds
+   *
+   * @example
+   * ```ts
+   * player.seek(30); // Seek to 30 seconds
+   * ```
+   */
+  seek(time) {
+    this.checkDestroyed();
+    try {
+      this.logger.debug("Seek requested", { time });
+      const wasPlaying = this.stateManager.getValue("playing");
+      if (wasPlaying) {
+        this.seekingWhilePlaying = true;
+      }
+      if (this.seekResumeTimeout !== null) {
+        clearTimeout(this.seekResumeTimeout);
+        this.seekResumeTimeout = null;
+      }
+      this.eventBus.emit("playback:seeking", { time });
+      this.stateManager.set("currentTime", time);
+      if (this.seekingWhilePlaying) {
+        this.seekResumeTimeout = setTimeout(() => {
+          if (this.seekingWhilePlaying && this.stateManager.getValue("playing")) {
+            this.logger.debug("Resuming playback after seek");
+            this.seekingWhilePlaying = false;
+            this.eventBus.emit("playback:play", void 0);
+          }
+          this.seekResumeTimeout = null;
+        }, 300);
+      }
+    } catch (error) {
+      this.errorHandler.handle(error, { operation: "seek", time });
+    }
+  }
+  /**
+   * Set volume.
+   *
+   * @param volume - Volume 0-1
+   *
+   * @example
+   * ```ts
+   * player.setVolume(0.5); // 50% volume
+   * ```
+   */
+  setVolume(volume) {
+    this.checkDestroyed();
+    const clampedVolume = Math.max(0, Math.min(1, volume));
+    this.stateManager.set("volume", clampedVolume);
+    this.eventBus.emit("volume:change", {
+      volume: clampedVolume,
+      muted: this.stateManager.getValue("muted")
+    });
+  }
+  /**
+   * Set muted state.
+   *
+   * @param muted - Mute flag
+   *
+   * @example
+   * ```ts
+   * player.setMuted(true);
+   * ```
+   */
+  setMuted(muted) {
+    this.checkDestroyed();
+    this.stateManager.set("muted", muted);
+    this.eventBus.emit("volume:mute", { muted });
+  }
+  /**
+   * Set playback rate.
+   *
+   * @param rate - Playback rate (e.g., 1.0 = normal, 2.0 = 2x speed)
+   *
+   * @example
+   * ```ts
+   * player.setPlaybackRate(1.5); // 1.5x speed
+   * ```
+   */
+  setPlaybackRate(rate) {
+    this.checkDestroyed();
+    this.stateManager.set("playbackRate", rate);
+    this.eventBus.emit("playback:ratechange", { rate });
+  }
+  /**
+   * Set autoplay state.
+   *
+   * When enabled, videos will automatically play after loading.
+   *
+   * @param autoplay - Autoplay flag
+   *
+   * @example
+   * ```ts
+   * player.setAutoplay(true);
+   * await player.load('video.mp4'); // Will auto-play
+   * ```
+   */
+  setAutoplay(autoplay) {
+    this.checkDestroyed();
+    this.stateManager.set("autoplay", autoplay);
+    this.logger.debug("Autoplay set", { autoplay });
+  }
+  /**
+   * Subscribe to an event.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * const unsub = player.on('playback:play', () => {
+   *   console.log('Playing!');
+   * });
+   *
+   * // Later: unsubscribe
+   * unsub();
+   * ```
+   */
+  on(event, handler) {
+    this.checkDestroyed();
+    return this.eventBus.on(event, handler);
+  }
+  /**
+   * Subscribe to an event once.
+   *
+   * @param event - Event name
+   * @param handler - Event handler
+   * @returns Unsubscribe function
+   *
+   * @example
+   * ```ts
+   * player.once('player:ready', () => {
+   *   console.log('Player ready!');
+   * });
+   * ```
+   */
+  once(event, handler) {
+    this.checkDestroyed();
+    return this.eventBus.once(event, handler);
+  }
+  /**
+   * Get a plugin by name.
+   *
+   * @param name - Plugin name
+   * @returns Plugin instance or null
+   *
+   * @example
+   * ```ts
+   * const hls = player.getPlugin('hls-plugin');
+   * ```
+   */
+  getPlugin(name) {
+    this.checkDestroyed();
+    return this.pluginManager.getPlugin(name);
+  }
+  /**
+   * Register a plugin.
+   *
+   * @param plugin - Plugin to register
+   *
+   * @example
+   * ```ts
+   * player.registerPlugin(myPlugin);
+   * ```
+   */
+  registerPlugin(plugin) {
+    this.checkDestroyed();
+    this.pluginManager.register(plugin);
+  }
+  /**
+   * Get current state snapshot.
+   *
+   * @returns Readonly state snapshot
+   *
+   * @example
+   * ```ts
+   * const state = player.getState();
+   * console.log(state.playing, state.currentTime);
+   * ```
+   */
+  getState() {
+    this.checkDestroyed();
+    return this.stateManager.snapshot();
+  }
+  // ===== Quality Methods (proxied to provider) =====
+  /**
+   * Get available quality levels from the current provider.
+   * @returns Array of quality levels or empty array if not available
+   */
+  getQualities() {
+    this.checkDestroyed();
+    if (!this._currentProvider) return [];
+    const provider = this._currentProvider;
+    if (typeof provider.getLevels === "function") {
+      return provider.getLevels();
+    }
+    return [];
+  }
+  /**
+   * Set quality level (-1 for auto).
+   * @param index - Quality level index
+   */
+  setQuality(index) {
+    this.checkDestroyed();
+    if (!this._currentProvider) {
+      this.logger.warn("No provider available for quality change");
+      return;
+    }
+    const provider = this._currentProvider;
+    if (typeof provider.setLevel === "function") {
+      provider.setLevel(index);
+      this.eventBus.emit("quality:change", {
+        quality: index === -1 ? "auto" : `level-${index}`,
+        auto: index === -1
+      });
+    }
+  }
+  /**
+   * Get current quality level index (-1 = auto).
+   */
+  getCurrentQuality() {
+    this.checkDestroyed();
+    if (!this._currentProvider) return -1;
+    const provider = this._currentProvider;
+    if (typeof provider.getCurrentLevel === "function") {
+      return provider.getCurrentLevel();
+    }
+    return -1;
+  }
+  // ===== Fullscreen Methods =====
+  /**
+   * Request fullscreen mode.
+   */
+  async requestFullscreen() {
+    this.checkDestroyed();
+    try {
+      if (this.container.requestFullscreen) {
+        await this.container.requestFullscreen();
+      } else if (this.container.webkitRequestFullscreen) {
+        await this.container.webkitRequestFullscreen();
+      }
+      this.stateManager.set("fullscreen", true);
+      this.eventBus.emit("fullscreen:change", { fullscreen: true });
+    } catch (error) {
+      this.logger.error("Fullscreen request failed", { error });
+    }
+  }
+  /**
+   * Exit fullscreen mode.
+   */
+  async exitFullscreen() {
+    this.checkDestroyed();
+    try {
+      if (document.exitFullscreen) {
+        await document.exitFullscreen();
+      } else if (document.webkitExitFullscreen) {
+        await document.webkitExitFullscreen();
+      }
+      this.stateManager.set("fullscreen", false);
+      this.eventBus.emit("fullscreen:change", { fullscreen: false });
+    } catch (error) {
+      this.logger.error("Exit fullscreen failed", { error });
+    }
+  }
+  /**
+   * Toggle fullscreen mode.
+   */
+  async toggleFullscreen() {
+    if (this.fullscreen) {
+      await this.exitFullscreen();
+    } else {
+      await this.requestFullscreen();
+    }
+  }
+  // ===== Casting Methods (proxied to plugins) =====
+  /**
+   * Request AirPlay (proxied to airplay plugin).
+   */
+  requestAirPlay() {
+    this.checkDestroyed();
+    const airplay = this.pluginManager.getPlugin("airplay");
+    if (airplay && typeof airplay.showPicker === "function") {
+      airplay.showPicker();
+    } else {
+      this.logger.warn("AirPlay plugin not available");
+    }
+  }
+  /**
+   * Request Chromecast session (proxied to chromecast plugin).
+   */
+  async requestChromecast() {
+    this.checkDestroyed();
+    const chromecast = this.pluginManager.getPlugin("chromecast");
+    if (chromecast && typeof chromecast.requestSession === "function") {
+      await chromecast.requestSession();
+    } else {
+      this.logger.warn("Chromecast plugin not available");
+    }
+  }
+  /**
+   * Stop casting (AirPlay or Chromecast).
+   */
+  stopCasting() {
+    this.checkDestroyed();
+    const airplay = this.pluginManager.getPlugin("airplay");
+    if (airplay && typeof airplay.stop === "function") {
+      airplay.stop();
+    }
+    const chromecast = this.pluginManager.getPlugin("chromecast");
+    if (chromecast && typeof chromecast.stopSession === "function") {
+      chromecast.stopSession();
+    }
+  }
+  // ===== Live Stream Methods =====
+  /**
+   * Seek to live edge (for live streams).
+   */
+  seekToLive() {
+    this.checkDestroyed();
+    const isLive = this.stateManager.getValue("live");
+    if (!isLive) {
+      this.logger.warn("Not a live stream");
+      return;
+    }
+    if (this._currentProvider) {
+      const provider = this._currentProvider;
+      if (typeof provider.getLiveInfo === "function") {
+        const liveInfo = provider.getLiveInfo();
+        if (liveInfo?.liveSyncPosition !== void 0) {
+          this.seek(liveInfo.liveSyncPosition);
+          return;
+        }
+      }
+    }
+    const duration = this.stateManager.getValue("duration");
+    if (duration > 0) {
+      this.seek(duration);
+    }
+  }
+  /**
+   * Destroy the player and cleanup all resources.
+   *
+   * @example
+   * ```ts
+   * player.destroy();
+   * ```
+   */
+  destroy() {
+    if (this.destroyed) {
+      return;
+    }
+    this.logger.info("Destroying player");
+    if (this.seekResumeTimeout !== null) {
+      clearTimeout(this.seekResumeTimeout);
+      this.seekResumeTimeout = null;
+    }
+    this.eventBus.emit("player:destroy", void 0);
+    this.pluginManager.destroyAll();
+    this.eventBus.destroy();
+    this.stateManager.destroy();
+    this.destroyed = true;
+    this.logger.info("Player destroyed");
+  }
+  // ===== State Getters =====
+  /**
+   * Get playing state.
+   */
+  get playing() {
+    return this.stateManager.getValue("playing");
+  }
+  /**
+   * Get paused state.
+   */
+  get paused() {
+    return this.stateManager.getValue("paused");
+  }
+  /**
+   * Get current time in seconds.
+   */
+  get currentTime() {
+    return this.stateManager.getValue("currentTime");
+  }
+  /**
+   * Get duration in seconds.
+   */
+  get duration() {
+    return this.stateManager.getValue("duration");
+  }
+  /**
+   * Get volume (0-1).
+   */
+  get volume() {
+    return this.stateManager.getValue("volume");
+  }
+  /**
+   * Get muted state.
+   */
+  get muted() {
+    return this.stateManager.getValue("muted");
+  }
+  /**
+   * Get playback rate.
+   */
+  get playbackRate() {
+    return this.stateManager.getValue("playbackRate");
+  }
+  /**
+   * Get buffered amount (0-1).
+   */
+  get bufferedAmount() {
+    return this.stateManager.getValue("bufferedAmount");
+  }
+  /**
+   * Get current provider plugin.
+   */
+  get currentProvider() {
+    return this._currentProvider;
+  }
+  /**
+   * Get fullscreen state.
+   */
+  get fullscreen() {
+    return this.stateManager.getValue("fullscreen");
+  }
+  /**
+   * Get live stream state.
+   */
+  get live() {
+    return this.stateManager.getValue("live");
+  }
+  /**
+   * Get autoplay state.
+   */
+  get autoplay() {
+    return this.stateManager.getValue("autoplay");
+  }
+  /**
+   * Check if player is destroyed.
+   * @private
+   */
+  checkDestroyed() {
+    if (this.destroyed) {
+      throw new Error("Cannot call methods on destroyed player");
+    }
+  }
+  /**
+   * Detect MIME type from source URL.
+   * @private
+   */
+  detectMimeType(source) {
+    const ext = source.split(".").pop()?.toLowerCase();
+    switch (ext) {
+      case "m3u8":
+        return "application/x-mpegURL";
+      case "mpd":
+        return "application/dash+xml";
+      case "mp4":
+        return "video/mp4";
+      case "webm":
+        return "video/webm";
+      case "ogg":
+        return "video/ogg";
+      default:
+        return "video/mp4";
+    }
+  }
+}
+async function createPlayer(options) {
+  const player = new ScarlettPlayer(options);
+  await player.init();
+  return player;
+}
+function formatLevel(level) {
+  if (level.name) {
+    return level.name;
+  }
+  if (level.height) {
+    const standardLabels = {
+      2160: "4K",
+      1440: "1440p",
+      1080: "1080p",
+      720: "720p",
+      480: "480p",
+      360: "360p",
+      240: "240p",
+      144: "144p"
+    };
+    const closest = Object.keys(standardLabels).map(Number).sort((a, b) => Math.abs(a - level.height) - Math.abs(b - level.height))[0];
+    if (Math.abs(closest - level.height) <= 20) {
+      return standardLabels[closest];
+    }
+    return `${level.height}p`;
+  }
+  if (level.bitrate) {
+    return formatBitrate(level.bitrate);
+  }
+  return "Unknown";
+}
+function formatBitrate(bitrate) {
+  if (bitrate >= 1e6) {
+    return `${(bitrate / 1e6).toFixed(1)} Mbps`;
+  }
+  if (bitrate >= 1e3) {
+    return `${Math.round(bitrate / 1e3)} Kbps`;
+  }
+  return `${bitrate} bps`;
+}
+function mapLevels(levels, currentLevel) {
+  return levels.map((level, index) => ({
+    index,
+    width: level.width || 0,
+    height: level.height || 0,
+    bitrate: level.bitrate || 0,
+    label: formatLevel(level),
+    codec: level.codecSet
+  }));
+}
+var HLS_ERROR_TYPES = {
+  NETWORK_ERROR: "networkError",
+  MEDIA_ERROR: "mediaError",
+  MUX_ERROR: "muxError"
+};
+function mapErrorType(hlsType) {
+  switch (hlsType) {
+    case HLS_ERROR_TYPES.NETWORK_ERROR:
+      return "network";
+    case HLS_ERROR_TYPES.MEDIA_ERROR:
+      return "media";
+    case HLS_ERROR_TYPES.MUX_ERROR:
+      return "mux";
+    default:
+      return "other";
+  }
+}
+function parseHlsError(data) {
+  return {
+    type: mapErrorType(data.type),
+    details: data.details || "Unknown error",
+    fatal: data.fatal || false,
+    url: data.url,
+    reason: data.reason,
+    response: data.response
+  };
+}
+function setupHlsEventHandlers(hls, api, callbacks) {
+  const handlers = [];
+  const addHandler = (event, handler) => {
+    hls.on(event, handler);
+    handlers.push({ event, handler });
+  };
+  addHandler("hlsManifestParsed", (_event, data) => {
+    api.logger.debug("HLS manifest parsed", { levels: data.levels.length });
+    const levels = data.levels.map((level, index) => ({
+      id: `level-${index}`,
+      label: formatLevel(level),
+      width: level.width,
+      height: level.height,
+      bitrate: level.bitrate,
+      active: index === hls.currentLevel
+    }));
+    api.setState("qualities", levels);
+    api.emit("quality:levels", {
+      levels: levels.map((l) => ({ id: l.id, label: l.label }))
+    });
+    callbacks.onManifestParsed?.(data.levels);
+  });
+  addHandler("hlsLevelSwitched", (_event, data) => {
+    const level = hls.levels[data.level];
+    const isAuto = callbacks.getIsAutoQuality?.() ?? hls.autoLevelEnabled;
+    api.logger.debug("HLS level switched", { level: data.level, height: level?.height, auto: isAuto });
+    if (level) {
+      const label = isAuto ? `Auto (${formatLevel(level)})` : formatLevel(level);
+      api.setState("currentQuality", {
+        id: isAuto ? "auto" : `level-${data.level}`,
+        label,
+        width: level.width,
+        height: level.height,
+        bitrate: level.bitrate,
+        active: true
+      });
+    }
+    api.emit("quality:change", {
+      quality: level ? formatLevel(level) : "auto",
+      auto: isAuto
+    });
+    callbacks.onLevelSwitched?.(data.level);
+  });
+  addHandler("hlsFragBuffered", () => {
+    api.setState("buffering", false);
+    callbacks.onBufferUpdate?.();
+  });
+  addHandler("hlsFragLoading", () => {
+    api.setState("buffering", true);
+  });
+  addHandler("hlsLevelLoaded", (_event, data) => {
+    if (data.details?.live !== void 0) {
+      api.setState("live", data.details.live);
+      callbacks.onLiveUpdate?.();
+    }
+  });
+  addHandler("hlsError", (_event, data) => {
+    const error = parseHlsError(data);
+    api.logger.warn("HLS error", { error });
+    callbacks.onError?.(error);
+  });
+  return () => {
+    for (const { event, handler } of handlers) {
+      hls.off(event, handler);
+    }
+    handlers.length = 0;
+  };
+}
+function setupVideoEventHandlers(video, api) {
+  const handlers = [];
+  const addHandler = (event, handler) => {
+    video.addEventListener(event, handler);
+    handlers.push({ event, handler });
+  };
+  addHandler("playing", () => {
+    api.setState("playing", true);
+    api.setState("paused", false);
+    api.setState("playbackState", "playing");
+  });
+  addHandler("pause", () => {
+    api.setState("playing", false);
+    api.setState("paused", true);
+    api.setState("playbackState", "paused");
+  });
+  addHandler("ended", () => {
+    api.setState("playing", false);
+    api.setState("ended", true);
+    api.setState("playbackState", "ended");
+    api.emit("playback:ended", void 0);
+  });
+  addHandler("timeupdate", () => {
+    api.setState("currentTime", video.currentTime);
+    api.emit("playback:timeupdate", { currentTime: video.currentTime });
+  });
+  addHandler("durationchange", () => {
+    api.setState("duration", video.duration || 0);
+    api.emit("media:loadedmetadata", { duration: video.duration || 0 });
+  });
+  addHandler("waiting", () => {
+    api.setState("waiting", true);
+    api.setState("buffering", true);
+    api.emit("media:waiting", void 0);
+  });
+  addHandler("canplay", () => {
+    api.setState("waiting", false);
+    api.setState("playbackState", "ready");
+    api.emit("media:canplay", void 0);
+  });
+  addHandler("canplaythrough", () => {
+    api.setState("buffering", false);
+    api.emit("media:canplaythrough", void 0);
+  });
+  addHandler("progress", () => {
+    if (video.buffered.length > 0) {
+      const bufferedEnd = video.buffered.end(video.buffered.length - 1);
+      const bufferedAmount = video.duration > 0 ? bufferedEnd / video.duration : 0;
+      api.setState("bufferedAmount", bufferedAmount);
+      api.setState("buffered", video.buffered);
+      api.emit("media:progress", { buffered: bufferedAmount });
+    }
+  });
+  addHandler("seeking", () => {
+    api.setState("seeking", true);
+  });
+  addHandler("seeked", () => {
+    api.setState("seeking", false);
+    api.emit("playback:seeked", { time: video.currentTime });
+  });
+  addHandler("volumechange", () => {
+    api.setState("volume", video.volume);
+    api.setState("muted", video.muted);
+    api.emit("volume:change", { volume: video.volume, muted: video.muted });
+  });
+  addHandler("ratechange", () => {
+    api.setState("playbackRate", video.playbackRate);
+    api.emit("playback:ratechange", { rate: video.playbackRate });
+  });
+  addHandler("loadedmetadata", () => {
+    api.setState("duration", video.duration);
+    api.setState("mediaType", video.videoWidth > 0 ? "video" : "audio");
+  });
+  addHandler("error", () => {
+    const error = video.error;
+    if (error) {
+      api.logger.error("Video element error", { code: error.code, message: error.message });
+      api.emit("media:error", { error: new Error(error.message || "Video playback error") });
+    }
+  });
+  addHandler("enterpictureinpicture", () => {
+    api.setState("pip", true);
+    api.logger.debug("PiP: entered (standard)");
+  });
+  addHandler("leavepictureinpicture", () => {
+    api.setState("pip", false);
+    api.logger.debug("PiP: exited (standard)");
+    if (!video.paused || api.getState("playing")) {
+      video.play().catch(() => {
+      });
+    }
+  });
+  const webkitVideo = video;
+  if ("webkitPresentationMode" in video) {
+    addHandler("webkitpresentationmodechanged", () => {
+      const mode = webkitVideo.webkitPresentationMode;
+      const isInPip = mode === "picture-in-picture";
+      api.setState("pip", isInPip);
+      api.logger.debug(`PiP: mode changed to ${mode} (webkit)`);
+      if (mode === "inline" && video.paused) {
+        video.play().catch(() => {
+        });
+      }
+    });
+  }
+  return () => {
+    for (const { event, handler } of handlers) {
+      video.removeEventListener(event, handler);
+    }
+    handlers.length = 0;
+  };
+}
+var hlsConstructor = null;
+var loadingPromise = null;
+function supportsNativeHLS() {
+  if (typeof document === "undefined") return false;
+  const video = document.createElement("video");
+  return video.canPlayType("application/vnd.apple.mpegurl") !== "";
+}
+function isHlsJsSupported() {
+  if (hlsConstructor) {
+    return hlsConstructor.isSupported();
+  }
+  if (typeof window === "undefined") return false;
+  return !!(window.MediaSource || window.WebKitMediaSource);
+}
+function isHLSSupported() {
+  return supportsNativeHLS() || isHlsJsSupported();
+}
+async function loadHlsJs() {
+  if (hlsConstructor) {
+    return hlsConstructor;
+  }
+  if (loadingPromise) {
+    return loadingPromise;
+  }
+  loadingPromise = (async () => {
+    try {
+      const hlsModule = await import("./hls.light-YJMge-Mx.js");
+      hlsConstructor = hlsModule.default;
+      if (!hlsConstructor.isSupported()) {
+        throw new Error("hls.js is not supported in this browser");
+      }
+      return hlsConstructor;
+    } catch (error) {
+      loadingPromise = null;
+      throw new Error(
+        `Failed to load hls.js: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  })();
+  return loadingPromise;
+}
+function createHlsInstance(config) {
+  if (!hlsConstructor) {
+    throw new Error("hls.js is not loaded. Call loadHlsJs() first.");
+  }
+  return new hlsConstructor(config);
+}
+function getHlsConstructor() {
+  return hlsConstructor;
+}
+var DEFAULT_CONFIG$3 = {
+  debug: false,
+  autoStartLoad: true,
+  startPosition: -1,
+  lowLatencyMode: false,
+  maxBufferLength: 30,
+  maxMaxBufferLength: 600,
+  backBufferLength: 30,
+  enableWorker: true,
+  maxNetworkRetries: 3,
+  maxMediaRetries: 2,
+  retryDelayMs: 1e3,
+  retryBackoffFactor: 2
+};
+function createHLSPlugin(config) {
+  const mergedConfig = { ...DEFAULT_CONFIG$3, ...config };
+  let api = null;
+  let hls = null;
+  let video = null;
+  let isNative = false;
+  let currentSrc = null;
+  let cleanupHlsEvents = null;
+  let cleanupVideoEvents = null;
+  let isAutoQuality = true;
+  let networkRetryCount = 0;
+  let mediaRetryCount = 0;
+  let retryTimeout = null;
+  let errorCount = 0;
+  let errorWindowStart = 0;
+  const MAX_ERRORS_IN_WINDOW = 10;
+  const ERROR_WINDOW_MS = 5e3;
+  const getOrCreateVideo = () => {
+    if (video) return video;
+    const existing = api?.container.querySelector("video");
+    if (existing) {
+      video = existing;
+      return video;
+    }
+    video = document.createElement("video");
+    video.style.cssText = "width:100%;height:100%;display:block;object-fit:contain;background:#000";
+    video.preload = "metadata";
+    video.controls = false;
+    video.playsInline = true;
+    api?.container.appendChild(video);
+    return video;
+  };
+  const cleanup = () => {
+    cleanupHlsEvents?.();
+    cleanupHlsEvents = null;
+    cleanupVideoEvents?.();
+    cleanupVideoEvents = null;
+    if (retryTimeout) {
+      clearTimeout(retryTimeout);
+      retryTimeout = null;
+    }
+    if (hls) {
+      hls.destroy();
+      hls = null;
+    }
+    currentSrc = null;
+    isNative = false;
+    isAutoQuality = true;
+    networkRetryCount = 0;
+    mediaRetryCount = 0;
+    errorCount = 0;
+    errorWindowStart = 0;
+  };
+  const buildHlsConfig = () => ({
+    debug: mergedConfig.debug,
+    autoStartLoad: mergedConfig.autoStartLoad,
+    startPosition: mergedConfig.startPosition,
+    startLevel: -1,
+    lowLatencyMode: mergedConfig.lowLatencyMode,
+    maxBufferLength: mergedConfig.maxBufferLength,
+    maxMaxBufferLength: mergedConfig.maxMaxBufferLength,
+    backBufferLength: mergedConfig.backBufferLength,
+    enableWorker: mergedConfig.enableWorker,
+    fragLoadingMaxRetry: 1,
+    manifestLoadingMaxRetry: 1,
+    levelLoadingMaxRetry: 1,
+    fragLoadingRetryDelay: 500,
+    manifestLoadingRetryDelay: 500,
+    levelLoadingRetryDelay: 500
+  });
+  const getRetryDelay = (retryCount) => {
+    const baseDelay = mergedConfig.retryDelayMs ?? 1e3;
+    const backoffFactor = mergedConfig.retryBackoffFactor ?? 2;
+    return baseDelay * Math.pow(backoffFactor, retryCount);
+  };
+  const emitFatalError = (error, retriesExhausted) => {
+    const message = retriesExhausted ? `HLS error: ${error.details} (max retries exceeded)` : `HLS error: ${error.details}`;
+    api?.logger.error(message, { type: error.type, details: error.details });
+    api?.setState("playbackState", "error");
+    api?.setState("buffering", false);
+    api?.emit("error", {
+      code: "MEDIA_ERROR",
+      message,
+      fatal: true,
+      timestamp: Date.now()
+    });
+  };
+  const handleHlsError = (error) => {
+    const Hls = getHlsConstructor();
+    if (!Hls || !hls) return;
+    const now = Date.now();
+    if (now - errorWindowStart > ERROR_WINDOW_MS) {
+      errorCount = 1;
+      errorWindowStart = now;
+    } else {
+      errorCount++;
+    }
+    if (errorCount >= MAX_ERRORS_IN_WINDOW) {
+      api?.logger.error(`Too many errors (${errorCount} in ${ERROR_WINDOW_MS}ms), giving up`);
+      emitFatalError(error, true);
+      cleanupHlsEvents?.();
+      cleanupHlsEvents = null;
+      hls.destroy();
+      hls = null;
+      return;
+    }
+    if (error.fatal) {
+      api?.logger.error("Fatal HLS error", { type: error.type, details: error.details });
+      switch (error.type) {
+        case "network": {
+          const maxRetries = mergedConfig.maxNetworkRetries ?? 3;
+          if (networkRetryCount >= maxRetries) {
+            api?.logger.error(`Network error recovery failed after ${networkRetryCount} attempts`);
+            emitFatalError(error, true);
+            return;
+          }
+          networkRetryCount++;
+          const delay = getRetryDelay(networkRetryCount - 1);
+          api?.logger.info(`Attempting network error recovery (attempt ${networkRetryCount}/${maxRetries}) in ${delay}ms`);
+          api?.emit("error:network", { error: new Error(error.details) });
+          if (retryTimeout) {
+            clearTimeout(retryTimeout);
+          }
+          retryTimeout = setTimeout(() => {
+            if (hls) {
+              hls.startLoad();
+            }
+          }, delay);
+          break;
+        }
+        case "media": {
+          const maxRetries = mergedConfig.maxMediaRetries ?? 2;
+          if (mediaRetryCount >= maxRetries) {
+            api?.logger.error(`Media error recovery failed after ${mediaRetryCount} attempts`);
+            emitFatalError(error, true);
+            return;
+          }
+          mediaRetryCount++;
+          const delay = getRetryDelay(mediaRetryCount - 1);
+          api?.logger.info(`Attempting media error recovery (attempt ${mediaRetryCount}/${maxRetries}) in ${delay}ms`);
+          api?.emit("error:media", { error: new Error(error.details) });
+          if (retryTimeout) {
+            clearTimeout(retryTimeout);
+          }
+          retryTimeout = setTimeout(() => {
+            if (hls) {
+              hls.recoverMediaError();
+            }
+          }, delay);
+          break;
+        }
+        default:
+          emitFatalError(error, false);
+          break;
+      }
+    }
+  };
+  const loadNative = async (src) => {
+    const videoEl = getOrCreateVideo();
+    isNative = true;
+    if (api) {
+      cleanupVideoEvents = setupVideoEventHandlers(videoEl, api);
+    }
+    return new Promise((resolve, reject) => {
+      const onLoaded = () => {
+        videoEl.removeEventListener("loadedmetadata", onLoaded);
+        videoEl.removeEventListener("error", onError);
+        api?.setState("source", { src, type: "application/x-mpegURL" });
+        api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
+        resolve();
+      };
+      const onError = () => {
+        videoEl.removeEventListener("loadedmetadata", onLoaded);
+        videoEl.removeEventListener("error", onError);
+        const error = videoEl.error;
+        reject(new Error(error?.message || "Failed to load HLS source"));
+      };
+      videoEl.addEventListener("loadedmetadata", onLoaded);
+      videoEl.addEventListener("error", onError);
+      videoEl.src = src;
+      videoEl.load();
+    });
+  };
+  const loadWithHlsJs = async (src) => {
+    await loadHlsJs();
+    const videoEl = getOrCreateVideo();
+    isNative = false;
+    hls = createHlsInstance(buildHlsConfig());
+    if (api) {
+      cleanupVideoEvents = setupVideoEventHandlers(videoEl, api);
+    }
+    return new Promise((resolve, reject) => {
+      if (!hls || !api) {
+        reject(new Error("HLS not initialized"));
+        return;
+      }
+      let resolved = false;
+      cleanupHlsEvents = setupHlsEventHandlers(hls, api, {
+        onManifestParsed: () => {
+          if (!resolved) {
+            resolved = true;
+            api?.setState("source", { src, type: "application/x-mpegURL" });
+            api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
+            resolve();
+          }
+        },
+        onLevelSwitched: () => {
+        },
+        onError: (error) => {
+          handleHlsError(error);
+          if (error.fatal && !resolved && error.type !== "network" && error.type !== "media") {
+            resolved = true;
+            reject(new Error(error.details));
+          }
+        },
+        getIsAutoQuality: () => isAutoQuality
+      });
+      hls.attachMedia(videoEl);
+      hls.loadSource(src);
+    });
+  };
+  const plugin = {
+    id: "hls-provider",
+    name: "HLS Provider (Light)",
+    version: "1.0.0",
+    type: "provider",
+    description: "HLS playback provider using hls.js/light (smaller bundle)",
+    canPlay(src) {
+      if (!isHLSSupported()) return false;
+      const url = src.toLowerCase();
+      const urlWithoutQuery = url.split("?")[0].split("#")[0];
+      if (urlWithoutQuery.endsWith(".m3u8")) return true;
+      if (url.includes("application/x-mpegurl")) return true;
+      if (url.includes("application/vnd.apple.mpegurl")) return true;
+      return false;
+    },
+    async init(pluginApi) {
+      api = pluginApi;
+      api.logger.info("HLS plugin (light) initialized");
+      const unsubPlay = api.on("playback:play", async () => {
+        if (!video) return;
+        try {
+          await video.play();
+        } catch (e) {
+          api?.logger.error("Play failed", e);
+        }
+      });
+      const unsubPause = api.on("playback:pause", () => {
+        video?.pause();
+      });
+      const unsubSeek = api.on("playback:seeking", ({ time }) => {
+        if (!video) return;
+        const clampedTime = Math.max(0, Math.min(time, video.duration || 0));
+        video.currentTime = clampedTime;
+      });
+      const unsubVolume = api.on("volume:change", ({ volume }) => {
+        if (video) video.volume = volume;
+      });
+      const unsubMute = api.on("volume:mute", ({ muted }) => {
+        if (video) video.muted = muted;
+      });
+      const unsubRate = api.on("playback:ratechange", ({ rate }) => {
+        if (video) video.playbackRate = rate;
+      });
+      const unsubQuality = api.on("quality:select", ({ quality, auto }) => {
+        if (!hls || isNative) {
+          api?.logger.warn("Quality selection not available");
+          return;
+        }
+        if (auto || quality === "auto") {
+          isAutoQuality = true;
+          hls.currentLevel = -1;
+          api?.logger.debug("Quality: auto selection enabled");
+          api?.setState("currentQuality", {
+            id: "auto",
+            label: "Auto",
+            width: 0,
+            height: 0,
+            bitrate: 0,
+            active: true
+          });
+        } else {
+          isAutoQuality = false;
+          const levelIndex = parseInt(quality.replace("level-", ""), 10);
+          if (!isNaN(levelIndex) && levelIndex >= 0 && levelIndex < hls.levels.length) {
+            hls.nextLevel = levelIndex;
+            api?.logger.debug(`Quality: queued switch to level ${levelIndex}`);
+          }
+        }
+      });
+      api.onDestroy(() => {
+        unsubPlay();
+        unsubPause();
+        unsubSeek();
+        unsubVolume();
+        unsubMute();
+        unsubRate();
+        unsubQuality();
+      });
+    },
+    async destroy() {
+      api?.logger.info("HLS plugin (light) destroying");
+      cleanup();
+      if (video?.parentNode) {
+        video.parentNode.removeChild(video);
+      }
+      video = null;
+      api = null;
+    },
+    async loadSource(src) {
+      if (!api) throw new Error("Plugin not initialized");
+      api.logger.info("Loading HLS source (light)", { src });
+      cleanup();
+      currentSrc = src;
+      api.setState("playbackState", "loading");
+      api.setState("buffering", true);
+      if (isHlsJsSupported()) {
+        api.logger.info("Using hls.js/light for HLS playback");
+        await loadWithHlsJs(src);
+      } else if (supportsNativeHLS()) {
+        api.logger.info("Using native HLS playback (hls.js not supported)");
+        await loadNative(src);
+      } else {
+        throw new Error("HLS playback not supported in this browser");
+      }
+      api.setState("playbackState", "ready");
+      api.setState("buffering", false);
+    },
+    getCurrentLevel() {
+      if (isNative || !hls) return -1;
+      return hls.currentLevel;
+    },
+    setLevel(index) {
+      if (isNative || !hls) {
+        api?.logger.warn("Quality selection not available in native HLS mode");
+        return;
+      }
+      hls.currentLevel = index;
+    },
+    getLevels() {
+      if (isNative || !hls) return [];
+      return mapLevels(hls.levels, hls.currentLevel);
+    },
+    getHlsInstance() {
+      return hls;
+    },
+    isNativeHLS() {
+      return isNative;
+    },
+    getLiveInfo() {
+      if (isNative || !hls) return null;
+      const live = api?.getState("live") || false;
+      if (!live) return null;
+      return {
+        isLive: true,
+        latency: hls.latency || 0,
+        targetLatency: hls.targetLatency || 3,
+        drift: hls.drift || 0
+      };
+    },
+    async switchToNative() {
+      if (isNative) {
+        api?.logger.debug("Already using native HLS");
+        return;
+      }
+      if (!supportsNativeHLS()) {
+        api?.logger.warn("Native HLS not supported in this browser");
+        return;
+      }
+      if (!currentSrc) {
+        api?.logger.warn("No source loaded");
+        return;
+      }
+      api?.logger.info("Switching to native HLS for AirPlay");
+      const wasPlaying = api?.getState("playing") || false;
+      const currentTime = video?.currentTime || 0;
+      const savedSrc = currentSrc;
+      cleanup();
+      await loadNative(savedSrc);
+      if (video && currentTime > 0) {
+        video.currentTime = currentTime;
+      }
+      if (wasPlaying && video) {
+        try {
+          await video.play();
+        } catch (e) {
+          api?.logger.debug("Could not auto-resume after switch");
+        }
+      }
+      api?.logger.info("Switched to native HLS");
+    },
+    async switchToHlsJs() {
+      if (!isNative) {
+        api?.logger.debug("Already using hls.js");
+        return;
+      }
+      if (!isHlsJsSupported()) {
+        api?.logger.warn("hls.js not supported in this browser");
+        return;
+      }
+      if (!currentSrc) {
+        api?.logger.warn("No source loaded");
+        return;
+      }
+      api?.logger.info("Switching back to hls.js");
+      const wasPlaying = api?.getState("playing") || false;
+      const currentTime = video?.currentTime || 0;
+      const savedSrc = currentSrc;
+      cleanup();
+      await loadWithHlsJs(savedSrc);
+      if (video && currentTime > 0) {
+        video.currentTime = currentTime;
+      }
+      if (wasPlaying && video) {
+        try {
+          await video.play();
+        } catch (e) {
+          api?.logger.debug("Could not auto-resume after switch");
+        }
+      }
+      api?.logger.info("Switched to hls.js");
+    }
+  };
+  return plugin;
+}
+var DEFAULT_THEME = {
+  primary: "#6366f1",
+  background: "#18181b",
+  text: "#fafafa",
+  textSecondary: "#a1a1aa",
+  progressBackground: "#3f3f46",
+  progressFill: "#6366f1",
+  borderRadius: "12px",
+  fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'
+};
+var DEFAULT_CONFIG$2 = {
+  layout: "full",
+  showArtwork: true,
+  showTitle: true,
+  showArtist: true,
+  showTime: true,
+  showVolume: true,
+  showShuffle: true,
+  showRepeat: true,
+  showNavigation: true,
+  classPrefix: "scarlett-audio",
+  autoHide: 0,
+  theme: DEFAULT_THEME
+};
+function formatTime(seconds) {
+  if (!isFinite(seconds) || seconds < 0) return "0:00";
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  if (h > 0) {
+    return `${h}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}`;
+  }
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+function createStyles(prefix, theme) {
+  return `
+    .${prefix} {
+      font-family: ${theme.fontFamily};
+      background: ${theme.background};
+      color: ${theme.text};
+      border-radius: ${theme.borderRadius};
+      overflow: hidden;
+      user-select: none;
+    }
+
+    .${prefix}--full {
+      display: flex;
+      flex-direction: column;
+      padding: 20px;
+      gap: 16px;
+      max-width: 400px;
+    }
+
+    .${prefix}--compact {
+      display: flex;
+      align-items: center;
+      padding: 12px 16px;
+      gap: 12px;
+    }
+
+    .${prefix}--mini {
+      display: flex;
+      align-items: center;
+      padding: 8px 12px;
+      gap: 8px;
+    }
+
+    .${prefix}__artwork {
+      flex-shrink: 0;
+      background: ${theme.progressBackground};
+      border-radius: 8px;
+      overflow: hidden;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .${prefix}--full .${prefix}__artwork {
+      width: 100%;
+      aspect-ratio: 1;
+      border-radius: ${theme.borderRadius};
+    }
+
+    .${prefix}--compact .${prefix}__artwork {
+      width: 56px;
+      height: 56px;
+    }
+
+    .${prefix}--mini .${prefix}__artwork {
+      width: 40px;
+      height: 40px;
+      border-radius: 6px;
+    }
+
+    .${prefix}__artwork img {
+      width: 100%;
+      height: 100%;
+      object-fit: cover;
+    }
+
+    .${prefix}__artwork-placeholder {
+      width: 50%;
+      height: 50%;
+      opacity: 0.3;
+    }
+
+    .${prefix}__info {
+      flex: 1;
+      min-width: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+
+    .${prefix}__title {
+      font-size: 16px;
+      font-weight: 600;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .${prefix}--mini .${prefix}__title {
+      font-size: 14px;
+      display: inline-block;
+      animation: none;
+    }
+
+    .${prefix}__title-wrapper {
+      overflow: hidden;
+      width: 100%;
+    }
+
+    .${prefix}--mini .${prefix}__title-wrapper .${prefix}__title.scrolling {
+      animation: marquee 8s linear infinite;
+    }
+
+    @keyframes marquee {
+      0% { transform: translateX(0); }
+      100% { transform: translateX(-50%); }
+    }
+
+    .${prefix}--mini .${prefix}__progress {
+      margin-top: 4px;
+    }
+
+    .${prefix}--mini .${prefix}__progress-bar {
+      height: 4px;
+    }
+
+    .${prefix}__artist {
+      font-size: 14px;
+      color: ${theme.textSecondary};
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .${prefix}--mini .${prefix}__artist {
+      font-size: 12px;
+    }
+
+    .${prefix}__progress {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+    }
+
+    .${prefix}__progress-bar {
+      flex: 1;
+      height: 6px;
+      background: ${theme.progressBackground};
+      border-radius: 3px;
+      cursor: pointer;
+      position: relative;
+      overflow: hidden;
+    }
+
+    .${prefix}__progress-bar:hover {
+      height: 8px;
+    }
+
+    .${prefix}__progress-fill {
+      height: 100%;
+      background: ${theme.progressFill};
+      border-radius: 3px;
+      width: 100%;
+      transform-origin: left center;
+      will-change: transform;
+    }
+
+    .${prefix}__progress-buffered {
+      position: absolute;
+      top: 0;
+      left: 0;
+      height: 100%;
+      background: ${theme.progressBackground};
+      opacity: 0.5;
+      border-radius: 3px;
+    }
+
+    .${prefix}__time {
+      font-size: 12px;
+      color: ${theme.textSecondary};
+      min-width: 40px;
+      text-align: center;
+    }
+
+    .${prefix}__controls {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+    }
+
+    .${prefix}__btn {
+      background: transparent;
+      border: none;
+      color: ${theme.text};
+      cursor: pointer;
+      padding: 8px;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: background 0.2s, transform 0.1s;
+    }
+
+    .${prefix}__btn:hover {
+      background: rgba(255, 255, 255, 0.1);
+    }
+
+    .${prefix}__btn:active {
+      transform: scale(0.95);
+    }
+
+    .${prefix}__btn--primary {
+      background: ${theme.primary};
+      width: 48px;
+      height: 48px;
+    }
+
+    .${prefix}__btn--primary:hover {
+      background: ${theme.primary};
+      opacity: 0.9;
+    }
+
+    .${prefix}--mini .${prefix}__btn--primary {
+      width: 36px;
+      height: 36px;
+    }
+
+    .${prefix}__btn--active {
+      color: ${theme.primary};
+    }
+
+    .${prefix}__btn svg {
+      width: 20px;
+      height: 20px;
+      fill: currentColor;
+    }
+
+    .${prefix}__btn--primary svg {
+      width: 24px;
+      height: 24px;
+    }
+
+    .${prefix}__volume {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .${prefix}__volume-slider {
+      width: 80px;
+      height: 4px;
+      background: ${theme.progressBackground};
+      border-radius: 2px;
+      cursor: pointer;
+      position: relative;
+    }
+
+    .${prefix}__volume-fill {
+      height: 100%;
+      background: ${theme.text};
+      border-radius: 2px;
+    }
+
+    .${prefix}__secondary-controls {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+    }
+
+    .${prefix}--hidden {
+      display: none;
+    }
+  `;
+}
+var ICONS = {
+  play: `<svg viewBox="0 0 24 24"><path d="M8 5v14l11-7z"/></svg>`,
+  pause: `<svg viewBox="0 0 24 24"><path d="M6 19h4V5H6v14zm8-14v14h4V5h-4z"/></svg>`,
+  previous: `<svg viewBox="0 0 24 24"><path d="M6 6h2v12H6zm3.5 6l8.5 6V6z"/></svg>`,
+  next: `<svg viewBox="0 0 24 24"><path d="M6 18l8.5-6L6 6v12zM16 6v12h2V6h-2z"/></svg>`,
+  shuffle: `<svg viewBox="0 0 24 24"><path d="M10.59 9.17L5.41 4 4 5.41l5.17 5.17 1.42-1.41zM14.5 4l2.04 2.04L4 18.59 5.41 20 17.96 7.46 20 9.5V4h-5.5zm.33 9.41l-1.41 1.41 3.13 3.13L14.5 20H20v-5.5l-2.04 2.04-3.13-3.13z"/></svg>`,
+  repeatOff: `<svg viewBox="0 0 24 24"><path d="M7 7h10v3l4-4-4-4v3H5v6h2V7zm10 10H7v-3l-4 4 4 4v-3h12v-6h-2v4z"/></svg>`,
+  repeatAll: `<svg viewBox="0 0 24 24"><path d="M7 7h10v3l4-4-4-4v3H5v6h2V7zm10 10H7v-3l-4 4 4 4v-3h12v-6h-2v4z"/></svg>`,
+  repeatOne: `<svg viewBox="0 0 24 24"><path d="M7 7h10v3l4-4-4-4v3H5v6h2V7zm10 10H7v-3l-4 4 4 4v-3h12v-6h-2v4zm-4-2V9h-1l-2 1v1h1.5v4H13z"/></svg>`,
+  volumeHigh: `<svg viewBox="0 0 24 24"><path d="M3 9v6h4l5 5V4L7 9H3zm13.5 3c0-1.77-1.02-3.29-2.5-4.03v8.05c1.48-.73 2.5-2.25 2.5-4.02zM14 3.23v2.06c2.89.86 5 3.54 5 6.71s-2.11 5.85-5 6.71v2.06c4.01-.91 7-4.49 7-8.77s-2.99-7.86-7-8.77z"/></svg>`,
+  volumeMuted: `<svg viewBox="0 0 24 24"><path d="M16.5 12c0-1.77-1.02-3.29-2.5-4.03v2.21l2.45 2.45c.03-.2.05-.41.05-.63zm2.5 0c0 .94-.2 1.82-.54 2.64l1.51 1.51C20.63 14.91 21 13.5 21 12c0-4.28-2.99-7.86-7-8.77v2.06c2.89.86 5 3.54 5 6.71zM4.27 3L3 4.27 7.73 9H3v6h4l5 5v-6.73l4.25 4.25c-.67.52-1.42.93-2.25 1.18v2.06c1.38-.31 2.63-.95 3.69-1.81L19.73 21 21 19.73l-9-9L4.27 3zM12 4L9.91 6.09 12 8.18V4z"/></svg>`,
+  music: `<svg viewBox="0 0 24 24"><path d="M12 3v10.55c-.59-.34-1.27-.55-2-.55-2.21 0-4 1.79-4 4s1.79 4 4 4 4-1.79 4-4V7h4V3h-6z"/></svg>`
+};
+function createAudioUIPlugin(config) {
+  const mergedConfig = { ...DEFAULT_CONFIG$2, ...config };
+  const theme = { ...DEFAULT_THEME, ...mergedConfig.theme };
+  const prefix = mergedConfig.classPrefix;
+  let api = null;
+  let container = null;
+  let styleElement = null;
+  let layout = mergedConfig.layout;
+  let isVisible = true;
+  let animationFrameId = null;
+  let lastKnownTime = 0;
+  let lastUpdateTimestamp = 0;
+  let isPlaying = false;
+  let artworkImg = null;
+  let titleEl = null;
+  let artistEl = null;
+  let progressFill = null;
+  let currentTimeEl = null;
+  let durationEl = null;
+  let playPauseBtn = null;
+  let shuffleBtn = null;
+  let repeatBtn = null;
+  let volumeBtn = null;
+  let volumeFill = null;
+  const startProgressAnimation = () => {
+    if (animationFrameId !== null) return;
+    const animate = (timestamp) => {
+      if (!api || !isPlaying) {
+        animationFrameId = null;
+        return;
+      }
+      const duration = api.getState("duration") || 0;
+      if (duration <= 0) {
+        animationFrameId = requestAnimationFrame(animate);
+        return;
+      }
+      const elapsed = (timestamp - lastUpdateTimestamp) / 1e3;
+      const interpolatedTime = Math.min(lastKnownTime + elapsed, duration);
+      const scale = interpolatedTime / duration;
+      if (progressFill) {
+        progressFill.style.transform = `scaleX(${scale})`;
+      }
+      if (currentTimeEl) {
+        currentTimeEl.textContent = formatTime(interpolatedTime);
+      }
+      animationFrameId = requestAnimationFrame(animate);
+    };
+    lastUpdateTimestamp = performance.now();
+    animationFrameId = requestAnimationFrame(animate);
+  };
+  const stopProgressAnimation = () => {
+    if (animationFrameId !== null) {
+      cancelAnimationFrame(animationFrameId);
+      animationFrameId = null;
+    }
+  };
+  const createUI = () => {
+    if (!api) return;
+    styleElement = document.createElement("style");
+    styleElement.textContent = createStyles(prefix, theme);
+    document.head.appendChild(styleElement);
+    container = document.createElement("div");
+    container.className = `${prefix} ${prefix}--${layout}`;
+    if (layout === "full") {
+      container.innerHTML = buildFullLayout();
+    } else if (layout === "compact") {
+      container.innerHTML = buildCompactLayout();
+    } else {
+      container.innerHTML = buildMiniLayout();
+    }
+    artworkImg = container.querySelector(`.${prefix}__artwork img`);
+    titleEl = container.querySelector(`.${prefix}__title`);
+    artistEl = container.querySelector(`.${prefix}__artist`);
+    progressFill = container.querySelector(`.${prefix}__progress-fill`);
+    currentTimeEl = container.querySelector(`.${prefix}__time--current`);
+    durationEl = container.querySelector(`.${prefix}__time--duration`);
+    playPauseBtn = container.querySelector(`.${prefix}__btn--play`);
+    shuffleBtn = container.querySelector(`.${prefix}__btn--shuffle`);
+    repeatBtn = container.querySelector(`.${prefix}__btn--repeat`);
+    volumeBtn = container.querySelector(`.${prefix}__btn--volume`);
+    volumeFill = container.querySelector(`.${prefix}__volume-fill`);
+    attachEventListeners();
+    api.container.appendChild(container);
+  };
+  const buildFullLayout = () => {
+    return `
+      ${mergedConfig.showArtwork ? `
+        <div class="${prefix}__artwork">
+          <img src="${mergedConfig.defaultArtwork || ""}" alt="Album art" />
+          ${!mergedConfig.defaultArtwork ? `<div class="${prefix}__artwork-placeholder">${ICONS.music}</div>` : ""}
+        </div>
+      ` : ""}
+      <div class="${prefix}__info">
+        ${mergedConfig.showTitle ? `<div class="${prefix}__title">-</div>` : ""}
+        ${mergedConfig.showArtist ? `<div class="${prefix}__artist">-</div>` : ""}
+      </div>
+      <div class="${prefix}__progress">
+        ${mergedConfig.showTime ? `<span class="${prefix}__time ${prefix}__time--current">0:00</span>` : ""}
+        <div class="${prefix}__progress-bar">
+          <div class="${prefix}__progress-fill" style="transform: scaleX(0)"></div>
+        </div>
+        ${mergedConfig.showTime ? `<span class="${prefix}__time ${prefix}__time--duration">0:00</span>` : ""}
+      </div>
+      <div class="${prefix}__controls">
+        ${mergedConfig.showShuffle ? `<button class="${prefix}__btn ${prefix}__btn--shuffle" title="Shuffle">${ICONS.shuffle}</button>` : ""}
+        ${mergedConfig.showNavigation ? `<button class="${prefix}__btn ${prefix}__btn--prev" title="Previous">${ICONS.previous}</button>` : ""}
+        <button class="${prefix}__btn ${prefix}__btn--primary ${prefix}__btn--play" title="Play">${ICONS.play}</button>
+        ${mergedConfig.showNavigation ? `<button class="${prefix}__btn ${prefix}__btn--next" title="Next">${ICONS.next}</button>` : ""}
+        ${mergedConfig.showRepeat ? `<button class="${prefix}__btn ${prefix}__btn--repeat" title="Repeat">${ICONS.repeatOff}</button>` : ""}
+      </div>
+      ${mergedConfig.showVolume ? `
+        <div class="${prefix}__secondary-controls">
+          <div class="${prefix}__volume">
+            <button class="${prefix}__btn ${prefix}__btn--volume" title="Volume">${ICONS.volumeHigh}</button>
+            <div class="${prefix}__volume-slider">
+              <div class="${prefix}__volume-fill" style="width: 100%"></div>
+            </div>
+          </div>
+        </div>
+      ` : ""}
+    `;
+  };
+  const buildCompactLayout = () => {
+    return `
+      ${mergedConfig.showArtwork ? `
+        <div class="${prefix}__artwork">
+          <img src="${mergedConfig.defaultArtwork || ""}" alt="Album art" />
+        </div>
+      ` : ""}
+      <div class="${prefix}__info">
+        ${mergedConfig.showTitle ? `<div class="${prefix}__title">-</div>` : ""}
+        ${mergedConfig.showArtist ? `<div class="${prefix}__artist">-</div>` : ""}
+        <div class="${prefix}__progress">
+          <div class="${prefix}__progress-bar">
+            <div class="${prefix}__progress-fill" style="transform: scaleX(0)"></div>
+          </div>
+        </div>
+      </div>
+      <div class="${prefix}__controls">
+        ${mergedConfig.showNavigation ? `<button class="${prefix}__btn ${prefix}__btn--prev" title="Previous">${ICONS.previous}</button>` : ""}
+        <button class="${prefix}__btn ${prefix}__btn--primary ${prefix}__btn--play" title="Play">${ICONS.play}</button>
+        ${mergedConfig.showNavigation ? `<button class="${prefix}__btn ${prefix}__btn--next" title="Next">${ICONS.next}</button>` : ""}
+      </div>
+    `;
+  };
+  const buildMiniLayout = () => {
+    return `
+      <button class="${prefix}__btn ${prefix}__btn--primary ${prefix}__btn--play" title="Play">${ICONS.play}</button>
+      ${mergedConfig.showArtwork ? `
+        <div class="${prefix}__artwork">
+          <img src="${mergedConfig.defaultArtwork || ""}" alt="Album art" />
+        </div>
+      ` : ""}
+      <div class="${prefix}__info">
+        ${mergedConfig.showTitle ? `<div class="${prefix}__title-wrapper"><div class="${prefix}__title">-</div></div>` : ""}
+        <div class="${prefix}__progress">
+          <div class="${prefix}__progress-bar">
+            <div class="${prefix}__progress-fill" style="transform: scaleX(0)"></div>
+          </div>
+        </div>
+      </div>
+    `;
+  };
+  const attachEventListeners = () => {
+    if (!container || !api) return;
+    playPauseBtn?.addEventListener("click", () => {
+      const playing = api?.getState("playing");
+      if (playing) {
+        api?.emit("playback:pause", void 0);
+      } else {
+        api?.emit("playback:play", void 0);
+      }
+    });
+    container.querySelector(`.${prefix}__btn--prev`)?.addEventListener("click", () => {
+      const playlist = api?.getPlugin("playlist");
+      if (playlist) {
+        playlist.previous();
+      } else {
+        api?.emit("playback:seeking", { time: 0 });
+      }
+    });
+    container.querySelector(`.${prefix}__btn--next`)?.addEventListener("click", () => {
+      const playlist = api?.getPlugin("playlist");
+      playlist?.next();
+    });
+    shuffleBtn?.addEventListener("click", () => {
+      const playlist = api?.getPlugin("playlist");
+      playlist?.toggleShuffle();
+    });
+    repeatBtn?.addEventListener("click", () => {
+      const playlist = api?.getPlugin("playlist");
+      playlist?.cycleRepeat();
+    });
+    volumeBtn?.addEventListener("click", () => {
+      const muted = api?.getState("muted");
+      api?.emit("volume:mute", { muted: !muted });
+    });
+    const progressBar = container.querySelector(`.${prefix}__progress-bar`);
+    progressBar?.addEventListener("click", (e) => {
+      const mouseEvent = e;
+      const rect = mouseEvent.currentTarget.getBoundingClientRect();
+      const percent = (mouseEvent.clientX - rect.left) / rect.width;
+      const duration = api?.getState("duration") || 0;
+      const time = percent * duration;
+      api?.emit("playback:seeking", { time });
+    });
+    const volumeSlider = container.querySelector(`.${prefix}__volume-slider`);
+    volumeSlider?.addEventListener("click", (e) => {
+      const mouseEvent = e;
+      const rect = mouseEvent.currentTarget.getBoundingClientRect();
+      const percent = Math.max(0, Math.min(1, (mouseEvent.clientX - rect.left) / rect.width));
+      api?.emit("volume:change", { volume: percent, muted: false });
+    });
+  };
+  const updateUI = () => {
+    if (!api || !container) return;
+    const playing = api.getState("playing");
+    const wasPlaying = isPlaying;
+    isPlaying = playing;
+    if (playPauseBtn) {
+      playPauseBtn.innerHTML = playing ? ICONS.pause : ICONS.play;
+      playPauseBtn.title = playing ? "Pause" : "Play";
+    }
+    const currentTime = api.getState("currentTime") || 0;
+    const duration = api.getState("duration") || 0;
+    lastKnownTime = currentTime;
+    lastUpdateTimestamp = performance.now();
+    if (playing && !wasPlaying) {
+      startProgressAnimation();
+    } else if (!playing && wasPlaying) {
+      stopProgressAnimation();
+    }
+    if (!playing) {
+      const scale = duration > 0 ? currentTime / duration : 0;
+      if (progressFill) {
+        progressFill.style.transform = `scaleX(${scale})`;
+      }
+      if (currentTimeEl) {
+        currentTimeEl.textContent = formatTime(currentTime);
+      }
+    }
+    if (durationEl) {
+      durationEl.textContent = formatTime(duration);
+    }
+    const title = api.getState("title");
+    const poster = api.getState("poster");
+    if (titleEl && title) {
+      titleEl.textContent = title;
+      if (layout === "mini") {
+        const wrapper = titleEl.parentElement;
+        if (wrapper && titleEl.scrollWidth > wrapper.clientWidth) {
+          titleEl.textContent = `${title}     •     ${title}     •     `;
+          titleEl.classList.add("scrolling");
+        } else {
+          titleEl.classList.remove("scrolling");
+        }
+      }
+    }
+    if (artworkImg && poster) {
+      artworkImg.src = poster;
+    }
+    const volume = api.getState("volume") || 1;
+    const muted = api.getState("muted");
+    if (volumeFill) {
+      volumeFill.style.width = `${(muted ? 0 : volume) * 100}%`;
+    }
+    if (volumeBtn) {
+      volumeBtn.innerHTML = muted || volume === 0 ? ICONS.volumeMuted : ICONS.volumeHigh;
+    }
+    const playlist = api.getPlugin("playlist");
+    if (playlist) {
+      const state = playlist.getState();
+      if (shuffleBtn) {
+        shuffleBtn.classList.toggle(`${prefix}__btn--active`, state.shuffle);
+      }
+      if (repeatBtn) {
+        repeatBtn.classList.toggle(`${prefix}__btn--active`, state.repeat !== "none");
+        if (state.repeat === "one") {
+          repeatBtn.innerHTML = ICONS.repeatOne;
+        } else if (state.repeat === "all") {
+          repeatBtn.innerHTML = ICONS.repeatAll;
+        } else {
+          repeatBtn.innerHTML = ICONS.repeatOff;
+        }
+      }
+    }
+  };
+  const plugin = {
+    id: "audio-ui",
+    name: "Audio UI",
+    version: "1.0.0",
+    type: "ui",
+    description: "Compact audio player interface",
+    async init(pluginApi) {
+      api = pluginApi;
+      api.logger.info("Audio UI plugin initialized");
+      createUI();
+      const unsubState = api.subscribeToState(() => {
+        updateUI();
+      });
+      const unsubTime = api.on("playback:timeupdate", () => {
+        updateUI();
+      });
+      const unsubPlaylist = api.on("playlist:change", (payload) => {
+        if (payload?.track) {
+          if (titleEl) titleEl.textContent = payload.track.title || "-";
+          if (artistEl) artistEl.textContent = payload.track.artist || "-";
+          if (artworkImg && payload.track.artwork) {
+            artworkImg.src = payload.track.artwork;
+          }
+        }
+      });
+      const unsubShuffle = api.on("playlist:shuffle", () => {
+        updateUI();
+      });
+      const unsubRepeat = api.on("playlist:repeat", () => {
+        updateUI();
+      });
+      api.onDestroy(() => {
+        unsubState();
+        unsubTime();
+        unsubPlaylist();
+        unsubShuffle();
+        unsubRepeat();
+      });
+      updateUI();
+    },
+    async destroy() {
+      api?.logger.info("Audio UI plugin destroying");
+      stopProgressAnimation();
+      if (container?.parentNode) {
+        container.parentNode.removeChild(container);
+      }
+      if (styleElement?.parentNode) {
+        styleElement.parentNode.removeChild(styleElement);
+      }
+      container = null;
+      styleElement = null;
+      api = null;
+    },
+    getElement() {
+      return container;
+    },
+    setLayout(newLayout) {
+      if (!container) return;
+      stopProgressAnimation();
+      layout = newLayout;
+      container.className = `${prefix} ${prefix}--${layout}`;
+      if (layout === "full") {
+        container.innerHTML = buildFullLayout();
+      } else if (layout === "compact") {
+        container.innerHTML = buildCompactLayout();
+      } else {
+        container.innerHTML = buildMiniLayout();
+      }
+      artworkImg = container.querySelector(`.${prefix}__artwork img`);
+      titleEl = container.querySelector(`.${prefix}__title`);
+      artistEl = container.querySelector(`.${prefix}__artist`);
+      progressFill = container.querySelector(`.${prefix}__progress-fill`);
+      currentTimeEl = container.querySelector(`.${prefix}__time--current`);
+      durationEl = container.querySelector(`.${prefix}__time--duration`);
+      playPauseBtn = container.querySelector(`.${prefix}__btn--play`);
+      shuffleBtn = container.querySelector(`.${prefix}__btn--shuffle`);
+      repeatBtn = container.querySelector(`.${prefix}__btn--repeat`);
+      volumeBtn = container.querySelector(`.${prefix}__btn--volume`);
+      volumeFill = container.querySelector(`.${prefix}__volume-fill`);
+      attachEventListeners();
+      updateUI();
+      if (isPlaying) {
+        startProgressAnimation();
+      }
+    },
+    setTheme(newTheme) {
+      Object.assign(theme, newTheme);
+      if (styleElement) {
+        styleElement.textContent = createStyles(prefix, theme);
+      }
+    },
+    show() {
+      isVisible = true;
+      container?.classList.remove(`${prefix}--hidden`);
+    },
+    hide() {
+      isVisible = false;
+      container?.classList.add(`${prefix}--hidden`);
+    },
+    toggle() {
+      if (isVisible) {
+        this.hide();
+      } else {
+        this.show();
+      }
+    }
+  };
+  return plugin;
+}
+var DEFAULT_CONFIG$1 = {
+  enablePlayPause: true,
+  enableSeek: true,
+  enableTrackNavigation: true,
+  seekOffset: 10,
+  updatePositionState: true
+};
+function isMediaSessionSupported() {
+  return typeof navigator !== "undefined" && "mediaSession" in navigator;
+}
+function createMediaSessionPlugin(config) {
+  const mergedConfig = { ...DEFAULT_CONFIG$1, ...config };
+  let api = null;
+  let currentMetadata = {};
+  const updateMetadata = () => {
+    if (!isMediaSessionSupported()) return;
+    const artwork = [];
+    const artworkSources = currentMetadata.artwork || mergedConfig.defaultArtwork || [];
+    for (const art of artworkSources) {
+      artwork.push({
+        src: art.src,
+        sizes: art.sizes || "512x512",
+        type: art.type || "image/png"
+      });
+    }
+    try {
+      navigator.mediaSession.metadata = new MediaMetadata({
+        title: currentMetadata.title || "Unknown",
+        artist: currentMetadata.artist || "",
+        album: currentMetadata.album || "",
+        artwork
+      });
+    } catch (e) {
+      api?.logger.warn("Failed to set media session metadata", e);
+    }
+  };
+  const updatePositionState = () => {
+    if (!isMediaSessionSupported() || !mergedConfig.updatePositionState) return;
+    const duration = api?.getState("duration") || 0;
+    const position = api?.getState("currentTime") || 0;
+    const playbackRate = api?.getState("playbackRate") || 1;
+    if (duration > 0 && isFinite(duration)) {
+      try {
+        navigator.mediaSession.setPositionState({
+          duration,
+          position: Math.min(position, duration),
+          playbackRate
+        });
+      } catch (e) {
+        api?.logger.debug("Failed to set position state", e);
+      }
+    }
+  };
+  const setupActionHandlers = () => {
+    if (!isMediaSessionSupported()) return;
+    const seekOffset = mergedConfig.seekOffset || 10;
+    if (mergedConfig.enablePlayPause) {
+      try {
+        navigator.mediaSession.setActionHandler("play", () => {
+          api?.logger.debug("Media session: play");
+          api?.emit("playback:play", void 0);
+        });
+        navigator.mediaSession.setActionHandler("pause", () => {
+          api?.logger.debug("Media session: pause");
+          api?.emit("playback:pause", void 0);
+        });
+        navigator.mediaSession.setActionHandler("stop", () => {
+          api?.logger.debug("Media session: stop");
+          api?.emit("playback:pause", void 0);
+          api?.emit("playback:seeking", { time: 0 });
+        });
+      } catch (e) {
+        api?.logger.debug("Some play/pause actions not supported", e);
+      }
+    }
+    if (mergedConfig.enableSeek) {
+      try {
+        navigator.mediaSession.setActionHandler("seekbackward", (details) => {
+          const offset = details.seekOffset || seekOffset;
+          const currentTime = api?.getState("currentTime") || 0;
+          const newTime = Math.max(0, currentTime - offset);
+          api?.logger.debug("Media session: seekbackward", { offset, newTime });
+          api?.emit("playback:seeking", { time: newTime });
+        });
+        navigator.mediaSession.setActionHandler("seekforward", (details) => {
+          const offset = details.seekOffset || seekOffset;
+          const currentTime = api?.getState("currentTime") || 0;
+          const duration = api?.getState("duration") || 0;
+          const newTime = Math.min(duration, currentTime + offset);
+          api?.logger.debug("Media session: seekforward", { offset, newTime });
+          api?.emit("playback:seeking", { time: newTime });
+        });
+        navigator.mediaSession.setActionHandler("seekto", (details) => {
+          if (details.seekTime !== void 0) {
+            api?.logger.debug("Media session: seekto", { time: details.seekTime });
+            api?.emit("playback:seeking", { time: details.seekTime });
+          }
+        });
+      } catch (e) {
+        api?.logger.debug("Some seek actions not supported", e);
+      }
+    }
+    if (mergedConfig.enableTrackNavigation) {
+      try {
+        navigator.mediaSession.setActionHandler("previoustrack", () => {
+          api?.logger.debug("Media session: previoustrack");
+          const playlist = api?.getPlugin("playlist");
+          if (playlist) {
+            playlist.previous();
+          } else {
+            api?.emit("playback:seeking", { time: 0 });
+          }
+        });
+        navigator.mediaSession.setActionHandler("nexttrack", () => {
+          api?.logger.debug("Media session: nexttrack");
+          const playlist = api?.getPlugin("playlist");
+          if (playlist) {
+            playlist.next();
+          }
+        });
+      } catch (e) {
+        api?.logger.debug("Track navigation not supported", e);
+      }
+    }
+  };
+  const clearActionHandlers = () => {
+    if (!isMediaSessionSupported()) return;
+    const actions = [
+      "play",
+      "pause",
+      "stop",
+      "seekbackward",
+      "seekforward",
+      "seekto",
+      "previoustrack",
+      "nexttrack"
+    ];
+    for (const action of actions) {
+      try {
+        navigator.mediaSession.setActionHandler(action, null);
+      } catch (e) {
+      }
+    }
+  };
+  const plugin = {
+    id: "media-session",
+    name: "Media Session",
+    version: "1.0.0",
+    type: "feature",
+    description: "Media Session API integration for system-level media controls",
+    async init(pluginApi) {
+      api = pluginApi;
+      if (!isMediaSessionSupported()) {
+        api.logger.info("Media Session API not supported in this browser");
+        return;
+      }
+      api.logger.info("Media Session plugin initialized");
+      setupActionHandlers();
+      const unsubPlay = api.on("playback:play", () => {
+        if (isMediaSessionSupported()) {
+          navigator.mediaSession.playbackState = "playing";
+        }
+      });
+      const unsubPause = api.on("playback:pause", () => {
+        if (isMediaSessionSupported()) {
+          navigator.mediaSession.playbackState = "paused";
+        }
+      });
+      const unsubEnded = api.on("playback:ended", () => {
+        if (isMediaSessionSupported()) {
+          navigator.mediaSession.playbackState = "none";
+        }
+      });
+      let lastPositionUpdate = 0;
+      const unsubTimeUpdate = api.on("playback:timeupdate", () => {
+        const now = Date.now();
+        if (now - lastPositionUpdate >= 1e3) {
+          lastPositionUpdate = now;
+          updatePositionState();
+        }
+      });
+      const unsubMetadata = api.on("media:loadedmetadata", () => {
+        updatePositionState();
+      });
+      const unsubState = api.subscribeToState((event) => {
+        if (event.key === "title" && typeof event.value === "string") {
+          currentMetadata.title = event.value;
+          updateMetadata();
+        } else if (event.key === "poster" && typeof event.value === "string") {
+          currentMetadata.artwork = [{ src: event.value, sizes: "512x512" }];
+          updateMetadata();
+        }
+      });
+      const unsubPlaylist = api.on("playlist:change", (payload) => {
+        if (payload?.track) {
+          const track = payload.track;
+          currentMetadata = {
+            title: track.title,
+            artist: track.artist,
+            album: track.album,
+            artwork: track.artwork ? [{ src: track.artwork, sizes: "512x512" }] : void 0
+          };
+          updateMetadata();
+        }
+      });
+      api.onDestroy(() => {
+        unsubPlay();
+        unsubPause();
+        unsubEnded();
+        unsubTimeUpdate();
+        unsubMetadata();
+        unsubState();
+        unsubPlaylist();
+        clearActionHandlers();
+      });
+    },
+    async destroy() {
+      api?.logger.info("Media Session plugin destroying");
+      clearActionHandlers();
+      if (isMediaSessionSupported()) {
+        navigator.mediaSession.metadata = null;
+        navigator.mediaSession.playbackState = "none";
+      }
+      api = null;
+    },
+    isSupported() {
+      return isMediaSessionSupported();
+    },
+    setMetadata(metadata) {
+      currentMetadata = { ...currentMetadata, ...metadata };
+      updateMetadata();
+    },
+    setPlaybackState(state) {
+      if (isMediaSessionSupported()) {
+        navigator.mediaSession.playbackState = state;
+      }
+    },
+    setPositionState(state) {
+      if (isMediaSessionSupported()) {
+        try {
+          navigator.mediaSession.setPositionState(state);
+        } catch (e) {
+          api?.logger.debug("Failed to set position state", e);
+        }
+      }
+    },
+    setActionHandler(action, handler) {
+      if (isMediaSessionSupported()) {
+        try {
+          navigator.mediaSession.setActionHandler(action, handler);
+        } catch (e) {
+          api?.logger.debug(`Action ${action} not supported`, e);
+        }
+      }
+    }
+  };
+  return plugin;
+}
+var DEFAULT_CONFIG = {
+  autoAdvance: true,
+  preloadNext: true,
+  persist: false,
+  persistKey: "scarlett-playlist",
+  shuffle: false,
+  repeat: "none"
+};
+function generateId() {
+  return `track-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function shuffleArray(array) {
+  const result = [...array];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+function createPlaylistPlugin(config) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  let api = null;
+  let tracks = mergedConfig.tracks || [];
+  let currentIndex = -1;
+  let shuffle = mergedConfig.shuffle || false;
+  let repeat = mergedConfig.repeat || "none";
+  let shuffleOrder = [];
+  tracks = tracks.map((t) => ({ ...t, id: t.id || generateId() }));
+  const generateShuffleOrder = () => {
+    const indices = tracks.map((_, i) => i);
+    shuffleOrder = shuffleArray(indices);
+    if (currentIndex >= 0) {
+      const currentPos = shuffleOrder.indexOf(currentIndex);
+      if (currentPos > 0) {
+        shuffleOrder.splice(currentPos, 1);
+        shuffleOrder.unshift(currentIndex);
+      }
+    }
+  };
+  const getActualIndex = (logicalIndex) => {
+    if (!shuffle || shuffleOrder.length === 0) {
+      return logicalIndex;
+    }
+    return shuffleOrder[logicalIndex] ?? logicalIndex;
+  };
+  const getLogicalIndex = (actualIndex) => {
+    if (!shuffle || shuffleOrder.length === 0) {
+      return actualIndex;
+    }
+    return shuffleOrder.indexOf(actualIndex);
+  };
+  const hasNextTrack = () => {
+    if (tracks.length === 0) return false;
+    if (repeat === "one" || repeat === "all") return true;
+    const logicalIndex = getLogicalIndex(currentIndex);
+    return logicalIndex < tracks.length - 1;
+  };
+  const hasPreviousTrack = () => {
+    if (tracks.length === 0) return false;
+    if (repeat === "one" || repeat === "all") return true;
+    const logicalIndex = getLogicalIndex(currentIndex);
+    return logicalIndex > 0;
+  };
+  const getNextIndex = () => {
+    if (tracks.length === 0) return -1;
+    if (repeat === "one") {
+      return currentIndex;
+    }
+    const logicalIndex = getLogicalIndex(currentIndex);
+    let nextLogical = logicalIndex + 1;
+    if (nextLogical >= tracks.length) {
+      if (repeat === "all") {
+        if (shuffle) {
+          generateShuffleOrder();
+        }
+        nextLogical = 0;
+      } else {
+        return -1;
+      }
+    }
+    return getActualIndex(nextLogical);
+  };
+  const getPreviousIndex = () => {
+    if (tracks.length === 0) return -1;
+    if (repeat === "one") {
+      return currentIndex;
+    }
+    const logicalIndex = getLogicalIndex(currentIndex);
+    let prevLogical = logicalIndex - 1;
+    if (prevLogical < 0) {
+      if (repeat === "all") {
+        prevLogical = tracks.length - 1;
+      } else {
+        return -1;
+      }
+    }
+    return getActualIndex(prevLogical);
+  };
+  const persistPlaylist = () => {
+    if (!mergedConfig.persist) return;
+    try {
+      const data = {
+        tracks,
+        currentIndex,
+        shuffle,
+        repeat,
+        shuffleOrder
+      };
+      localStorage.setItem(mergedConfig.persistKey, JSON.stringify(data));
+    } catch (e) {
+      api?.logger.warn("Failed to persist playlist", e);
+    }
+  };
+  const loadPersistedPlaylist = () => {
+    if (!mergedConfig.persist) return;
+    try {
+      const data = localStorage.getItem(mergedConfig.persistKey);
+      if (data) {
+        const parsed = JSON.parse(data);
+        tracks = parsed.tracks || [];
+        currentIndex = parsed.currentIndex ?? -1;
+        shuffle = parsed.shuffle ?? false;
+        repeat = parsed.repeat ?? "none";
+        shuffleOrder = parsed.shuffleOrder || [];
+      }
+    } catch (e) {
+      api?.logger.warn("Failed to load persisted playlist", e);
+    }
+  };
+  const emitChange = () => {
+    const track = currentIndex >= 0 ? tracks[currentIndex] : null;
+    api?.emit("playlist:change", { track, index: currentIndex });
+    persistPlaylist();
+  };
+  const setCurrentTrack = (index) => {
+    if (index < 0 || index >= tracks.length) {
+      api?.logger.warn("Invalid track index", { index });
+      return;
+    }
+    const track = tracks[index];
+    currentIndex = index;
+    api?.logger.info("Track changed", { index, title: track.title, src: track.src });
+    if (track.title) {
+      api?.setState("title", track.title);
+    }
+    if (track.artwork) {
+      api?.setState("poster", track.artwork);
+    }
+    api?.setState("mediaType", track.type || "audio");
+    emitChange();
+  };
+  const plugin = {
+    id: "playlist",
+    name: "Playlist",
+    version: "1.0.0",
+    type: "feature",
+    description: "Playlist management with shuffle, repeat, and gapless playback",
+    async init(pluginApi) {
+      api = pluginApi;
+      api.logger.info("Playlist plugin initialized");
+      loadPersistedPlaylist();
+      if (shuffle && tracks.length > 0) {
+        generateShuffleOrder();
+      }
+      const unsubEnded = api.on("playback:ended", () => {
+        if (!mergedConfig.autoAdvance) return;
+        const nextIdx = getNextIndex();
+        if (nextIdx >= 0) {
+          api?.logger.debug("Auto-advancing to next track", { nextIdx });
+          setCurrentTrack(nextIdx);
+        } else {
+          api?.logger.info("Playlist ended");
+          api?.emit("playlist:ended", void 0);
+        }
+      });
+      api.onDestroy(() => {
+        unsubEnded();
+        persistPlaylist();
+      });
+    },
+    async destroy() {
+      api?.logger.info("Playlist plugin destroying");
+      persistPlaylist();
+      api = null;
+    },
+    add(trackOrTracks) {
+      const newTracks = Array.isArray(trackOrTracks) ? trackOrTracks : [trackOrTracks];
+      newTracks.forEach((track) => {
+        const normalizedTrack = { ...track, id: track.id || generateId() };
+        const index = tracks.length;
+        tracks.push(normalizedTrack);
+        api?.emit("playlist:add", { track: normalizedTrack, index });
+        api?.logger.debug("Track added", { title: normalizedTrack.title, index });
+      });
+      if (shuffle) {
+        const startIndex = tracks.length - newTracks.length;
+        for (let i = startIndex; i < tracks.length; i++) {
+          const insertPos = Math.floor(Math.random() * (shuffleOrder.length - getLogicalIndex(currentIndex))) + getLogicalIndex(currentIndex) + 1;
+          shuffleOrder.splice(Math.min(insertPos, shuffleOrder.length), 0, i);
+        }
+      }
+      persistPlaylist();
+    },
+    insert(index, track) {
+      const normalizedTrack = { ...track, id: track.id || generateId() };
+      const clampedIndex = Math.max(0, Math.min(index, tracks.length));
+      tracks.splice(clampedIndex, 0, normalizedTrack);
+      if (currentIndex >= clampedIndex) {
+        currentIndex++;
+      }
+      if (shuffle) {
+        shuffleOrder = shuffleOrder.map((i) => i >= clampedIndex ? i + 1 : i);
+        const insertPos = Math.floor(Math.random() * shuffleOrder.length);
+        shuffleOrder.splice(insertPos, 0, clampedIndex);
+      }
+      api?.emit("playlist:add", { track: normalizedTrack, index: clampedIndex });
+      persistPlaylist();
+    },
+    remove(idOrIndex) {
+      let index;
+      if (typeof idOrIndex === "string") {
+        index = tracks.findIndex((t) => t.id === idOrIndex);
+        if (index === -1) {
+          api?.logger.warn("Track not found", { id: idOrIndex });
+          return;
+        }
+      } else {
+        index = idOrIndex;
+      }
+      if (index < 0 || index >= tracks.length) {
+        api?.logger.warn("Invalid track index", { index });
+        return;
+      }
+      const [removedTrack] = tracks.splice(index, 1);
+      if (index < currentIndex) {
+        currentIndex--;
+      } else if (index === currentIndex) {
+        if (currentIndex >= tracks.length) {
+          currentIndex = tracks.length - 1;
+        }
+        emitChange();
+      }
+      if (shuffle) {
+        shuffleOrder = shuffleOrder.filter((i) => i !== index).map((i) => i > index ? i - 1 : i);
+      }
+      api?.emit("playlist:remove", { track: removedTrack, index });
+      persistPlaylist();
+    },
+    clear() {
+      tracks = [];
+      currentIndex = -1;
+      shuffleOrder = [];
+      api?.emit("playlist:clear", void 0);
+      emitChange();
+    },
+    play(idOrIndex) {
+      let index;
+      if (idOrIndex === void 0) {
+        index = currentIndex >= 0 ? currentIndex : shuffle ? getActualIndex(0) : 0;
+      } else if (typeof idOrIndex === "string") {
+        index = tracks.findIndex((t) => t.id === idOrIndex);
+        if (index === -1) {
+          api?.logger.warn("Track not found", { id: idOrIndex });
+          return;
+        }
+      } else {
+        index = idOrIndex;
+      }
+      if (tracks.length === 0) {
+        api?.logger.warn("Playlist is empty");
+        return;
+      }
+      setCurrentTrack(index);
+    },
+    next() {
+      const nextIdx = getNextIndex();
+      if (nextIdx >= 0) {
+        setCurrentTrack(nextIdx);
+      } else {
+        api?.logger.info("No next track");
+      }
+    },
+    previous() {
+      const currentTime = api?.getState("currentTime") || 0;
+      if (currentTime > 3) {
+        api?.emit("playback:seeking", { time: 0 });
+        return;
+      }
+      const prevIdx = getPreviousIndex();
+      if (prevIdx >= 0) {
+        setCurrentTrack(prevIdx);
+      } else {
+        api?.logger.info("No previous track");
+      }
+    },
+    toggleShuffle() {
+      this.setShuffle(!shuffle);
+    },
+    setShuffle(enabled) {
+      shuffle = enabled;
+      if (enabled) {
+        generateShuffleOrder();
+      } else {
+        shuffleOrder = [];
+      }
+      api?.emit("playlist:shuffle", { enabled });
+      api?.logger.info("Shuffle mode", { enabled });
+      persistPlaylist();
+    },
+    cycleRepeat() {
+      const modes = ["none", "all", "one"];
+      const currentIdx = modes.indexOf(repeat);
+      const nextIdx = (currentIdx + 1) % modes.length;
+      this.setRepeat(modes[nextIdx]);
+    },
+    setRepeat(mode) {
+      repeat = mode;
+      api?.emit("playlist:repeat", { mode });
+      api?.logger.info("Repeat mode", { mode });
+      persistPlaylist();
+    },
+    move(fromIndex, toIndex) {
+      if (fromIndex < 0 || fromIndex >= tracks.length) return;
+      if (toIndex < 0 || toIndex >= tracks.length) return;
+      if (fromIndex === toIndex) return;
+      const [track] = tracks.splice(fromIndex, 1);
+      tracks.splice(toIndex, 0, track);
+      if (currentIndex === fromIndex) {
+        currentIndex = toIndex;
+      } else if (fromIndex < currentIndex && toIndex >= currentIndex) {
+        currentIndex--;
+      } else if (fromIndex > currentIndex && toIndex <= currentIndex) {
+        currentIndex++;
+      }
+      if (shuffle) {
+        generateShuffleOrder();
+      }
+      api?.emit("playlist:reorder", { tracks: [...tracks] });
+      persistPlaylist();
+    },
+    getState() {
+      return {
+        tracks: [...tracks],
+        currentIndex,
+        currentTrack: currentIndex >= 0 ? tracks[currentIndex] : null,
+        shuffle,
+        repeat,
+        shuffleOrder: [...shuffleOrder],
+        hasNext: hasNextTrack(),
+        hasPrevious: hasPreviousTrack()
+      };
+    },
+    getTracks() {
+      return [...tracks];
+    },
+    getCurrentTrack() {
+      return currentIndex >= 0 ? tracks[currentIndex] : null;
+    },
+    getTrack(id) {
+      return tracks.find((t) => t.id === id) || null;
+    }
+  };
+  return plugin;
+}
+function parseAudioDataAttributes(element) {
+  const dataset = element.dataset;
+  const config = {
+    src: dataset.src,
+    autoplay: dataset.autoplay !== void 0 && dataset.autoplay !== "false",
+    muted: dataset.muted !== void 0 && dataset.muted !== "false",
+    loop: dataset.loop !== void 0 && dataset.loop !== "false",
+    compact: dataset.compact !== void 0 && dataset.compact !== "false",
+    brandColor: dataset.brandColor,
+    primaryColor: dataset.primaryColor,
+    backgroundColor: dataset.backgroundColor,
+    title: dataset.title,
+    artist: dataset.artist,
+    album: dataset.album,
+    artwork: dataset.artwork || dataset.poster
+  };
+  if (dataset.playlist) {
+    try {
+      config.playlist = JSON.parse(dataset.playlist);
+    } catch (e) {
+      console.warn("[Scarlett Audio] Invalid playlist JSON");
+    }
+  }
+  return config;
+}
+async function createAudioPlayer(container, config) {
+  if (!config.src && !config.playlist?.length) {
+    console.error("[Scarlett Audio] No source URL or playlist provided");
+    return null;
+  }
+  try {
+    container.style.position = container.style.position || "relative";
+    if (config.compact) {
+      container.style.height = container.style.height || "64px";
+    } else {
+      container.style.height = container.style.height || "120px";
+    }
+    container.style.width = container.style.width || "100%";
+    const plugins = [
+      createHLSPlugin(),
+      createMediaSessionPlugin({
+        title: config.title || config.playlist?.[0]?.title,
+        artist: config.artist || config.playlist?.[0]?.artist,
+        album: config.album,
+        artwork: config.artwork || config.playlist?.[0]?.artwork
+      })
+    ];
+    if (config.playlist?.length) {
+      plugins.push(createPlaylistPlugin({
+        items: config.playlist.map((item, index) => ({
+          id: `track-${index}`,
+          src: item.src,
+          title: item.title,
+          artist: item.artist,
+          poster: item.artwork,
+          duration: item.duration
+        }))
+      }));
+    }
+    plugins.push(createAudioUIPlugin({
+      layout: config.compact ? "compact" : "full",
+      theme: {
+        primary: config.brandColor,
+        text: config.primaryColor,
+        background: config.backgroundColor
+      }
+    }));
+    const player = await createPlayer({
+      container,
+      src: config.src || config.playlist?.[0]?.src || "",
+      autoplay: config.autoplay || false,
+      muted: config.muted || false,
+      loop: config.loop || false,
+      plugins
+    });
+    return player;
+  } catch (error) {
+    console.error("[Scarlett Audio] Failed to create player:", error);
+    return null;
+  }
+}
+async function initElement(element) {
+  if (element.hasAttribute("data-scarlett-initialized")) {
+    return null;
+  }
+  const config = parseAudioDataAttributes(element);
+  element.setAttribute("data-scarlett-initialized", "true");
+  const player = await createAudioPlayer(element, config);
+  if (!player) {
+    element.removeAttribute("data-scarlett-initialized");
+  }
+  return player;
+}
+const AUDIO_SELECTORS = [
+  "[data-scarlett-audio]",
+  "[data-audio-player]",
+  ".scarlett-audio"
+];
+async function initAll() {
+  const selector = AUDIO_SELECTORS.join(", ");
+  const elements = document.querySelectorAll(selector);
+  const promises = Array.from(elements).map((element) => initElement(element));
+  await Promise.all(promises);
+  if (elements.length > 0) {
+    console.log(`[Scarlett Audio] Initialized ${elements.length} player(s) (light build)`);
+  }
+}
+async function create(options) {
+  let container = null;
+  if (typeof options.container === "string") {
+    container = document.querySelector(options.container);
+    if (!container) {
+      console.error(`[Scarlett Audio] Container not found: ${options.container}`);
+      return null;
+    }
+  } else {
+    container = options.container;
+  }
+  return createAudioPlayer(container, options);
+}
+const VERSION = "0.1.2-audio-light";
+const ScarlettAudioAPI = {
+  create,
+  initAll,
+  version: VERSION
+};
+if (typeof window !== "undefined") {
+  window.ScarlettAudio = ScarlettAudioAPI;
+}
+if (typeof document !== "undefined") {
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", () => {
+      initAll();
+    });
+  } else {
+    initAll();
+  }
+}
+export {
+  create,
+  createAudioPlayer,
+  ScarlettAudioAPI as default,
+  initAll,
+  initElement,
+  parseAudioDataAttributes
+};
+//# sourceMappingURL=embed.audio.light.js.map