rx-player 4.4.0 → 4.4.1-dev.2025101500

package/src/experimental/features/__tests__/metaplaylist.test.ts

@@ -1,5 +1,7 @@
 import { describe, it, expect } from "vitest";
+import initializeCoreEntry from "../../../core/entry";
 import type { IFeaturesObject } from "../../../features/types";
+import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import metaplaylist from "../../../transports/metaplaylist";
 import addLocalManifestFeature from "../metaplaylist";
@@ -10,9 +12,16 @@ describe("Features list - METAPLAYLIST", () => {
     addLocalManifestFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { metaplaylist },
-      mainThreadMediaSourceInit: MediaSourceContentInitializer,
+      monothread: {
+        init: MediaSourceContentInitializer,
+        coreInterface: MonoThreadCoreInterface,
+        initializeCoreEntry,
+      },
     });
     expect(featureObject.transports.metaplaylist).toBe(metaplaylist);
-    expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
+    expect(featureObject.monothread).not.toBe(null);
+    expect(featureObject.monothread?.init).toBe(MediaSourceContentInitializer);
+    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
+    expect(featureObject.monothread?.initializeCoreEntry).toBe(initializeCoreEntry);
   });
 });

package/src/experimental/features/__tests__/multi_thread.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest";
 import type { IFeaturesObject } from "../../../features/types";
-import MultiThreadContentInitializer from "../../../main_thread/init/multi_thread_content_initializer";
+import { WorkerCoreInterface } from "../../../main_thread/core_interface/multithread";
+import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import addMultiThreadFeature from "../multi_thread";
 
 describe("Features list - EME", () => {
@@ -8,10 +9,14 @@ describe("Features list - EME", () => {
     const featureObject: IFeaturesObject = {} as IFeaturesObject;
     addMultiThreadFeature(featureObject);
     expect(featureObject).toEqual({
-      multithread: { init: MultiThreadContentInitializer },
+      multithread: {
+        init: MediaSourceContentInitializer,
+        coreInterface: WorkerCoreInterface,
+      },
     });
     expect(featureObject.multithread).not.toBe(null);
     expect(featureObject.multithread).not.toBe(undefined);
-    expect(featureObject.multithread?.init).toBe(MultiThreadContentInitializer);
+    expect(featureObject.multithread?.init).toBe(MediaSourceContentInitializer);
+    expect(featureObject.multithread?.coreInterface).toBe(WorkerCoreInterface);
   });
 });

package/src/experimental/features/local.ts

@@ -14,13 +14,19 @@
  * limitations under the License.
  */
 
+import initializeCoreEntry from "../../core/entry";
 import type { IFeaturesObject } from "../../features/types";
+import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import local from "../../transports/local";
 
 function addLocalManifestFeature(features: IFeaturesObject): void {
   features.transports.local = local;
-  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
+  features.monothread = {
+    init: MediaSourceContentInitializer,
+    coreInterface: MonoThreadCoreInterface,
+    initializeCoreEntry,
+  };
 }
 
 export { addLocalManifestFeature as LOCAL_MANIFEST };

package/src/experimental/features/metaplaylist.ts

@@ -14,13 +14,19 @@
  * limitations under the License.
  */
 
+import initializeCoreEntry from "../../core/entry";
 import type { IFeaturesObject } from "../../features/types";
+import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import metaplaylist from "../../transports/metaplaylist";
 
 function addMetaPlaylistFeature(features: IFeaturesObject): void {
   features.transports.metaplaylist = metaplaylist;
-  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
+  features.monothread = {
+    init: MediaSourceContentInitializer,
+    coreInterface: MonoThreadCoreInterface,
+    initializeCoreEntry,
+  };
 }
 
 export { addMetaPlaylistFeature as METAPLAYLIST };

package/src/experimental/features/multi_thread.ts

@@ -1,12 +1,16 @@
 import type { IFeaturesObject } from "../../features/types";
-import MultiThreadContentInitializer from "../../main_thread/init/multi_thread_content_initializer";
+import { WorkerCoreInterface } from "../../main_thread/core_interface/multithread";
+import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 
 /**
  * Add ability to run the RxPlayer's main buffering logic in a WebMultiThread.
  * @param {Object} features
  */
 function addMultiThreadFeature(features: IFeaturesObject): void {
-  features.multithread = { init: MultiThreadContentInitializer };
+  features.multithread = {
+    init: MediaSourceContentInitializer,
+    coreInterface: WorkerCoreInterface,
+  };
 }
 
 export { addMultiThreadFeature as MULTI_THREAD };

package/src/features/features_object.ts

