avbridge 2.10.0 → 2.11.0

package/dist/subtitles-5H24MEBJ.js

@@ -0,0 +1,4 @@
+export { SubtitleOverlay, SubtitleResourceBag, attachSubtitleTracks, discoverSidecars, srtToVtt } from './chunk-EDDWAN2L.js';
+import './chunk-LUFA47FP.js';
+//# sourceMappingURL=subtitles-5H24MEBJ.js.map
+//# sourceMappingURL=subtitles-5H24MEBJ.js.map

package/dist/{subtitles-4T74JRGT.js.map → subtitles-5H24MEBJ.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"subtitles-4T74JRGT.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"subtitles-5H24MEBJ.js"}

package/dist/subtitles-HMVGWTU2.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var chunkWRKO6Q42_cjs = require('./chunk-WRKO6Q42.cjs');
+require('./chunk-QDJLQR53.cjs');
+
+
+
+Object.defineProperty(exports, "SubtitleOverlay", {
+  enumerable: true,
+  get: function () { return chunkWRKO6Q42_cjs.SubtitleOverlay; }
+});
+Object.defineProperty(exports, "SubtitleResourceBag", {
+  enumerable: true,
+  get: function () { return chunkWRKO6Q42_cjs.SubtitleResourceBag; }
+});
+Object.defineProperty(exports, "attachSubtitleTracks", {
+  enumerable: true,
+  get: function () { return chunkWRKO6Q42_cjs.attachSubtitleTracks; }
+});
+Object.defineProperty(exports, "discoverSidecars", {
+  enumerable: true,
+  get: function () { return chunkWRKO6Q42_cjs.discoverSidecars; }
+});
+Object.defineProperty(exports, "srtToVtt", {
+  enumerable: true,
+  get: function () { return chunkWRKO6Q42_cjs.srtToVtt; }
+});
+//# sourceMappingURL=subtitles-HMVGWTU2.cjs.map
+//# sourceMappingURL=subtitles-HMVGWTU2.cjs.map

package/dist/{subtitles-QUH4LPI4.cjs.map → subtitles-HMVGWTU2.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"subtitles-QUH4LPI4.cjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"subtitles-HMVGWTU2.cjs"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "avbridge",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Play and convert arbitrary video files in the browser. Native, remux, hybrid, fallback, and transcode — one API.",
   "license": "MIT",
   "author": "Keishi Hattori",

package/src/element/avbridge-player.ts

@@ -39,7 +39,7 @@ function formatTime(sec: number): string {
 }
 
 const PLAYBACK_SPEEDS = [0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75, 2] as const;
-const CONTROLS_HIDE_MS = 3000;
+const DEFAULT_CONTROLS_HIDE_MS = 3000;
 
 type PlayerState = "idle" | "loading" | "playing" | "paused" | "buffering" | "ended" | "error";
 
@@ -101,6 +101,8 @@ export class AvbridgePlayerElement extends HTMLElement {
   private _state: PlayerState = "idle";
   private _controlsTimer: ReturnType<typeof setTimeout> | null = null;
   private _settingsOpen = false;
+  private _activeAudioTrackId: number | null = null;
+  private _activeSubtitleTrackId: number | null = null;
   private _userSeeking = false;
   private _holdTimer: ReturnType<typeof setTimeout> | null = null;
   private _holdSpeedActive = false;
@@ -435,6 +437,11 @@ export class AvbridgePlayerElement extends HTMLElement {
     return frac * (this._video.duration || 0);
   }
 
+  /** Seekbar width below which drag-to-scrub seeks in real-time (vs
+   *  preview-only). On narrow bars precise positioning is hard, so
+   *  immediate video feedback is more useful than a time tooltip. */
+  private static readonly SCRUB_WIDTH_THRESHOLD = 400;
+
   private _onSeekPointerDown(e: PointerEvent): void {
     // Ignore synthetic clicks originating from the input's own handling
     if (e.button !== 0 && e.pointerType === "mouse") return;
@@ -444,16 +451,32 @@ export class AvbridgePlayerElement extends HTMLElement {
     seekBar.setPointerCapture(e.pointerId);
     seekBar.setAttribute("data-seeking", "");
 
+    // Decide scrub mode based on physical width.
+    const scrubMode = seekBar.getBoundingClientRect().width < AvbridgePlayerElement.SCRUB_WIDTH_THRESHOLD;
+    let lastScrubCommit = 0;
+
     const initial = this._timeFromSeekPointer(e.clientX);
     this._seekInput.value = String(initial);
     this._onSeekInput();
     this._updateSeekTooltip(e.clientX);
+    if (scrubMode) this._onSeekCommit();
 
     const onMove = (ev: PointerEvent) => {
       const t = this._timeFromSeekPointer(ev.clientX);
       this._seekInput.value = String(t);
       this._onSeekInput();
       this._updateSeekTooltip(ev.clientX);
+      // In scrub mode, commit seeks throttled to ~4 Hz so we don't
+      // overwhelm the seek pipeline (especially on canvas strategies
+      // where each seek restarts the decoder pump).
+      if (scrubMode) {
+        const now = performance.now();
+        if (now - lastScrubCommit > 250) {
+          lastScrubCommit = now;
+          this._onSeekCommit();
+          this._userSeeking = true; // keep seeking flag live
+        }
+      }
     };
     const onUp = (ev: PointerEvent) => {
       const t = this._timeFromSeekPointer(ev.clientX);
@@ -589,21 +612,29 @@ export class AvbridgePlayerElement extends HTMLElement {
     // Audio tracks
     const audios = this._video.audioTracks ?? [];
     if (audios.length > 1) {
+      const activeAudioId = this._activeAudioTrackId ?? audios[0]?.id;
+      const activeAudio = audios.find((t: { id: number }) => t.id === activeAudioId) ?? audios[0];
+      const audioValue = activeAudio?.language ?? `Track ${activeAudio?.id ?? 1}`;
       let audioOpts = "";
       for (const t of audios) {
-        audioOpts += `<option value="${t.id}">${t.language ?? `Track ${t.id}`}</option>`;
+        const sel = t.id === activeAudioId ? " selected" : "";
+        audioOpts += `<option value="${t.id}"${sel}>${t.language ?? `Track ${t.id}`}</option>`;
       }
-      sections.push(selectRow("Audio", audios[0]?.language ?? "Track 1", audioOpts, `data-action="audio"`));
+      sections.push(selectRow("Audio", audioValue, audioOpts, `data-action="audio"`));
     }
 
     // Subtitle tracks
     const subs = this._video.subtitleTracks ?? [];
     if (subs.length > 0) {
-      let subOpts = `<option value="-1" selected>Off</option>`;
+      const activeSubId = this._activeSubtitleTrackId;
+      const activeSub = activeSubId != null ? subs.find((t: { id: number }) => t.id === activeSubId) : null;
+      const subValue = activeSub ? (activeSub.language ?? `Track ${activeSub.id}`) : "Off";
+      let subOpts = `<option value="-1"${activeSubId == null ? " selected" : ""}>Off</option>`;
       for (const t of subs) {
-        subOpts += `<option value="${t.id}">${t.language ?? `Track ${t.id}`}</option>`;
+        const sel = t.id === activeSubId ? " selected" : "";
+        subOpts += `<option value="${t.id}"${sel}>${t.language ?? `Track ${t.id}`}</option>`;
       }
-      sections.push(selectRow("Subtitles", "Off", subOpts, `data-action="subtitle"`));
+      sections.push(selectRow("Subtitles", subValue, subOpts, `data-action="subtitle"`));
     }
 
     // Fit mode — opt-in via the `show-fit` attribute
@@ -657,11 +688,15 @@ export class AvbridgePlayerElement extends HTMLElement {
             this._video.playbackRate = Number(val);
             break;
           case "audio":
+            this._activeAudioTrackId = Number(val);
             void this._video.setAudioTrack(Number(val));
             break;
-          case "subtitle":
-            void this._video.setSubtitleTrack(Number(val) >= 0 ? Number(val) : null);
+          case "subtitle": {
+            const subId = Number(val);
+            this._activeSubtitleTrackId = subId >= 0 ? subId : null;
+            void this._video.setSubtitleTrack(subId >= 0 ? subId : null);
             break;
+          }
           case "fit":
             this.setAttribute("fit", val);
             break;
@@ -762,16 +797,28 @@ export class AvbridgePlayerElement extends HTMLElement {
     this.showControls();
   }
 
-  private _scheduleHide(durationMs: number = CONTROLS_HIDE_MS): void {
+  private _scheduleHide(durationMs?: number): void {
+    const ms = durationMs ?? this._getControlsTimeout();
     if (this._controlsTimer) clearTimeout(this._controlsTimer);
     if (this._state !== "playing" && this._state !== "buffering") return;
     if (this._settingsOpen) return;
+    // A timeout of 0 or negative means "never hide" (controls always visible).
+    if (ms <= 0) return;
     this._controlsTimer = setTimeout(() => {
       if (this._state === "playing") {
         this.setAttribute("data-controls-hidden", "");
         this._toolbarTop.setAttribute("data-visible", "false");
       }
-    }, durationMs);
+    }, ms);
+  }
+
+  /** Read the controls-timeout attribute. 0 or negative = never hide.
+   *  Unset = default 3000ms. */
+  private _getControlsTimeout(): number {
+    const attr = this.getAttribute("controls-timeout");
+    if (attr == null) return DEFAULT_CONTROLS_HIDE_MS;
+    const n = Number(attr);
+    return Number.isFinite(n) ? n : DEFAULT_CONTROLS_HIDE_MS;
   }
 
   // Strategy is visible in Stats for Nerds, no badge in controls bar.
@@ -786,6 +833,9 @@ export class AvbridgePlayerElement extends HTMLElement {
 
   /** Track whether the last interaction was touch so click handler can skip. */
   private _lastPointerTypeWasTouch = false;
+  /** True for ~50ms after a touch double-tap was handled, so the
+   *  synthetic dblclick from the browser doesn't also fire fullscreen. */
+  private _touchDoubleTapConsumed = false;
 
   /** True if the event's composed path passes through consumer-slotted
    *  content (toolbar or content-overlay). Slotted content lives in the
@@ -830,6 +880,11 @@ export class AvbridgePlayerElement extends HTMLElement {
   private _onContainerDblClick(e: MouseEvent): void {
     if ((e.target as HTMLElement).closest?.(".avp-controls, .avp-settings")) return;
     if (this._isSlottedContentEvent(e)) return;
+    // On touch devices, the browser synthesizes a dblclick after two
+    // rapid taps. But we already handled the double-tap in _onPointerUp
+    // (which does ff/rw on sides, fullscreen in center). Skip the
+    // synthetic dblclick so both don't fire.
+    if (this._touchDoubleTapConsumed) return;
     // Cancel the pending single-click play/pause
     if (this._tapTimer) { clearTimeout(this._tapTimer); this._tapTimer = null; }
     this._toggleFullscreen();
@@ -877,6 +932,10 @@ export class AvbridgePlayerElement extends HTMLElement {
       } else {
         this._toggleFullscreen();
       }
+      // Prevent the synthetic dblclick (fired ~50ms later by the
+      // browser) from also toggling fullscreen.
+      this._touchDoubleTapConsumed = true;
+      setTimeout(() => { this._touchDoubleTapConsumed = false; }, 100);
       this._lastTapTime = 0;
       return;
     }
@@ -918,6 +977,14 @@ export class AvbridgePlayerElement extends HTMLElement {
 
   // ── Keyboard shortcuts ─────────────────────────────────────────────────
 
+  /** Duration of one frame in seconds, derived from diagnostics fps or
+   *  a 30fps default. Used for frame-step shortcuts (`,` / `.`). */
+  private _frameDuration(): number {
+    const diag = this._video.getDiagnostics() as { fps?: number } | null;
+    const fps = diag?.fps && diag.fps > 0 ? diag.fps : 30;
+    return 1 / fps;
+  }
+
   private _onKeydown(e: KeyboardEvent): void {
     // Don't intercept if the user is typing in an input
     if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
@@ -964,6 +1031,21 @@ export class AvbridgePlayerElement extends HTMLElement {
         this._video.playbackRate = Math.max(0.25, this._video.playbackRate - 0.25);
         this._buildSettingsMenu();
         break;
+      case ",":
+        // Frame-back (YouTube-style: , while paused steps back one frame)
+        e.preventDefault();
+        if (!this._video.paused) this._video.pause();
+        this._video.currentTime = Math.max(0, this._video.currentTime - this._frameDuration());
+        break;
+      case ".":
+        // Frame-forward (YouTube-style: . while paused steps forward one frame)
+        e.preventDefault();
+        if (!this._video.paused) this._video.pause();
+        this._video.currentTime = Math.min(
+          this._video.duration || 0,
+          this._video.currentTime + this._frameDuration(),
+        );
+        break;
       case "Escape":
         if (this._settingsOpen) {
           e.preventDefault();

package/src/element/avbridge-subtitles.ts

@@ -0,0 +1,273 @@
+/**
+ * `<avbridge-subtitles>` — scrollable subtitle timeline panel.
+ *
+ * Connects to an `<avbridge-player>` or `<avbridge-video>` via the `for`
+ * attribute (points to the player's `id`) or auto-detects a sibling.
+ * Reads TextTrack cues from the player's inner `<video>`, renders them
+ * as a timestamped list, highlights the active cue, and seeks on click.
+ *
+ * Usage:
+ *   <avbridge-player id="player">...</avbridge-player>
+ *   <avbridge-subtitles for="player"></avbridge-subtitles>
+ */
+
+const HTMLElementCtor: typeof HTMLElement =
+  typeof HTMLElement !== "undefined"
+    ? HTMLElement
+    : (class {} as unknown as typeof HTMLElement);
+
+const STYLES = `
+:host {
+  display: block;
+  font-family: system-ui, -apple-system, sans-serif;
+  font-size: 14px;
+  color: #eee;
+  background: #1a1a1a;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+}
+
+.avs-empty {
+  padding: 16px;
+  opacity: 0.5;
+  text-align: center;
+  font-size: 13px;
+}
+
+.avs-cue {
+  display: flex;
+  gap: 12px;
+  padding: 8px 12px;
+  cursor: pointer;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.06);
+  transition: background 0.1s;
+  align-items: flex-start;
+}
+
+.avs-cue:hover {
+  background: rgba(255, 255, 255, 0.06);
+}
+
+.avs-cue.active {
+  background: rgba(62, 166, 255, 0.12);
+}
+
+.avs-time {
+  flex-shrink: 0;
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+  opacity: 0.5;
+  min-width: 48px;
+  padding-top: 1px;
+}
+
+.avs-cue.active .avs-time {
+  opacity: 0.8;
+  color: #3ea6ff;
+}
+
+.avs-text {
+  flex: 1;
+  min-width: 0;
+  line-height: 1.4;
+  word-break: break-word;
+}
+`;
+
+interface CueEntry {
+  start: number;
+  end: number;
+  text: string;
+  el: HTMLDivElement;
+}
+
+export class AvbridgeSubtitlesElement extends HTMLElementCtor {
+  static readonly observedAttributes = ["for"];
+
+  private _player: HTMLElement | null = null;
+  private _cues: CueEntry[] = [];
+  private _tickTimer: ReturnType<typeof setInterval> | null = null;
+  private _activeCueIndex = -1;
+  private _trackChangeListener: (() => void) | null = null;
+
+  constructor() {
+    super();
+    const shadow = this.attachShadow({ mode: "open" });
+    shadow.innerHTML = `<style>${STYLES}</style><div class="avs-empty">No subtitles loaded</div>`;
+  }
+
+  connectedCallback(): void {
+    this._connectPlayer();
+    this._startTick();
+  }
+
+  disconnectedCallback(): void {
+    this._stopTick();
+    this._disconnectPlayer();
+  }
+
+  attributeChangedCallback(name: string): void {
+    if (name === "for") {
+      this._disconnectPlayer();
+      this._connectPlayer();
+    }
+  }
+
+  // ── Player connection ──────────────────────────────────────────────────
+
+  private _connectPlayer(): void {
+    const forId = this.getAttribute("for");
+    if (forId) {
+      this._player = document.getElementById(forId);
+    } else {
+      // Auto-detect sibling avbridge-player or avbridge-video
+      this._player =
+        this.parentElement?.querySelector("avbridge-player") ??
+        this.parentElement?.querySelector("avbridge-video") ??
+        null;
+    }
+    if (!this._player) return;
+
+    // Listen for trackschange to rebuild the cue list when subtitles
+    // are added/removed dynamically.
+    this._trackChangeListener = () => this._rebuildCues();
+    this._player.addEventListener("trackschange", this._trackChangeListener);
+
+    // Initial build (subtitle may already be loaded).
+    // Defer so the player has time to bootstrap.
+    requestAnimationFrame(() => this._rebuildCues());
+  }
+
+  private _disconnectPlayer(): void {
+    if (this._player && this._trackChangeListener) {
+      this._player.removeEventListener("trackschange", this._trackChangeListener);
+    }
+    this._player = null;
+    this._trackChangeListener = null;
+  }
+
+  private _getVideoElement(): HTMLVideoElement | null {
+    if (!this._player) return null;
+    return (this._player as unknown as { videoElement?: HTMLVideoElement }).videoElement ?? null;
+  }
+
+  // ── Cue list ───────────────────────────────────────────────────────────
+
+  private _rebuildCues(): void {
+    const video = this._getVideoElement();
+    const shadow = this.shadowRoot!;
+    this._cues = [];
+    this._activeCueIndex = -1;
+
+    if (!video) {
+      shadow.innerHTML = `<style>${STYLES}</style><div class="avs-empty">No player connected</div>`;
+      return;
+    }
+
+    // Find the first subtitle/caption track with cues.
+    let track: TextTrack | null = null;
+    for (let i = 0; i < video.textTracks.length; i++) {
+      const t = video.textTracks[i];
+      if ((t.kind === "subtitles" || t.kind === "captions") && t.cues && t.cues.length > 0) {
+        track = t;
+        break;
+      }
+    }
+
+    if (!track || !track.cues || track.cues.length === 0) {
+      shadow.innerHTML = `<style>${STYLES}</style><div class="avs-empty">No subtitle cues available</div>`;
+      // Retry shortly — cues may load async.
+      setTimeout(() => {
+        if (this._cues.length === 0 && this.isConnected) this._rebuildCues();
+      }, 1000);
+      return;
+    }
+
+    // Build the list.
+    const container = document.createElement("div");
+    for (let i = 0; i < track.cues.length; i++) {
+      const cue = track.cues[i] as VTTCue;
+      const el = document.createElement("div");
+      el.className = "avs-cue";
+
+      const timeEl = document.createElement("span");
+      timeEl.className = "avs-time";
+      timeEl.textContent = formatTime(cue.startTime);
+
+      const textEl = document.createElement("span");
+      textEl.className = "avs-text";
+      textEl.textContent = cue.text.replace(/<[^>]+>/g, "");
+
+      el.appendChild(timeEl);
+      el.appendChild(textEl);
+
+      const startTime = cue.startTime;
+      el.addEventListener("click", () => {
+        if (this._player) {
+          (this._player as unknown as { currentTime: number }).currentTime = startTime;
+        }
+      });
+
+      container.appendChild(el);
+      this._cues.push({ start: cue.startTime, end: cue.endTime, text: cue.text, el });
+    }
+
+    shadow.innerHTML = `<style>${STYLES}</style>`;
+    shadow.appendChild(container);
+  }
+
+  // ── Active cue tracking ────────────────────────────────────────────────
+
+  private _startTick(): void {
+    if (this._tickTimer) return;
+    this._tickTimer = setInterval(() => this._tick(), 250);
+  }
+
+  private _stopTick(): void {
+    if (this._tickTimer) {
+      clearInterval(this._tickTimer);
+      this._tickTimer = null;
+    }
+  }
+
+  private _tick(): void {
+    if (this._cues.length === 0 || !this._player) return;
+    const currentTime = (this._player as unknown as { currentTime: number }).currentTime ?? 0;
+
+    let newActive = -1;
+    for (let i = 0; i < this._cues.length; i++) {
+      const c = this._cues[i];
+      if (currentTime >= c.start && currentTime <= c.end) {
+        newActive = i;
+        break;
+      }
+    }
+
+    if (newActive === this._activeCueIndex) return;
+
+    // Remove previous highlight.
+    if (this._activeCueIndex >= 0 && this._activeCueIndex < this._cues.length) {
+      this._cues[this._activeCueIndex].el.classList.remove("active");
+    }
+
+    this._activeCueIndex = newActive;
+
+    // Apply new highlight + scroll into view.
+    if (newActive >= 0) {
+      const cue = this._cues[newActive];
+      cue.el.classList.add("active");
+      cue.el.scrollIntoView({ block: "center", behavior: "smooth" });
+    }
+  }
+}
+
+function formatTime(sec: number): string {
+  if (!Number.isFinite(sec) || sec < 0) sec = 0;
+  const total = Math.floor(sec);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor((total % 3600) / 60);
+  const s = total % 60;
+  const mm = String(m).padStart(h > 0 ? 2 : 1, "0");
+  const ss = String(s).padStart(2, "0");
+  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
+}

package/src/element/avbridge-video.ts

@@ -856,15 +856,35 @@ export class AvbridgeVideoElement extends HTMLElementCtor {
       sidecarUrl: subtitle.url,
     };
     this._subtitleTracks.push(track);
+    // eslint-disable-next-line no-console
+    console.log(`[avbridge:subs] addSubtitle id=${track.id} format=${format} lang=${subtitle.language ?? "?"}`);
     await attachSubtitleTracks(
       this._videoEl,
       this._subtitleTracks,
       undefined,
       (err, t) => {
         // eslint-disable-next-line no-console
-        console.warn(`[avbridge] subtitle ${t.id} failed: ${err.message}`);
+        console.warn(`[avbridge:subs] subtitle ${t.id} failed: ${err.message}`);
       },
     );
+    // Enable the newly-added track so it renders immediately. On native
+    // strategy the <video>'s textTrack must be mode="showing"; on canvas
+    // strategies the renderer's watchTextTracks picks it up from the
+    // hidden-mode textTracks.
+    const textTracks = this._videoEl.textTracks;
+    for (let i = 0; i < textTracks.length; i++) {
+      if (textTracks[i].label === (subtitle.language ?? `Subtitle ${track.id}`)) {
+        textTracks[i].mode = "showing";
+        // eslint-disable-next-line no-console
+        console.log(`[avbridge:subs] enabled textTrack[${i}] mode=showing`);
+        break;
+      }
+    }
+    // Notify the settings sheet so it rebuilds with the new track.
+    this._dispatch("trackschange", {
+      audioTracks: this._audioTracks,
+      subtitleTracks: this.subtitleTracks,
+    });
   }
 
   /**

package/src/strategies/fallback/audio-output.ts

@@ -281,6 +281,10 @@ export class AudioOutput implements ClockSource {
       await this.ctx.resume();
     }
 
+    // Reconnect the gain node — pause() disconnects it to cut off
+    // in-flight audio instantly. Safe to call even if already connected.
+    try { this.gain.connect(this.ctx.destination); } catch { /* ignore */ }
+
     if (this.state === "paused") {
       // Resume: media time should continue from where we paused. ctx.currentTime
       // is preserved across suspend/resume, so re-anchoring it to "now" with
@@ -317,6 +321,12 @@ export class AudioOutput implements ClockSource {
     this.mediaTimeOfAnchor = this.now();
     this.state = "paused";
     if (this.noAudio) return;
+    // Disconnect the gain node immediately so any in-flight scheduled
+    // buffers are silenced instantly. ctx.suspend() is async and
+    // already-started AudioBufferSourceNodes keep playing until the
+    // context actually suspends — without the disconnect, audio bleeds
+    // through for ~200ms after pause().
+    try { this.gain.disconnect(); } catch { /* ignore */ }
     if (this.ctx.state === "running") {
       await this.ctx.suspend();
     }

package/src/subtitles/index.ts

@@ -110,6 +110,8 @@ export async function attachSubtitleTracks(
 
   for (const t of tracks) {
     if (!t.sidecarUrl) continue;
+    // eslint-disable-next-line no-console
+    console.log(`[avbridge:subs] attaching track id=${t.id} format=${t.format} url=${t.sidecarUrl.slice(0, 60)}`);
     try {
       let url = t.sidecarUrl;
       if (t.format === "srt") {