rx-player 4.4.1 → 4.5.0-dev.2026012301

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/experimental/features/worker/index.ts

@@ -0,0 +1,5 @@
+export { DASH, DASH_WASM } from "../../../features/list";
+export { LOCAL_MANIFEST } from "../local";
+
+// TODO: `SMOOTH` (has to be made worker-compatible)
+// TODO: `METAPLAYLIST` (once every transport is ported)

package/src/experimental/tools/DummyMediaElement/html5.ts

@@ -410,8 +410,8 @@ export class DummyMediaElement
   public set src(val: string) {
     this._src = val;
     this.srcObject = null;
-    this._currentContentCanceller?.cancel();
-    const canceller = new TaskCanceller();
+    this._currentContentCanceller?.cancel("Resetting DummyMediaElement src");
+    const canceller = new TaskCanceller("DummyMediaElement src");
     this._currentContentCanceller = canceller;
     setTimeout(() => {
       while (this._pendingPlayPromises.length > 0) {
@@ -445,7 +445,7 @@ export class DummyMediaElement
   public set srcObject(val: MediaProvider | null) {
     // media element load algorithm
 
-    this._currentContentCanceller?.cancel();
+    this._currentContentCanceller?.cancel("Resetting DummyMediaElement srcObject");
     this._wasLoadedDataSentForCurrentContent = false;
     this._wasPlayPerformedOnCurrentContent = false;
     this.buffered = new TimeRangesWithMetadata();
@@ -478,7 +478,7 @@ export class DummyMediaElement
         throw new Error("A DummyMediaElement can only be linked to a DummyMediaSource");
       }
       this._attachedMediaSource = val;
-      this._currentContentCanceller = new TaskCanceller();
+      this._currentContentCanceller = new TaskCanceller("DummyMediaElement srcObject");
       const intervalId = setInterval(() => {
         this._tick();
       }, TICK_INTERVAL);

package/src/experimental/tools/DummyMediaElement/mse.ts

@@ -164,14 +164,14 @@ export class DummyMediaSource
       sb.updating = false;
       if (sb instanceof DummySourceBuffer) {
         if (sb.currentAppendCanceller !== null) {
-          sb.currentAppendCanceller.cancel();
+          sb.currentAppendCanceller.cancel("Removing DummySourceBuffer");
           sb.currentAppendCanceller = null;
           sb.eventScheduler
             .schedule(sb, "abort", null)
             .then(() => sb.eventScheduler.schedule(sb, "updateend", null))
             .catch(noop);
         }
-        sb.canceller.cancel();
+        sb.canceller.cancel("Removing DummySourceBuffer");
         sb.removed = true;
       }
     }
@@ -369,7 +369,7 @@ export class DummySourceBuffer
     this.onerror = null;
     this.onabort = null;
     this.hasMetadata = false;
-    this.canceller = new TaskCanceller();
+    this.canceller = new TaskCanceller("DummySourceBuffer");
     this.currentAppendCanceller = null;
     this._lastKeyId = null;
     this._callbacks = callbacks;
@@ -485,7 +485,7 @@ export class DummySourceBuffer
 
     this.updating = true;
 
-    const canceller = new TaskCanceller();
+    const canceller = new TaskCanceller("DummySourceBuffer append");
     canceller.linkToSignal(this.canceller.signal);
     this.currentAppendCanceller = canceller;
     this.eventScheduler
@@ -629,7 +629,7 @@ export class DummySourceBuffer
     }
 
     if (this.updating) {
-      this.currentAppendCanceller?.cancel();
+      this.currentAppendCanceller?.cancel("Aborting DummySourceBuffer");
       this.currentAppendCanceller = null;
       this.updating = false;
       this.eventScheduler

package/src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts

@@ -16,11 +16,9 @@
 
 import { MediaSource_ } from "../../../compat/browser_compatibility_types";
 import type { IMediaElement } from "../../../compat/browser_compatibility_types";
+import disableRemotePlaybackOnManagedMediaSource from "../../../compat/disable_remote_playback_on_managed_media_source";
+import resetMediaElement from "../../../compat/reset_media_element";
 import log from "../../../log";
-import {
-  resetMediaElement,
-  disableRemotePlaybackOnManagedMediaSource,
-} from "../../../main_thread/init/utils/create_media_source";
 import { SourceBufferType } from "../../../mse";
 import type { MainSourceBufferInterface } from "../../../mse/main_media_source_interface";
 import MainMediaSourceInterface from "../../../mse/main_media_source_interface";

package/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -78,7 +78,7 @@ export default class VideoThumbnailLoader {
     const manifest = this._player.__priv_getManifest();
     if (manifest === null) {
       if (this._lastRepresentationInfo !== null) {
-        this._lastRepresentationInfo.cleaner.cancel();
+        this._lastRepresentationInfo.cleaner.cancel("VTL: no manifest");
         this._lastRepresentationInfo = null;
       }
       return Promise.reject(
@@ -94,7 +94,7 @@ export default class VideoThumbnailLoader {
     const content = getTrickModeInfo(time, manifest);
     if (content === null) {
       if (this._lastRepresentationInfo !== null) {
-        this._lastRepresentationInfo.cleaner.cancel();
+        this._lastRepresentationInfo.cleaner.cancel("VTL: no trickmode");
         this._lastRepresentationInfo = null;
       }
       return Promise.reject(
@@ -109,7 +109,7 @@ export default class VideoThumbnailLoader {
       this._lastRepresentationInfo !== null &&
       !areSameRepresentation(this._lastRepresentationInfo.content, content)
     ) {
-      this._lastRepresentationInfo.cleaner.cancel();
+      this._lastRepresentationInfo.cleaner.cancel("VTL: Representation is different");
       this._lastRepresentationInfo = null;
     }
 
@@ -120,7 +120,7 @@ export default class VideoThumbnailLoader {
 
     if (neededSegments.length === 0) {
       if (this._lastRepresentationInfo !== null) {
-        this._lastRepresentationInfo.cleaner.cancel();
+        this._lastRepresentationInfo.cleaner.cancel("VTL: no segment info");
         this._lastRepresentationInfo = null;
       }
       return Promise.reject(
@@ -166,7 +166,7 @@ export default class VideoThumbnailLoader {
     const loader = loaders[content.manifest.transport];
     if (loader === undefined) {
       if (this._lastRepresentationInfo !== null) {
-        this._lastRepresentationInfo.cleaner.cancel();
+        this._lastRepresentationInfo.cleaner.cancel("VTL: no parser");
         this._lastRepresentationInfo = null;
       }
       return Promise.reject(
@@ -180,7 +180,7 @@ export default class VideoThumbnailLoader {
 
     let lastRepInfo: IVideoThumbnailLoaderRepresentationInfo;
     if (this._lastRepresentationInfo === null) {
-      const lastRepInfoCleaner = new TaskCanceller();
+      const lastRepInfoCleaner = new TaskCanceller("VTL: Representation Info");
       const segmentFetcher = createSegmentFetcher({
         bufferType: "video",
         pipeline: loader.video,
@@ -235,12 +235,14 @@ export default class VideoThumbnailLoader {
 
     abortUnlistedSegmentRequests(lastRepInfo.pendingRequests, neededSegments);
 
-    const currentTaskCanceller = new TaskCanceller();
+    const currentTaskCanceller = new TaskCanceller("VTL: Task");
 
     return lastRepInfo.sourceBuffer
       .catch((err) => {
         if (this._lastRepresentationInfo !== null) {
-          this._lastRepresentationInfo.cleaner.cancel();
+          this._lastRepresentationInfo.cleaner.cancel(
+            "VTL: SourceBuffer initialization failure",
+          );
           this._lastRepresentationInfo = null;
         }
         throw new VideoThumbnailLoaderError(
@@ -272,7 +274,7 @@ export default class VideoThumbnailLoader {
           if (pending !== undefined) {
             promises.push(pending.promise);
           } else {
-            const requestCanceller = new TaskCanceller();
+            const requestCanceller = new TaskCanceller("VTL: Request");
             const unlinkSignal = requestCanceller.linkToSignal(
               lastRepInfo.cleaner.signal,
             );
@@ -327,7 +329,7 @@ export default class VideoThumbnailLoader {
    */
   dispose(): void {
     if (this._lastRepresentationInfo !== null) {
-      this._lastRepresentationInfo.cleaner.cancel();
+      this._lastRepresentationInfo.cleaner.cancel("VTL: dispose");
       this._lastRepresentationInfo = null;
     }
   }
@@ -382,7 +384,7 @@ function abortUnlistedSegmentRequests(
   pendingRequests
     .filter((req) => !neededSegments.some(({ id }) => id === req.segmentId))
     .forEach((req) => {
-      req.canceller.cancel();
+      req.canceller.cancel("VTL: abort unlisted segments");
     });
 }
 

package/src/experimental/tools/createMetaplaylist/get_duration_from_manifest.ts

@@ -75,7 +75,7 @@ async function getDurationFromManifest(
       timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
       connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
       // We won't cancel
-      cancelSignal: new TaskCanceller().signal,
+      cancelSignal: new TaskCanceller(undefined).signal,
     });
     const { responseData } = response;
     const root = responseData.documentElement;
@@ -116,7 +116,7 @@ async function getDurationFromManifest(
     timeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT,
     connectionTimeout: config.getCurrent().DEFAULT_CONNECTION_TIMEOUT,
     // We won't cancel
-    cancelSignal: new TaskCanceller().signal,
+    cancelSignal: new TaskCanceller(undefined).signal,
   });
   const { responseData } = response;
   const metaplaylist = JSON.parse(responseData) as IMetaPlaylist;

package/src/features/README.md

@@ -8,3 +8,8 @@ RxPlayer without importing others.
 
 How this is technically done is through a global `features` Object, which will have added
 properties (which corresponds to those features' code) each time a new feature is added.
+
+## For workers
+
+The `worker` directory contains features intended for the worker-side that will then be
+exported through the RxPlayer's `worker/features` path.

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