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

package/src/errors/__tests__/media_error.test.ts

@@ -1,10 +1,13 @@
 import { describe, it, expect } from "vitest";
-import MediaError from "../media_error";
+import type { ISerializedMediaError } from "../media_error";
+import MediaError, { deserializeMediaError } from "../media_error";
 
 describe("errors - MediaError", () => {
   it("should format a MediaError", () => {
     const reason = "test";
-    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", reason);
+    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", reason, {
+      timeInfo: { position: 5, minPosition: 10, maxPosition: 100 },
+    });
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
     expect(mediaError.type).toBe("MEDIA_ERROR");
@@ -15,7 +18,9 @@ describe("errors - MediaError", () => {
 
   it("should be able to set it as fatal", () => {
     const reason = "test";
-    const mediaError = new MediaError("MEDIA_TIME_AFTER_MANIFEST", reason);
+    const mediaError = new MediaError("MEDIA_TIME_AFTER_MANIFEST", reason, {
+      timeInfo: { position: 5, minPosition: 10, maxPosition: 100 },
+    });
     mediaError.fatal = true;
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
@@ -36,4 +41,102 @@ describe("errors - MediaError", () => {
     expect(mediaError.fatal).toBe(true);
     expect(mediaError.message).toBe("MEDIA_ERR_NETWORK: test");
   });
+
+  it("should expose and serialize custom position metadata", () => {
+    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", "test", {
+      timeInfo: {
+        position: 3,
+        minPosition: 10,
+        maxPosition: 20,
+      },
+    });
+
+    expect(mediaError.timeInfo).toEqual({
+      position: 3,
+      minPosition: 10,
+      maxPosition: 20,
+    });
+    expect(mediaError.serialize()).toEqual({
+      isSerializedError: true,
+      name: "MediaError",
+      code: "MEDIA_TIME_BEFORE_MANIFEST",
+      reason: "test",
+      tracks: undefined,
+      timeInfo: {
+        position: 3,
+        minPosition: 10,
+        maxPosition: 20,
+      },
+    });
+  });
+
+  it("should deserialize a serialized MediaError with timeInfo", () => {
+    const serializedError: ISerializedMediaError = {
+      isSerializedError: true,
+      name: "MediaError",
+      code: "MEDIA_TIME_BEFORE_MANIFEST",
+      reason: "test",
+      tracks: undefined,
+      timeInfo: {
+        position: 3,
+        minPosition: 10,
+        maxPosition: 20,
+      },
+    };
+
+    const mediaError = deserializeMediaError(serializedError);
+
+    expect(mediaError).toBeInstanceOf(MediaError);
+    expect(mediaError.code).toBe("MEDIA_TIME_BEFORE_MANIFEST");
+    expect(mediaError.message).toBe("MEDIA_TIME_BEFORE_MANIFEST: test");
+    expect(mediaError.timeInfo).toEqual(serializedError.timeInfo);
+  });
+
+  it("should deserialize a serialized MediaError with tracks", () => {
+    const serializedError: ISerializedMediaError = {
+      isSerializedError: true,
+      name: "MediaError",
+      code: "BUFFER_APPEND_ERROR",
+      reason: "test",
+      tracks: [
+        {
+          type: "audio",
+          track: {
+            id: "fra1",
+            audioDescription: false,
+            language: "fra",
+            normalized: "fra",
+            representations: [],
+          },
+        },
+      ],
+      timeInfo: undefined,
+    };
+
+    const mediaError = deserializeMediaError(serializedError);
+
+    expect(mediaError).toBeInstanceOf(MediaError);
+    expect(mediaError.code).toBe("BUFFER_APPEND_ERROR");
+    expect(mediaError.message).toBe("BUFFER_APPEND_ERROR: test");
+    expect(mediaError.tracksInfo).toEqual(serializedError.tracks);
+  });
+
+  it("should deserialize a serialized MediaError without metadata", () => {
+    const serializedError = {
+      isSerializedError: true as const,
+      name: "MediaError" as const,
+      code: "MEDIA_ERR_NETWORK" as const,
+      reason: "test",
+      tracks: undefined,
+      timeInfo: undefined,
+    };
+
+    const mediaError = deserializeMediaError(serializedError);
+
+    expect(mediaError).toBeInstanceOf(MediaError);
+    expect(mediaError.code).toBe("MEDIA_ERR_NETWORK");
+    expect(mediaError.message).toBe("MEDIA_ERR_NETWORK: test");
+    expect(mediaError.timeInfo).toBeUndefined();
+    expect(mediaError.tracksInfo).toBeUndefined();
+  });
 });

package/src/errors/index.ts

@@ -22,7 +22,7 @@ import { ErrorCodes, ErrorTypes, NetworkErrorTypes } from "./error_codes";
 import formatError from "./format_error";
 import isKnownError from "./is_known_error";
 import type { ISerializedMediaError } from "./media_error";
-import MediaError from "./media_error";
+import MediaError, { deserializeMediaError } from "./media_error";
 import type { ISerializedNetworkError } from "./network_error";
 import NetworkError from "./network_error";
 import type { ISerializedOtherError } from "./other_error";
@@ -46,6 +46,7 @@ export {
   ErrorTypes,
   formatError,
   MediaError,
+  deserializeMediaError,
   NetworkError,
   OtherError,
   NetworkErrorTypes,

package/src/errors/media_error.ts

@@ -15,16 +15,27 @@
  */
 
 import type { ITaggedTrack } from "../manifest";
+import assert from "../utils/assert";
 import type { IMediaErrorCode } from "./error_codes";
 import { ErrorTypes } from "./error_codes";
 import errorMessage from "./error_message";
 
-type ICodeWithAdaptationType =
+export type ICodeWithAdaptationType =
   | "BUFFER_APPEND_ERROR"
   | "BUFFER_FULL_ERROR"
   | "NO_PLAYABLE_REPRESENTATION"
   | "MANIFEST_INCOMPATIBLE_CODECS_ERROR";
 
+export type ICodeWithManifestPositionError =
+  | "MEDIA_TIME_BEFORE_MANIFEST"
+  | "MEDIA_TIME_AFTER_MANIFEST";
+
+interface ITimeInfo {
+  position: number;
+  minPosition: number;
+  maxPosition: number;
+}
+
 /**
  * Error linked to the media Playback.
  *
@@ -36,6 +47,7 @@ export default class MediaError extends Error {
   public readonly type: "MEDIA_ERROR";
   public readonly code: IMediaErrorCode;
   public readonly tracksInfo: ITaggedTrack[] | undefined;
+  public readonly timeInfo: ITimeInfo | undefined;
   public fatal: boolean;
   private _originalMessage: string;
 
@@ -52,13 +64,18 @@ export default class MediaError extends Error {
     },
   );
   constructor(
-    code: Exclude<IMediaErrorCode, ICodeWithAdaptationType>,
+    code: ICodeWithManifestPositionError,
+    reason: string,
+    context: {
+      timeInfo: ITimeInfo;
+    },
+  );
+  constructor(
+    code: Exclude<
+      IMediaErrorCode,
+      ICodeWithAdaptationType | ICodeWithManifestPositionError
+    >,
     reason: string,
-    context?:
-      | {
-          tracks?: undefined;
-        }
-      | undefined,
   );
   constructor(
     code: IMediaErrorCode,
@@ -66,6 +83,7 @@ export default class MediaError extends Error {
     context?:
       | {
           tracks?: ITaggedTrack[] | undefined;
+          timeInfo?: ITimeInfo;
         }
       | undefined,
   ) {
@@ -82,6 +100,9 @@ export default class MediaError extends Error {
     if (context?.tracks !== undefined && context?.tracks.length > 0) {
       this.tracksInfo = context.tracks;
     }
+    if (context?.timeInfo !== undefined) {
+      this.timeInfo = context.timeInfo;
+    }
   }
 
   /**
@@ -97,10 +118,44 @@ export default class MediaError extends Error {
       code: this.code,
       reason: this._originalMessage,
       tracks: this.tracksInfo,
+      timeInfo: this.timeInfo,
     };
   }
 }
 
+/**
+ * Re-create a `MediaError` from a serialized representation.
+ * @param {Object} serializedMediaError
+ * @returns {MediaError}
+ */
+export function deserializeMediaError(
+  serializedMediaError: ISerializedMediaError,
+): MediaError {
+  if (
+    serializedMediaError.code === "MEDIA_TIME_BEFORE_MANIFEST" ||
+    serializedMediaError.code === "MEDIA_TIME_AFTER_MANIFEST"
+  ) {
+    assert(
+      serializedMediaError.timeInfo !== undefined,
+      `The MediaError with code ${serializedMediaError.code} does not provide "timeinfo"`,
+    );
+    return new MediaError(serializedMediaError.code, serializedMediaError.reason, {
+      timeInfo: serializedMediaError.timeInfo,
+    });
+  }
+  if (
+    serializedMediaError.code === "BUFFER_APPEND_ERROR" ||
+    serializedMediaError.code === "BUFFER_FULL_ERROR" ||
+    serializedMediaError.code === "NO_PLAYABLE_REPRESENTATION" ||
+    serializedMediaError.code === "MANIFEST_INCOMPATIBLE_CODECS_ERROR"
+  ) {
+    return new MediaError(serializedMediaError.code, serializedMediaError.reason, {
+      tracks: serializedMediaError.tracks,
+    });
+  }
+  return new MediaError(serializedMediaError.code, serializedMediaError.reason);
+}
+
 /** Serializable object which allows to create a `MediaError` later. */
 export interface ISerializedMediaError {
   isSerializedError: true;
@@ -108,4 +163,5 @@ export interface ISerializedMediaError {
   code: IMediaErrorCode;
   reason: string;
   tracks: ITaggedTrack[] | undefined;
+  timeInfo?: ITimeInfo | undefined;
 }

package/src/experimental/README.md

@@ -15,5 +15,5 @@ is mainly to confine the "library path" of that feature to the
 `rx-player/experimental/features` subdirectory.
 
 Note that tools NEED to be declared in their own directory inside a `./tools/<TOOL_NAME>`
-directory, with their inner `index.js` file exporting them, as that's a requirement from
+directory, with their inner `index.ts` file exporting them, as that's a requirement from
 our exporting strategy.

package/src/features/README.md

@@ -3,8 +3,8 @@
 This directory regroups the code importing all the "features" of the RxPlayer piece by
 piece.
 
-It is mostly used for allowing a library user to only imports some features of the
-RxPlayer without importing others.
+It is mostly used for allowing a library user to import only some features of the RxPlayer
+without importing others.
 
 How this is technically done is through a global `features` Object, which will have added
 properties (which corresponds to those features' code) each time a new feature is added.
@@ -12,4 +12,4 @@ properties (which corresponds to those features' code) each time a new feature i
 ## For workers
 
 The `worker` directory contains features intended for the worker-side that will then be
-exported through the RxPlayer's `worker/features` path.
+exported through the RxPlayer's `experimental/worker/features` path.

package/src/main_thread/api/README.md

@@ -20,13 +20,12 @@ As such, its main roles are to:
 
 To facilitate those actions, the API relies on multiple building blocks:
 
-- **the `PlaybackObserver` (./playback_observer.ts)**
-
-  Provide multiple methods allowing to monitor the current playback conditions (e.g. the
-  current position and/or the current playback rate). Many RxPlayer modules rely on this
-  PlaybackObserver.
-
 - **the `option utils` (./option_utils.ts)**
 
   Parse options given to some RxPlayer API calls, to add default parameters and provide
-  inteligible warnings/errors
+  intelligible warnings/errors
+
+- **the `debug` directory (./debug/)**
+
+  Contains the logic for the debug overlay API, (e.g. that can be rendered through the
+  `createDebugElement` RxPlayer API)

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.2026043000";
     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.2026043000";
 
 /** 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);
+    });
+  });
 });
 
 /**