rx-player 4.3.1-dev.2025041002 → 4.4.0-dev.2025041400

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

@@ -4,13 +4,21 @@ import EncryptedMediaError from "../encrypted_media_error";
 describe("errors - EncryptedMediaError", () => {
   it("should format an EncryptedMediaError", () => {
     const reason = "test";
-    const encryptedMediaError = new EncryptedMediaError("KEY_LOAD_TIMEOUT", reason);
+    const encryptedMediaError = new EncryptedMediaError(
+      "MEDIA_IS_ENCRYPTED_ERROR",
+      reason,
+      {
+        keyStatuses: undefined,
+        keySystemConfiguration: undefined,
+        keySystem: undefined,
+      },
+    );
     expect(encryptedMediaError).toBeInstanceOf(Error);
     expect(encryptedMediaError.name).toBe("EncryptedMediaError");
     expect(encryptedMediaError.type).toBe("ENCRYPTED_MEDIA_ERROR");
-    expect(encryptedMediaError.code).toBe("KEY_LOAD_TIMEOUT");
+    expect(encryptedMediaError.code).toBe("MEDIA_IS_ENCRYPTED_ERROR");
     expect(encryptedMediaError.fatal).toBe(false);
-    expect(encryptedMediaError.message).toBe("KEY_LOAD_TIMEOUT: test");
+    expect(encryptedMediaError.message).toBe("MEDIA_IS_ENCRYPTED_ERROR: test");
   });
 
   it("should be able to set it as fatal", () => {
@@ -18,6 +26,11 @@ describe("errors - EncryptedMediaError", () => {
     const encryptedMediaError = new EncryptedMediaError(
       "INCOMPATIBLE_KEYSYSTEMS",
       reason,
+      {
+        keyStatuses: undefined,
+        keySystemConfiguration: undefined,
+        keySystem: undefined,
+      },
     );
     encryptedMediaError.fatal = true;
     expect(encryptedMediaError).toBeInstanceOf(Error);

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

@@ -33,7 +33,15 @@ describe("Errors - isKnownError", () => {
   });
 
   it("should return true for an EncryptedMediaError", () => {
-    const encryptedMediaError = new EncryptedMediaError("KEY_UPDATE_ERROR", "toto");
+    const encryptedMediaError = new EncryptedMediaError(
+      "INCOMPATIBLE_KEYSYSTEMS",
+      "toto",
+      {
+        keyStatuses: undefined,
+        keySystemConfiguration: undefined,
+        keySystem: undefined,
+      },
+    );
     expect(isKnownError(encryptedMediaError)).toBe(true);
   });
 });

package/src/errors/encrypted_media_error.ts

@@ -29,7 +29,9 @@ export default class EncryptedMediaError extends Error {
   public readonly name: "EncryptedMediaError";
   public readonly type: "ENCRYPTED_MEDIA_ERROR";
   public readonly code: IEncryptedMediaErrorCode;
-  public readonly keyStatuses?: IEncryptedMediaErrorKeyStatusObject[];
+  public readonly keyStatuses: IEncryptedMediaErrorKeyStatusObject[] | undefined;
+  public readonly keySystemConfiguration: MediaKeySystemConfiguration | undefined;
+  public readonly keySystem: string | undefined;
   public fatal: boolean;
   private _originalMessage: string;
 
@@ -40,18 +42,44 @@ export default class EncryptedMediaError extends Error {
   constructor(
     code: "KEY_STATUS_CHANGE_ERROR",
     reason: string,
-    supplementaryInfos: { keyStatuses: IEncryptedMediaErrorKeyStatusObject[] },
+    supplementaryInfos: {
+      keyStatuses: IEncryptedMediaErrorKeyStatusObject[];
+      keySystemConfiguration: MediaKeySystemConfiguration;
+      keySystem: string;
+    },
   );
   constructor(
-    code: Omit<IEncryptedMediaErrorCode, "KEY_STATUS_CHANGE_ERROR">,
+    code: Omit<
+      IEncryptedMediaErrorCode,
+      | "KEY_STATUS_CHANGE_ERROR"
+      | "INCOMPATIBLE_KEYSYSTEMS"
+      | "INVALID_KEY_SYSTEM"
+      | "MEDIA_IS_ENCRYPTED_ERROR"
+    >,
     reason: string,
+    supplementaryInfos: {
+      keyStatuses: undefined;
+      keySystemConfiguration: MediaKeySystemConfiguration;
+      keySystem: string;
+    },
+  );
+  constructor(
+    code: "INCOMPATIBLE_KEYSYSTEMS" | "INVALID_KEY_SYSTEM" | "MEDIA_IS_ENCRYPTED_ERROR",
+    reason: string,
+    supplementaryInfos: {
+      keyStatuses: undefined;
+      keySystemConfiguration: undefined;
+      keySystem: undefined;
+    },
   );
   constructor(
     code: IEncryptedMediaErrorCode,
     reason: string,
-    supplementaryInfos?:
-      | { keyStatuses?: IEncryptedMediaErrorKeyStatusObject[] | undefined }
-      | undefined,
+    supplementaryInfos: {
+      keyStatuses: IEncryptedMediaErrorKeyStatusObject[] | undefined;
+      keySystemConfiguration: MediaKeySystemConfiguration | undefined;
+      keySystem: string | undefined;
+    },
   ) {
     super(errorMessage(code, reason));
     // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
@@ -64,9 +92,9 @@ export default class EncryptedMediaError extends Error {
     this._originalMessage = reason;
     this.fatal = false;
 
-    if (typeof supplementaryInfos?.keyStatuses === "string") {
-      this.keyStatuses = supplementaryInfos.keyStatuses;
-    }
+    this.keyStatuses = supplementaryInfos.keyStatuses;
+    this.keySystemConfiguration = supplementaryInfos.keySystemConfiguration;
+    this.keySystem = supplementaryInfos.keySystem;
   }
 
   /**
@@ -81,6 +109,8 @@ export default class EncryptedMediaError extends Error {
       code: this.code,
       reason: this._originalMessage,
       keyStatuses: this.keyStatuses,
+      keySystemConfiguration: this.keySystemConfiguration,
+      keySystem: this.keySystem,
     };
   }
 }
@@ -95,4 +125,6 @@ export interface ISerializedEncryptedMediaError {
         keyId: ArrayBuffer;
       }>
     | undefined;
+  keySystemConfiguration: MediaKeySystemConfiguration | undefined;
+  keySystem: string | undefined;
 }

package/src/main_thread/api/public_api.ts

@@ -408,7 +408,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.3.1-dev.2025041002";
+    this.version = /* PLAYER_VERSION */ "4.4.0-dev.2025041400";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3415,7 +3415,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.3.1-dev.2025041002";
+Player.version = /* PLAYER_VERSION */ "4.4.0-dev.2025041400";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/decrypt/content_decryptor.ts

@@ -300,7 +300,11 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
 
         const { serverCertificate } = options;
         if (!isNullOrUndefined(serverCertificate)) {
-          const resSsc = await setServerCertificate(mediaKeys, serverCertificate);
+          const resSsc = await setServerCertificate(
+            mediaKeys,
+            serverCertificate,
+            mediaKeySystemAccess,
+          );
           if (resSsc.type === "error") {
             this.trigger("warning", resSsc.value);
           }
@@ -584,7 +588,7 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
     SessionEventsListener(
       mediaKeySession,
       options,
-      mediaKeySystemAccess.keySystem,
+      mediaKeySystemAccess,
       {
         onKeyUpdate: (value: IKeyUpdateValue): void => {
           const linkedKeys = getKeyIdsLinkedToSession(
@@ -715,6 +719,11 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
         throw new EncryptedMediaError(
           "KEY_GENERATE_REQUEST_ERROR",
           error instanceof Error ? error.toString() : "Unknown error",
+          {
+            keyStatuses: undefined,
+            keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+            keySystem: mediaKeySystemAccess.keySystem,
+          },
         );
       }
     }

package/src/main_thread/decrypt/find_key_system.ts

@@ -463,6 +463,11 @@ export default function getMediaKeySystemAccess(
         "No key system compatible with your wanted " +
           "configuration has been found in the current " +
           "browser.",
+        {
+          keyStatuses: undefined,
+          keySystemConfiguration: undefined,
+          keySystem: undefined,
+        },
       );
     }
 

package/src/main_thread/decrypt/get_media_keys.ts

@@ -157,6 +157,10 @@ async function createMediaKeys(
   } catch (error) {
     const message =
       error instanceof Error ? error.message : "Unknown error when creating MediaKeys.";
-    throw new EncryptedMediaError("CREATE_MEDIA_KEYS_ERROR", message);
+    throw new EncryptedMediaError("CREATE_MEDIA_KEYS_ERROR", message, {
+      keyStatuses: undefined,
+      keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+      keySystem: mediaKeySystemAccess.keySystem,
+    });
   }
 }

package/src/main_thread/decrypt/session_events_listener.ts

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import type { IMediaKeySession } from "../../compat/browser_compatibility_types";
+import type {
+  IMediaKeySession,
+  IMediaKeySystemAccess,
+} from "../../compat/browser_compatibility_types";
 import {
   onKeyError,
   onKeyMessage,
@@ -35,14 +38,15 @@ import checkKeyStatuses from "./utils/check_key_statuses";
  * depending on the configuration given.
  * @param {MediaKeySession} session - The MediaKeySession concerned.
  * @param {Object} keySystemOptions - The key system options.
- * @param {String} keySystem - The configuration keySystem used for deciphering
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess - The
+ * `MediaKeySystemAccess` that produced the linked `MediaKeys` instance.
  * @param {Object} callbacks
  * @param {Object} cancelSignal
  */
 export default function SessionEventsListener(
   session: IMediaKeySession,
   keySystemOptions: IKeySystemOption,
-  keySystem: string,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
   callbacks: ISessionEventListenerCallbacks,
   cancelSignal: CancellationSignal,
 ): void {
@@ -70,7 +74,13 @@ export default function SessionEventsListener(
     session,
     (evt) => {
       manualCanceller.cancel();
-      callbacks.onError(new EncryptedMediaError("KEY_ERROR", (evt as Event).type));
+      callbacks.onError(
+        new EncryptedMediaError("KEY_ERROR", (evt as Event).type, {
+          keyStatuses: undefined,
+          keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+          keySystem: mediaKeySystemAccess.keySystem,
+        }),
+      );
     },
     manualCanceller.signal,
   );
@@ -120,7 +130,11 @@ export default function SessionEventsListener(
             log.info("DRM: No license given, skipping session.update");
           } else {
             try {
-              await updateSessionWithMessage(session, licenseObject);
+              await updateSessionWithMessage(
+                session,
+                licenseObject,
+                mediaKeySystemAccess,
+              );
             } catch (err) {
               manualCanceller.cancel();
               callbacks.onError(err);
@@ -132,7 +146,7 @@ export default function SessionEventsListener(
             return;
           }
           manualCanceller.cancel();
-          const formattedError = formatGetLicenseError(err);
+          const formattedError = formatGetLicenseError(err, mediaKeySystemAccess);
 
           if (!isNullOrUndefined(err)) {
             const { fallbackOnLastTry } = err as {
@@ -170,7 +184,7 @@ export default function SessionEventsListener(
     const { warning, blacklistedKeyIds, whitelistedKeyIds } = checkKeyStatuses(
       session,
       keySystemOptions,
-      keySystem,
+      mediaKeySystemAccess,
     );
     if (warning !== undefined) {
       callbacks.onWarning(warning);
@@ -237,7 +251,8 @@ export default function SessionEventsListener(
         error instanceof GetLicenseTimeoutError ||
         isNullOrUndefined(error) ||
         (error as { noRetry?: boolean }).noRetry !== true,
-      onRetry: (error: unknown) => callbacks.onWarning(formatGetLicenseError(error)),
+      onRetry: (error: unknown) =>
+        callbacks.onWarning(formatGetLicenseError(error, mediaKeySystemAccess)),
     };
   }
 }
@@ -257,19 +272,35 @@ export interface ISessionEventListenerCallbacks {
  * Format an error returned by a `getLicense` call to a proper form as defined
  * by the RxPlayer's API.
  * @param {*} error
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess - The
+ * `MediaKeySystemAccess` that produced the linked `MediaKeys` instance.
+ * This parameter is mainly useful for error generation.
  * @returns {Error}
  */
-function formatGetLicenseError(error: unknown): IPlayerError {
+function formatGetLicenseError(
+  error: unknown,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
+): IPlayerError {
   if (error instanceof GetLicenseTimeoutError) {
     return new EncryptedMediaError(
       "KEY_LOAD_TIMEOUT",
       "The license server took too much time to " + "respond.",
+      {
+        keyStatuses: undefined,
+        keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+        keySystem: mediaKeySystemAccess.keySystem,
+      },
     );
   }
 
   const err = new EncryptedMediaError(
     "KEY_LOAD_ERROR",
     "An error occured when calling `getLicense`.",
+    {
+      keyStatuses: undefined,
+      keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+      keySystem: mediaKeySystemAccess.keySystem,
+    },
   );
   if (
     !isNullOrUndefined(error) &&
@@ -284,18 +315,26 @@ function formatGetLicenseError(error: unknown): IPlayerError {
  * Call MediaKeySession.update with the given `message`, if defined.
  * @param {MediaKeySession} session
  * @param {ArrayBuffer|TypedArray|null} message
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess - The
+ * `MediaKeySystemAccess` that produced the linked `MediaKeys` instance.
+ * This parameter is mainly useful for error generation.
  * @returns {Promise}
  */
 async function updateSessionWithMessage(
   session: IMediaKeySession,
   message: BufferSource,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
 ): Promise<void> {
   log.info("DRM: Updating MediaKeySession with message");
   try {
     await session.update(message);
   } catch (error) {
     const reason = error instanceof Error ? error.toString() : "`session.update` failed";
-    throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
+    throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason, {
+      keyStatuses: undefined,
+      keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+      keySystem: mediaKeySystemAccess.keySystem,
+    });
   }
   log.info("DRM: MediaKeySession update succeeded.");
 }

package/src/main_thread/decrypt/set_server_certificate.ts

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import type { IMediaKeys } from "../../compat/browser_compatibility_types";
+import type {
+  IMediaKeys,
+  IMediaKeySystemAccess,
+} from "../../compat/browser_compatibility_types";
 import { EncryptedMediaError, isKnownError } from "../../errors";
 import log from "../../log";
 import type { IPlayerError } from "../../public_types";
@@ -32,11 +35,15 @@ import ServerCertificateStore from "./utils/server_certificate_store";
  *
  * @param {MediaKeys} mediaKeys
  * @param {ArrayBuffer} serverCertificate
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess - The
+ * `MediaKeySystemAccess` that produced the `MediaKeys` instance provided.
+ * This parameter is mainly useful for error generation.
  * @returns {Promise}
  */
 async function setServerCertificate(
   mediaKeys: IMediaKeys,
   serverCertificate: BufferSource,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
 ): Promise<unknown> {
   try {
     const res = await mediaKeys.setServerCertificate(serverCertificate);
@@ -51,7 +58,11 @@ async function setServerCertificate(
     );
     const reason =
       error instanceof Error ? error.toString() : "`setServerCertificate` error";
-    throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason);
+    throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason, {
+      keyStatuses: undefined,
+      keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+      keySystem: mediaKeySystemAccess.keySystem,
+    });
   }
 }
 
@@ -60,11 +71,15 @@ async function setServerCertificate(
  * and complete.
  * @param {MediaKeys} mediaKeys
  * @param {ArrayBuffer} serverCertificate
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess - The
+ * `MediaKeySystemAccess` that produced the `MediaKeys` instance provided.
+ * This parameter is mainly useful for error generation.
  * @returns {Promise.<Object>}
  */
 export default async function trySettingServerCertificate(
   mediaKeys: IMediaKeys,
   serverCertificate: BufferSource,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
 ): Promise<
   | { type: "success"; value: unknown }
   | { type: "already-has-one" }
@@ -90,7 +105,11 @@ export default async function trySettingServerCertificate(
   // Calling `prepare` allow to invalidate temporarily that status.
   ServerCertificateStore.prepare(mediaKeys);
   try {
-    const result = await setServerCertificate(mediaKeys, serverCertificate);
+    const result = await setServerCertificate(
+      mediaKeys,
+      serverCertificate,
+      mediaKeySystemAccess,
+    );
     ServerCertificateStore.set(mediaKeys, serverCertificate);
     return { type: "success", value: result };
   } catch (error) {
@@ -99,6 +118,11 @@ export default async function trySettingServerCertificate(
       : new EncryptedMediaError(
           "LICENSE_SERVER_CERTIFICATE_ERROR",
           "Unknown error when setting the server certificate.",
+          {
+            keyStatuses: undefined,
+            keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+            keySystem: mediaKeySystemAccess.keySystem,
+          },
         );
     return { type: "error" as const, value: formattedErr };
   }

package/src/main_thread/decrypt/utils/check_key_statuses.ts

@@ -14,7 +14,10 @@
  * limitations under the License.
  */
 
-import type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
+import type {
+  IMediaKeySession,
+  IMediaKeySystemAccess,
+} from "../../../compat/browser_compatibility_types";
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
 import log from "../../../log";
@@ -79,13 +82,14 @@ type IKeyStatusesForEach = (
  * @param {MediaKeySession} session - The MediaKeySession from which the keys
  * will be checked.
  * @param {Object} options
- * @param {String} keySystem - The configuration keySystem used for deciphering
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess - The
+ * `MediaKeySystemAccess` that produced the linked `MediaKeys` instance.
  * @returns {Object} - Warnings to send, whitelisted and blacklisted key ids.
  */
 export default function checkKeyStatuses(
   session: IMediaKeySession,
   options: IKeyStatusesCheckingOptions,
-  keySystem: string,
+  mediaKeySystemAccess: IMediaKeySystemAccess,
 ): {
   warning: EncryptedMediaError | undefined;
   blacklistedKeyIds: Uint8Array[];
@@ -107,7 +111,10 @@ export default function checkKeyStatuses(
         ];
       })();
 
-      const keyId = getUUIDKidFromKeyStatusKID(keySystem, new Uint8Array(keyStatusKeyId));
+      const keyId = getUUIDKidFromKeyStatusKID(
+        mediaKeySystemAccess.keySystem,
+        new Uint8Array(keyStatusKeyId),
+      );
 
       const keyStatusObj = { keyId: keyId.buffer, keyStatus };
 
@@ -120,7 +127,11 @@ export default function checkKeyStatuses(
           const error = new EncryptedMediaError(
             "KEY_STATUS_CHANGE_ERROR",
             `A decryption key expired (${bytesToHex(keyId)})`,
-            { keyStatuses: [keyStatusObj, ...badKeyStatuses] },
+            {
+              keyStatuses: [keyStatusObj, ...badKeyStatuses],
+              keySystem: mediaKeySystemAccess.keySystem,
+              keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+            },
           );
 
           if (onKeyExpiration === "error" || onKeyExpiration === undefined) {
@@ -153,7 +164,11 @@ export default function checkKeyStatuses(
           const error = new EncryptedMediaError(
             "KEY_STATUS_CHANGE_ERROR",
             `A "${keyStatus}" status has been encountered (${bytesToHex(keyId)})`,
-            { keyStatuses: [keyStatusObj, ...badKeyStatuses] },
+            {
+              keyStatuses: [keyStatusObj, ...badKeyStatuses],
+              keySystem: mediaKeySystemAccess.keySystem,
+              keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+            },
           );
           switch (onKeyInternalError) {
             case undefined:
@@ -185,7 +200,11 @@ export default function checkKeyStatuses(
           const error = new EncryptedMediaError(
             "KEY_STATUS_CHANGE_ERROR",
             `A "${keyStatus}" status has been encountered (${bytesToHex(keyId)})`,
-            { keyStatuses: [keyStatusObj, ...badKeyStatuses] },
+            {
+              keyStatuses: [keyStatusObj, ...badKeyStatuses],
+              keySystem: mediaKeySystemAccess.keySystem,
+              keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+            },
           );
           switch (onKeyOutputRestricted) {
             case undefined:
@@ -223,7 +242,11 @@ export default function checkKeyStatuses(
     warning = new EncryptedMediaError(
       "KEY_STATUS_CHANGE_ERROR",
       "One or several problematic key statuses have been encountered",
-      { keyStatuses: badKeyStatuses },
+      {
+        keyStatuses: badKeyStatuses,
+        keySystem: mediaKeySystemAccess.keySystem,
+        keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+      },
     );
   }
   return { warning, blacklistedKeyIds, whitelistedKeyIds };

package/src/main_thread/decrypt/utils/media_keys_attacher.ts

@@ -255,6 +255,11 @@ async function attachMediaKeys(
     throw new EncryptedMediaError(
       "MEDIA_KEYS_ATTACHMENT_ERROR",
       "Could not attach the MediaKeys to the media element: " + errMessage,
+      {
+        keyStatuses: undefined,
+        keySystemConfiguration: mediaKeysInfo.mediaKeySystemAccess.getConfiguration(),
+        keySystem: mediaKeysInfo.mediaKeySystemAccess.keySystem,
+      },
     );
   }
 }

package/src/main_thread/init/multi_thread_content_initializer.ts

@@ -1247,7 +1247,11 @@ export default class MultiThreadContentInitializer extends ContentInitializer {
             return;
           }
           stopListening();
-          const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+          const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg, {
+            keyStatuses: undefined,
+            keySystemConfiguration: undefined,
+            keySystem: undefined,
+          });
           this._onFatalError(err);
         },
         { clearSignal: cancelSignal },
@@ -2121,13 +2125,14 @@ function formatWorkerError(sentError: ISentError): IPlayerError {
         tracks: sentError.tracks,
       });
     case "EncryptedMediaError":
-      if (sentError.code === "KEY_STATUS_CHANGE_ERROR") {
-        return new EncryptedMediaError(sentError.code, sentError.reason, {
-          keyStatuses: sentError.keyStatuses ?? [],
-        });
-      } else {
-        return new EncryptedMediaError(sentError.code, sentError.reason);
-      }
+      // We assume that everything have already been checked Worker-side here
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      return new EncryptedMediaError(sentError.code, sentError.reason, {
+        keyStatuses: sentError.keyStatuses,
+        keySystemConfiguration: sentError.keySystemConfiguration,
+        keySystem: sentError.keySystem,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
     case "OtherError":
       return new OtherError(sentError.code, sentError.reason);
   }

package/src/main_thread/init/utils/initialize_content_decryption.ts

@@ -155,7 +155,11 @@ export default function initializeContentDecryption(
       value: EncryptedMediaError;
     };
   } {
-    const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+    const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg, {
+      keyStatuses: undefined,
+      keySystemConfiguration: undefined,
+      keySystem: undefined,
+    });
     const ref = new SharedReference({
       initializationState: { type: "initialized" as const, value: null },
       drmSystemId: undefined,

package/.vscode/settings.json

@@ -1 +0,0 @@
-{}