@@ -27,7 +27,7 @@ const features: IFeaturesObject = {
   decrypt: null,
   htmlTextDisplayer: null,
   htmlTextTracksParsers: {},
-  mainThreadMediaSourceInit: null,
+  monothread: null,
   multithread: null,
   nativeTextDisplayer: null,
   nativeTextTracksParsers: {},

package/src/features/list/__tests__/dash.test.ts

@@ -1,4 +1,6 @@
 import { describe, it, expect } from "vitest";
+import initializeCoreEntry from "../../../core/entry";
+import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import dashJsParser from "../../../parsers/manifest/dash/js-parser";
 import DASHFeature from "../../../transports/dash";
@@ -10,15 +12,22 @@ describe("Features list - DASH", () => {
     const featureObject = {
       transports: {},
       dashParsers: { js: null, wasm: null },
-      mainThreadMediaSourceInit: null,
+      monothread: null,
     } as unknown as IFeaturesObject;
     addDASHFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { dash: DASHFeature },
       dashParsers: { js: dashJsParser, wasm: null },
-      mainThreadMediaSourceInit: MediaSourceContentInitializer,
+      monothread: {
+        init: MediaSourceContentInitializer,
+        coreInterface: MonoThreadCoreInterface,
+        initializeCoreEntry,
+      },
     });
     expect(featureObject.transports.dash).toBe(DASHFeature);
-    expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
+    expect(featureObject.monothread).not.toBe(null);
+    expect(featureObject.monothread?.init).toBe(MediaSourceContentInitializer);
+    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
+    expect(featureObject.monothread?.initializeCoreEntry).toBe(initializeCoreEntry);
   });
 });

package/src/features/list/__tests__/smooth.test.ts

@@ -1,4 +1,6 @@
 import { describe, it, expect } from "vitest";
+import initializeCoreEntry from "../../../core/entry";
+import { MonoThreadCoreInterface } from "../../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../../main_thread/init/media_source_content_initializer";
 import SmoothFeature from "../../../transports/smooth";
 import type { IFeaturesObject } from "../../types";
@@ -10,9 +12,16 @@ describe("Features list - Smooth", () => {
     addSmoothFeature(featureObject);
     expect(featureObject).toEqual({
       transports: { smooth: SmoothFeature },
-      mainThreadMediaSourceInit: MediaSourceContentInitializer,
+      monothread: {
+        init: MediaSourceContentInitializer,
+        coreInterface: MonoThreadCoreInterface,
+        initializeCoreEntry,
+      },
     });
     expect(featureObject.transports.smooth).toBe(SmoothFeature);
-    expect(featureObject.mainThreadMediaSourceInit).toBe(MediaSourceContentInitializer);
+    expect(featureObject.monothread).not.toBe(null);
+    expect(featureObject.monothread?.init).toBe(MediaSourceContentInitializer);
+    expect(featureObject.monothread?.coreInterface).toBe(MonoThreadCoreInterface);
+    expect(featureObject.monothread?.initializeCoreEntry).toBe(initializeCoreEntry);
   });
 });

package/src/features/list/dash.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import initializeCoreEntry from "../../core/entry";
+import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import dashJsParser from "../../parsers/manifest/dash/js-parser";
 import dash from "../../transports/dash";
@@ -28,7 +30,11 @@ function addDASHFeature(features: IFeaturesObject): void {
     features.transports.dash = dash;
   }
   features.dashParsers.js = dashJsParser;
-  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
+  features.monothread = {
+    init: MediaSourceContentInitializer,
+    coreInterface: MonoThreadCoreInterface,
+    initializeCoreEntry,
+  };
 }
 
 export { addDASHFeature as DASH };

package/src/features/list/dash_wasm.ts

@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 
+import initializeCoreEntry from "../../core/entry";
 import type { IFeaturesObject } from "../../features/types";
+import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import type { IDashWasmParserOptions } from "../../parsers/manifest/dash/wasm-parser";
 import DashWasmParser from "../../parsers/manifest/dash/wasm-parser";
@@ -27,7 +29,11 @@ const dashWasmFeature = {
       features.transports.dash = dash;
     }
     features.dashParsers.wasm = dashWasmParser;
-    features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
+    features.monothread = {
+      init: MediaSourceContentInitializer,
+      coreInterface: MonoThreadCoreInterface,
+      initializeCoreEntry,
+    };
   },
 
   initialize(opts: IDashWasmParserOptions): Promise<void> {

package/src/features/list/media_source_main.ts

@@ -1,3 +1,5 @@
+import initializeCoreEntry from "../../core/entry";
+import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import type { IFeaturesObject } from "../types";
 
@@ -6,7 +8,11 @@ import type { IFeaturesObject } from "../types";
  * @param {Object} features
  */
 function addMediaSourceMainFeature(features: IFeaturesObject): void {
-  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
+  features.monothread = {
+    init: MediaSourceContentInitializer,
+    coreInterface: MonoThreadCoreInterface,
+    initializeCoreEntry,
+  };
 }
 
 export { addMediaSourceMainFeature as MEDIA_SOURCE_MAIN };

package/src/features/list/smooth.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import initializeCoreEntry from "../../core/entry";
+import { MonoThreadCoreInterface } from "../../main_thread/core_interface/monothread";
 import MediaSourceContentInitializer from "../../main_thread/init/media_source_content_initializer";
 import smooth from "../../transports/smooth";
 import type { IFeaturesObject } from "../types";
@@ -26,7 +28,11 @@ function addSmoothFeature(features: IFeaturesObject): void {
   if (features.transports.smooth === undefined) {
     features.transports.smooth = smooth;
   }
-  features.mainThreadMediaSourceInit = MediaSourceContentInitializer;
+  features.monothread = {
+    init: MediaSourceContentInitializer,
+    coreInterface: MonoThreadCoreInterface,
+    initializeCoreEntry,
+  };
 }
 
 export { addSmoothFeature as SMOOTH };

package/src/features/types.ts

@@ -15,11 +15,15 @@
  */
 
 import type { IMediaElement } from "../compat/browser_compatibility_types";
+import type IInitializeCoreEntry from "../core/entry";
 import type { SegmentSink } from "../core/segment_sinks";
+import type {
+  WorkerCoreInterface,
+  MonoThreadCoreInterface,
+} from "../main_thread/core_interface/types";
 import type ContentDecryptor from "../main_thread/decrypt";
 import type DirectFileContentInitializer from "../main_thread/init/directfile_content_initializer";
 import type MediaSourceContentInitializer from "../main_thread/init/media_source_content_initializer";
-import type MultiThreadContentInitializer from "../main_thread/init/multi_thread_content_initializer";
 import type HTMLTextDisplayer from "../main_thread/text_displayer/html";
 import type NativeTextDisplayer from "../main_thread/text_displayer/native/native_text_displayer";
 import type MediaElementTracksStore from "../main_thread/tracks_store/media_element_tracks_store";
@@ -114,14 +118,29 @@ export interface IFeaturesObject {
    * Feature allowing to load contents through MediaSource API through the
    * main thread.
    */
-  mainThreadMediaSourceInit: typeof MediaSourceContentInitializer | null;
+  monothread: {
+    /** Class to load a content through the MediaSource API. */
+    init: typeof MediaSourceContentInitializer;
+    /** The RxPlayer's core logic. */
+    initializeCoreEntry: typeof IInitializeCoreEntry;
+    /**
+     * Class allowing to exchange messages with the RxPlayer's `core`, here
+     * running in `coreEntry`
+     */
+    coreInterface: typeof MonoThreadCoreInterface;
+  } | null;
   /**
    * Features allowing to load contents through MediaSource API through
    * a WebWorker.
    */
   multithread: {
-    /** Class to load a content through MediaSource API via a WebWorker. */
-    init: typeof MultiThreadContentInitializer;
+    /** Class to load a content through the MediaSource API. */
+    init: typeof MediaSourceContentInitializer;
+    /**
+     * Class allowing to exchange messages with the RxPlayer's `core`, here
+     * running in another thread.
+     */
+    coreInterface: typeof WorkerCoreInterface;
   } | null;
   /**
    * Function for loading and parsing contents through various protocols, by

package/src/main_thread/README.md

@@ -27,6 +27,14 @@ Those modules are:
   Negotiate content decryption. Only used for contents with DRM (Digital Right
   Management).
 
+- **the `CoreInterface` (./core_interface)**
+
+  Provide an interface allowing to communicate to the central RxPlayer logic in the `core`
+  directory (`../core/`), which may run in another thread.
+
+  That interface depends on the context (e.g. depending on if we are playing in a
+  mono-threaded mode or a multithreaded mode).
+
 - **the `TracksStore` (or `MediaElementTracksStore`) (./tracks_store)**
 
   Ease up text/audio/video track switching to provide a simple-to-use API.

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,
@@ -445,7 +445,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.4.0";
+    this.version = /* PLAYER_VERSION */ "4.4.1-dev.2025101500";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -572,8 +572,8 @@ 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);
@@ -586,7 +586,7 @@ 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);
@@ -1034,6 +1034,19 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         connectionTimeout: requestConfig.segment?.connectionTimeout,
       };
 
+      const transportOptions = {
+        lowLatencyMode,
+        checkMediaSegmentIntegrity,
+        checkManifestIntegrity,
+        referenceDateTime,
+        serverSyncInfos,
+        manifestLoader,
+        segmentLoader,
+        representationFilter: options.representationFilter,
+        __priv_manifestUpdateUrl,
+        __priv_patchLastSegmentInSidx,
+      };
+
       const canRunInMultiThread =
         features.multithread !== null &&
         this._priv_worker !== null &&
