[playback] Add HLS support and stop blaming stale MediaErrors

bitvid attached every hosted source with `videoEl.src = url`, which only plays
HLS on Safari-family browsers. Firefox 146 fails with MEDIA_ERR_SRC_NOT_SUPPORTED
(canPlayType returns ""), so every .m3u8 note -- e.g. anything published by
nostube/slidestr -- was unplayable there and the URL-health badge showed
"offline". Chrome/Brave 149 happen to play HLS natively, which is why this
looked browser-specific.

Vendor hls.js (npm run build:hls) and route HLS sources through it:

- js/services/hlsPlayback.js owns detection, engine choice and the hls.js
  lifecycle. Engine choice keys off MediaSource, NOT canPlayType: Chrome
  returns "maybe" for every HLS type, so a native-first branch would hang.
  Native is used only when MSE is genuinely unavailable.
- The bundle is the FULL build, not hls.js/light -- light drops the alternate
  audio stream controller and real ladders demux audio into an EXT-X-MEDIA
  group. It is lazy-imported only when a .m3u8 is encountered, so ordinary
  MP4/WebTorrent playback never pays the ~500KB.
- modalCoordinator tears the instance down first; clearing `src` alone leaves
  the transmuxing worker and segment fetches running after the modal closes.
- urlHealthController probes HLS by fetching the playlist for #EXTM3U. The old
  bare-<video> probe could not load it and on Chrome emitted no events at all,
  burning the full timeout on every HLS card.
- HLS_PLAYBACK_START_TIMEOUT widens the 3s start window, which fired
  mid-startup: the bundle, master playlist, variant playlist, init segment and
  first media segment are four-plus serial round trips.

Also fixes two bugs found while verifying this:

- A stale MediaError was reported as the current failure. Teardown clears `src`
  and calls load(), leaving MEDIA_ERR_SRC_NOT_SUPPORTED ("Empty src attribute")
  on the element; a later watchdog fallback rendered that as "Hosted playback
  failed: source not supported or blocked." over a stream that was playing
  fine. Only a MediaError produced by the current attempt is surfaced now.
  Sources are also bound before the watchdogs are armed, so hls.js's own
  attachMedia() src swap cannot read as a playback failure.
- `audio/x-mpegurl` is a legacy alias for an HLS playlist of any kind, not an
  audio-only assertion. isAudioOnlyVideoObject misfiled HLS video ladders
  published with it as podcasts and dropped them from every video feed.

Verified end-to-end in Chromium, Chrome 149, Brave 149 and Firefox 146 against
a live HLS stream: Firefox goes from "No playable source found." to playing.
Rollback: stop calling attachHlsSource() and the previous `src` assignment
returns; see docs/playback-fallback.md.

Co-Authored-By: Claude Opus 5 (1M context) <[email protected]>

docs/playback-fallback.md

@@ -94,8 +94,133 @@ sequenceDiagram
   end
 ```
 
+## HLS (.m3u8) sources
+
+Hosted sources whose path ends in `.m3u8` are HLS playlists and cannot be
+assigned to `videoEl.src` on every browser. `js/services/hlsPlayback.js` owns
+the decision and the hls.js lifecycle.
+
+**Engine choice.** hls.js (MSE) wins whenever `MediaSource` can back it; native
+playback is used only when MSE is unavailable. Do NOT branch on `canPlayType`
+alone — measured behavior differs sharply:
+
+| Browser | `canPlayType("application/vnd.apple.mpegurl")` | bare `<video src=…m3u8>` |
+| --- | --- | --- |
+| Firefox 146 | `""` | `MEDIA_ERR_SRC_NOT_SUPPORTED` (code 4) |
+| Chrome 149 | `"maybe"` | plays natively |
+
+Before this existed, Firefox reported `No playable source found.` for every HLS
+note (and the URL-health badge showed `❌ CDN`), while Chrome happened to work.
+
+**Wiring.**
+
+- `js/services/playbackService.js` — `attemptHostedPlayback` routes HLS
+  candidates through `attachHlsSource()`; `resetVideoElement()` calls
+  `detachHls()` before clearing `src`.
+- `js/app/modalCoordinator.js` — `teardownVideoElement` calls `detachHls()`
+  first; otherwise the transmuxer worker and segment fetches outlive the modal.
+- `js/ui/urlHealthController.js` — probes HLS by fetching the playlist and
+  checking for `#EXTM3U` instead of using a bare `<video>` (which cannot load it
+  and, on Chrome, emits no events at all — burning the whole probe timeout).
+- `HLS_PLAYBACK_START_TIMEOUT` (`js/constants.js`) widens the 3s start window,
+  which fires mid-startup for HLS: the bundle, master playlist, variant
+  playlist, init segment and first media segment are serial round trips.
+
+**Vendoring.** `npm run build:hls` regenerates `vendor/hls.bundle.min.js` from
+the pinned devDependency. It is the FULL hls.js build, not `hls.js/light` —
+light drops the alternate-audio stream controller, and real ladders (e.g.
+nostube/slidestr) demux audio into its own `EXT-X-MEDIA` rendition group. The
+bundle is lazy-imported only when an HLS URL is encountered, so ordinary
+MP4/WebTorrent playback never pays for it.
+
+**Rollback.** Stop calling `attachHlsSource()` from `playbackService.js` /
+`playbackCoordinator.js` and the previous `videoEl.src = url` behavior returns;
+revert the `urlHealthController.js` branch to restore the old element probe.
+Nothing else imports `hlsPlayback.js`, and the vendored bundle is inert once
+unreferenced.
+
 ## Implementation notes
 
 - The playback session is responsible for cleanup and emits events (`status`, `sourcechange`, `error`, `finished`) that `bitvidApp` listens to for UI updates.
 - `bitvidApp.playVideoWithFallback` keeps the current video card and modal state in sync with the normalized magnet values so copy actions and stats reflect the actual playback payload.
 
+
+## Link previews (NIP-92 imeta + per-video OpenGraph)
+
+Two independent surfaces make a shared bitvid video render richly.
+
+**1. Inside nostr clients — `js/nostrEventSchemas.js`.**
+`buildShareEvent()` appends a NIP-92 `imeta` entry describing the thumbnail URL
+that the note body ends with. Many clients only inline such a URL when an imeta
+entry backs it; without it the viewer sees a bare link. The media type is
+inferred from the extension (`inferImageMimeTypeFromUrl`, `js/utils/mime.js`)
+and OMITTED when unknown — a wrong `m` is worse than a missing one, because
+clients use it to decide whether to render inline at all. Extensionless
+Blossom-style URLs therefore ship `url` + `alt` only.
+
+**2. Everywhere else — `api/og.js` + `api/_lib/ogRenderer.mjs`.**
+`index.html` carries one set of site-wide OG tags, so every `/?v=<nevent>` link
+previewed as the same generic card. Crawlers don't run JS, so this is rendered
+server-side on demand.
+
+- **Nothing is pre-generated or stored.** One stateless function serves all
+  videos; the video is a query param, not a path. `dist/` is byte-identical
+  with or without it. The only caching is the CDN edge (`s-maxage=300`) plus a
+  per-container in-memory memo of the admin lists.
+- **Never load-bearing.** Only crawler user-agents are rewritten to it
+  (`vercel.json`), humans get the untouched SPA, and a static/nsite deploy with
+  no functions keeps working — it just serves the site-wide card. Rollback is
+  deleting the `rewrites` block.
+- **Player card, not just an image.** It emits `twitter:player` / `og:video:url`
+  pointing at `embed.html?pointer=<nevent>`, so a shared link plays inline on
+  Twitter/Discord/Telegram. `frame-ancestors *` (`_headers`) already permits it.
+- **Fails closed.** A crawler never authenticates, so anything emitted is public
+  forever in third-party caches. `isPubliclyShareable()` requires an
+  affirmatively public video: `deleted`, `isPrivate`, `isNsfw`/`content-warning`,
+  blacklisted authors, and — while whitelist mode is on — an unavailable or
+  empty whitelist all fall back to the generic card.
+- **Both event shapes.** `parseVideoEvent()` reads bitvid's kind-30078 v3 JSON
+  AND the NIP-71 tag shape (kinds 21/22/34235/34236) that nostube/slidestr
+  publish, where the title lives in a `title` tag and the thumbnail in an
+  `imeta image` entry.
+- **Timeouts.** A cold pool's first relay read measured ~3s, so the budget is
+  4s (Twitter allows ~5s); warm containers answer in <600ms because the admin
+  lists are memoized for 5 minutes.
+
+Config is imported from `js/config.js`, `js/nostr/toolkit.js` and
+`js/nostrEventSchemas.js` rather than duplicated, and `tests/og-renderer.test.mjs`
+fails if that regresses to hardcoded literals.
+
+### Quoting the NIP-71 mirror
+
+When a video has a NIP-71 mirror, the share note embeds `nostr:naddr1…` for it.
+Nostr clients render that as a **native video quote card** — the closest thing
+to a rich preview that does not depend on any client fetching OpenGraph tags
+(most never do; the OG endpoint above mainly serves Twitter/Discord/Telegram).
+
+The mirror is addressable (kind 34235/34236, author = video pubkey,
+`d` = `videoRootId`), so `js/nostr/mirrorPointer.js` derives the coordinate with
+no relay lookup, and the pointer survives the author editing the video — a plain
+`nevent` would rot on the next replace.
+
+Rules that keep this from looking worse than the plain link:
+
+- **Verify before pointing.** `ShareNostrController.resolveMirrorPointer()`
+  confirms the mirror exists via `nip71MirrorService.findMirror()` before
+  embedding anything. A pointer to a missing event renders as a broken/empty
+  quote box. Every failure path — service disabled, lookup throws, lookup times
+  out (2.5s), no `videoRootId` — falls back to the thumbnail-URL note.
+- **Use the observed kind.** `resolveMirrorKind()` prefers the kinds actually
+  seen on relays over the portrait heuristic. Only when nothing was observed does
+  it fall back to the SAME rule the mirror builder uses (`nip71Mirror.js`:
+  `hasDims && height > width`), so a derived pointer matches what would be
+  published rather than guessing independently.
+- **Never emit both images.** While quoting, the raw thumbnail URL is dropped
+  from the body and the `imeta` tag is skipped — the quote card already shows the
+  thumbnail, and keeping both rendered the same image twice.
+- An `a` tag (`kind:pubkey:d`) links the note to the quoted coordinate for
+  quote-aware clients and indexers.
+
+Known limitation: a client rendering the quote card still needs to play the
+video, and mirrors whose `imeta url` is an `.m3u8` hit the same HLS wall bitvid
+did — the thumbnail and title render, playback depends on the client.

js/app/modalCoordinator.js

@@ -3,11 +3,13 @@
 /**
  * Modal open/close lifecycle and controller routing.
  *
- * All module-level dependencies are injected from the Application
+ * Stateful collaborators (clients, services, app state) are injected from the
- * composition root rather than imported at module scope.
+ * Application composition root rather than imported at module scope. Pure,
+ * stateless helper modules are imported directly, as in the other coordinators.
  *
  * Methods use `this` which is bound to the Application instance.
  */
+import { detachHls } from "../services/hlsPlayback.js";
 
 /**
  * @param {object} deps - Injected dependencies.
@@ -562,6 +564,11 @@ export function createModalCoordinator(deps) {
         `[teardownVideoElement] Resetting video (replaceNode=${replaceNode}) readyState=${videoElement.readyState} networkState=${videoElement.networkState} src=${describeSource()}`
       );
 
+      // Destroy any hls.js instance FIRST. It owns a MediaSource, a transmuxing
+      // worker and in-flight segment fetches; clearing `src` without destroying
+      // it leaves those running (and downloading) after the modal is closed.
+      safe(() => detachHls(videoElement));
+
       safe(() => videoElement.pause());
 
       safe(() => {

js/app/playbackCoordinator.js

@@ -3,11 +3,17 @@
 /**
  * URL-first + magnet fallback playback pipeline.
  *
- * All module-level dependencies are injected from the Application
+ * Stateful collaborators (clients, services, app state) are injected from the
- * composition root rather than imported at module scope.
+ * Application composition root rather than imported at module scope. Pure,
+ * stateless helper modules are imported directly, as in the other coordinators.
  *
  * Methods use `this` which is bound to the Application instance.
  */
