rx-player 4.5.0-dev.2026012302 → 4.5.0-dev.2026031700

package/src/mse/__tests__/main_media_source_interface.test.ts

@@ -0,0 +1,846 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type {
+  IMediaSource,
+  ISourceBuffer,
+  ISourceBufferList,
+} from "../../compat/browser_compatibility_types";
+import { SourceBufferError } from "../../errors";
+import noop from "../../utils/noop";
+import MainMediaSourceInterface, {
+  MainSourceBufferInterface,
+} from "../main_media_source_interface";
+import { SourceBufferType } from "../types";
+import MediaSourceDurationUpdater from "../utils/media_source_duration_updater";
+
+const {
+  MockMediaSource,
+  MockSourceBuffer,
+  getLastMediaSourceMock,
+  mediaSourceProps,
+  makeMockSourceBufferList,
+  mockMaintainEndOfStream,
+  mockOnSourceClose,
+  mockOnSourceEnded,
+  mockOnSourceOpen,
+  mockTryToChangeSourceBufferType,
+} = vi.hoisted(() => {
+  /** Creates a minimal mock SourceBuffer with controllable event dispatching */
+  class InnerMockSourceBuffer implements ISourceBuffer {
+    private _listeners: Record<string, Array<(e?: unknown) => void>> = {};
+    updating: boolean = false;
+    buffered: TimeRanges = {
+      length: 0,
+      start: vi.fn().mockReturnValue(0),
+      end: vi.fn().mockReturnValue(0),
+    };
+    timestampOffset: number = 0;
+    appendWindowStart: number = 0;
+    appendWindowEnd: number = Infinity;
+    onabort = null;
+    onerror = null;
+    onupdate = null;
+    onupdateend = null;
+    onupdatestart = null;
+    changeType(): void {
+      // noop
+    }
+    appendBuffer(): void {
+      // noop
+    }
+    remove(): void {
+      // noop
+    }
+    abort(): void {
+      // noop
+    }
+    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+    addEventListener(event: any, cb: (e?: any) => void) {
+      this._listeners[event] = this._listeners[event] ?? [];
+      this._listeners[event].push(cb);
+    }
+    removeEventListener(event?: any, cb?: ((e?: any) => void) | undefined) {
+      if (event === undefined) {
+        this._listeners = {};
+        return;
+      }
+      this._listeners[event] = (this._listeners[event] ?? []).filter((fn) =>
+        cb === undefined ? false : fn !== cb,
+      );
+    }
+
+    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+    _emit(event: string, arg?: unknown) {
+      for (const cb of this._listeners[event] ?? []) {
+        cb(arg);
+      }
+    }
+  }
+
+  /**
+   * Creates a minimal ISourceBufferList-compatible object from an array of
+   * ISourceBuffer instances.
+   */
+  function makeMockSourceBufferListInner(buffers: ISourceBuffer[]): ISourceBufferList {
+    return {
+      onaddsourcebuffer: null,
+      onremovesourcebuffer: null,
+      get length() {
+        return buffers.length;
+      },
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      ...Object.fromEntries(buffers.map((buf, i) => [i, buf])),
+    };
+  }
+
+  const mediaSourcePropsObj: {
+    handle: MediaProvider | undefined;
+    streaming: boolean | undefined;
+  } = { handle: undefined, streaming: undefined };
+
+  let lastCreatedMockMS: InnerMockMediaSource | null = null;
+  class InnerMockMediaSource implements IMediaSource {
+    private _mediaSourceListeners: Record<string, Array<() => void>>;
+    readyState: ReadyState = "open";
+    duration: number = 0;
+    onsourceclose = null;
+    onsourceended = null;
+    onsourceopen = null;
+    constructor() {
+      this._mediaSourceListeners = {};
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      lastCreatedMockMS = this;
+    }
+    clearLiveSeekableRange(): never {
+      throw new Error("not implemented");
+    }
+    setLiveSeekableRange(): never {
+      throw new Error("not implemented");
+    }
+    sourceBuffers = makeMockSourceBufferListInner([]);
+    addSourceBuffer(): ISourceBuffer {
+      throw new Error("not implemented");
+    }
+    removeSourceBuffer(): never {
+      throw new Error("not implemented");
+    }
+    endOfStream(): void {
+      // noop
+    }
+    get handle(): MediaProvider | undefined {
+      return mediaSourcePropsObj.handle;
+    }
+    get streaming(): boolean | undefined {
+      return mediaSourcePropsObj.streaming;
+    }
+    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+    addEventListener(event: any, cb: (e?: any) => void) {
+      this._mediaSourceListeners[event] = this._mediaSourceListeners[event] ?? [];
+      this._mediaSourceListeners[event].push(cb);
+    }
+    removeEventListener(event?: any, cb?: ((e?: any) => void) | undefined) {
+      if (event === undefined) {
+        this._mediaSourceListeners = {};
+        return;
+      }
+      this._mediaSourceListeners[event] = (
+        this._mediaSourceListeners[event] ?? []
+      ).filter((fn) => (cb === undefined ? false : fn !== cb));
+    }
+    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */
+
+    _emit(event: string) {
+      for (const cb of this._mediaSourceListeners[event] ?? []) {
+        cb();
+      }
+    }
+  }
+
+  return {
+    mockTryToChangeSourceBufferType: vi.fn().mockReturnValue(true),
+    mockOnSourceOpen: vi.fn(),
+    mockOnSourceEnded: vi.fn(),
+    mockOnSourceClose: vi.fn(),
+    mockMaintainEndOfStream: vi.fn(),
+    MockMediaSource: InnerMockMediaSource,
+    MockSourceBuffer: InnerMockSourceBuffer,
+    makeMockSourceBufferList: makeMockSourceBufferListInner,
+    mediaSourceProps: mediaSourcePropsObj,
+    getLastMediaSourceMock: (): InnerMockMediaSource => {
+      if (lastCreatedMockMS === null) {
+        throw new Error("No MockMediaSource has been instantiated yet");
+      }
+      return lastCreatedMockMS;
+    },
+  };
+});
+
+vi.mock("../../compat/browser_compatibility_types", () => {
+  return {
+    MediaSource_: MockMediaSource,
+  };
+});
+
+vi.mock("../../compat/change_source_buffer_type", () => ({
+  default: mockTryToChangeSourceBufferType,
+}));
+
+vi.mock("../../compat/event_listeners", () => ({
+  onSourceOpen: mockOnSourceOpen,
+  onSourceEnded: mockOnSourceEnded,
+  onSourceClose: mockOnSourceClose,
+}));
+
+vi.mock("../../log", () => ({
+  default: {
+    info: vi.fn(),
+    debug: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+
+vi.mock("../utils/end_of_stream", () => ({
+  maintainEndOfStream: mockMaintainEndOfStream,
+}));
+
+describe("MainMediaSourceInterface", () => {
+  const mockUpdateDuration = vi.spyOn(
+    MediaSourceDurationUpdater.prototype,
+    "updateDuration",
+  );
+  const mockStopUpdating = vi.spyOn(MediaSourceDurationUpdater.prototype, "stopUpdating");
+
+  let mockMS: InstanceType<typeof MockMediaSource>;
+
+  beforeEach(() => {
+    mockOnSourceOpen.mockReset();
+    mockOnSourceEnded.mockReset();
+    mockOnSourceClose.mockReset();
+    mockUpdateDuration.mockReset();
+    mockStopUpdating.mockReset();
+    mockMaintainEndOfStream.mockReset();
+  });
+
+  afterEach(() => {
+    mediaSourceProps.handle = undefined;
+    mediaSourceProps.streaming = undefined;
+    vi.resetAllMocks();
+  });
+
+  it("constructs correctly and registers event listeners", () => {
+    const iface = new MainMediaSourceInterface("test-id");
+    expect(iface.id).toBe("test-id");
+    expect(iface.sourceBuffers).toEqual([]);
+    expect(iface.readyState).toBe("open");
+    expect(mockOnSourceOpen).toHaveBeenCalledOnce();
+    expect(mockOnSourceEnded).toHaveBeenCalledOnce();
+    expect(mockOnSourceClose).toHaveBeenCalledOnce();
+  });
+
+  it("uses forcedMediaSource when provided", () => {
+    const error = new Error("toto");
+    class ExtentedMediaSource extends MockMediaSource {
+      addSourceBuffer(): ISourceBuffer {
+        throw error;
+      }
+    }
+    const ForcedConstructor = ExtentedMediaSource;
+    const iface = new MainMediaSourceInterface("forced-id", ForcedConstructor);
+    expect(() => iface.addSourceBuffer(SourceBufferType.Video, "test")).toThrow(error);
+  });
+
+  it("sets handle to media-source type when mediaSource.handle is nullish", () => {
+    mediaSourceProps.handle = undefined;
+    const iface = new MainMediaSourceInterface("h-id");
+    expect(iface.handle).toMatchObject({ type: "media-source" });
+  });
+
+  it("sets handle to 'handle' type when mediaSource.handle is defined", () => {
+    const fakeHandle = new Blob();
+    mediaSourceProps.handle = fakeHandle;
+    const iface = new MainMediaSourceInterface("h-id");
+    expect(iface.handle).toMatchObject({ type: "handle", value: fakeHandle });
+  });
+
+  it("tracks streaming from the MediaSource when it is defined", () => {
+    mediaSourceProps.streaming = true;
+    const iface1 = new MainMediaSourceInterface("stream-id");
+    expect(iface1.streaming).toBe(true);
+    mediaSourceProps.streaming = false;
+    const iface2 = new MainMediaSourceInterface("stream-id");
+    expect(iface2.streaming).toBe(false);
+  });
+
+  it("updates streaming to true when 'startstreaming' fires", () => {
+    mediaSourceProps.streaming = false;
+    const iface = new MainMediaSourceInterface("stream-id");
+    mockMS = getLastMediaSourceMock();
+    mockMS._emit("startstreaming");
+    expect(iface.streaming).toBe(true);
+  });
+
+  it("updates streaming to false when 'endstreaming' fires", () => {
+    mediaSourceProps.streaming = true;
+    const iface = new MainMediaSourceInterface("stream-id");
+    mockMS = getLastMediaSourceMock();
+    mockMS._emit("endstreaming");
+    expect(iface.streaming).toBe(false);
+  });
+
+  it("triggers mediaSourceOpen when onSourceOpen callback fires", () => {
+    const iface = new MainMediaSourceInterface("open-id");
+    const listener = vi.fn();
+    iface.addEventListener("mediaSourceOpen", listener);
+    const [[, cb]] = mockOnSourceOpen.mock.calls;
+    cb();
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it("triggers mediaSourceEnded when onSourceEnded callback fires", () => {
+    const iface = new MainMediaSourceInterface("ended-id");
+    const listener = vi.fn();
+    iface.addEventListener("mediaSourceEnded", listener);
+    const [[, cb]] = mockOnSourceEnded.mock.calls;
+    cb();
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it("triggers mediaSourceClose when onSourceClose callback fires", () => {
+    const iface = new MainMediaSourceInterface("close-id");
+    const listener = vi.fn();
+    iface.addEventListener("mediaSourceClose", listener);
+    const [[, cb]] = mockOnSourceClose.mock.calls;
+    cb();
+    expect(listener).toHaveBeenCalledOnce();
+  });
+
+  it("addSourceBuffer creates and stores a MainSourceBufferInterface", () => {
+    const sb = new MockSourceBuffer();
+    vi.spyOn(MockMediaSource.prototype, "addSourceBuffer").mockReturnValue(sb);
+    const iface = new MainMediaSourceInterface("sb-id");
+    const result = iface.addSourceBuffer(
+      SourceBufferType.Video,
+      "video/mp4; codecs=avc1",
+    );
+    expect(result).toBeInstanceOf(MainSourceBufferInterface);
+    expect(iface.sourceBuffers).toHaveLength(1);
+    expect(iface.sourceBuffers[0]).toBe(result);
+  });
+
+  it("setDuration delegates to durationUpdater", () => {
+    const iface = new MainMediaSourceInterface("dur-id");
+    iface.setDuration(120, true);
+    expect(mockUpdateDuration).toHaveBeenCalledWith(120, true);
+  });
+
+  it("interruptDurationSetting delegates to durationUpdater", () => {
+    const iface = new MainMediaSourceInterface("dur-id");
+    iface.interruptDurationSetting("test-reason");
+    expect(mockStopUpdating).toHaveBeenCalledWith("test-reason");
+  });
+
+  it("maintainEndOfStream calls maintainEndOfStream util only once", () => {
+    const iface = new MainMediaSourceInterface("eos-id");
+    iface.maintainEndOfStream();
+    iface.maintainEndOfStream(); // second call should not create another canceller
+    expect(mockMaintainEndOfStream).toHaveBeenCalledOnce();
+  });
+
+  it("stopEndOfStream cancels active end-of-stream", () => {
+    const iface = new MainMediaSourceInterface("eos-id");
+    iface.maintainEndOfStream();
+    expect(mockMaintainEndOfStream).toHaveBeenCalledOnce();
+    iface.stopEndOfStream();
+    // Calling again should be a no-op (no second cancel call means no throw)
+    iface.stopEndOfStream();
+  });
+
+  it("dispose cleans up sourceBuffers and resets media source", () => {
+    const sb = new MockSourceBuffer();
+    const mockAbort = vi.spyOn(sb, "abort");
+    vi.spyOn(MockMediaSource.prototype, "addSourceBuffer").mockReturnValue(sb);
+    const iface = new MainMediaSourceInterface("dispose-id");
+    mockMS = getLastMediaSourceMock();
+    mockMS.sourceBuffers = makeMockSourceBufferList([sb]);
+    iface.addSourceBuffer(SourceBufferType.Audio, "audio/mp4; codecs=mp4a");
+    iface.dispose("test-dispose");
+    expect(mockAbort).toHaveBeenCalled();
+  });
+});
+
+describe("MainSourceBufferInterface", () => {
+  let sb: ISourceBuffer & {
+    _emit(event: string, arg?: unknown): void;
+  };
+
+  beforeEach(() => {
+    sb = new MockSourceBuffer();
+    mockTryToChangeSourceBufferType.mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  function createMainSourceBufferInterface(
+    type = SourceBufferType.Video,
+    codec = "video/mp4",
+  ) {
+    return new MainSourceBufferInterface(type, codec, sb);
+  }
+
+  it("appendBuffer returns a promise that resolves on updateend", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1, 2, 3]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4" });
+    sb._emit("updateend");
+    const result = await promise;
+    expect(Array.isArray(result)).toBe(true);
+    expect(mockAppendBuffer).toHaveBeenCalledWith(data);
+  });
+
+  it("appendBuffer rejects on SourceBuffer error event", async () => {
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4" });
+    const err = new Error("Some Message");
+    err.name = "SomeError";
+    sb._emit("error", err);
+    const thrownError = new SourceBufferError("SomeError", "Some Message", false);
+    await expect(promise).rejects.toMatchObject(thrownError);
+  });
+
+  it("appendBuffer rejects with QuotaExceededError flagged correctly", async () => {
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4" });
+    const err = new Error("QuotaExceeded");
+    err.name = "QuotaExceededError";
+    sb._emit("error", err);
+    const thrownError = new SourceBufferError(
+      "QuotaExceededError",
+      "QuotaExceeded",
+      true,
+    );
+    await expect(promise).rejects.toMatchObject(thrownError);
+  });
+
+  it("updates codec via tryToChangeSourceBufferType when a different codec is passed", async () => {
+    const iface = createMainSourceBufferInterface(SourceBufferType.Video, "video/mp4");
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/webm" });
+    sb._emit("updateend");
+    await promise;
+    expect(mockTryToChangeSourceBufferType).toHaveBeenCalledWith(sb, "video/webm");
+    expect(iface.codec).toBe("video/webm");
+  });
+
+  it("does not update codec when tryToChangeSourceBufferType returns false", async () => {
+    mockTryToChangeSourceBufferType.mockReturnValue(false);
+    const iface = createMainSourceBufferInterface(SourceBufferType.Video, "video/mp4");
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/webm" });
+    sb._emit("updateend");
+    await promise;
+    expect(iface.codec).toBe("video/mp4");
+  });
+
+  it("sets timestampOffset when it differs from current value", async () => {
+    const iface = createMainSourceBufferInterface();
+    sb.timestampOffset = 0;
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4", timestampOffset: 5 });
+    sb._emit("updateend");
+    await promise;
+    expect(sb.timestampOffset).toBe(5);
+  });
+
+  it("does not set timestampOffset when it matches current value", async () => {
+    const iface = createMainSourceBufferInterface();
+    sb.timestampOffset = 5;
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4", timestampOffset: 5 });
+    sb._emit("updateend");
+    await promise;
+    expect(sb.timestampOffset).toBe(5);
+  });
+
+  it("resets appendWindowStart to 0 when appendWindow[0] is undefined and was > 0", async () => {
+    const iface = createMainSourceBufferInterface();
+    sb.appendWindowStart = 2;
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, {
+      codec: "video/mp4",
+      appendWindow: [undefined, undefined],
+    });
+    sb._emit("updateend");
+    await promise;
+    expect(sb.appendWindowStart).toBe(0);
+  });
+
+  it("sets appendWindowStart when it differs", async () => {
+    const iface = createMainSourceBufferInterface();
+    sb.appendWindowStart = 0;
+    sb.appendWindowEnd = Infinity;
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, {
+      codec: "video/mp4",
+      appendWindow: [3, 10],
+    });
+    sb._emit("updateend");
+    await promise;
+    expect(sb.appendWindowStart).toBe(3);
+    expect(sb.appendWindowEnd).toBe(10);
+  });
+
+  it("pre-updates appendWindowEnd before setting appendWindowStart when needed", async () => {
+    const iface = createMainSourceBufferInterface();
+    sb.appendWindowStart = 0;
+    sb.appendWindowEnd = 5; // new start (8) >= current end (5) → must bump end first
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, {
+      codec: "video/mp4",
+      appendWindow: [8, 20],
+    });
+    sb._emit("updateend");
+    await promise;
+    expect(sb.appendWindowStart).toBe(8);
+    expect(sb.appendWindowEnd).toBe(20);
+  });
+
+  it("resets appendWindowEnd to Infinity when appendWindow[1] is undefined and was not Infinity", async () => {
+    const iface = createMainSourceBufferInterface();
+    sb.appendWindowEnd = 30;
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, {
+      codec: "video/mp4",
+      appendWindow: [undefined, undefined],
+    });
+    sb._emit("updateend");
+    await promise;
+    expect(sb.appendWindowEnd).toBe(Infinity);
+  });
+
+  it("merges consecutive Push operations with identical parameters", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface();
+    const data1 = new Uint8Array([1, 2]);
+    const data2 = new Uint8Array([3, 4]);
+
+    // First block all appendBuffer operation by implying that the sourcebuffer is updating
+    sb.updating = true;
+    const p1 = iface.appendBuffer(data1, { codec: "video/mp4", timestampOffset: 0 });
+    const p2 = iface.appendBuffer(data2, { codec: "video/mp4", timestampOffset: 0 });
+
+    expect(mockAppendBuffer).not.toHaveBeenCalled();
+
+    // Remove lock
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+
+    // Both segments are merged into a single appendBuffer call
+    expect(mockAppendBuffer).toHaveBeenCalledOnce();
+
+    // One updateend resolves both promises
+    sb.updating = false;
+    sb._emit("updateend");
+    const [r1, r2] = await Promise.all([p1, p2]);
+    expect(r1).toEqual(r2);
+  });
+
+  it("does NOT merge consecutive Push operations with different codecs", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface(SourceBufferType.Video, "video/mp4");
+    const data1 = new Uint8Array([1]);
+    const data2 = new Uint8Array([2]);
+
+    // First block all appendBuffer operation by implying that the sourcebuffer is updating
+    sb.updating = true;
+
+    const p1 = iface.appendBuffer(data1, { codec: "video/mp4" });
+    const p2 = iface.appendBuffer(data2, { codec: "video/webm" });
+
+    expect(mockAppendBuffer).not.toHaveBeenCalled();
+
+    // Remove lock
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+
+    // First push executed immediately
+    expect(mockAppendBuffer).toHaveBeenCalledOnce();
+
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+    await p1;
+
+    // Second push should start now
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+    await p2;
+
+    expect(mockAppendBuffer).toHaveBeenCalledTimes(2);
+  });
+
+  it("does NOT merge consecutive Push operations with different timestampOffsets", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface();
+    const data1 = new Uint8Array([1]);
+    const data2 = new Uint8Array([2]);
+
+    // First block all appendBuffer operation by implying that the sourcebuffer is updating
+    sb.updating = true;
+
+    const p1 = iface.appendBuffer(data1, { codec: "video/mp4", timestampOffset: 0 });
+    const p2 = iface.appendBuffer(data2, { codec: "video/mp4", timestampOffset: 5 });
+
+    expect(mockAppendBuffer).not.toHaveBeenCalled();
+
+    // Remove lock
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+
+    expect(mockAppendBuffer).toHaveBeenCalledOnce();
+
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+    await p1;
+
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+    await p2;
+
+    expect(mockAppendBuffer).toHaveBeenCalledTimes(2);
+  });
+
+  it("handles ArrayBuffer input in merge path", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface();
+    const buf1 = new ArrayBuffer(2);
+    new Uint8Array(buf1).set([1, 2]);
+    const buf2 = new ArrayBuffer(2);
+    new Uint8Array(buf2).set([3, 4]);
+
+    // First block all appendBuffer operation by implying that the sourcebuffer is updating
+    sb.updating = true;
+
+    const p1 = iface.appendBuffer(buf1, { codec: "video/mp4" });
+    const p2 = iface.appendBuffer(buf2, { codec: "video/mp4" });
+
+    expect(mockAppendBuffer).not.toHaveBeenCalled();
+
+    // Remove lock
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+
+    expect(mockAppendBuffer).toHaveBeenCalledOnce();
+    sb.updating = false;
+    sb._emit("updateend");
+    await Promise.all([p1, p2]);
+  });
+
+  it("handles DataView input in merge path", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface();
+    const buf = new ArrayBuffer(4);
+    const dv1 = new DataView(buf, 0, 2);
+    const dv2 = new DataView(buf, 2, 2);
+
+    // First block all appendBuffer operation by implying that the sourcebuffer is updating
+    sb.updating = true;
+
+    const p1 = iface.appendBuffer(dv1, { codec: "video/mp4" });
+    const p2 = iface.appendBuffer(dv2, { codec: "video/mp4" });
+
+    // Remove lock
+    sb.updating = false;
+    sb._emit("updateend");
+    sb.updating = true;
+
+    expect(mockAppendBuffer).toHaveBeenCalledOnce();
+    sb.updating = false;
+    sb._emit("updateend");
+    await Promise.all([p1, p2]);
+  });
+
+  it("rejects and continues queue when appendBuffer throws synchronously", async () => {
+    const iface = createMainSourceBufferInterface();
+    vi.spyOn(sb, "appendBuffer").mockImplementationOnce(() => {
+      throw new Error("random error");
+    });
+
+    const data1 = new Uint8Array([1]);
+    const data2 = new Uint8Array([2]);
+
+    const p1 = iface.appendBuffer(data1, { codec: "video/mp4" });
+    const p2 = iface.appendBuffer(data2, { codec: "video/mp4" });
+
+    const error = new SourceBufferError("Error", "random error", false);
+    await expect(p1).rejects.toMatchObject(error);
+
+    // Queue should move on – second push should now run
+    // TODO: For a synchronous error, maybe we shouldn't await an updateend?
+    sb._emit("updateend");
+    await expect(p2).resolves.toBeDefined();
+  });
+
+  it("remove returns a promise that resolves on updateend", async () => {
+    const mockRemove = vi.spyOn(MockSourceBuffer.prototype, "remove");
+    const iface = createMainSourceBufferInterface();
+    const promise = iface.remove(0, 10);
+    expect(mockRemove).toHaveBeenCalledWith(0, 10);
+    sb._emit("updateend");
+    await expect(promise).resolves.toEqual([]);
+  });
+
+  it("remove rejects when SourceBuffer.remove throws synchronously", async () => {
+    const iface = createMainSourceBufferInterface();
+    vi.spyOn(sb, "remove").mockImplementationOnce(() => {
+      throw new Error("some remove error");
+    });
+    const promise = iface.remove(0, 5);
+    const error = new SourceBufferError("Error", "some remove error", false);
+    await expect(promise).rejects.toMatchObject(error);
+  });
+
+  it("queues a remove after a pending push", async () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const mockRemove = vi.spyOn(MockSourceBuffer.prototype, "remove");
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+
+    const pushPromise = iface.appendBuffer(data, { codec: "video/mp4" });
+    const removePromise = iface.remove(0, 5);
+
+    // Only the push should have started
+    expect(mockAppendBuffer).toHaveBeenCalledOnce();
+    expect(mockRemove).not.toHaveBeenCalled();
+
+    sb._emit("updateend");
+    await pushPromise;
+
+    expect(mockRemove).toHaveBeenCalledWith(0, 5);
+    sb._emit("updateend");
+    await expect(removePromise).resolves.toBeDefined();
+  });
+
+  it("getBuffered returns ranges from the underlying SourceBuffer", () => {
+    const iface = createMainSourceBufferInterface();
+    const result = iface.getBuffered();
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("getBuffered returns empty array when accessing buffered throws", () => {
+    const iface = createMainSourceBufferInterface();
+    Object.defineProperty(sb, "buffered", {
+      get() {
+        throw new Error("buffered unavailable");
+      },
+      configurable: true,
+    });
+    const result = iface.getBuffered();
+    expect(result).toEqual([]);
+  });
+
+  it("abort calls sourceBuffer.abort and rejects pending operations", async () => {
+    const mockAbort = vi.spyOn(MockSourceBuffer.prototype, "abort");
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+
+    const p1 = iface.appendBuffer(data, { codec: "video/mp4" });
+    const p2 = iface.appendBuffer(data, { codec: "video/mp4" });
+
+    iface.abort("test-abort");
+
+    await expect(p1).rejects.toBeDefined();
+    await expect(p2).rejects.toBeDefined();
+    expect(mockAbort).toHaveBeenCalled();
+  });
+
+  it("dispose calls sourceBuffer.abort and rejects pending operations", async () => {
+    const mockAbort = vi.spyOn(MockSourceBuffer.prototype, "abort");
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+    const p1 = iface.appendBuffer(data, { codec: "video/mp4" });
+
+    iface.dispose("test-dispose");
+
+    await expect(p1).rejects.toBeDefined();
+    expect(mockAbort).toHaveBeenCalled();
+  });
+
+  it("abort does not throw even if sourceBuffer.abort throws", () => {
+    const iface = createMainSourceBufferInterface();
+    vi.spyOn(sb, "abort").mockImplementation(() => {
+      throw new Error("abort threw");
+    });
+    expect(() => iface.abort("safe")).not.toThrow();
+  });
+
+  it("resolves with empty array when buffered throws InvalidStateError on updateend", async () => {
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4" });
+
+    let callCount = 0;
+    Object.defineProperty(sb, "buffered", {
+      get() {
+        callCount++;
+        if (callCount > 1) {
+          const e = new Error("InvalidStateError");
+          e.name = "InvalidStateError";
+          throw e;
+        }
+        return { length: 0, start: () => 0, end: () => 0 };
+      },
+      configurable: true,
+    });
+
+    sb._emit("updateend");
+    await expect(promise).resolves.toEqual([]);
+  });
+
+  it("rejects with non-InvalidStateError thrown from buffered on updateend", async () => {
+    const iface = createMainSourceBufferInterface();
+    const data = new Uint8Array([1]);
+    const promise = iface.appendBuffer(data, { codec: "video/mp4" });
+
+    const e = new Error("some buffered error");
+    e.name = "SomeOtherError";
+    Object.defineProperty(sb, "buffered", {
+      get() {
+        throw e;
+      },
+      configurable: true,
+    });
+
+    sb._emit("updateend");
+    await expect(promise).rejects.toMatchObject(e);
+  });
+
+  it("logs error when error event fires with no current operations", () => {
+    createMainSourceBufferInterface();
+    // No pending operation – just fire error; should not throw
+    expect(() => sb._emit("error", new Error("orphan error"))).not.toThrow();
+    // TODO: check logs?
+  });
+
+  it("does not call appendBuffer again if sourceBuffer.updating is true", () => {
+    const mockAppendBuffer = vi.spyOn(MockSourceBuffer.prototype, "appendBuffer");
+    const iface = createMainSourceBufferInterface();
+    sb.updating = true;
+    const data = new Uint8Array([1]);
+    iface.appendBuffer(data, { codec: "video/mp4" }).catch(noop);
+    // Because updating=true _performNextOperation bails out
+    expect(mockAppendBuffer).not.toHaveBeenCalled();
+  });
+});