rx-player 4.4.1 → 4.5.0-dev.2026012301

package/src/core/{main/worker/worker_text_displayer_interface.ts → entry/core_text_displayer_interface.ts}

@@ -1,25 +1,25 @@
-import log from "../../../log";
-import type { ITextDisplayerData } from "../../../main_thread/types";
+import log from "../../log";
+import type { ITextDisplayerData } from "../../main_thread/types";
+import type { IRange } from "../../utils/ranges";
+import { CancellationError } from "../../utils/task_canceller";
+import type { ITextDisplayerInterface } from "../segment_sinks";
 import type {
-  IRemoveTextDataWorkerMessage,
-  IStopTextDisplayerWorkerMessage,
-  IResetTextDisplayerWorkerMessage,
-  IPushTextDataWorkerMessage,
-} from "../../../multithread_types";
-import { WorkerMessageType } from "../../../multithread_types";
-import type { IRange } from "../../../utils/ranges";
-import { CancellationError } from "../../../utils/task_canceller";
-import type { ITextDisplayerInterface } from "../../segment_sinks";
+  IPushTextDataCoreMessage,
+  IRemoveTextDataCoreMessage,
+  IResetTextDisplayerCoreMessage,
+  IStopTextDisplayerCoreMessage,
+} from "../types";
+import { CoreMessageType } from "../types";
 
 /**
- * Implementation of an `ITextDisplayerInterface` running in a WebWorker
- * (so, in a different thread than the `ITextDisplayer`).
+ * Implementation of an `ITextDisplayerInterface` for the Core, that can run in
+ * a WebWorker (so, in a different thread than the `ITextDisplayer`).
  *
- * @class WorkerTextDisplayerInterface
+ * @class CoreTextDisplayerInterface
  */
