@scarlett-player/hls 1.8.1 → 1.10.0

package/dist/{chunk-VD46AQJB.js → chunk-UB2TS72E.js}

@@ -5,15 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/sanitize-url.ts
-function sanitizeUrl(url) {
-  if (!url) return void 0;
-  try {
-    const parsed = new URL(url);
-    return `${parsed.origin}${parsed.pathname}`;
-  } catch {
-    return void 0;
-  }
-}
+import { sanitizeUrl } from "@scarlett-player/core";
 
 // src/create-hls-plugin.ts
 import { ErrorCode } from "@scarlett-player/core";
@@ -98,15 +90,41 @@ function mapErrorType(hlsType) {
   }
 }
 function parseHlsError(data) {
+  const frag = data.frag;
+  const response = data.response;
+  const context = data.context;
   return {
     type: mapErrorType(data.type),
     details: data.details || "Unknown error",
     fatal: data.fatal || false,
-    url: data.url,
+    // hls.js puts the request URL in a different place per error type:
+    // playlist errors set data.url, while fragment and key load errors set
+    // data.url not at all and carry it on data.frag.url and data.response.url.
+    // Reading only data.url dropped the failing segment from every diagnostic
+    // an origin outage produces - which is the case the diagnostics exist for.
+    url: data.url ?? frag?.url ?? response?.url ?? context?.url,
     reason: data.reason,
     response: data.response
   };
 }
+function audioTrackId(index) {
+  return `audio-${index}`;
+}
+function audioTrackIndex(id) {
+  if (!id) return -1;
+  const match = /^audio-(0|[1-9]\d*)$/.exec(id);
+  return match ? Number.parseInt(match[1], 10) : -1;
+}
+function formatAudioTrack(track, index, active) {
+  return {
+    id: audioTrackId(index),
+    // A manifest may declare neither NAME nor LANGUAGE; a numbered fallback
+    // still gives the viewer something selectable rather than a blank row.
+    label: track.name || track.lang || `Audio ${index + 1}`,
+    language: track.lang,
+    active
+  };
+}
 function setupHlsEventHandlers(hls, api, callbacks) {
   const handlers = [];
   const addHandler = (event, handler) => {
@@ -150,6 +168,24 @@ function setupHlsEventHandlers(hls, api, callbacks) {
     });
     callbacks.onLevelSwitched?.(data.level);
   });
