rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/core/{main/worker/worker_main.ts → entry/core_entry.ts}

@@ -1,57 +1,91 @@
-import config from "../../../config";
-import { MediaError, OtherError } from "../../../errors";
-import features from "../../../features";
-import log from "../../../log";
-import Manifest, { Adaptation, Period, Representation } from "../../../manifest/classes";
+import config from "../../config";
+import { MediaError, OtherError } from "../../errors";
+import features from "../../features";
+import log from "../../log";
 import type {
   IContentInitializationData,
-  IDiscontinuityUpdateWorkerMessagePayload,
   IMainThreadMessage,
   IReferenceUpdateMessage,
   IThumbnailDataRequestMainMessage,
-} from "../../../multithread_types";
-import { MainThreadMessageType, WorkerMessageType } from "../../../multithread_types";
-import DashJsParser from "../../../parsers/manifest/dash/js-parser";
-import DashWasmParser from "../../../parsers/manifest/dash/wasm-parser";
-import { ObservationPosition } from "../../../playback_observer";
-import type { IWorkerPlaybackObservation } from "../../../playback_observer/worker_playback_observer";
-import WorkerPlaybackObserver from "../../../playback_observer/worker_playback_observer";
-import type { IPlayerError, ITrackType } from "../../../public_types";
-import createDashPipelines from "../../../transports/dash";
-import arrayFind from "../../../utils/array_find";
-import assert, { assertUnreachable } from "../../../utils/assert";
-import globalScope from "../../../utils/global_scope";
-import type { ILogFormat, ILoggerLevel } from "../../../utils/logger";
-import { scaleTimestamp } from "../../../utils/monotonic_timestamp";
-import objectAssign from "../../../utils/object_assign";
-import type { IReadOnlySharedReference } from "../../../utils/reference";
-import SharedReference from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
+} from "../../main_thread/types";
+import { MainThreadMessageType } from "../../main_thread/types";
+import Manifest, { Adaptation, Period, Representation } from "../../manifest/classes";
+import { ObservationPosition } from "../../playback_observer";
+import type { ICorePlaybackObservation } from "../../playback_observer/core_playback_observer";
+import CorePlaybackObserver from "../../playback_observer/core_playback_observer";
+import type { IPlayerError, ITrackType } from "../../public_types";
+import arrayFind from "../../utils/array_find";
+import assert, { assertUnreachable } from "../../utils/assert";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import type { ILogFormat, ILoggerLevel } from "../../utils/logger";
+import { scaleTimestamp } from "../../utils/monotonic_timestamp";
+import objectAssign from "../../utils/object_assign";
+import type { IReadOnlySharedReference } from "../../utils/reference";
+import SharedReference from "../../utils/reference";
+import TaskCanceller from "../../utils/task_canceller";
 import type {
   INeedsMediaSourceReloadPayload,
   IStreamOrchestratorCallbacks,
   IStreamStatusPayload,
-} 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 getThumbnailData from "../common/get_thumbnail_data";
-import synchronizeSegmentSinksOnObservation from "../common/synchronize_sinks_on_observation";
+} from "../stream";
+import StreamOrchestrator from "../stream";
+import type {
+  ICoreMessage,
+  IDiscontinuityUpdateCoreMessagePayload,
+  IResolutionInfo,
+} from "../types";
+import { CoreMessageType } from "../types";
 import ContentPreparer from "./content_preparer";
