rx-player 4.5.0-dev.2026033100 → 4.5.0-dev.2026041501

package/src/core/fetchers/thumbnails/thumbnail_fetcher.ts

@@ -243,7 +243,7 @@ export default function createThumbnailFetcher(
         cdnMetadata,
         thumbnail,
         pipelineRequestOptions,
-        cancellationSignal,
+        requestCanceller.signal,
       );
     }
 

package/src/core/fetchers/utils/schedule_request.ts

@@ -20,7 +20,6 @@ import type { ICdnMetadata } from "../../../parsers/manifest";
 import cancellableSleep from "../../../utils/cancellable_sleep";
 import getFuzzedDelay from "../../../utils/get_fuzzed_delay";
 import getTimestamp from "../../../utils/monotonic_timestamp";
-import noop from "../../../utils/noop";
 import { RequestError } from "../../../utils/request";
 import type { CancellationSignal } from "../../../utils/task_canceller";
 import TaskCanceller from "../../../utils/task_canceller";
@@ -315,7 +314,7 @@ export async function scheduleRequestWithCdns<T>(
         () => {
           const updatedPrioritaryCdn = getCdnToRequest();
           if (cancellationSignal.isCancelled()) {
-            throw cancellationSignal.cancellationError;
+            return;
           }
           if (updatedPrioritaryCdn === undefined) {
             return cleanAndReject(prevRequestError);
@@ -333,7 +332,10 @@ export async function scheduleRequestWithCdns<T>(
 
       cancellableSleep(blockedFor, canceller.signal).then(
         () => requestCdn(nextWantedCdn).then(cleanAndResolve, cleanAndReject),
-        noop,
+        (err) =>
+          cleanAndReject(
+            cancellationSignal.isCancelled() ? cancellationSignal.cancellationError : err,
+          ),
       );
 
       function cleanAndResolve(response: T) {

package/src/core/segment_sinks/__tests__/garbage_collector.test.ts

@@ -0,0 +1,434 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  makeReadyOnlyPlaybackObserver,
+  DummyObservationPosition,
+} from "../../../playback_observer/__tests__/mocks";
+import type { IRange } from "../../../utils/ranges";
+import SharedReference from "../../../utils/reference";
+import TaskCanceller from "../../../utils/task_canceller";
+import type { IStreamOrchestratorPlaybackObservation } from "../../stream";
+import BufferGarbageCollector from "../garbage_collector";
+import { DummySegmentSink } from "./mocks";
+
+const mockLog = vi.hoisted(() => ({
+  debug: vi.fn(),
+  error: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+}));
+vi.mock("../../../log", () => ({ default: mockLog }));
+
+describe("BufferGarbageCollector", () => {
+  const mockedPlaybackObserver = makeReadyOnlyPlaybackObserver<
+    Pick<IStreamOrchestratorPlaybackObservation, "position" | "buffered">
+  >({
+    position: new DummyObservationPosition({
+      getWanted: vi.fn(() => 0),
+    }),
+    buffered: { video: null, audio: null, text: null },
+  });
+  const mockRemoveBuffer = vi.spyOn(DummySegmentSink.prototype, "removeBuffer");
+
+  function emitObservation(position: number, videoBuffered: IRange[] | null) {
+    mockedPlaybackObserver.emit({
+      position: new DummyObservationPosition({
+        getWanted: () => position,
+      }),
+      buffered: { video: videoBuffered, audio: null, text: null },
+    });
+  }
+  beforeEach(() => {
+    mockRemoveBuffer.mockReturnValue(Promise.resolve(undefined));
+  });
+
+  afterEach(() => {
+    mockedPlaybackObserver.reset();
+    vi.resetAllMocks();
+  });
+
+  it("calls removeBuffer for data behind maxBufferBehind (outer range fully behind)", async () => {
+    emitObservation(100, [{ start: 0, end: 80 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    // Wait for async operations
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(0, 80);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls removeBuffer for partial range behind maxBufferBehind (outer range partially behind)", async () => {
+    emitObservation(100, [{ start: 85, end: 95 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(85, 90);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls removeBuffer for data inside innerRange when behind maxBufferBehind", async () => {
+    emitObservation(100, [{ start: 80, end: 110 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(5);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(80, 95);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls removeBuffer for data ahead maxBufferAhead (outer range fully ahead)", async () => {
+    emitObservation(100, [{ start: 120, end: 150 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(Infinity);
+    const maxBufferAhead = new SharedReference<number>(10);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(120, 150);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls removeBuffer for partial range ahead maxBufferAhead (outer range partially ahead)", async () => {
+    emitObservation(100, [{ start: 105, end: 120 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(Infinity);
+    const maxBufferAhead = new SharedReference<number>(10);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(110, 120);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("calls removeBuffer for data inside innerRange when ahead maxBufferAhead", async () => {
+    emitObservation(100, [{ start: 80, end: 120 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(Infinity);
+    const maxBufferAhead = new SharedReference<number>(5);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(105, 120);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not call removeBuffer when both maxBufferBehind and maxBufferAhead are Infinity", async () => {
+    emitObservation(100, [{ start: 0, end: 200 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(Infinity);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).not.toHaveBeenCalled();
+  });
+
+  it("does not call removeBuffer when buffered is null", async () => {
+    emitObservation(100, null);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(10);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(mockRemoveBuffer).not.toHaveBeenCalled();
+  });
+
+  it("registers listeners on maxBufferBehind and maxBufferAhead", () => {
+    emitObservation(100, []);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(10);
+    const mbbUpdate = vi.spyOn(maxBufferBehind, "onUpdate");
+    const mbaUpdate = vi.spyOn(maxBufferAhead, "onUpdate");
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    expect(mbbUpdate).toHaveBeenCalledTimes(1);
+    expect(mbaUpdate).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-runs clean when maxBufferBehind changes", async () => {
+    emitObservation(100, [{ start: 0, end: 80 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(Infinity);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).not.toHaveBeenCalled();
+
+    maxBufferBehind.setValue(10);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(0, 80);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-runs clean when maxBufferAhead changes", async () => {
+    emitObservation(100, [{ start: 120, end: 150 }]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(Infinity);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).not.toHaveBeenCalled();
+
+    maxBufferAhead.setValue(10);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(120, 150);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-runs clean on new playback observation", async () => {
+    // Initially empty buffer, then buffered grows behind position
+    emitObservation(100, []);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).not.toHaveBeenCalled();
+
+    // Simulate new observation: position=200, buffer=[0-180] (fully behind 200-10=190)
+    emitObservation(200, [{ start: 0, end: 180 }]);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(0, 180);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(1);
+
+    emitObservation(500, [{ start: 180, end: 300 }]);
+
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(180, 300);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(2);
+  });
+
+  it("logs error when removeBuffer rejects (non-cancellation error)", async () => {
+    emitObservation(100, [{ start: 0, end: 80 }]);
+    const error = new Error("removeBuffer failed");
+    mockRemoveBuffer.mockReturnValueOnce(Promise.reject(error));
+
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    // Wait for rejection to propagate
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(mockLog.error).toHaveBeenCalledWith(
+      "Stream",
+      "Could not run BufferGarbageCollector:",
+      "removeBuffer failed",
+    );
+  });
+
+  it("does not log error when removeBuffer rejects with a cancellation error and signal is cancelled", async () => {
+    emitObservation(100, [{ start: 0, end: 80 }]);
+    const canceller = new TaskCanceller("test removeBuffer");
+    mockRemoveBuffer.mockImplementation(() => {
+      return new Promise((_res, rej) => {
+        canceller.signal.register((err) => rej(err));
+      });
+    });
+
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(Infinity);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      canceller.signal,
+    );
+
+    await new Promise((r) =>
+      setTimeout(() => {
+        canceller.cancel("cancelling remove");
+        r(undefined);
+      }, 0),
+    );
+    await new Promise((r) => setTimeout(r, 0));
+    expect(mockLog.error).not.toHaveBeenCalled();
+  });
+
+  it("handles both behind and ahead cleanup simultaneously", async () => {
+    emitObservation(100, [
+      { start: 0, end: 80 },
+      { start: 120, end: 150 },
+    ]);
+    const segmentSink = new DummySegmentSink({ bufferType: "video" });
+    const maxBufferBehind = new SharedReference<number>(10);
+    const maxBufferAhead = new SharedReference<number>(10);
+
+    BufferGarbageCollector(
+      {
+        segmentSink,
+        playbackObserver: mockedPlaybackObserver.observer,
+        maxBufferBehind,
+        maxBufferAhead,
+      },
+      new TaskCanceller("test BufferGarbageCollector").signal,
+    );
+
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(0, 80);
+    expect(mockRemoveBuffer).toHaveBeenCalledWith(120, 150);
+    expect(mockRemoveBuffer).toHaveBeenCalledTimes(2);
+  });
+});

package/src/core/segment_sinks/__tests__/mocks.ts

@@ -0,0 +1,49 @@
+import { makeMockedClass } from "../../../utils/test-utils";
+import type { SegmentSink } from "../implementations";
+import type SegmentInventory from "../inventory";
+import type BufferedHistory from "../inventory/buffered_history";
+
+export const DummySegmentSink = makeMockedClass<SegmentSink>(
+  {
+    removeBuffer: notImplemented("removeBuffer"),
+    declareInitSegment: notImplemented("declareInitSegment"),
+    pushChunk: notImplemented("pushChunk"),
+    freeInitSegment: notImplemented("freeInitSegment"),
+    synchronizeInventory: notImplemented("synchronizeInventory"),
+    getPendingOperations: notImplemented("getPendingOperations"),
+    getLastKnownInventory: notImplemented("getLastKnownInventory"),
+    getSegmentHistory: notImplemented("getSegmentHistory"),
+    signalSegmentComplete: notImplemented("signalSegmentComplete"),
+    dispose: notImplemented("dispose"),
+  },
+  {
+    bufferType: "video",
+    codec: "not implemented",
+  },
+);
+
+export const DummySegmentInventory = makeMockedClass<SegmentInventory>(
+  {
+    reset: notImplemented("reset"),
+    synchronizeBuffered: notImplemented("synchronizeBuffered"),
+    getInventory: notImplemented("getInventory"),
+    getHistoryFor: notImplemented("getHistoryFor"),
+    insertChunk: notImplemented("insertChunk"),
+    completeSegment: notImplemented("completeSegment"),
+  },
+  {},
+);
+
+export const DummyBufferedHistory = makeMockedClass<BufferedHistory>(
+  {
+    addBufferedSegment: notImplemented("addBufferedSegment"),
+    getHistoryFor: notImplemented("getHistoryFor"),
+  },
+  {},
+);
+
+function notImplemented(name: string): () => never {
+  return () => {
+    throw new Error(`${name} not implemented`);
+  };
+}

package/src/core/segment_sinks/garbage_collector.ts

@@ -47,8 +47,6 @@ export interface IGarbageCollectorArgument {
  *
  * @param {Object} opt
  * @param {Object} cancellationSignal
- *
- * TODO Move to main thread?
  */
 export default function BufferGarbageCollector(
   {
@@ -90,7 +88,6 @@ export default function BufferGarbageCollector(
   }
   maxBufferBehind.onUpdate(clean, { clearSignal: cancellationSignal });
   maxBufferAhead.onUpdate(clean, { clearSignal: cancellationSignal });
-  clean();
 }
 
 /**