@@ -1044,39 +1057,33 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         ) &&
         typeof options.representationFilter !== "function";
       if (mode === "main" || (mode === "auto" && !canRunInMultiThread)) {
-        if (features.mainThreadMediaSourceInit === null) {
+        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;
-
         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,
+        );
+        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 +1092,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) {
@@ -1108,19 +1117,8 @@ class Player extends EventEmitter<IPublicAPIEvent> {
         assert(typeof options.representationFilter !== "function");
         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_worker),
           adaptiveOptions,
           autoPlay,
           bufferOptions,
@@ -1129,13 +1127,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,
         });
@@ -3576,7 +3574,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     }
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.4.0";
+Player.version = /* PLAYER_VERSION */ "4.4.1-dev.2025101500";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/core_interface/README.md

@@ -0,0 +1,22 @@
+# CoreInterface
+
+| Consideration           | Status                                               |
+| ----------------------- | ---------------------------------------------------- |
+| Preferred import style  | Only through the `features` object                   |
+| Multithread environment | May run in WebWorker depending on the implementation |
+
+## Overview
+
+This directory defines `CoreInterface` implementations, which is the link between the
+RxPlayer's "main_thread" logic (which implements logic running always in main thread: the
+API, decryption, subtitles rendering, track management...) to the RxPlayer's "core" logic
+(which implements logic which may run in a WebWorker: manifest loading, segment loading
+and parsing, adaptive...).
+
+Depending on if playback for the current content currently relies on a single thread or
+multiple ones, a different `CoreInterface` implementation will be selected.
+
+This directory should not be imported directly by the main logic (beside types). Rather,
+the RxPlayer's global `features` object should refer to the implementations currently
+available instead. This is to ensure that the `CoreInterface` logic is only imported if
+the application has explicitly asked for the corresponding feature.

package/src/main_thread/core_interface/base.ts

@@ -0,0 +1,36 @@
+import type { ICoreMessage } from "../../core/types";
+import type { IMainThreadMessage } from "../types";
+
+export default abstract class CoreInterface {
+  protected listeners: Array<(evt: ICoreMessage) => void> = [];
+  protected listenersError: Array<() => void> = [];
+
+  public abstract sendMessage(msg: IMainThreadMessage): void;
+
+  public addMessageListener(cb: (evt: ICoreMessage) => void): void {
+    this.listeners.push(cb);
+  }
+
+  public removeMessageListener(cb: (evt: ICoreMessage) => void): void {
+    const index = this.listeners.indexOf(cb);
+    if (index >= 0) {
+      this.listeners.splice(index, 1);
+    }
+  }
+
+  public addErrorListener(cb: () => void): void {
+    this.listenersError.push(cb);
+  }
+
+  public removeErrorListener(cb: () => void): void {
+    const index = this.listenersError.indexOf(cb);
+    if (index >= 0) {
+      this.listenersError.splice(index, 1);
+    }
+  }
+
+  public dispose(): void {
+    this.listeners.length = 0;
+    this.listenersError.length = 0;
+  }
+}

package/src/main_thread/core_interface/monothread.ts

@@ -0,0 +1,46 @@
+import {
+  CoreMessageType,
+  type ICoreMessage,
+  type IMessageReceiverCallback,
+} from "../../core/types";
+import log from "../../log";
+import noop from "../../utils/noop";
+import type { IMainThreadMessage } from "../types";
+import CoreInterface from "./base";
+
+export class MonoThreadCoreInterface extends CoreInterface {
+  private _currentCoreListener: IMessageReceiverCallback;
+
+  constructor() {
+    super();
+    this._currentCoreListener = noop;
+  }
+
+  public sendMessage(msg: IMainThreadMessage) {
+    log.debug("M-->C", "Sending message", { name: msg.type });
+    queueMicrotask(() => {
+      // NOTE: We don't clone for performance reasons
+      this._currentCoreListener({ data: msg });
+    });
+  }
+
+  public getCallbacks(): {
+    setCoreMessageReceiver: (handler: IMessageReceiverCallback) => void;
+    sendCoreMessage: (msg: ICoreMessage, transferables?: Transferable[]) => void;
+  } {
+    const setCoreMessageReceiver = (handler: IMessageReceiverCallback): void => {
+      this._currentCoreListener = handler;
+    };
+    const sendCoreMessage = (msg: ICoreMessage, _transferables?: Transferable[]) => {
+      queueMicrotask(() => {
+        if (msg.type !== CoreMessageType.LogMessage) {
+          log.debug("M<--C", "Sending message", { name: msg.type });
+        }
+        this.listeners.forEach((listener) => {
+          listener(msg);
+        });
+      });
+    };
+    return { setCoreMessageReceiver, sendCoreMessage };
+  }
+}