rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/main_thread/api/public_api.ts

@@ -38,7 +38,9 @@ import type {
   IInbandEvent,
   IABRThrottlers,
   IBufferType,
+  ICoreMessage,
 } from "../../core/types";
+import { CoreMessageType } from "../../core/types";
 import type { IDefaultConfig } from "../../default_config";
 import type { IErrorCode, IErrorType } from "../../errors";
 import { ErrorCodes, ErrorTypes, formatError, MediaError } from "../../errors";
@@ -60,13 +62,10 @@ import {
   getMaximumSafePosition,
   getMinimumSafePosition,
   ManifestMetadataFormat,
-  createRepresentationFilterFromFnString,
   getPeriodForTime,
   toVideoRepresentation,
   toAudioRepresentation,
 } from "../../manifest";
-import type { IWorkerMessage } from "../../multithread_types";
-import { MainThreadMessageType, WorkerMessageType } from "../../multithread_types";
 import type { IPlaybackObservation } from "../../playback_observer";
 import MediaElementPlaybackObserver from "../../playback_observer/media_element_playback_observer";
 import type {
@@ -133,6 +132,7 @@ import type { ContentInitializer } from "../init";
 import renderThumbnail from "../render_thumbnail";
 import type { IMediaElementTracksStore, ITSPeriodObject } from "../tracks_store";
 import TracksStore from "../tracks_store";
+import { MainThreadMessageType } from "../types";
 import type { IParsedLoadVideoOptions, IParsedStartAtOption } from "./option_utils";
 import {
   checkReloadOptions,
@@ -185,17 +185,6 @@ if (isDebugModeEnabled) {
 
 const generateContentId = idGenerator();
 
-/**
- * Options of a `loadVideo` call which are for now not supported when running
- * in a "multithread" mode.
- *
- * TODO support those?
- */
-const MULTI_THREAD_UNSUPPORTED_LOAD_VIDEO_OPTIONS = [
-  "manifestLoader",
-  "segmentLoader",
-] as const;
-
 /**
  * @class Player
  * @extends EventEmitter
@@ -270,7 +259,10 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     lastBitrates: { audio?: number; video?: number; text?: number };
   };
 
-  private _priv_worker: Worker | null;
+  private _priv_workerData: {
+    worker: Worker;
+    messageListeners: Map<string, Array<(payload: unknown) => void>>;
+  } | null;
 
   /**
    * Current fatal error which STOPPED the player.
@@ -445,12 +437,12 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.4.1";
+    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026012301";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
     Player._priv_registerVideoElement(this.videoElement);
-    const destroyCanceller = new TaskCanceller();
+    const destroyCanceller = new TaskCanceller("API");
     this._destroyCanceller = destroyCanceller;
 
     this._priv_pictureInPictureRef = getPictureOnPictureStateRef(
@@ -499,7 +491,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
     this._priv_lastAutoPlay = false;
 
-    this._priv_worker = null;
+    this._priv_workerData = null;
 
     const onVolumeChange = () => {
       this.trigger("volumeChange", {
@@ -529,7 +521,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
       // check if the user already attach worker before
       // terminate the previous worker to release the resources
-      if (this._priv_worker !== null) {
+      if (this._priv_workerData !== null) {
         if (this.state !== "STOPPED") {
           log.warn(
             "API",
@@ -542,22 +534,38 @@ class Player extends EventEmitter<IPublicAPIEvent> {
             ),
           );
         } else {
-          this._priv_worker.terminate();
+          this._priv_workerData.worker.terminate();
+          this._priv_workerData.messageListeners.clear();
+          this._priv_workerData = null;
         }
       }
 
+      let workerData: typeof Player.prototype._priv_workerData;
       if (typeof workerSettings.workerUrl === "string") {
-        this._priv_worker = new Worker(workerSettings.workerUrl);
+        workerData = {
+          worker: new Worker(workerSettings.workerUrl),
+          messageListeners: new Map(),
+        };
+      } else if ("postMessage" in workerSettings.workerUrl) {
+        workerData = {
+          worker: workerSettings.workerUrl,
+          messageListeners: new Map(),
+        };
       } else {
         const blobUrl = URL.createObjectURL(workerSettings.workerUrl);
-        this._priv_worker = new Worker(blobUrl);
+        workerData = {
+          worker: new Worker(blobUrl),
+          messageListeners: new Map(),
+        };
         URL.revokeObjectURL(blobUrl);
       }
+      this._priv_workerData = workerData;
 
-      this._priv_worker.onerror = (evt: ErrorEvent) => {
-        if (this._priv_worker !== null) {
-          this._priv_worker.terminate();
-          this._priv_worker = null;
+      this._priv_workerData.worker.onerror = (evt: ErrorEvent) => {
+        if (this._priv_workerData !== null) {
+          this._priv_workerData.worker.terminate();
+          this._priv_workerData.messageListeners.clear();
+          this._priv_workerData = null;
         }
         log.error(
           "API",
@@ -572,13 +580,17 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         );
       };
       const handleInitMessages = (msg: MessageEvent) => {
-        const msgData = msg.data as unknown as IWorkerMessage;
-        if (msgData.type === WorkerMessageType.InitError) {
+        const msgData = msg.data as unknown as ICoreMessage;
+        if (msgData.type === CoreMessageType.InitError) {
           log.warn("API", "Processing InitError worker message: detaching worker");
-          if (this._priv_worker !== null) {
-            this._priv_worker.removeEventListener("message", handleInitMessages);
-            this._priv_worker.terminate();
-            this._priv_worker = null;
+          if (this._priv_workerData !== null) {
+            this._priv_workerData.worker.removeEventListener(
+              "message",
+              handleInitMessages,
+            );
+            this._priv_workerData.worker.terminate();
+            this._priv_workerData.messageListeners.clear();
+            this._priv_workerData = null;
           }
           rej(
             new WorkerInitializationError(
@@ -586,18 +598,43 @@ class Player extends EventEmitter<IPublicAPIEvent> {
               "Worker parser initialization failed: " + msgData.value.errorMessage,
             ),
           );
-        } else if (msgData.type === WorkerMessageType.InitSuccess) {
+        } else if (msgData.type === CoreMessageType.InitSuccess) {
           log.info("API", "InitSuccess received from worker.");
-          if (this._priv_worker !== null) {
-            this._priv_worker.removeEventListener("message", handleInitMessages);
+          if (this._priv_workerData !== null) {
+            this._priv_workerData.worker.removeEventListener(
+              "message",
+              handleInitMessages,
+            );
           }
           res();
         }
       };
-      this._priv_worker.addEventListener("message", handleInitMessages);
+      const onAppDefinedMessage = (evt: MessageEvent<ICoreMessage>) => {
+        if (evt.data.type !== CoreMessageType.AppDefined) {
+          return;
+        }
+        const { name, payload } = evt.data.value;
+        const listeners = workerData.messageListeners.get(name);
+        if (listeners === undefined) {
+          return;
+        }
+        for (const listener of listeners.slice()) {
+          try {
+            listener(payload);
+          } catch (err) {
+            log.error(
+              "API",
+              "A message listener failed with an error:",
+              err instanceof Error ? err : "Unknown Error",
+            );
+          }
+        }
+      };
+      this._priv_workerData.worker.addEventListener("message", handleInitMessages);
+      this._priv_workerData.worker.addEventListener("message", onAppDefinedMessage);
 
       log.debug("M-->C", "Sending message", { name: MainThreadMessageType.Init });
-      this._priv_worker.postMessage({
+      this._priv_workerData.worker.postMessage({
         type: MainThreadMessageType.Init,
         value: {
           dashWasmUrl: workerSettings.dashWasmUrl,
@@ -612,13 +649,13 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       log.addEventListener(
         "onLogLevelChange",
         (logInfo) => {
-          if (this._priv_worker === null) {
+          if (this._priv_workerData === null) {
             return;
           }
           log.debug("M-->C", "Sending message", {
             name: MainThreadMessageType.LogLevelUpdate,
           });
-          this._priv_worker.postMessage({
+          this._priv_workerData.worker.postMessage({
             type: MainThreadMessageType.LogLevelUpdate,
             value: {
               logLevel: logInfo.level,
@@ -631,13 +668,13 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       );
 
       const sendConfigUpdates = (updates: Partial<IDefaultConfig>) => {
-        if (this._priv_worker === null) {
+        if (this._priv_workerData === null) {
           return;
         }
         log.debug("M-->C", "Sending message:", {
           name: MainThreadMessageType.ConfigUpdate,
         });
-        this._priv_worker.postMessage({
+        this._priv_workerData.worker.postMessage({
           type: MainThreadMessageType.ConfigUpdate,
           value: updates,
         });
@@ -649,6 +686,57 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     });
   }
 
+  /**
+   * Construct Object allowing to exchange message with the worker associated to
+   * this RxPlayer instance.
+   * @returns {Object|null} Object allowing communication with the Worker
+   * associated to an `RxPlayer`'s instance.
+   * `null` if no worker is attached currently.
+   */
+  public getWorkerInterface(): IWorkerInterface | null {
+    if (this._priv_workerData === null) {
+      return null;
+    }
+    const workerData = this._priv_workerData;
+    /** @see IWorkerInterface */
+    return {
+      sendMessage(messageName: string, payload: unknown) {
+        workerData.worker.postMessage({
+          type: MainThreadMessageType.AppDefined,
+          value: {
+            name: messageName,
+            payload,
+          },
+        });
+      },
+      addMessageListener(messageName: string, callback: (x: unknown) => void) {
+        const prev = workerData.messageListeners.get(messageName);
+        if (prev === undefined) {
+          workerData.messageListeners.set(messageName, [callback]);
+        } else {
+          workerData.messageListeners.set(messageName, [...prev, callback]);
+        }
+      },
+      removeMessageListener(messageName: string, callback: (x: unknown) => void) {
+        const prev = workerData.messageListeners.get(messageName);
+        if (prev === undefined) {
+          return;
+        }
+        while (true) {
+          const indexOf = prev.indexOf(callback);
+          if (indexOf < 0) {
+            return;
+          }
+          prev.splice(indexOf, 1);
+          if (prev.length === 0) {
+            workerData.messageListeners.delete(messageName);
+            return;
+          }
+        }
+      },
+    };
+  }
+
   /**
    * Returns information on which "mode" the RxPlayer is running for the current
    * content (e.g. main logic running in a WebWorker or not, are we in
@@ -691,7 +779,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
    */
   stop(): void {
     if (this._priv_contentInfos !== null) {
-      this._priv_contentInfos.currentContentCanceller.cancel();
+      this._priv_contentInfos.currentContentCanceller.cancel("API stop");
     }
     this._priv_cleanUpCurrentContentState();
     if (this.state !== PLAYER_STATES.STOPPED) {
@@ -717,16 +805,17 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
 
     // free resources linked to the Player instance
-    this._destroyCanceller.cancel();
+    this._destroyCanceller.cancel("API destroy");
 
     this._priv_reloadingMetadata = {};
 
     // un-attach video element
     this.videoElement = null;
 
-    if (this._priv_worker !== null) {
-      this._priv_worker.terminate();
-      this._priv_worker = null;
+    if (this._priv_workerData !== null) {
+      this._priv_workerData.worker.terminate();
+      this._priv_workerData.messageListeners.clear();
+      this._priv_workerData = null;
     }
   }
 
@@ -765,8 +854,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       startAt = { position: reloadOpts.reloadAt.position };
     } else if (reloadOpts?.reloadAt?.relative !== undefined) {
       if (reloadPosition === undefined) {
-        throw new Error(
-          "Can't reload to a relative position when previous content was not loaded.",
+        log.warn(
+          "API",
+          "reload API > reloadAt.relative option given but we don't know the previous content's position",
         );
       } else {
         startAt = { position: reloadOpts.reloadAt.relative + reloadPosition };
@@ -808,11 +898,11 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     if (features.createDebugElement === null) {
       throw new Error("Feature `DEBUG_ELEMENT` not added to the RxPlayer");
     }
-    const canceller = new TaskCanceller();
+    const canceller = new TaskCanceller("API debug element");
     features.createDebugElement(element, this, canceller.signal);
     return {
       dispose() {
-        canceller.cancel();
+        canceller.cancel("API debug dispose");
       },
     };
   }
@@ -922,7 +1012,6 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       referenceDateTime,
       segmentLoader,
       serverSyncInfos,
-      mode,
       experimentalOptions,
       __priv_manifestUpdateUrl,
       __priv_patchLastSegmentInSidx,
@@ -939,7 +1028,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     const isDirectFile = transport === "directfile";
 
     /** Emit to stop the current content. */
-    const currentContentCanceller = new TaskCanceller();
+    const currentContentCanceller = new TaskCanceller("API current content");
 
     const videoElement = this.videoElement;
 
@@ -1034,49 +1123,84 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         connectionTimeout: requestConfig.segment?.connectionTimeout,
       };
 
-      const canRunInMultiThread =
-        features.multithread !== null &&
-        this._priv_worker !== null &&
-        this.videoElement.FORCED_MEDIA_SOURCE === undefined &&
-        transport === "dash" &&
-        MULTI_THREAD_UNSUPPORTED_LOAD_VIDEO_OPTIONS.every((option) =>
-          isNullOrUndefined(options[option]),
-        ) &&
-        typeof options.representationFilter !== "function";
-      if (mode === "main" || (mode === "auto" && !canRunInMultiThread)) {
-        if (features.mainThreadMediaSourceInit === null) {
+      const transportOptions = {
+        lowLatencyMode,
+        checkMediaSegmentIntegrity,
+        checkManifestIntegrity,
+        referenceDateTime,
+        serverSyncInfos,
+        manifestLoader,
+        segmentLoader,
+        representationFilter: options.representationFilter,
+        __priv_manifestUpdateUrl,
+        __priv_patchLastSegmentInSidx,
+      };
+
+      if (!this._priv_shouldLoadMultithread(options)) {
+        if (features.monothread === null) {
           throw new Error(
             "Cannot load video, neither in a WebWorker nor with the " +
               "`MEDIA_SOURCE_MAIN` feature",
           );
         }
-        const transportFn = features.transports[transport];
-        if (typeof transportFn !== "function") {
-          // Stop previous content and reset its state
-          this.stop();
-          this._priv_currentError = null;
-          throw new Error(`transport "${transport}" not supported`);
-        }
 
-        const representationFilter =
-          typeof options.representationFilter === "string"
-            ? createRepresentationFilterFromFnString(options.representationFilter)
-            : options.representationFilter;
+        // Small checks, log if some option seems wrong
+        if (
+          typeof transportOptions.representationFilter?.workerId === "string" &&
+          (isNullOrUndefined(transportOptions.representationFilter.fn) ||
+            isNullOrUndefined(transportOptions.representationFilter.eval))
+        ) {
+          log.warn(
+            "API",
+            "You only set a `workerId` for a `representationFilter` in monothreaded mode. Ignoring it...",
+          );
+        }
+        if (
+          typeof transportOptions.manifestLoader?.workerId === "string" &&
+          isNullOrUndefined(transportOptions.manifestLoader.fn)
+        ) {
+          log.warn(
+            "API",
+            "You only set a `workerId` for a `manifestLoader` in monothreaded mode. Ignoring it...",
+          );
+        }
+        if (
+          typeof transportOptions.segmentLoader?.workerId === "string" &&
+          isNullOrUndefined(transportOptions.segmentLoader.fn)
+        ) {
+          log.warn(
+            "API",
+            "You only set a `workerId` for a `segmentLoader` in monothreaded mode. Ignoring it...",
+          );
+        }
 
         log.info("API", "Initializing MediaSource mode in the main thread");
-        const transportPipelines = transportFn({
-          lowLatencyMode,
-          checkMediaSegmentIntegrity,
-          checkManifestIntegrity,
-          manifestLoader,
-          referenceDateTime,
-          representationFilter,
-          segmentLoader,
-          serverSyncInfos,
-          __priv_manifestUpdateUrl,
-          __priv_patchLastSegmentInSidx,
+        const coreInterface = new features.monothread.coreInterface();
+        const coreInterfaceCallbacks = coreInterface.getCallbacks();
+        features.monothread.initializeCoreEntry(
+          coreInterfaceCallbacks.setCoreMessageReceiver,
+          coreInterfaceCallbacks.sendCoreMessage,
+          {
+            // No need for core-side plugins in monothread mode
+            representationFilters: new Map(),
+            segmentLoaders: new Map(),
+            manifestLoaders: new Map(),
+          },
+        );
+        coreInterface.sendMessage({
+          type: MainThreadMessageType.Init,
+          value: {
+            dashWasmUrl: undefined,
+            hasVideo: this.videoElement?.nodeName.toLowerCase() === "video",
+            logLevel: log.getLevel(),
+            logFormat: log.getFormat(),
+            sendBackLogs: false,
+            date: Date.now(),
+            timestamp: getMonotonicTimeStamp(),
+          },
         });
-        initializer = new features.mainThreadMediaSourceInit({
+        initializer = new features.monothread.init({
+          coreInterface,
           adaptiveOptions,
           autoPlay,
           bufferOptions,
@@ -1085,13 +1209,15 @@ class Player extends EventEmitter<IPublicAPIEvent> {
             experimentalOptions.enableRepresentationAvoidance,
           keySystems,
           lowLatencyMode,
-          transport: transportPipelines,
+          transport,
+          transportOptions,
           manifestRequestSettings,
           segmentRequestOptions,
           speed: this._priv_speed,
           startAt,
           textTrackOptions,
           url,
+          useMseInWorker: false,
         });
       } else {
         if (features.multithread === null) {
@@ -1099,28 +1225,62 @@ class Player extends EventEmitter<IPublicAPIEvent> {
             "Cannot load video in multithread mode: `MULTI_THREAD` " +
               "feature not imported.",
           );
-        } else if (this._priv_worker === null) {
+        } else if (this._priv_workerData === null) {
           throw new Error(
             "Cannot load video in multithread mode: `attachWorker` " +
               "method not called.",
           );
         }
-        assert(typeof options.representationFilter !== "function");
+
+        // Small checks, log if some option seems wrong
+        if (
+          transportOptions.representationFilter !== undefined &&
+          !isNullOrUndefined(transportOptions.representationFilter.fn)
+        ) {
+          transportOptions.representationFilter.fn = undefined;
+          if (
+            isNullOrUndefined(transportOptions.representationFilter.workerId) &&
+            isNullOrUndefined(transportOptions.representationFilter.eval)
+          ) {
+            log.warn(
+              "API",
+              "You only set a representationFilter function in a mulithreaded mode, ignoring it...",
+            );
+          }
+        }
+        if (
+          transportOptions.manifestLoader !== undefined &&
+          !isNullOrUndefined(transportOptions.manifestLoader.workerId)
+        ) {
+          transportOptions.manifestLoader.fn = undefined;
+          if (isNullOrUndefined(transportOptions.manifestLoader.fn)) {
+            log.warn(
+              "API",
+              "You only set a manifestLoader function in a mulithreaded mode, ignoring it...",
+            );
+          }
+        }
+        if (
+          transportOptions.segmentLoader !== undefined &&
+          !isNullOrUndefined(transportOptions.segmentLoader.workerId)
+        ) {
+          transportOptions.segmentLoader.fn = undefined;
+          if (isNullOrUndefined(transportOptions.segmentLoader.fn)) {
+            log.warn(
+              "API",
+              "You only set a segmentLoader function in a mulithreaded mode, ignoring it...",
+            );
+          }
+        }
+
+        // `initialManifest` is not supported in multithread mode.
+        manifestRequestSettings.initialManifest = undefined;
         useWorker = true;
         log.info("API", "Initializing MediaSource mode in a WebWorker");
-        const transportOptions = {
-          lowLatencyMode,
-          checkMediaSegmentIntegrity,
-          checkManifestIntegrity,
-          referenceDateTime,
-          serverSyncInfos,
-          manifestLoader: undefined,
-          segmentLoader: undefined,
-          representationFilter: options.representationFilter,
-          __priv_manifestUpdateUrl,
-          __priv_patchLastSegmentInSidx,
-        };
         initializer = new features.multithread.init({
+          coreInterface: new features.multithread.coreInterface(
+            this._priv_workerData.worker,
+          ),
           adaptiveOptions,
           autoPlay,
           bufferOptions,
@@ -1129,13 +1289,13 @@ class Player extends EventEmitter<IPublicAPIEvent> {
             experimentalOptions.enableRepresentationAvoidance,
           keySystems,
           lowLatencyMode,
+          transport,
           transportOptions,
           manifestRequestSettings,
           segmentRequestOptions,
           speed: this._priv_speed,
           startAt,
           textTrackOptions,
-          worker: this._priv_worker,
           url,
           useMseInWorker: hasMseInWorker,
         });
@@ -1177,8 +1337,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
      */
     playbackObserver.blockSeeking();
 
-    currentContentCanceller.signal.register(() => {
-      playbackObserver.stop();
+    currentContentCanceller.signal.register((err) => {
+      playbackObserver.stop(err.reason);
     });
 
     /** Future `this._priv_contentInfos` related to this content. */
@@ -1299,8 +1459,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       isDirectFile,
       currentContentCanceller.signal,
     );
-    currentContentCanceller.signal.register(() => {
-      initializer.dispose();
+    currentContentCanceller.signal.register((err) => {
+      initializer.dispose(err.reason);
     });
 
     /**
@@ -1345,7 +1505,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
      */
     const triggerPlayPauseEventsWhenReady = (willAutoPlay: boolean) => {
       if (playPauseEventsCanceller !== null) {
-        playPauseEventsCanceller.cancel(); // cancel previous logic
+        playPauseEventsCanceller.cancel("reset"); // cancel previous logic
         playPauseEventsCanceller = null;
       }
       playerStateRef.onUpdate(
@@ -1355,9 +1515,9 @@ class Player extends EventEmitter<IPublicAPIEvent> {
           }
           stopListeningToStateUpdates();
           if (playPauseEventsCanceller !== null) {
-            playPauseEventsCanceller.cancel();
+            playPauseEventsCanceller.cancel("reset");
           }
-          playPauseEventsCanceller = new TaskCanceller();
+          playPauseEventsCanceller = new TaskCanceller("API play/pause events");
           playPauseEventsCanceller.linkToSignal(currentContentCanceller.signal);
           if (willAutoPlay !== !videoElement.paused) {
             // paused status is not at the expected value on load: emit event
@@ -1408,11 +1568,11 @@ class Player extends EventEmitter<IPublicAPIEvent> {
 
         if (seekEventsCanceller !== null) {
           if (!isLoadedState(this.state)) {
-            seekEventsCanceller.cancel();
+            seekEventsCanceller.cancel("Player State Update");
             seekEventsCanceller = null;
           }
         } else if (isLoadedState(this.state)) {
-          seekEventsCanceller = new TaskCanceller();
+          seekEventsCanceller = new TaskCanceller("API seek events");
           seekEventsCanceller.linkToSignal(currentContentCanceller.signal);
           emitSeekEvents(
             playbackObserver,
@@ -3563,7 +3723,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       defaultReason: "An unknown error stopped content playback.",
     });
     formattedError.fatal = true;
-    contentInfos.currentContentCanceller.cancel();
+    contentInfos.currentContentCanceller.cancel("fatal err");
     this._priv_cleanUpCurrentContentState();
     this._priv_currentError = formattedError;
     log.error("API", "The player stopped because of an error", formattedError);
@@ -3577,8 +3737,72 @@ class Player extends EventEmitter<IPublicAPIEvent> {
       this.trigger("error", formattedError);
     }
   }
+
+  /**
+   * Returns `true` if the content concerned by those options should load in
+   * multithread mode.
+   * Returns `false` if it should load in main thread.
+   * @param {Object} options - The `loadVideo` options for that content.
+   * @returns {boolean} - `true` if the content should be loaded in multithread
+   * mode.
+   */
+  private _priv_shouldLoadMultithread(options: IParsedLoadVideoOptions): boolean {
+    if (options.mode === "main") {
+      return false;
+    }
+    if (options.mode === "multithread") {
+      return true;
+    }
+    if (options.transport === "directfile") {
+      return false;
+    }
+
+    if (features.multithread === null || this._priv_workerData === null) {
+      // No possibility for multithread
+      return false;
+    }
+    if (!isNullOrUndefined(this.videoElement?.FORCED_MEDIA_SOURCE)) {
+      // Special case: Dummy Media Element only in main thread for now
+      // TODO: Make it work with multithread?
+      return false;
+    }
+    if (options.transport !== "dash" && options.transport !== "local") {
+      return false;
+    }
+    if (
+      features.monothread === null ||
+      typeof features.transports[options.transport] !== "function"
+    ) {
+      // We cannot play in monothread anyway, but we may be able to in
+      // multithread
+      return true;
+    }
+    if (
+      options.manifestLoader !== undefined &&
+      typeof options.manifestLoader.fn === "function" &&
+      isNullOrUndefined(options.manifestLoader.workerId)
+    ) {
+      return false;
+    }
+    if (
+      options.segmentLoader !== undefined &&
+      typeof options.segmentLoader.fn === "function" &&
+      isNullOrUndefined(options.segmentLoader.workerId)
+    ) {
+      return false;
+    }
+    if (
+      options.representationFilter !== undefined &&
+      typeof options.representationFilter.fn === "function" &&
+      isNullOrUndefined(options.representationFilter.workerId) &&
+      isNullOrUndefined(options.representationFilter.eval)
+    ) {
+      return false;
+    }
+    return true;
+  }
 }
-Player.version = /* PLAYER_VERSION */ "4.4.1";
+Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026012301";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {
@@ -3738,4 +3962,39 @@ export interface IPublicApiContentInfos {
   onVideoTracksNotPlayable: "continue" | "error";
 }
 
+/**
+ * Object allowing communication with the Worker associated to an `RxPlayer`'s instance.
+ */
+interface IWorkerInterface {
+  /**
+   * Allows to send a message to a Worker associated with an `RxPlayer` instance.
+   * It should be coupled with an `addMessageListener` done on the worker-side
+   * for the corresponding `messageName`.
+   * @param {string} messageName - Name for the associated event that has been
+   * listened to through an `addMessageListener` call on the worker-side.
+   * Can be any string.
+   * @param {Object} payload - Payload for that particular event.
+   */
+  sendMessage(messageName: string, payload: unknown): void;
+  /**
+   * Listen to events sent by the worker-side, so that if it decides to call
+   * sendMessage` there for that same `messageName`, you callback will be
+   * triggered.
+   * @param {string} messageName - Name for the event you want to listen to.
+   * @param {Function} callback - callback that will be triggered any time that
+   * event is received from the Worker-side with the sent payload as argument.
+   */
+  addMessageListener(messageName: string, callback: (x: unknown) => void): void;
+  /**
+   * Remove a callback previously registered through `addMessageListener` on this
+   * same interface.
+   * @param {string} messageName - Name for the event you want to unregister.
+   * @param {Function} callback - Callback you want to unregister for that
+   * event.
+   * Should be the exact same callback (same reference to it) than the one
+   * registered previously through `addMessageListener`.
+   */
+  removeMessageListener(messageName: string, callback: (x: unknown) => void): void;
+}
+
 export default Player;