rx-player 4.5.0-dev.2026041501 → 4.5.0-dev.2026060400

package/src/compat/__tests__/is_codec_supported.test.ts

@@ -1,10 +1,16 @@
 import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
 import isCodecSupported from "../is_codec_supported";
 
-const mocks = vi.hoisted(() => {
+type IMockedMediaSource =
+  | {
+      isTypeSupported?: ((codec: string) => boolean) | undefined;
+    }
+  | undefined;
+
+const mocks: { default: { MediaSource_: IMockedMediaSource } } = vi.hoisted(() => {
   return {
     default: {
-      MediaSource_: {} as unknown,
+      MediaSource_: {},
     },
   };
 });

package/src/compat/eme/eme-api-implementation.ts

@@ -315,7 +315,7 @@ function defaultSetMediaKeys(
   try {
     let ret: unknown;
     if (typeof elt.setMediaKeys === "function") {
-      // eslint-disable-next-line @typescript-eslint/no-restricted-types
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion, @typescript-eslint/no-restricted-types
       ret = elt.setMediaKeys(mediaKeys as MediaKeys);
     }
 

package/src/compat/patch_webkit_source_buffer.ts

@@ -25,13 +25,12 @@ interface IWebKitSourceBufferConstructor {
   prototype: IWebKitSourceBuffer;
 }
 
-interface IWebKitSourceBuffer
-  extends EventEmitter<{
-    updatestart: Event;
-    update: Event;
-    updateend: Event;
-    error: Event | Error;
-  }> {
+interface IWebKitSourceBuffer extends EventEmitter<{
+  updatestart: Event;
+  update: Event;
+  updateend: Event;
+  error: Event | Error;
+}> {
   _emitUpdate?: (eventName: "error" | "update", val: unknown) => void;
   appendBuffer?: (data: BufferSource) => void;
   updating: boolean;

package/src/core/adaptive/utils/pending_requests_store.ts

@@ -54,6 +54,7 @@ export default class PendingRequestsStore {
   public addProgress(progress: IPendingRequestStoreProgress): void {
     const request = this._currentRequests[progress.id];
     if (isNullOrUndefined(request)) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
       if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
         throw new Error("ABR: progress for a request not added");
       }
@@ -69,6 +70,7 @@ export default class PendingRequestsStore {
    */
   public remove(id: string): void {
     if (isNullOrUndefined(this._currentRequests[id])) {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
       if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
         throw new Error("ABR: can't remove unknown request");
       }

package/src/core/entry/__tests__/content_time_boundaries_observer.test.ts

@@ -143,6 +143,25 @@ describe("ContentTimeBoundariesObserver", () => {
       expect(mockTrigger).toHaveBeenCalledWith("warning", expect.any(Object));
       const warning = mockTrigger.mock.calls[0][1];
       expect(warning.code).toBe("MEDIA_TIME_BEFORE_MANIFEST");
+      expect(warning.timeInfo).toEqual({
+        position: 5,
+        minPosition: 10,
+        maxPosition: 100,
+      });
+    });
+
+    it("should not trigger warning when position is within epsilon of manifest minimum", async () => {
+      mockGetMinimumSafePosition.mockReturnValue(10);
+      const manifest = createMockManifest();
+      const playbackObserver = createMockPlaybackObserver();
+
+      new ContentTimeBoundariesObserver(manifest, playbackObserver, ["audio"]);
+      await sleep(0);
+
+      const positionCallback = mockPlaybackObserverListen.mock.calls[0][0];
+      positionCallback({ position: { getWanted: () => 9.9995 } });
+
+      expect(mockTrigger).not.toHaveBeenCalled();
     });
 
     it("should trigger warning when position is after manifest maximum", async () => {

package/src/core/entry/content_preparer.ts

@@ -500,6 +500,7 @@ function createMediaSourceInterfaceAndSegmentSinksStore(
         value: sentMediaSourceLink,
         mediaSourceId: mediaSourceInterface.id,
       },
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
       [handle.value as unknown as Transferable],
     );
   } else {

package/src/core/entry/content_time_boundaries_observer.ts

@@ -47,6 +47,12 @@ import TaskCanceller from "../../utils/task_canceller";
  *     Manifest range.
  * @class ContentTimeBoundariesObserver
  */
+
+// `HTMLMediaElement.currentTime` can be off by a very small amount from the
+// Manifest-derived boundaries. We keep an epsilon so those rounding
+// differences do not trigger spurious boundary warnings.
+const EPSILON = 1e-3;
+
 export default class ContentTimeBoundariesObserver extends EventEmitter<IContentTimeBoundariesObserverEvent> {
   /** Allows to interrupt everything the `ContentTimeBoundariesObserver` is doing. */
   private _canceller: TaskCanceller;
@@ -113,20 +119,38 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
       playbackObserver.listen(
         ({ position }) => {
           const wantedPosition = position.getWanted();
-          if (wantedPosition < manifest.getMinimumSafePosition()) {
+          const minimumPosition = manifest.getMinimumSafePosition();
+          const maximumPosition = maximumPositionCalculator.getMaximumAvailablePosition();
+
+          // Only report "before manifest" when the position is meaningfully
+          // behind the minimum, not when `<video>.currentTime` and the
+          // Manifest disagree by a tiny floating-point delta.
+          if (wantedPosition < minimumPosition - EPSILON) {
             const warning = new MediaError(
               "MEDIA_TIME_BEFORE_MANIFEST",
               "The current position is behind the " +
                 "earliest time announced in the Manifest.",
+              {
+                timeInfo: {
+                  position: wantedPosition,
+                  minPosition: minimumPosition,
+                  maxPosition: maximumPosition,
+                },
+              },
             );
             this.trigger("warning", warning);
-          } else if (
-            wantedPosition > maximumPositionCalculator.getMaximumAvailablePosition()
-          ) {
+          } else if (wantedPosition > maximumPosition + EPSILON) {
             const warning = new MediaError(
               "MEDIA_TIME_AFTER_MANIFEST",
               "The current position is after the latest " +
                 "time announced in the Manifest.",
+              {
+                timeInfo: {
+                  position: wantedPosition,
+                  minPosition: minimumPosition,
+                  maxPosition: maximumPosition,
+                },
+              },
             );
             this.trigger("warning", warning);
           }

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

@@ -349,6 +349,7 @@ export default class AudioVideoSegmentSink extends SegmentSink {
  */
 function assertDataIsBufferSource(data: unknown): asserts data is BufferSource {
   if (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     (__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.PRODUCTION as number)
   ) {
     return;

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

@@ -191,6 +191,7 @@ function assertChunkIsTextTrackSegmentData(
   chunk: unknown,
 ): asserts chunk is ITextTracksBufferSegmentData {
   if (
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     (__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.PRODUCTION as number)
   ) {
     return;
@@ -285,6 +286,7 @@ export interface ITextDisplayerInterface {
  * It doesn't correspond at all to real code that will be called. This is just
  * a hack to tell TypeScript to perform that check.
  */
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
   // @ts-expect-error: unused function for type checking
   function _checkType(input: ITextTrackSegmentData): void {

package/src/core/segment_sinks/implementations/utils/manual_time_ranges.ts

@@ -36,6 +36,7 @@ export default class ManualTimeRanges implements TimeRanges {
   }
 
   insert(start: number, end: number): void {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
       assert(start >= 0, "invalid start time");
       assert(end - start > 0, "invalid end time");
@@ -45,6 +46,7 @@ export default class ManualTimeRanges implements TimeRanges {
   }
 
   remove(start: number, end: number): void {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     if ((__ENVIRONMENT__.CURRENT_ENV as number) === (__ENVIRONMENT__.DEV as number)) {
       assert(start >= 0, "invalid start time");
       assert(end - start > 0, "invalid end time");

package/src/core/stream/adaptation/types.ts

@@ -15,8 +15,10 @@ import type {
 } from "../representation";
 
 /** Callbacks called by the `AdaptationStream` on various events. */
-export interface IAdaptationStreamCallbacks
-  extends Omit<IRepresentationStreamCallbacks, "terminating" | "addedSegment"> {
+export interface IAdaptationStreamCallbacks extends Omit<
+  IRepresentationStreamCallbacks,
+  "terminating" | "addedSegment"
+> {
   /** Called as new bitrate estimates are done. */
   bitrateEstimateChange(payload: IBitrateEstimateChangePayload): void;
   /**
@@ -111,8 +113,7 @@ export interface INeedsBufferFlushPayload {
 }
 
 /** Regular playback information needed by the AdaptationStream. */
-export interface IAdaptationStreamPlaybackObservation
-  extends IRepresentationStreamPlaybackObservation {
+export interface IAdaptationStreamPlaybackObservation extends IRepresentationStreamPlaybackObservation {
   /**
    * For the current SegmentSink, difference in seconds between the next position
    * where no segment data is available and the current position.

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -710,8 +710,10 @@ export type IStreamOrchestratorOptions = IPeriodStreamOptions & {
 };
 
 /** Callbacks called by the `StreamOrchestrator` on various events. */
-export interface IStreamOrchestratorCallbacks
-  extends Omit<IPeriodStreamCallbacks, "waitingMediaSourceReload"> {
+export interface IStreamOrchestratorCallbacks extends Omit<
+  IPeriodStreamCallbacks,
+  "waitingMediaSourceReload"
+> {
   /**
    * Called when a `PeriodStream` has been removed.
    * This event can be used for clean-up purposes. For example, you are free to

package/src/errors/__tests__/media_error.test.ts

@@ -1,10 +1,13 @@
 import { describe, it, expect } from "vitest";
-import MediaError from "../media_error";
+import type { ISerializedMediaError } from "../media_error";
+import MediaError, { deserializeMediaError } from "../media_error";
 
 describe("errors - MediaError", () => {
   it("should format a MediaError", () => {
     const reason = "test";
-    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", reason);
+    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", reason, {
+      timeInfo: { position: 5, minPosition: 10, maxPosition: 100 },
+    });
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
     expect(mediaError.type).toBe("MEDIA_ERROR");
@@ -15,7 +18,9 @@ describe("errors - MediaError", () => {
 
   it("should be able to set it as fatal", () => {
     const reason = "test";
-    const mediaError = new MediaError("MEDIA_TIME_AFTER_MANIFEST", reason);
+    const mediaError = new MediaError("MEDIA_TIME_AFTER_MANIFEST", reason, {
+      timeInfo: { position: 5, minPosition: 10, maxPosition: 100 },
+    });
     mediaError.fatal = true;
     expect(mediaError).toBeInstanceOf(Error);
     expect(mediaError.name).toBe("MediaError");
@@ -36,4 +41,102 @@ describe("errors - MediaError", () => {
     expect(mediaError.fatal).toBe(true);
     expect(mediaError.message).toBe("MEDIA_ERR_NETWORK: test");
   });
+
+  it("should expose and serialize custom position metadata", () => {
+    const mediaError = new MediaError("MEDIA_TIME_BEFORE_MANIFEST", "test", {
+      timeInfo: {
+        position: 3,
+        minPosition: 10,
+        maxPosition: 20,
+      },
+    });
+
+    expect(mediaError.timeInfo).toEqual({
+      position: 3,
+      minPosition: 10,
+      maxPosition: 20,
+    });
+    expect(mediaError.serialize()).toEqual({
+      isSerializedError: true,
+      name: "MediaError",
+      code: "MEDIA_TIME_BEFORE_MANIFEST",
+      reason: "test",
+      tracks: undefined,
+      timeInfo: {
+        position: 3,
+        minPosition: 10,
+        maxPosition: 20,
+      },
+    });
+  });
+
+  it("should deserialize a serialized MediaError with timeInfo", () => {
+    const serializedError: ISerializedMediaError = {
+      isSerializedError: true,
+      name: "MediaError",
+      code: "MEDIA_TIME_BEFORE_MANIFEST",
+      reason: "test",
+      tracks: undefined,
+      timeInfo: {
+        position: 3,
+        minPosition: 10,
+        maxPosition: 20,
+      },
+    };
+
+    const mediaError = deserializeMediaError(serializedError);
+
+    expect(mediaError).toBeInstanceOf(MediaError);
+    expect(mediaError.code).toBe("MEDIA_TIME_BEFORE_MANIFEST");
+    expect(mediaError.message).toBe("MEDIA_TIME_BEFORE_MANIFEST: test");
+    expect(mediaError.timeInfo).toEqual(serializedError.timeInfo);
+  });
+
+  it("should deserialize a serialized MediaError with tracks", () => {
+    const serializedError: ISerializedMediaError = {
+      isSerializedError: true,
+      name: "MediaError",
+      code: "BUFFER_APPEND_ERROR",
+      reason: "test",
+      tracks: [
+        {
+          type: "audio",
+          track: {
+            id: "fra1",
+            audioDescription: false,
+            language: "fra",
+            normalized: "fra",
+            representations: [],
+          },
+        },
+      ],
+      timeInfo: undefined,
+    };
+
+    const mediaError = deserializeMediaError(serializedError);
+
+    expect(mediaError).toBeInstanceOf(MediaError);
+    expect(mediaError.code).toBe("BUFFER_APPEND_ERROR");
+    expect(mediaError.message).toBe("BUFFER_APPEND_ERROR: test");
+    expect(mediaError.tracksInfo).toEqual(serializedError.tracks);
+  });
+
+  it("should deserialize a serialized MediaError without metadata", () => {
+    const serializedError = {
+      isSerializedError: true as const,
+      name: "MediaError" as const,
+      code: "MEDIA_ERR_NETWORK" as const,
+      reason: "test",
+      tracks: undefined,
+      timeInfo: undefined,
+    };
+
+    const mediaError = deserializeMediaError(serializedError);
+
+    expect(mediaError).toBeInstanceOf(MediaError);
+    expect(mediaError.code).toBe("MEDIA_ERR_NETWORK");
+    expect(mediaError.message).toBe("MEDIA_ERR_NETWORK: test");
+    expect(mediaError.timeInfo).toBeUndefined();
+    expect(mediaError.tracksInfo).toBeUndefined();
+  });
 });

package/src/errors/index.ts

@@ -22,7 +22,7 @@ import { ErrorCodes, ErrorTypes, NetworkErrorTypes } from "./error_codes";
 import formatError from "./format_error";
 import isKnownError from "./is_known_error";
 import type { ISerializedMediaError } from "./media_error";
-import MediaError from "./media_error";
+import MediaError, { deserializeMediaError } from "./media_error";
 import type { ISerializedNetworkError } from "./network_error";
 import NetworkError from "./network_error";
 import type { ISerializedOtherError } from "./other_error";
@@ -46,6 +46,7 @@ export {
   ErrorTypes,
   formatError,
   MediaError,
+  deserializeMediaError,
   NetworkError,
   OtherError,
   NetworkErrorTypes,

package/src/errors/media_error.ts

@@ -15,16 +15,27 @@
  */
 
 import type { ITaggedTrack } from "../manifest";
+import assert from "../utils/assert";
 import type { IMediaErrorCode } from "./error_codes";
 import { ErrorTypes } from "./error_codes";
 import errorMessage from "./error_message";
 
-type ICodeWithAdaptationType =
+export type ICodeWithAdaptationType =
   | "BUFFER_APPEND_ERROR"
   | "BUFFER_FULL_ERROR"
   | "NO_PLAYABLE_REPRESENTATION"
   | "MANIFEST_INCOMPATIBLE_CODECS_ERROR";
 
+export type ICodeWithManifestPositionError =
+  | "MEDIA_TIME_BEFORE_MANIFEST"
+  | "MEDIA_TIME_AFTER_MANIFEST";
+
+interface ITimeInfo {
+  position: number;
+  minPosition: number;
+  maxPosition: number;
+}
+
 /**
  * Error linked to the media Playback.
  *
@@ -36,6 +47,7 @@ export default class MediaError extends Error {
   public readonly type: "MEDIA_ERROR";
   public readonly code: IMediaErrorCode;
   public readonly tracksInfo: ITaggedTrack[] | undefined;
+  public readonly timeInfo: ITimeInfo | undefined;
   public fatal: boolean;
   private _originalMessage: string;
 
@@ -52,13 +64,18 @@ export default class MediaError extends Error {
     },
   );
   constructor(
-    code: Exclude<IMediaErrorCode, ICodeWithAdaptationType>,
+    code: ICodeWithManifestPositionError,
+    reason: string,
+    context: {
+      timeInfo: ITimeInfo;
+    },
+  );
+  constructor(
+    code: Exclude<
+      IMediaErrorCode,
+      ICodeWithAdaptationType | ICodeWithManifestPositionError
+    >,
     reason: string,
-    context?:
-      | {
-          tracks?: undefined;
-        }
-      | undefined,
   );
   constructor(
     code: IMediaErrorCode,
@@ -66,6 +83,7 @@ export default class MediaError extends Error {
     context?:
       | {
           tracks?: ITaggedTrack[] | undefined;
+          timeInfo?: ITimeInfo;
         }
       | undefined,
   ) {
@@ -82,6 +100,9 @@ export default class MediaError extends Error {
     if (context?.tracks !== undefined && context?.tracks.length > 0) {
       this.tracksInfo = context.tracks;
     }
+    if (context?.timeInfo !== undefined) {
+      this.timeInfo = context.timeInfo;
+    }
   }
 
   /**
@@ -97,10 +118,44 @@ export default class MediaError extends Error {
       code: this.code,
       reason: this._originalMessage,
       tracks: this.tracksInfo,
+      timeInfo: this.timeInfo,
     };
   }
 }
 
+/**
+ * Re-create a `MediaError` from a serialized representation.
+ * @param {Object} serializedMediaError
+ * @returns {MediaError}
+ */
+export function deserializeMediaError(
+  serializedMediaError: ISerializedMediaError,
+): MediaError {
+  if (
+    serializedMediaError.code === "MEDIA_TIME_BEFORE_MANIFEST" ||
+    serializedMediaError.code === "MEDIA_TIME_AFTER_MANIFEST"
+  ) {
+    assert(
+      serializedMediaError.timeInfo !== undefined,
+      `The MediaError with code ${serializedMediaError.code} does not provide "timeinfo"`,
+    );
+    return new MediaError(serializedMediaError.code, serializedMediaError.reason, {
+      timeInfo: serializedMediaError.timeInfo,
+    });
+  }
+  if (
+    serializedMediaError.code === "BUFFER_APPEND_ERROR" ||
+    serializedMediaError.code === "BUFFER_FULL_ERROR" ||
+    serializedMediaError.code === "NO_PLAYABLE_REPRESENTATION" ||
+    serializedMediaError.code === "MANIFEST_INCOMPATIBLE_CODECS_ERROR"
+  ) {
+    return new MediaError(serializedMediaError.code, serializedMediaError.reason, {
+      tracks: serializedMediaError.tracks,
+    });
+  }
+  return new MediaError(serializedMediaError.code, serializedMediaError.reason);
+}
+
 /** Serializable object which allows to create a `MediaError` later. */
 export interface ISerializedMediaError {
   isSerializedError: true;
@@ -108,4 +163,5 @@ export interface ISerializedMediaError {
   code: IMediaErrorCode;
   reason: string;
   tracks: ITaggedTrack[] | undefined;
+  timeInfo?: ITimeInfo | undefined;
 }

package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/HDCPPolicy.test.ts

@@ -1,10 +1,16 @@
 import { describe, afterEach, it, expect, vi, beforeEach } from "vitest";
 import probeHDCPPolicy from "../../probers/HDCPPolicy";
 
-const compatEmeMock = vi.hoisted(() => {
+type IRequestMediaKeySystemAccess =
+  | ((...args: unknown[]) => Promise<unknown>)
+  | undefined;
+
+const compatEmeMock: {
+  default: { requestMediaKeySystemAccess: IRequestMediaKeySystemAccess };
+} = vi.hoisted(() => {
   return {
     default: {
-      requestMediaKeySystemAccess: undefined as unknown,
+      requestMediaKeySystemAccess: undefined,
     },
   };
 });

package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/defaultCodecsFinder.test.ts

@@ -4,10 +4,14 @@ import {
   findDefaultAudioCodec,
 } from "../../probers/defaultCodecsFinder";
 
-const mocks = vi.hoisted(() => {
+type IMockedMediaSource = {
+  isTypeSupported?: ((codec: string) => boolean) | undefined;
+} | null;
+
+const mocks: { default: { MediaSource_: IMockedMediaSource } } = vi.hoisted(() => {
   return {
     default: {
-      MediaSource_: {} as unknown,
+      MediaSource_: {},
     },
   };
 });

package/src/experimental/tools/mediaCapabilitiesProber/probers/__tests__/mediaContentType.test.ts

@@ -2,10 +2,14 @@ import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
 import probeMediaContentType from "../../probers/mediaContentType";
 import type { IMediaConfiguration } from "../../types";
 
-const mocks = vi.hoisted(() => {
+type IMockedMediaSource = {
+  isTypeSupported?: ((codec: string) => boolean) | boolean | undefined;
+} | null;
+
+const mocks: { default: { MediaSource_: IMockedMediaSource } } = vi.hoisted(() => {
   return {
     default: {
-      MediaSource_: {} as unknown,
+      MediaSource_: {},
     },
   };
 });

package/src/experimental/tools/mediaCapabilitiesProber/utils.ts

@@ -83,6 +83,7 @@ export function filterConfigurationWithCapabilities(
           }
         )[capability] !== undefined
       ) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         (probedConfig as { [id: string]: string | IMediaConfiguration })[capability] = (
           configuration as { [id: string]: string | IMediaConfiguration }
         )[capability];
@@ -105,6 +106,7 @@ export function filterConfigurationWithCapabilities(
           Object.keys((configuration as { [id: string]: IMediaConfiguration })[key])
             .length === 0)
       ) {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         (probedConfig as { [id: string]: IMediaConfiguration })[key] = subProbedConfig;
       }
     }

package/src/importable_worker.ts

@@ -63,6 +63,7 @@ export default class RxPlayerWorker<
     globalScope.addEventListener("message", (evt: MessageEvent<IMainThreadMessage>) => {
       if (evt.data.type === MainThreadMessageType.AppDefined) {
         const { name, payload } = evt.data.value;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         const listeners = this._messageListeners.get(name as keyof TReceivingEventRecord);
         if (listeners === undefined) {
           return;