@scarlett-player/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2271 @@
+const effectContext = {
+  current: null
+};
+let currentEffect = null;
+function setCurrentEffect(effect2) {
+  effectContext.current = effect2;
+  currentEffect = effect2;
+}
+function getCurrentEffect() {
+  return effectContext.current;
+}
+function effect(fn) {
+  const execute = () => {
+    setCurrentEffect(execute);
+    try {
+      fn();
+    } catch (error) {
+      console.error("[Scarlett Player] Error in effect:", error);
+      throw error;
+    } finally {
+      setCurrentEffect(null);
+    }
+  };
+  execute();
+  return () => {
+  };
+}
+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() {
+    if (currentEffect) {
+      this.subscribers.add(currentEffect);
+    }
+    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);
+}
+class Computed {
+  constructor(computation) {
+    this.dirty = true;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.dependencies = /* @__PURE__ */ new Set();
+    this.computation = computation;
+    this.invalidateCallback = () => this.invalidate();
+  }
+  /**
+   * Get the computed value, tracking dependency if in effect context.
+   *
+   * Recomputes if dirty, otherwise returns cached value.
+   *
+   * @returns Computed value
+   */
+  get() {
+    if (this.dirty) {
+      const prevEffect = getCurrentEffect();
+      setCurrentEffect(this.invalidateCallback);
+      try {
+        this.value = this.computation();
+        this.dirty = false;
+      } finally {
+        setCurrentEffect(prevEffect);
+      }
+    }
+    if (currentEffect) {
+      this.subscribers.add(currentEffect);
+    }
+    return this.value;
+  }
+  /**
+   * Mark the computed value as dirty (needs recomputation).
+   *
+   * Called when a dependency changes.
+   * @internal
+   */
+  invalidate() {
+    const wasDirty = this.dirty;
+    this.dirty = true;
+    if (!wasDirty || this.subscribers.size > 0) {
+      this.notifySubscribers();
+    }
+  }
+  /**
+   * Subscribe to computed value changes.
+   *
+   * @param callback - Function to call when computed value may have changed
+   * @returns Unsubscribe function
+   */
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    return () => this.subscribers.delete(callback);
+  }
+  /**
+   * Notify subscribers that this computed value needs recomputation.
+   * @internal
+   */
+  notifySubscribers() {
+    this.subscribers.forEach((subscriber) => {
+      try {
+        subscriber();
+      } catch (error) {
+        console.error("[Scarlett Player] Error in computed subscriber:", error);
+      }
+    });
+  }
+  /**
+   * Clean up all subscriptions.
+   */
+  destroy() {
+    this.dependencies.forEach((unsub) => unsub());
+    this.dependencies.clear();
+    this.subscribers.clear();
+    this.value = void 0;
+    this.dirty = true;
+  }
+  /**
+   * Get the current number of subscribers (for debugging).
+   * @internal
+   */
+  getSubscriberCount() {
+    return this.subscribers.size;
+  }
+}
+function computed(computation) {
+  return new Computed(computation);
+}
+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);
+  }
+}
+function createLogger(scope) {
+  return new Logger({ scope });
+}
+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
+    });
+    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.stateManager.update({
+        playing: true,
+        paused: false,
+        playbackState: "playing"
+      });
+      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.stateManager.update({
+        playing: false,
+        paused: true,
+        playbackState: "paused"
+      });
+      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;
+}
+export {
+  Computed,
+  ErrorCode,
+  ErrorHandler,
+  EventBus,
+  Logger,
+  PluginAPI,
+  PluginManager,
+  ScarlettPlayer,
+  Signal,
+  StateManager,
+  computed,
+  createLogger,
+  createPlayer,
+  currentEffect,
+  effect,
+  getCurrentEffect,
+  setCurrentEffect,
+  signal
+};
+//# sourceMappingURL=index.js.map