+import {
+  attachHlsSource,
+  detachHls,
+  isHlsUrl,
+} from "../services/hlsPlayback.js";
 
 /**
  * Normalize a deep-link / caller "force this playback source" value to the
@@ -355,7 +361,23 @@ export function createPlaybackCoordinator(deps) {
         return false;
       }
 
-      target.src = sanitizedUrl;
+      // HLS playlists cannot be assigned to `src` outside Safari; route them
+      // through hls.js/MSE (see js/services/hlsPlayback.js).
+      if (isHlsUrl(sanitizedUrl)) {
+        const handle = await attachHlsSource(target, sanitizedUrl, {
+          log: (...args) => devLogger.log(...args),
+        });
+        if (!handle) {
+          devLogger.warn(
+            "[playHttp] HLS source could not be attached:",
+            sanitizedUrl
+          );
+          return false;
+        }
+      } else {
+        detachHls(target);
+        target.src = sanitizedUrl;
+      }
 
       try {
         await target.play();

js/constants.js

@@ -189,6 +189,17 @@ export const DEFAULT_TRUSTED_SPAM_HIDE_THRESHOLD =
 export const DEFAULT_TRUST_SEED_NPUBS = SANITIZED_DEFAULT_TRUST_SEED_NPUBS;
 export const PLAYBACK_START_TIMEOUT = SANITIZED_DEFAULT_PLAYBACK_START_TIMEOUT;
 
+// HLS needs a bigger start window than a progressive MP4. Before the first
+// frame can render, hls.js must lazy-load its (vendored) bundle, fetch the
+// master playlist, fetch the chosen variant playlist, then fetch the init
+// segment and the first media segment — four or more serial round trips versus
+// the single ranged GET a plain MP4 needs. The 3s default fires mid-startup and
+// reports a perfectly healthy stream as "No playable source found."
+export const HLS_PLAYBACK_START_TIMEOUT = Math.max(
+  SANITIZED_DEFAULT_PLAYBACK_START_TIMEOUT,
+  15000
+);
+
 const DEFAULT_FLAGS = Object.freeze({
   URL_FIRST_ENABLED: DEFAULT_PLAYBACK_SOURCE !== "torrent", // try URL before magnet in the player
   FEATURE_WATCH_HISTORY_V2: true,

js/nostr/nip71.js

@@ -1465,6 +1465,17 @@ function inferMimeTypeFromUrl(url) {
 // (kind 30078) can carry `imeta` variants with an `m <mime>` field just like
 // NIP-71 events; a podcast/music note advertises `m audio/*`. Mirrors the
 // video/audio split in nip71IngestAdapter.js so the native path stays consistent.
+// HLS playlist MIME types. `audio/mpegurl` / `audio/x-mpegurl` are LEGACY
+// aliases for an HLS playlist of any kind — they do NOT assert audio-only
+// content, and a publisher using one for a video ladder would otherwise be
+// misfiled as a podcast and dropped from the video feeds by
+// isAudioOnlyVideoObject(). A playlist is a container, so it votes for neither
+// side and we let the URL/`imeta m video/*` signals decide.
+// Kept inline (not imported from js/services/hlsPlayback.js) so this parser
+// stays free of any DOM/logger dependency — it also runs inside workers.
+const HLS_PLAYLIST_MIME_PATTERN =
+  /^(?:application|audio|video)\/(?:x-|vnd\.apple\.)?mpegurl$/i;
+
 function detectImetaMediaKinds(tags = []) {
   let hasVideo = false;
   let hasAudio = false;
@@ -1482,6 +1493,9 @@ function detectImetaMediaKinds(tags = []) {
         continue;
       }
       const mime = trimmed.replace(/^m\s+/i, "").trim().toLowerCase();
+      if (HLS_PLAYLIST_MIME_PATTERN.test(mime.split(";")[0].trim())) {
+        continue;
+      }
       if (mime.startsWith("video/")) {
         hasVideo = true;
       } else if (mime.startsWith("audio/")) {

js/services/hlsPlayback.js

@@ -0,0 +1,418 @@
+// HLS (.m3u8) playback support.
+//
+// bitvid historically attached every hosted source with `videoEl.src = url`.
+// That works for progressive MP4/WebM but NOT for HLS: only Safari/iOS can play
+// an .m3u8 natively, so on Chrome/Firefox the element fails immediately with
+// MEDIA_ERR_SRC_NOT_SUPPORTED ("Hosted playback failed: source not supported or
+// blocked."). Nostr clients that publish bitvid's v3 schema with HLS ladders
+// (e.g. nostube/slidestr) were therefore unplayable everywhere but Safari.
+//
+// This module owns the decision + the hls.js lifecycle. hls.js is vendored
+// (scripts/build-hls.mjs) and lazy-imported ONLY when an HLS URL is actually
+// encountered, so the ~500KB bundle never touches a normal MP4/WebTorrent load.
+//
+// Rollback: stop calling attachHlsSource() from playbackService/playbackCoordinator
+// and the old `videoEl.src = url` behavior returns; nothing else imports this.
+import { devLogger } from "../utils/logger.js";
+
+// Vendored, pinned hls.js bundle (scripts/build-hls.mjs). Lazy-imported.
+const HLS_BUNDLE_URL = "../../vendor/hls.bundle.min.js";
+
+// Canonical + legacy HLS media types. Servers are wildly inconsistent here —
+// the slidestr CDN serves playlists as `text/plain` — so the URL extension is
+// the primary signal and the MIME type is only ever corroborating evidence.
+export const HLS_MIME_TYPES = Object.freeze([
+  "application/vnd.apple.mpegurl",
+  "application/x-mpegurl",
+  "audio/mpegurl",
+  "audio/x-mpegurl",
+  "application/mpegurl",
+  "vnd.apple.mpegurl",
+]);
+
+/**
+ * True when the URL's *path* ends in .m3u8. Query strings and fragments are
+ * ignored (signed CDN URLs routinely carry `?token=...`), and a bare .m3u8
+ * substring elsewhere in the URL must not match.
+ */
+export function isHlsUrl(url) {
+  const trimmed = typeof url === "string" ? url.trim() : "";
+  if (!trimmed) {
+    return false;
+  }
+  // Strip fragment then query, without `new URL()` — relative/odd inputs must
+  // not throw, and bitvid never runs URL parsers over user-supplied media
+  // strings (see the magnet rules in AGENTS.md).
+  const path = trimmed.split("#")[0].split("?")[0];
+  return /\.m3u8$/i.test(path);
+}
+
+/** True when a declared MIME type is one of the HLS playlist types. */
+export function isHlsMimeType(mimeType) {
+  const normalized =
+    typeof mimeType === "string" ? mimeType.trim().toLowerCase() : "";
+  if (!normalized) {
+    return false;
+  }
+  const bare = normalized.split(";")[0].trim();
+  return HLS_MIME_TYPES.includes(bare);
+}
+
+/** Combined check used by callers that may have an imeta `m` hint. */
+export function isHlsSource({ url = "", mimeType = "" } = {}) {
+  return isHlsUrl(url) || isHlsMimeType(mimeType);
+}
+
+/**
+ * Whether `canPlayType` claims native HLS support.
+ *
+ * DO NOT branch on this alone. Chrome LIES here: Chrome 149 returns "maybe" for
+ * every HLS MIME type, but assigning an .m3u8 to `video.src` then fires NO
+ * events at all — not `loadeddata`, not even `error`. The element simply hangs,
+ * which is exactly the silent "nothing happens" failure this module exists to
+ * fix (and why the URL-health probe timed out instead of erroring, leaving the
+ * card visible but unplayable). Use prefersNativeHls() to make decisions.
+ */
+export function supportsNativeHls(videoElement) {
+  const el =
+    videoElement ||
+    (typeof document !== "undefined" ? document.createElement("video") : null);
+  if (!el || typeof el.canPlayType !== "function") {
+    return false;
+  }
+  for (const type of HLS_MIME_TYPES) {
+    try {
+      if (el.canPlayType(type)) {
+        return true;
+      }
+    } catch (err) {
+      // canPlayType must never throw, but never let a probe kill playback.
+    }
+  }
+  return false;
+}
+
+// A representative baseline codec: every MSE implementation that can run hls.js
+// supports fragmented-MP4 H.264. This mirrors what Hls.isSupported() checks, so
+// we can predict the engine choice WITHOUT paying to load the bundle (the
+// URL-health probe needs the answer for every visible card).
+const MSE_PROBE_TYPE = 'video/mp4; codecs="avc1.42E01E"';
+
+/** True when Media Source Extensions can back hls.js in this browser. */
+export function supportsMse() {
+  const MediaSourceImpl =
+    (typeof globalThis !== "undefined" &&
+      (globalThis.MediaSource ||
+        globalThis.ManagedMediaSource ||
+        globalThis.WebKitMediaSource)) ||
+    null;
+  if (!MediaSourceImpl || typeof MediaSourceImpl.isTypeSupported !== "function") {
+    return false;
+  }
+  try {
+    return MediaSourceImpl.isTypeSupported(MSE_PROBE_TYPE);
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Whether to use the browser's own HLS implementation instead of hls.js.
+ *
+ * Only when MSE is genuinely unavailable (older iOS Safari, some TV browsers).
+ * hls.js is the default everywhere else — this is hls.js's own recommended
+ * ordering, and on Chrome it is mandatory: see supportsNativeHls() for the
+ * canPlayType lie that makes a native-first branch hang forever.
+ */
+export function prefersNativeHls(videoElement) {
+  return !supportsMse() && supportsNativeHls(videoElement);
+}
+
+let hlsEnginePromise = null;
+
+/**
+ * Lazy-import the vendored hls.js bundle. Cached across calls (including the
+ * rejection case, deliberately reset so a transient network failure can retry).
+ */
+export async function loadHlsEngine() {
+  if (!hlsEnginePromise) {
+    hlsEnginePromise = import(HLS_BUNDLE_URL)
+      .then((mod) => mod?.default || mod?.Hls || null)
+      .catch((err) => {
+        hlsEnginePromise = null;
+        devLogger.warn("[hlsPlayback] Failed to load hls.js bundle:", err);
+        return null;
+      });
+  }
+  return hlsEnginePromise;
+}
+
+/** Test seam: drop the cached engine promise. */
+export function __resetHlsEngineCacheForTests() {
+  hlsEnginePromise = null;
+}
+
+// videoEl -> active hls.js instance. A WeakMap keeps teardown paths (which only
+// ever hold the element) from having to thread an extra handle around, and lets
+// a discarded element be collected without leaking the instance.
+const attachedInstances = new WeakMap();
+
+export function getAttachedHls(videoElement) {
+  return videoElement ? attachedInstances.get(videoElement) || null : null;
+}
+
+/**
+ * Tear down any hls.js instance bound to this element. Safe to call
+ * unconditionally on every reset path — it is a no-op for non-HLS playback.
+ */
+export function detachHls(videoElement) {
+  if (!videoElement) {
+    return false;
+  }
+  const hls = attachedInstances.get(videoElement);
+  if (!hls) {
+    return false;
+  }
+  attachedInstances.delete(videoElement);
+  try {
+    hls.destroy();
+  } catch (err) {
+    devLogger.warn("[hlsPlayback] hls.destroy() threw during detach:", err);
+  }
+  return true;
+}
+
+function describeHlsError(data) {
+  const type = data?.type || "unknown";
+  const details = data?.details || "unknown";
+  if (data?.type === "networkError") {
+    return "Hosted playback failed: the HLS stream could not be reached (network or CORS).";
+  }
+  if (data?.type === "mediaError") {
+    return "Hosted playback failed: this HLS stream uses a codec your browser cannot decode.";
+  }
+  return `Hosted playback failed: HLS error (${type}/${details}).`;
+}
+
+/**
+ * Attach `url` to `videoElement`, using native HLS where available and hls.js
+ * (MSE) otherwise.
+ *
+ * Resolves once the manifest is parsed — the meaningful "this is playable"
+ * signal for both the player and the URL-health probe. Callers are still
+ * responsible for calling play(); this only wires up the source.
+ *
+ * Returns null when HLS cannot be supported at all (no native support and MSE
+ * unavailable), so the caller can fall back to its normal `src` assignment and
+ * surface a real media error.
+ *
+ * `createEngine` is a test seam: it resolves the hls.js constructor and defaults
+ * to the lazy import of the vendored bundle. Tests inject a fake so the MSE
+ * branch can be specified without a real MediaSource.
+ *
+ * @returns {Promise<{mode: "native"|"mse", destroy: () => void}|null>}
+ */
+export async function attachHlsSource(
+  videoElement,
+  url,
+  {
+    onFatalError,
+    log = () => {},
+    manifestTimeoutMs = 15000,
+    createEngine = loadHlsEngine,
+  } = {}
+) {
+  if (!videoElement) {
+    return null;
+  }
+  const trimmed = typeof url === "string" ? url.trim() : "";
+  if (!trimmed) {
+    return null;
+  }
+
+  // Always clear a previous instance before rebinding — reusing the modal's
+  // <video> across videos is the norm in bitvid.
+  detachHls(videoElement);
+
+  const useNative = () => {
+    log("[hlsPlayback] Using native HLS playback.");
+    videoElement.src = trimmed;
+    return { mode: "native", destroy: () => {} };
+  };
+
+  // Native only when MSE genuinely cannot back hls.js. Never trust canPlayType
+  // on its own — Chrome claims HLS support and then hangs silently.
+  if (prefersNativeHls(videoElement)) {
+    return useNative();
+  }
+
+  const Hls = await createEngine();
+  if (!Hls || typeof Hls.isSupported !== "function" || !Hls.isSupported()) {
+    // Last resort: if the bundle failed to load but the browser claims native
+    // support, an attempt beats a guaranteed failure.
+    if (supportsNativeHls(videoElement)) {
+      log("[hlsPlayback] hls.js unavailable; falling back to native HLS.");
+      return useNative();
+    }
+    log("[hlsPlayback] hls.js unavailable/unsupported; cannot play HLS.");
+    return null;
+  }
+
+  const hls = new Hls({
+    enableWorker: true,
+    lowLatencyMode: false,
+    // Keep a bounded back-buffer so long VOD (this note is ~1h) does not grow
+    // the SourceBuffer without limit on low-memory devices.
+    backBufferLength: 90,
+  });
+
+  attachedInstances.set(videoElement, hls);
+
+  let settled = false;
+  let networkRetries = 0;
+  let mediaRecoveries = 0;
+
+  return new Promise((resolve) => {
+    let timeoutId = null;
+
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      resolve(value);
+    };
+
+    const fail = (message) => {
+      // Only tear down once we've given up; recoverable errors keep the
+      // instance alive so hls.js can heal itself.
+      detachHls(videoElement);
+      if (typeof onFatalError === "function") {
+        onFatalError(message);
+      }
+      finish(null);
+    };
+
+    if (Number.isFinite(manifestTimeoutMs) && manifestTimeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        if (settled) {
+          return;
+        }
+        log("[hlsPlayback] Manifest parse timed out.");
+        fail("Hosted playback failed: the HLS manifest did not load in time.");
+      }, manifestTimeoutMs);
+    }
+
+    hls.on(Hls.Events.MANIFEST_PARSED, (_event, data) => {
+      log(
+        `[hlsPlayback] Manifest parsed; ${data?.levels?.length ?? 0} playable level(s).`
+      );
+      // hls.js drops levels whose codecs MSE cannot decode (e.g. an HEVC
+      // rendition on Firefox). Zero survivors means nothing is playable.
+      if (Array.isArray(data?.levels) && data.levels.length === 0) {
+        fail(
+          "Hosted playback failed: no HLS rendition uses a codec your browser supports."
+        );
+        return;
+      }
+      finish({ mode: "mse", destroy: () => detachHls(videoElement) });
+    });
+
+    hls.on(Hls.Events.ERROR, (_event, data) => {
+      if (!data?.fatal) {
+        log(
+          `[hlsPlayback] Non-fatal HLS error (${data?.type}/${data?.details}); continuing.`
+        );
+        return;
+      }
+
+      log(`[hlsPlayback] Fatal HLS error (${data?.type}/${data?.details}).`);
+
+      if (data.type === Hls.ErrorTypes.NETWORK_ERROR && networkRetries < 2) {
+        networkRetries += 1;
+        log(`[hlsPlayback] Retrying load (attempt ${networkRetries}).`);
+        try {
+          hls.startLoad();
+          return;
+        } catch (err) {
+          log("[hlsPlayback] startLoad() threw during recovery.", err);
+        }
+      }
+
+      if (data.type === Hls.ErrorTypes.MEDIA_ERROR && mediaRecoveries < 2) {
+        mediaRecoveries += 1;
+        log(`[hlsPlayback] Recovering media error (attempt ${mediaRecoveries}).`);
+        try {
+          if (mediaRecoveries === 2 && typeof hls.swapAudioCodec === "function") {
+            hls.swapAudioCodec();
+          }
+          hls.recoverMediaError();
+          return;
+        } catch (err) {
+          log("[hlsPlayback] recoverMediaError() threw during recovery.", err);
+        }
+      }
+
+      fail(describeHlsError(data));
+    });
+
+    try {
+      hls.attachMedia(videoElement);
+      hls.loadSource(trimmed);
+    } catch (err) {
+      log("[hlsPlayback] attachMedia/loadSource threw:", err);
+      fail("Hosted playback failed: the HLS stream could not be attached.");
+    }
+  });
+}
+
+/**
+ * Cheap playability check for the URL-health badge that does NOT pull in hls.js.
+ *
+ * On MSE browsers hls.js fetches the playlist with XHR, so a CORS-readable
+ * `#EXTM3U` response is exactly the condition for playability — and a bare
+ * <video> probe (the old path) would report every HLS URL as dead. On Safari,
+ * native playback needs no CORS, so the caller should keep using the element
+ * probe there.
+ *
+ * @returns {Promise<"ok"|"error"|"timeout">}
+ */
+export async function probeHlsManifest(url, timeoutMs = 4000) {
+  const trimmed = typeof url === "string" ? url.trim() : "";
+  if (!trimmed || typeof fetch !== "function") {
+    return "error";
+  }
+
+  const controller =
+    typeof AbortController === "function" ? new AbortController() : null;
+  let timedOut = false;
+  const timeoutId =
+    Number.isFinite(timeoutMs) && timeoutMs > 0
+      ? setTimeout(() => {
+          timedOut = true;
+          controller?.abort();
+        }, timeoutMs)
+      : null;
+
+  try {
+    const response = await fetch(trimmed, {
+      method: "GET",
+      cache: "no-store",
+      signal: controller?.signal,
+    });
+    if (!response.ok) {
+      return "error";
+    }
+    const text = await response.text();
+    return text.trimStart().startsWith("#EXTM3U") ? "ok" : "error";
+  } catch (err) {
+    return timedOut ? "timeout" : "error";
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}

js/services/playbackService.js

@@ -1,5 +1,8 @@
 import { userLogger } from "../utils/logger.js";
-import { PLAYBACK_START_TIMEOUT } from "../constants.js";
+import {
+  HLS_PLAYBACK_START_TIMEOUT,
+  PLAYBACK_START_TIMEOUT,
+} from "../constants.js";
 import { getCurrentVideo, setCurrentVideo } from "../state/appState.js";
 import {
   consumeAutoplayFallbackMute,
@@ -9,6 +12,7 @@ import {
   SimpleEventEmitter,
   extractWebSeedsFromMagnet,
 } from "./playbackHelpers.js";
+import { attachHlsSource, detachHls, isHlsUrl } from "./hlsPlayback.js";
 // js/services/playbackService.js
 
 /**
@@ -855,6 +859,10 @@ class PlaybackSession extends SimpleEventEmitter {
 
       const resetVideoElement = () => {
         if (!activeVideoEl) return;
+        // Kill any hls.js instance BEFORE touching src/load(): a live instance
+        // keeps appending to the MediaSource and would fight the reset (and
+        // leak its worker) when we move to the next mirror or to WebTorrent.
+        detachHls(activeVideoEl);
         try {
           activeVideoEl.pause();
         } catch (err) {
@@ -1055,6 +1063,11 @@ class PlaybackSession extends SimpleEventEmitter {
             };
           });
 
+          // Whatever MediaError the element already carries from a previous
+          // load. Identity comparison works because starting a new load clears
+          // `error` to null and a fresh failure allocates a new MediaError.
+          const staleMediaError = activeVideoEl.error || null;
+
           const attachWatchdogs = ({ stallMs = 8000 } = {}) => {
             this.registerWatchdogs(activeVideoEl, {
               stallMs,
@@ -1071,7 +1084,17 @@ class PlaybackSession extends SimpleEventEmitter {
                   attachWatchdogs({ stallMs: 0 });
                   return;
                 }
-                const errorMessage = getHostedVideoErrorMessage(activeVideoEl);
+                // Only report a MediaError this attempt actually produced.
+                // teardownVideoElement()/resetVideoElement() clear `src` and
+                // call load(), which leaves a stale MEDIA_ERR_SRC_NOT_SUPPORTED
+                // ("Empty src attribute") on the element. Reading it blindly
+                // reported "Hosted playback failed: source not supported or
+                // blocked." for a stream that was playing perfectly — a
+                // failure message attributed to the wrong load entirely.
+                const errorMessage =
+                  activeVideoEl.error && activeVideoEl.error !== staleMediaError
+                    ? getHostedVideoErrorMessage(activeVideoEl)
+                    : "";
                 if (errorMessage) {
                   this.emit("status", { message: errorMessage });
                 }
@@ -1080,9 +1103,6 @@ class PlaybackSession extends SimpleEventEmitter {
             });
           };
 
-          // Use default stall timeout here; the initial start timeout is handled by the race wrapper
-          attachWatchdogs({ stallMs: 8000 });
-
           const handleFatalPlaybackError = (err) => {
             this.service.log(
               "[playVideoWithFallback] Direct URL playback threw:",
@@ -1091,6 +1111,14 @@ class PlaybackSession extends SimpleEventEmitter {
             outcomeResolver({ status: "fallback", reason: "play-error" });
           };
 
+          // Bind the source BEFORE arming the watchdogs. hls.js's attachMedia()
+          // points `src` at a MediaSource blob URL, which aborts any load still
+          // pending on the reused modal element and fires `abort`/`emptied`.
+          // With watchdogs already live those read as a playback failure and
+          // abandon a stream that is about to play fine. A plain `src =` is
+          // safe either way: media events are dispatched asynchronously, so
+          // listeners registered later in the same task still observe them.
+          let hlsAttached = true;
           try {
             // Guarantee the direct load is CORS-free regardless of how we got
             // here (see resetVideoElement) so any hosted URL plays reliably.
@@ -1100,8 +1128,57 @@ class PlaybackSession extends SimpleEventEmitter {
               // ignore
             }
             activeVideoEl.crossOrigin = null;
-            activeVideoEl.src = candidateUrl;
+
-            const playPromise = activeVideoEl.play();
+            // HLS cannot be assigned to `src` outside Safari — it needs hls.js
+            // + MSE. attachHlsSource() handles both paths and resolves once the
+            // manifest is parsed. A null result means HLS is unplayable here
+            // (or already failed fatally), and the outcome promise is settled,
+            // so skip play() and let the normal fallback plumbing take over.
+            if (isHlsUrl(candidateUrl)) {
+              const hlsHandle = await attachHlsSource(
+                activeVideoEl,
+                candidateUrl,
+                {
+                  log: (...args) => this.service.log(...args),
+                  onFatalError: (message) => {
+                    this.emit("status", { message });
+                    outcomeResolver({
+                      status: "fallback",
+                      reason: "hls-error",
+                      errorMessage: message,
+                    });
+                  },
+                }
+              );
+              if (!hlsHandle) {
+                hlsAttached = false;
+                // A fatal HLS error already resolved the outcome with a
+                // specific message; this only covers "no HLS support at all".
+                const message =
+                  "Hosted playback failed: this browser cannot play HLS streams.";
+                this.emit("status", { message });
+                outcomeResolver({
+                  status: "fallback",
+                  reason: "hls-unsupported",
+                  errorMessage: message,
+                });
+              }
+            } else {
+              activeVideoEl.src = candidateUrl;
+            }
+          } catch (err) {
+            hlsAttached = false;
+            handleFatalPlaybackError(err);
+          }
+
+          try {
+            // Use default stall timeout here; the initial start timeout is
+            // handled by the race wrapper.
+            if (hlsAttached) {
+              attachWatchdogs({ stallMs: 8000 });
+            }
+
+            const playPromise = hlsAttached ? activeVideoEl.play() : null;
             if (playPromise && typeof playPromise.catch === "function") {
               playPromise.catch((err) => {
                 if (err?.name === "NotAllowedError") {
@@ -1215,9 +1292,15 @@ class PlaybackSession extends SimpleEventEmitter {
           let lastUrlResult = null;
           for (let i = 0; i < this.hostedSourceCandidates.length; i += 1) {
             const candidateUrl = this.hostedSourceCandidates[i];
+            // HLS starts slower by construction (see HLS_PLAYBACK_START_TIMEOUT).
+            // `forcedSource` still means "wait indefinitely", so keep 0 as 0.
+            const candidateTimeout =
+              effectiveTimeout && isHlsUrl(candidateUrl)
+                ? Math.max(effectiveTimeout, HLS_PLAYBACK_START_TIMEOUT)
+                : effectiveTimeout;
             const urlResult = await withTimeout(
               attemptHostedPlayback(candidateUrl),
-              effectiveTimeout,
+              candidateTimeout,
               "URL Playback"
             );
 

js/ui/urlHealthController.js

@@ -1,4 +1,9 @@
 import { SHORT_TIMEOUT_MS } from "../constants.js";
+import {
+  isHlsUrl,
+  prefersNativeHls,
+  probeHlsManifest,
+} from "../services/hlsPlayback.js";
 
 export default class UrlHealthController {
   constructor({
@@ -275,6 +280,21 @@ export default class UrlHealthController {
       return { outcome: "error" };
     }
 
+    // A bare <video> cannot load an .m3u8 on the browsers bitvid actually runs
+    // hls.js on. Worse, Chrome neither plays it NOR errors — it emits no events
+    // at all, so this probe burned the full timeout on every healthy HLS card.
+    // Since playback will use hls.js (which fetches the playlist over CORS), a
+    // readable #EXTM3U response is the accurate signal — and far cheaper than
+    // pulling in the hls.js bundle just to paint a badge.
+    if (isHlsUrl(trimmed) && !prefersNativeHls()) {
+      const defaultTimeout =
+        this.constants.URL_PROBE_TIMEOUT_MS || SHORT_TIMEOUT_MS;
+      const effective =
+        Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : defaultTimeout;
+      const outcome = await probeHlsManifest(trimmed, effective);
+      return { outcome };
+    }
+
     if (this.activeVideoProbes >= this.MAX_CONCURRENT_VIDEO_PROBES) {
       await new Promise((resolve) => {
         this.videoProbeQueue.push(resolve);

package-lock.json

@@ -25,6 +25,7 @@
         "blossom-client-sdk": "5.0.0",
         "cssnano": "^7.1.2",
         "fake-indexeddb": "^6.2.5",
+        "hls.js": "^1.6.16",
         "jsdom": "^28.1.0",
         "nostr-wasm": "^0.1.0",
         "pixelmatch": "^5.3.0",
@@ -3252,6 +3253,13 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hls.js": {
+      "version": "1.6.16",
+      "resolved": "https://registry.npmjs.org/hls.js/-/hls.js-1.6.16.tgz",
+      "integrity": "sha512-VSIRpLfRwlAAdGL4wiTucx2ScRipo0ed1FBatWkyt832jC4CReKstga6yIhYVwGu9LOBjuX9wzmRMeQdBJtzEA==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
     "node_modules/hookified": {
       "version": "1.15.1",
       "resolved": "https://registry.npmjs.org/hookified/-/hookified-1.15.1.tgz",

package.json

@@ -17,6 +17,7 @@
     "build:beacon": "npm run build:beacon:bundle && npm run lint:inline-styles",
     "build:bitcoin-connect": "node scripts/build-bitcoin-connect.mjs",
     "build:blossom-sdk": "node scripts/build-blossom-sdk.mjs",
+    "build:hls": "node scripts/build-hls.mjs",
     "ci:beacon": "npm run build:beacon",
     "format": "prettier --cache --write css/tailwind.source.css css/tokens.css css/docs.css \"docs/**/*.html\" tailwind.config.cjs README.md CONTRIBUTING.md",
     "audit": "node scripts/daily-design-system-audit.mjs",
@@ -65,6 +66,7 @@
     "blossom-client-sdk": "5.0.0",
     "cssnano": "^7.1.2",
     "fake-indexeddb": "^6.2.5",
+    "hls.js": "^1.6.16",
     "jsdom": "^28.1.0",
     "nostr-wasm": "^0.1.0",
     "pixelmatch": "^5.3.0",

scripts/build-hls.mjs

@@ -0,0 +1,46 @@
+// Bundles hls.js into a single self-contained ESM file that bitvid lazy-imports
+// the first time a viewer opens an HLS (.m3u8) source. Mirrors the
+// blossom-sdk / bitcoin-connect / floating-ui vendor steps. Pinned via the exact
+// devDependency version in package.json.
+//
+// Lazy-import is the whole point: hls.js is ~530KB minified, and the vast
+// majority of bitvid videos are progressive MP4 or WebTorrent. Nothing here may
+// be imported from a module that loads on boot.
+import { build } from "esbuild";
+import { mkdir, copyFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const entryPoint = path.join(repoRoot, "scripts/vendor/hls-entry.mjs");
+const vendorDir = path.join(repoRoot, "vendor");
+const outFile = path.join(vendorDir, "hls.bundle.min.js");
+const licenseSrc = path.join(repoRoot, "node_modules/hls.js/LICENSE");
+const licenseOut = path.join(vendorDir, "hls.LICENSE");
+
+await mkdir(vendorDir, { recursive: true });
+
+await build({
+  bundle: true,
+  entryPoints: [entryPoint],
+  outfile: outFile,
+  format: "esm",
+  splitting: false,
+  platform: "browser",
+  target: ["es2020"],
+  minify: true,
+  sourcemap: false,
+  define: {
+    "process.env.NODE_ENV": '"production"',
+    global: "globalThis",
+  },
+  logLevel: "info",
+});
+
+try {
+  await copyFile(licenseSrc, licenseOut);
+} catch (error) {
+  console.warn("[build-hls] could not copy LICENSE:", error.message);
+}
+
+console.log("[build-hls] wrote", path.relative(repoRoot, outFile));

scripts/vendor/hls-entry.mjs

@@ -0,0 +1,6 @@
+// Vendor entry for hls.js. We deliberately bundle the FULL build rather than
+// `hls.js/light`: the light build drops the alternate-audio stream controller,
+// and real-world HLS ladders (e.g. nostube/slidestr publishes an
+// `EXT-X-MEDIA:TYPE=AUDIO` rendition group) demux audio into its own playlist.
+// With the light build those streams play video-only or not at all.
+export { default } from "hls.js";

tests/services/hlsPlayback.test.mjs

@@ -0,0 +1,632 @@
+// HLS (.m3u8) support — see js/services/hlsPlayback.js.
+//
+// Scenario spec (SCN-hls-*): bitvid used to attach every hosted source with
+// `videoEl.src = url`, which only plays HLS on Safari. Nostr clients publishing
+// bitvid's v3 schema with HLS ladders (nostube/slidestr) were unplayable on
+// Chrome/Firefox, and the URL-health probe reported every healthy HLS stream as
+// offline. These tests pin the observable decisions at those boundaries:
+// detection, engine selection, teardown, and the manifest probe.
+//
+// The hls.js engine itself is never loaded here — the tests exercise the
+// native-HLS branch and the fetch-based manifest probe, which are the two paths
+// that do not require a real MediaSource implementation.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  HLS_MIME_TYPES,
+  attachHlsSource,
+  detachHls,
+  getAttachedHls,
+  isHlsMimeType,
+  isHlsSource,
+  isHlsUrl,
+  prefersNativeHls,
+  probeHlsManifest,
+  supportsMse,
+  supportsNativeHls,
+} from "../../js/services/hlsPlayback.js";
+
+// --- SCN-hls-detect -------------------------------------------------------
+// Given a hosted URL, when its path ends in .m3u8, then it is treated as HLS —
+// regardless of query strings (signed CDN URLs) or fragments.
+
+test("isHlsUrl matches .m3u8 paths, including with query/fragment", () => {
+  assert.equal(
+    isHlsUrl(
+      "https://almond.apps2.slidestr.net/3751b84f27234fc8ce3227d132b422f7e00f4a50c6cdc322080fed89a302d7dd.m3u8"
+    ),
+    true
+  );
+  assert.equal(isHlsUrl("https://cdn.example/v.M3U8"), true);
+  assert.equal(isHlsUrl("https://cdn.example/v.m3u8?token=abc&exp=1"), true);
+  assert.equal(isHlsUrl("https://cdn.example/v.m3u8#t=10"), true);
+  assert.equal(isHlsUrl("  https://cdn.example/v.m3u8  "), true);
+});
+
+test("isHlsUrl rejects non-playlist URLs and incidental .m3u8 substrings", () => {
+  assert.equal(isHlsUrl("https://cdn.example/v.mp4"), false);
+  assert.equal(isHlsUrl("https://cdn.example/v.webm"), false);
+  // .m3u8 must terminate the PATH, not merely appear somewhere in the URL.
+  assert.equal(isHlsUrl("https://cdn.example/v.m3u8.mp4"), false);
+  assert.equal(isHlsUrl("https://cdn.example/?next=/a.m3u8"), false);
+  assert.equal(isHlsUrl(""), false);
+  assert.equal(isHlsUrl(null), false);
+  assert.equal(isHlsUrl(undefined), false);
+  assert.equal(isHlsUrl(42), false);
+});
+
+test("isHlsMimeType covers the canonical and legacy playlist types", () => {
+  for (const type of HLS_MIME_TYPES) {
+    assert.equal(isHlsMimeType(type), true, `${type} should be HLS`);
+    assert.equal(isHlsMimeType(type.toUpperCase()), true);
+  }
+  // Parameters must not defeat the match (servers append charset).
+  assert.equal(isHlsMimeType("application/vnd.apple.mpegurl; charset=utf-8"), true);
+  assert.equal(isHlsMimeType("video/mp4"), false);
+  assert.equal(isHlsMimeType("text/plain"), false);
+  assert.equal(isHlsMimeType(""), false);
+  assert.equal(isHlsMimeType(null), false);
+});
+
+test("isHlsSource accepts either the URL or an imeta mime hint", () => {
+  assert.equal(isHlsSource({ url: "https://cdn.example/v.m3u8" }), true);
+  assert.equal(
+    isHlsSource({ url: "https://cdn.example/stream", mimeType: "application/vnd.apple.mpegurl" }),
+    true
+  );
+  assert.equal(isHlsSource({ url: "https://cdn.example/v.mp4" }), false);
+  assert.equal(isHlsSource({}), false);
+  assert.equal(isHlsSource(), false);
+});
+
+// --- SCN-hls-engine-choice ------------------------------------------------
+// Given a browser that CLAIMS native HLS support via canPlayType, when MSE is
+// also available, then hls.js must win. This is not a preference — it is a
+// correctness requirement measured in real browsers:
+//
+//   Firefox 146:  canPlayType("application/vnd.apple.mpegurl") === ""
+//                 bare <video> → MEDIA_ERR_SRC_NOT_SUPPORTED (code 4)
+//   Chrome  149:  canPlayType(...) === "maybe"  ← and it is genuinely true there
+//
+// canPlayType is only ever a hint, so the engine choice keys off MSE (what
+// hls.js actually needs) and falls back to native only when MSE is absent.
+
+const makeFakeVideo = (canPlayTypeResult = "") => ({
+  src: "",
+  canPlayType: () => canPlayTypeResult,
+});
+
+// Node has no MediaSource; install/remove a fake to drive supportsMse().
+const withMediaSource = async (isTypeSupported, fn) => {
+  const had = "MediaSource" in globalThis;
+  const original = globalThis.MediaSource;
+  globalThis.MediaSource = { isTypeSupported };
+  try {
+    return await fn();
+  } finally {
+    if (had) {
+      globalThis.MediaSource = original;
+    } else {
+      delete globalThis.MediaSource;
+    }
+  }
+};
+
+test("supportsNativeHls reflects canPlayType for the playlist types", () => {
+  assert.equal(supportsNativeHls(makeFakeVideo("maybe")), true);
+  assert.equal(supportsNativeHls(makeFakeVideo("probably")), true);
+  assert.equal(supportsNativeHls(makeFakeVideo("")), false);
+});
+
+test("supportsNativeHls survives a throwing canPlayType", () => {
+  const hostile = {
+    canPlayType() {
+      throw new Error("nope");
+    },
+  };
+  assert.equal(supportsNativeHls(hostile), false);
+});
+
+test("supportsMse tracks MediaSource.isTypeSupported", async () => {
+  assert.equal(supportsMse(), false, "no MediaSource in this environment");
+  await withMediaSource(() => true, () => {
+    assert.equal(supportsMse(), true);
+  });
+  await withMediaSource(() => false, () => {
+    assert.equal(supportsMse(), false);
+  });
+  await withMediaSource(() => {
+    throw new Error("boom");
+  }, () => {
+    assert.equal(supportsMse(), false, "a throwing check must not propagate");
+  });
+});
+
+test("prefersNativeHls is false whenever MSE can back hls.js", async () => {
+  const chromeLike = makeFakeVideo("maybe");
+  await withMediaSource(() => true, () => {
+    // Chrome's canPlayType says "maybe" — hls.js must still win.
+    assert.equal(prefersNativeHls(chromeLike), false);
+  });
+  // Only with MSE genuinely gone does native become the choice.
+  assert.equal(prefersNativeHls(chromeLike), true);
+  assert.equal(prefersNativeHls(makeFakeVideo("")), false, "neither path works");
+});
+
+test("attachHlsSource prefers hls.js over a native claim when MSE exists", async () => {
+  const video = makeFakeVideo("maybe");
+  const { engine, instances } = makeFakeEngine();
+  const handle = await withMediaSource(() => true, () =>
+    attachHlsSource(video, "https://cdn.example/v.m3u8", {
+      createEngine: async () => engine,
+    })
+  );
+  assert.equal(handle.mode, "mse");
+  assert.equal(video.src, "", "must not use the native src path");
+  assert.equal(instances.length, 1);
+});
+
+test("attachHlsSource uses native playback when MSE is unavailable", async () => {
+  const video = makeFakeVideo("maybe");
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8");
+  assert.ok(handle, "expected a handle");
+  assert.equal(handle.mode, "native");
+  assert.equal(video.src, "https://cdn.example/v.m3u8");
+  // Nothing to destroy on the native path, but destroy() must stay callable.
+  assert.doesNotThrow(() => handle.destroy());
+  assert.equal(getAttachedHls(video), null);
+});
+
+test("attachHlsSource falls back to native when the engine fails to load", async () => {
+  const video = makeFakeVideo("maybe");
+  const handle = await withMediaSource(() => true, () =>
+    attachHlsSource(video, "https://cdn.example/v.m3u8", {
+      createEngine: async () => null,
+    })
+  );
+  assert.equal(handle.mode, "native", "an attempt beats a guaranteed failure");
+  assert.equal(video.src, "https://cdn.example/v.m3u8");
+});
+
+test("attachHlsSource trims the URL before assigning it", async () => {
+  const video = makeFakeVideo("maybe");
+  await attachHlsSource(video, "  https://cdn.example/v.m3u8\n");
+  assert.equal(video.src, "https://cdn.example/v.m3u8");
+});
+
+test("attachHlsSource returns null for missing element or URL", async () => {
+  assert.equal(await attachHlsSource(null, "https://cdn.example/v.m3u8"), null);
+  assert.equal(await attachHlsSource(makeFakeVideo("maybe"), ""), null);
+  assert.equal(await attachHlsSource(makeFakeVideo("maybe"), null), null);
+});
+
+// --- MSE test double ------------------------------------------------------
+// A minimal stand-in for the hls.js constructor: enough surface for the
+// attach/teardown/error contract, with hooks to drive events deterministically.
+// `autoManifest` mirrors real hls.js, which parses the manifest asynchronously
+// after loadSource(); tests that drive errors turn it off.
+
+const HLS_EVENTS = {
+  MANIFEST_PARSED: "hlsManifestParsed",
+  ERROR: "hlsError",
+};
+const HLS_ERROR_TYPES = {
+  NETWORK_ERROR: "networkError",
+  MEDIA_ERROR: "mediaError",
+  OTHER_ERROR: "otherError",
+};
+
+function makeFakeEngine({ autoManifest = true, levels = [{ height: 240 }] } = {}) {
+  const instances = [];
+
+  class FakeHls {
+    static isSupported() {
+      return true;
+    }
+    static get Events() {
+      return HLS_EVENTS;
+    }
+    static get ErrorTypes() {
+      return HLS_ERROR_TYPES;
+    }
+
+    constructor(config) {
+      this.config = config;
+      this.handlers = new Map();
+      this.destroyCalls = 0;
+      this.startLoadCalls = 0;
+      this.recoverMediaErrorCalls = 0;
+      this.swapAudioCodecCalls = 0;
+      this.attachedMedia = null;
+      this.loadedSource = null;
+      instances.push(this);
+    }
+
+    on(event, handler) {
+      if (!this.handlers.has(event)) {
+        this.handlers.set(event, []);
+      }
+      this.handlers.get(event).push(handler);
+    }
+
+    emit(event, data) {
+      for (const handler of this.handlers.get(event) || []) {
+        handler(event, data);
+      }
+    }
+
+    attachMedia(media) {
+      this.attachedMedia = media;
+    }
+
+    loadSource(url) {
+      this.loadedSource = url;
+      if (autoManifest) {
+        // Real hls.js parses asynchronously; keep that ordering.
+        queueMicrotask(() => this.emit(HLS_EVENTS.MANIFEST_PARSED, { levels }));
+      }
+    }
+
+    startLoad() {
+      this.startLoadCalls += 1;
+    }
+
+    recoverMediaError() {
+      this.recoverMediaErrorCalls += 1;
+    }
+
+    swapAudioCodec() {
+      this.swapAudioCodecCalls += 1;
+    }
+
+    destroy() {
+      this.destroyCalls += 1;
+    }
+  }
+
+  return { engine: FakeHls, instances };
+}
+
+// --- SCN-hls-mse ----------------------------------------------------------
+// Given an MSE browser, when a playlist parses with at least one playable
+// level, then attach resolves; when hls.js drops every level (e.g. an
+// HEVC-only ladder on Firefox) or errors fatally, then attach fails with a
+// specific, user-facing message instead of a bare "no playable source".
+
+test("attachHlsSource resolves once the manifest parses, and configures hls.js", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine();
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+  });
+
+  assert.equal(handle.mode, "mse");
+  // Native `src` must stay untouched — MSE owns the element now.
+  assert.equal(video.src, "");
+  // A bounded back-buffer matters for hour-long VOD on low-memory devices.
+  assert.equal(instances[0].config.backBufferLength, 90);
+  assert.equal(instances[0].config.enableWorker, true);
+});
+
+test("attachHlsSource fails when no rendition survives codec filtering", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine({ levels: [] });
+  const messages = [];
+
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+    onFatalError: (message) => messages.push(message),
+  });
+
+  assert.equal(handle, null);
+  assert.equal(messages.length, 1);
+  assert.match(messages[0], /codec your browser supports/i);
+  assert.equal(instances[0].destroyCalls, 1, "must not leak the instance");
+  assert.equal(getAttachedHls(video), null);
+});
+
+test("attachHlsSource returns null when hls.js is unsupported here", async () => {
+  const video = makeFakeVideo("");
+  class Unsupported {
+    static isSupported() {
+      return false;
+    }
+  }
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => Unsupported,
+  });
+  assert.equal(handle, null);
+  assert.equal(video.src, "", "must not fall back to an unplayable src");
+});
+
+test("attachHlsSource returns null when the engine bundle fails to load", async () => {
+  const video = makeFakeVideo("");
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => null,
+  });
+  assert.equal(handle, null);
+});
+
+test("a fatal network error retries twice before giving up", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine({ autoManifest: false });
+  const messages = [];
+
+  const pending = attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+    onFatalError: (message) => messages.push(message),
+  });
+  await Promise.resolve();
+  const instance = instances[0];
+
+  const networkError = {
+    fatal: true,
+    type: HLS_ERROR_TYPES.NETWORK_ERROR,
+    details: "manifestLoadError",
+  };
+  instance.emit(HLS_EVENTS.ERROR, networkError);
+  assert.equal(instance.startLoadCalls, 1);
+  instance.emit(HLS_EVENTS.ERROR, networkError);
+  assert.equal(instance.startLoadCalls, 2);
+  // Third fatal network error exhausts the retry budget.
+  instance.emit(HLS_EVENTS.ERROR, networkError);
+  assert.equal(instance.startLoadCalls, 2);
+
+  assert.equal(await pending, null);
+  assert.equal(messages.length, 1);
+  assert.match(messages[0], /network or CORS/i);
+  assert.equal(instance.destroyCalls, 1);
+});
+
+test("a fatal media error recovers, then swaps audio codec, then gives up", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine({ autoManifest: false });
+  const messages = [];
+
+  const pending = attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+    onFatalError: (message) => messages.push(message),
+  });
+  await Promise.resolve();
+  const instance = instances[0];
+
+  const mediaError = {
+    fatal: true,
+    type: HLS_ERROR_TYPES.MEDIA_ERROR,
+    details: "bufferAppendError",
+  };
+  instance.emit(HLS_EVENTS.ERROR, mediaError);
+  assert.equal(instance.recoverMediaErrorCalls, 1);
+  assert.equal(instance.swapAudioCodecCalls, 0);
+
+  instance.emit(HLS_EVENTS.ERROR, mediaError);
+  assert.equal(instance.recoverMediaErrorCalls, 2);
+  assert.equal(instance.swapAudioCodecCalls, 1, "second attempt swaps codec");
+
+  instance.emit(HLS_EVENTS.ERROR, mediaError);
+  assert.equal(instance.recoverMediaErrorCalls, 2, "budget exhausted");
+
+  assert.equal(await pending, null);
+  assert.match(messages[0], /codec your browser cannot decode/i);
+});
+
+test("non-fatal errors never tear the stream down", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine({ autoManifest: false });
+  const messages = [];
+
+  const pending = attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+    onFatalError: (message) => messages.push(message),
+  });
+  await Promise.resolve();
+  const instance = instances[0];
+
+  instance.emit(HLS_EVENTS.ERROR, {
+    fatal: false,
+    type: HLS_ERROR_TYPES.NETWORK_ERROR,
+    details: "fragLoadError",
+  });
+
+  assert.equal(instance.destroyCalls, 0);
+  assert.equal(messages.length, 0);
+
+  // A transient fragment error must still let the stream come up.
+  instance.emit(HLS_EVENTS.MANIFEST_PARSED, { levels: [{ height: 720 }] });
+  const handle = await pending;
+  assert.equal(handle.mode, "mse");
+});
+
+test("a stuck manifest fails via the attach timeout rather than hanging", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine({ autoManifest: false });
+  const messages = [];
+
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+    manifestTimeoutMs: 20,
+    onFatalError: (message) => messages.push(message),
+  });
+
+  assert.equal(handle, null);
+  assert.match(messages[0], /did not load in time/i);
+  assert.equal(instances[0].destroyCalls, 1);
+});
+
+test("attachMedia throwing is reported, not propagated", async () => {
+  const video = makeFakeVideo("");
+  const { engine } = makeFakeEngine({ autoManifest: false });
+  const messages = [];
+  class Hostile extends engine {
+    attachMedia() {
+      throw new Error("MediaSource unavailable");
+    }
+  }
+
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => Hostile,
+    onFatalError: (message) => messages.push(message),
+  });
+
+  assert.equal(handle, null);
+  assert.match(messages[0], /could not be attached/i);
+});
+
+// --- SCN-hls-teardown -----------------------------------------------------
+// Given an attached hls.js instance, when the modal tears the element down,
+// then destroy() runs exactly once and the element is unbound — otherwise the
+// transmuxing worker and segment fetches keep running after the modal closes.
+
+test("detachHls destroys the bound hls.js instance exactly once", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine();
+
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+  });
+
+  assert.ok(handle, "expected an MSE handle");
+  assert.equal(handle.mode, "mse");
+  const instance = instances[0];
+  assert.equal(getAttachedHls(video), instance);
+  assert.equal(instance.loadedSource, "https://cdn.example/v.m3u8");
+  assert.equal(instance.attachedMedia, video);
+
+  assert.equal(detachHls(video), true);
+  assert.equal(instance.destroyCalls, 1);
+  assert.equal(getAttachedHls(video), null);
+
+  // Second detach (e.g. modal teardown after the session already reset) must
+  // not double-destroy — hls.js throws on a destroyed instance.
+  assert.equal(detachHls(video), false);
+  assert.equal(instance.destroyCalls, 1);
+});
+
+test("handle.destroy() tears the instance down too", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine();
+  const handle = await attachHlsSource(video, "https://cdn.example/v.m3u8", {
+    createEngine: async () => engine,
+  });
+  handle.destroy();
+  assert.equal(instances[0].destroyCalls, 1);
+  assert.equal(getAttachedHls(video), null);
+});
+
+test("re-attaching to the same element destroys the previous instance", async () => {
+  const video = makeFakeVideo("");
+  const { engine, instances } = makeFakeEngine();
+  await attachHlsSource(video, "https://cdn.example/a.m3u8", {
+    createEngine: async () => engine,
+  });
+  await attachHlsSource(video, "https://cdn.example/b.m3u8", {
+    createEngine: async () => engine,
+  });
+  assert.equal(instances.length, 2);
+  assert.equal(instances[0].destroyCalls, 1, "first instance must be destroyed");
+  assert.equal(instances[1].destroyCalls, 0);
+  assert.equal(instances[1].loadedSource, "https://cdn.example/b.m3u8");
+  assert.equal(getAttachedHls(video), instances[1]);
+});
+
+test("detachHls is a safe no-op for non-HLS elements and null", () => {
+  assert.equal(detachHls(null), false);
+  assert.equal(detachHls(undefined), false);
+  assert.equal(detachHls(makeFakeVideo("")), false);
+});
+
+test("getAttachedHls returns null when nothing is bound", () => {
+  assert.equal(getAttachedHls(makeFakeVideo("")), null);
+  assert.equal(getAttachedHls(null), null);
+});
+
+// --- SCN-hls-probe --------------------------------------------------------
+// Given the URL-health badge probing an HLS URL on an MSE browser, when the
+// playlist is CORS-readable and starts with #EXTM3U, then the source is "ok".
+// A bare <video> probe (the old path) reported every such URL as offline, which
+// combined with the magnet-less "unhealthy" stream badge marks the card
+// confirmed-dead and hides it from the grid.
+
+const withFetch = async (impl, fn) => {
+  const original = globalThis.fetch;
+  globalThis.fetch = impl;
+  try {
+    return await fn();
+  } finally {
+    globalThis.fetch = original;
+  }
+};
+
+test("probeHlsManifest returns ok for a readable #EXTM3U playlist", async () => {
+  const result = await withFetch(
+    async () => ({
+      ok: true,
+      text: async () =>
+        '#EXTM3U\n#EXT-X-STREAM-INF:BANDWIDTH=584301,CODECS="avc1.640015"\nlow.m3u8\n',
+    }),
+    () => probeHlsManifest("https://cdn.example/v.m3u8")
+  );
+  assert.equal(result, "ok");
+});
+
+test("probeHlsManifest tolerates leading whitespace/BOM-ish padding", async () => {
+  const result = await withFetch(
+    async () => ({ ok: true, text: async () => "\n\n  #EXTM3U\n" }),
+    () => probeHlsManifest("https://cdn.example/v.m3u8")
+  );
+  assert.equal(result, "ok");
+});
+
+test("probeHlsManifest reports error for a non-playlist body", async () => {
+  const result = await withFetch(
+    async () => ({ ok: true, text: async () => "<html>404</html>" }),
+    () => probeHlsManifest("https://cdn.example/v.m3u8")
+  );
+  assert.equal(result, "error");
+});
+
+test("probeHlsManifest reports error for a non-2xx response", async () => {
+  const result = await withFetch(
+    async () => ({ ok: false, status: 403, text: async () => "#EXTM3U" }),
+    () => probeHlsManifest("https://cdn.example/v.m3u8")
+  );
+  assert.equal(result, "error");
+});
+
+test("probeHlsManifest reports error when the fetch rejects (CORS/DNS)", async () => {
+  const result = await withFetch(
+    async () => {
+      throw new TypeError("Failed to fetch");
+    },
+    () => probeHlsManifest("https://cdn.example/v.m3u8")
+  );
+  assert.equal(result, "error");
+});
+
+test("probeHlsManifest distinguishes a timeout from a hard error", async () => {
+  const result = await withFetch(
+    (_url, options) =>
+      new Promise((_resolve, reject) => {
+        // Never settles on its own; the probe's own AbortController must fire.
+        options?.signal?.addEventListener("abort", () => {
+          reject(new DOMException("Aborted", "AbortError"));
+        });
+      }),
+    () => probeHlsManifest("https://cdn.example/v.m3u8", 30)
+  );
+  assert.equal(result, "timeout");
+});
+
+test("probeHlsManifest rejects empty input without touching the network", async () => {
+  let called = false;
+  const result = await withFetch(
+    async () => {
+      called = true;
+      return { ok: true, text: async () => "#EXTM3U" };
+    },
+    () => probeHlsManifest("   ")
+  );
+  assert.equal(result, "error");
+  assert.equal(called, false);
+});

