avbridge 2.12.0 → 2.12.1

package/dist/element.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunk7EF4VTUS_cjs = require('./chunk-7EF4VTUS.cjs');
+var chunkUM6WCSGL_cjs = require('./chunk-UM6WCSGL.cjs');
 require('./chunk-WRKO6Q42.cjs');
-require('./chunk-HBHSUGNI.cjs');
+require('./chunk-VLI3Y6IJ.cjs');
 require('./chunk-2IJ66NTD.cjs');
 require('./chunk-QDJLQR53.cjs');
 require('./chunk-HZUVMXBN.cjs');
@@ -296,7 +296,7 @@ var AvbridgeVideoElement = class extends HTMLElementCtor {
     this._dispatch("loadstart", {});
     let player;
     try {
-      player = await chunk7EF4VTUS_cjs.createPlayer({
+      player = await chunkUM6WCSGL_cjs.createPlayer({
         source,
         target: this._videoEl,
         // Honor the consumer's preferred initial strategy. "auto" means

package/dist/element.js

@@ -1,6 +1,6 @@
-import { createPlayer } from './chunk-Z26PXRUY.js';
+import { createPlayer } from './chunk-BN7BRTLY.js';
 import './chunk-EDDWAN2L.js';
-import './chunk-2LNXMGT6.js';
+import './chunk-5CX7BVVV.js';
 import './chunk-CPJLFFCC.js';
 import './chunk-LUFA47FP.js';
 import './chunk-3YKWU4FM.js';

package/dist/index.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkGJBNLPGI_cjs = require('./chunk-GJBNLPGI.cjs');
-var chunk7EF4VTUS_cjs = require('./chunk-7EF4VTUS.cjs');
+var chunkE5MAM2P4_cjs = require('./chunk-E5MAM2P4.cjs');
+var chunkUM6WCSGL_cjs = require('./chunk-UM6WCSGL.cjs');
 var chunkWRKO6Q42_cjs = require('./chunk-WRKO6Q42.cjs');
-var chunkHBHSUGNI_cjs = require('./chunk-HBHSUGNI.cjs');
+var chunkVLI3Y6IJ_cjs = require('./chunk-VLI3Y6IJ.cjs');
 var chunk2IJ66NTD_cjs = require('./chunk-2IJ66NTD.cjs');
 require('./chunk-QDJLQR53.cjs');
 require('./chunk-HZUVMXBN.cjs');
@@ -37,7 +37,7 @@ async function transcodeViaLibav(ctx, options) {
     import('mediabunny'),
     import('./libav-demux-575OYCT2.cjs'),
     import('./source-VFLXLOCN.cjs'),
-    import('./remux-VPKCLHHM.cjs')
+    import('./remux-NSBJFMLG.cjs')
   ]);
   const normalized = await normalizeSource(ctx.source);
   const demux = await openLibavDemux({
@@ -535,7 +535,7 @@ async function transcode(source, options = {}) {
   const quality = options.quality ?? "medium";
   validateCodecCompatibility(outputFormat, videoCodec, audioCodec);
   options.signal?.throwIfAborted();
-  const ctx = await chunkHBHSUGNI_cjs.probe(source);
+  const ctx = await chunkVLI3Y6IJ_cjs.probe(source);
   options.signal?.throwIfAborted();
   if (isLibavTranscodeContainer(ctx.container)) {
     return transcodeViaLibav(ctx, options);
@@ -552,7 +552,7 @@ async function transcode(source, options = {}) {
 async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, options) {
   const mb = await import('mediabunny');
   const input = new mb.Input({
-    source: await chunkHBHSUGNI_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
+    source: await chunkVLI3Y6IJ_cjs.buildMediabunnySourceFromInput(mb, ctx.source),
     formats: mb.ALL_FORMATS
   });
   let bytesWritten = 0;
@@ -566,7 +566,7 @@ async function attemptTranscode(ctx, outputFormat, videoCodec, audioCodec, quali
     }
   })) : null;
   const output = new mb.Output({
-    format: chunkGJBNLPGI_cjs.createOutputFormat(mb, outputFormat),
+    format: chunkE5MAM2P4_cjs.createOutputFormat(mb, outputFormat),
     target: streamTarget ?? bufferTarget
   });
   const videoOptions = options.dropVideo ? { discard: true } : {
@@ -657,8 +657,8 @@ async function doTranscode(ctx, outputFormat, videoCodec, audioCodec, quality, o
       await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
     }
   }
-  const mimeType = chunkGJBNLPGI_cjs.mimeForFormat(outputFormat);
-  const filename = chunkGJBNLPGI_cjs.generateFilename(ctx.name, outputFormat);
+  const mimeType = chunkE5MAM2P4_cjs.mimeForFormat(outputFormat);
+  const filename = chunkE5MAM2P4_cjs.generateFilename(ctx.name, outputFormat);
   if (options.outputStream) {
     options.onProgress?.({ percent: 100, bytesWritten: 0 });
     return {
@@ -759,35 +759,35 @@ function qualityToMediabunny2(mb, quality) {
 
 Object.defineProperty(exports, "remux", {
   enumerable: true,
-  get: function () { return chunkGJBNLPGI_cjs.remux; }
+  get: function () { return chunkE5MAM2P4_cjs.remux; }
 });
 Object.defineProperty(exports, "FALLBACK_AUDIO_CODECS", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.FALLBACK_AUDIO_CODECS; }
+  get: function () { return chunkUM6WCSGL_cjs.FALLBACK_AUDIO_CODECS; }
 });
 Object.defineProperty(exports, "FALLBACK_VIDEO_CODECS", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.FALLBACK_VIDEO_CODECS; }
+  get: function () { return chunkUM6WCSGL_cjs.FALLBACK_VIDEO_CODECS; }
 });
 Object.defineProperty(exports, "NATIVE_AUDIO_CODECS", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.NATIVE_AUDIO_CODECS; }
+  get: function () { return chunkUM6WCSGL_cjs.NATIVE_AUDIO_CODECS; }
 });
 Object.defineProperty(exports, "NATIVE_VIDEO_CODECS", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.NATIVE_VIDEO_CODECS; }
+  get: function () { return chunkUM6WCSGL_cjs.NATIVE_VIDEO_CODECS; }
 });
 Object.defineProperty(exports, "UnifiedPlayer", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.UnifiedPlayer; }
+  get: function () { return chunkUM6WCSGL_cjs.UnifiedPlayer; }
 });
 Object.defineProperty(exports, "classify", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.classifyContext; }
