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

package/src/main_thread/api/public_api.ts

@@ -437,7 +437,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026033100";
+    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026041501";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -1244,31 +1244,31 @@ class Player extends EventEmitter<IPublicAPIEvent> {
           ) {
             log.warn(
               "API",
-              "You only set a representationFilter function in a mulithreaded mode, ignoring it...",
+              "You set a `representationFilter` function without a `workerId` while loading in multithread mode. That function cannot run in the worker, so it will be ignored.",
             );
           }
         }
         if (
           transportOptions.manifestLoader !== undefined &&
-          !isNullOrUndefined(transportOptions.manifestLoader.workerId)
+          !isNullOrUndefined(transportOptions.manifestLoader.fn)
         ) {
           transportOptions.manifestLoader.fn = undefined;
-          if (isNullOrUndefined(transportOptions.manifestLoader.fn)) {
+          if (isNullOrUndefined(transportOptions.manifestLoader.workerId)) {
             log.warn(
               "API",
-              "You only set a manifestLoader function in a mulithreaded mode, ignoring it...",
+              "You set a `manifestLoader` function without a `workerId` while loading in multithread mode. That function cannot run in the worker, so it will be ignored.",
             );
           }
         }
         if (
           transportOptions.segmentLoader !== undefined &&
-          !isNullOrUndefined(transportOptions.segmentLoader.workerId)
+          !isNullOrUndefined(transportOptions.segmentLoader.fn)
         ) {
           transportOptions.segmentLoader.fn = undefined;
-          if (isNullOrUndefined(transportOptions.segmentLoader.fn)) {
+          if (isNullOrUndefined(transportOptions.segmentLoader.workerId)) {
             log.warn(
               "API",
-              "You only set a segmentLoader function in a mulithreaded mode, ignoring it...",
+              "You set a `segmentLoader` function without a `workerId` while loading in multithread mode. That function cannot run in the worker, so it will be ignored.",
             );
           }
         }
@@ -3029,6 +3029,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     contentInfos: IPublicApiContentInfos,
     updates: IPeriodsUpdateResult,
   ): void {
+    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+      return; // Event for another content
+    }
     if (this._priv_contentInfos === null || this._priv_contentInfos.manifest === null) {
       return;
     }
@@ -3210,7 +3213,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       "audioRepresentationChange",
       isNullOrUndefined(audioRepresentation)
         ? audioRepresentation
-        : toVideoRepresentation(audioRepresentation),
+        : toAudioRepresentation(audioRepresentation),
       cancelSignal,
     );
     const videoRepresentation = this.__priv_getCurrentRepresentations()?.video ?? null;