-export default class WorkerTextDisplayerInterface implements ITextDisplayerInterface {
+export default class CoreTextDisplayerInterface implements ITextDisplayerInterface {
   private _contentId: string;
-  private _messageSender: (msg: IWorkerTextDisplayerInterfaceMessage) => void;
+  private _messageSender: (msg: ICoreTextDisplayerInterfaceMessage) => void;
   public _queues: {
     pushTextData: Array<{
       resolve: (ranges: IRange[]) => void;
@@ -37,7 +37,7 @@ export default class WorkerTextDisplayerInterface implements ITextDisplayerInter
    */
   constructor(
     contentId: string,
-    messageSender: (msg: IWorkerTextDisplayerInterfaceMessage) => void,
+    messageSender: (msg: ICoreTextDisplayerInterfaceMessage) => void,
   ) {
     this._contentId = contentId;
     this._messageSender = messageSender;
@@ -50,7 +50,7 @@ export default class WorkerTextDisplayerInterface implements ITextDisplayerInter
   public pushTextData(infos: ITextDisplayerData): Promise<IRange[]> {
     return new Promise((resolve, reject) => {
       this._messageSender({
-        type: WorkerMessageType.PushTextData,
+        type: CoreMessageType.PushTextData,
         contentId: this._contentId,
         value: infos,
       });
@@ -64,7 +64,7 @@ export default class WorkerTextDisplayerInterface implements ITextDisplayerInter
   public remove(start: number, end: number): Promise<IRange[]> {
     return new Promise((resolve, reject) => {
       this._messageSender({
-        type: WorkerMessageType.RemoveTextData,
+        type: CoreMessageType.RemoveTextData,
         contentId: this._contentId,
         value: { start, end },
       });
@@ -77,27 +77,30 @@ export default class WorkerTextDisplayerInterface implements ITextDisplayerInter
    */
   public reset(): void {
     this._messageSender({
-      type: WorkerMessageType.ResetTextDisplayer,
+      type: CoreMessageType.ResetTextDisplayer,
       contentId: this._contentId,
       value: null,
     });
-    this._resetCurrentQueue();
+    this._resetCurrentQueue("WorkerTextDisplayerInterface reset");
   }
 
   /**
    * @see ITextDisplayerInterface
    */
-  public stop(): void {
+  public stop(reason: string | undefined): void {
     this._messageSender({
-      type: WorkerMessageType.StopTextDisplayer,
+      type: CoreMessageType.StopTextDisplayer,
       contentId: this._contentId,
       value: null,
     });
-    this._resetCurrentQueue();
+    this._resetCurrentQueue(reason);
   }
 
-  private _resetCurrentQueue(): void {
-    const error = new CancellationError();
+  private _resetCurrentQueue(reason: string | undefined): void {
+    const error = new CancellationError(
+      "WorkerTextDisplayerInterface queue",
+      reason ?? "reset",
+    );
     this._queues.pushTextData.forEach((elt) => {
       elt.reject(error);
     });
@@ -155,8 +158,8 @@ export default class WorkerTextDisplayerInterface implements ITextDisplayerInter
   }
 }
 
-type IWorkerTextDisplayerInterfaceMessage =
-  | IPushTextDataWorkerMessage
-  | IRemoveTextDataWorkerMessage
-  | IStopTextDisplayerWorkerMessage
-  | IResetTextDisplayerWorkerMessage;
+type ICoreTextDisplayerInterfaceMessage =
+  | IPushTextDataCoreMessage
+  | IRemoveTextDataCoreMessage
+  | IStopTextDisplayerCoreMessage
+  | IResetTextDisplayerCoreMessage;

package/src/core/{main/common → entry}/create_content_time_boundaries_observer.ts

@@ -1,13 +1,13 @@
 import type {
   ISegmentSinksStore,
   IStreamOrchestratorPlaybackObservation,
-} from "../../../core/types";
-import log from "../../../log";
-import type { IManifest, IPeriod } from "../../../manifest";
-import type { IMediaSourceInterface } from "../../../mse";
-import type { IReadOnlyPlaybackObserver } from "../../../playback_observer";
-import type { IPlayerError } from "../../../public_types";
-import type { CancellationSignal } from "../../../utils/task_canceller";
+} from "../../core/types";
+import log from "../../log";
+import type { IManifest, IPeriod } from "../../manifest";
+import type { IMediaSourceInterface } from "../../mse";
+import type { IReadOnlyPlaybackObserver } from "../../playback_observer";
+import type { IPlayerError } from "../../public_types";
+import type { CancellationSignal } from "../../utils/task_canceller";
 import ContentTimeBoundariesObserver from "./content_time_boundaries_observer";
 
 export interface IContentTimeBoundariesObserverCallbacks {
@@ -38,16 +38,16 @@ export default function createContentTimeBoundariesObserver(
   callbacks: IContentTimeBoundariesObserverCallbacks,
   cancelSignal: CancellationSignal,
 ): ContentTimeBoundariesObserver {
-  cancelSignal.register(() => {
-    mediaSource.interruptDurationSetting();
+  cancelSignal.register((err) => {
+    mediaSource.interruptDurationSetting(err.reason);
   });
   const contentTimeBoundariesObserver = new ContentTimeBoundariesObserver(
     manifest,
     streamObserver,
     segmentSinksStore.getBufferTypes(),
   );
-  cancelSignal.register(() => {
-    contentTimeBoundariesObserver.dispose();
+  cancelSignal.register((err) => {
+    contentTimeBoundariesObserver.dispose(err.reason);
   });
   contentTimeBoundariesObserver.addEventListener("warning", (err) =>
     callbacks.onWarning(err),

package/src/core/{main/common → entry}/get_buffered_data_per_media_buffer.ts

@@ -1,9 +1,9 @@
-import type { ITextDisplayer } from "../../../main_thread/types";
-import type { IMediaSourceInterface } from "../../../mse";
-import { SourceBufferType } from "../../../mse";
-import type { ITrackType } from "../../../public_types";
-import arrayFind from "../../../utils/array_find";
-import type { IRange } from "../../../utils/ranges";
+import type { ITextDisplayer } from "../../main_thread/types";
+import type { IMediaSourceInterface } from "../../mse";
+import { SourceBufferType } from "../../mse";
+import type { ITrackType } from "../../public_types";
+import arrayFind from "../../utils/array_find";
+import type { IRange } from "../../utils/ranges";
 
 /**
  * Returns a JS object where keys are the type of buffers (e.g. "audio",

package/src/core/{main/common → entry}/get_thumbnail_data.ts

@@ -1,8 +1,8 @@
-import type { IManifest } from "../../../manifest";
-import type { IThumbnailResponse } from "../../../transports";
-import arrayFind from "../../../utils/array_find";
-import TaskCanceller from "../../../utils/task_canceller";
-import type { IThumbnailFetcher } from "../../fetchers";
+import type { IManifest } from "../../manifest";
+import type { IThumbnailResponse } from "../../transports";
+import arrayFind from "../../utils/array_find";
+import TaskCanceller from "../../utils/task_canceller";
+import type { IThumbnailFetcher } from "../fetchers";
 
 /**
  * @param {function} fetchThumbnails
@@ -35,6 +35,6 @@ export default async function getThumbnailData(
   }
   return fetchThumbnails(
     { segment: wantedThumbnail, track: thumbnailTrack, period },
-    new TaskCanceller().signal,
+    new TaskCanceller(undefined).signal,
   );
 }

package/src/core/entry/index.ts

@@ -0,0 +1,5 @@
+import type { IMessageReceiverCallback } from "./core_entry";
+import initializeCoreEntry from "./core_entry";
+export default initializeCoreEntry;
+export type { IMessageReceiverCallback };
+export type { ICorePlugins } from "./content_preparer";

package/src/core/{main/common → entry}/synchronize_sinks_on_observation.ts

@@ -1,5 +1,5 @@
-import type { ICorePlaybackObservation } from "../../../main_thread/init/utils/create_core_playback_observer";
-import type SegmentSinksStore from "../../segment_sinks";
+import type { ICorePlaybackObservation } from "../../main_thread/init/utils/create_core_playback_observer";
+import type SegmentSinksStore from "../segment_sinks";
 
 /**
  * Synchronize SegmentSinks with what has been buffered.

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

@@ -1,10 +1,10 @@
-import log from "../../../log";
-import type { ITrackUpdateChoiceObject } from "../../../multithread_types";
-import type { ITrackType } from "../../../public_types";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import objectAssign from "../../../utils/object_assign";
-import SharedReference from "../../../utils/reference";
-import type { IAdaptationChoice, IRepresentationsChoice } from "../../stream";
+import log from "../../log";
+import type { ITrackUpdateChoiceObject } from "../../main_thread/types";
+import type { ITrackType } from "../../public_types";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import objectAssign from "../../utils/object_assign";
+import SharedReference from "../../utils/reference";
+import type { IAdaptationChoice, IRepresentationsChoice } from "../stream";
 
 export default class TrackChoiceSetter {
   /**

package/src/core/entry/utils.ts

@@ -0,0 +1,11 @@
+import { formatError } from "../../errors";
+import type { ISentError } from "../types";
+
+export function formatErrorForSender(error: unknown): ISentError {
+  const formattedError = formatError(error, {
+    defaultCode: "NONE",
+    defaultReason: "An unknown error stopped content playback.",
+  });
+
+  return formattedError.serialize();
+}

package/src/core/fetchers/manifest/manifest_fetcher.ts

@@ -108,7 +108,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     this._pipelines = pipelines.manifest;
     this._transportName = pipelines.transportName;
     this._settings = settings;
-    this._canceller = new TaskCanceller();
+    this._canceller = new TaskCanceller("ManifestFetcher");
     this._isStarted = false;
     this._isRefreshPending = false;
     this._consecutiveUnsafeMode = 0;
@@ -120,9 +120,12 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
    *
    * Once `dispose` has been called. This `ManifestFetcher` cannot be relied on
    * anymore.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * cancellation. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public dispose() {
-    this._canceller.cancel();
+  public dispose(reason: string | undefined) {
+    this._canceller.cancel(reason ?? "ManifestFetcher dispose");
     this.removeEventListener();
   }
 
@@ -469,7 +472,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
      * be effectively considered.
      * `nextRefreshCanceller` will allow to cancel every other when one is triggered.
      */
-    const nextRefreshCanceller = new TaskCanceller();
+    const nextRefreshCanceller = new TaskCanceller("ManifestFetcher refresh handling");
     nextRefreshCanceller.linkToSignal(this._canceller.signal);
 
     /* Function to manually schedule a Manifest refresh */
@@ -486,7 +489,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
       );
       const timeoutId = setTimeout(
         () => {
-          nextRefreshCanceller.cancel();
+          nextRefreshCanceller.cancel("manifest request timeout");
           this._triggerNextManifestRefresh(manifest, {
             enablePartialRefresh,
             unsafeMode,
@@ -503,7 +506,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     if (manifest.expired !== null) {
       const timeoutId = setTimeout(() => {
         manifest.expired?.then(() => {
-          nextRefreshCanceller.cancel();
+          nextRefreshCanceller.cancel("manifest expiration");
           this._triggerNextManifestRefresh(manifest, {
             enablePartialRefresh: false,
             unsafeMode: unsafeModeEnabled,
@@ -573,7 +576,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
       }
       const timeoutId = setTimeout(
         () => {
-          nextRefreshCanceller.cancel();
+          nextRefreshCanceller.cancel("manifest request timeout");
           this._triggerNextManifestRefresh(manifest, {
             enablePartialRefresh: false,
             unsafeMode: unsafeModeEnabled,
@@ -709,7 +712,7 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
       return;
     }
     this.trigger("error", err);
-    this.dispose();
+    this.dispose("ManifestFetcher fatal err");
   }
 }
 

package/src/core/fetchers/segment/__tests__/task_prioritizer.test.ts

@@ -37,7 +37,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     });
     let wasInterrupted = 0;
     let wasEnded = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
     const prom = prioritizer
       .create(
         task,
@@ -83,7 +83,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     prioritizer
       .create(
@@ -178,7 +178,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     prioritizer
       .create(
@@ -273,7 +273,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     prioritizer
       .create(
@@ -368,7 +368,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     const prom = prioritizer
       .create(
@@ -472,7 +472,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     const prom = prioritizer
       .create(
@@ -582,7 +582,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     const prom = prioritizer
       .create(
@@ -684,7 +684,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was2Ended = false;
     let was3Interrupted = 0;
     let was3Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     const prom = prioritizer
       .create(
@@ -796,7 +796,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was1Ended = false;
     let was2Interrupted = 0;
     let was2Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     const prom = prioritizer
       .create(
@@ -870,7 +870,7 @@ describe("SegmentFetchers TaskPrioritizer", () => {
     let was1Ended = false;
     let was2Interrupted = 0;
     let was2Ended = false;
-    const taskCanceller = new TaskCanceller();
+    const taskCanceller = new TaskCanceller(undefined);
 
     prioritizer
       .create(

package/src/core/fetchers/segment/segment_queue.ts

@@ -129,6 +129,9 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
    * By setting that value to `false`, you anounce to the `SegmentQueue`
    * that it should not wait for an initialization segment before parsing a
    * media segment.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * reset. Used for debugging matters, especially for debug log
+   * inspection.
    * @returns {Object} - `SharedReference` on which the queue of segment for
    * that content can be communicated and updated. See type for more
    * information.
@@ -136,13 +139,14 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
   public resetForContent(
     content: ISegmentQueueContext,
     hasInitSegment: boolean,
+    reason: string | undefined,
   ): SharedReference<ISegmentQueueItem> {
-    this._currentContentInfo?.currentCanceller.cancel();
+    this._currentContentInfo?.currentCanceller.cancel(reason ?? "SegmentQueue reset");
     const downloadQueue = new SharedReference<ISegmentQueueItem>({
       initSegment: null,
       segmentQueue: [],
     });
-    const currentCanceller = new TaskCanceller();
+    const currentCanceller = new TaskCanceller("SegmentQueue " + content.adaptation.type);
     currentCanceller.signal.register(() => {
       downloadQueue.finish();
     });
@@ -165,7 +169,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
           log.debug("SF", "Media segment can be loaded again, restarting queue.", {
             type: content.adaptation.type,
           });
-          this._restartMediaSegmentDownloadingQueue(currentContentInfo);
+          this._restartMediaSegmentDownloadingQueue(currentContentInfo, "interrupt end");
         }
       },
       { clearSignal: currentCanceller.signal },
@@ -195,7 +199,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
           log.debug("SF", "no more media segment to request. Cancelling queue.", {
             type: content.adaptation.type,
           });
-          this._restartMediaSegmentDownloadingQueue(currentContentInfo);
+          this._restartMediaSegmentDownloadingQueue(
+            currentContentInfo,
+            "media segment queue empty",
+          );
           return;
         } else if (currentSegmentRequest === null) {
           // There's no request although there are needed segments: start requests
@@ -203,7 +210,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
             type: content.adaptation.type,
             queueLength: segmentQueue.length,
           });
-          this._restartMediaSegmentDownloadingQueue(currentContentInfo);
+          this._restartMediaSegmentDownloadingQueue(
+            currentContentInfo,
+            "media segment queue start",
+          );
           return;
         } else {
           const nextItem = segmentQueue[0];
@@ -212,7 +222,10 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
             log.debug("SF", "Next media segment changed, cancelling previous", {
               type: content.adaptation.type,
             });
-            this._restartMediaSegmentDownloadingQueue(currentContentInfo);
+            this._restartMediaSegmentDownloadingQueue(
+              currentContentInfo,
+              "next media segment changed",
+            );
             return;
           }
           if (currentSegmentRequest.priority !== nextItem.priority) {
@@ -253,7 +266,11 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
             type: content.adaptation.type,
           });
         }
-        this._restartInitSegmentDownloadingQueue(currentContentInfo, next.initSegment);
+        this._restartInitSegmentDownloadingQueue(
+          currentContentInfo,
+          next.initSegment,
+          "init segment queue empty",
+        );
       },
       { emitCurrentValue: true, clearSignal: currentCanceller.signal },
     );
@@ -265,20 +282,29 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
    * Stop the currently-active `SegmentQueue`.
    *
    * Do nothing if no queue is active.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * stop. Used for debugging matters, especially for debug log
+   * inspection.
    */
-  public stop() {
-    this._currentContentInfo?.currentCanceller.cancel();
+  public stop(reason: string | undefined) {
+    this._currentContentInfo?.currentCanceller.cancel(reason ?? "SegmentQueue stop");
     this._currentContentInfo = null;
   }
 
   /**
    * Internal logic performing media segment requests.
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * restart. Used for debugging matters, especially for debug log
+   * inspection.
    */
   private _restartMediaSegmentDownloadingQueue(
     contentInfo: ISegmentQueueContentInfo,
+    reason: string | undefined,
   ): void {
     if (contentInfo.mediaSegmentRequest !== null) {
-      contentInfo.mediaSegmentRequest.canceller.cancel();
+      contentInfo.mediaSegmentRequest.canceller.cancel(
+        reason ?? "SegmentQueue media restart",
+      );
     }
 
     const { downloadQueue, content, initSegmentInfoRef, currentCanceller } = contentInfo;
@@ -299,7 +325,9 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
         this.trigger("emptyQueue", null);
         return;
       }
-      const canceller = new TaskCanceller();
+      const canceller = new TaskCanceller(
+        "SegmentQueue media segments queue " + content.adaptation.type,
+      );
       const unlinkCanceller =
         currentCanceller === null
           ? noop
@@ -447,7 +475,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
         unlinkCanceller();
         if (!isComplete) {
           isComplete = true;
-          this.stop();
+          this.stop("request err");
           this.trigger("error", error);
         }
       });
@@ -461,21 +489,29 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
    * Internal logic performing initialization segment requests.
    * @param {Object} contentInfo
    * @param {Object} queuedInitSegment
+   * @param {string | undefined} reason - Human-inspectable reason behind the
+   * dispose. Used for debugging matters, especially for debug log
+   * inspection.
    */
   private _restartInitSegmentDownloadingQueue(
     contentInfo: ISegmentQueueContentInfo,
     queuedInitSegment: IQueuedSegment | null,
+    reason: string | undefined,
   ): void {
     const { content, initSegmentInfoRef } = contentInfo;
 
     if (contentInfo.initSegmentRequest !== null) {
-      contentInfo.initSegmentRequest.canceller.cancel();
+      contentInfo.initSegmentRequest.canceller.cancel(
+        reason ?? "SegmentQueue init restart",
+      );
     }
     if (queuedInitSegment === null) {
       return;
     }
 
-    const canceller = new TaskCanceller();
+    const canceller = new TaskCanceller(
+      "SegmentQueue init segment " + content.adaptation.type,
+    );
     const unlinkCanceller =
       contentInfo.currentCanceller === null
         ? noop
@@ -529,7 +565,7 @@ export default class SegmentQueue<T> extends EventEmitter<ISegmentQueueEvent<T>>
       unlinkCanceller();
       if (!isComplete) {
         isComplete = true;
-        this.stop();
+        this.stop("request err");
         this.trigger("error", error);
       }
     });

package/src/core/fetchers/segment/task_prioritizer.ts

@@ -94,7 +94,7 @@ export default class TaskPrioritizer<T> {
           reject(err);
         };
 
-        const interrupter = new TaskCanceller();
+        const interrupter = new TaskCanceller(undefined);
         const unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
         newTask.interrupter = interrupter;
         interrupter.signal.register(() => {
@@ -342,7 +342,7 @@ export default class TaskPrioritizer<T> {
     } else if (this._minPendingPriority === task.priority) {
       this._minPendingPriority = Math.min(...this._pendingTasks.map((t) => t.priority));
     }
-    task.interrupter?.cancel(); // Interrupt at last step because it calls external code
+    task.interrupter?.cancel("TaskPrioritizer interrupt"); // Interrupt at last step because it calls external code
   }
 
   /**

package/src/core/fetchers/thumbnails/thumbnail_fetcher.ts

@@ -143,7 +143,7 @@ export default function createThumbnailFetcher(
      * This is different than `cancellationSignal` which is linked to this call,
      * as several calls might share the same request.
      */
-    const requestCanceller = new TaskCanceller();
+    const requestCanceller = new TaskCanceller("Thumbnail request");
     const fetchPromise = doFetch();
     currRequestInfo = {
       thumbnailContext,
@@ -218,7 +218,7 @@ export default function createThumbnailFetcher(
       }
       pendingRequestsInfo[requestIdx].referenceCount--;
       if (pendingRequestsInfo[requestIdx].referenceCount <= 0) {
-        requestCanceller.cancel();
+        requestCanceller.cancel("Thumbnail request aborted");
         pendingRequestsInfo.splice(requestIdx, 1);
       }
     }

package/src/core/fetchers/utils/schedule_request.ts

@@ -307,7 +307,7 @@ export async function scheduleRequestWithCdns<T>(
       return requestCdn(nextWantedCdn);
     }
 
-    const canceller = new TaskCanceller();
+    const canceller = new TaskCanceller("Request Backoff");
     const unlinkCanceller = canceller.linkToSignal(cancellationSignal);
     return new Promise<T>((res, rej) => {
       cdnPrioritizer?.addEventListener(
@@ -321,7 +321,7 @@ export async function scheduleRequestWithCdns<T>(
             return cleanAndReject(prevRequestError);
           }
           if (updatedPrioritaryCdn !== nextWantedCdn) {
-            canceller.cancel();
+            canceller.cancel("new prioritized CDN");
             waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError).then(
               cleanAndResolve,
               cleanAndReject,

package/src/core/segment_sinks/implementations/audio_video/audio_video_segment_sink.ts

@@ -254,10 +254,10 @@ export default class AudioVideoSegmentSink extends SegmentSink {
   }
 
   /** @see SegmentSink */
-  public dispose(): void {
+  public dispose(reason: string | undefined): void {
     try {
       log.debug("Stream", "Calling `dispose` on the SourceBufferInterface");
-      this._sourceBuffer.dispose();
+      this._sourceBuffer.dispose(reason);
     } catch (e) {
       log.debug(
         "Stream",

package/src/core/segment_sinks/implementations/text/text_segment_sink.ts

@@ -273,7 +273,7 @@ export interface ITextDisplayerInterface {
   /**
    * @see ITextDisplayer
    */
-  stop(): void;
+  stop(reason: string | undefined): void;
 }
 
 /*