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

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

@@ -143,6 +143,11 @@ 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 trigger warning when position is after manifest maximum", async () => {

package/src/core/entry/content_time_boundaries_observer.ts

@@ -113,20 +113,34 @@ 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();
+          if (wantedPosition < minimumPosition) {
             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) {
             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/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/main_thread/api/public_api.ts

@@ -437,7 +437,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
     videoElement.preload = "auto";
 
-    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026041501";
+    this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026043000";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3837,7 +3837,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return true;
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026041501";
+Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026043000";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/init/media_source_content_initializer.ts

@@ -15,9 +15,10 @@ import type {
   ISentLogValue,
 } from "../../core/types";
 import { CoreMessageType } from "../../core/types";
+import type { MediaError } from "../../errors";
 import {
+  deserializeMediaError,
   EncryptedMediaError,
-  MediaError,
   NetworkError,
   OtherError,
   SourceBufferError,
@@ -2292,10 +2293,7 @@ function formatCoreError(sentError: ISentError): IPlayerError {
         ),
       );
     case "MediaError":
-      // eslint-disable-next-line
-      return new MediaError(sentError.code as any, sentError.reason, {
-        tracks: sentError.tracks,
-      });
+      return deserializeMediaError(sentError);
     case "EncryptedMediaError":
       // We assume that everything have already been checked Worker-side here
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument