rx-player 4.3.0-dev.2025012900 → 4.3.0-dev.2025030400

package/src/core/main/worker/content_preparer.ts

@@ -26,18 +26,52 @@ import type { IManifestRefreshSettings } from "../../fetchers";
 import { ManifestFetcher, SegmentQueueCreator } from "../../fetchers";
 import SegmentSinksStore from "../../segment_sinks";
 import type { INeedsMediaSourceReloadPayload } from "../../stream";
-import DecipherabilityFreezeDetector from "../common/DecipherabilityFreezeDetector";
+import FreezeResolver from "../common/FreezeResolver";
 import { limitVideoResolution, throttleVideoBitrate } from "./globals";
 import sendMessage, { formatErrorForSender } from "./send_message";
 import TrackChoiceSetter from "./track_choice_setter";
 import WorkerTextDisplayerInterface from "./worker_text_displayer_interface";
 
+/** Function allowing to associate a unique identifier to all created `MediaSource` */
 const generateMediaSourceId = idGenerator();
 
+/**
+ * Class facilitating the workflows behind loading a new content for the
+ * RxPlayer Core:
+ *
+ *   - Handle Manifest fetching and Manifest updates.
+ *
+ *   - Handle the `MediaSource`'s creation and indirectly of its `SourceBuffer`s
+ *     as well as handling "MediaSource reloading".
+ *
+ *   - initialize various modules (`segmentQueueCreator`, CmcdDataBuilder`,
+ *     `RepresentationEstimator`) linked to the initialized content.
+ *
+ * You can start loading a content through the `initializeNewContent` method.
+ *
+ * When a content is linked to the `ContentPreparer` you can inspect the
+ * different initialized modules by calling its `getCurrentContent` method.
+ *
+ * @class ContentPreparer
+ */
 export default class ContentPreparer {
+  /**
+   * Information on the content linked to that `ContentPreparer` through its
+   * `initializeNewContent` method.
+   * `null` if no content is initialized.
+   */
   private _currentContent: IPreparedContentData | null;
-  private _currentMediaSourceCanceller: TaskCanceller;
+  /**
+   * TaskCanceller which is triggered when the currently-initialized content is
+   * not needed anymore, because we stopped it since or switched to a new content.
+   */
   private _contentCanceller: TaskCanceller;
+  /**
+   * TaskCanceller which is triggered when the currently-created MediaSource is
+   * not needed anymore, either because the content has changed or because we
+   * had to reload.
+   */
+  private _currentMediaSourceCanceller: TaskCanceller;
 
   /** @see constructor */
   private _hasMseInWorker: boolean;
@@ -73,6 +107,18 @@ export default class ContentPreparer {
     this._contentCanceller = contentCanceller;
   }
 
+  /**
+   * Start fetching the wanted content's Manifest and initializing the various
+   * modules stored by the `ContentPreparer` linked to that content.
+   *
+   * The returned Promise resolves with the parsed Manifest when those modules
+   * are all ready and you can thus begin to load the content.
+   *
+   * Reject if it failed to do so.
+   * @param {Object} context - Information on the content that should be
+   * initialized.
+   * @returns {Promise.<Object>}
+   */
   public initializeNewContent(
     context: IContentInitializationData,
   ): Promise<IManifestMetadata> {
@@ -84,7 +130,8 @@ export default class ContentPreparer {
 
       currentMediaSourceCanceller.linkToSignal(contentCanceller.signal);
 
-      const { contentId, url, hasText, transportOptions } = context;
+      const { contentId, url, hasText, transportOptions, enableRepresentationAvoidance } =
+        context;
       let manifest: IManifest | null = null;
 
       // TODO better way
@@ -139,7 +186,7 @@ export default class ContentPreparer {
       const trackChoiceSetter = new TrackChoiceSetter();
 
       const [mediaSource, segmentSinksStore, workerTextSender] =
-        createMediaSourceAndBuffersStore(
+        createMediaSourceInterfaceAndSegmentSinksStore(
           contentId,
           {
             hasMseInWorker: this._hasMseInWorker,
@@ -148,13 +195,12 @@ export default class ContentPreparer {
           },
           currentMediaSourceCanceller.signal,
         );
-      const decipherabilityFreezeDetector = new DecipherabilityFreezeDetector(
-        segmentSinksStore,
-      );
+      const freezeResolver = new FreezeResolver(segmentSinksStore);
       this._currentContent = {
         cmcdDataBuilder,
         contentId,
-        decipherabilityFreezeDetector,
+        enableRepresentationAvoidance,
+        freezeResolver,
         mediaSource,
         manifest: null,
         manifestFetcher,
@@ -204,6 +250,11 @@ export default class ContentPreparer {
       manifestFetcher.addEventListener(
         "error",
         (err: unknown) => {
+          sendMessage({
+            type: WorkerMessageType.Error,
+            contentId,
+            value: formatErrorForSender(err),
+          });
           rej(err);
         },
         contentCanceller.signal,
@@ -247,14 +298,36 @@ export default class ContentPreparer {
     });
   }
 
+  /**
+   * Get information on the current content prepared through the
+   * `initializeNewContent` method, or `null` if no content is currently
+   * prepared.
+   * @returns {Object|null}
+   */
   public getCurrentContent(): IPreparedContentData | null {
     return this._currentContent;
   }
 
+  /**
+   * Schedule an update for the Manifest file,
+   *
+   * Do nothing if no content is currently prepared.
+   * @param {Object} settings - Various settings to configure the ways and
+   * moment at which the Manifest will be refreshed.
+   */
   public scheduleManifestRefresh(settings: IManifestRefreshSettings): void {
     this._currentContent?.manifestFetcher.scheduleManualRefresh(settings);
   }
 
+  /**
+   * If there is a prepared content right now, performs the destructive
+   * "reloading" strategy: dispose of its `MediaSource` (and of its
+   * `SourceBuffer`) and recreate one.
+   *
+   * The returned Promise resolves when it restarts being ready.
+   * @param {Object} reloadInfo
+   * @returns {Promise}
+   */
   public reloadMediaSource(reloadInfo: INeedsMediaSourceReloadPayload): Promise<void> {
     this._currentMediaSourceCanceller.cancel();
     if (this._currentContent === null) {
@@ -272,8 +345,8 @@ export default class ContentPreparer {
       [],
     );
 
-    const [mediaSource, segmentSinksStore, workerTextSender] =
-      createMediaSourceAndBuffersStore(
+    const [mediaSourceInterface, segmentSinksStore, workerTextSender] =
+      createMediaSourceInterfaceAndSegmentSinksStore(
         this._currentContent.contentId,
         {
           hasMseInWorker: this._hasMseInWorker,
@@ -282,18 +355,19 @@ export default class ContentPreparer {
         },
         this._currentMediaSourceCanceller.signal,
       );
-    this._currentContent.mediaSource = mediaSource;
+    this._currentContent.mediaSource = mediaSourceInterface;
     this._currentContent.segmentSinksStore = segmentSinksStore;
+    this._currentContent.freezeResolver = new FreezeResolver(segmentSinksStore);
     this._currentContent.workerTextSender = workerTextSender;
     return new Promise((res, rej) => {
-      mediaSource.addEventListener(
+      mediaSourceInterface.addEventListener(
         "mediaSourceOpen",
         function () {
           res();
         },
         this._currentMediaSourceCanceller.signal,
       );
-      mediaSource.addEventListener(
+      mediaSourceInterface.addEventListener(
         "mediaSourceClose",
         function () {
           rej(new Error("MediaSource ReadyState changed to close during init."));
@@ -306,6 +380,10 @@ export default class ContentPreparer {
     });
   }
 
+  /**
+   * Dispose all resources linked to the currently preopared content if one and
+   * stop linking it to this `ContentPreparer`.
+   */
   public disposeCurrentContent() {
     this._contentCanceller.cancel();
     this._contentCanceller = new TaskCanceller();
@@ -328,6 +406,12 @@ export interface IPreparedContentData {
    * conditions with a CDN.
    */
   cmcdDataBuilder: CmcdDataBuilder | null;
+  /**
+   * If `true`, the RxPlayer can enable its "Representation avoidance"
+   * mechanism, where it avoid loading Representation that it suspect
+   * have issues being decoded on the current device.
+   */
+  enableRepresentationAvoidance: boolean;
   /**
    * Interface to the MediaSource implementation, allowing to buffer audio
    * and video media segments.
@@ -342,10 +426,10 @@ export interface IPreparedContentData {
    */
   manifest: IManifest | null;
   /**
-   * Specific module detecting freezing issues due to lower-level
-   * decipherability-related bugs.
+   * Specific module detecting freezing issues and trying to work-around
+   * them.
    */
-  decipherabilityFreezeDetector: DecipherabilityFreezeDetector;
+  freezeResolver: FreezeResolver;
   /**
    * Perform the adaptive logic, allowing to choose the best Representation for
    * the different types of media to load.
@@ -379,7 +463,7 @@ export interface IPreparedContentData {
  * @param {Object} cancelSignal
  * @returns {Array.<Object>}
  */
-function createMediaSourceAndBuffersStore(
+function createMediaSourceInterfaceAndSegmentSinksStore(
   contentId: string,
   capabilities: {
     hasMseInWorker: boolean;
@@ -388,10 +472,10 @@ function createMediaSourceAndBuffersStore(
   },
   cancelSignal: CancellationSignal,
 ): [IMediaSourceInterface, SegmentSinksStore, WorkerTextDisplayerInterface | null] {
-  let mediaSource: IMediaSourceInterface;
+  let mediaSourceInterface: IMediaSourceInterface;
   if (capabilities.hasMseInWorker) {
     const mainMediaSource = new MainMediaSourceInterface(generateMediaSourceId());
-    mediaSource = mainMediaSource;
+    mediaSourceInterface = mainMediaSource;
 
     let sentMediaSourceLink: IAttachMediaSourceWorkerMessagePayload;
     const handle = mainMediaSource.handle;
@@ -410,12 +494,12 @@ function createMediaSourceAndBuffersStore(
         type: WorkerMessageType.AttachMediaSource,
         contentId,
         value: sentMediaSourceLink,
-        mediaSourceId: mediaSource.id,
+        mediaSourceId: mediaSourceInterface.id,
       },
       [handle.value as unknown as Transferable],
     );
   } else {
-    mediaSource = new WorkerMediaSourceInterface(
+    mediaSourceInterface = new WorkerMediaSourceInterface(
       generateMediaSourceId(),
       contentId,
       sendMessage,
@@ -426,12 +510,16 @@ function createMediaSourceAndBuffersStore(
     ? new WorkerTextDisplayerInterface(contentId, sendMessage)
     : null;
   const { hasVideo } = capabilities;
-  const segmentSinksStore = new SegmentSinksStore(mediaSource, hasVideo, textSender);
+  const segmentSinksStore = new SegmentSinksStore(
+    mediaSourceInterface,
+    hasVideo,
+    textSender,
+  );
   cancelSignal.register(() => {
     segmentSinksStore.disposeAll();
     textSender?.stop();
-    mediaSource.dispose();
+    mediaSourceInterface.dispose();
   });
 
-  return [mediaSource, segmentSinksStore, textSender];
+  return [mediaSourceInterface, segmentSinksStore, textSender];
 }

package/src/core/main/worker/worker_main.ts

@@ -34,7 +34,9 @@ import type {
 } from "../../stream";
 import StreamOrchestrator from "../../stream";
 import createContentTimeBoundariesObserver from "../common/create_content_time_boundaries_observer";
+import type { IFreezeResolution } from "../common/FreezeResolver";
 import getBufferedDataPerMediaBuffer from "../common/get_buffered_data_per_media_buffer";
+import synchronizeSegmentSinksOnObservation from "../common/synchronize_sinks_on_observation";
 import ContentPreparer from "./content_preparer";
 import {
   limitVideoResolution,
@@ -150,6 +152,7 @@ export default function initializeWorkerMain() {
         currentLoadedContentTaskCanceller.signal.register(() => {
           currentContentObservationRef.finish();
         });
+        log.debug("WP: Loading new pepared content.");
         loadOrReloadPreparedContent(
           msg.value,
           contentPreparer,
@@ -487,6 +490,7 @@ function loadOrReloadPreparedContent(
   playbackObservationRef: IReadOnlySharedReference<IWorkerPlaybackObservation>,
   parentCancelSignal: CancellationSignal,
 ) {
+  log.debug("WP: Loading prepared content");
   const currentLoadCanceller = new TaskCanceller();
   currentLoadCanceller.linkToSignal(parentCancelSignal);
 
@@ -516,6 +520,7 @@ function loadOrReloadPreparedContent(
   const {
     contentId,
     cmcdDataBuilder,
+    enableRepresentationAvoidance,
     manifest,
     mediaSource,
     representationEstimator,
@@ -523,23 +528,20 @@ function loadOrReloadPreparedContent(
     segmentQueueCreator,
   } = preparedContent;
   const { drmSystemId, enableFastSwitching, initialTime, onCodecSwitch } = val;
+
   playbackObservationRef.onUpdate(
     (observation) => {
-      if (preparedContent.decipherabilityFreezeDetector.needToReload(observation)) {
-        handleMediaSourceReload({
-          timeOffset: 0,
-          minimumPosition: 0,
-          maximumPosition: Infinity,
+      synchronizeSegmentSinksOnObservation(observation, segmentSinksStore);
+      const freezeResolution =
+        preparedContent.freezeResolver.onNewObservation(observation);
+      if (freezeResolution !== null) {
+        handleFreezeResolution(freezeResolution, {
+          contentId,
+          manifest,
+          handleMediaSourceReload,
+          enableRepresentationAvoidance,
         });
       }
-
-      // Synchronize SegmentSinks with what has been buffered.
-      ["video" as const, "audio" as const, "text" as const].forEach((tType) => {
-        const segmentSinkStatus = segmentSinksStore.getStatus(tType);
-        if (segmentSinkStatus.type === "initialized") {
-          segmentSinkStatus.value.synchronizeInventory(observation.buffered[tType] ?? []);
-        }
-      });
     },
     { clearSignal: currentLoadCanceller.signal },
   );
@@ -881,8 +883,15 @@ function loadOrReloadPreparedContent(
     if (currentLoadCanceller !== null) {
       currentLoadCanceller.cancel();
     }
+    log.debug(
+      "WP: Reloading MediaSource",
+      payload.timeOffset,
+      payload.minimumPosition,
+      payload.maximumPosition,
+    );
     contentPreparer.reloadMediaSource(payload).then(
       () => {
+        log.info("WP: MediaSource Reloaded, loading content again");
         loadOrReloadPreparedContent(
           {
             initialTime: newInitialTime,
@@ -960,3 +969,71 @@ function sendSegmentSinksStoreInfos(
     value: { segmentSinkMetrics: segmentSinksMetrics, messageId },
   });
 }
+
+/**
+ * Handle accordingly an `IFreezeResolution` object.
+ * @param {Object|null} freezeResolution - The `IFreezeResolution` suggested.
+ * @param {Object} param - Parameters that might be needed to implement the
+ * resolution.
+ * @param {string} param.contentId - `contentId` for the current content, used
+ * e.g. for message exchanges between threads.
+ * @param {Object} param.manifest - The current content's Manifest object.
+ * @param {Function} param.handleMediaSourceReload - Function to call if we need
+ * to ask for a "MediaSource reload".
+ * @param {Boolean} param.enableRepresentationAvoidance - If `true`, this
+ * function is authorized to mark `Representation` as "to avoid" if the
+ * `IFreezeResolution` object suggest it.
+ */
+function handleFreezeResolution(
+  freezeResolution: IFreezeResolution,
+  {
+    contentId,
+    manifest,
+    handleMediaSourceReload,
+    enableRepresentationAvoidance,
+  }: {
+    contentId: string;
+    manifest: Manifest;
+    handleMediaSourceReload: (payload: INeedsMediaSourceReloadPayload) => void;
+    enableRepresentationAvoidance: boolean;
+  },
+): void {
+  switch (freezeResolution.type) {
+    case "reload": {
+      log.info("WP: Planning reload due to freeze");
+      handleMediaSourceReload({
+        timeOffset: 0,
+        minimumPosition: 0,
+        maximumPosition: Infinity,
+      });
+      break;
+    }
+    case "flush": {
+      log.info("WP: Flushing buffer due to freeze");
+      sendMessage({
+        type: WorkerMessageType.NeedsBufferFlush,
+        contentId,
+        value: {
+          relativeResumingPosition: freezeResolution.value.relativeSeek,
+          relativePosHasBeenDefaulted: false,
+        },
+      });
+      break;
+    }
+    case "avoid-representations": {
+      log.info("WP: Planning Representation avoidance due to freeze");
+      const content = freezeResolution.value;
+      if (enableRepresentationAvoidance) {
+        manifest.addRepresentationsToAvoid(content);
+      }
+      handleMediaSourceReload({
+        timeOffset: 0,
+        minimumPosition: 0,
+        maximumPosition: Infinity,
+      });
+      break;
+    }
+    default:
+      assertUnreachable(freezeResolution);
+  }
+}

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -94,8 +94,9 @@ export default function AdaptationStream(
   let previouslyEmittedBitrate: number | undefined;
 
   const initialRepIds = content.representations.getValue().representationIds;
-  const initialRepresentations = content.adaptation.representations.filter(
-    (r) => arrayIncludes(initialRepIds, r.id) && r.isPlayable() !== false,
+  const initialRepresentations = getRepresentationList(
+    content.adaptation.representations,
+    initialRepIds,
   );
 
   /** Emit the list of Representation for the adaptive logic. */
@@ -174,8 +175,13 @@ export default function AdaptationStream(
         cancelCurrentStreams.cancel();
       }
       const newRepIds = content.representations.getValue().representationIds;
-      const newRepresentations = content.adaptation.representations.filter((r) =>
-        arrayIncludes(newRepIds, r.id),
+
+      // NOTE: We expect that the rest of the RxPlayer code is already handling
+      // cases where the list of playable `Representation` changes:
+      // decipherability updates, "`Representation` avoidance" etc.
+      const newRepresentations = getRepresentationList(
+        content.adaptation.representations,
+        newRepIds,
       );
       representationsList.setValueIfChanged(newRepresentations);
       cancelCurrentStreams = new TaskCanceller();
@@ -540,3 +546,31 @@ export default function AdaptationStream(
     return wba * bufferGoalRatio;
   }
 }
+
+/**
+ * Construct the list of the `Representation` to play, based on what's supported
+ * and what the API seem to authorize.
+ * @param {Array.<Object>} availableRepresentations - All available
+ * Representation in the current `Adaptation`, including unsupported ones.
+ * @param {Array.<string>} authorizedRepIds - The subset of `Representation`
+ * that the API authorize us to play.
+ * @returns {Array.<Object>}
+ */
+function getRepresentationList(
+  availableRepresentations: IRepresentation[],
+  authorizedRepIds: string[],
+): IRepresentation[] {
+  const filteredRepresentations = availableRepresentations.filter(
+    (r) =>
+      arrayIncludes(authorizedRepIds, r.id) &&
+      !r.shouldBeAvoided &&
+      r.isPlayable() !== false,
+  );
+  if (filteredRepresentations.length > 0) {
+    return filteredRepresentations;
+  }
+  // Retry without "`Representation` avoidance"
+  return availableRepresentations.filter(
+    (r) => arrayIncludes(authorizedRepIds, r.id) && r.isPlayable() !== false,
+  );
+}

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -17,11 +17,7 @@
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
-import type {
-  IManifest,
-  IDecipherabilityUpdateElement,
-  IPeriod,
-} from "../../../manifest";
+import type { IManifest, IUpdatedRepresentationInfo, IPeriod } from "../../../manifest";
 import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import queueMicrotask from "../../../utils/queue_microtask";
@@ -295,7 +291,7 @@ export default function StreamOrchestrator(
      * @returns {Promise}
      */
     async function onDecipherabilityUpdates(
-      updates: IDecipherabilityUpdateElement[],
+      updates: IUpdatedRepresentationInfo[],
     ): Promise<void> {
       const segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
       const ofCurrentType = updates.filter(

package/src/default_config.ts

@@ -550,6 +550,33 @@ const DEFAULT_CONFIG = {
    */
   UNFREEZING_DELTA_POSITION: 0.001,
 
+  /**
+   * `FREEZING` is a situation where the playback does not seem to advance despite
+   * all web indicators telling us we can.
+   * Those may be linked to device issues, but sometimes are just linked to
+   * performance or it may be just decryption negotiations taking more time than
+   * expected.
+   *
+   * Anyway we might in the RxPlayer "flush" the buffer in that situation to
+   * un-stuck playback (this is usually done by seeking close to the current
+   * position),
+   *
+   * Yet that "flush" attempt may not in the end be succesful.
+   *
+   * If a flush was performed more than `FREEZING_FLUSH_FAILURE_DELAY.MINIMUM`
+   * milliseconds ago and less than `FREEZING_FLUSH_FAILURE_DELAY.MAXIMUM`
+   * milliseconds ago, yet a `FREEZING` situation at roughly the same playback
+   * position (deviating from less than
+   * `FREEZING_FLUSH_FAILURE_DELAY.POSITION_DELTA` seconds from it) is
+   * encountered again, we will consider that the flushing attempt was unsuccesful
+   * and try more agressive solutions (such as reloading the content).
+   */
+  FREEZING_FLUSH_FAILURE_DELAY: {
+    MAXIMUM: 20000,
+    MINIMUM: 4000,
+    POSITION_DELTA: 1,
+  },
+
   /**
    * The RxPlayer has a recurring logic which will synchronize the browser's
    * buffers' buffered time ranges with its internal representation in the

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts

@@ -12,7 +12,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
     const probeDRMInfos = (await vi.importActual("../../probers/DRMInfos"))
       .default as typeof IProbeDRMInfos;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeDRMInfos(configuration)).rejects.toEqual(
+    await expect(probeDRMInfos(configuration)).rejects.toEqual(
       "MediaCapabilitiesProber >>> API_CALL: " +
         "Missing a type argument to request a media key system access.",
     );
@@ -25,7 +25,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
     const probeDRMInfos = (await vi.importActual("../../probers/DRMInfos"))
       .default as typeof IProbeDRMInfos;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeDRMInfos(configuration)).rejects.toEqual(
+    await expect(probeDRMInfos(configuration)).rejects.toEqual(
       "MediaCapabilitiesProber >>> API_CALL: " +
         "Missing a type argument to request a media key system access.",
     );
@@ -43,7 +43,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
     const probeDRMInfos = (await vi.importActual("../../probers/DRMInfos"))
       .default as typeof IProbeDRMInfos;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeDRMInfos(configuration)).resolves.toEqual([
+    await expect(probeDRMInfos(configuration)).resolves.toEqual([
       ProberStatus.NotSupported,
       { configuration: {}, type: "clearkick" },
     ]);

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts

@@ -14,7 +14,7 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
     const probeHDCPPolicy = (await vi.importActual("../../probers/HDCPPolicy"))
       .default as typeof IProbeHDCPPolicy;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeHDCPPolicy({})).rejects.toEqual(
+    await expect(probeHDCPPolicy({})).rejects.toEqual(
       "MediaCapabilitiesProber >>> API_CALL: API not available",
     );
   });
@@ -33,7 +33,7 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
     const probeHDCPPolicy = (await vi.importActual("../../probers/HDCPPolicy"))
       .default as typeof IProbeHDCPPolicy;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeHDCPPolicy({})).rejects.toEqual(
+    await expect(probeHDCPPolicy({})).rejects.toEqual(
       "MediaCapabilitiesProber >>> API_CALL: " +
         "Missing policy argument for calling getStatusForPolicy.",
     );

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/decodingInfos.test.ts

@@ -162,17 +162,17 @@ describe("MediaCapabilitiesProber probers - decodingInfo", () => {
       });
   });
 
-  it("should throw if API mediaCapabilities not available", () => {
+  it("should throw if API mediaCapabilities not available", async () => {
     // @ts-expect-error: `navigator.mediaCapabilities` is read-only normally, for
     // now, we're going through JSDom through so that's OK.
     delete navigator.mediaCapabilities;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeDecodingInfos({})).rejects.toThrowError(
+    await expect(probeDecodingInfos({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: MediaCapabilities API not available",
     );
   });
 
-  it("should throw if API decodingInfo not available", () => {
+  it("should throw if API decodingInfo not available", async () => {
     if (!isNullOrUndefined(navigator.mediaCapabilities)) {
       // @ts-expect-error: `navigator.mediaCapabilities` is read-only normally, for
       // now, we're going through JSDom through so that's OK.
@@ -183,7 +183,7 @@ describe("MediaCapabilitiesProber probers - decodingInfo", () => {
       navigator.mediaCapabilities = {};
     }
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeDecodingInfos({})).rejects.toThrowError(
+    await expect(probeDecodingInfos({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: Decoding Info not available",
     );
   });

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/mediaContentType.test.ts

@@ -16,7 +16,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       await vi.importActual("../../probers/mediaContentType")
     ).default as typeof IProbeMediaContentType;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeMediaContentType({})).rejects.toThrowError(
+    await expect(probeMediaContentType({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: " + "MediaSource API not available",
     );
   });
@@ -31,7 +31,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       await vi.importActual("../../probers/mediaContentType")
     ).default as typeof IProbeMediaContentType;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeMediaContentType({})).rejects.toThrowError(
+    await expect(probeMediaContentType({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: " + "isTypeSupported not available",
     );
   });

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/mediaDisplayInfos.test.ts

@@ -15,7 +15,7 @@ describe("MediaCapabilitiesProber probers probeMediaDisplayInfos", () => {
       await vi.importActual("../../probers/mediaDisplayInfos")
     ).default as typeof IProbeMediaDisplayInfos;
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    expect(probeMediaDisplayInfos({})).rejects.toThrowError(
+    await expect(probeMediaDisplayInfos({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: matchMedia not available",
     );
     (

package/src/main_thread/api/__tests__/option_utils.test.ts

@@ -301,6 +301,9 @@ describe("API - parseLoadVideoOptions", () => {
     textTrackElement: undefined,
     textTrackMode: "native",
     url: undefined,
+    experimentalOptions: {
+      enableRepresentationAvoidance: false,
+    },
   };
 
   it("should throw if no option is given", () => {