@@ -3747,6 +3750,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    * to the content for which the error was received.
    */
   private _priv_onFatalError(err: unknown, contentInfos: IPublicApiContentInfos): void {
+    if (contentInfos.contentId !== this._priv_contentInfos?.contentId) {
+      return; // Event for another content
+    }
     const formattedError = formatError(err, {
       defaultCode: "NONE",
       defaultReason: "An unknown error stopped content playback.",
@@ -3831,7 +3837,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return true;
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026033100";
+Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026041501";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/decrypt/README.md

@@ -12,11 +12,11 @@ imported by outside code).
 ## Overview
 
 This directory exports the `ContentDecryptor`, which allows to easily interface with the
-browser APIs for decrypting an encrypted content, it follows the
-[Encrypted Media Extensions recommandations](https://www.w3.org/TR/encrypted-media/).
+browser APIs for decrypting encrypted content. It follows the
+[Encrypted Media Extensions recommendations](https://www.w3.org/TR/encrypted-media/).
 
-The `ContentDecryptor` is a module isolated from the rest of the player taking a form of a
-class. It starts initializing decryption capabilities as soon as it is instanciated and
+The `ContentDecryptor` is a module isolated from the rest of the player taking the form of
+a class. It starts initializing decryption capabilities as soon as it is instantiated and
 emits various events to communicate with external code.
 
 A central concept of the `ContentDecryptor` is its states. As decryption initialization

package/src/main_thread/decrypt/__tests__/__global__/content_decryptor.test.ts

@@ -1,10 +1,52 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
+import getEmeApiImplementation from "../../../../compat/eme";
+import { EncryptedMediaError } from "../../../../errors";
+import type { IKeySystemOption } from "../../../../public_types";
+import assert from "../../../../utils/assert";
 import { getMissingKeyIds } from "../../content_decryptor";
+import { ContentDecryptorState } from "../../types";
+import { defaultKSConfig, mockCompat } from "./utils";
+
+const mocks = vi.hoisted(() => {
+  return {
+    shouldRenewMediaKeySystemAccess: vi.fn(() => false),
+    canReuseMediaKeys: vi.fn(() => true),
+    onEncrypted: vi.fn(),
+    requestMediaKeySystemAccess: vi.fn(),
+    setMediaKeys: vi.fn(),
+    getInitData: vi.fn(),
+    generateKeyRequest: vi.fn(),
+  };
+});
+vi.mock("../../../../compat/should_renew_media_key_system_access", () => ({
+  default: mocks.shouldRenewMediaKeySystemAccess,
+}));
+vi.mock("../../../../compat/can_reuse_media_keys", () => ({
+  default: mocks.canReuseMediaKeys,
+}));
+vi.mock("../../../../compat/eme", () => ({
+  default: () => ({
+    onEncrypted: mocks.onEncrypted,
+    requestMediaKeySystemAccess: mocks.requestMediaKeySystemAccess,
+    setMediaKeys: mocks.setMediaKeys,
+  }),
+  getInitData: mocks.getInitData,
+  generateKeyRequest: mocks.generateKeyRequest,
+  closeSession: vi.fn(),
+  loadSession: vi.fn(),
+}));
 
 describe("content_decryptor - blacklist missing key Ids", () => {
   beforeEach(() => {
     vi.resetModules();
     vi.restoreAllMocks();
+    mocks.shouldRenewMediaKeySystemAccess.mockReset();
+    mocks.canReuseMediaKeys.mockReset();
+    mocks.onEncrypted.mockReset();
+    mocks.requestMediaKeySystemAccess.mockReset();
+    mocks.setMediaKeys.mockReset();
+    mocks.getInitData.mockReset();
+    mocks.generateKeyRequest.mockReset();
   });
 
   it("should return an empty array if actualKeyIds contains all expectedKeyIds", () => {
@@ -43,3 +85,96 @@ describe("content_decryptor - blacklist missing key Ids", () => {
     expect(result).toEqual([new Uint8Array([2]), new Uint8Array([4])]);
   });
 });
+
+describe("content_decryptor - session decommissioning", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    mocks.shouldRenewMediaKeySystemAccess.mockReset();
+    mocks.canReuseMediaKeys.mockReset();
+    mocks.onEncrypted.mockReset();
+    mocks.requestMediaKeySystemAccess.mockReset();
+    mocks.setMediaKeys.mockReset();
+    mocks.getInitData.mockReset();
+    mocks.generateKeyRequest.mockReset();
+  });
+
+  it("should only remove the decommissioned session from tracked sessions", async () => {
+    vi.resetModules();
+    const videoElt = document.createElement("video");
+    mockCompat(mocks);
+    const sessionCallbacks: Array<{ onError: (err: unknown) => void }> = [];
+    vi.doMock("../../session_events_listener", () => ({
+      __esModule: true,
+      default: vi.fn(
+        (_session: unknown, _options: unknown, _access: unknown, callbacks: unknown) => {
+          sessionCallbacks.push(callbacks as { onError: (err: unknown) => void });
+        },
+      ),
+      BlacklistedSessionError: class BlacklistedSessionError extends Error {},
+    }));
+    const { DecommissionedSessionError } = await import("../../utils/check_key_statuses");
+    const { default: ContentDecryptor } = await import("../../content_decryptor");
+
+    const mockGetLicense = vi.fn(() => Promise.resolve(new Uint8Array([1, 2, 3, 4])));
+    const ksConfig: IKeySystemOption[] = [
+      {
+        type: "com.widevine.alpha",
+        getLicense: mockGetLicense,
+        onKeyInternalError: "close-session",
+      },
+    ];
+
+    const eme = getEmeApiImplementation("auto");
+    assert(eme !== null, "Expected to have an EME implementation");
+    const contentDecryptor = new ContentDecryptor(eme, videoElt, ksConfig);
+
+    await new Promise<void>((res, rej) => {
+      contentDecryptor.addEventListener("stateChange", (state) => {
+        if (state !== ContentDecryptorState.WaitingForAttachment) {
+          rej(new Error(`Unexpected state: ${state}`));
+          return;
+        }
+        contentDecryptor.removeEventListener("stateChange");
+        contentDecryptor.attach();
+        res();
+      });
+    });
+
+    contentDecryptor.onInitializationData({
+      type: "cenc",
+      values: [{ systemId: "15", data: new Uint8Array([1, 1, 1]) }],
+    });
+    contentDecryptor.onInitializationData({
+      type: "cenc",
+      values: [{ systemId: "15", data: new Uint8Array([2, 2, 2]) }],
+    });
+    contentDecryptor.onInitializationData({
+      type: "cenc",
+      values: [{ systemId: "15", data: new Uint8Array([3, 3, 3]) }],
+    });
+
+    await new Promise((res) => setTimeout(res, 120));
+
+    expect(
+      (contentDecryptor as unknown as { _currentSessions: unknown[] })._currentSessions,
+    ).toHaveLength(3);
+
+    sessionCallbacks[1].onError(
+      new DecommissionedSessionError(
+        new EncryptedMediaError("KEY_LOAD_ERROR", "forced decommissioning", {
+          keyStatuses: undefined,
+          keySystemConfiguration: defaultKSConfig[0],
+          keySystem: "com.widevine.alpha",
+        }),
+      ),
+    );
+    await new Promise((res) => setTimeout(res, 30));
+
+    expect(
+      (contentDecryptor as unknown as { _currentSessions: unknown[] })._currentSessions,
+    ).toHaveLength(2);
+
+    contentDecryptor.dispose(undefined);
+  });
+});

package/src/main_thread/decrypt/__tests__/__global__/get_license.test.ts

@@ -284,6 +284,76 @@ describe("decrypt - global tests - getLicense", () => {
       ignoreLicenseRequests: false,
     });
   }, 15000);
+
+  it("should emit KEY_LOAD_TIMEOUT when getLicense times out", async () => {
+    const initData = new Uint8Array([54, 55, 75]);
+    const initDataEvent = {
+      type: "cenc",
+      values: [{ systemId: "15", data: initData }],
+    };
+    const challenge = formatFakeChallengeFromInitData(initData, "cenc");
+    const mediaKeySession = new MediaKeySessionImpl();
+    vi.spyOn(MediaKeysImpl.prototype, "createSession").mockReturnValue(mediaKeySession);
+    const mockGetLicense = vi.fn(() => {
+      return new Promise<BufferSource>((resolve) => {
+        setTimeout(() => {
+          resolve(challenge);
+        }, 30);
+      });
+    });
+
+    const videoElt = document.createElement("video");
+    mockCompat(mocks);
+
+    await new Promise<void>((res, rej) => {
+      const ksConfig: IKeySystemOption[] = [
+        {
+          type: "com.widevine.alpha",
+          getLicense: mockGetLicense,
+          getLicenseConfig: {
+            retry: 0,
+            timeout: 5,
+          },
+        },
+      ];
+      const eme = getEmeApiImplementation("auto");
+      assert(eme !== null);
+      const contentDecryptor = new ContentDecryptor(eme, videoElt, ksConfig);
+
+      contentDecryptor.addEventListener("stateChange", (newState: number) => {
+        if (newState !== ContentDecryptorState.WaitingForAttachment) {
+          rej(new Error(`Unexpected state: ${newState}`));
+          return;
+        }
+        contentDecryptor.removeEventListener("stateChange");
+        contentDecryptor.attach();
+      });
+
+      contentDecryptor.addEventListener("warning", (warning: Error) => {
+        rej(new Error(`Unexpected warning: ${warning.toString()}`));
+      });
+
+      contentDecryptor.addEventListener("error", (error: Error) => {
+        try {
+          expect(error).toBeInstanceOf(Error);
+          expect((error as IPlayerError).name).toEqual("EncryptedMediaError");
+          expect((error as IPlayerError).type).toEqual("ENCRYPTED_MEDIA_ERROR");
+          expect((error as IPlayerError).code).toEqual("KEY_LOAD_TIMEOUT");
+          expect((error as IPlayerError).message).toEqual(
+            "KEY_LOAD_TIMEOUT: The license server took too much time to respond.",
+          );
+          expect(mockGetLicense).toHaveBeenCalledTimes(1);
+          expect(mockGetLicense).toHaveBeenNthCalledWith(1, challenge, "license-request");
+          contentDecryptor.dispose(undefined);
+          res();
+        } catch (e) {
+          rej(e);
+        }
+      });
+
+      contentDecryptor.onInitializationData(initDataEvent);
+    });
+  });
 });
 
 /**

package/src/main_thread/decrypt/__tests__/__global__/server_certificate.test.ts

@@ -291,4 +291,48 @@ describe("decrypt - global tests - server certificate", () => {
       }, 10);
     });
   });
+
+  it("should continue if setServerCertificate resolves to false and retry later", () => {
+    const videoElt = document.createElement("video");
+    mockCompat(mocks);
+    const mockSetServerCertificate = vi
+      .spyOn(MediaKeysImpl.prototype, "setServerCertificate")
+      .mockImplementationOnce((_serverCertificate: BufferSource): Promise<false> => {
+        return Promise.resolve(false);
+      })
+      .mockImplementationOnce((_serverCertificate: BufferSource): Promise<true> => {
+        return Promise.resolve(true);
+      });
+
+    const eme = getEmeApiImplementation("auto");
+    assert(eme !== null, "Expected to have an EME implementation");
+    const firstDecryptor = new ContentDecryptor(eme, videoElt, ksConfigCert);
+
+    return new Promise<void>((res) => {
+      firstDecryptor.addEventListener("stateChange", (state) => {
+        if (state === ContentDecryptorState.WaitingForAttachment) {
+          firstDecryptor.removeEventListener("stateChange");
+          firstDecryptor.attach();
+        }
+      });
+
+      setTimeout(() => {
+        firstDecryptor.dispose(undefined);
+
+        const secondDecryptor = new ContentDecryptor(eme, videoElt, ksConfigCert);
+        secondDecryptor.addEventListener("stateChange", (state) => {
+          if (state === ContentDecryptorState.WaitingForAttachment) {
+            secondDecryptor.removeEventListener("stateChange");
+            secondDecryptor.attach();
+          }
+        });
+
+        setTimeout(() => {
+          secondDecryptor.dispose(undefined);
+          expect(mockSetServerCertificate).toHaveBeenCalledTimes(2);
+          res();
+        }, 10);
+      }, 10);
+    });
+  });
 });

package/src/main_thread/decrypt/__tests__/__global__/utils.ts

@@ -121,7 +121,7 @@ export class MediaKeyStatusMapImpl {
     ) => void,
     thisArg?: unknown,
   ): void {
-    this._map.forEach((value, key) => callbackfn.bind(thisArg, value, key, this));
+    this._map.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
   }
 
   public _setKeyStatus(keyId: BufferSource, value: MediaKeyStatus | undefined): void {
@@ -222,7 +222,7 @@ export class MediaKeysImpl {
     return new MediaKeySessionImpl();
   }
 
-  setServerCertificate(_serverCertificate: BufferSource): Promise<true> {
+  setServerCertificate(_serverCertificate: BufferSource): Promise<boolean> {
     return Promise.resolve(true);
   }
 }

package/src/main_thread/decrypt/content_decryptor.ts

@@ -309,6 +309,11 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
           );
           if (resSsc.type === "error") {
             this.trigger("warning", resSsc.value);
+          } else if (resSsc.type === "not-supported") {
+            log.warn(
+              "DRM",
+              "Server certificate is not supported by the current MediaKeys.",
+            );
           }
         }
 
@@ -654,7 +659,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
             this._lockInitDataQueue();
             const indexOf = this._currentSessions.indexOf(sessionInfo);
             if (indexOf >= 0) {
-              this._currentSessions.splice(indexOf);
+              this._currentSessions.splice(indexOf, 1);
             }
             if (initializationData.content !== undefined) {
               this.trigger("keyIdsCompatibilityUpdate", {

package/src/main_thread/decrypt/session_events_listener.ts

@@ -400,7 +400,7 @@ export class GetLicenseTimeoutError extends Error {
   constructor(message: string) {
     super(message);
     // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
-    Object.setPrototypeOf(this, BlacklistedSessionError.prototype);
+    Object.setPrototypeOf(this, GetLicenseTimeoutError.prototype);
     this.message = message;
   }
 }

package/src/main_thread/decrypt/set_server_certificate.ts

@@ -84,6 +84,7 @@ export default async function trySettingServerCertificate(
 ): Promise<
   | { type: "success"; value: unknown }
   | { type: "already-has-one" }
+  | { type: "not-supported" }
   | { type: "method-not-implemented" }
   | { type: "error"; value: IPlayerError }
 > {
@@ -112,6 +113,10 @@ export default async function trySettingServerCertificate(
       serverCertificate,
       mediaKeySystemAccess,
     );
+    if (result === false) {
+      log.warn("DRM", "MediaKeys ignored the server certificate. Continuing without it.");
+      return { type: "not-supported" };
+    }
     ServerCertificateStore.set(mediaKeys, serverCertificate);
     return { type: "success", value: result };
   } catch (error) {