+  const publishAudioTracks = (tracks, activeIndex) => {
+    const audioTracks = tracks.map(
+      (track, index) => formatAudioTrack(track, index, index === activeIndex)
+    );
+    api.setState("audioTracks", audioTracks);
+    api.setState("currentAudioTrack", audioTracks[activeIndex] ?? null);
+  };
+  addHandler("hlsAudioTracksUpdated", (_event, data) => {
+    const tracks = data.audioTracks ?? [];
+    api.logger.debug("HLS audio tracks updated", { tracks: tracks.length });
+    publishAudioTracks(tracks, hls.audioTrack);
+    callbacks.onAudioTracksUpdated?.(tracks);
+  });
+  addHandler("hlsAudioTrackSwitched", (_event, data) => {
+    api.logger.debug("HLS audio track switched", { id: data.id });
+    publishAudioTracks(hls.audioTracks ?? [], data.id);
+    callbacks.onAudioTrackSwitched?.(data.id);
+  });
   let lastBandwidthUpdate = 0;
   addHandler("hlsFragLoaded", () => {
     const now = Date.now();
@@ -170,16 +206,15 @@ function setupHlsEventHandlers(hls, api, callbacks) {
     if (data.details?.live !== void 0) {
       api.setState("live", data.details.live);
       if (data.details.live) {
+        const details = data.details;
+        const start = details.fragmentStart ?? (details.fragments?.[0]?.start ?? 0);
+        const end = details.edge ?? details.totalduration ?? 0;
+        api.setState("seekableRange", { start, end });
         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));
+        if (video) {
+          const latency = Math.max(0, end - video.currentTime);
+          api.setState("liveLatency", latency);
+          api.setState("liveEdge", latency < (details.targetduration ?? 3) * 3);
         }
       }
       callbacks.onLiveUpdate?.();
@@ -197,14 +232,16 @@ function setupHlsEventHandlers(hls, api, callbacks) {
       api.logger.error(`HLS fatal error: ${error.details} (type=${error.type})`, {
         type: error.type,
         details: error.details,
-        url: error.url
+        status: error.response?.code,
+        url: sanitizeUrl(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
+        status: error.response?.code,
+        url: sanitizeUrl(error.url)
       });
     }
     callbacks.onError?.(error);
@@ -214,6 +251,8 @@ function setupHlsEventHandlers(hls, api, callbacks) {
       hls.off(event, handler);
     }
     handlers.length = 0;
+    api.setState("audioTracks", []);
+    api.setState("currentAudioTrack", null);
   };
 }
 function setupVideoEventHandlers(video, api) {
@@ -253,19 +292,27 @@ function setupVideoEventHandlers(video, api) {
   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));
+    if (video.seekable && video.seekable.length > 0) {
+      if (api.getState("live") || !Number.isFinite(video.duration)) {
+        const start = video.seekable.start(0);
+        const end = video.seekable.end(video.seekable.length - 1);
+        api.setState("seekableRange", { start, end });
+        const latency = Math.max(0, end - video.currentTime);
+        api.setState("liveEdge", latency < 10);
+        api.setState("liveLatency", latency);
+      }
     }
   });
   addHandler("durationchange", () => {
-    api.setState("duration", video.duration || 0);
-    api.emit("media:loadedmetadata", { duration: video.duration || 0 });
+    const rawDuration = video.duration;
+    const isLive = !Number.isFinite(rawDuration) || rawDuration === Infinity;
+    if (isLive) {
+      api.setState("live", true);
+      api.setState("duration", 0);
+    } else {
+      api.setState("duration", rawDuration || 0);
+    }
+    api.emit("media:loadedmetadata", { duration: api.getState("duration") });
   });
   addHandler("waiting", () => {
     api.setState("waiting", true);
@@ -401,7 +448,7 @@ function createValidatingPlaylistLoader(Hls) {
 }
 
 // src/version.ts
-var PKG_VERSION = true ? "1.8.1" : "0.0.0-dev";
+var PKG_VERSION = true ? "1.10.0" : "0.0.0-dev";
 
 // src/create-hls-plugin.ts
 var DEFAULT_CONFIG = {
@@ -461,6 +508,11 @@ function createHLSPluginWith(loader, variant, config) {
   let onlineListener = null;
   let reconnectTriggerError = null;
   let reconnectExhausted = false;
+  let isReconnecting = false;
+  let isLiveClassified = false;
+  let stallWatchdogTimer = null;
+  let lastStallCheckTime = 0;
+  let lastStallCheckPosition = 0;
   const applyPoster = () => {
     if (!video) return;
     video.poster = api?.getState("poster") || "";
@@ -492,6 +544,10 @@ function createHLSPluginWith(loader, variant, config) {
       clearTimeout(retryTimeout);
       retryTimeout = null;
     }
+    if (stallWatchdogTimer) {
+      clearTimeout(stallWatchdogTimer);
+      stallWatchdogTimer = null;
+    }
     if (hls) {
       hls.destroy();
       hls = null;
@@ -603,20 +659,20 @@ function createHLSPluginWith(loader, variant, config) {
   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) {
+      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 fatal errors (${errorCount} in ${ERROR_WINDOW_MS}ms), giving up`);
+        emitFatalError(error, true);
+        teardownPipeline(new Error(error.details));
+        return true;
+      }
       api?.logger.error("Fatal HLS error", { type: error.type, details: error.details });
       switch (error.type) {
         case "network": {
@@ -895,9 +951,15 @@ function createHLSPluginWith(loader, variant, config) {
           if (resolved || session !== loadSession) return;
           resolved = true;
           releaseAbort();
-          api?.logger.error(`HLS load timed out after ${timeout_ms}ms`, { src });
+          api?.logger.error(`HLS load timed out after ${timeout_ms}ms`, { src: sanitizeUrl(src) });
+          const timeoutError = {
+            type: "network",
+            details: "Video took too long to load (network timeout)",
+            fatal: true
+          };
+          emitFatalError(timeoutError, true);
           teardownPipeline();
-          reject(new Error("Video took too long to load (network timeout)"));
+          reject(new Error(timeoutError.details));
         }, timeout_ms);
       }
       hls.attachMedia(videoEl);
@@ -914,6 +976,51 @@ function createHLSPluginWith(loader, variant, config) {
     reconnectResumePosition = 0;
     reconnectTriggerError = null;
     reconnectExhausted = false;
+    isReconnecting = false;
+  };
+  const startStallWatchdog = () => {
+    if (!video || stallWatchdogTimer) return;
+    lastStallCheckTime = Date.now();
+    lastStallCheckPosition = video.currentTime;
+    const levelTargetDuration = hls?.targetDuration ?? hls?.levels?.[hls?.currentLevel]?.details?.targetduration ?? 0;
+    const targetDuration = Math.max(15, 4 * (levelTargetDuration || 0) || 15);
+    const checkInterval = Math.min(targetDuration, 3e4);
+    const check = () => {
+      if (!video || !api) return;
+      const isPlaying = api.getState("playing");
+      const isSeeking = api.getState("seeking");
+      if (!isPlaying || isSeeking) {
+        stallWatchdogTimer = setTimeout(check, checkInterval);
+        return;
+      }
+      const elapsed = Date.now() - lastStallCheckTime;
+      const positionDelta = video.currentTime - lastStallCheckPosition;
+      if (positionDelta > 0.5) {
+        lastStallCheckTime = Date.now();
+        lastStallCheckPosition = video.currentTime;
+      } else if (elapsed > targetDuration * 1e3) {
+        api.logger.warn("Playback stall detected \u2014 no timeupdate progress", {
+          elapsed: Math.round(elapsed),
+          currentTime: video.currentTime,
+          targetDuration: Math.round(targetDuration)
+        });
+        const stallError = {
+          type: "network",
+          details: "Playback stalled \u2014 no data received",
+          fatal: true
+        };
+        maybeScheduleReconnect(stallError);
+        return;
+      }
+      stallWatchdogTimer = setTimeout(check, checkInterval);
+    };
+    stallWatchdogTimer = setTimeout(check, checkInterval);
+  };
+  const stopStallWatchdog = () => {
+    if (stallWatchdogTimer) {
+      clearTimeout(stallWatchdogTimer);
+      stallWatchdogTimer = null;
+    }
   };
   const emitReconnectExhausted = (elapsedMs, windowMs) => {
     if (reconnectExhausted) return;
@@ -939,17 +1046,30 @@ function createHLSPluginWith(loader, variant, config) {
   const scheduleReconnectAttempt = () => {
     if (reconnectExhausted) return;
     if (reconnectTimer) return;
-    const window_ms = mergedConfig.reconnectWindowMs ?? 3e5;
+    const isLive = (api?.getState("live") ?? false) && isLiveClassified;
+    const configWindowMs = mergedConfig.reconnectWindowMs ?? 3e5;
+    const window_ms = isLive ? Infinity : configWindowMs;
     const elapsed_ms = Date.now() - reconnectWindowStart;
     if (elapsed_ms > window_ms) {
       api?.logger.warn(`Auto-reconnect window exhausted after ${reconnectAttempts} attempts`);
       emitReconnectExhausted(elapsed_ms, window_ms);
       return;
     }
+    const LONG_OUTAGE_MS = 6e5;
+    if (isLive && elapsed_ms > LONG_OUTAGE_MS) {
+      api?.emit("error:reconnecting", {
+        attempt: reconnectAttempts + 1,
+        delayMs: 0,
+        elapsedMs: elapsed_ms,
+        windowMs: window_ms,
+        longOutage: true
+      });
+    }
     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));
+    const isAtCap = backoff >= max_delay;
+    const delay = isLive && isAtCap ? 3e4 : 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,
@@ -964,7 +1084,9 @@ function createHLSPluginWith(loader, variant, config) {
   };
   const maybeScheduleReconnect = (error) => {
     if (mergedConfig.autoReconnect === false) return;
-    if (!hasPlayedContent || !currentSrc) return;
+    if (!currentSrc) return;
+    const isLive = (api?.getState("live") ?? false) && isLiveClassified;
+    if (!isLive && !hasPlayedContent) return;
     if (error.type !== "network" && error.type !== "media") return;
     if (reconnectWindowStart === 0) {
       reconnectWindowStart = Date.now();
@@ -975,13 +1097,14 @@ function createHLSPluginWith(loader, variant, config) {
   };
   const attemptReconnect = async () => {
     if (!api || !currentSrc) return;
+    isReconnecting = true;
     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 });
+    api.logger.info(`Auto-reconnect attempt ${reconnectAttempts}`, { src: sanitizeUrl(saved_src) });
     try {
       teardownPipeline(new Error("HLS load cancelled: reconnecting"));
       networkRetryCount = 0;
@@ -1007,14 +1130,21 @@ function createHLSPluginWith(loader, variant, config) {
       });
       api.logger.info("Auto-reconnect succeeded");
       cancelReconnect();
-      try {
-        await video?.play();
-      } catch {
+      const wasPaused = api.getState("paused");
+      if (!wasPaused) {
+        try {
+          await video?.play();
+        } catch {
+        }
+      } else {
+        api.logger.info("Stream reconnected while paused; maintaining pause at live edge");
       }
     } catch {
       if (session !== loadSession) return;
       api?.logger.warn(`Auto-reconnect attempt ${reconnectAttempts} failed`);
       scheduleReconnectAttempt();
+    } finally {
+      isReconnecting = false;
     }
   };
   const plugin = {
@@ -1048,6 +1178,7 @@ function createHLSPluginWith(loader, variant, config) {
       });
       const unsubSeek = api.on("playback:seeking", ({ time }) => {
         if (!video) return;
+        if (!Number.isFinite(time)) return;
         const clampedTime = Math.max(0, Math.min(time, video.duration || 0));
         video.currentTime = clampedTime;
       });
@@ -1100,20 +1231,43 @@ function createHLSPluginWith(loader, variant, config) {
           }
         }
       });
+      const unsubAudioTrack = api.on("track:audio", ({ trackId }) => {
+        if (!hls || isNative) {
+          api?.logger.warn("Audio track selection not available");
+          return;
+        }
+        const index = audioTrackIndex(trackId);
+        const tracks = hls.audioTracks ?? [];
+        if (index < 0 || index >= tracks.length) {
+          api?.logger.warn("Ignoring unknown audio track selection", { trackId });
+          return;
+        }
+        hls.audioTrack = index;
+        api?.logger.debug(`Audio: queued switch to track ${index}`);
+      });
       if (typeof window !== "undefined") {
         onlineListener = () => {
+          const hasActiveReconnect = reconnectTimer !== null || reconnectWindowStart > 0 || isReconnecting || reconnectAttempts > 0 && !reconnectExhausted;
+          if (!hasActiveReconnect) {
+            return;
+          }
           if (reconnectTimer) {
             api?.logger.info("Browser back online, reconnecting immediately");
             clearTimeout(reconnectTimer);
             reconnectTimer = null;
-            void attemptReconnect();
           }
+          void attemptReconnect();
         };
         window.addEventListener("online", onlineListener);
       }
       const unsubPoster = api.subscribeToState((event) => {
         if (event.key === "poster") applyPoster();
       });
+      const unsubLive = api.subscribeToState((event) => {
+        if (event.key === "live") {
+          isLiveClassified = true;
+        }
+      });
       api.onDestroy(() => {
         unsubPlay();
         unsubPause();
@@ -1122,8 +1276,20 @@ function createHLSPluginWith(loader, variant, config) {
         unsubMute();
         unsubRate();
         unsubQuality();
+        unsubAudioTrack();
         unsubPoster();
+        unsubLive();
       });
+      const unsubPlayState = api.subscribeToState((event) => {
+        if (event.key === "playing") {
+          if (event.value) {
+            startStallWatchdog();
+          } else {
+            stopStallWatchdog();
+          }
+        }
+      });
+      api.onDestroy(unsubPlayState);
     },
     async destroy() {
       api?.logger.info(`HLS plugin${variant.logSuffix} destroying`);
@@ -1142,10 +1308,12 @@ function createHLSPluginWith(loader, variant, config) {
     },
     async loadSource(src) {
       if (!api) throw new Error("Plugin not initialized");
-      api.logger.info(`Loading HLS source${variant.logSuffix}`, { src });
+      api.logger.info(`Loading HLS source${variant.logSuffix}`, { src: sanitizeUrl(src) });
       const session = ++loadSession;
       cancelReconnect();
       hasPlayedContent = false;
+      isLiveClassified = false;
+      api.setState("live", false);
       cleanup(new Error("HLS load cancelled: superseded by a new load"));
       currentSrc = src;
       applyPoster();
@@ -1195,14 +1363,24 @@ function createHLSPluginWith(loader, variant, config) {
       return isNative;
     },
     getLiveInfo() {
-      if (isNative || !hls) return null;
       const live = api?.getState("live") || false;
       if (!live) return null;
+      if (isNative) {
+        return {
+          isLive: true,
+          latency: 0,
+          targetLatency: 3,
+          drift: 0,
+          liveSyncPosition: video?.seekable?.length ? Math.max(0, video.seekable.end(video.seekable.length - 1) - 3) : void 0
+        };
+      }
+      if (!hls) return null;
       return {
         isLive: true,
         latency: hls.latency || 0,
         targetLatency: hls.targetLatency || 3,
-        drift: hls.drift || 0
+        drift: hls.drift || 0,
+        liveSyncPosition: hls.liveSyncPosition ?? (video?.seekable?.length ? Math.max(0, video.seekable.end(video.seekable.length - 1) - 3) : void 0)
       };
     },
     /**
@@ -1228,7 +1406,9 @@ function createHLSPluginWith(loader, variant, config) {
       const currentTime = video?.currentTime || 0;
       const savedSrc = currentSrc;
       const session = ++loadSession;
+      cancelReconnect();
       cleanup(new Error("HLS load cancelled: switching to native HLS"));
+      currentSrc = savedSrc;
       await loadNative(savedSrc);
       if (session !== loadSession) return;
       if (video && currentTime > 0) {
@@ -1265,7 +1445,9 @@ function createHLSPluginWith(loader, variant, config) {
       const currentTime = video?.currentTime || 0;
       const savedSrc = currentSrc;
       const session = ++loadSession;
+      cancelReconnect();
       cleanup(new Error("HLS load cancelled: switching to hls.js"));
+      currentSrc = savedSrc;
       await loadWithHlsJs(savedSrc);
       if (session !== loadSession) return;
       if (video && currentTime > 0) {