tests/services/playbackService_staleError.test.mjs

@@ -0,0 +1,185 @@
+// SCN-stale-media-error
+//
+// Given the modal <video> is reused across videos, teardownVideoElement() /
+// resetVideoElement() clear `src` and call load(). Browsers respond by leaving a
+// MEDIA_ERR_SRC_NOT_SUPPORTED ("Empty src attribute") MediaError on the element.
+//
+// When a watchdog fallback later fires for an unrelated reason (a stall, or an
+// `abort` raised by our own source swap), then the failure message must NOT be
+// derived from that leftover MediaError — doing so reported
+//   "Hosted playback failed: source not supported or blocked."
+// over a stream that was playing correctly, blaming the current load for a
+// previous one's failure.
+//
+// Then: only a MediaError produced by THIS attempt may be surfaced.
+
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { PlaybackService } from "../../js/services/playbackService.js";
+
+// Minimal <video> double: records listeners so the test can dispatch the exact
+// media events the real watchdogs bind to.
+function makeVideoStub({ initialError = null } = {}) {
+  const listeners = new Map();
+  return {
+    error: initialError,
+    src: "",
+    srcObject: null,
+    currentTime: 0,
+    readyState: 0,
+    networkState: 0,
+    muted: false,
+    dataset: {},
+    listeners,
+    addEventListener(type, handler) {
+      if (!listeners.has(type)) listeners.set(type, []);
+      listeners.get(type).push(handler);
+    },
+    removeEventListener(type, handler) {
+      const arr = listeners.get(type) || [];
+      const i = arr.indexOf(handler);
+      if (i >= 0) arr.splice(i, 1);
+    },
+    dispatch(type) {
+      for (const h of [...(listeners.get(type) || [])]) h({ type });
+    },
+    hasAttribute: () => false,
+    removeAttribute() {},
+    setAttribute() {},
+    play: () => Promise.resolve(),
+    pause() {},
+    load() {},
+  };
+}
+
+const EMPTY_SRC_ERROR = Object.freeze({
+  code: 4, // MEDIA_ERR_SRC_NOT_SUPPORTED
+  message: "MEDIA_ELEMENT_ERROR: Empty src attribute",
+});
+
+describe("PlaybackService stale MediaError handling", () => {
+  before(() => {
+    global.window = {
+      localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    };
+    global.document = { createElement: () => makeVideoStub() };
+  });
+
+  after(() => {
+    delete global.window;
+    delete global.document;
+  });
+
+  const runWatchdogFallback = async ({ initialError, errorAtFallback }) => {
+    const video = makeVideoStub({ initialError });
+    const service = new PlaybackService({
+      logger: () => {},
+      urlFirstEnabled: true,
+      isValidMagnetUri: () => false,
+    });
+
+    const statuses = [];
+    let fallbackReason = null;
+
+    // Drive the watchdog contract directly: this is the boundary where the
+    // message is chosen, independent of network or codec support.
+    const cleanup = service.registerUrlPlaybackWatchdogs(video, {
+      stallMs: 0,
+      onSuccess: () => {},
+      onFallback: (reason) => {
+        fallbackReason = reason;
+      },
+    });
+
+    video.error = errorAtFallback;
+    video.dispatch("stalled");
+    cleanup();
+
+    return { statuses, fallbackReason, video };
+  };
+
+  test("a fallback still reports its reason to the caller", async () => {
+    const { fallbackReason } = await runWatchdogFallback({
+      initialError: EMPTY_SRC_ERROR,
+      errorAtFallback: EMPTY_SRC_ERROR,
+    });
+    assert.equal(fallbackReason, "stalled");
+  });
+
+  test("the leftover empty-src MediaError is identity-distinguishable", () => {
+    // The fix hinges on identity: starting a new load clears `error` to null,
+    // and a genuine new failure allocates a DIFFERENT MediaError object. If a
+    // browser ever reused the object this guard would silently stop working.
+    const stale = EMPTY_SRC_ERROR;
+    const fresh = { code: 4, message: "MEDIA_ELEMENT_ERROR: Format error" };
+    assert.notEqual(stale, fresh);
+    assert.equal(stale === EMPTY_SRC_ERROR, true);
+  });
+
+  // Drive a real session to the watchdog-fallback branch with a stale error
+  // already on the element, and capture what the viewer would be shown.
+  const runSessionWithStall = async ({ initialError, errorAtFallback }) => {
+    const video = makeVideoStub({ initialError });
+
+    // Fire `stalled` as soon as the session arms its watchdogs — this is the
+    // spurious fallback the viewer hits while the stream is actually fine.
+    const originalAdd = video.addEventListener.bind(video);
+    video.addEventListener = (type, handler) => {
+      originalAdd(type, handler);
+      if (type === "stalled") {
+        setTimeout(() => {
+          video.error = errorAtFallback;
+          video.dispatch("stalled");
+        }, 0);
+      }
+    };
+
+    const service = new PlaybackService({
+      logger: () => {},
+      urlFirstEnabled: true,
+      isValidMagnetUri: () => false,
+    });
+
+    const statuses = [];
+    const session = service.createSession({
+      url: "https://cdn.example/video.mp4",
+      magnet: "",
+      videoElement: video,
+      autoplay: true,
+      playbackStartTimeout: 200,
+    });
+    session.on?.("status", (p) => statuses.push(p.message));
+
+    await session.execute();
+    return statuses;
+  };
+
+  test("a stale empty-src error is NOT blamed on the current load", async () => {
+    const statuses = await runSessionWithStall({
+      initialError: EMPTY_SRC_ERROR,
+      errorAtFallback: EMPTY_SRC_ERROR, // unchanged => stale
+    });
+    assert.equal(
+      statuses.some((m) => /source not supported or blocked/i.test(m)),
+      false,
+      `stale error must not be reported; got: ${JSON.stringify(statuses)}`
+    );
+  });
+
+  test("a MediaError raised by THIS load is still reported", async () => {
+    // The guard must not silence genuine failures — a new MediaError object
+    // appearing during the attempt is real and must reach the viewer.
+    const statuses = await runSessionWithStall({
+      initialError: null,
+      errorAtFallback: {
+        code: 4,
+        message: "MEDIA_ELEMENT_ERROR: Format error",
+      },
+    });
+    assert.equal(
+      statuses.some((m) => /source not supported or blocked/i.test(m)),
+      true,
+      `genuine error must be reported; got: ${JSON.stringify(statuses)}`
+    );
+  });
+});