-import {
-  limitVideoResolution,
-  maxBufferAhead,
-  maxBufferBehind,
-  maxVideoBufferSize,
-  throttleVideoBitrate,
-  wantedBufferAhead,
-} from "./globals";
-import sendMessage, { formatErrorForSender } from "./send_message";
-
-export default function initializeWorkerMain() {
+import type { ICorePlugins } from "./content_preparer";
+import createContentTimeBoundariesObserver from "./create_content_time_boundaries_observer";
+import type { IFreezeResolution } from "./FreezeResolver";
+import getBufferedDataPerMediaBuffer from "./get_buffered_data_per_media_buffer";
+import getThumbnailData from "./get_thumbnail_data";
+import synchronizeSegmentSinksOnObservation from "./synchronize_sinks_on_observation";
+import { formatErrorForSender } from "./utils";
+
+export type IMessageReceiverCallback = (evt: { data: IMainThreadMessage }) => void;
+
+/**
+ * Initialize a `CoreEntry`, which is the part of the RxPlayer acting as an
+ * entry point to all its "core" code.
+ *
+ * Its role is to receive and react to messages coming from "main thead", which
+ * may include loading and playing a content, and to send back messages for the main
+ * thread.
+ * @param {Function} setMessageReceiver - Declares the function that will
+ * receive messages coming from the "main thread" part of the RxPlayer logic.
+ * @param {Function} sendMessage - Function allowing to send messages to the
+ * "main thread" part of the RxPlayer logic.
+ * @param {Object} corePlugins - Callbacks that may have been registered by
+ * the application if it loaded the core independantly as a worker.
+ */
+export default function initializeCoreEntry(
+  setMessageReceiver: (cb: IMessageReceiverCallback) => void,
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
+  corePlugins: ICorePlugins,
+): void {
+  const {
+    DEFAULT_WANTED_BUFFER_AHEAD,
+    DEFAULT_MAX_VIDEO_BUFFER_SIZE,
+    DEFAULT_MAX_BUFFER_AHEAD,
+    DEFAULT_MAX_BUFFER_BEHIND,
+  } = config.getCurrent();
+  const refs: ICoreReferences = {
+    wantedBufferAhead: new SharedReference(DEFAULT_WANTED_BUFFER_AHEAD),
+    maxVideoBufferSize: new SharedReference(DEFAULT_MAX_VIDEO_BUFFER_SIZE),
+    maxBufferAhead: new SharedReference(DEFAULT_MAX_BUFFER_AHEAD),
+    maxBufferBehind: new SharedReference(DEFAULT_MAX_BUFFER_BEHIND),
+    limitVideoResolution: new SharedReference<IResolutionInfo>({
+      height: undefined,
+      width: undefined,
+      pixelRatio: 1,
+    }),
+    throttleVideoBitrate: new SharedReference(Infinity),
+  };
+
   /**
-   * `true` once the worker has been initialized.
+   * `true` once the CoreEntry has been initialized.
    * Allow to enforce the fact that it is only initialized once.
    */
   let isInitialized = false;
@@ -68,48 +102,54 @@ export default function initializeWorkerMain() {
    */
   let currentContentHandle: IContentHandle | null = null;
 
-  // Initialize Manually a `DashWasmParser` and add the feature.
-  // TODO allow worker-side feature-switching? Not sure how
-  const dashWasmParser = new DashWasmParser();
-  features.dashParsers.wasm = dashWasmParser;
-  features.dashParsers.js = DashJsParser;
-  features.transports.dash = createDashPipelines;
-
   /**
    * When set, emit playback observation made on the main thread.
    */
-  let playbackObservationRef: SharedReference<IWorkerPlaybackObservation> | null = null;
-
-  globalScope.onmessageerror = (_msg: MessageEvent) => {
-    log.error("Core", "Error when receiving message from main thread.");
-  };
-  onmessage = function (e: MessageEvent<IMainThreadMessage>) {
+  let playbackObservationRef: SharedReference<ICorePlaybackObservation> | null = null;
+  setMessageReceiver((e) => {
     log.debug("Core", "received message", { name: e.data.type });
 
     const msg = e.data;
     switch (msg.type) {
       case MainThreadMessageType.Init:
-        assert(!isInitialized);
-        isInitialized = true;
-        scaleTimestamp(msg.value);
-        updateLoggerLevel(
-          msg.value.logLevel,
-          msg.value.logFormat,
-          msg.value.sendBackLogs,
-        );
-        if (msg.value.dashWasmUrl !== undefined && dashWasmParser.isCompatible()) {
-          dashWasmParser.initialize({ wasmUrl: msg.value.dashWasmUrl }).catch((err) => {
-            const error = err instanceof Error ? err.toString() : "Unknown Error";
-            log.error("Core", "Could not initialize DASH_WASM parser", error);
-          });
-        }
+        {
+          assert(!isInitialized);
+          isInitialized = true;
+          scaleTimestamp(msg.value);
+          updateLoggerLevel(
+            msg.value.logLevel,
+            msg.value.logFormat,
+            msg.value.sendBackLogs,
+          );
+          if (!isNullOrUndefined(msg.value.dashWasmUrl)) {
+            const dashWasmParser = features.dashParsers.wasm;
+            if (dashWasmParser === null) {
+              log.error(
+                "Core",
+                "Could not initialize DASH_WASM parser: DASH_WASM feature not added",
+              );
+            } else if (!dashWasmParser.isCompatible()) {
+              log.warn(
+                "Core",
+                "Could not initialize DASH_WASM parser: Browser not compatible",
+              );
+            } else {
+              dashWasmParser
+                .initialize({ wasmUrl: msg.value.dashWasmUrl })
+                .catch((err) => {
+                  const error = err instanceof Error ? err.toString() : "Unknown Error";
+                  log.error("Core", "Could not initialize DASH_WASM parser", error);
+                });
+            }
+          }
 
-        if (!msg.value.hasVideo) {
-          contentPreparer.disposeCurrentContent();
-          contentPreparer = new ContentPreparer({ hasVideo: msg.value.hasVideo });
-        }
+          if (!msg.value.hasVideo) {
+            contentPreparer.disposeCurrentContent("Received Init msg");
+            contentPreparer = new ContentPreparer({ hasVideo: msg.value.hasVideo });
+          }
 
-        sendMessage({ type: WorkerMessageType.InitSuccess, value: null });
+          sendMessage({ type: CoreMessageType.InitSuccess, value: null });
+        }
         break;
 
       case MainThreadMessageType.LogLevelUpdate:
@@ -121,7 +161,7 @@ export default function initializeWorkerMain() {
         break;
 
       case MainThreadMessageType.PrepareContent:
-        prepareNewContent(contentPreparer, msg.value);
+        prepareNewContent(sendMessage, contentPreparer, msg.value, refs, corePlugins);
         break;
 
       case MainThreadMessageType.StartPreparedContent: {
@@ -134,16 +174,18 @@ export default function initializeWorkerMain() {
         playbackObservationRef?.finish();
 
         const currentContentObservationRef =
-          new SharedReference<IWorkerPlaybackObservation>(
+          new SharedReference<ICorePlaybackObservation>(
             objectAssign(msg.value.initialObservation, {
               position: new ObservationPosition(...msg.value.initialObservation.position),
             }),
           );
         playbackObservationRef = currentContentObservationRef;
         currentContentHandle = loadPreparedContent(
+          sendMessage,
           msg.value,
           contentPreparer,
           currentContentObservationRef,
+          refs,
         );
         break;
       }
@@ -174,14 +216,14 @@ export default function initializeWorkerMain() {
       }
 
       case MainThreadMessageType.ReferenceUpdate:
-        updateGlobalReference(msg);
+        updateCoreReference(msg, refs);
         break;
 
       case MainThreadMessageType.StopContent:
         if (msg.contentId !== contentPreparer.getCurrentContent()?.contentId) {
           return;
         }
-        contentPreparer.disposeCurrentContent();
+        contentPreparer.disposeCurrentContent("StopContent message");
 
         currentContentHandle?.stop();
         currentContentHandle = null;
@@ -304,14 +346,14 @@ export default function initializeWorkerMain() {
           const warning = preparedContent.manifest.updateCodecSupport(newEvaluatedCodecs);
           if (warning !== null) {
             sendMessage({
-              type: WorkerMessageType.Warning,
+              type: CoreMessageType.Warning,
               contentId: preparedContent.contentId,
               value: formatErrorForSender(warning),
             });
           }
         } catch (err) {
           sendMessage({
-            type: WorkerMessageType.Error,
+            type: CoreMessageType.Error,
             contentId: preparedContent.contentId,
             value: formatErrorForSender(err),
           });
@@ -363,11 +405,11 @@ export default function initializeWorkerMain() {
         if (preparedContent === null || preparedContent.contentId !== msg.contentId) {
           return;
         }
-        if (preparedContent.workerTextSender === null) {
+        if (preparedContent.coreTextSender === null) {
           log.error("Core", "Added text track but text track aren't enabled");
           return;
         }
-        preparedContent.workerTextSender.onPushedTrackSuccess(msg.value.ranges);
+        preparedContent.coreTextSender.onPushedTrackSuccess(msg.value.ranges);
         break;
       }
 
@@ -376,11 +418,11 @@ export default function initializeWorkerMain() {
         if (preparedContent === null || preparedContent.contentId !== msg.contentId) {
           return;
         }
-        if (preparedContent.workerTextSender === null) {
+        if (preparedContent.coreTextSender === null) {
           log.error("Core", "Added text track but text track aren't enabled");
           return;
         }
-        preparedContent.workerTextSender.onPushedTrackError(new Error(msg.value.message));
+        preparedContent.coreTextSender.onPushedTrackError(new Error(msg.value.message));
         break;
       }
 
@@ -389,11 +431,11 @@ export default function initializeWorkerMain() {
         if (preparedContent === null || preparedContent.contentId !== msg.contentId) {
           return;
         }
-        if (preparedContent.workerTextSender === null) {
+        if (preparedContent.coreTextSender === null) {
           log.error("Core", "Removed text track but text track aren't enabled");
           return;
         }
-        preparedContent.workerTextSender.onRemoveSuccess(msg.value.ranges);
+        preparedContent.coreTextSender.onRemoveSuccess(msg.value.ranges);
         break;
       }
 
@@ -402,21 +444,21 @@ export default function initializeWorkerMain() {
         if (preparedContent === null || preparedContent.contentId !== msg.contentId) {
           return;
         }
-        if (preparedContent.workerTextSender === null) {
+        if (preparedContent.coreTextSender === null) {
           log.error("Core", "Removed text track but text track aren't enabled");
           return;
         }
-        preparedContent.workerTextSender.onRemoveError(new Error(msg.value.message));
+        preparedContent.coreTextSender.onRemoveError(new Error(msg.value.message));
         break;
       }
 
       case MainThreadMessageType.PullSegmentSinkStoreInfos: {
-        sendSegmentSinksStoreInfos(contentPreparer, msg.value.requestId);
+        sendSegmentSinksStoreInfos(sendMessage, contentPreparer, msg.value.requestId);
         break;
       }
 
       case MainThreadMessageType.ThumbnailDataRequest: {
-        sendThumbnailData(contentPreparer, msg);
+        sendThumbnailData(sendMessage, contentPreparer, msg);
         break;
       }
 
@@ -425,53 +467,88 @@ export default function initializeWorkerMain() {
         break;
       }
 
+      case MainThreadMessageType.AppDefined: {
+        break;
+      }
+
       default:
         assertUnreachable(msg);
     }
-  };
+  });
 }
 
+/**
+ * Performs steps needed to prepare a future content to be played:
+ *   - Load its Manifest file
+ *   - Create MSE `MediaSource` for that content.
+ *   - Initialize all modules that will follow that content
+ *   - etc.
+ * @param {Function} sendMessage - Function allowing to send messages to the
+ * "main thread" part of the RxPlayer logic.
+ * @param {ContentPreparer} contentPreparer - Interface allowing to setup and
+ * prepare a content.
+ * @param {Object} contentInitData - Configuration wanted for the content to
+ * load.
+ * @param {Object} refs - Collection of so-called "references": values
+ * configuring playback that may be updated at any time and that the
+ * CoreEntry should react on.
+ * @param {Object} corePlugins - Callbacks that may have been registered by
+ * the application if it loaded the core independantly as a worker.
+ */
 function prepareNewContent(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   contentPreparer: ContentPreparer,
   contentInitData: IContentInitializationData,
+  refs: ICoreReferences,
+  corePlugins: ICorePlugins,
 ): void {
-  contentPreparer.initializeNewContent(contentInitData).then(
-    (manifest) => {
-      sendMessage({
-        type: WorkerMessageType.ManifestReady,
-        contentId: contentInitData.contentId,
-        value: { manifest },
-      });
-    },
-    (err: unknown) => {
-      sendMessage({
-        type: WorkerMessageType.Error,
-        contentId: contentInitData.contentId,
-        value: formatErrorForSender(err),
-      });
-    },
-  );
+  contentPreparer
+    .initializeNewContent(
+      sendMessage,
+      contentInitData,
+      {
+        limitResolution: { video: refs.limitVideoResolution },
+        throttleBitrate: { video: refs.throttleVideoBitrate },
+      },
+      corePlugins,
+    )
+    .then(
+      (manifest) => {
+        sendMessage({
+          type: CoreMessageType.ManifestReady,
+          contentId: contentInitData.contentId,
+          value: { manifest },
+        });
+      },
+      (err: unknown) => {
+        sendMessage({
+          type: CoreMessageType.Error,
+          contentId: contentInitData.contentId,
+          value: formatErrorForSender(err),
+        });
+      },
+    );
 }
 
-function updateGlobalReference(msg: IReferenceUpdateMessage): void {
+function updateCoreReference(msg: IReferenceUpdateMessage, refs: ICoreReferences): void {
   switch (msg.value.name) {
     case "wantedBufferAhead":
-      wantedBufferAhead.setValueIfChanged(msg.value.newVal);
+      refs.wantedBufferAhead.setValueIfChanged(msg.value.newVal);
       break;
     case "maxVideoBufferSize":
-      maxVideoBufferSize.setValueIfChanged(msg.value.newVal);
+      refs.maxVideoBufferSize.setValueIfChanged(msg.value.newVal);
       break;
     case "maxBufferBehind":
-      maxBufferBehind.setValueIfChanged(msg.value.newVal);
+      refs.maxBufferBehind.setValueIfChanged(msg.value.newVal);
       break;
     case "maxBufferAhead":
-      maxBufferAhead.setValueIfChanged(msg.value.newVal);
+      refs.maxBufferAhead.setValueIfChanged(msg.value.newVal);
       break;
     case "limitVideoResolution":
-      limitVideoResolution.setValueIfChanged(msg.value.newVal);
+      refs.limitVideoResolution.setValueIfChanged(msg.value.newVal);
       break;
     case "throttleVideoBitrate":
-      throttleVideoBitrate.setValueIfChanged(msg.value.newVal);
+      refs.throttleVideoBitrate.setValueIfChanged(msg.value.newVal);
       break;
     default:
       assertUnreachable(msg.value);
@@ -507,12 +584,14 @@ interface IContentHandle {
 }
 
 function loadPreparedContent(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   val: ILoadingContentParameters,
   contentPreparer: ContentPreparer,
-  playbackObservationRef: IReadOnlySharedReference<IWorkerPlaybackObservation>,
+  playbackObservationRef: IReadOnlySharedReference<ICorePlaybackObservation>,
+  refs: ICoreReferences,
 ): IContentHandle {
   log.debug("Core", "Loading pepared content.");
-  const contentCanceller = new TaskCanceller();
+  const contentCanceller = new TaskCanceller("Start Content Worker");
 
   let currentLoadCanceller: TaskCanceller | null = null;
 
@@ -522,17 +601,17 @@ function loadPreparedContent(
       return onMediaSourceReload();
     },
     stop: () => {
-      contentCanceller.cancel();
+      contentCanceller.cancel("ContentHandle stop");
     },
   };
 
   function startLoadingAt(startTime: number): void {
-    currentLoadCanceller?.cancel();
-    currentLoadCanceller = new TaskCanceller();
+    currentLoadCanceller?.cancel("Reloading content worker");
+    currentLoadCanceller = new TaskCanceller("(Re)Loading Content Worker");
     currentLoadCanceller.linkToSignal(contentCanceller.signal);
 
     /**
-     * Stores last discontinuity update sent to the worker for each Period and type
+     * Stores last discontinuity update sent to the Core for each Period and type
      * combinations, at least until the corresponding `PeriodStreamCleared`
      * message.
      *
@@ -541,14 +620,14 @@ function loadPreparedContent(
      */
     const lastSentDiscontinuitiesStore: Map<
       Period,
-      Map<ITrackType, IDiscontinuityUpdateWorkerMessagePayload>
+      Map<ITrackType, IDiscontinuityUpdateCoreMessagePayload>
     > = new Map();
 
     const preparedContent = contentPreparer.getCurrentContent();
     if (preparedContent === null || preparedContent.manifest === null) {
       const error = new OtherError("NONE", "Loading content when none is prepared");
       sendMessage({
-        type: WorkerMessageType.Error,
+        type: CoreMessageType.Error,
         contentId: undefined,
         value: formatErrorForSender(error),
       });
@@ -572,7 +651,7 @@ function loadPreparedContent(
         const freezeResolution =
           preparedContent.freezeResolver.onNewObservation(observation);
         if (freezeResolution !== null) {
-          handleFreezeResolution(freezeResolution, {
+          handleFreezeResolution(sendMessage, freezeResolution, {
             contentId,
             manifest,
             handleMediaSourceReload: performMediaSourceReload,
@@ -591,14 +670,14 @@ function loadPreparedContent(
         "Wanted starting time not found in the Manifest.",
       );
       sendMessage({
-        type: WorkerMessageType.Error,
+        type: CoreMessageType.Error,
         contentId,
         value: formatErrorForSender(error),
       });
       throw error;
     }
 
-    const playbackObserver = new WorkerPlaybackObserver(
+    const playbackObserver = new CorePlaybackObserver(
       playbackObservationRef,
       contentId,
       sendMessage,
@@ -617,13 +696,13 @@ function loadPreparedContent(
       {
         onWarning: (err: IPlayerError) =>
           sendMessage({
-            type: WorkerMessageType.Warning,
+            type: CoreMessageType.Warning,
             contentId,
             value: formatErrorForSender(err),
           }),
         onPeriodChanged: (period: Period) => {
           sendMessage({
-            type: WorkerMessageType.ActivePeriodChanged,
+            type: CoreMessageType.ActivePeriodChanged,
             contentId,
             value: { periodId: period.id },
           });
@@ -639,10 +718,10 @@ function loadPreparedContent(
       segmentSinksStore,
       segmentQueueCreator,
       {
-        wantedBufferAhead,
-        maxVideoBufferSize,
-        maxBufferAhead,
-        maxBufferBehind,
+        wantedBufferAhead: refs.wantedBufferAhead,
+        maxVideoBufferSize: refs.maxVideoBufferSize,
+        maxBufferAhead: refs.maxBufferAhead,
+        maxBufferBehind: refs.maxBufferBehind,
         drmSystemId,
         enableFastSwitching,
         onCodecSwitch,
@@ -660,7 +739,7 @@ function loadPreparedContent(
       return {
         needsBufferFlush(payload) {
           sendMessage({
-            type: WorkerMessageType.NeedsBufferFlush,
+            type: CoreMessageType.NeedsBufferFlush,
             contentId,
             value: payload,
           });
@@ -706,7 +785,7 @@ function loadPreparedContent(
 
         lockedStream(payload) {
           sendMessage({
-            type: WorkerMessageType.LockedStream,
+            type: CoreMessageType.LockedStream,
             contentId,
             value: {
               periodId: payload.period.id,
@@ -728,7 +807,7 @@ function loadPreparedContent(
             return;
           }
           sendMessage({
-            type: WorkerMessageType.AdaptationChanged,
+            type: CoreMessageType.AdaptationChanged,
             contentId,
             value: {
               adaptationId: value.adaptation?.id ?? null,
@@ -747,7 +826,7 @@ function loadPreparedContent(
             return;
           }
           sendMessage({
-            type: WorkerMessageType.RepresentationChanged,
+            type: CoreMessageType.RepresentationChanged,
             contentId,
             value: {
               adaptationId: value.adaptation.id,
@@ -760,7 +839,7 @@ function loadPreparedContent(
 
         inbandEvent(value) {
           sendMessage({
-            type: WorkerMessageType.InbandEvent,
+            type: CoreMessageType.InbandEvent,
             contentId,
             value,
           });
@@ -768,7 +847,7 @@ function loadPreparedContent(
 
         warning(value) {
           sendMessage({
-            type: WorkerMessageType.Warning,
+            type: CoreMessageType.Warning,
             contentId,
             value: formatErrorForSender(value),
           });
@@ -784,7 +863,7 @@ function loadPreparedContent(
             value.adaptationRef,
           );
           sendMessage({
-            type: WorkerMessageType.PeriodStreamReady,
+            type: CoreMessageType.PeriodStreamReady,
             contentId,
             value: { periodId: value.period.id, bufferType: value.type },
           });
@@ -811,7 +890,7 @@ function loadPreparedContent(
             value.type,
           );
           sendMessage({
-            type: WorkerMessageType.PeriodStreamCleared,
+            type: CoreMessageType.PeriodStreamCleared,
             contentId,
             value: { periodId: value.period.id, bufferType: value.type },
           });
@@ -829,7 +908,7 @@ function loadPreparedContent(
           // Considering this is only for an unimportant undocumented API, we may
           // throttle such messages. (e.g. max one per 2 seconds for each type?).
           sendMessage({
-            type: WorkerMessageType.BitrateEstimateChange,
+            type: CoreMessageType.BitrateEstimateChange,
             contentId,
             value: {
               bitrate: payload.bitrate,
@@ -844,7 +923,7 @@ function loadPreparedContent(
 
         needsDecipherabilityFlush() {
           sendMessage({
-            type: WorkerMessageType.NeedsDecipherabilityFlush,
+            type: CoreMessageType.NeedsDecipherabilityFlush,
             contentId,
             value: null,
           });
@@ -867,7 +946,7 @@ function loadPreparedContent(
               content.representation = content.representation.getMetadataSnapshot();
             }
             sendMessage({
-              type: WorkerMessageType.EncryptionDataEncountered,
+              type: CoreMessageType.EncryptionDataEncountered,
               contentId,
               value: {
                 keyIds: value.keyIds,
@@ -881,7 +960,7 @@ function loadPreparedContent(
 
         error(error: unknown) {
           sendMessage({
-            type: WorkerMessageType.Error,
+            type: CoreMessageType.Error,
             contentId,
             value: formatErrorForSender(error),
           });
@@ -920,7 +999,7 @@ function loadPreparedContent(
       };
       periodMap.set(value.bufferType, msgObj);
       sendMessage({
-        type: WorkerMessageType.DiscontinuityUpdate,
+        type: CoreMessageType.DiscontinuityUpdate,
         contentId,
         value: msgObj,
       });
@@ -929,7 +1008,7 @@ function loadPreparedContent(
 
   function performMediaSourceReload(payload: INeedsMediaSourceReloadPayload): void {
     if (currentLoadCanceller !== null) {
-      currentLoadCanceller.cancel();
+      currentLoadCanceller.cancel("WorkerMain MediaSource reload");
       currentLoadCanceller = null;
     }
     const mediaSourceId = contentPreparer.getCurrentContent()?.mediaSource.id;
@@ -945,7 +1024,7 @@ function loadPreparedContent(
 
     sendMessage(
       {
-        type: WorkerMessageType.ReloadingMediaSource,
+        type: CoreMessageType.ReloadingMediaSource,
         mediaSourceId,
         value: payload,
       },
@@ -959,11 +1038,11 @@ function loadPreparedContent(
     const lastObservation = playbackObservationRef.getValue();
     const newInitialTime = lastObservation.position.getWanted();
     if (currentLoadCanceller !== null) {
-      currentLoadCanceller.cancel();
+      currentLoadCanceller.cancel("MediaSource reload");
       currentLoadCanceller = null;
     }
     const contentId = contentPreparer.getCurrentContent()?.contentId;
-    contentPreparer.reloadMediaSource().then(
+    contentPreparer.reloadMediaSource(sendMessage).then(
       () => {
         log.info("Core", "MediaSource Reloaded, loading content again", {
           newInitialTime,
@@ -976,7 +1055,7 @@ function loadPreparedContent(
           return;
         }
         sendMessage({
-          type: WorkerMessageType.Error,
+          type: CoreMessageType.Error,
           contentId,
           value: formatErrorForSender(err),
         });
@@ -1004,7 +1083,7 @@ function updateLoggerLevel(
       });
       // Not relying on `sendMessage` as it also logs
       postMessage({
-        type: WorkerMessageType.LogMessage,
+        type: CoreMessageType.LogMessage,
         value: {
           namespace,
           logLevel: levelStr,
@@ -1018,10 +1097,12 @@ function updateLoggerLevel(
 /**
  * Send a message `SegmentSinkStoreUpdate` to the main thread with
  * a serialized object that represents the segmentSinksStore state.
+ * @param {Function} sendMessage - Function allowing to send messages to the
+ * "main thread" part of the RxPlayer logic.
  * @param {ContentPreparer} contentPreparer
- * @returns {void}
  */
 function sendSegmentSinksStoreInfos(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   contentPreparer: ContentPreparer,
   requestId: number,
 ): void {
@@ -1031,7 +1112,7 @@ function sendSegmentSinksStoreInfos(
   }
   const segmentSinksMetrics = currentContent.segmentSinksStore.getSegmentSinksMetrics();
   sendMessage({
-    type: WorkerMessageType.SegmentSinkStoreUpdate,
+    type: CoreMessageType.SegmentSinkStoreUpdate,
     contentId: currentContent.contentId,
     value: { segmentSinkMetrics: segmentSinksMetrics, requestId },
   });
@@ -1039,6 +1120,8 @@ function sendSegmentSinksStoreInfos(
 
 /**
  * Handle accordingly an `IFreezeResolution` object.
+ * @param {Function} sendMessage - Function allowing to send messages to the
+ * "main thread" part of the RxPlayer logic.
  * @param {Object|null} freezeResolution - The `IFreezeResolution` suggested.
  * @param {Object} param - Parameters that might be needed to implement the
  * resolution.
@@ -1052,6 +1135,7 @@ function sendSegmentSinksStoreInfos(
  * `IFreezeResolution` object suggest it.
  */
 function handleFreezeResolution(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   freezeResolution: IFreezeResolution,
   {
     contentId,
@@ -1078,7 +1162,7 @@ function handleFreezeResolution(
     case "flush": {
       log.info("Core", "Flushing buffer due to freeze");
       sendMessage({
-        type: WorkerMessageType.NeedsBufferFlush,
+        type: CoreMessageType.NeedsBufferFlush,
         contentId,
         value: {
           relativeResumingPosition: freezeResolution.value.relativeSeek,
@@ -1111,13 +1195,14 @@ function handleFreezeResolution(
  * @returns {void}
  */
 function sendThumbnailData(
+  sendMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void,
   contentPreparer: ContentPreparer,
   msg: IThumbnailDataRequestMainMessage,
 ): void {
   const preparedContent = contentPreparer.getCurrentContent();
   const respondWithError = (err: unknown) => {
     sendMessage({
-      type: WorkerMessageType.ThumbnailDataResponse,
+      type: CoreMessageType.ThumbnailDataResponse,
       contentId: msg.contentId,
       value: {
         status: "error",
@@ -1145,7 +1230,7 @@ function sendThumbnailData(
     (result) => {
       sendMessage(
         {
-          type: WorkerMessageType.ThumbnailDataResponse,
+          type: CoreMessageType.ThumbnailDataResponse,
           contentId: msg.contentId,
           value: {
             status: "success",
@@ -1161,3 +1246,20 @@ function sendThumbnailData(
     },
   );
 }
+
+/**
+ * Collection of so-called "references": values configuring playback that may
+ * be updated at any time and that the CoreEntry should react on.
+ */
+export interface ICoreReferences {
+  limitVideoResolution: SharedReference<IResolutionInfo>;
+  /** Max buffer size after the current position, in seconds (we GC further up). */
+  maxBufferAhead: SharedReference<number>;
+  /** Max buffer size before the current position, in seconds (we GC further down). */
+  maxBufferBehind: SharedReference<number>;
+  /** Buffer maximum size in kiloBytes at which we stop downloading */
+  maxVideoBufferSize: SharedReference<number>;
+  throttleVideoBitrate: SharedReference<number>;
+  /** Buffer "goal" at which we stop downloading new segments. */
+  wantedBufferAhead: SharedReference<number>;
+}