+  get: function () { return chunkUM6WCSGL_cjs.classifyContext; }
 });
 Object.defineProperty(exports, "createPlayer", {
   enumerable: true,
-  get: function () { return chunk7EF4VTUS_cjs.createPlayer; }
+  get: function () { return chunkUM6WCSGL_cjs.createPlayer; }
 });
 Object.defineProperty(exports, "srtToVtt", {
   enumerable: true,
@@ -795,7 +795,7 @@ Object.defineProperty(exports, "srtToVtt", {
 });
 Object.defineProperty(exports, "probe", {
   enumerable: true,
-  get: function () { return chunkHBHSUGNI_cjs.probe; }
+  get: function () { return chunkVLI3Y6IJ_cjs.probe; }
 });
 Object.defineProperty(exports, "AvbridgeError", {
   enumerable: true,

package/dist/index.js

@@ -1,9 +1,9 @@
-import { mimeForFormat, generateFilename, createOutputFormat } from './chunk-5Y5BTB5D.js';
-export { remux } from './chunk-5Y5BTB5D.js';
-export { FALLBACK_AUDIO_CODECS, FALLBACK_VIDEO_CODECS, NATIVE_AUDIO_CODECS, NATIVE_VIDEO_CODECS, UnifiedPlayer, classifyContext as classify, createPlayer } from './chunk-Z26PXRUY.js';
+import { mimeForFormat, generateFilename, createOutputFormat } from './chunk-B76QWPFM.js';
+export { remux } from './chunk-B76QWPFM.js';
+export { FALLBACK_AUDIO_CODECS, FALLBACK_VIDEO_CODECS, NATIVE_AUDIO_CODECS, NATIVE_VIDEO_CODECS, UnifiedPlayer, classifyContext as classify, createPlayer } from './chunk-BN7BRTLY.js';
 export { srtToVtt } from './chunk-EDDWAN2L.js';
-import { probe, buildMediabunnySourceFromInput } from './chunk-2LNXMGT6.js';
-export { probe } from './chunk-2LNXMGT6.js';
+import { probe, buildMediabunnySourceFromInput } from './chunk-5CX7BVVV.js';
+export { probe } from './chunk-5CX7BVVV.js';
 import { AvbridgeError, ERR_CONTAINER_NOT_SUPPORTED, ERR_TRANSCODE_UNSUPPORTED_COMBO, ERR_TRANSCODE_ABORTED, ERR_TRANSCODE_DECODE, ERR_CODEC_NOT_SUPPORTED } from './chunk-CPJLFFCC.js';
 export { AvbridgeError, ERR_ALL_STRATEGIES_EXHAUSTED, ERR_CODEC_NOT_SUPPORTED, ERR_FETCH_FAILED, ERR_LIBAV_NOT_REACHABLE, ERR_MSE_CODEC_NOT_SUPPORTED, ERR_MSE_NOT_SUPPORTED, ERR_PLAYER_NOT_READY, ERR_PROBE_FAILED, ERR_PROBE_FETCH_FAILED, ERR_PROBE_UNKNOWN_CONTAINER, ERR_RANGE_NOT_SUPPORTED, ERR_STRATEGY_FAILED } from './chunk-CPJLFFCC.js';
 import './chunk-LUFA47FP.js';
@@ -38,7 +38,7 @@ async function transcodeViaLibav(ctx, options) {
     import('mediabunny'),
     import('./libav-demux-SXZDLC7W.js'),
     import('./source-4TZ6KMNV.js'),
-    import('./remux-7TA4FKTY.js')
+    import('./remux-PHUHO3VV.js')
   ]);
   const normalized = await normalizeSource(ctx.source);
   const demux = await openLibavDemux({

package/dist/player.cjs

@@ -239,7 +239,7 @@ async function probe(source, transport) {
       const hasUnknownCodec = result.videoTracks.some((t) => t.codec === "unknown") || result.audioTracks.some((t) => t.codec === "unknown");
       if (hasUnknownCodec) {
         try {
-          const { probeWithLibav } = await import('./avi-Y3N325WZ.cjs');
+          const { probeWithLibav } = await import('./avi-5BPR6QUX.cjs');
           return await probeWithLibav(normalized, sniffed);
         } catch {
           return result;
@@ -252,7 +252,7 @@ async function probe(source, transport) {
         mediabunnyErr.message
       );
       try {
-        const { probeWithLibav } = await import('./avi-Y3N325WZ.cjs');
+        const { probeWithLibav } = await import('./avi-5BPR6QUX.cjs');
         return await probeWithLibav(normalized, sniffed);
       } catch (libavErr) {
         const mbMsg = mediabunnyErr.message || String(mediabunnyErr);
@@ -266,7 +266,7 @@ async function probe(source, transport) {
     }
   }
   try {
-    const { probeWithLibav } = await import('./avi-Y3N325WZ.cjs');
+    const { probeWithLibav } = await import('./avi-5BPR6QUX.cjs');
     return await probeWithLibav(normalized, sniffed);
   } catch (err) {
     const inner = err instanceof Error ? err.message : String(err);
@@ -1335,10 +1335,20 @@ var VideoRenderer = class {
   /** Resolves once the first decoded frame has been enqueued. */
   firstFrameReady;
   resolveFirstFrame;
-  /** True once at least one frame has been enqueued. */
+  /**
+   * True once at least one frame has been enqueued *since the last flush*.
+   * Used by `readyState` — initial cold-start reports HAVE_NOTHING until
+   * any frame has arrived, and after a seek we want the same semantics
+   * (HAVE_NOTHING until post-seek frames arrive), so the cumulative
+   * `framesPainted > 0` that used to live here was wrong: it kept the
+   * state "true forever" after the first frame ever, so post-seek
+   * `waitForBuffer()` would exit immediately with an empty queue and
+   * leave video frozen while audio kept going.
+   */
   hasFrames() {
-    return this.queue.length > 0 || this.framesPainted > 0;
+    return this.queue.length > 0 || this.hasEverEnqueuedSinceFlush;
   }
+  hasEverEnqueuedSinceFlush = false;
   /** Current depth of the frame queue. Used by the decoder for backpressure. */
   queueDepth() {
     return this.queue.length;
@@ -1357,6 +1367,7 @@ var VideoRenderer = class {
       return;
     }
     this.queue.push(frame);
+    this.hasEverEnqueuedSinceFlush = true;
     if (this.queue.length === 1 && this.framesPainted === 0) {
       this.resolveFirstFrame();
     }
@@ -1490,7 +1501,8 @@ var VideoRenderer = class {
         }
         return;
       }
-      const dropThresholdUs = audioNowUs - frameDurationUs * 2;
+      const _relaxDrop = globalThis.AVBRIDGE_RELAX_DROP === true;
+      const dropThresholdUs = _relaxDrop ? audioNowUs - 60 * 1e6 : audioNowUs - frameDurationUs * 2;
       let dropped = 0;
       while (bestIdx > 0) {
         const ts = this.queue[0].timestamp ?? 0;
@@ -1551,16 +1563,28 @@ var VideoRenderer = class {
     while (this.queue.length > 0) this.queue.shift()?.close();
     this.prerolled = false;
     this.ptsCalibrated = false;
+    this.hasEverEnqueuedSinceFlush = false;
     if (isDebug() && count > 0) {
       console.log(`[avbridge:renderer] FLUSH discarded=${count} painted=${this.framesPainted} drops=${this.framesDroppedLate}`);
     }
   }
   stats() {
+    let queueSpanMs = 0;
+    let queueHeadMs = 0;
+    let queueTailMs = 0;
+    if (this.queue.length > 0) {
+      queueHeadMs = Math.round((this.queue[0].timestamp ?? 0) / 1e3);
+      queueTailMs = Math.round((this.queue[this.queue.length - 1].timestamp ?? 0) / 1e3);
+      queueSpanMs = Math.max(0, queueTailMs - queueHeadMs);
+    }
     return {
       framesPainted: this.framesPainted,
       framesDroppedLate: this.framesDroppedLate,
       framesDroppedOverflow: this.framesDroppedOverflow,
-      queueDepth: this.queue.length
+      queueDepth: this.queue.length,
+      queueHeadMs,
+      queueTailMs,
+      queueSpanMs
     };
   }
   destroy() {
@@ -2098,6 +2122,7 @@ async function startHybridDecoder(opts) {
   }
   let bsfCtx = null;
   let bsfPkt = null;
+  let bsfRequiredButMissing = false;
   if (videoStream && opts.context.videoTracks[0]?.codec === "mpeg4") {
     try {
       bsfCtx = await libav.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
@@ -2108,13 +2133,19 @@ async function startHybridDecoder(opts) {
         bsfPkt = await libav.av_packet_alloc();
         chunkNNVOHKXJ_cjs.dbg.info("bsf", "mpeg4_unpack_bframes BSF active (hybrid)");
       } else {
-        console.warn("[avbridge] mpeg4_unpack_bframes BSF not available in hybrid decoder");
+        bsfRequiredButMissing = true;
         bsfCtx = null;
       }
     } catch (err) {
-      console.warn("[avbridge] hybrid: failed to init BSF:", err.message);
+      bsfRequiredButMissing = true;
       bsfCtx = null;
       bsfPkt = null;
+      chunkNNVOHKXJ_cjs.dbg.warn("bsf", `hybrid: mpeg4_unpack_bframes BSF init failed: ${err.message}`);
+    }
+    if (bsfRequiredButMissing) {
+      console.error(
+        "[avbridge] MPEG-4 Part 2 (DivX/Xvid) detected but mpeg4_unpack_bframes BSF is unavailable in this libav variant. Files with packed B-frames will play with incorrect frame ordering. Rebuild the libav variant with the `avbsf` fragment included."
+      );
     }
   }
   async function applyBSF(packets) {
@@ -2124,7 +2155,6 @@ async function startHybridDecoder(opts) {
       await libav.ff_copyin_packet(bsfPkt, pkt);
       const sendErr = await libav.av_bsf_send_packet(bsfCtx, bsfPkt);
       if (sendErr < 0) {
-        out.push(pkt);
         continue;
       }
       while (true) {
@@ -2138,10 +2168,13 @@ async function startHybridDecoder(opts) {
   async function flushBSF() {
     if (!bsfCtx || !bsfPkt) return;
     try {
-      await libav.av_bsf_send_packet(bsfCtx, 0);
-      while (true) {
-        const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
-        if (err < 0) break;
+      if (libav.av_bsf_flush) {
+        await libav.av_bsf_flush(bsfCtx);
+      } else {
+        while (true) {
+          const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+          if (err < 0) break;
+        }
       }
     } catch {
     }
@@ -2453,6 +2486,7 @@ async function startHybridDecoder(opts) {
         videoChunksFed,
         audioFramesDecoded,
         bsfApplied: bsfCtx ? ["mpeg4_unpack_bframes"] : [],
+        bsfMissing: bsfRequiredButMissing ? ["mpeg4_unpack_bframes"] : [],
         videoDecodeQueueSize: videoDecoder?.decodeQueueSize ?? 0,
         // Confirmed transport info — see fallback decoder for the pattern.
         _transport: inputHandle.transport === "http-range" ? "http-range" : "memory",
@@ -2752,6 +2786,7 @@ async function startDecoder(opts) {
   }
   let bsfCtx = null;
   let bsfPkt = null;
+  let bsfRequiredButMissing = false;
   if (videoStream && opts.context.videoTracks[0]?.codec === "mpeg4") {
     try {
       bsfCtx = await libav.av_bsf_list_parse_str_js("mpeg4_unpack_bframes");
@@ -2762,13 +2797,19 @@ async function startDecoder(opts) {
         bsfPkt = await libav.av_packet_alloc();
         chunkNNVOHKXJ_cjs.dbg.info("bsf", "mpeg4_unpack_bframes BSF active");
       } else {
-        console.warn("[avbridge] mpeg4_unpack_bframes BSF not available \u2014 decoding without it");
+        bsfRequiredButMissing = true;
         bsfCtx = null;
       }
     } catch (err) {
-      console.warn("[avbridge] failed to init mpeg4_unpack_bframes BSF:", err.message);
+      bsfRequiredButMissing = true;
       bsfCtx = null;
       bsfPkt = null;
+      chunkNNVOHKXJ_cjs.dbg.warn("bsf", `mpeg4_unpack_bframes BSF init failed: ${err.message}`);
+    }
+    if (bsfRequiredButMissing) {
+      console.error(
+        "[avbridge] MPEG-4 Part 2 (DivX/Xvid) detected but mpeg4_unpack_bframes BSF is unavailable in this libav variant. Files with packed B-frames will play with incorrect frame ordering (backwards PTS jumps, heavy late-drop stuttering). Rebuild the libav variant with the `avbsf` fragment included. See docs/dev/POSTMORTEMS.md for details."
+      );
     }
   }
   async function applyBSF(packets) {
@@ -2778,7 +2819,6 @@ async function startDecoder(opts) {
       await libav.ff_copyin_packet(bsfPkt, pkt);
       const sendErr = await libav.av_bsf_send_packet(bsfCtx, bsfPkt);
       if (sendErr < 0) {
-        out.push(pkt);
         continue;
       }
       while (true) {
@@ -2792,10 +2832,13 @@ async function startDecoder(opts) {
   async function flushBSF() {
     if (!bsfCtx || !bsfPkt) return;
     try {
-      await libav.av_bsf_send_packet(bsfCtx, 0);
-      while (true) {
-        const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
-        if (err < 0) break;
+      if (libav.av_bsf_flush) {
+        await libav.av_bsf_flush(bsfCtx);
+      } else {
+        while (true) {
+          const err = await libav.av_bsf_receive_packet(bsfCtx, bsfPkt);
+          if (err < 0) break;
+        }
       }
     } catch {
     }
@@ -2813,6 +2856,19 @@ async function startDecoder(opts) {
   let watchdogOverflowWarned = false;
   let syntheticVideoUs = 0;
   let syntheticAudioUs = 0;
+  let videoDecodeMsTotal = 0;
+  let audioDecodeMsTotal = 0;
+  let videoDecodeBatches = 0;
+  let audioDecodeBatches = 0;
+  let readMsTotal = 0;
+  let readBatches = 0;
+  let pumpThrottleMsTotal = 0;
+  let pumpThrottleEntries = 0;
+  let slowestVideoBatchMs = 0;
+  let newestVideoPtsUs = 0;
+  let lastEmittedPtsUs = -1;
+  let ptsRegressions = 0;
+  let worstPtsRegressionMs = 0;
   const videoTrackInfo = opts.context.videoTracks.find((t) => t.id === videoStream?.index);
   const videoFps = videoTrackInfo?.fps && videoTrackInfo.fps > 0 ? videoTrackInfo.fps : 30;
   const videoFrameStepUs = Math.max(1, Math.round(1e6 / videoFps));
@@ -2821,9 +2877,12 @@ async function startDecoder(opts) {
       let readErr;
       let packets;
       try {
+        const _readStart = performance.now();
         [readErr, packets] = await libav.ff_read_frame_multi(fmt_ctx, readPkt, {
           limit: 16 * 1024
         });
+        readMsTotal += performance.now() - _readStart;
+        readBatches++;
       } catch (err) {
         console.error("[avbridge] ff_read_frame_multi failed:", err);
         return;
@@ -2885,8 +2944,17 @@ async function startDecoder(opts) {
           }
         }
       }
-      while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
-        await new Promise((r) => setTimeout(r, 50));
+      {
+        const _throttleStart = performance.now();
+        let _throttled = false;
+        while (!destroyed && myToken === pumpToken && (opts.audio.bufferAhead() > 2 || opts.renderer.queueDepth() >= opts.renderer.queueHighWater)) {
+          _throttled = true;
+          await new Promise((r) => setTimeout(r, 50));
+        }
+        if (_throttled) {
+          pumpThrottleMsTotal += performance.now() - _throttleStart;
+          pumpThrottleEntries++;
+        }
       }
       if (readErr === libav.AVERROR_EOF) {
         if (videoDec) await decodeVideoBatch(
@@ -2912,6 +2980,7 @@ async function startDecoder(opts) {
   async function decodeVideoBatch(pkts, myToken, flush = false) {
     if (!videoDec || destroyed || myToken !== pumpToken) return;
     let frames;
+    const _t0 = performance.now();
     try {
       frames = await libav.ff_decode_multi(
         videoDec.c,
@@ -2924,18 +2993,38 @@ async function startDecoder(opts) {
       console.error("[avbridge] video decode batch failed:", err);
       return;
     }
+    {
+      const _dt = performance.now() - _t0;
+      videoDecodeMsTotal += _dt;
+      videoDecodeBatches++;
+      if (_dt > slowestVideoBatchMs) slowestVideoBatchMs = _dt;
+    }
     if (myToken !== pumpToken || destroyed) return;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
       sanitizeFrameTimestamp(
         f,
         () => {
-          const ts = syntheticVideoUs;
-          syntheticVideoUs += videoFrameStepUs;
-          return ts;
+          const base = lastEmittedPtsUs >= 0 ? lastEmittedPtsUs + videoFrameStepUs : syntheticVideoUs;
+          syntheticVideoUs = base + videoFrameStepUs;
+          return base;
         },
         videoTimeBase
       );
+      const _fPts = (f.ptshi ?? 0) * 4294967296 + (f.pts ?? 0);
+      if (_fPts > newestVideoPtsUs) newestVideoPtsUs = _fPts;
+      if (lastEmittedPtsUs >= 0 && _fPts < lastEmittedPtsUs) {
+        ptsRegressions++;
+        const regressMs = (lastEmittedPtsUs - _fPts) / 1e3;
+        if (regressMs > worstPtsRegressionMs) worstPtsRegressionMs = regressMs;
+        if (ptsRegressions <= 10) {
+          console.warn(
+            `[avbridge:decoder] dropped out-of-order frame #${ptsRegressions}: pts=${(_fPts / 1e3).toFixed(1)}ms < previous=${(lastEmittedPtsUs / 1e3).toFixed(1)}ms (regression=${regressMs.toFixed(1)}ms). Typically a post-seek B-frame reorder tail.`
+          );
+        }
+        continue;
+      }
+      lastEmittedPtsUs = _fPts;
       try {
         const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
         opts.renderer.enqueue(vf);
@@ -2950,6 +3039,7 @@ async function startDecoder(opts) {
   async function decodeAudioBatch(pkts, myToken, flush = false) {
     if (!audioDec || destroyed || myToken !== pumpToken) return;
     let frames;
+    const _t0 = performance.now();
     try {
       frames = await libav.ff_decode_multi(
         audioDec.c,
@@ -2962,6 +3052,8 @@ async function startDecoder(opts) {
       console.error("[avbridge] audio decode batch failed:", err);
       return;
     }
+    audioDecodeMsTotal += performance.now() - _t0;
+    audioDecodeBatches++;
     if (myToken !== pumpToken || destroyed) return;
     for (const f of frames) {
       if (myToken !== pumpToken || destroyed) return;
@@ -3083,6 +3175,7 @@ async function startDecoder(opts) {
       await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
       syntheticAudioUs = Math.round(timeSec * 1e6);
+      lastEmittedPtsUs = -1;
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] fallback pump failed (post-setAudioTrack):", err)
       );
@@ -3120,6 +3213,7 @@ async function startDecoder(opts) {
       await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
       syntheticAudioUs = Math.round(timeSec * 1e6);
+      lastEmittedPtsUs = -1;
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] decoder pump failed (post-seek):", err)
       );
@@ -3133,7 +3227,24 @@ async function startDecoder(opts) {
         packetsRead,
         videoFramesDecoded,
         audioFramesDecoded,
+        // Throughput instrumentation — the stats panel turns these into
+        // "decode fps actual / realtime target" and shows slowest batch
+        // + producer throttle share.
+        videoDecodeMsTotal,
+        videoDecodeBatches,
+        audioDecodeMsTotal,
+        audioDecodeBatches,
+        readMsTotal,
+        readBatches,
+        pumpThrottleMsTotal,
+        pumpThrottleEntries,
+        slowestVideoBatchMs,
+        newestVideoPtsMs: Math.round(newestVideoPtsUs / 1e3),
+        ptsRegressions,
+        worstPtsRegressionMs,
+        sourceFps: videoFps,
         bsfApplied: bsfCtx ? ["mpeg4_unpack_bframes"] : [],
+        bsfMissing: bsfRequiredButMissing ? ["mpeg4_unpack_bframes"] : [],
         // Confirmed transport info: once prepareLibavInput returns
         // successfully, we *know* whether the source is http-range (probe
         // succeeded and returned 206) or in-memory blob. Diagnostics hoists
@@ -6022,10 +6133,12 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
     }
   }
   // ── Stats for nerds ────────────────────────────────────────────────────
+  _statsPrev = null;
   _toggleStats() {
     this._statsOpen = !this._statsOpen;
     this._statsEl.classList.toggle("open", this._statsOpen);
     if (this._statsOpen) {
+      this._statsPrev = null;
       this._updateStats();
       this._statsInterval = setInterval(() => this._updateStats(), 1e3);
     } else {
@@ -6042,23 +6155,76 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
       return;
     }
     const rt = d.runtime ?? {};
-    const lines = [
-      `Container: ${d.container ?? "?"}`,
-      `Video: ${d.videoCodec ?? "?"} ${d.width ?? "?"}\xD7${d.height ?? "?"}`,
-      `Audio: ${d.audioCodec ?? "none"}`,
-      `Strategy: ${d.strategy ?? "?"}  Class: ${d.strategyClass ?? "?"}`,
-      `Transport: ${d.transport ?? "?"} Range: ${d.rangeSupported ?? "?"}`,
-      `Duration: ${typeof d.duration === "number" ? d.duration.toFixed(1) + "s" : "?"}`
-    ];
-    if (rt.framesDecoded != null) lines.push(`Frames: ${rt.framesDecoded} decoded, ${rt.framesDropped ?? 0} dropped`);
-    if (rt.framesPainted != null) lines.push(`Painted: ${rt.framesPainted} Late: ${rt.framesDroppedLate ?? 0} Overflow: ${rt.framesDroppedOverflow ?? 0}`);
-    if (rt.videoFramesDecoded != null) lines.push(`Video decoded: ${rt.videoFramesDecoded} Chunks fed: ${rt.videoChunksFed ?? "?"}`);
-    if (rt.audioFramesDecoded != null) lines.push(`Audio decoded: ${rt.audioFramesDecoded}`);
-    if (rt.packetsRead != null) lines.push(`Packets read: ${rt.packetsRead}`);
-    if (rt.bsfApplied && rt.bsfApplied.length > 0) lines.push(`BSF: ${rt.bsfApplied.join(", ")}`);
-    if (rt.audioState != null) lines.push(`Audio state: ${rt.audioState} Clock: ${rt.clockMode ?? "?"}`);
+    const now = performance.now();
+    const prev = this._statsPrev;
+    const dtSec = prev ? Math.max(1e-3, (now - prev.ts) / 1e3) : 0;
+    const delta = (key) => {
+      if (!prev) return null;
+      const a = rt[key];
+      const b = prev.rt[key];
+      if (typeof a === "number" && typeof b === "number") return a - b;
+      return null;
+    };
+    const rate = (key) => {
+      const d_ = delta(key);
+      return d_ != null ? d_ / dtSec : null;
+    };
+    const fmt = (n, digits = 1) => n == null ? "?" : n.toFixed(digits);
+    const sourceFps = typeof rt.sourceFps === "number" ? rt.sourceFps : d.fps;
+    const lines = [];
+    lines.push(`Container: ${d.container ?? "?"}   Strategy: ${d.strategy ?? "?"} (${d.strategyClass ?? "?"})`);
+    lines.push(`Video: ${d.videoCodec ?? "?"} ${d.width ?? "?"}\xD7${d.height ?? "?"}${sourceFps ? ` @ ${sourceFps.toFixed(3)} fps` : ""}`);
+    lines.push(`Audio: ${d.audioCodec ?? "none"}   Transport: ${d.transport ?? "?"}${d.rangeSupported === true ? "/range" : ""}`);
+    lines.push(`Duration: ${typeof d.duration === "number" ? d.duration.toFixed(1) + "s" : "?"}   Playback rate: ${this._video.playbackRate.toFixed(2)}x`);
+    if (rt.videoFramesDecoded != null) {
+      const decFps = rate("videoFramesDecoded");
+      const paintFps = rate("framesPainted");
+      const dropLateFps = rate("framesDroppedLate");
+      const dropOverflowFps = rate("framesDroppedOverflow");
+      const pct = sourceFps && decFps != null ? ` (${(decFps / sourceFps * 100).toFixed(0)}% of realtime)` : "";
+      lines.push(`Decode fps: ${fmt(decFps)}${pct}   Paint fps: ${fmt(paintFps)}`);
+      lines.push(`Drops/sec: late=${fmt(dropLateFps)} overflow=${fmt(dropOverflowFps)}   Totals: painted=${rt.framesPainted} dropped=${rt.framesDroppedLate}`);
+    }
+    if (typeof rt.videoDecodeMsTotal === "number") {
+      const msDelta = delta("videoDecodeMsTotal");
+      const batchesDelta = delta("videoDecodeBatches");
+      const perBatch = msDelta != null && batchesDelta && batchesDelta > 0 ? msDelta / batchesDelta : null;
+      const share = msDelta != null && dtSec > 0 ? msDelta / (dtSec * 1e3) * 100 : null;
+      lines.push(
+        `Video decode: ${fmt(perBatch)}ms/batch avg   ${fmt(share)}% of wall   slowest=${fmt(rt.slowestVideoBatchMs)}ms`
+      );
+    }
+    if (typeof rt.audioDecodeMsTotal === "number") {
+      const msDelta = delta("audioDecodeMsTotal");
+      const share = msDelta != null && dtSec > 0 ? msDelta / (dtSec * 1e3) * 100 : null;
+      lines.push(`Audio decode: ${fmt(share)}% of wall`);
+    }
+    if (typeof rt.pumpThrottleMsTotal === "number") {
+      const msDelta = delta("pumpThrottleMsTotal");
+      const share = msDelta != null && dtSec > 0 ? msDelta / (dtSec * 1e3) * 100 : null;
+      lines.push(`Producer throttled: ${fmt(share)}% of wall`);
+    }
+    if (rt.queueDepth != null) {
+      lines.push(
+        `Queue: depth=${rt.queueDepth} span=${fmt(rt.queueSpanMs)}ms head=${fmt(rt.queueHeadMs)}ms tail=${fmt(rt.queueTailMs)}ms`
+      );
+    }
+    if (typeof rt.newestVideoPtsMs === "number") {
+      lines.push(`Newest decoded PTS: ${(rt.newestVideoPtsMs / 1e3).toFixed(2)}s`);
+    }
+    if (rt.audioState != null) {
+      lines.push(`Audio state: ${rt.audioState}   bufferAhead=${fmt(rt.bufferAhead, 2)}s   clock=${rt.clockMode ?? "?"}`);
+    }
+    if (typeof rt.ptsRegressions === "number" && rt.ptsRegressions > 0) {
+      lines.push(`PTS REGRESSIONS: ${rt.ptsRegressions} (worst=${fmt(rt.worstPtsRegressionMs)}ms) \u2014 decoder emitting out of order`);
+    }
+    if (rt.bsfApplied && rt.bsfApplied.length > 0) lines.push(`BSF active: ${rt.bsfApplied.join(", ")}`);
+    if (rt.bsfMissing && rt.bsfMissing.length > 0) {
+      lines.push(`BSF MISSING: ${rt.bsfMissing.join(", ")} (rebuild libav with avbsf)`);
+    }
     if (d.probedBy) lines.push(`Probed by: ${d.probedBy}`);
     this._statsEl.textContent = lines.join("\n");
+    this._statsPrev = { ts: now, rt: { ...rt } };
   }
   // ── Controls: fullscreen ───────────────────────────────────────────────
   _toggleFullscreen() {