avbridge 2.12.0 → 2.13.0

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);
@@ -1022,22 +1022,25 @@ async function createRemuxPipeline(ctx, video) {
       }
     }
     let mimePromise = null;
+    const myToken = pumpToken;
     const writable = new WritableStream({
       write: async (chunk) => {
-        if (destroyed) return;
+        if (destroyed || pumpToken !== myToken) return;
         if (!sink) {
           const mime = await (mimePromise ??= output.getMimeType());
+          if (destroyed || pumpToken !== myToken) return;
           sink = new MseSink({ mime, video });
           await sink.ready();
+          if (destroyed || pumpToken !== myToken) return;
           if (pendingStartTime > 0) {
             sink.invalidate(pendingStartTime);
           }
           sink.setPlayOnSeek(pendingAutoPlay);
         }
-        while (sink && !destroyed && (sink.queueLength() > 10 || sink.bufferedAhead() > 60 || sink.totalBuffered() > 120)) {
+        while (sink && !destroyed && pumpToken === myToken && (sink.queueLength() > 10 || sink.bufferedAhead() > 60 || sink.totalBuffered() > 120)) {
           await new Promise((r) => setTimeout(r, 500));
         }
-        if (destroyed) return;
+        if (destroyed || pumpToken !== myToken) return;
         sink.append(chunk.data);
         stats.bytesWritten += chunk.data.byteLength;
         stats.fragments++;
@@ -1304,7 +1307,21 @@ var VideoRenderer = class {
   framesPainted = 0;
   framesDroppedLate = 0;
   framesDroppedOverflow = 0;
+  /** True once the head frame has been painted as a pre-roll poster
+   *  since the last flush. Used to ensure pre-roll paints exactly one
+   *  frame (held static) during the post-seek discard window. */
   prerolled = false;
+  /** PTS (µs) of the most recently painted frame. Used as the calibration
+   *  reference on the first post-flush snap: the pre-roll path paints one
+   *  frame *before* PTS-based playback starts, so the queue head's PTS at
+   *  first PTS-based paint is the *next* frame, off by one frameDur from
+   *  the actually-displayed frame. Calibrating against the painted frame
+   *  instead of the queue head removes that one-frame offset and yields
+   *  calib ≈ 0 instead of +frameDur. */
+  lastPaintedPtsUs = 0;
+  hasLastPaintedPts = false;
+  /** Audio-clock reading (ms) at the previous paint, for overlay Δaud. */
+  lastPaintAudMs = 0;
   /** Wall-clock time of the last paint, in ms (performance.now()). */
   lastPaintWall = 0;
   /** Minimum ms between paints — paces video at roughly source fps. */
@@ -1335,32 +1352,47 @@ 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;
   }
   /**
-   * Soft cap for decoder backpressure. The decoder pump throttles when
-   * `queueDepth() >= queueHighWater`. Set high enough that normal decode
-   * bursts don't trigger the renderer's overflow-drop loop (which runs at
-   * every paint), but low enough that the decoder doesn't run unboundedly
-   * ahead. The hard cap in `enqueue()` is 64.
+   * Cap the decoder may fill the queue up to. Used by the decoder's
+   * enqueue-side discard logic (it closes new frames instead of pushing
+   * them when this is reached). Sized so a long post-seek catch-up
+   * fits — the decoder produces frames at PTS T_kf onwards rapidly
+   * while the demuxer is chewing through pre-target audio; if the
+   * queue can hold the whole post-seek burst, the renderer plays
+   * smoothly from pre-roll without a frozen-video gap when audio.start
+   * fires. At ~340 KB per SD frame the cap is ~85 MB peak; at HD it's
+   * larger but still bounded.
    */
-  queueHighWater = 30;
+  queueHighWater = 256;
   enqueue(frame) {
     if (this.destroyed) {
       frame.close();
       return;
     }
     this.queue.push(frame);
+    this.hasEverEnqueuedSinceFlush = true;
     if (this.queue.length === 1 && this.framesPainted === 0) {
       this.resolveFirstFrame();
     }
-    while (this.queue.length > 60) {
+    while (this.queue.length > this.queueHighWater + 8) {
       this.queue.shift()?.close();
       this.framesDroppedOverflow++;
     }
@@ -1442,12 +1474,9 @@ var VideoRenderer = class {
     if (this.queue.length === 0) return;
     const playing = this.clock.isPlaying();
     if (!playing) {
-      if (!this.prerolled) {
-        const head = this.queue.shift();
-        this.paint(head);
-        head.close();
+      if (!this.prerolled && this.queue.length > 0) {
         this.prerolled = true;
-        this.lastPaintWall = performance.now();
+        this.paint(this.queue[0]);
       }
       return;
     }
@@ -1456,14 +1485,29 @@ var VideoRenderer = class {
     const hasPts = headTs > 0 || this.queue.length > 1;
     if (hasPts) {
       const wallNow2 = performance.now();
-      if (!this.ptsCalibrated || wallNow2 - this.lastCalibrationWall > 1e4) {
-        this.ptsCalibrationUs = headTs - rawAudioNowUs;
+      if (!this.ptsCalibrated) {
+        const anchorUs = (this.clock.anchorTime?.() ?? this.clock.now()) * 1e6;
+        const referencePtsUs = this.hasLastPaintedPts ? this.lastPaintedPtsUs : headTs;
+        this.ptsCalibrationUs = referencePtsUs - anchorUs;
         this.ptsCalibrated = true;
         this.lastCalibrationWall = wallNow2;
+        if (isDebug()) {
+          console.log(
+            `[avbridge:renderer] CALIB-FIRST audioAnchor=${(anchorUs / 1e3).toFixed(1)}ms prerolledPTS=${this.hasLastPaintedPts ? (this.lastPaintedPtsUs / 1e3).toFixed(1) : "n/a"}ms queueHeadPTS=${(headTs / 1e3).toFixed(1)}ms rawAudioNow=${(rawAudioNowUs / 1e3).toFixed(1)}ms \u2192 calib=${(this.ptsCalibrationUs / 1e3).toFixed(1)}ms`
+          );
+        }
+      } else if (wallNow2 - this.lastCalibrationWall > 1e4) {
+        const oldCalib = this.ptsCalibrationUs;
+        this.ptsCalibrationUs = headTs - rawAudioNowUs;
+        this.lastCalibrationWall = wallNow2;
+        if (isDebug()) {
+          console.log(
+            `[avbridge:renderer] CALIB-RESNAP headPTS=${(headTs / 1e3).toFixed(1)}ms rawAudioNow=${(rawAudioNowUs / 1e3).toFixed(1)}ms calib ${(oldCalib / 1e3).toFixed(1)}ms \u2192 ${(this.ptsCalibrationUs / 1e3).toFixed(1)}ms (\u0394=${((this.ptsCalibrationUs - oldCalib) / 1e3).toFixed(1)}ms after 10s)`
+          );
+        }
       }
       const audioNowUs = rawAudioNowUs + this.ptsCalibrationUs;
-      const frameDurationUs = this.paintIntervalMs * 1e3;
-      const deadlineUs = audioNowUs + frameDurationUs;
+      const deadlineUs = audioNowUs;
       let bestIdx = -1;
       for (let i = 0; i < this.queue.length; i++) {
         const ts = this.queue[i].timestamp ?? 0;
@@ -1490,19 +1534,21 @@ var VideoRenderer = class {
         }
         return;
       }
-      const dropThresholdUs = audioNowUs - frameDurationUs * 2;
+      const _relaxDrop = globalThis.AVBRIDGE_RELAX_DROP === true;
       let dropped = 0;
-      while (bestIdx > 0) {
-        const ts = this.queue[0].timestamp ?? 0;
-        if (ts < dropThresholdUs) {
+      const initialBestIdx = bestIdx;
+      if (!_relaxDrop) {
+        while (bestIdx > 0) {
           this.queue.shift()?.close();
           this.framesDroppedLate++;
           bestIdx--;
           dropped++;
-        } else {
-          break;
         }
       }
+      const paintTs = this.queue[0]?.timestamp ?? 0;
+      if (isDebug()) {
+        console.log(`[TRACE] PAINT bestIdx_initial=${initialBestIdx} dropped=${dropped} paintPts=${(paintTs / 1e3).toFixed(1)}ms audioNow=${(audioNowUs / 1e3).toFixed(1)}ms deadline=${(deadlineUs / 1e3).toFixed(1)}ms queueLen=${this.queue.length} wall=${performance.now().toFixed(0)}`);
+      }
       this.ticksPainted++;
       if (isDebug()) {
         const now = performance.now();
@@ -1538,6 +1584,33 @@ var VideoRenderer = class {
     }
     try {
       this.ctx.drawImage(frame, 0, 0, this.canvas.width, this.canvas.height);
+      if (isDebug()) {
+        const wallNow = performance.now();
+        const audNowMs = this.clock.now() * 1e3;
+        const ptsMs = (frame.timestamp ?? 0) / 1e3;
+        const dWall = this.lastPaintWall > 0 ? wallNow - this.lastPaintWall : 0;
+        const dAud = this.lastPaintAudMs > 0 ? audNowMs - this.lastPaintAudMs : 0;
+        const dPts = this.hasLastPaintedPts ? ptsMs - this.lastPaintedPtsUs / 1e3 : 0;
+        this.ctx.save();
+        this.ctx.font = "bold 18px monospace";
+        const lines = [
+          `#${this.framesPainted + 1}  pts=${ptsMs.toFixed(0)}  aud=${audNowMs.toFixed(0)}  wall=${wallNow.toFixed(0)}`,
+          `\u0394pts=${dPts.toFixed(0)}  \u0394aud=${dAud.toFixed(0)}  \u0394wall=${dWall.toFixed(0)}`
+        ];
+        const lineHeight = 22;
+        const padTop = 6;
+        const stripH = padTop + lineHeight * lines.length;
+        this.ctx.fillStyle = "rgba(0,0,0,0.7)";
+        this.ctx.fillRect(0, 0, this.canvas.width, stripH);
+        this.ctx.fillStyle = "#0f0";
+        for (let i = 0; i < lines.length; i++) {
+          this.ctx.fillText(lines[i], 8, padTop + lineHeight * (i + 1) - 4);
+        }
+        this.ctx.restore();
+      }
+      this.lastPaintedPtsUs = frame.timestamp ?? 0;
+      this.hasLastPaintedPts = true;
+      this.lastPaintAudMs = this.clock.now() * 1e3;
       this.framesPainted++;
     } catch (err) {
       if (this.framesPainted === 0 && this.framesDroppedLate === 0) {
@@ -1550,17 +1623,30 @@ var VideoRenderer = class {
     const count = this.queue.length;
     while (this.queue.length > 0) this.queue.shift()?.close();
     this.prerolled = false;
+    this.hasLastPaintedPts = 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() {
@@ -1578,6 +1664,9 @@ var VideoRenderer = class {
 };
 
 // src/strategies/fallback/audio-output.ts
+function isDebug2() {
+  return typeof globalThis !== "undefined" && !!globalThis.AVBRIDGE_DEBUG;
+}
 var AudioOutput = class {
   ctx;
   gain;
@@ -1599,6 +1688,16 @@ var AudioOutput = class {
   mediaTimeOfNext = 0;
   /** Anchor: media time `mediaTimeOfAnchor` corresponds to ctx time `ctxTimeAtAnchor`. */
   mediaTimeOfAnchor = 0;
+  /**
+   * Ctx time at which the first audible chunk will start playing. `-1`
+   * before any chunk has been scheduled successfully (clock is frozen);
+   * the actual ctx time once one has. The renderer's `clock.now()` uses
+   * this to avoid advancing during the silent-gap window between
+   * `audio.start()` and the first chunk that schedules without being
+   * dropped — that gap is what produces the "audio-less fast-forward"
+   * the user sees post-seek when the gate releases on video-only grace.
+   */
+  firstAudibleCtxStart = -1;
   ctxTimeAtAnchor = 0;
   pendingQueue = [];
   framesScheduled = 0;
@@ -1671,10 +1770,16 @@ var AudioOutput = class {
       return this.mediaTimeOfAnchor;
     }
     if (this.state === "playing") {
+      if (this.firstAudibleCtxStart < 0) {
+        return this.mediaTimeOfAnchor;
+      }
       return this.mediaTimeOfAnchor + (this.ctx.currentTime - this.ctxTimeAtAnchor) * this._rate;
     }
     return this.mediaTimeOfAnchor;
   }
+  anchorTime() {
+    return this.mediaTimeOfAnchor;
+  }
   isPlaying() {
     return this.state === "playing";
   }
@@ -1701,18 +1806,81 @@ var AudioOutput = class {
    * Schedule a chunk of decoded samples. Queues internally while idle (cold
    * start or post-seek), schedules directly to the audio graph while playing.
    * In wall-clock mode, samples are silently discarded.
+   *
+   * `ptsSec` is the chunk's source-domain content PTS in seconds, from
+   * the demuxer. When provided, the chunk plays at the ctx-time
+   * corresponding to that PTS — so pre-target audio after a seek
+   * naturally drops (its computed `ctxStart` falls in the past) and
+   * post-target audio plays at its true content time, without any
+   * external trim or anchor rebase. When `ptsSec` is null (cold start
+   * with no PTS yet, or codecs whose packet→frame mapping isn't 1:1),
+   * the chunk is scheduled sequentially after `mediaTimeOfNext` — the
+   * pre-refactor behavior.
    */
-  schedule(samples, channels, sampleRate) {
+  schedule(samples, channels, sampleRate, ptsSec) {
     if (this.destroyed || this.noAudio) return;
     const frameCount = samples.length / channels;
     const durationSec = frameCount / sampleRate;
+    const hasPts = ptsSec != null && Number.isFinite(ptsSec);
+    if (hasPts && ptsSec + durationSec / this._rate < this.mediaTimeOfAnchor) {
+      return;
+    }
     if (this.state === "idle" || this.state === "paused") {
-      this.pendingQueue.push({ samples, channels, sampleRate, frameCount, durationSec });
+      this.pendingQueue.push({
+        samples,
+        channels,
+        sampleRate,
+        frameCount,
+        durationSec,
+        ptsSec: hasPts ? ptsSec : null
+      });
       return;
     }
-    this.scheduleNow(samples, channels, sampleRate, frameCount);
+    this.scheduleNow(
+      samples,
+      channels,
+      sampleRate,
+      frameCount,
+      hasPts ? ptsSec : null
+    );
   }
-  scheduleNow(samples, channels, sampleRate, frameCount) {
+  scheduleNow(samples, channels, sampleRate, frameCount, ptsSec) {
+    const durationSec = frameCount / sampleRate;
+    let ctxStart;
+    if (ptsSec != null) {
+      ctxStart = this.ctxTimeAtAnchor + (ptsSec - this.mediaTimeOfAnchor) / this._rate;
+      if (isDebug2()) {
+        console.log(`[TRACE-AUD] PTS sched #${this.framesScheduled} pts=${ptsSec.toFixed(3)} dur=${durationSec.toFixed(4)} ctxStart=${ctxStart.toFixed(4)} ctxNow=${this.ctx.currentTime.toFixed(4)} anchor=${this.mediaTimeOfAnchor.toFixed(3)} ctxAnchor=${this.ctxTimeAtAnchor.toFixed(4)} mtNext=${this.mediaTimeOfNext.toFixed(3)} rate=${this._rate}`);
+      }
+      if (ctxStart < this.ctx.currentTime - 1e-3) {
+        if (isDebug2()) {
+          console.log(`[TRACE-AUD] DROP late chunk pts=${ptsSec.toFixed(3)} ctxStart=${ctxStart.toFixed(4)} < ctxNow=${this.ctx.currentTime.toFixed(4)}`);
+        }
+        return;
+      }
+      if (this.firstAudibleCtxStart < 0) {
+        this.firstAudibleCtxStart = ctxStart;
+        this.mediaTimeOfAnchor = ptsSec;
+        this.ctxTimeAtAnchor = ctxStart;
+        if (isDebug2()) {
+          console.log(`[TRACE-AUD] UNFREEZE clock \u2014 first audible chunk pts=${ptsSec.toFixed(3)} ctxStart=${ctxStart.toFixed(4)} \u2192 anchor=${this.mediaTimeOfAnchor.toFixed(3)} ctxAnchor=${this.ctxTimeAtAnchor.toFixed(4)}`);
+        }
+      }
+      const endMediaTime = ptsSec + durationSec / this._rate;
+      if (endMediaTime > this.mediaTimeOfNext) {
+        this.mediaTimeOfNext = endMediaTime;
+      }
+    } else {
+      ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor) / this._rate;
+      console.warn(`[TRACE-AUD] LEGACY (no PTS) sched dur=${durationSec.toFixed(4)} ctxStart=${ctxStart.toFixed(4)} ctxNow=${this.ctx.currentTime.toFixed(4)}`);
+      if (ctxStart < this.ctx.currentTime) {
+        console.warn(`[TRACE-AUD] REBASE anchor was=${this.mediaTimeOfAnchor.toFixed(3)} ctxAnchor was=${this.ctxTimeAtAnchor.toFixed(4)} \u2192 anchor=${this.mediaTimeOfNext.toFixed(3)} ctxAnchor=${this.ctx.currentTime.toFixed(4)}`);
+        this.ctxTimeAtAnchor = this.ctx.currentTime;
+        this.mediaTimeOfAnchor = this.mediaTimeOfNext;
+        ctxStart = this.ctx.currentTime;
+      }
+      this.mediaTimeOfNext += durationSec;
+    }
     const buffer = this.ctx.createBuffer(channels, frameCount, sampleRate);
     for (let ch = 0; ch < channels; ch++) {
       const channelData = buffer.getChannelData(ch);
@@ -1724,14 +1892,7 @@ var AudioOutput = class {
     node.buffer = buffer;
     node.connect(this.gain);
     if (this._rate !== 1) node.playbackRate.value = this._rate;
-    let ctxStart = this.ctxTimeAtAnchor + (this.mediaTimeOfNext - this.mediaTimeOfAnchor) / this._rate;
-    if (ctxStart < this.ctx.currentTime) {
-      this.ctxTimeAtAnchor = this.ctx.currentTime;
-      this.mediaTimeOfAnchor = this.mediaTimeOfNext;
-      ctxStart = this.ctx.currentTime;
-    }
     node.start(ctxStart);
-    this.mediaTimeOfNext += frameCount / sampleRate;
     this.framesScheduled++;
   }
   // ── Lifecycle ─────────────────────────────────────────────────────────
@@ -1756,12 +1917,15 @@ var AudioOutput = class {
     } catch {
     }
     if (this.state === "paused") {
+      if (isDebug2()) {
+        console.log(`[TRACE-AUD] START(resume) anchor=${this.mediaTimeOfAnchor.toFixed(3)} ctxAnchor=${this.ctxTimeAtAnchor.toFixed(4)} \u2192 ctxAnchor=${this.ctx.currentTime.toFixed(4)} ctxNow=${this.ctx.currentTime.toFixed(4)} pendingCount=${this.pendingQueue.length}`);
+      }
       this.ctxTimeAtAnchor = this.ctx.currentTime;
       this.state = "playing";
       const drain2 = this.pendingQueue;
       this.pendingQueue = [];
       for (const c of drain2) {
-        this.scheduleNow(c.samples, c.channels, c.sampleRate, c.frameCount);
+        this.scheduleNow(c.samples, c.channels, c.sampleRate, c.frameCount, c.ptsSec);
       }
       return;
     }
@@ -1769,10 +1933,13 @@ var AudioOutput = class {
     this.ctxTimeAtAnchor = this.ctx.currentTime + STARTUP_DELAY;
     this.mediaTimeOfNext = this.mediaTimeOfAnchor;
     this.state = "playing";
+    if (isDebug2()) {
+      console.log(`[TRACE-AUD] START(cold) anchor=${this.mediaTimeOfAnchor.toFixed(3)} ctxAnchor=${this.ctxTimeAtAnchor.toFixed(4)} mtNext=${this.mediaTimeOfNext.toFixed(3)} ctxNow=${this.ctx.currentTime.toFixed(4)} pendingCount=${this.pendingQueue.length}`);
+    }
     const drain = this.pendingQueue;
     this.pendingQueue = [];
     for (const c of drain) {
-      this.scheduleNow(c.samples, c.channels, c.sampleRate, c.frameCount);
+      this.scheduleNow(c.samples, c.channels, c.sampleRate, c.frameCount, c.ptsSec);
     }
   }
   /** Pause playback. Suspends the audio context. */
@@ -1798,6 +1965,9 @@ var AudioOutput = class {
    * supplying new samples) and then call `start()` to resume playback.
    */
   async reset(newMediaTime) {
+    if (isDebug2()) {
+      console.log(`[TRACE-AUD] RESET to=${newMediaTime.toFixed(3)} prev_anchor=${this.mediaTimeOfAnchor.toFixed(3)} prev_mtNext=${this.mediaTimeOfNext.toFixed(3)} prev_ctxAnchor=${this.ctxTimeAtAnchor.toFixed(4)} ctxNow=${this.ctx.currentTime.toFixed(4)} state=${this.state}`);
+    }
     if (this.noAudio) {
       this.pendingQueue = [];
       this.mediaTimeOfAnchor = newMediaTime;
@@ -1816,6 +1986,7 @@ var AudioOutput = class {
     this.mediaTimeOfAnchor = newMediaTime;
     this.mediaTimeOfNext = newMediaTime;
     this.ctxTimeAtAnchor = this.ctx.currentTime;
+    this.firstAudibleCtxStart = -1;
     this.state = "idle";
     if (this.ctx.state === "running") {
       await this.ctx.suspend();
@@ -1995,28 +2166,6 @@ function asUint8(x) {
   const ta = x;
   return new Uint8Array(ta.buffer, ta.byteOffset, ta.byteLength);
 }
-function sanitizeFrameTimestamp(frame, nextUs, fallbackTimeBase) {
-  const lo = frame.pts ?? 0;
-  const hi = frame.ptshi ?? 0;
-  const isInvalid = hi === -2147483648 && lo === 0 || !Number.isFinite(lo);
-  if (isInvalid) {
-    const us2 = nextUs();
-    frame.pts = us2;
-    frame.ptshi = 0;
-    return;
-  }
-  const tb = fallbackTimeBase ?? [1, 1e6];
-  const pts64 = hi * 4294967296 + lo;
-  const us = Math.round(pts64 * 1e6 * tb[0] / tb[1]);
-  if (Number.isFinite(us) && Math.abs(us) <= Number.MAX_SAFE_INTEGER) {
-    frame.pts = us;
-    frame.ptshi = us < 0 ? -1 : 0;
-    return;
-  }
-  const fallback = nextUs();
-  frame.pts = fallback;
-  frame.ptshi = 0;
-}
 
 // src/strategies/hybrid/decoder.ts
 async function startHybridDecoder(opts) {
@@ -2098,6 +2247,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 +2258,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 +2280,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 +2293,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 {
     }
@@ -2155,7 +2313,6 @@ async function startHybridDecoder(opts) {
   let videoChunksFed = 0;
   let bufferedUntilSec = 0;
   let syntheticVideoUs = 0;
-  let syntheticAudioUs = 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));
@@ -2187,7 +2344,13 @@ async function startHybridDecoder(opts) {
         }
       }
       if (audioDec && audioPackets && audioPackets.length > 0) {
-        await decodeAudioBatch(audioPackets, myToken);
+        await decodeAudioBatch(
+          audioPackets,
+          myToken,
+          /*flush*/
+          false,
+          audioTimeBase
+        );
       }
       if (myToken !== pumpToken || destroyed) return;
       await new Promise((r) => setTimeout(r, 0));
@@ -2234,8 +2397,11 @@ async function startHybridDecoder(opts) {
       }
     }
   }
-  async function decodeAudioBatch(pkts, myToken, flush = false) {
+  async function decodeAudioBatch(pkts, myToken, flush = false, tb) {
     if (!audioDec || destroyed || myToken !== pumpToken) return;
+    const pktPtsSec = pkts.map(
+      (p) => tb ? packetPtsSec(p, tb) : null
+    );
     const AUDIO_SUB_BATCH = 4;
     let allFrames = [];
     for (let i = 0; i < pkts.length; i += AUDIO_SUB_BATCH) {
@@ -2273,22 +2439,13 @@ async function startHybridDecoder(opts) {
     }
     if (myToken !== pumpToken || destroyed) return;
     const frames = allFrames;
-    for (const f of frames) {
+    for (let i = 0; i < frames.length; i++) {
       if (myToken !== pumpToken || destroyed) return;
-      sanitizeFrameTimestamp(
-        f,
-        () => {
-          const ts = syntheticAudioUs;
-          const samples2 = f.nb_samples ?? 1024;
-          const sampleRate = f.sample_rate ?? 44100;
-          syntheticAudioUs += Math.round(samples2 * 1e6 / sampleRate);
-          return ts;
-        },
-        audioTimeBase
-      );
+      const f = frames[i];
       const samples = libavFrameToInterleavedFloat32(f);
       if (samples) {
-        opts.audio.schedule(samples.data, samples.channels, samples.sampleRate);
+        const pts = pktPtsSec[i] ?? null;
+        opts.audio.schedule(samples.data, samples.channels, samples.sampleRate, pts);
         audioFramesDecoded++;
       }
     }
@@ -2398,7 +2555,6 @@ async function startHybridDecoder(opts) {
       }
       await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
-      syntheticAudioUs = Math.round(timeSec * 1e6);
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] hybrid pump failed (post-setAudioTrack):", err)
       );
@@ -2437,7 +2593,6 @@ async function startHybridDecoder(opts) {
       }
       await flushBSF();
       syntheticVideoUs = Math.round(timeSec * 1e6);
-      syntheticAudioUs = Math.round(timeSec * 1e6);
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] hybrid pump failed (post-seek):", err)
       );
@@ -2453,6 +2608,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",
@@ -2689,6 +2845,9 @@ async function createHybridSession(ctx, target, transport) {
 }
 
 // src/strategies/fallback/decoder.ts
+function isDebug3() {
+  return typeof globalThis !== "undefined" && !!globalThis.AVBRIDGE_DEBUG;
+}
 async function startDecoder(opts) {
   const variant = "avbridge";
   const libav = await chunkNNVOHKXJ_cjs.loadLibav(variant);
@@ -2752,6 +2911,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 +2922,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 +2944,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 +2957,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 {
     }
@@ -2811,8 +2979,28 @@ async function startDecoder(opts) {
   let watchdogSlowSinceMs = 0;
   let watchdogSlowWarned = false;
   let watchdogOverflowWarned = false;
-  let syntheticVideoUs = 0;
-  let syntheticAudioUs = 0;
+  let lastContentUs = -1;
+  let firstValidPtsLoggedSinceSeek = false;
+  let seenFirstAudioPacketSinceSeek = false;
+  let seekTargetSec = 0;
+  let diagPktsLoggedSinceSeek = 0;
+  let diagFramesLoggedSinceSeek = 0;
+  let diagFrameKeysDumped = false;
+  const DIAG_MAX_PKTS = 100;
+  const DIAG_MAX_FRAMES = 300;
+  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 +3009,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;
@@ -2835,6 +3026,18 @@ async function startDecoder(opts) {
         for (const pkt of videoPackets) {
           const sec = packetPtsSec(pkt, videoTimeBase);
           if (sec != null && sec > bufferedUntilSec) bufferedUntilSec = sec;
+          if (isDebug3() && diagPktsLoggedSinceSeek < DIAG_MAX_PKTS) {
+            const rawHi = pkt.ptshi ?? 0;
+            const rawLo = pkt.pts ?? 0;
+            const isInvalidPts = rawHi === -2147483648 && rawLo === 0;
+            const rawPts64 = isInvalidPts ? null : rawHi * 4294967296 + rawLo;
+            const rawSec = rawPts64 != null && videoTimeBase ? rawPts64 * videoTimeBase[0] / videoTimeBase[1] : null;
+            const pktKeys = diagPktsLoggedSinceSeek === 0 ? `[keys: ${Object.keys(pkt).join(",")}]` : "";
+            console.log(
+              `[DIAG-PKT] vidx=${diagPktsLoggedSinceSeek} pts=${isInvalidPts ? "NOPTS" : rawPts64} pts_sec=${rawSec != null ? rawSec.toFixed(3) : "n/a"} ptshi=${rawHi} ptslo=${rawLo} flags=0x${(pkt.flags ?? 0).toString(16)} keyframe=${(pkt.flags ?? 0) & 1 ? "Y" : "N"} stream=${pkt.stream_index} dataLen=${pkt.data?.length ?? 0} seekTarget=${seekTargetSec.toFixed(3)} ` + pktKeys
+            );
+            diagPktsLoggedSinceSeek++;
+          }
         }
       }
       if (audioPackets && audioTimeBase) {
@@ -2842,9 +3045,25 @@ async function startDecoder(opts) {
           const sec = packetPtsSec(pkt, audioTimeBase);
           if (sec != null && sec > bufferedUntilSec) bufferedUntilSec = sec;
         }
+        if (!seenFirstAudioPacketSinceSeek && audioPackets.length > 0) {
+          const firstSec = packetPtsSec(audioPackets[0], audioTimeBase);
+          if (firstSec != null && Number.isFinite(firstSec)) {
+            seenFirstAudioPacketSinceSeek = true;
+            chunkNNVOHKXJ_cjs.dbg.info(
+              "av-anchor",
+              `seek-target=${seekTargetSec.toFixed(3)}s, first-audio-pkt-pts=${firstSec.toFixed(3)}s (\u0394=${((firstSec - seekTargetSec) * 1e3).toFixed(1)}ms \u2014 pre-target packets will be skipped by AudioOutput)`
+            );
+          }
+        }
       }
       if (audioDec && audioPackets && audioPackets.length > 0) {
-        await decodeAudioBatch(audioPackets, myToken);
+        await decodeAudioBatch(
+          audioPackets,
+          myToken,
+          /*flush*/
+          false,
+          audioTimeBase
+        );
       }
       if (myToken !== pumpToken || destroyed) return;
       if (videoDec && videoPackets && videoPackets.length > 0) {
@@ -2885,8 +3104,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) {
+          _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 +3140,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,32 +3153,133 @@ 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;
-        },
-        videoTimeBase
-      );
+      const _diagShouldLog = isDebug3() && diagFramesLoggedSinceSeek < DIAG_MAX_FRAMES;
+      const _diagRawHi = f.ptshi ?? 0;
+      const _diagRawLo = f.pts ?? 0;
+      const _diagInvalid = _diagRawHi === -2147483648 && _diagRawLo === 0;
+      const _diagRawPts64 = _diagInvalid ? null : _diagRawHi * 4294967296 + _diagRawLo;
+      const _diagRawSec = _diagRawPts64 != null && videoTimeBase ? _diagRawPts64 * videoTimeBase[0] / videoTimeBase[1] : null;
+      if (_diagShouldLog && !diagFrameKeysDumped) {
+        diagFrameKeysDumped = true;
+        const allKeys = Object.keys(f);
+        const fieldDump = {};
+        for (const k of allKeys) {
+          const v = f[k];
+          if (k === "data") continue;
+          if (typeof v === "object" && v !== null && "length" in v) continue;
+          fieldDump[k] = v;
+        }
+        console.log(`[DIAG-FRAME] FIRST FRAME post-seek \u2014 all keys: ${allKeys.join(",")}`);
+        console.log(`[DIAG-FRAME] FIRST FRAME field dump:`, fieldDump);
+      }
+      let rawUs = null;
+      if (!_diagInvalid && _diagRawPts64 != null) {
+        const tb = videoTimeBase ?? [1, 1e6];
+        const us = Math.round(_diagRawPts64 * 1e6 * tb[0] / tb[1]);
+        if (Number.isFinite(us) && Math.abs(us) <= Number.MAX_SAFE_INTEGER) {
+          rawUs = us;
+        }
+      }
+      const _diagLog = (decision, finalPtsUs, sanFallback) => {
+        if (!_diagShouldLog) return;
+        const ptsSrc = sanFallback ? `SYNTHETIC(${_diagInvalid ? "NOPTS" : "invalid-range"})` : "LIBAV";
+        console.log(
+          `[DIAG-FRAME] vidx=${diagFramesLoggedSinceSeek} raw_pts=${_diagInvalid ? "NOPTS" : _diagRawPts64} raw_pts_sec=${_diagRawSec != null ? _diagRawSec.toFixed(3) : "n/a"} pts_src=${ptsSrc} final_pts_us=${finalPtsUs} final_pts_sec=${(finalPtsUs / 1e6).toFixed(3)} seekTarget=${seekTargetSec.toFixed(3)} offset_to_target_ms=${(finalPtsUs / 1e3 - seekTargetSec * 1e3).toFixed(1)} lastEmittedPts_us=${lastEmittedPtsUs} decision=${decision}`
+        );
+        diagFramesLoggedSinceSeek++;
+      };
+      let _diagSanFallbackFired = false;
+      const seekTargetUs = Math.round(seekTargetSec * 1e6);
+      if (lastContentUs < 0) {
+        if (rawUs == null) {
+          const isColdStartKeyframe = seekTargetSec === 0 && f.key_frame === 1;
+          if (isColdStartKeyframe) {
+            lastContentUs = 0;
+            _diagSanFallbackFired = true;
+          } else {
+            _diagLog("PRE-ANCHOR-DROP", 0, true);
+            continue;
+          }
+        } else {
+          lastContentUs = rawUs;
+          if (!firstValidPtsLoggedSinceSeek) {
+            firstValidPtsLoggedSinceSeek = true;
+            if (isDebug3()) {
+              console.log(
+                `[avbridge:decoder] post-seek anchor established: first valid raw pts = ${(rawUs / 1e3).toFixed(1)}ms (seekTarget = ${(seekTargetSec * 1e3).toFixed(1)}ms, \u0394 = ${((rawUs - seekTargetUs) / 1e3).toFixed(1)}ms)`
+              );
+            }
+            if (rawUs >= seekTargetUs) {
+              console.warn(
+                `[avbridge:decoder] first valid raw pts \u2265 seek target \u2014 pre-anchor NOPTS frames may have straddled the target and been mis-discarded. First painted frame may be late by up to one keyframe interval.`
+              );
+            }
+          }
+        }
+      } else {
+        if (rawUs != null) {
+          lastContentUs = rawUs;
+        } else {
+          lastContentUs += videoFrameStepUs;
+          _diagSanFallbackFired = true;
+        }
+      }
+      f.pts = lastContentUs;
+      f.ptshi = lastContentUs < 0 ? -1 : 0;
+      const _fPts = lastContentUs;
+      if (_fPts > newestVideoPtsUs) newestVideoPtsUs = _fPts;
+      if (lastEmittedPtsUs >= 0 && _fPts < lastEmittedPtsUs) {
+        _diagLog("REGRESSED-DROP", _fPts, _diagSanFallbackFired);
+        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;
+      const targetUs = Math.round(seekTargetSec * 1e6);
+      if (_fPts < targetUs - videoFrameStepUs) {
+        _diagLog("PRE-TARGET-DROP", _fPts, _diagSanFallbackFired);
+        continue;
+      }
       try {
         const vf = bridge.laFrameToVideoFrame(f, { timeBase: [1, 1e6] });
-        opts.renderer.enqueue(vf);
+        if (opts.renderer.queueDepth() >= opts.renderer.queueHighWater) {
+          vf.close();
+          _diagLog("OVERFLOW-DROP", _fPts, _diagSanFallbackFired);
+        } else {
+          opts.renderer.enqueue(vf);
+          _diagLog("ENQUEUED", _fPts, _diagSanFallbackFired);
+        }
         videoFramesDecoded++;
       } catch (err) {
         if (videoFramesDecoded === 0) {
           console.warn("[avbridge] laFrameToVideoFrame failed:", err);
         }
+        _diagLog("BRIDGE-ERROR", _fPts, _diagSanFallbackFired);
       }
     }
   }
-  async function decodeAudioBatch(pkts, myToken, flush = false) {
+  async function decodeAudioBatch(pkts, myToken, flush = false, tb) {
     if (!audioDec || destroyed || myToken !== pumpToken) return;
+    const pktPtsSec = pkts.map(
+      (p) => tb ? packetPtsSec(p, tb) : null
+    );
     let frames;
+    const _t0 = performance.now();
     try {
       frames = await libav.ff_decode_multi(
         audioDec.c,
@@ -2962,23 +3292,20 @@ 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) {
+    for (let i = 0; i < frames.length; i++) {
       if (myToken !== pumpToken || destroyed) return;
-      sanitizeFrameTimestamp(
-        f,
-        () => {
-          const ts = syntheticAudioUs;
-          const samples2 = f.nb_samples ?? 1024;
-          const sampleRate = f.sample_rate ?? 44100;
-          syntheticAudioUs += Math.round(samples2 * 1e6 / sampleRate);
-          return ts;
-        },
-        audioTimeBase
-      );
+      const f = frames[i];
       const samples = libavFrameToInterleavedFloat32(f);
       if (samples) {
-        opts.audio.schedule(samples.data, samples.channels, samples.sampleRate);
+        const pts = pktPtsSec[i] ?? null;
+        if (isDebug3()) {
+          const dur = samples.data.length / samples.channels / samples.sampleRate;
+          console.log(`[TRACE-DEC] audio frame #${audioFramesDecoded} pts=${pts != null ? pts.toFixed(4) : "NULL"} dur=${dur.toFixed(4)} samples=${samples.data.length / samples.channels} sr=${samples.sampleRate} ch=${samples.channels} pktsIn=${pkts.length} framesOut=${frames.length}`);
+        }
+        opts.audio.schedule(samples.data, samples.channels, samples.sampleRate, pts);
         audioFramesDecoded++;
       }
     }
@@ -3081,13 +3408,17 @@ async function startDecoder(opts) {
       } catch {
       }
       await flushBSF();
-      syntheticVideoUs = Math.round(timeSec * 1e6);
-      syntheticAudioUs = Math.round(timeSec * 1e6);
+      lastContentUs = -1;
+      lastEmittedPtsUs = -1;
+      firstValidPtsLoggedSinceSeek = false;
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] fallback pump failed (post-setAudioTrack):", err)
       );
     },
     async seek(timeSec) {
+      if (isDebug3()) {
+        console.log(`[SEEK] target=${timeSec.toFixed(3)}s (${(timeSec * 1e3).toFixed(0)}ms) wall=${performance.now().toFixed(0)}`);
+      }
       const newToken = ++pumpToken;
       if (pumpRunning) {
         try {
@@ -3118,8 +3449,14 @@ async function startDecoder(opts) {
       } catch {
       }
       await flushBSF();
-      syntheticVideoUs = Math.round(timeSec * 1e6);
-      syntheticAudioUs = Math.round(timeSec * 1e6);
+      lastContentUs = -1;
+      lastEmittedPtsUs = -1;
+      firstValidPtsLoggedSinceSeek = false;
+      seenFirstAudioPacketSinceSeek = false;
+      seekTargetSec = timeSec;
+      diagPktsLoggedSinceSeek = 0;
+      diagFramesLoggedSinceSeek = 0;
+      diagFrameKeysDumped = false;
       pumpRunning = pumpLoop(newToken).catch(
         (err) => console.error("[avbridge] decoder pump failed (post-seek):", err)
       );
@@ -3133,7 +3470,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
@@ -5473,8 +5827,42 @@ var PROXY_ATTRIBUTES = [
 ];
 var PLAYER_ATTRIBUTES = ["show-fit"];
 var FIT_MODES = ["contain", "cover", "fill"];
-var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
+var AvbridgePlayerElement = class extends HTMLElement {
   static observedAttributes = [...PROXY_ATTRIBUTES, ...PLAYER_ATTRIBUTES];
+  /**
+   * Returns `true` if a DOM event originated from one of the player's
+   * **interactive chrome elements** (seek bar, control buttons, settings
+   * menu, overlay play button) rather than the bare video surface.
+   *
+   * This is the escape hatch for host pages that wrap the player in a
+   * gesture recognizer (e.g. TikTok-style vertical-swipe pager). For
+   * bubble-phase listeners the player's own handlers already call
+   * `stopPropagation()` on chrome interactions — but **capture-phase**
+   * listeners run *before* the player's handlers, so they need to check
+   * the event's path themselves and bail. This helper does that check
+   * via `composedPath()`, which traverses shadow boundaries correctly.
+   *
+   * Returns `false` for events on the bare video surface — host pages
+   * remain free to claim those for their own gestures (e.g. swipe-to-pan
+   * to the next video). Returns `false` for events that never hit a
+   * player at all.
+   *
+   * @example
+   * // TikTok-style vertical swipe on the document, capture phase:
+   * document.addEventListener("pointerdown", (e) => {
+   *   if (AvbridgePlayerElement.isPlayerChromeEvent(e)) return;
+   *   startSwipeGesture(e);
+   * }, { capture: true });
+   */
+  static isPlayerChromeEvent(event) {
+    const CHROME_SELECTOR = ".avp-controls, .avp-settings, .avp-overlay-btn";
+    for (const node of event.composedPath()) {
+      if (node instanceof HTMLElement && node.matches?.(CHROME_SELECTOR)) {
+        return true;
+      }
+    }
+    return false;
+  }
   // ── Internal DOM refs ──────────────────────────────────────────────────
   _video;
   _playBtn;
@@ -5504,6 +5892,11 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
   _activeAudioTrackId = null;
   _activeSubtitleTrackId = null;
   _userSeeking = false;
+  /** Last seek target the user committed. The thumb stays here (and
+   *  `_updateTime` skips updating from `timeupdate`) until the underlying
+   *  `currentTime` actually catches up — otherwise the thumb visibly snaps
+   *  back to the pre-seek position while the remux pipeline rebuilds. */
+  _pendingSeekTarget = null;
   _holdTimer = null;
   _holdSpeedActive = false;
   _savedPlaybackRate = 1;
@@ -5610,7 +6003,10 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
         );
       });
     }
-    on(this._video, "loadstart", () => this._setState("loading"));
+    on(this._video, "loadstart", () => {
+      this._pendingSeekTarget = null;
+      this._setState("loading");
+    });
     on(this._video, "ready", () => {
       this._setState(this._video.paused ? "paused" : "playing");
       this._seekInput.max = String(this._video.duration || 0);
@@ -5757,7 +6153,9 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
     this._timeDisplay.textContent = `${formatTime(t)} / ${formatTime(this._video.duration)}`;
   }
   _onSeekCommit() {
-    this._video.currentTime = Number(this._seekInput.value);
+    const target = Number(this._seekInput.value);
+    this._pendingSeekTarget = target;
+    this._video.currentTime = target;
     this._userSeeking = false;
   }
   /** Linear click-to-time mapping across the full track width (no edge clamping). */
@@ -5767,40 +6165,57 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
     const frac = Math.max(0, Math.min(1, (clientX - rect.left) / rect.width));
     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. */
-  static SCRUB_WIDTH_THRESHOLD = 400;
   _onSeekPointerDown(e) {
     if (e.button !== 0 && e.pointerType === "mouse") return;
     e.preventDefault();
+    e.stopPropagation();
     this._userSeeking = true;
     const seekBar = this.shadowRoot.querySelector(".avp-seek");
     seekBar.setPointerCapture(e.pointerId);
     seekBar.setAttribute("data-seeking", "");
-    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 coarse = typeof matchMedia !== "undefined" && matchMedia("(pointer: coarse)").matches;
+    const startTime = coarse ? this._video.currentTime || 0 : 0;
+    const startClientX = e.clientX;
+    let lastCommit = 0;
+    const timeAt = (clientX) => {
+      if (coarse) {
+        const rect = seekBar.getBoundingClientRect();
+        const dx = clientX - startClientX;
+        const dt = dx / rect.width * (this._video.duration || 0);
+        return Math.max(0, Math.min(this._video.duration || 0, startTime + dt));
+      }
+      return this._timeFromSeekPointer(clientX);
+    };
+    const showTooltip = (t, clientX) => {
+      if (coarse) this._updateSeekTooltipAtTime(t);
+      else this._updateSeekTooltip(clientX);
+    };
+    if (!coarse) {
+      const initial = timeAt(e.clientX);
+      this._seekInput.value = String(initial);
+      this._onSeekInput();
+      showTooltip(initial, e.clientX);
+      this._onSeekCommit();
+      this._userSeeking = true;
+    } else {
+      showTooltip(startTime, e.clientX);
+    }
     const onMove = (ev) => {
-      const t = this._timeFromSeekPointer(ev.clientX);
+      ev.stopPropagation();
+      const t = timeAt(ev.clientX);
       this._seekInput.value = String(t);
       this._onSeekInput();
-      this._updateSeekTooltip(ev.clientX);
-      if (scrubMode) {
-        const now = performance.now();
-        if (now - lastScrubCommit > 250) {
-          lastScrubCommit = now;
-          this._onSeekCommit();
-          this._userSeeking = true;
-        }
+      showTooltip(t, ev.clientX);
+      const now = performance.now();
+      if (now - lastCommit > 250) {
+        lastCommit = now;
+        this._onSeekCommit();
+        this._userSeeking = true;
       }
     };
     const onUp = (ev) => {
-      const t = this._timeFromSeekPointer(ev.clientX);
+      ev.stopPropagation();
+      const t = timeAt(ev.clientX);
       this._seekInput.value = String(t);
       this._onSeekCommit();
       this._seekInput.focus();
@@ -5827,6 +6242,15 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
     this._seekTooltip.textContent = formatTime(t);
     this._seekTooltip.style.left = `${frac * 100}%`;
   }
+  /** Position the tooltip over a specific time (vs. pointer X). Used by
+   *  relative-drag scrub on coarse pointers, where the displayed time
+   *  is decoupled from the finger position. */
+  _updateSeekTooltipAtTime(t) {
+    const dur = this._video.duration || 0;
+    const frac = dur > 0 ? Math.max(0, Math.min(1, t / dur)) : 0;
+    this._seekTooltip.textContent = formatTime(t);
+    this._seekTooltip.style.left = `${frac * 100}%`;
+  }
   _updateSeekVisuals(t) {
     const dur = this._video.duration || 0;
     const pct = dur > 0 ? t / dur * 100 : 0;
@@ -5838,6 +6262,15 @@ var AvbridgePlayerElement = class _AvbridgePlayerElement extends HTMLElement {
     if (this._userSeeking) return;
     const t = this._video.currentTime;
     const d = this._video.duration;
+    if (this._pendingSeekTarget !== null) {
+      if (Math.abs(t - this._pendingSeekTarget) < 0.5) {
+        this._pendingSeekTarget = null;
+      } else {
+        this._timeDisplay.textContent = `${formatTime(this._pendingSeekTarget)} / ${formatTime(d)}`;
+        this._updateBuffered();
+        return;
+      }
+    }
     this._seekInput.value = String(t);
     this._updateSeekVisuals(t);
     this._timeDisplay.textContent = `${formatTime(t)} / ${formatTime(d)}`;
@@ -6022,10 +6455,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 +6477,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() {