rx-player 4.5.0-dev.2026060401 → 4.5.0

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

@@ -46,7 +46,8 @@ function shouldRetry(error: unknown): boolean {
         error.status === 415 || // some CDN seems to use that code when
         // requesting low-latency segments too much
         // in advance
-        error.status === 412
+        error.status === 412 ||
+        error.status === 429 // TODO: Handle optional Retry-After header
       );
     }
     return (
@@ -64,7 +65,8 @@ function shouldRetry(error: unknown): boolean {
         error.xhr.status === 415 || // some CDN seems to use that code when
         // requesting low-latency segments too much
         // in advance
-        error.xhr.status === 412
+        error.xhr.status === 412 ||
+        error.xhr.status === 429
       );
     }
     return false;

package/src/main_thread/__tests__/render_thumbnail.test.ts

@@ -0,0 +1,193 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import TaskCanceller from "../../utils/task_canceller";
+import type { IPublicApiContentInfos } from "../api/public_api";
+import renderThumbnail from "../render_thumbnail";
+
+const { mockFormatError, mockGetPeriodForTime } = vi.hoisted(() => {
+  return {
+    mockFormatError: vi.fn((err: unknown) => err),
+    mockGetPeriodForTime: vi.fn(() => ({
+      id: "period-1",
+      thumbnailTracks: [{ id: "thumb-track-1" }],
+    })),
+  };
+});
+
+vi.mock("../../errors", () => ({
+  formatError: mockFormatError,
+}));
+
+vi.mock("../../manifest", () => ({
+  getPeriodForTime: mockGetPeriodForTime,
+}));
+
+describe("renderThumbnail", () => {
+  let imageInstances: FakeImage[];
+
+  beforeEach(() => {
+    imageInstances = [];
+    vi.stubGlobal(
+      "Image",
+      class FakeImage {
+        public onload: null | (() => void) = null;
+        public onerror: null | (() => void) = null;
+
+        set src(_value: string) {
+          imageInstances.push(this);
+        }
+      },
+    );
+    vi.stubGlobal("URL", {
+      createObjectURL: vi.fn(() => "blob:thumbnail"),
+      revokeObjectURL: vi.fn(),
+    });
+    vi.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue({
+      drawImage: vi.fn(),
+    } as unknown as CanvasRenderingContext2D);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("keeps the newer thumbnail when an aborted older request finishes later", async () => {
+    let resolveFirstFetch!: (value: IThumbnailResponseLike) => void;
+    const contentInfos = createContentInfos(
+      vi
+        .fn()
+        .mockImplementationOnce(
+          () =>
+            new Promise<IThumbnailResponseLike>((resolve) => {
+              resolveFirstFetch = resolve;
+            }),
+        )
+        .mockResolvedValueOnce(makeThumbnailResponse(10, 20)),
+    );
+    const container = document.createElement("div");
+
+    const firstPromise = renderThumbnail(contentInfos, { container, time: 0.5 });
+    const secondPromise = renderThumbnail(contentInfos, { container, time: 12 });
+
+    await Promise.resolve();
+    expect(imageInstances).toHaveLength(1);
+    imageInstances[0].onload?.();
+    await expect(secondPromise).resolves.toBeUndefined();
+    expect(container.childElementCount).toBe(1);
+
+    resolveFirstFetch(makeThumbnailResponse(0, 10));
+    await expect(firstPromise).rejects.toMatchObject({ code: "ABORTED" });
+    expect(container.childElementCount).toBe(1);
+    expect(container.firstElementChild?.className).toBe("__rx-thumbnail__");
+  });
+
+  it("does not remove the newer pending request when an older request aborts", async () => {
+    let resolveFirstFetch!: (value: IThumbnailResponseLike) => void;
+    const contentInfos = createContentInfos(
+      vi
+        .fn()
+        .mockImplementationOnce(
+          () =>
+            new Promise<IThumbnailResponseLike>((resolve) => {
+              resolveFirstFetch = resolve;
+            }),
+        )
+        .mockResolvedValueOnce(makeThumbnailResponse(10, 20)),
+    );
+    const container = document.createElement("div");
+
+    const firstPromise = renderThumbnail(contentInfos, { container, time: 0.5 });
+    const secondPromise = renderThumbnail(contentInfos, { container, time: 12 });
+    const pendingRequest =
+      contentInfos.thumbnailRequestsInfo.pendingRequests.get(container);
+
+    expect(pendingRequest).toBeDefined();
+    await Promise.resolve();
+    expect(imageInstances).toHaveLength(1);
+
+    resolveFirstFetch(makeThumbnailResponse(0, 10));
+    await expect(firstPromise).rejects.toMatchObject({ code: "ABORTED" });
+    expect(contentInfos.thumbnailRequestsInfo.pendingRequests.get(container)).toBe(
+      pendingRequest,
+    );
+
+    imageInstances[0].onload?.();
+    await expect(secondPromise).resolves.toBeUndefined();
+    expect(
+      contentInfos.thumbnailRequestsInfo.pendingRequests.get(container),
+    ).toBeUndefined();
+  });
+});
+
+function createContentInfos(
+  fetchThumbnailDataCallback: (
+    periodId: string,
+    thumbnailTrackId: string,
+    time: number,
+  ) => Promise<IThumbnailResponseLike>,
+): IPublicApiContentInfos {
+  return {
+    contentId: "content-1",
+    originalUrl: undefined,
+    manifest: {} as IPublicApiContentInfos["manifest"],
+    currentPeriod: null,
+    activeAdaptations: null,
+    activeRepresentations: null,
+    defaultAudioTrackSwitchingMode: "reload",
+    fetchThumbnailDataCallback,
+    handledTrackTypes: {
+      audio: true,
+      video: true,
+      text: true,
+    },
+    initializer: {} as IPublicApiContentInfos["initializer"],
+    isDirectFile: false,
+    mediaElementTracksStore: null,
+    onAudioTracksNotPlayable: "continue",
+    onVideoTracksNotPlayable: "continue",
+    playbackObserver: {} as IPublicApiContentInfos["playbackObserver"],
+    segmentSinkMetricsCallback: null,
+    thumbnailRequestsInfo: {
+      pendingRequests: new WeakMap(),
+      lastResponse: null,
+    },
+    tracksStore: null,
+    useWorker: false,
+    currentContentCanceller: new TaskCanceller("content"),
+  };
+}
+
+function makeThumbnailResponse(start: number, end: number): IThumbnailResponseLike {
+  return {
+    data: new Uint8Array([1, 2, 3]).buffer,
+    mimeType: "image/jpeg",
+    thumbnails: [
+      {
+        start,
+        end,
+        width: 320,
+        height: 180,
+        offsetX: 0,
+        offsetY: 0,
+      },
+    ],
+  };
+}
+
+interface IThumbnailResponseLike {
+  data: ArrayBuffer;
+  mimeType: string;
+  thumbnails: Array<{
+    start: number;
+    end: number;
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+  }>;
+}
+
+interface FakeImage {
+  onload: null | (() => void);
+  onerror: null | (() => void);
+}

package/src/main_thread/api/public_api.ts

@@ -439,7 +439,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.2026060401";
+    this.version = /* PLAYER_VERSION */ "4.5.0";
     this.log = log;
     this.state = "STOPPED";
     this.videoElement = videoElement;
@@ -3845,7 +3845,7 @@ class Player extends EventEmitter<IPublicAPIEvent> {
     return true;
   }
 }
-Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026060401";
+Player.version = /* PLAYER_VERSION */ "4.5.0";
 
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {

package/src/main_thread/core_interface/monothread.ts

@@ -5,6 +5,7 @@ import {
 } from "../../core/types";
 import log from "../../log";
 import noop from "../../utils/noop";
+import queueMicrotaskUtil from "../../utils/queue_microtask";
 import type { IMainThreadMessage } from "../types";
 import CoreInterface from "./base";
 
@@ -18,7 +19,7 @@ export class MonoThreadCoreInterface extends CoreInterface {
 
   public sendMessage(msg: IMainThreadMessage) {
     log.debug("M-->C", "Sending message", { name: msg.type });
-    queueMicrotask(() => {
+    queueMicrotaskUtil(() => {
       // NOTE: We don't clone for performance reasons
       this._currentCoreListener({ data: msg });
     });
@@ -32,7 +33,7 @@ export class MonoThreadCoreInterface extends CoreInterface {
       this._currentCoreListener = handler;
     };
     const sendCoreMessage = (msg: ICoreMessage, _transferables?: Transferable[]) => {
-      queueMicrotask(() => {
+      queueMicrotaskUtil(() => {
         if (msg.type !== CoreMessageType.LogMessage) {
           log.debug("M<--C", "Sending message", { name: msg.type });
         }

package/src/main_thread/render_thumbnail.ts

@@ -63,7 +63,9 @@ export default async function renderThumbnail(
   const onFinished = () => {
     unlinkCanceller();
     canceller.cancel("thumbnail request finished");
-    thumbnailRequestsInfo.pendingRequests.delete(container);
+    if (thumbnailRequestsInfo.pendingRequests.get(container) === canceller) {
+      thumbnailRequestsInfo.pendingRequests.delete(container);
+    }
 
     // Let's revoke the URL after a round-trip to the event loop just in case
     // to prevent revoking before the browser use it.
@@ -208,16 +210,17 @@ export default async function renderThumbnail(
       };
     });
   } catch (srcError) {
-    if (options.keepPreviousThumbnailOnError !== true) {
-      clearPreviousThumbnails();
-    }
     if (srcError !== null && srcError === canceller.signal.cancellationError) {
+      onFinished();
       const error = new ThumbnailRenderingError(
         "ABORTED",
         "Thumbnail rendering has been aborted",
       );
       throw error;
     }
+    if (options.keepPreviousThumbnailOnError !== true) {
+      clearPreviousThumbnails();
+    }
     if (srcError instanceof ThumbnailRenderingError) {
       onFinished();
       throw srcError;

package/src/parsers/manifest/dash/wasm-parser/rs/lib.rs

@@ -15,6 +15,7 @@ use processor::MPDProcessor;
 use reader::MPDReader;
 use std::io::BufReader;
 
+#[cfg_attr(target_family = "wasm", link(wasm_import_module = "env"))]
 extern "C" {
     /// JS callback called each time a new known tag is encountered in the MPD.
     ///