tests/video-schema-and-conversion.test.mjs

@@ -141,6 +141,68 @@ test(".ogg url WITHOUT an audio imeta is kept (ambiguous → treated as video)",
   assert.equal(parsed.url, "https://cdn.example/clip.ogg");
 });
 
+// HLS playlists are a CONTAINER format, not an assertion about content. The
+// `audio/mpegurl` / `audio/x-mpegurl` spellings are legacy aliases for an HLS
+// playlist of any kind, so they must not vote "audio-only" — otherwise an HLS
+// video ladder published with the legacy type is misfiled as a podcast and
+// silently dropped from every video feed.
+test("HLS playlist events are kept regardless of the playlist mime spelling", () => {
+  const makeHlsEvent = (mime, id) => ({
+    id,
+    content: JSON.stringify({
+      version: 3,
+      title: "Why I'm (sort of) not worried about AI",
+      url: "https://almond.apps2.slidestr.net/3751b84f.m3u8",
+      videoRootId: `root-${id}`,
+    }),
+    tags: [
+      [
+        "imeta",
+        "dim 1280x720",
+        "url https://almond.apps2.slidestr.net/3751b84f.m3u8",
+        `m ${mime}`,
+        "duration 3512",
+      ],
+    ],
+  });
+
+  for (const mime of [
+    "application/vnd.apple.mpegurl",
+    "application/x-mpegurl",
+    "audio/mpegurl",
+    "audio/x-mpegurl",
+    "APPLICATION/VND.APPLE.MPEGURL",
+  ]) {
+    const parsed = convertEventToVideo(makeHlsEvent(mime, `evt-hls-${mime}`));
+    assert.equal(
+      parsed.invalid,
+      false,
+      `HLS note with "m ${mime}" must not be filtered as audio-only`
+    );
+    assert.equal(parsed.url, "https://almond.apps2.slidestr.net/3751b84f.m3u8");
+  }
+});
+
+test("a genuine audio/* variant still filters an HLS-tagged note", () => {
+  // The playlist type abstains; it must not *rescue* a note that also carries a
+  // real audio-only variant and no video variant.
+  const audioHls = {
+    id: "evt-hls-audio",
+    content: JSON.stringify({
+      version: 3,
+      title: "Podcast, HLS packaged",
+      url: "https://cdn.example/episode.m3u8",
+      videoRootId: "root-hls-audio",
+    }),
+    tags: [
+      ["imeta", "url https://cdn.example/episode.m3u8", "m application/x-mpegurl"],
+      ["imeta", "url https://cdn.example/episode.mp3", "m audio/mpeg"],
+    ],
+  };
+
+  assert.equal(convertEventToVideo(audioHls).invalid, true);
+});
+
 test("a video imeta variant wins even when an audio variant is also present", () => {
   const mixed = {
     id: "evt-mixed",

vendor/hls.LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2017 Dailymotion (http://www.dailymotion.com)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+src/remux/mp4-generator.js and src/demux/exp-golomb.ts implementation in this project
+are derived from the HLS library for video.js (https://github.com/videojs/videojs-contrib-hls)
+
+That work is also covered by the Apache 2 License, following copyright:
+Copyright (c) 2013-2015 Brightcove
+
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/hls.bundle.min.js

@@ -0,0 +1,40 @@
+var O=Number.isFinite||function(n){return typeof n=="number"&&isFinite(n)},No=Number.isSafeInteger||function(n){return typeof n=="number"&&Math.abs(n)<=Bo},Bo=Number.MAX_SAFE_INTEGER||9007199254740991,K=(function(n){return n.NETWORK_ERROR="networkError",n.MEDIA_ERROR="mediaError",n.KEY_SYSTEM_ERROR="keySystemError",n.MUX_ERROR="muxError",n.OTHER_ERROR="otherError",n})({}),L=(function(n){return n.KEY_SYSTEM_NO_KEYS="keySystemNoKeys",n.KEY_SYSTEM_NO_ACCESS="keySystemNoAccess",n.KEY_SYSTEM_NO_SESSION="keySystemNoSession",n.KEY_SYSTEM_NO_CONFIGURED_LICENSE="keySystemNoConfiguredLicense",n.KEY_SYSTEM_LICENSE_REQUEST_FAILED="keySystemLicenseRequestFailed",n.KEY_SYSTEM_SERVER_CERTIFICATE_REQUEST_FAILED="keySystemServerCertificateRequestFailed",n.KEY_SYSTEM_SERVER_CERTIFICATE_UPDATE_FAILED="keySystemServerCertificateUpdateFailed",n.KEY_SYSTEM_SESSION_UPDATE_FAILED="keySystemSessionUpdateFailed",n.KEY_SYSTEM_STATUS_OUTPUT_RESTRICTED="keySystemStatusOutputRestricted",n.KEY_SYSTEM_STATUS_INTERNAL_ERROR="keySystemStatusInternalError",n.KEY_SYSTEM_DESTROY_MEDIA_KEYS_ERROR="keySystemDestroyMediaKeysError",n.KEY_SYSTEM_DESTROY_CLOSE_SESSION_ERROR="keySystemDestroyCloseSessionError",n.KEY_SYSTEM_DESTROY_REMOVE_SESSION_ERROR="keySystemDestroyRemoveSessionError",n.MANIFEST_LOAD_ERROR="manifestLoadError",n.MANIFEST_LOAD_TIMEOUT="manifestLoadTimeOut",n.MANIFEST_PARSING_ERROR="manifestParsingError",n.MANIFEST_INCOMPATIBLE_CODECS_ERROR="manifestIncompatibleCodecsError",n.LEVEL_EMPTY_ERROR="levelEmptyError",n.LEVEL_LOAD_ERROR="levelLoadError",n.LEVEL_LOAD_TIMEOUT="levelLoadTimeOut",n.LEVEL_PARSING_ERROR="levelParsingError",n.LEVEL_SWITCH_ERROR="levelSwitchError",n.AUDIO_TRACK_LOAD_ERROR="audioTrackLoadError",n.AUDIO_TRACK_LOAD_TIMEOUT="audioTrackLoadTimeOut",n.SUBTITLE_LOAD_ERROR="subtitleTrackLoadError",n.SUBTITLE_TRACK_LOAD_TIMEOUT="subtitleTrackLoadTimeOut",n.FRAG_LOAD_ERROR="fragLoadError",n.FRAG_LOAD_TIMEOUT="fragLoadTimeOut",n.FRAG_DECRYPT_ERROR="fragDecryptError",n.FRAG_PARSING_ERROR="fragParsingError",n.FRAG_GAP="fragGap",n.REMUX_ALLOC_ERROR="remuxAllocError",n.KEY_LOAD_ERROR="keyLoadError",n.KEY_LOAD_TIMEOUT="keyLoadTimeOut",n.BUFFER_ADD_CODEC_ERROR="bufferAddCodecError",n.BUFFER_INCOMPATIBLE_CODECS_ERROR="bufferIncompatibleCodecsError",n.BUFFER_APPEND_ERROR="bufferAppendError",n.BUFFER_APPENDING_ERROR="bufferAppendingError",n.BUFFER_STALLED_ERROR="bufferStalledError",n.BUFFER_FULL_ERROR="bufferFullError",n.BUFFER_SEEK_OVER_HOLE="bufferSeekOverHole",n.BUFFER_NUDGE_ON_STALL="bufferNudgeOnStall",n.ASSET_LIST_LOAD_ERROR="assetListLoadError",n.ASSET_LIST_LOAD_TIMEOUT="assetListLoadTimeout",n.ASSET_LIST_PARSING_ERROR="assetListParsingError",n.INTERSTITIAL_ASSET_ITEM_ERROR="interstitialAssetItemError",n.INTERNAL_EXCEPTION="internalException",n.INTERNAL_ABORTED="aborted",n.ATTACH_MEDIA_ERROR="attachMediaError",n.UNKNOWN="unknown",n})({}),m=(function(n){return n.MEDIA_ATTACHING="hlsMediaAttaching",n.MEDIA_ATTACHED="hlsMediaAttached",n.MEDIA_DETACHING="hlsMediaDetaching",n.MEDIA_DETACHED="hlsMediaDetached",n.MEDIA_ENDED="hlsMediaEnded",n.STALL_RESOLVED="hlsStallResolved",n.BUFFER_RESET="hlsBufferReset",n.BUFFER_CODECS="hlsBufferCodecs",n.BUFFER_CREATED="hlsBufferCreated",n.BUFFER_APPENDING="hlsBufferAppending",n.BUFFER_APPENDED="hlsBufferAppended",n.BUFFER_EOS="hlsBufferEos",n.BUFFERED_TO_END="hlsBufferedToEnd",n.BUFFER_FLUSHING="hlsBufferFlushing",n.BUFFER_FLUSHED="hlsBufferFlushed",n.MANIFEST_LOADING="hlsManifestLoading",n.MANIFEST_LOADED="hlsManifestLoaded",n.MANIFEST_PARSED="hlsManifestParsed",n.LEVEL_SWITCHING="hlsLevelSwitching",n.LEVEL_SWITCHED="hlsLevelSwitched",n.LEVEL_LOADING="hlsLevelLoading",n.LEVEL_LOADED="hlsLevelLoaded",n.LEVEL_UPDATED="hlsLevelUpdated",n.LEVEL_PTS_UPDATED="hlsLevelPtsUpdated",n.LEVELS_UPDATED="hlsLevelsUpdated",n.AUDIO_TRACKS_UPDATED="hlsAudioTracksUpdated",n.AUDIO_TRACK_SWITCHING="hlsAudioTrackSwitching",n.AUDIO_TRACK_SWITCHED="hlsAudioTrackSwitched",n.AUDIO_TRACK_LOADING="hlsAudioTrackLoading",n.AUDIO_TRACK_LOADED="hlsAudioTrackLoaded",n.AUDIO_TRACK_UPDATED="hlsAudioTrackUpdated",n.SUBTITLE_TRACKS_UPDATED="hlsSubtitleTracksUpdated",n.SUBTITLE_TRACKS_CLEARED="hlsSubtitleTracksCleared",n.SUBTITLE_TRACK_SWITCH="hlsSubtitleTrackSwitch",n.SUBTITLE_TRACK_LOADING="hlsSubtitleTrackLoading",n.SUBTITLE_TRACK_LOADED="hlsSubtitleTrackLoaded",n.SUBTITLE_TRACK_UPDATED="hlsSubtitleTrackUpdated",n.SUBTITLE_FRAG_PROCESSED="hlsSubtitleFragProcessed",n.CUES_PARSED="hlsCuesParsed",n.NON_NATIVE_TEXT_TRACKS_FOUND="hlsNonNativeTextTracksFound",n.INIT_PTS_FOUND="hlsInitPtsFound",n.FRAG_LOADING="hlsFragLoading",n.FRAG_LOAD_EMERGENCY_ABORTED="hlsFragLoadEmergencyAborted",n.FRAG_LOADED="hlsFragLoaded",n.FRAG_DECRYPTED="hlsFragDecrypted",n.FRAG_PARSING_INIT_SEGMENT="hlsFragParsingInitSegment",n.FRAG_PARSING_USERDATA="hlsFragParsingUserdata",n.FRAG_PARSING_METADATA="hlsFragParsingMetadata",n.FRAG_PARSED="hlsFragParsed",n.FRAG_BUFFERED="hlsFragBuffered",n.FRAG_CHANGED="hlsFragChanged",n.FPS_DROP="hlsFpsDrop",n.FPS_DROP_LEVELine truncated
+      Fragment duration: ${i.duration.toFixed(3)}
+      Time to underbuffer: ${x.toFixed(3)} s
+      Estimated load time for current fragment: ${U.toFixed(3)} s
+      Estimated load time for down switch fragment: ${G.toFixed(3)} s
+      TTFB estimate: ${_|0} ms
+      Current BW estimate: ${O(b)?b|0:"Unknown"} bps
+      New BW estimate: ${this.getBwEstimate()|0} bps
+      Switching to level ${H} @ ${k|0} bps`),a.nextLoadLevel=a.nextAutoLevel=H,this.clearTimer();let q=()=>{if(this.clearTimer(),this.fragCurrent===i&&this.hls.loadLevel===H&&H>0){let J=this.getStarvationDelay();if(this.warn(`Aborting inflight request ${H>0?"and switching down":""}
+      Fragment duration: ${i.duration.toFixed(3)} s
+      Time to underbuffer: ${J.toFixed(3)} s`),i.abortRequests(),this.fragCurrent=this.partCurrent=null,H>f){let j=this.findBestLevel(this.hls.levels[f].bitrate,f,H,0,J,1,1);j===-1&&(j=f),this.hls.nextLoadLevel=this.hls.nextAutoLevel=j,this.resetEstimator(this.hls.levels[j].bitrate)}}};p||U>G*2?q():this.timer=self.setInterval(q,G*1e3),a.trigger(m.FRAG_LOAD_EMERGENCY_ABORTED,{frag:i,part:r,stats:h})},this.hls=e,this.bwEstimator=this.initEstimator(),this.registerListeners()}resetEstimator(e){e&&(this.log(`setting initial bwe to ${e}`),this.hls.config.abrEwmaDefaultEstimate=e),this.firstSelection=-1,this.bwEstimator=this.initEstimator()}initEstimator(){let e=this.hls.config;return new di(e.abrEwmaSlowVoD,e.abrEwmaFastVoD,e.abrEwmaDefaultEstimate)}registerListeners(){let{hls:e}=this;e.on(m.MANIFEST_LOADING,this.onManifestLoading,this),e.on(m.FRAG_LOADING,this.onFragLoading,this),e.on(m.FRAG_LOADED,this.onFragLoaded,this),e.on(m.FRAG_BUFFERED,this.onFragBuffered,this),e.on(m.LEVEL_SWITCHING,this.onLevelSwitching,this),e.on(m.LEVEL_LOADED,this.onLevelLoaded,this),e.on(m.LEVELS_UPDATED,this.onLevelsUpdated,this),e.on(m.MAX_AUTO_LEVEL_UPDATED,this.onMaxAutoLevelUpdated,this),e.on(m.ERROR,this.onError,this)}unregisterListeners(){let{hls:e}=this;e&&(e.off(m.MANIFEST_LOADING,this.onManifestLoading,this),e.off(m.FRAG_LOADING,this.onFragLoading,this),e.off(m.FRAG_LOADED,this.onFragLoaded,this),e.off(m.FRAG_BUFFERED,this.onFragBuffered,this),e.off(m.LEVEL_SWITCHING,this.onLevelSwitching,this),e.off(m.LEVEL_LOADED,this.onLevelLoaded,this),e.off(m.LEVELS_UPDATED,this.onLevelsUpdated,this),e.off(m.MAX_AUTO_LEVEL_UPDATED,this.onMaxAutoLevelUpdated,this),e.off(m.ERROR,this.onError,this))}destroy(){this.unregisterListeners(),this.clearTimer(),this.hls=this._abandonRulesCheck=this.supportedCache=null,this.fragCurrent=this.partCurrent=null}onManifestLoading(e,t){this.lastLoadedFragLevel=-1,this.firstSelection=-1,this.lastLevelLoadSec=0,this.supportedCache={},this.fragCurrent=this.partCurrent=null,this.onLevelsUpdated(),this.clearTimer()}onLevelsUpdated(){this.lastLoadedFragLevel>-1&&this.fragCurrent&&(this.lastLoadedFragLevel=this.fragCurrent.level),this._nextAutoLevel=-1,this.onMaxAutoLevelUpdated(),this.codecTiers=null,this.audioTracksByGroup=null}onMaxAutoLevelUpdated(){this.firstSelection=-1,this.nextAutoLevelKey=""}onFragLoading(e,t){let s=t.frag;if(!this.ignoreFragment(s)){if(!s.bitrateTest){var i;this.fragCurrent=s,this.partCurrent=(i=t.part)!=null?i:null}this.clearTimer(),this.timer=self.setInterval(this._abandonRulesCheck,100)}}onLevelSwitching(e,t){this.clearTimer()}onError(e,t){if(!t.fatal)switch(t.details){case L.BUFFER_ADD_CODEC_ERROR:case L.BUFFER_APPEND_ERROR:this.lastLoadedFragLevel=-1,this.firstSelection=-1;break;case L.FRAG_LOAD_TIMEOUT:{let s=t.frag,{fragCurrent:i,partCurrent:r}=this;if(s&&i&&s.sn===i.sn&&s.level===i.level){let a=performance.now(),o=r?r.stats:s.stats,c=a-o.loading.start,l=o.loading.first?o.loading.first-o.loading.start:-1;if(o.loaded&&l>-1){let u=this.bwEstimator.getEstimateTTFB();this.bwEstimator.sample(c-Math.min(u,l),o.loaded)}else this.bwEstimator.sampleTTFB(c)}break}}}getTimeToLoadFrag(e,t,s,i){let r=e+s/t,a=i?e+this.lastLevelLoadSec:0;return r+a}onLevelLoaded(e,t){let s=this.hls.config,{loading:i}=t.stats,r=i.end-i.first;O(r)&&(this.lastLevelLoadSec=r/1e3),t.details.live?this.bwEstimator.update(s.abrEwmaSlowLive,s.abrEwmaFastLive):this.bwEstimator.update(s.abrEwmaSlowVoD,s.abrEwmaFastVoD),this.timer>-1&&this._abandonRulesCheck(t.levelInfo)}onFragLoaded(e,{frag:t,part:s}){let i=s?s.stats:t.stats;if(t.type===N.MAIN&&this.bwEstimator.sampleTTFB(i.loading.first-i.loading.start),!this.ignoreFragment(t)){if(this.clearTimer(),t.level===this._nextAutoLevel&&(this._nextAutoLevel=-1),this.firstSelection=-1,this.hls.config.abrMaxWithRealBitrate){let r=s?s.duration:t.duration,a=this.hls.levels[t.level],o=(a.loaded?a.loaded.bytes:0)+i.loaded,c=(a.loaded?a.loaded.duration:0)+r;a.loaded={bytes:o,duration:c},a.realBitrate=Math.round(8*o/c)}if(t.bitrateTest){let r={stats:i,frag:t,part:s,id:t.type};this.onFragBuffered(m.FRAG_BUFFERED,r),t.bitrateTest=!1}else this.lastLoadedFragLevel=t.level}}onFragBuffered(e,t){let{frag:s,part:i}=t,r=i!=null&&i.stats.loaded?i.stats:s.stats;if(r.aborted||this.ignoreFragment(s))return;let a=r.parsing.end-r.loading.start-Math.min(r.loading.first-r.loading.start,this.bwEstimator.getEstimateTTFB());this.bwEstimator.sample(a,r.loaded),r.bwEstimate=this.getBwEstimate(),s.bitrateTest?this.bitrateTestDelay=a/1e3:this.bitrateTestDelay=0}ignoreFragment(e){return e.type!==N.MAIN||e.sn==="initSegment"}clearTimer(){this.timer>-1&&(self.clearInterval(this.timer),this.timer=-1)}get firstAutoLevel(){let{maxAutoLevel:e,minAutoLevel:t}=this.hls,s=this.getBwEstimate(),i=this.hls.config.maxStarvationDelay,r=this.findBestLevel(s,t,e,0,i,1,1);if(r>-1)return r;let a=this.hls.firstLevel,o=Math.min(Math.max(a,t),e);return this.warn(`Could not find best starting auto level. Defaulting to first in 
Line truncated
+Playlist starting @${e.startSN}
+${e.m3u8}
+
+Playlist starting @${t.startSN}
+${t.m3u8}`)}function Ua(n,e,t=!0){let s=e.startSN+e.skippedSegments-n.startSN,i=n.fragments,r=s>=0,a=0;if(r&&s<i.length)a=i[s].start;else if(r&&e.startSN===n.endSN+1)a=n.fragmentEnd;else if(r&&t)a=n.fragmentStart+s*e.levelTargetDuration;else if(!e.skippedSegments&&e.fragmentStart===0)a=n.fragmentStart;else return;Pi(e,a)}function Pi(n,e){if(e){let t=n.fragments;for(let s=n.skippedSegments;s<t.length;s++)t[s].addStart(e);n.fragmentHint&&n.fragmentHint.addStart(e)}}function $a(n,e=1/0){let t=1e3*n.targetduration;if(n.updated){let s=n.fragments;if(s.length&&t*4>e){let r=s[s.length-1].duration*1e3;r<t&&(t=r)}}else t/=2;return Math.round(t)}function Ga(n,e,t){if(!n)return null;let s=n.fragments[e-n.startSN];return s||(s=n.fragmentHint,s&&s.sn===e)?s:e<n.startSN&&t&&t.sn===e?t:null}function Fn(n,e,t){return n?Ka(n.partList,e,t):null}function Ka(n,e,t){if(n)for(let s=n.length;s--;){let i=n[s];if(i.index===t&&i.fragment.sn===e)return i}return null}function Va(n){n.forEach((e,t)=>{var s;(s=e.details)==null||s.fragments.forEach(i=>{i.level=t,i.initSegment&&(i.initSegment.level=t)})})}function ac(n,e){return n!==e&&e?Nn(n)!==Nn(e):!1}function Nn(n){return n.replace(/\?[^?]*$/,"")}function Pt(n,e){for(let s=0,i=n.length;s<i;s++){var t;if(((t=n[s])==null?void 0:t.cc)===e)return n[s]}return null}function oc(n,e){return!!(n&&e.startCC<n.endCC&&e.endCC>n.startCC)}function Bn(n,e){let t=n.start+e;n.startPTS=t,n.setStart(t),n.endPTS=t+n.duration}function Ha(n,e){let t=e.fragments;for(let s=0,i=t.length;s<i;s++)Bn(t[s],n);e.fragmentHint&&Bn(e.fragmentHint,n),e.alignedSliding=!0}function lc(n,e){n&&(Ya(e,n),e.alignedSliding||Is(e,n),!e.alignedSliding&&!e.skippedSegments&&Ua(n,e,!1))}function Ya(n,e){if(!oc(e,n))return;let t=Math.min(e.endCC,n.endCC),s=Pt(e.fragments,t),i=Pt(n.fragments,t);if(!s||!i)return;te.log(`Aligning playlist at start of dicontinuity sequence ${t}`);let r=s.start-i.start;Ha(r,n)}function Is(n,e){if(!n.hasProgramDateTime||!e.hasProgramDateTime)return;let t=n.fragments,s=e.fragments;if(!t.length||!s.length)return;let i,r,a=Math.min(e.endCC,n.endCC);e.startCC<a&&n.startCC<a&&(i=Pt(s,a),r=Pt(t,a)),(!i||!r)&&(i=s[Math.floor(s.length/2)],r=Pt(t,i.cc)||t[Math.floor(t.length/2)]);let o=i.programDateTime,c=r.programDateTime;if(!o||!c)return;let l=(c-o)/1e3-(r.start-i.start);Ha(l,n)}function Se(n,e,t){xe(n,e,t),n.addEventListener(e,t)}function xe(n,e,t){n.removeEventListener(e,t)}var cc={toString:function(n){let e="",t=n.length;for(let s=0;s<t;s++)e+=`[${n.start(s).toFixed(3)}-${n.end(s).toFixed(3)}]`;return e}},D={STOPPED:"STOPPED",IDLE:"IDLE",KEY_LOADING:"KEY_LOADING",FRAG_LOADING:"FRAG_LOADING",FRAG_LOADING_WAITING_RETRY:"FRAG_LOADING_WAITING_RETRY",WAITING_TRACK:"WAITING_TRACK",PARSING:"PARSING",PARSED:"PARSED",ENDED:"ENDED",ERROR:"ERROR",WAITING_INIT_PTS:"WAITING_INIT_PTS",WAITING_LEVEL:"WAITING_LEVEL"},Bt=class extends Ss{constructor(e,t,s,i,r){super(i,e.logger),this.hls=void 0,this.fragPrevious=null,this.fragCurrent=null,this.fragmentTracker=void 0,this.transmuxer=null,this._state=D.STOPPED,this.playlistType=void 0,this.media=null,this.mediaBuffer=null,this.config=void 0,this.bitrateTest=!1,this.lastCurrentTime=0,this.nextLoadPosition=0,this.startPosition=0,this.startTimeOffset=null,this.retryDate=0,this.levels=null,this.fragmentLoader=void 0,this.keyLoader=void 0,this.levelLastLoaded=null,this.startFragRequested=!1,this.decrypter=void 0,this.initPTS=[],this.buffering=!0,this.loadingParts=!1,this.loopSn=void 0,this.onMediaSeeking=()=>{let{config:a,fragCurrent:o,media:c,mediaBuffer:l,state:h}=this,u=c?c.currentTime:0,d=W.bufferInfo(l||c,u,a.maxBufferHole),f=!d.len;if(this.log(`Media seeking to ${O(u)?u.toFixed(3):u}, state: ${h}, ${f?"out of":"in"} buffer`),this.state===D.ENDED)this.resetLoadingState();else if(o){let g=a.maxFragLookUpTolerance,y=o.start-g,p=o.start+o.duration+g;if(f||p<d.start||y>d.end){let E=u>p;(u<y||E)&&(E&&o.loader&&(this.log(`Cancelling fragment load for seek (sn: ${o.sn})`),o.abortRequests(),this.resetLoadingState()),this.fragPrevious=null)}}if(c){this.fragmentTracker.removeFragmentsInRange(u,1/0,this.playlistType,!0);let g=this.lastCurrentTime;if(u>g&&(this.lastCurrentTime=u),!this.loadingParts){let y=Math.max(d.end,u),p=this.shouldLoadParts(this.getLevelDetails(),y);p&&(this.log(`LL-Part loading ON after seeking to ${u.toFixed(2)} with buffer @${y.toFixed(2)}`),this.loadingParts=p)}}this.hls.hasEnoughToStart||(this.log(`Setting ${f?"startPosition":"nextLoadPosition"} to ${u} for seek without enough to start`),this.nextLoadPosition=u,f&&(this.startPosition=u)),f&&this.state===D.IDLE&&this.tickImmediate()},this.onMediaEnded=()=>{this.log("setting startPosition to 0 because media ended"),this.startPosition=this.lastCurrentTime=0},this.playlistType=r,this.hls=e,this.fragmentLoader=new Li(e.config),this.keyLoader=s,this.fragmentTracker=t,this.config=e.config,this.decrypter=new Ft(e.config)}registerListeners(){let{hls:e}=this;e.on(m.MEDIA_ATTACHED,this.onMediaAttached,this),e.on(m.MEDIA_DE
Line truncated
+        discontinuity: ${T}
+        trackSwitch: ${S}
+        contiguous: ${A}
+        accurateTimeOffset: ${c}
+        timeOffset: ${y}
+        initSegmentChange: ${R}`);let P=new Vi(s,i,t,o,h);this.configureTransmuxer(P)}if(this.frag=r,this.part=a,this.workerContext)this.workerContext.worker.postMessage({instanceNo:f,cmd:"demux",data:e,decryptdata:p,chunkMeta:l,state:I},e instanceof ArrayBuffer?[e]:[]);else if(g){let P=g.push(e,p,l,I);Kt(P)?P.then(M=>{this.handleTransmuxComplete(M)}).catch(M=>{this.transmuxerError(M,l,"transmuxer-interface push error")}):this.handleTransmuxComplete(P)}}flush(e){e.transmuxing.start=self.performance.now();let{instanceNo:t,transmuxer:s}=this;if(this.workerContext)this.workerContext.worker.postMessage({instanceNo:t,cmd:"flush",chunkMeta:e});else if(s){let i=s.flush(e);Kt(i)?i.then(r=>{this.handleFlushResult(r,e)}).catch(r=>{this.transmuxerError(r,e,"transmuxer-interface flush error")}):this.handleFlushResult(i,e)}}transmuxerError(e,t,s){this.hls&&(this.error=e,this.hls.trigger(m.ERROR,{type:K.MEDIA_ERROR,details:L.FRAG_PARSING_ERROR,chunkMeta:t,frag:this.frag||void 0,part:this.part||void 0,fatal:!1,error:e,err:e,reason:s}))}handleFlushResult(e,t){e.forEach(s=>{this.handleTransmuxComplete(s)}),this.onFlush(t)}configureTransmuxer(e){let{instanceNo:t,transmuxer:s}=this;this.workerContext?this.workerContext.worker.postMessage({instanceNo:t,cmd:"configure",config:e}):s&&s.configure(e)}handleTransmuxComplete(e){e.chunkMeta.transmuxing.end=self.performance.now(),this.onTransmuxComplete(e)}},Wn=100,Yi=class extends Bt{constructor(e,t,s){super(e,t,s,"audio-stream-controller",N.AUDIO),this.mainAnchor=null,this.mainFragLoading=null,this.audioOnly=!1,this.bufferedTrack=null,this.switchingTrack=null,this.trackId=-1,this.waitingData=null,this.mainDetails=null,this.flushing=!1,this.bufferFlushed=!1,this.cachedTrackLoadedData=null,this.registerListeners()}onHandlerDestroying(){this.unregisterListeners(),super.onHandlerDestroying(),this.resetItem()}resetItem(){this.mainDetails=this.mainAnchor=this.mainFragLoading=this.bufferedTrack=this.switchingTrack=this.waitingData=this.cachedTrackLoadedData=null}registerListeners(){super.registerListeners();let{hls:e}=this;e.on(m.LEVEL_LOADED,this.onLevelLoaded,this),e.on(m.AUDIO_TRACKS_UPDATED,this.onAudioTracksUpdated,this),e.on(m.AUDIO_TRACK_SWITCHING,this.onAudioTrackSwitching,this),e.on(m.AUDIO_TRACK_LOADED,this.onAudioTrackLoaded,this),e.on(m.BUFFER_RESET,this.onBufferReset,this),e.on(m.BUFFER_CREATED,this.onBufferCreated,this),e.on(m.BUFFER_FLUSHING,this.onBufferFlushing,this),e.on(m.BUFFER_FLUSHED,this.onBufferFlushed,this),e.on(m.INIT_PTS_FOUND,this.onInitPtsFound,this),e.on(m.FRAG_LOADING,this.onFragLoading,this),e.on(m.FRAG_BUFFERED,this.onFragBuffered,this)}unregisterListeners(){let{hls:e}=this;e&&(super.unregisterListeners(),e.off(m.LEVEL_LOADED,this.onLevelLoaded,this),e.off(m.AUDIO_TRACKS_UPDATED,this.onAudioTracksUpdated,this),e.off(m.AUDIO_TRACK_SWITCHING,this.onAudioTrackSwitching,this),e.off(m.AUDIO_TRACK_LOADED,this.onAudioTrackLoaded,this),e.off(m.BUFFER_RESET,this.onBufferReset,this),e.off(m.BUFFER_CREATED,this.onBufferCreated,this),e.off(m.BUFFER_FLUSHING,this.onBufferFlushing,this),e.off(m.BUFFER_FLUSHED,this.onBufferFlushed,this),e.off(m.INIT_PTS_FOUND,this.onInitPtsFound,this),e.off(m.FRAG_LOADING,this.onFragLoading,this),e.off(m.FRAG_BUFFERED,this.onFragBuffered,this))}onInitPtsFound(e,{frag:t,id:s,initPTS:i,timescale:r,trackId:a}){if(s===N.MAIN){let o=t.cc,c=this.fragCurrent;if(this.initPTS[o]={baseTime:i,timescale:r,trackId:a},this.log(`InitPTS for cc: ${o} found from main: ${i/r} (${i}/${r}) trackId: ${a}`),this.mainAnchor=t,this.state===D.WAITING_INIT_PTS){let l=this.waitingData;(!l&&!this.loadingParts||l&&l.frag.cc!==o)&&this.syncWithAnchor(t,l?.frag)}else!this.hls.hasEnoughToStart&&c&&c.cc!==o?(c.abortRequests(),this.syncWithAnchor(t,c)):this.state===D.IDLE&&this.tick()}}getLoadPosition(){return!this.startFragRequested&&this.nextLoadPosition>=0?this.nextLoadPosition:super.getLoadPosition()}syncWithAnchor(e,t){var s;let i=((s=this.mainFragLoading)==null?void 0:s.frag)||null;if(t&&i?.cc===t.cc)return;let r=(i||e).cc,a=this.getLevelDetails(),o=this.getLoadPosition(),c=Da(a,r,o);c&&(this.log(`Syncing with main frag at ${c.start} cc ${c.cc}`),this.startFragRequested=!1,this.nextLoadPosition=c.start,this.resetLoadingState(),this.state===D.IDLE&&this.doTickIdle())}startLoad(e,t){if(!this.levels){this.startPosition=e,this.state=D.STOPPED;return}let s=this.lastCurrentTime;this.stopLoad(),this.setInterval(Wn),s>0&&e===-1?(this.log(`Override startPosition with lastCurrentTime @${s.toFixed(3)}`),e=s,this.state=D.IDLE):this.state=D.WAITING_TRACK,this.nextLoadPosition=this.lastCurrentTime=e+this.timelineOffset,this.startPosition=t?-1:e,this.tick()}doTick(){switch(this.state){case D.IDLE:this.doTickIdle();break;case D.WAITING_TRACK:{let{levels:e,trackId:t}=this,s=e?.[t],i=s?.details;if(i&&!this.waitForLive(s)){if(this.waitForCdnTuneIn(i))break;this.state=D.WAITING_INIT_PTS}break}case D.FRAG_LOADING_WAITING_RETRY:{this.checkRetryDate();break}case D.WAITING_INIT_PTS:{let e
Line truncated
+${this.list("video")}
+${this.list("audio")}
+${this.list("audiovideo")}}`}list(e){var t,s;return(t=this.queues)!=null&&t[e]||(s=this.tracks)!=null&&s[e]?`${e}: (${this.listSbInfo(e)}) ${this.listOps(e)}`:""}listSbInfo(e){var t;let s=(t=this.tracks)==null?void 0:t[e],i=s?.buffer;return i?`SourceBuffer${i.updating?" updating":""}${s.ended?" ended":""}${s.ending?" ending":""}`:"none"}listOps(e){var t;return((t=this.queues)==null?void 0:t[e].map(s=>s.label).join(", "))||""}},qn=/(avc[1234]|hvc1|hev1|dvh[1e]|vp09|av01)(?:\.[^.,]+)+/,ho="HlsJsTrackRemovedError",Xi=class extends Error{constructor(e){super(e),this.name=ho}},zi=class extends Ae{constructor(e,t){super("buffer-controller",e.logger),this.hls=void 0,this.fragmentTracker=void 0,this.details=null,this._objectUrl=null,this.operationQueue=null,this.bufferCodecEventsTotal=0,this.media=null,this.mediaSource=null,this.lastMpegAudioChunk=null,this.blockedAudioAppend=null,this.lastVideoAppendEnd=0,this.appendSource=void 0,this.transferData=void 0,this.overrides=void 0,this.appendErrors={audio:0,video:0,audiovideo:0},this.tracks={},this.sourceBuffers=[[null,null],[null,null]],this._onEndStreaming=s=>{var i;this.hls&&((i=this.mediaSource)==null?void 0:i.readyState)==="open"&&this.hls.pauseBuffering()},this._onStartStreaming=s=>{this.hls&&this.hls.resumeBuffering()},this._onMediaSourceOpen=s=>{let{media:i,mediaSource:r}=this;s&&this.log("Media source opened"),!(!i||!r)&&(r.removeEventListener("sourceopen",this._onMediaSourceOpen),i.removeEventListener("emptied",this._onMediaEmptied),this.updateDuration(),this.hls.trigger(m.MEDIA_ATTACHED,{media:i,mediaSource:r}),this.mediaSource!==null&&this.checkPendingTracks())},this._onMediaSourceClose=()=>{this.log("Media source closed")},this._onMediaSourceEnded=()=>{this.log("Media source ended")},this._onMediaEmptied=()=>{let{mediaSrc:s,_objectUrl:i}=this;s!==i&&this.error(`Media element src was set while attaching MediaSource (${i} > ${s})`)},this.hls=e,this.fragmentTracker=t,this.appendSource=Yo(ze(e.config.preferManagedMediaSource)),this.initTracks(),this.registerListeners()}hasSourceTypes(){return Object.keys(this.tracks).length>0}destroy(){this.unregisterListeners(),this.details=null,this.lastMpegAudioChunk=this.blockedAudioAppend=null,this.transferData=this.overrides=void 0,this.operationQueue&&(this.operationQueue.destroy(),this.operationQueue=null),this.hls=this.fragmentTracker=null,this._onMediaSourceOpen=this._onMediaSourceClose=null,this._onMediaSourceEnded=null,this._onStartStreaming=this._onEndStreaming=null}registerListeners(){let{hls:e}=this;e.on(m.MEDIA_ATTACHING,this.onMediaAttaching,this),e.on(m.MEDIA_DETACHING,this.onMediaDetaching,this),e.on(m.MANIFEST_LOADING,this.onManifestLoading,this),e.on(m.MANIFEST_PARSED,this.onManifestParsed,this),e.on(m.BUFFER_RESET,this.onBufferReset,this),e.on(m.BUFFER_APPENDING,this.onBufferAppending,this),e.on(m.BUFFER_CODECS,this.onBufferCodecs,this),e.on(m.BUFFER_EOS,this.onBufferEos,this),e.on(m.BUFFER_FLUSHING,this.onBufferFlushing,this),e.on(m.LEVEL_UPDATED,this.onLevelUpdated,this),e.on(m.FRAG_PARSED,this.onFragParsed,this),e.on(m.FRAG_CHANGED,this.onFragChanged,this),e.on(m.ERROR,this.onError,this)}unregisterListeners(){let{hls:e}=this;e.off(m.MEDIA_ATTACHING,this.onMediaAttaching,this),e.off(m.MEDIA_DETACHING,this.onMediaDetaching,this),e.off(m.MANIFEST_LOADING,this.onManifestLoading,this),e.off(m.MANIFEST_PARSED,this.onManifestParsed,this),e.off(m.BUFFER_RESET,this.onBufferReset,this),e.off(m.BUFFER_APPENDING,this.onBufferAppending,this),e.off(m.BUFFER_CODECS,this.onBufferCodecs,this),e.off(m.BUFFER_EOS,this.onBufferEos,this),e.off(m.BUFFER_FLUSHING,this.onBufferFlushing,this),e.off(m.LEVEL_UPDATED,this.onLevelUpdated,this),e.off(m.FRAG_PARSED,this.onFragParsed,this),e.off(m.FRAG_CHANGED,this.onFragChanged,this),e.off(m.ERROR,this.onError,this)}transferMedia(){let{media:e,mediaSource:t}=this;if(!e)return null;let s={};if(this.operationQueue){let r=this.isUpdating();r||this.operationQueue.removeBlockers();let a=this.isQueued();(r||a)&&this.warn(`Transfering MediaSource with${a?" operations in queue":""}${r?" updating SourceBuffer(s)":""} ${this.operationQueue}`),this.operationQueue.destroy()}let i=this.transferData;return!this.sourceBufferCount&&i&&i.mediaSource===t?se(s,i.tracks):this.sourceBuffers.forEach(r=>{let[a]=r;a&&(s[a]=se({},this.tracks[a]),this.removeBuffer(a)),r[0]=r[1]=null}),{media:e,mediaSource:t,tracks:s}}initTracks(){let e={};this.sourceBuffers=[[null,null],[null,null]],this.tracks=e,this.resetQueue(),this.resetAppendErrors(),this.lastMpegAudioChunk=this.blockedAudioAppend=null,this.lastVideoAppendEnd=0}onManifestLoading(){this.bufferCodecEventsTotal=0,this.details=null}onManifestParsed(e,t){var s;let i=2;(t.audio&&!t.video||!t.altAudio)&&(i=1),this.bufferCodecEventsTotal=i,this.log(`${i} bufferCodec event(s) expected.`),(s=this.transferData)!=null&&s.mediaSource&&this.sourceBufferCount&&i&&this.bufferCreated()}onMediaAttaching(e,t){let s=this.media=t.media;this.transferData=this.overrides=void
Line truncated
+required tracks: ${re(s,(c,l)=>c==="initSegment"?void 0:l)};
+transfer tracks: ${re(i,(c,l)=>c==="initSegment"?void 0:l)}}`),!da(i,s)){t.mediaSource=null,t.tracks=void 0;let c=e.currentTime,l=this.details,h=Math.max(c,l?.fragments[0].start||0);if(h-c>1){this.log(`attachTransferred: waiting for playback to reach new tracks start time ${c} -> ${h}`);return}this.warn(`attachTransferred: resetting MediaSource for incompatible tracks ("${Object.keys(i)}"->"${Object.keys(s)}") start time: ${h} currentTime: ${c}`),this.onMediaDetaching(m.MEDIA_DETACHING,{}),this.onMediaAttaching(m.MEDIA_ATTACHING,t),e.currentTime=h;return}this.transferData=void 0,r.forEach(c=>{let l=c,h=i[l];if(h){let u=h.buffer;if(u){let d=this.fragmentTracker,f=h.id;if(d.hasFragments(f)||d.hasParts(f)){let p=W.getBuffered(u);d.detectEvictedFragments(l,p,f,null,!0)}let g=ti(l),y=[l,u];this.sourceBuffers[g]=y,u.updating&&this.operationQueue&&this.operationQueue.prependBlocker(l),this.trackSourceBuffer(l,h)}}}),o(),this.bufferCreated()}else this.log("attachTransferred: MediaSource w/o SourceBuffers"),o()}get mediaSourceOpenOrEnded(){var e;let t=(e=this.mediaSource)==null?void 0:e.readyState;return t==="open"||t==="ended"}onMediaDetaching(e,t){let s=!!t.transferMedia;this.transferData=this.overrides=void 0;let{media:i,mediaSource:r,_objectUrl:a}=this;if(r){if(this.log(`media source ${s?"transferring":"detaching"}`),s)this.sourceBuffers.forEach(([o])=>{o&&this.removeBuffer(o)}),this.resetQueue();else{if(this.mediaSourceOpenOrEnded){let o=r.readyState==="open";try{let c=r.sourceBuffers;for(let l=c.length;l--;)o&&c[l].abort(),r.removeSourceBuffer(c[l]);o&&r.endOfStream()}catch(c){this.warn(`onMediaDetaching: ${c.message} while calling endOfStream`)}}this.sourceBufferCount&&this.onBufferReset()}r.removeEventListener("sourceopen",this._onMediaSourceOpen),r.removeEventListener("sourceended",this._onMediaSourceEnded),r.removeEventListener("sourceclose",this._onMediaSourceClose),this.appendSource&&(r.removeEventListener("startstreaming",this._onStartStreaming),r.removeEventListener("endstreaming",this._onEndStreaming)),this.mediaSource=null,this._objectUrl=null}i&&(i.removeEventListener("emptied",this._onMediaEmptied),s||(a&&self.URL.revokeObjectURL(a),this.mediaSrc===a?(i.removeAttribute("src"),this.appendSource&&jn(i),i.load()):this.warn("media|source.src was changed by a third party - skip cleanup")),this.media=null),this.hls.trigger(m.MEDIA_DETACHED,t)}onBufferReset(){this.sourceBuffers.forEach(([e])=>{e&&this.resetBuffer(e)}),this.initTracks()}resetBuffer(e){var t;let s=(t=this.tracks[e])==null?void 0:t.buffer;if(this.removeBuffer(e),s)try{var i;(i=this.mediaSource)!=null&&i.sourceBuffers.length&&this.mediaSource.removeSourceBuffer(s)}catch(r){this.warn(`onBufferReset ${e}`,r)}delete this.tracks[e]}removeBuffer(e){this.removeBufferListeners(e),this.sourceBuffers[ti(e)]=[null,null];let t=this.tracks[e];t&&(t.buffer=void 0)}resetQueue(){this.operationQueue&&this.operationQueue.destroy(),this.operationQueue=new ji(this.tracks)}onBufferCodecs(e,t){var s;let i=this.tracks,r=Object.keys(t);this.log(`BUFFER_CODECS: "${r}" (current SB count ${this.sourceBufferCount})`);let a="audiovideo"in t&&(i.audio||i.video)||i.audiovideo&&("audio"in t||"video"in t),o=!a&&this.sourceBufferCount&&this.media&&r.some(c=>!i[c]);if(a||o){this.warn(`Unsupported transition between "${Object.keys(i)}" and "${r}" SourceBuffers`);return}r.forEach(c=>{var l,h;let u=t[c],{id:d,codec:f,levelCodec:g,container:y,metadata:p,supplemental:E}=u,T=i[c],S=(l=this.transferData)==null||(l=l.tracks)==null?void 0:l[c],v=S!=null&&S.buffer?S:T,x=v?.pendingCodec||v?.codec,_=v?.levelCodec;T||(T=i[c]={buffer:void 0,listeners:[],codec:f,supplemental:E,container:y,levelCodec:g,metadata:p,id:d});let A=ns(x,_),b=A?.replace(qn,"$1"),R=ns(f,g),I=(h=R)==null?void 0:h.replace(qn,"$1");R&&A&&b!==I&&(c.slice(0,5)==="audio"&&(R=gs(R,this.appendSource)),this.log(`switching codec ${x} to ${R}`),R!==(T.pendingCodec||T.codec)&&(T.pendingCodec=R),T.container=y,this.appendChangeType(c,y,R))}),(this.tracksReady||this.sourceBufferCount)&&(t.tracks=this.sourceBufferTracks),!this.sourceBufferCount&&(this.bufferCodecEventsTotal>1&&!this.tracks.video&&!t.video&&((s=t.audio)==null?void 0:s.id)==="main"&&(this.log("Main audio-only"),this.bufferCodecEventsTotal=1),this.mediaSourceOpenOrEnded&&this.checkPendingTracks())}get sourceBufferTracks(){return Object.keys(this.tracks).reduce((e,t)=>{let s=this.tracks[t];return e[t]={id:s.id,container:s.container,codec:s.codec,levelCodec:s.levelCodec},e},{})}appendChangeType(e,t,s){let i=`${t};codecs=${s}`,r={label:`change-type=${i}`,execute:()=>{let a=this.tracks[e];if(a){let o=a.buffer;o!=null&&o.changeType&&(this.log(`changing ${e} sourceBuffer type to ${i}`),o.changeType(i),a.codec=s,a.container=t)}this.shiftAndExecuteNext(e)},onStart:()=>{},onComplete:()=>{},onError:a=>{this.warn(`Failed to change ${e} SourceBuffer type`,a)}};this.append(r,e,this.isPending(this.tracks[e]))}blockAudio(e){var t;let s=e.start,i=s+e.duration*.05;if(((t=this.fragmen
Line truncated
+      } (data length: ${t.byteLength})`),s.update(t)}getSelectedKeySystemFormats(){return Object.keys(this.keySystemAccessPromises).map(e=>({keySystem:e,hasMediaKeys:this.keySystemAccessPromises[e].hasMediaKeys})).filter(({hasMediaKeys:e})=>!!e).map(({keySystem:e})=>qs(e)).filter(e=>!!e)}getKeySystemAccess(e){return this.getKeySystemSelectionPromise(e).then(({keySystem:t,mediaKeys:s})=>this.attemptSetMediaKeys(t,s))}selectKeySystem(e){return new Promise((t,s)=>{this.getKeySystemSelectionPromise(e).then(({keySystem:i})=>{let r=qs(i);r?t(r):s(new Error(`Unable to find format for key-system "${i}"`))}).catch(s)})}selectKeySystemFormat(e){let t=Object.keys(e.levelkeys||{});return this.keyFormatPromise||(this.log(`Selecting key-system from fragment (sn: ${e.sn} ${e.type}: ${e.level}) key formats ${t.join(", ")}`),this.keyFormatPromise=this.getKeyFormatPromise(t)),this.keyFormatPromise}getKeyFormatPromise(e){let t=_t(this.config),s=e.map(os).filter(i=>!!i&&t.indexOf(i)!==-1);return this.selectKeySystem(s)}getKeyStatus(e){let{mediaKeySessions:t}=this;for(let s=0;s<t.length;s++){let i=zh(e,t[s]);if(i)return i}}loadKey(e){let t=e.keyInfo.decryptdata,s=es(t),i=this.bannedKeyIds[s];if(i||this.getKeyStatus(t)==="internal-error"){let o=Jn(i||"internal-error",t);return this.handleError(o,e.frag),Promise.reject(o)}let r=`(keyId: ${s} format: "${t.keyFormat}" method: ${t.method} uri: ${t.uri})`;this.log(`Starting session for key ${r}`);let a=this.keyIdToKeySessionPromise[s];if(!a){let o=this.getKeySystemForKeyPromise(t).then(({keySystem:c,mediaKeys:l})=>(this.throwIfDestroyed(),this.log(`Handle encrypted media sn: ${e.frag.sn} ${e.frag.type}: ${e.frag.level} using key ${r}`),this.attemptSetMediaKeys(c,l).then(()=>(this.throwIfDestroyed(),this.createMediaKeySessionContext({keySystem:c,mediaKeys:l,decryptdata:t}))))).then(c=>{let l="cenc",h=t.pssh?t.pssh.buffer:null;return this.generateRequestWithPreferredKeySession(c,l,h,"playlist-key")});return o.catch(c=>this.handleError(c,e.frag)),this.keyIdToKeySessionPromise[s]=o,o}return a.catch(o=>{if(o instanceof Te){let c=ee({},o.data);this.getKeyStatus(t)==="internal-error"&&(c.decryptdata=t);let l=new Te(c,o.message);this.handleError(l,e.frag)}}),a}throwIfDestroyed(e="Invalid state"){if(!this.hls)throw new Error("invalid state")}handleError(e,t){if(this.hls)if(e instanceof Te){t&&(e.data.frag=t);let s=e.data.decryptdata;this.error(`${e.message}${s?` (${me(s.keyId||[])})`:""}`),this.hls.trigger(m.ERROR,e.data)}else this.error(e.message),this.hls.trigger(m.ERROR,{type:K.KEY_SYSTEM_ERROR,details:L.KEY_SYSTEM_NO_KEYS,error:e,fatal:!0})}getKeySystemForKeyPromise(e){let t=es(e),s=this.keyIdToKeySessionPromise[t];if(!s){let i=os(e.keyFormat),r=i?[i]:_t(this.config);return this.attemptKeySystemAccess(r)}return s}getKeySystemSelectionPromise(e){if(e.length||(e=_t(this.config)),e.length===0)throw new Te({type:K.KEY_SYSTEM_ERROR,details:L.KEY_SYSTEM_NO_CONFIGURED_LICENSE,fatal:!0},`Missing key-system license configuration options ${re({drmSystems:this.config.drmSystems})}`);return this.attemptKeySystemAccess(e)}attemptSetMediaKeys(e,t){if(this.mediaResolved=void 0,this.mediaKeys===t)return Promise.resolve();let s=this.setMediaKeysQueue.slice();this.log(`Setting media-keys for "${e}"`);let i=Promise.all(s).then(()=>this.media?this.media.setMediaKeys(t):new Promise((r,a)=>{this.mediaResolved=()=>{if(this.mediaResolved=void 0,!this.media)return a(new Error("Attempted to set mediaKeys without media element attached"));this.mediaKeys=t,this.media.setMediaKeys(t).then(r).catch(a)}}));return this.mediaKeys=t,this.setMediaKeysQueue.push(i),i.then(()=>{this.log(`Media-keys set for "${e}"`),s.push(i),this.setMediaKeysQueue=this.setMediaKeysQueue.filter(r=>s.indexOf(r)===-1)})}generateRequestWithPreferredKeySession(e,t,s,i){var r;let a=(r=this.config.drmSystems)==null||(r=r[e.keySystem])==null?void 0:r.generateRequest;if(a)try{let g=a.call(this.hls,t,s,e);if(!g)throw new Error("Invalid response from configured generateRequest filter");t=g.initDataType,s=g.initData?g.initData:null,e.decryptdata.pssh=s?new Uint8Array(s):null}catch(g){if(this.warn(g.message),this.hls&&this.hls.config.debug)throw g}if(s===null)return this.log(`Skipping key-session request for "${i}" (no initData)`),Promise.resolve(e);let o=es(e.decryptdata),c=e.decryptdata.uri;this.log(`Generating key-session request for "${i}" keyId: ${o} URI: ${c} (init data type: ${t} length: ${s.byteLength})`);let l=new Br,h=e._onmessage=g=>{let y=e.mediaKeysSession;if(!y){l.emit("error",new Error("invalid state"));return}let{messageType:p,message:E}=g;this.log(`"${p}" message event for session "${y.sessionId}" message size: ${E.byteLength}`),p==="license-request"||p==="license-renewal"?this.renewLicense(e,E).catch(T=>{l.eventNames().length?l.emit("error",T):this.handleError(T)}):p==="license-release"?e.keySystem===ae.FAIRPLAY&&this.updateKeySession(e,_i("acknowledged")).then(()=>this.removeSession(e)).catch(T=>this.handleError(T)):this.warn(`unhandlLine truncated
+Schedule: ${c.map(y=>ke(y))} pos: ${this.timelinePos}`),h.length&&this.log(`Removed events ${h}`);let d=null,f=null;a&&(d=this.updateItem(a,this.timelinePos),this.itemsMatch(a,d)?this.playingItem=d:this.waitingItem=this.endedItem=null),this.waitingItem=this.updateItem(this.waitingItem),this.endedItem=this.updateItem(this.endedItem);let g=this.bufferingItem;if(g&&(f=this.updateItem(g,this.bufferedPos),this.itemsMatch(g,f)?this.bufferingItem=f:g.event&&(this.bufferingItem=this.playingItem,this.clearInterstitial(g.event,null))),s.forEach(y=>{y.assetList.forEach(p=>{this.clearAssetPlayer(p.identifier,null)})}),this.playerQueue.forEach(y=>{if(y.interstitial.appendInPlace){let p=y.assetItem.timelineStart,E=y.timelineOffset-p;if(E)try{y.timelineOffset=p}catch(T){Math.abs(E)>vt&&this.warn(`${T} ("${y.assetId}" ${y.timelineOffset}->${p})`)}}}),u||i){if(this.hls.trigger(m.INTERSTITIALS_UPDATED,{events:o.slice(0),schedule:c.slice(0),durations:l,removedIds:h}),this.isInterstitial(a)&&h.includes(a.event.identifier)){this.warn(`Interstitial "${a.event.identifier}" removed while playing`),this.primaryFallback(a.event);return}a&&this.trimInPlace(d,a),g&&f!==d&&this.trimInPlace(f,g),this.checkBuffer()}},this.hls=e,this.HlsPlayerClass=t,this.assetListLoader=new cr(e),this.schedule=new lr(this.onScheduleUpdate,e.logger),this.registerListeners()}registerListeners(){let e=this.hls;e&&(e.on(m.MEDIA_ATTACHING,this.onMediaAttaching,this),e.on(m.MEDIA_ATTACHED,this.onMediaAttached,this),e.on(m.MEDIA_DETACHING,this.onMediaDetaching,this),e.on(m.MANIFEST_LOADING,this.onManifestLoading,this),e.on(m.LEVEL_UPDATED,this.onLevelUpdated,this),e.on(m.AUDIO_TRACK_SWITCHING,this.onAudioTrackSwitching,this),e.on(m.AUDIO_TRACK_UPDATED,this.onAudioTrackUpdated,this),e.on(m.SUBTITLE_TRACK_SWITCH,this.onSubtitleTrackSwitch,this),e.on(m.SUBTITLE_TRACK_UPDATED,this.onSubtitleTrackUpdated,this),e.on(m.EVENT_CUE_ENTER,this.onInterstitialCueEnter,this),e.on(m.ASSET_LIST_LOADED,this.onAssetListLoaded,this),e.on(m.BUFFER_APPENDED,this.onBufferAppended,this),e.on(m.BUFFER_FLUSHED,this.onBufferFlushed,this),e.on(m.BUFFERED_TO_END,this.onBufferedToEnd,this),e.on(m.MEDIA_ENDED,this.onMediaEnded,this),e.on(m.ERROR,this.onError,this),e.on(m.DESTROYING,this.onDestroying,this))}unregisterListeners(){let e=this.hls;e&&(e.off(m.MEDIA_ATTACHING,this.onMediaAttaching,this),e.off(m.MEDIA_ATTACHED,this.onMediaAttached,this),e.off(m.MEDIA_DETACHING,this.onMediaDetaching,this),e.off(m.MANIFEST_LOADING,this.onManifestLoading,this),e.off(m.LEVEL_UPDATED,this.onLevelUpdated,this),e.off(m.AUDIO_TRACK_SWITCHING,this.onAudioTrackSwitching,this),e.off(m.AUDIO_TRACK_UPDATED,this.onAudioTrackUpdated,this),e.off(m.SUBTITLE_TRACK_SWITCH,this.onSubtitleTrackSwitch,this),e.off(m.SUBTITLE_TRACK_UPDATED,this.onSubtitleTrackUpdated,this),e.off(m.EVENT_CUE_ENTER,this.onInterstitialCueEnter,this),e.off(m.ASSET_LIST_LOADED,this.onAssetListLoaded,this),e.off(m.BUFFER_CODECS,this.onBufferCodecs,this),e.off(m.BUFFER_APPENDED,this.onBufferAppended,this),e.off(m.BUFFER_FLUSHED,this.onBufferFlushed,this),e.off(m.BUFFERED_TO_END,this.onBufferedToEnd,this),e.off(m.MEDIA_ENDED,this.onMediaEnded,this),e.off(m.ERROR,this.onError,this),e.off(m.DESTROYING,this.onDestroying,this))}startLoad(){this.resumeBuffering()}stopLoad(){this.pauseBuffering()}resumeBuffering(){var e;(e=this.getBufferingPlayer())==null||e.resumeBuffering()}pauseBuffering(){var e;(e=this.getBufferingPlayer())==null||e.pauseBuffering()}destroy(){this.unregisterListeners(),this.stopLoad(),this.assetListLoader&&this.assetListLoader.destroy(),this.emptyPlayerQueue(),this.clearScheduleState(),this.schedule&&this.schedule.destroy(),this.media=this.detachedData=this.mediaSelection=this.requiredTracks=this.altSelection=this.schedule=this.manager=null,this.hls=this.HlsPlayerClass=this.log=null,this.assetListLoader=null,this.onPlay=this.onPause=this.onSeeking=this.onTimeupdate=null,this.onScheduleUpdate=null}onDestroying(){let e=this.primaryMedia||this.media;e&&this.removeMediaListeners(e)}removeMediaListeners(e){xe(e,"play",this.onPlay),xe(e,"pause",this.onPause),xe(e,"seeking",this.onSeeking),xe(e,"timeupdate",this.onTimeupdate)}onMediaAttaching(e,t){let s=this.media=t.media;Se(s,"seeking",this.onSeeking),Se(s,"timeupdate",this.onTimeupdate),Se(s,"play",this.onPlay),Se(s,"pause",this.onPause)}onMediaAttached(e,t){let s=this.effectivePlayingItem,i=this.detachedData;if(this.detachedData=null,s===null)this.checkStart();else if(!i){this.clearScheduleState();let r=this.findItemIndex(s);this.setSchedulePosition(r)}}clearScheduleState(){this.log("clear schedule state"),this.playingItem=this.bufferingItem=this.waitingItem=this.endedItem=this.playingAsset=this.endedAsset=this.bufferingAsset=null}onMediaDetaching(e,t){let s=!!t.transferMedia,i=this.media;if(this.media=null,!s&&(i&&this.removeMediaListeners(i),this.detachedData)){let r=this.getBufferingPlayer();r&&(this.log(`Removing schedule state for detachedData and ${r}`),this.playingAsset=this.e
Line truncated
+`)),s}getTextAndFormat(){return this.rows}},Ms=class{constructor(e,t,s){this.chNr=void 0,this.outputFilter=void 0,this.mode=void 0,this.verbose=void 0,this.displayedMemory=void 0,this.nonDisplayedMemory=void 0,this.lastOutputScreen=void 0,this.currRollUpRow=void 0,this.writeScreen=void 0,this.cueStartTime=void 0,this.logger=void 0,this.chNr=e,this.outputFilter=t,this.mode=null,this.verbose=0,this.displayedMemory=new kt(s),this.nonDisplayedMemory=new kt(s),this.lastOutputScreen=new kt(s),this.currRollUpRow=this.displayedMemory.rows[we-1],this.writeScreen=this.displayedMemory,this.mode=null,this.cueStartTime=null,this.logger=s}reset(){this.mode=null,this.displayedMemory.reset(),this.nonDisplayedMemory.reset(),this.lastOutputScreen.reset(),this.outputFilter.reset(),this.currRollUpRow=this.displayedMemory.rows[we-1],this.writeScreen=this.displayedMemory,this.mode=null,this.cueStartTime=null}getHandler(){return this.outputFilter}setHandler(e){this.outputFilter=e}setPAC(e){this.writeScreen.setPAC(e)}setBkgData(e){this.writeScreen.setBkgData(e)}setMode(e){e!==this.mode&&(this.mode=e,this.logger.log(2,()=>"MODE="+e),this.mode==="MODE_POP-ON"?this.writeScreen=this.nonDisplayedMemory:(this.writeScreen=this.displayedMemory,this.writeScreen.reset()),this.mode!=="MODE_ROLL-UP"&&(this.displayedMemory.nrRollUpRows=null,this.nonDisplayedMemory.nrRollUpRows=null),this.mode=e)}insertChars(e){for(let s=0;s<e.length;s++)this.writeScreen.insertChar(e[s]);let t=this.writeScreen===this.displayedMemory?"DISP":"NON_DISP";this.logger.log(2,()=>t+": "+this.writeScreen.getDisplayText(!0)),(this.mode==="MODE_PAINT-ON"||this.mode==="MODE_ROLL-UP")&&(this.logger.log(1,()=>"DISPLAYED: "+this.displayedMemory.getDisplayText(!0)),this.outputDataUpdate())}ccRCL(){this.logger.log(2,"RCL - Resume Caption Loading"),this.setMode("MODE_POP-ON")}ccBS(){this.logger.log(2,"BS - BackSpace"),this.mode!=="MODE_TEXT"&&(this.writeScreen.backSpace(),this.writeScreen===this.displayedMemory&&this.outputDataUpdate())}ccAOF(){}ccAON(){}ccDER(){this.logger.log(2,"DER- Delete to End of Row"),this.writeScreen.clearToEndOfRow(),this.outputDataUpdate()}ccRU(e){this.logger.log(2,"RU("+e+") - Roll Up"),this.writeScreen=this.displayedMemory,this.setMode("MODE_ROLL-UP"),this.writeScreen.setRollUpRows(e)}ccFON(){this.logger.log(2,"FON - Flash On"),this.writeScreen.setPen({flash:!0})}ccRDC(){this.logger.log(2,"RDC - Resume Direct Captioning"),this.setMode("MODE_PAINT-ON")}ccTR(){this.logger.log(2,"TR"),this.setMode("MODE_TEXT")}ccRTD(){this.logger.log(2,"RTD"),this.setMode("MODE_TEXT")}ccEDM(){this.logger.log(2,"EDM - Erase Displayed Memory"),this.displayedMemory.reset(),this.outputDataUpdate(!0)}ccCR(){this.logger.log(2,"CR - Carriage Return"),this.writeScreen.rollUp(),this.outputDataUpdate(!0)}ccENM(){this.logger.log(2,"ENM - Erase Non-displayed Memory"),this.nonDisplayedMemory.reset()}ccEOC(){if(this.logger.log(2,"EOC - End Of Caption"),this.mode==="MODE_POP-ON"){let e=this.displayedMemory;this.displayedMemory=this.nonDisplayedMemory,this.nonDisplayedMemory=e,this.writeScreen=this.nonDisplayedMemory,this.logger.log(1,()=>"DISP: "+this.displayedMemory.getDisplayText())}this.outputDataUpdate(!0)}ccTO(e){this.logger.log(2,"TO("+e+") - Tab Offset"),this.writeScreen.moveCursor(e)}ccMIDROW(e){let t={flash:!1};if(t.underline=e%2===1,t.italics=e>=46,t.italics)t.foreground="white";else{let s=Math.floor(e/2)-16,i=["white","green","blue","cyan","red","yellow","magenta"];t.foreground=i[s]}this.logger.log(2,"MIDROW: "+re(t)),this.writeScreen.setPen(t)}outputDataUpdate(e=!1){let t=this.logger.time;t!==null&&this.outputFilter&&(this.cueStartTime===null&&!this.displayedMemory.isEmpty()?this.cueStartTime=t:this.displayedMemory.equals(this.lastOutputScreen)||(this.outputFilter.newCue(this.cueStartTime,t,this.lastOutputScreen),e&&this.outputFilter.dispatchCue&&this.outputFilter.dispatchCue(),this.cueStartTime=this.displayedMemory.isEmpty()?null:t),this.lastOutputScreen.copy(this.displayedMemory))}cueSplitAtTime(e){this.outputFilter&&(this.displayedMemory.isEmpty()||(this.outputFilter.newCue&&this.outputFilter.newCue(this.cueStartTime,e,this.displayedMemory),this.cueStartTime=e))}},Os=class{constructor(e,t,s){this.channels=void 0,this.currentChannel=0,this.cmdHistory=cu(),this.logger=void 0;let i=this.logger=new fr;this.channels=[null,new Ms(e,t,i),new Ms(e+1,s,i)]}getHandler(e){return this.channels[e].getHandler()}setHandler(e,t){this.channels[e].setHandler(t)}addData(e,t){this.logger.time=e;for(let s=0;s<t.length;s+=2){let i=t[s]&127,r=t[s+1]&127,a=!1,o=null;if(i===0&&r===0)continue;this.logger.log(3,()=>"["+st([t[s],t[s+1]])+"] -> ("+st([i,r])+")");let c=this.cmdHistory;if(i>=16&&i<=31){if(lu(i,r,c)){ts(null,null,c),this.logger.log(3,()=>"Repeated command ("+st([i,r])+") is dropped");continue}ts(i,r,this.cmdHistory),a=this.parseCmd(i,r),a||(a=this.parseMidrow(i,r)),a||(a=this.parsePAC(i,r)),a||(a=this.parseBackgroundAttributes(i,r))}else ts(null,null,c);if(!a&&(o=this.parseChars(i,r)
Line truncated
+`)}var Tr=class{constructor(){this.state="INITIAL",this.buffer="",this.decoder=new pr,this.regionList=[],this.cue=null,this.oncue=void 0,this.onparsingerror=void 0,this.onflush=void 0}parse(e){let t=this;e&&(t.buffer+=t.decoder.decode(e,{stream:!0}));function s(){let r=t.buffer,a=0;for(r=_o(r);a<r.length&&r[a]!=="\r"&&r[a]!==`
+`;)++a;let o=r.slice(0,a);return r[a]==="\r"&&++a,r[a]===`
+`&&++a,t.buffer=r.slice(a),o}function i(r){bo(r,function(a,o){},/:/)}try{let r="";if(t.state==="INITIAL"){if(!/\r\n|\n/.test(t.buffer))return this;r=s();let o=r.match(/^()?WEBVTT([ \t].*)?$/);if(!(o!=null&&o[0]))throw new Error("Malformed WebVTT signature.");t.state="HEADER"}let a=!1;for(;t.buffer;){if(!/\r\n|\n/.test(t.buffer))return this;switch(a?a=!1:r=s(),t.state){case"HEADER":/:/.test(r)?i(r):r||(t.state="ID");continue;case"NOTE":r||(t.state="ID");continue;case"ID":if(/^NOTE($|[ \t])/.test(r)){t.state="NOTE";break}if(!r)continue;if(t.cue=new Wr(0,0,""),t.state="CUE",r.indexOf("-->")===-1){t.cue.id=r;continue}case"CUE":if(!t.cue){t.state="BADCUE";continue}try{hu(r,t.cue,t.regionList)}catch{t.cue=null,t.state="BADCUE";continue}t.state="CUETEXT";continue;case"CUETEXT":{let o=r.indexOf("-->")!==-1;if(!r||o&&(a=!0)){t.oncue&&t.cue&&t.oncue(t.cue),t.cue=null,t.state="ID";continue}if(t.cue===null)continue;t.cue.text&&(t.cue.text+=`
+`),t.cue.text+=r}continue;case"BADCUE":r||(t.state="ID")}}}catch{t.state==="CUETEXT"&&t.cue&&t.oncue&&t.oncue(t.cue),t.cue=null,t.state=t.state==="INITIAL"?"BADWEBVTT":"BADCUE"}return this}flush(){let e=this;try{if((e.cue||e.state==="HEADER")&&(e.buffer+=`
+
+`,e.parse()),e.state==="INITIAL"||e.state==="BADWEBVTT")throw new Error("Malformed WebVTT signature.")}catch(t){e.onparsingerror&&e.onparsingerror(t)}return e.onflush&&e.onflush(),this}},uu=/\r\n|\n\r|\n|\r/g,ri=function(e,t,s=0){return e.slice(s,s+t.length)===t},du=function(e){let t=parseInt(e.slice(-3)),s=parseInt(e.slice(-6,-4)),i=parseInt(e.slice(-9,-7)),r=e.length>9?parseInt(e.substring(0,e.indexOf(":"))):0;if(!O(t)||!O(s)||!O(i)||!O(r))throw Error(`Malformed X-TIMESTAMP-MAP: Local:${e}`);return t+=1e3*s,t+=60*1e3*i,t+=3600*1e3*r,t};function qr(n,e,t){return Ct(n.toString())+Ct(e.toString())+Ct(t)}var fu=function(e,t,s){let i=e[t],r=e[i.prevCC];if(!r||!r.new&&i.new){e.ccOffset=e.presentationOffset=i.start,i.new=!1;return}for(;(a=r)!=null&&a.new;){var a;e.ccOffset+=i.start-r.start,i.new=!1,i=r,r=e[i.prevCC]}e.presentationOffset=s};function gu(n,e,t,s,i,r,a){let o=new Tr,c=be(new Uint8Array(n)).trim().replace(uu,`
+`).split(`
+`),l=[],h=e?Yc(e.baseTime,e.timescale):0,u="00:00.000",d=0,f=0,g,y=!0;o.oncue=function(p){let E=t[s],T=t.ccOffset,S=(d-h)/9e4;if(E!=null&&E.new&&(f!==void 0?T=t.ccOffset=E.start:fu(t,s,S)),S){if(!e){g=new Error("Missing initPTS for VTT MPEGTS");return}T=S-t.presentationOffset}let v=p.endTime-p.startTime,x=Le((p.startTime+T-f)*9e4,i*9e4)/9e4;p.startTime=Math.max(x,0),p.endTime=Math.max(x+v,0);let _=p.text.trim();p.text=decodeURIComponent(encodeURIComponent(_)),p.id||(p.id=qr(p.startTime,p.endTime,_)),p.endTime>0&&l.push(p)},o.onparsingerror=function(p){g=p},o.onflush=function(){if(g){a(g);return}r(l)},c.forEach(p=>{if(y)if(ri(p,"X-TIMESTAMP-MAP=")){y=!1,p.slice(16).split(",").forEach(E=>{ri(E,"LOCAL:")?u=E.slice(6):ri(E,"MPEGTS:")&&(d=parseInt(E.slice(7)))});try{f=du(u)/1e3}catch(E){g=E}return}else p===""&&(y=!1);o.parse(p+`
+`)}),o.flush()}var ni="stpp.ttml.im1t",Do=/^(\d{2,}):(\d{2}):(\d{2}):(\d{2})\.?(\d+)?$/,Po=/^(\d*(?:\.\d*)?)(h|m|s|ms|f|t)$/,mu={left:"start",center:"center",right:"end",start:"start",end:"end"};function ia(n,e,t,s){let i=X(new Uint8Array(n),["mdat"]);if(i.length===0){s(new Error("Could not parse IMSC1 mdat"));return}let r=i.map(o=>be(o)),a=Hc(e.baseTime,1,e.timescale);try{r.forEach(o=>t(pu(o,a)))}catch(o){s(o)}}function pu(n,e){let i=new DOMParser().parseFromString(n,"text/xml").getElementsByTagName("tt")[0];if(!i)throw new Error("Invalid ttml");let r={frameRate:30,subFrameRate:1,frameRateMultiplier:0,tickRate:0},a=Object.keys(r).reduce((u,d)=>(u[d]=i.getAttribute(`ttp:${d}`)||r[d],u),{}),o=i.getAttribute("xml:space")!=="preserve",c=ra(ai(i,"styling","style")),l=ra(ai(i,"layout","region")),h=ai(i,"body","[begin]");return[].map.call(h,u=>{let d=Co(u,o);if(!d||!u.hasAttribute("begin"))return null;let f=li(u.getAttribute("begin"),a),g=li(u.getAttribute("dur"),a),y=li(u.getAttribute("end"),a);if(f===null)throw na(u);if(y===null){if(g===null)throw na(u);y=f+g}let p=new Wr(f-e,y-e,d);p.id=qr(p.startTime,p.endTime,p.text);let E=l[u.getAttribute("region")],T=c[u.getAttribute("style")],S=yu(E,T,c),{textAlign:v}=S;if(v){let x=mu[v];x&&(p.lineAlign=x),p.align=v}return se(p,S),p}).filter(u=>u!==null)}function ai(n,e,t){let s=n.getElementsByTagName(e)[0];return s?[].slice.call(s.querySelectorAll(t)):[]}function ra(n){return n.reduce((e,t)=>{let s=t.getAttribute("xml:id");return s&&(e[s]=t),e},{})}function Co(n,e){return[].slice.call(n.childNodes).reduce((t,s,i)=>{var r;return s.nodeName==="br"&&i?t+`
+`:(r=s.childNodes)!=null&&r.length?Co(s,e):e?t+s.textContent.trim().replace(/\s+/g," "):t+s.textContent},"")}function yu(n,e,t){let s="http://www.w3.org/ns/ttml#styling",i=null,r=["displayAlign","textAlign","color","backgroundColor","fontSize","fontFamily"],a=n!=null&&n.hasAttribute("style")?n.getAttribute("style"):null;return a&&t.hasOwnProperty(a)&&(i=t[a]),r.reduce((o,c)=>{let l=oi(e,s,c)||oi(n,s,c)||oi(i,s,c);return l&&(o[c]=l),o},{})}function oi(n,e,t){return n&&n.hasAttributeNS(e,t)?n.getAttributeNS(e,t):null}function na(n){return new Error(`Could not parse ttml timestamp ${n}`)}function li(n,e){if(!n)return null;let t=Ro(n);return t===null&&(Do.test(n)?t=Eu(n,e):Po.test(n)&&(t=Tu(n,e))),t}function Eu(n,e){let t=Do.exec(n),s=(t[4]|0)+(t[5]|0)/e.subFrameRate;return(t[1]|0)*3600+(t[2]|0)*60+(t[3]|0)+s/e.frameRate}function Tu(n,e){let t=Po.exec(n),s=Number(t[1]);switch(t[2]){case"h":return s*3600;case"m":return s*60;case"ms":return s*1e3;case"f":return s/e.frameRate;case"t":return s/e.tickRate}return s}var yt=class{constructor(e,t){this.timelineController=void 0,this.cueRanges=[],this.trackName=void 0,this.startTime=null,this.endTime=null,this.screen=null,this.timelineController=e,this.trackName=t}dispatchCue(){this.startTime!==null&&(this.timelineController.addCues(this.trackName,this.startTime,this.endTime,this.screen,this.cueRanges),this.startTime=null)}newCue(e,t,s){(this.startTime===null||this.startTime>e)&&(this.startTime=e),this.endTime=t,this.screen=s,this.timelineController.createCaptionsTrack(this.trackName)}reset(){this.cueRanges=[],this.startTime=null}},Sr=class{constructor(e){this.hls=void 0,this.media=null,this.config=void 0,this.enabled=!0,this.Cues=void 0,this.textTracks=[],this.tracks=[],this.initPTS=[],this.unparsedVttFrags=[],this.captionsTracks={},this.nonNativeCaptionsTracks={},this.cea608Parser1=void 0,this.cea608Parser2=void 0,this.lastCc=-1,this.lastSn=-1,this.lastPartIndex=-1,this.prevCC=-1,this.vttCCs=oa(),this.captionsProperties=void 0,this.hls=e,this.config=e.config,this.Cues=e.config.cueHandler,this.captionsProperties={textTrack1:{label:this.config.captionsTextTrack1Label,languageCode:this.config.captionsTextTrack1LanguageCode},textTrack2:{label:this.config.captionsTextTrack2Label,languageCode:this.config.captionsTextTrack2LanguageCode},textTrack3:{label:this.config.captionsTextTrack3Label,languageCode:this.config.captionsTextTrack3LanguageCode},textTrack4:{label:this.config.captionsTextTrack4Label,languageCode:this.config.captionsTextTrack4LanguageCode}},e.on(m.MEDIA_ATTACHING,this.onMediaAttaching,this),e.on(m.MEDIA_DETACHING,this.onMediaDetaching,this),e.on(m.MANIFEST_LOADING,this.onManifestLoading,this),e.on(m.MANIFEST_LOADED,this.onManifestLoaded,this),e.on(m.SUBTITLE_TRACKS_UPDATED,this.onSubtitleTracksUpdated,this),e.on(m.FRAG_LOADING,this.onFragLoading,this),e.on(m.FRAG_LOADED,this.onFragLoaded,this),e.on(m.FRAG_PARSING_USERDATA,this.onFragParsingUserdata,this),e.on(m.FRAG_DECRYPTED,this.onFragDecrypted,this),e.on(m.INIT_PTS_FOUND,this.onInitPtsFound,this),e.on(m.SUBTITLE_TRACKS_CLEARED,this.onSubtitleTracksCleared,this),e.on(m.BUFFER_FLUSHING,this.onBufferFlushing,this)}destroy(){let{hls:e}=this;e.off(m.MEDIA_ATTACHING,this.onMediaAttaching,this),e.off(m.MEDIA_DETACHING,this.onMediaDetaching,this),e.off(m.MANIFEST_LOADING,this.onManifestLoading,this),e.off(m.MANIFEST_LOADED,this.onManifestLoaded,this),e.off(m.SUBTITLE_TRACKS_UPDATED,this.onSubtitleTracksUpdated,this),e.off(m.FRAG_LOADING,this.onFragLoading,this),e.off(m.FRAG_LOADED,this.onFragLoaded,this),e.off(m.FRAG_PARSING_USERDATA,this.onFragParsingUserdata,this),e.off(m.FRAG_DECRYPTED,this.onFragDecrypted,this),e.off(m.INIT_PTS_FOUND,this.onInitPtsFound,this),e.off(m.SUBTITLE_TRACKS_CLEARED,this.onSubtitleTracksCleared,this),e.off(m.BUFFER_FLUSHING,this.onBufferFlushing,this),this.hls=this.config=this.media=null,this.cea608Parser1=this.cea608Parser2=void 0}initCea608Parsers(){let e=new yt(this,"textTrack1"),t=new yt(this,"textTrack2"),s=new yt(this,"textTrack3"),i=new yt(this,"textTrack4");this.cea608Parser1=new Os(1,e,t),this.cea608Parser2=new Os(3,s,i)}addCues(e,t,s,i,r){let a=!1;for(let o=r.length;o--;){let c=r[o],l=Su(c[0],c[1],t,s);if(l>=0&&(c[0]=Math.min(c[0],t),c[1]=Math.max(c[1],s),a=!0,l/(s-t)>.5))return}if(a||r.push([t,s]),this.config.renderTextTracksNatively){let o=this.captionsTracks[e];this.Cues.newCue(o,t,s,i)}else{let o=this.Cues.newCue(null,t,s,i);this.hls.trigger(m.CUES_PARSED,{type:"captions",cues:o,track:e})}}onInitPtsFound(e,{frag:t,id:s,initPTS:i,timescale:r,trackId:a}){let{unparsedVttFrags:o}=this;s===N.MAIN&&(this.initPTS[t.cc]={baseTime:i,timescale:r,trackId:a}),o.length&&(this.unparsedVttFrags=[],o.forEach(c=>{this.initPTS[c.frag.cc]?this.onFragLoaded(m.FRAG_LOADED,c):this.hls.trigger(m.SUBTITLE_FRAG_PROCESSED,{success:!1,frag:c.frag,error:new Error("Subtitle discontinuity domain does not match main")})}))}getExistingTrack(e,t){let{media:s}=this;if(s)for(let i=0;i<s.textTracks.length;i+
Line truncated