@scarlett-player/hls 1.1.1 → 1.2.0

package/dist/chunk-IFUZZQQE.js

@@ -0,0 +1,1141 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/create-hls-plugin.ts
+import { ErrorCode } from "@scarlett-player/core";
+
+// src/quality.ts
+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
+  }));
+}
+function getInitialBandwidthEstimate(overrideBps) {
+  const HLS_DEFAULT_ESTIMATE = 5e5;
+  if (overrideBps !== void 0 && overrideBps > 0) {
+    return overrideBps;
+  }
+  const connection = navigator.connection;
+  if (connection?.downlink && connection.downlink > 0) {
+    const bps = connection.downlink * 1e6;
+    return Math.round(bps * 0.85);
+  }
+  return HLS_DEFAULT_ESTIMATE;
+}
+
+// src/event-map.ts
+var HLS_ERROR_TYPES = {
+  NETWORK_ERROR: "networkError",
+  MEDIA_ERROR: "mediaError",
+  KEY_SYSTEM_ERROR: "keySystemError",
+  MUX_ERROR: "muxError",
+  OTHER_ERROR: "otherError"
+};
+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);
+  });
+  let lastBandwidthUpdate = 0;
+  addHandler("hlsFragLoaded", () => {
+    const now = Date.now();
+    if (now - lastBandwidthUpdate >= 2e3 && hls.bandwidthEstimate) {
+      lastBandwidthUpdate = now;
+      api.setState("bandwidth", Math.round(hls.bandwidthEstimate));
+    }
+    callbacks.onFragLoaded?.();
+  });
+  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);
+      if (data.details.live) {
+        const video = hls.media;
+        if (video && video.seekable && video.seekable.length > 0) {
+          const start = video.seekable.start(0);
+          const end = video.seekable.end(video.seekable.length - 1);
+          api.setState("seekableRange", { start, end });
+          const threshold = (data.details.targetduration ?? 3) * 3;
+          const isAtLiveEdge = end - video.currentTime < threshold;
+          api.setState("liveEdge", isAtLiveEdge);
+          const latency = end - video.currentTime;
+          api.setState("liveLatency", Math.max(0, latency));
+        }
+      }
+      callbacks.onLiveUpdate?.();
+    }
+  });
+  addHandler("hlsError", (_event, data) => {
+    const error = parseHlsError(data);
+    const isBufferHoleSeek = !error.fatal && (error.details?.includes("bufferStalledError") || data.reason?.includes("buffer holes"));
+    if (isBufferHoleSeek) {
+      api.logger.debug(`HLS buffer recovery: ${error.reason || error.details}`, {
+        details: error.details,
+        reason: error.reason
+      });
+    } else if (error.fatal) {
+      api.logger.error(`HLS fatal error: ${error.details} (type=${error.type})`, {
+        type: error.type,
+        details: error.details,
+        url: error.url
+      });
+    } else {
+      api.logger.warn(`HLS error: ${error.details} (type=${error.type}, fatal=${error.fatal})`, {
+        type: error.type,
+        details: error.details,
+        fatal: error.fatal,
+        url: error.url
+      });
+    }
+    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("play", () => {
+    api.setState("paused", false);
+  });
+  addHandler("playing", () => {
+    api.setState("playing", true);
+    api.setState("paused", false);
+    api.setState("waiting", false);
+    api.setState("buffering", 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 });
+    const isLive = api.getState("live");
+    if (isLive && video.seekable && video.seekable.length > 0) {
+      const start = video.seekable.start(0);
+      const end = video.seekable.end(video.seekable.length - 1);
+      api.setState("seekableRange", { start, end });
+      const isAtLiveEdge = end - video.currentTime < 10;
+      api.setState("liveEdge", isAtLiveEdge);
+      api.setState("liveLatency", Math.max(0, end - 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("loadeddata", () => {
+    if (video.videoWidth > 0) {
+      api.setState("mediaType", "video");
+    }
+  });
+  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;
+  };
+}
+
+// src/playlist-validation.ts
+var PLAYLIST_INVALID_TEXT = "Invalid playlist document";
+var MEDIA_PLAYLIST_CONTEXTS = ["level", "audioTrack", "subtitleTrack"];
+function isValidPlaylistDocument(data, contextType) {
+  if (typeof data !== "string" || data.length === 0) return false;
+  const text = data.trimStart();
+  if (!text.startsWith("#EXTM3U")) return false;
+  if (contextType && MEDIA_PLAYLIST_CONTEXTS.includes(contextType)) {
+    return /^#EXT(?:INF|-X-TARGETDURATION):/m.test(text);
+  }
+  return true;
+}
+function createValidatingPlaylistLoader(Hls) {
+  const BaseLoader = Hls.DefaultConfig.loader;
+  return class ValidatingPlaylistLoader extends BaseLoader {
+    /**
+     * Load a playlist, validating the response document before it reaches
+     * the M3U8 parser.
+     *
+     * @param context - hls.js loader context
+     * @param config - hls.js loader config
+     * @param callbacks - hls.js loader callbacks
+     */
+    load(context, config, callbacks) {
+      const wrapped = {
+        ...callbacks,
+        onSuccess: (response, stats, ctx, networkDetails) => {
+          if (!isValidPlaylistDocument(response?.data, ctx?.type)) {
+            callbacks.onError(
+              { code: 0, text: PLAYLIST_INVALID_TEXT },
+              ctx,
+              networkDetails,
+              stats
+            );
+            return;
+          }
+          callbacks.onSuccess(response, stats, ctx, networkDetails);
+        }
+      };
+      super.load(context, config, wrapped);
+    }
+  };
+}
+
+// src/create-hls-plugin.ts
+var DEFAULT_CONFIG = {
+  debug: false,
+  autoStartLoad: true,
+  startPosition: -1,
+  lowLatencyMode: false,
+  maxBufferLength: 30,
+  maxMaxBufferLength: 600,
+  backBufferLength: 30,
+  enableWorker: true,
+  capLevelToPlayerSize: true,
+  // Error recovery settings
+  maxNetworkRetries: 3,
+  maxMediaRetries: 2,
+  retryDelayMs: 1e3,
+  retryBackoffFactor: 2,
+  // Load watchdog: never leave the viewer on an endless spinner
+  loadTimeoutMs: 3e4,
+  // Self-healing: reconnect automatically after fatal errors mid-playback
+  autoReconnect: true,
+  reconnectBaseDelayMs: 2e3,
+  reconnectMaxDelayMs: 3e4,
+  reconnectWindowMs: 3e5,
+  // Never index a malformed live playlist refresh blindly
+  validatePlaylists: true
+};
+var MANIFEST_PHASE_ERRORS = [
+  "manifestLoadError",
+  "manifestLoadTimeOut",
+  "manifestParsingError"
+];
+function createHLSPluginWith(loader, variant, config) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...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 loadSession = 0;
+  let abortPendingLoad = null;
+  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;
+  let hasPlayedContent = false;
+  let reconnectTimer = null;
+  let reconnectAttempts = 0;
+  let reconnectWindowStart = 0;
+  let reconnectResumePosition = 0;
+  let onlineListener = null;
+  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 = "position:absolute;top:0;left:0;width:100%;height:100%;display:block;object-fit:contain;background:#000";
+    video.preload = "metadata";
+    video.controls = false;
+    video.playsInline = true;
+    const poster = api?.getState("poster");
+    if (poster) {
+      video.poster = poster;
+    }
+    api?.container.appendChild(video);
+    return video;
+  };
+  const teardownPipeline = (reason) => {
+    abortPendingLoad?.(reason ?? new Error("HLS load cancelled"));
+    abortPendingLoad = null;
+    cleanupHlsEvents?.();
+    cleanupHlsEvents = null;
+    cleanupVideoEvents?.();
+    cleanupVideoEvents = null;
+    if (retryTimeout) {
+      clearTimeout(retryTimeout);
+      retryTimeout = null;
+    }
+    if (hls) {
+      hls.destroy();
+      hls = null;
+    }
+  };
+  const cleanup = (reason) => {
+    teardownPipeline(reason);
+    currentSrc = null;
+    isNative = false;
+    isAutoQuality = true;
+    networkRetryCount = 0;
+    mediaRetryCount = 0;
+    errorCount = 0;
+    errorWindowStart = 0;
+  };
+  const buildHlsConfig = () => {
+    const config2 = buildBaseHlsConfig();
+    if (mergedConfig.validatePlaylists !== false) {
+      const Hls = loader.getHlsConstructor();
+      if (Hls && Hls.DefaultConfig?.loader) {
+        config2.pLoader = createValidatingPlaylistLoader(Hls);
+      }
+    }
+    return config2;
+  };
+  const buildBaseHlsConfig = () => ({
+    debug: mergedConfig.debug,
+    autoStartLoad: mergedConfig.autoStartLoad,
+    startPosition: mergedConfig.startPosition,
+    startLevel: -1,
+    // Auto quality selection (ABR)
+    abrEwmaDefaultEstimate: getInitialBandwidthEstimate(mergedConfig.initialBandwidthEstimate),
+    lowLatencyMode: mergedConfig.lowLatencyMode,
+    maxBufferLength: mergedConfig.maxBufferLength,
+    maxMaxBufferLength: mergedConfig.maxMaxBufferLength,
+    backBufferLength: mergedConfig.backBufferLength,
+    enableWorker: mergedConfig.enableWorker,
+    capLevelToPlayerSize: mergedConfig.capLevelToPlayerSize,
+    // Minimize hls.js internal retries - we handle retries ourselves
+    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;
+    const delay = baseDelay * Math.pow(backoffFactor, retryCount);
+    const jitter = delay * (0.7 + Math.random() * 0.3);
+    return jitter;
+  };
+  const APPEND_ERROR_DETAILS = [
+    "bufferAppendError",
+    "bufferAppendingError",
+    "bufferAddCodecError"
+  ];
+  const mapFatalErrorCode = (error) => {
+    if (error.response?.text === PLAYLIST_INVALID_TEXT) {
+      return ErrorCode.PLAYLIST_INVALID;
+    }
+    if (error.details === "bufferFullError") {
+      return ErrorCode.MEDIA_BUFFER_FULL;
+    }
+    if (APPEND_ERROR_DETAILS.includes(error.details)) {
+      return ErrorCode.MEDIA_APPEND_ERROR;
+    }
+    switch (error.type) {
+      case "network":
+        return ErrorCode.MEDIA_NETWORK_ERROR;
+      case "media":
+      case "mux":
+        return ErrorCode.MEDIA_DECODE_ERROR;
+      default:
+        return ErrorCode.PLAYBACK_FAILED;
+    }
+  };
+  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: mapFatalErrorCode(error),
+      message,
+      fatal: true,
+      timestamp: Date.now()
+    });
+    maybeScheduleReconnect(error);
+  };
+  const handleHlsError = (error) => {
+    const Hls = loader.getHlsConstructor();
+    if (!Hls || !hls) return false;
+    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);
+      teardownPipeline(new Error(error.details));
+      return true;
+    }
+    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 true;
+          }
+          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);
+          }
+          const isManifestPhase = MANIFEST_PHASE_ERRORS.includes(error.details);
+          const retry_session = loadSession;
+          retryTimeout = setTimeout(() => {
+            if (retry_session !== loadSession || !hls) return;
+            if (isManifestPhase && currentSrc) {
+              hls.loadSource(currentSrc);
+            } else {
+              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 true;
+          }
+          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);
+          }
+          const retry_session = loadSession;
+          retryTimeout = setTimeout(() => {
+            if (retry_session !== loadSession || !hls) return;
+            hls.recoverMediaError();
+          }, delay);
+          break;
+        }
+        default:
+          emitFatalError(error, false);
+          return true;
+      }
+    }
+    return false;
+  };
+  const loadNative = async (src) => {
+    const session = loadSession;
+    const videoEl = getOrCreateVideo();
+    isNative = true;
+    if (api) {
+      cleanupVideoEvents = setupVideoEventHandlers(videoEl, api);
+    }
+    return new Promise((resolve, reject) => {
+      let watchdog = null;
+      let settled = false;
+      const settle = () => {
+        settled = true;
+        if (abortPendingLoad === abort) {
+          abortPendingLoad = null;
+        }
+        videoEl.removeEventListener("loadedmetadata", onLoaded);
+        videoEl.removeEventListener("error", onError);
+        if (watchdog !== null) {
+          clearTimeout(watchdog);
+          watchdog = null;
+        }
+      };
+      const abort = (reason) => {
+        if (settled) return;
+        settle();
+        reject(reason);
+      };
+      abortPendingLoad = abort;
+      const onLoaded = () => {
+        if (settled) return;
+        if (session !== loadSession) {
+          settle();
+          reject(new Error("HLS load cancelled"));
+          return;
+        }
+        settle();
+        hasPlayedContent = true;
+        const onFatalVideoError = () => {
+          const media_error = videoEl.error;
+          const hls_error = {
+            type: media_error?.code === MediaError.MEDIA_ERR_NETWORK ? "network" : "media",
+            details: media_error?.message || "Native HLS playback error",
+            fatal: true
+          };
+          emitFatalError(hls_error, false);
+        };
+        videoEl.addEventListener("error", onFatalVideoError);
+        const removeFatalListener = () => videoEl.removeEventListener("error", onFatalVideoError);
+        const previous_cleanup = cleanupVideoEvents;
+        cleanupVideoEvents = () => {
+          removeFatalListener();
+          previous_cleanup?.();
+        };
+        api?.setState("source", { src, type: "application/x-mpegURL" });
+        api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
+        resolve();
+      };
+      const onError = () => {
+        if (settled) return;
+        settle();
+        const error = videoEl.error;
+        reject(new Error(error?.message || "Failed to load HLS source"));
+      };
+      const timeout_ms = mergedConfig.loadTimeoutMs ?? 3e4;
+      if (timeout_ms > 0) {
+        watchdog = setTimeout(() => {
+          if (settled || session !== loadSession) return;
+          settle();
+          reject(new Error("Video took too long to load (network timeout)"));
+        }, timeout_ms);
+      }
+      videoEl.addEventListener("loadedmetadata", onLoaded);
+      videoEl.addEventListener("error", onError);
+      videoEl.src = src;
+      videoEl.load();
+    });
+  };
+  const loadWithHlsJs = async (src) => {
+    const session = loadSession;
+    await loader.loadHlsJs();
+    if (session !== loadSession) {
+      throw new Error("HLS load cancelled");
+    }
+    const videoEl = getOrCreateVideo();
+    isNative = false;
+    hls = loader.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;
+      let watchdog = null;
+      const clearWatchdog = () => {
+        if (watchdog !== null) {
+          clearTimeout(watchdog);
+          watchdog = null;
+        }
+      };
+      const abort = (reason) => {
+        if (resolved) return;
+        resolved = true;
+        clearWatchdog();
+        reject(reason);
+      };
+      abortPendingLoad = abort;
+      const releaseAbort = () => {
+        if (abortPendingLoad === abort) {
+          abortPendingLoad = null;
+        }
+      };
+      cleanupHlsEvents = setupHlsEventHandlers(hls, api, {
+        onManifestParsed: () => {
+          if (session !== loadSession) return;
+          if (!resolved) {
+            resolved = true;
+            releaseAbort();
+            clearWatchdog();
+            hasPlayedContent = true;
+            api?.setState("source", { src, type: "application/x-mpegURL" });
+            api?.emit("media:loaded", { src, type: "application/x-mpegURL" });
+            resolve();
+          }
+        },
+        onLevelSwitched: () => {
+        },
+        onError: (error) => {
+          if (session !== loadSession) return;
+          const terminal = handleHlsError(error);
+          if (terminal && !resolved) {
+            resolved = true;
+            releaseAbort();
+            clearWatchdog();
+            reject(new Error(error.details));
+          }
+        },
+        onFragLoaded: () => {
+          if (session !== loadSession) return;
+          if (networkRetryCount > 0 || mediaRetryCount > 0) {
+            api?.logger.debug("Playback recovered, resetting retry budgets");
+            networkRetryCount = 0;
+            mediaRetryCount = 0;
+          }
+        },
+        getIsAutoQuality: () => isAutoQuality
+      });
+      const timeout_ms = mergedConfig.loadTimeoutMs ?? 3e4;
+      if (timeout_ms > 0) {
+        watchdog = setTimeout(() => {
+          if (resolved || session !== loadSession) return;
+          resolved = true;
+          releaseAbort();
+          api?.logger.error(`HLS load timed out after ${timeout_ms}ms`, { src });
+          teardownPipeline();
+          reject(new Error("Video took too long to load (network timeout)"));
+        }, timeout_ms);
+      }
+      hls.attachMedia(videoEl);
+      hls.loadSource(src);
+    });
+  };
+  const cancelReconnect = () => {
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    reconnectAttempts = 0;
+    reconnectWindowStart = 0;
+    reconnectResumePosition = 0;
+  };
+  const scheduleReconnectAttempt = () => {
+    if (reconnectTimer) return;
+    const window_ms = mergedConfig.reconnectWindowMs ?? 3e5;
+    if (Date.now() - reconnectWindowStart > window_ms) {
+      api?.logger.warn(`Auto-reconnect window exhausted after ${reconnectAttempts} attempts`);
+      return;
+    }
+    const base_delay = mergedConfig.reconnectBaseDelayMs ?? 2e3;
+    const max_delay = mergedConfig.reconnectMaxDelayMs ?? 3e4;
+    const backoff = Math.min(base_delay * Math.pow(2, reconnectAttempts), max_delay);
+    const delay = Math.round(backoff * (0.7 + Math.random() * 0.3));
+    api?.logger.info(`Scheduling auto-reconnect attempt ${reconnectAttempts + 1} in ${delay}ms`);
+    api?.emit("error:reconnecting", { attempt: reconnectAttempts + 1, delayMs: delay });
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void attemptReconnect();
+    }, delay);
+  };
+  const maybeScheduleReconnect = (error) => {
+    if (mergedConfig.autoReconnect === false) return;
+    if (!hasPlayedContent || !currentSrc) return;
+    if (error.type !== "network" && error.type !== "media") return;
+    if (reconnectWindowStart === 0) {
+      reconnectWindowStart = Date.now();
+      reconnectResumePosition = video?.currentTime ?? 0;
+    }
+    scheduleReconnectAttempt();
+  };
+  const attemptReconnect = async () => {
+    if (!api || !currentSrc) return;
+    const session = ++loadSession;
+    reconnectAttempts++;
+    const saved_src = currentSrc;
+    const was_live = api.getState("live");
+    const was_native = isNative;
+    const resume_position = reconnectResumePosition;
+    api.logger.info(`Auto-reconnect attempt ${reconnectAttempts}`, { src: saved_src });
+    try {
+      teardownPipeline(new Error("HLS load cancelled: reconnecting"));
+      networkRetryCount = 0;
+      mediaRetryCount = 0;
+      errorCount = 0;
+      errorWindowStart = 0;
+      currentSrc = saved_src;
+      api.setState("playbackState", "loading");
+      if (was_native && loader.supportsNativeHLS()) {
+        await loadNative(saved_src);
+      } else {
+        await loadWithHlsJs(saved_src);
+      }
+      if (session !== loadSession) return;
+      if (!was_live && video && resume_position > 0) {
+        video.currentTime = resume_position;
+      }
+      api.setState("playbackState", "ready");
+      api.setState("buffering", false);
+      api.emit("error:recovered", void 0);
+      api.logger.info("Auto-reconnect succeeded");
+      cancelReconnect();
+      try {
+        await video?.play();
+      } catch {
+      }
+    } catch {
+      if (session !== loadSession) return;
+      api?.logger.warn(`Auto-reconnect attempt ${reconnectAttempts} failed`);
+      scheduleReconnectAttempt();
+    }
+  };
+  const plugin = {
+    id: "hls-provider",
+    name: variant.name,
+    version: "1.0.0",
+    type: "provider",
+    description: variant.description,
+    canPlay(src) {
+      if (!loader.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${variant.logSuffix} 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}`);
+            const targetLevel = hls.levels[levelIndex];
+            if (targetLevel) {
+              const label = formatLevel(targetLevel);
+              api?.setState("currentQuality", {
+                id: `level-${levelIndex}`,
+                label: `${label}...`,
+                // Ellipsis indicates switching in progress
+                width: targetLevel.width,
+                height: targetLevel.height,
+                bitrate: targetLevel.bitrate,
+                active: false
+                // Not yet active
+              });
+            }
+          }
+        }
+      });
+      if (typeof window !== "undefined") {
+        onlineListener = () => {
+          if (reconnectTimer) {
+            api?.logger.info("Browser back online, reconnecting immediately");
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+            void attemptReconnect();
+          }
+        };
+        window.addEventListener("online", onlineListener);
+      }
+      api.onDestroy(() => {
+        unsubPlay();
+        unsubPause();
+        unsubSeek();
+        unsubVolume();
+        unsubMute();
+        unsubRate();
+        unsubQuality();
+      });
+    },
+    async destroy() {
+      api?.logger.info(`HLS plugin${variant.logSuffix} destroying`);
+      loadSession++;
+      cancelReconnect();
+      if (onlineListener && typeof window !== "undefined") {
+        window.removeEventListener("online", onlineListener);
+        onlineListener = null;
+      }
+      cleanup(new Error("HLS load cancelled: player destroyed"));
+      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${variant.logSuffix}`, { src });
+      const session = ++loadSession;
+      cancelReconnect();
+      hasPlayedContent = false;
+      cleanup(new Error("HLS load cancelled: superseded by a new load"));
+      currentSrc = src;
+      api.setState("playbackState", "loading");
+      api.setState("buffering", true);
+      if (api.getState("airplayActive") && loader.supportsNativeHLS()) {
+        api.logger.info("Using native HLS (AirPlay active)");
+        await loadNative(src);
+      } else if (loader.isHlsJsSupported()) {
+        api.logger.info(`Using ${variant.engineLabel} for HLS playback`);
+        await loadWithHlsJs(src);
+      } else if (loader.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");
+      }
+      if (session !== loadSession) return;
+      if (video) {
+        const muted = api.getState("muted");
+        const volume = api.getState("volume");
+        if (muted !== void 0) video.muted = muted;
+        if (volume !== void 0) video.volume = volume;
+      }
+      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
+      };
+    },
+    /**
+     * Switch from hls.js to native HLS playback.
+     * Used for AirPlay compatibility in Safari.
+     * Preserves current playback position.
+     */
+    async switchToNative() {
+      if (isNative) {
+        api?.logger.debug("Already using native HLS");
+        return;
+      }
+      if (!loader.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;
+      const session = ++loadSession;
+      cleanup(new Error("HLS load cancelled: switching to native HLS"));
+      await loadNative(savedSrc);
+      if (session !== loadSession) return;
+      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");
+    },
+    /**
+     * Switch from native HLS back to hls.js.
+     * Restores quality control after AirPlay session ends.
+     */
+    async switchToHlsJs() {
+      if (!isNative) {
+        api?.logger.debug("Already using hls.js");
+        return;
+      }
+      if (!loader.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;
+      const session = ++loadSession;
+      cleanup(new Error("HLS load cancelled: switching to hls.js"));
+      await loadWithHlsJs(savedSrc);
+      if (session !== loadSession) return;
+      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;
+}
+
+export {
+  __export,
+  createHLSPluginWith
+};