fix: improve QuotaExceededError recovery with stats.loaded fallback and eviction gating

The previous eviction logic never triggered because it relied on
frag.byteLength (which reads stats.total from Content-Length). While
Jellyfin does set Content-Length, stats.total can still be 0 during
progressive loading or with other servers using chunked transfer.
Switch to stats.loaded (actual bytes received, always populated after
fragment completion) with byteLength as fallback.

Additionally, progressive loading creates a new append operation per
chunk, each with its own quotaEvictionAttempted closure. This caused
every chunk to independently trigger eviction or emit BUFFER_FULL_ERROR.
Add a class-level _quotaEvictionPending flag per SourceBuffer type so
that subsequent QuotaExceededErrors piggyback on the in-flight eviction
by queuing retries behind the pending remove, avoiding redundant
evictions and suppressing the BUFFER_FULL_ERROR spam.

Changes:
- fragment-tracker: use stats.loaded as primary byte source in
  getBackBufferEvictionEnd, falling back to byteLength
- buffer-controller: add _quotaEvictionPending flag gating per type
- buffer-controller: add getQuotaEvictionFlushOp that clears the
  pending flag on complete/error
- buffer-controller: log warning when no back buffer is available
  to evict

Author: alchemyyy

src/controller/buffer-controller.ts

@@ -118,6 +118,13 @@ export default class BufferController extends Logger implements ComponentAPI {
     audiovideo: 0,
   };
   private appendError?: ErrorData;
+  // Tracks whether a QuotaExceededError back-buffer eviction is in progress
+  // for a given SourceBuffer type. While true, subsequent QuotaExceededErrors
+  // on the same type piggyback on the pending eviction instead of triggering
+  // their own or emitting BUFFER_FULL_ERROR.
+  private _quotaEvictionPending: Partial<
+    Record<SourceBufferName, boolean>
+  > = {};
   // Record of required or created buffers by type. SourceBuffer is stored in Track.buffer once created.
   private tracks: SourceBufferTrackSet = {};
   // Array of SourceBuffer type and SourceBuffer (or null). One entry per TrackSet in this.tracks.
@@ -907,27 +914,38 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
           error.name == 'QuotaExceededError' ||
           `quota` in error;
 
-        // On QuotaExceededError: evict back buffer and retry the append once
-        // instead of emitting an error that forces the segment to be re-downloaded.
-        if (isQuotaError && !quotaEvictionAttempted) {
-          const evictEnd = this.getBackBufferEvictionTarget(
-            type,
-            data.byteLength,
-            frag.type,
-          );
-          if (evictEnd > 0) {
-            quotaEvictionAttempted = true;
+        if (isQuotaError) {
+          // An eviction is already in flight for this type — piggyback on it
+          // by queuing a retry after the pending remove, no new eviction needed.
+          if (this._quotaEvictionPending[type]) {
             this.log(
-              `QuotaExceededError on "${type}" append sn: ${sn} — evicting back buffer to ${evictEnd.toFixed(3)}s and retrying`,
+              `QuotaExceededError on "${type}" sn: ${sn} — eviction already pending, queuing retry`,
             );
-            // Insert a remove operation followed by a retry of this append
-            // right after the current (failed) operation in the queue.
-            // When shiftAndExecuteNext removes the failed op, the remove runs
-            // first, then the retry append with the same data.
-            const removeOp = this.getFlushOp(type, 0, evictEnd);
-            this.insertNext([removeOp, operation], type);
+            this.insertNext([operation], type);
             return;
           }
+
+          // First QuotaExceededError for this type: evict minimum back buffer
+          if (!quotaEvictionAttempted) {
+            const evictEnd = this.getBackBufferEvictionTarget(
+              type,
+              data.byteLength,
+              frag.type,
+            );
+            if (evictEnd > 0) {
+              quotaEvictionAttempted = true;
+              this._quotaEvictionPending[type] = true;
+              this.log(
+                `QuotaExceededError on "${type}" append sn: ${sn} — evicting back buffer to ${evictEnd.toFixed(3)}s and retrying`,
+              );
+              const removeOp = this.getQuotaEvictionFlushOp(type, 0, evictEnd);
+              this.insertNext([removeOp, operation], type);
+              return;
+            }
+            this.warn(
+              `QuotaExceededError on "${type}" sn: ${sn} — no back buffer available to evict`,
+            );
+          }
         }
 
         // in case any error occured while appending, put back segment in segments table
@@ -997,6 +1015,33 @@ transfer tracks: ${stringify(transferredTracks, (key, value) => (key === 'initSe
     this.append(operation, type, this.isPending(this.tracks[type]));
   }
 
+  // Like getFlushOp but clears _quotaEvictionPending on complete/error
+  private getQuotaEvictionFlushOp(
+    type: SourceBufferName,
+    start: number,
+    end: number,
+  ): BufferOperation {
+    this.log(`queuing quota-eviction "${type}" remove ${start}-${end}`);
+    return {
+      label: 'remove',
+      execute: () => {
+        this.removeExecutor(type, start, end);
+      },
+      onStart: () => {},
+      onComplete: () => {
+        this._quotaEvictionPending[type] = false;
+        this.hls.trigger(Events.BUFFER_FLUSHED, { type });
+      },
+      onError: (error: Error) => {
+        this._quotaEvictionPending[type] = false;
+        this.warn(
+          `Failed to remove ${start}-${end} from "${type}" SourceBuffer (quota eviction)`,
+          error,
+        );
+      },
+    };
+  }
+
   private getFlushOp(
     type: SourceBufferName,
     start: number,

src/controller/fragment-tracker.ts

@@ -486,6 +486,10 @@ export class FragmentTracker implements ComponentAPI {
    * Returns the eviction end position needed to free at least `bytesNeeded`
    * from the back buffer, or 0 if not enough data is available.
    * Walks buffered fragments oldest-first, accumulating actual byte sizes.
+   *
+   * Uses stats.loaded (actual bytes received) as the primary byte measure
+   * since it is always set after fragment completion, unlike stats.total
+   * which depends on Content-Length and may be 0 with chunked transfer.
    */
   public getBackBufferEvictionEnd(
     beforePosition: number,
@@ -503,7 +507,9 @@ export class FragmentTracker implements ComponentAPI {
         continue;
       }
       const frag = entity.body;
-      if (frag.end <= beforePosition && frag.byteLength) {
+      // Use stats.loaded (always set after load) with byteLength as fallback
+      const bytes = (frag.hasStats && frag.stats.loaded) || frag.byteLength;
+      if (frag.end <= beforePosition && bytes) {
         candidates[count++] = entity;
       }
     }
@@ -525,7 +531,8 @@ export class FragmentTracker implements ComponentAPI {
     let evictEnd = 0;
     for (let i = 0; i < count; i++) {
       const frag = candidates[i].body;
-      bytesFreed += frag.byteLength!;
+      const bytes = (frag.hasStats && frag.stats.loaded) || frag.byteLength;
+      bytesFreed += bytes!;
       evictEnd = frag.end;
       if (bytesFreed >= bytesNeeded) {
         return evictEnd;