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

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

@@ -1,14 +1,17 @@
 import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import {
+  DummyManifest,
+  DummyPeriod,
+  DummyAdaptation,
+  DummyRepresentation,
+  createSegment,
+} from "../../../../manifest/classes/__tests__/mocks";
 import PendingRequestsStore from "../pending_requests_store";
 import type {
   IPendingRequestStoreBegin,
   IPendingRequestStoreProgress,
 } from "../pending_requests_store";
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
 const mocks = vi.hoisted(() => ({
   warn: vi.fn(),
 }));
@@ -24,11 +27,11 @@ describe("PendingRequestsStore", () => {
   let store: PendingRequestsStore;
 
   const createMockContent = (segmentTime: number = 0) => ({
-    manifest: {} as any,
-    period: {} as any,
-    adaptation: {} as any,
-    representation: {} as any,
-    segment: { time: segmentTime } as any,
+    manifest: new DummyManifest(),
+    period: new DummyPeriod(),
+    adaptation: new DummyAdaptation(),
+    representation: new DummyRepresentation(),
+    segment: createSegment({ time: segmentTime }),
   });
 
   const createMockRequest = (
@@ -231,6 +234,7 @@ describe("PendingRequestsStore", () => {
 
       store.add(request);
       // Manually corrupt the internal state to test filtering
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
       (store as any)._currentRequests.corrupted = null;
 
       const requests = store.getRequests();

package/src/core/adaptive/utils/__tests__/representation_score_calculator.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import type { IRepresentation } from "../../../../manifest";
+import { DummyRepresentation } from "../../../../manifest/classes/__tests__/mocks";
 import RepresentationScoreCalculator, {
   ScoreConfidenceLevel,
 } from "../representation_score_calculator";
@@ -40,15 +41,15 @@ describe("RepresentationScoreCalculator", () => {
   beforeEach(() => {
     calculator = new RepresentationScoreCalculator();
 
-    mockRepresentation1 = {
+    mockRepresentation1 = new DummyRepresentation({
       id: "rep1",
       bitrate: 1000000,
-    } as IRepresentation;
+    });
 
-    mockRepresentation2 = {
+    mockRepresentation2 = new DummyRepresentation({
       id: "rep2",
       bitrate: 2000000,
-    } as IRepresentation;
+    });
   });
   afterEach(() => {
     vi.resetAllMocks();
@@ -118,7 +119,7 @@ describe("RepresentationScoreCalculator", () => {
       expect(estimate).toBeUndefined();
     });
 
-    it("should return LOW confidence when less than 5 segments loaded", () => {
+    it("should return LOW confidence when less than 6 segments loaded", () => {
       calculator.addSample(mockRepresentation1, 2, 4);
       calculator.addSample(mockRepresentation1, 2, 4);
 
@@ -127,8 +128,8 @@ describe("RepresentationScoreCalculator", () => {
     });
 
     it("should return LOW confidence when loaded duration is less than 10 seconds", () => {
-      // Add 5 segments but with short duration
-      for (let i = 0; i < 5; i++) {
+      // Add 6 segments but with short duration
+      for (let i = 0; i < 6; i++) {
         calculator.addSample(mockRepresentation1, 1, 1);
       }
 
@@ -136,8 +137,7 @@ describe("RepresentationScoreCalculator", () => {
       expect(estimate?.confidenceLevel).toBe(ScoreConfidenceLevel.LOW);
     });
 
-    it("should return HIGH confidence when > 5 segments and >= 10 seconds loaded", () => {
-      // Add 5 segments with 2 seconds each (total 10 seconds)
+    it("should return HIGH confidence when 6 segments and >= 10 seconds loaded", () => {
       for (let i = 0; i < 6; i++) {
         calculator.addSample(mockRepresentation1, 1, 2);
       }
@@ -146,8 +146,8 @@ describe("RepresentationScoreCalculator", () => {
       expect(estimate?.confidenceLevel).toBe(ScoreConfidenceLevel.HIGH);
     });
 
-    it("should return HIGH confidence when > 5 segments and > 10 seconds loaded", () => {
-      // Add 5 segments with 3 seconds each (total 15 seconds)
+    it("should return HIGH confidence when > 6 segments and > 10 seconds loaded", () => {
+      // Add 6 segments with 3 seconds each (total 15 seconds)
       for (let i = 0; i < 6; i++) {
         calculator.addSample(mockRepresentation1, 1, 3);
       }

package/src/core/adaptive/utils/__tests__/select_optimal_representation.test.ts

@@ -1,48 +1,38 @@
 import { describe, it, expect } from "vitest";
-import type { IRepresentation } from "../../../../manifest";
+import { DummyRepresentation } from "../../../../manifest/classes/__tests__/mocks";
 import selectOptimalRepresentation from "../select_optimal_representation";
 
 describe("ABR - selectOptimalRepresentation", () => {
   const fakeReps = [
-    { bitrate: 100 },
-    { bitrate: 1000 },
-    { bitrate: 10000 },
-    { bitrate: 100000 },
+    new DummyRepresentation({ bitrate: 100 }),
+    new DummyRepresentation({ bitrate: 1000 }),
+    new DummyRepresentation({ bitrate: 10000 }),
+    new DummyRepresentation({ bitrate: 100000 }),
   ];
 
   it("should return the best representation when the optimal bitrate given is Infinity", () => {
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], Infinity)).toBe(
+    expect(selectOptimalRepresentation(fakeReps, Infinity)).toBe(
       fakeReps[fakeReps.length - 1],
     );
   });
 
   it("should return the best representation when both the optimal bitrate and the higher limit given are higher or equal than the highest Representation", () => {
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 100000)).toBe(
+    expect(selectOptimalRepresentation(fakeReps, 100000)).toBe(
       fakeReps[fakeReps.length - 1],
     );
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 900000)).toBe(
+    expect(selectOptimalRepresentation(fakeReps, 900000)).toBe(
       fakeReps[fakeReps.length - 1],
     );
   });
 
   it("should return the worst representation when the optimal bitrate given is 0", () => {
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 0)).toBe(
-      fakeReps[0],
-    );
+    expect(selectOptimalRepresentation(fakeReps, 0)).toBe(fakeReps[0]);
   });
 
   it("should return the worst representation when the optimal bitrate is lower or equal than the lowest Representation", () => {
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 4)).toBe(
-      fakeReps[0],
-    );
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 100)).toBe(
-      fakeReps[0],
-    );
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 0)).toBe(
-      fakeReps[0],
-    );
-    expect(selectOptimalRepresentation(fakeReps as IRepresentation[], 100)).toBe(
-      fakeReps[0],
-    );
+    expect(selectOptimalRepresentation(fakeReps, 4)).toBe(fakeReps[0]);
+    expect(selectOptimalRepresentation(fakeReps, 100)).toBe(fakeReps[0]);
+    expect(selectOptimalRepresentation(fakeReps, 0)).toBe(fakeReps[0]);
+    expect(selectOptimalRepresentation(fakeReps, 100)).toBe(fakeReps[0]);
   });
 });

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

@@ -110,7 +110,7 @@ export default class RepresentationScoreCalculator {
         representation,
         ewma: currentEWMA,
         loadedDuration: segmentDuration,
-        loadedSegments: 0,
+        loadedSegments: 1,
       };
     }
 
@@ -143,7 +143,7 @@ export default class RepresentationScoreCalculator {
     const { ewma, loadedSegments, loadedDuration } = this._currentRepresentationData;
     const estimate = ewma.getEstimate();
     const confidenceLevel =
-      loadedSegments >= 5 && loadedDuration >= 10
+      loadedSegments >= 6 && loadedDuration >= 10
         ? ScoreConfidenceLevel.HIGH
         : ScoreConfidenceLevel.LOW;
 

package/src/core/cmcd/__tests__/cmcd_data_builder.test.ts

@@ -358,9 +358,7 @@ describe("CmcdDataBuilder", () => {
         speed: 1,
         rebuffering: null,
       });
-      builder.startMonitoringPlayback(
-        observer as Parameters<typeof builder.startMonitoringPlayback>[0],
-      );
+      builder.startMonitoringPlayback(observer);
 
       const payload: any = builder.getCmcdDataForSegmentRequest(makeSegmentInfo());
       const requestHeader = payload.value["CMCD-Request"];
@@ -371,9 +369,7 @@ describe("CmcdDataBuilder", () => {
     it("includes pr when playback speed is not 1", () => {
       const builder = new CmcdDataBuilder({ communicationType: "headers" });
       const observer = makePlaybackObserver({ speed: 2, rebuffering: null });
-      builder.startMonitoringPlayback(
-        observer as Parameters<typeof builder.startMonitoringPlayback>[0],
-      );
+      builder.startMonitoringPlayback(observer);
 
       const payload: any = builder.getCmcdDataForManifest("dash");
       const sessionHeader = payload.value["CMCD-Session"];
@@ -383,9 +379,17 @@ describe("CmcdDataBuilder", () => {
     it("does not include pr when speed is 1", () => {
       const builder = new CmcdDataBuilder({ communicationType: "headers" });
       const observer = makePlaybackObserver({ speed: 1, rebuffering: null });
-      builder.startMonitoringPlayback(
-        observer as Parameters<typeof builder.startMonitoringPlayback>[0],
-      );
+      builder.startMonitoringPlayback(observer);
+
+      const payload: any = builder.getCmcdDataForManifest("dash");
+      const sessionHeader = payload.value["CMCD-Session"];
+      expect(sessionHeader).not.toContain("pr=");
+    });
+
+    it("does not include pr when playback speed is negative", () => {
+      const builder = new CmcdDataBuilder({ communicationType: "headers" });
+      const observer = makePlaybackObserver({ speed: -1, rebuffering: null });
+      builder.startMonitoringPlayback(observer);
 
       const payload: any = builder.getCmcdDataForManifest("dash");
       const sessionHeader = payload.value["CMCD-Session"];
@@ -395,23 +399,40 @@ describe("CmcdDataBuilder", () => {
     it("includes su when rebuffering is active", () => {
       const builder = new CmcdDataBuilder({ communicationType: "headers" });
       const observer = makePlaybackObserver({ rebuffering: { timestamp: 0 }, speed: 1 });
-      builder.startMonitoringPlayback(
-        observer as Parameters<typeof builder.startMonitoringPlayback>[0],
-      );
+      builder.startMonitoringPlayback(observer);
 
       const payload: any = builder.getCmcdDataForManifest("dash");
       const requestHeader = payload.value["CMCD-Request"];
       expect(requestHeader).toContain("su");
     });
+
+    it("does not include dl or rtp when playback speed is 0", () => {
+      const builder = new CmcdDataBuilder({ communicationType: "headers" });
+      const observer = makePlaybackObserver({
+        buffered: {
+          video: [{ start: 5, end: 20 }],
+          audio: null,
+          text: null,
+        },
+        speed: 0,
+        rebuffering: null,
+      });
+      builder.startMonitoringPlayback(observer);
+
+      const payload: any = builder.getCmcdDataForSegmentRequest(makeSegmentInfo());
+      const requestHeader = payload.value["CMCD-Request"];
+      const statusHeader = payload.value["CMCD-Status"];
+      expect(requestHeader).toContain("bl=10000");
+      expect(requestHeader).not.toContain("dl=");
+      expect(statusHeader).not.toContain("rtp=");
+    });
   });
 
   describe("stopMonitoringPlayback", () => {
     it("clears the playback observer so subsequent calls work without observation data", () => {
       const builder = new CmcdDataBuilder({ communicationType: "headers" });
       const observer = makePlaybackObserver({ speed: 2, rebuffering: null });
-      builder.startMonitoringPlayback(
-        observer as Parameters<typeof builder.startMonitoringPlayback>[0],
-      );
+      builder.startMonitoringPlayback(observer);
       builder.stopMonitoringPlayback();
 
       const payload: any = builder.getCmcdDataForManifest("dash");
@@ -460,5 +481,29 @@ describe("CmcdDataBuilder", () => {
         }
       }
     });
+
+    it("escapes all backslashes and quotes in header strings", () => {
+      const builder = new CmcdDataBuilder({
+        sessionId: 's\\"id\\tail',
+        contentId: 'c\\"id\\tail',
+        communicationType: "headers",
+      });
+      const payload: any = builder.getCmcdDataForManifest("dash");
+      const sessionHeader = payload.value["CMCD-Session"];
+      expect(sessionHeader).toContain('cid="c\\\\\\"id\\\\tail"');
+      expect(sessionHeader).toContain('sid="s\\\\\\"id\\\\tail"');
+    });
+
+    it("preserves all backslashes and quotes after query decoding", () => {
+      const builder = new CmcdDataBuilder({
+        sessionId: 's\\"id\\tail',
+        contentId: 'c\\"id\\tail',
+        communicationType: "query",
+      });
+      const payload: any = builder.getCmcdDataForManifest("dash");
+      const qs = decodeURIComponent(payload.value[0][1]);
+      expect(qs).toContain('cid="c\\\\\\"id\\\\tail"');
+      expect(qs).toContain('sid="s\\\\\\"id\\\\tail"');
+    });
   });
 });

package/src/core/cmcd/cmcd_data_builder.ts

@@ -186,7 +186,10 @@ export default class CmcdDataBuilder {
 
     const lastObservation = this._playbackObserver?.getReference().getValue();
     props.pr =
-      lastObservation === undefined || lastObservation.speed === 1
+      lastObservation === undefined ||
+      !isFinite(lastObservation.speed) ||
+      lastObservation.speed < 0 ||
+      lastObservation.speed === 1
         ? undefined
         : lastObservation.speed;
     if (lastObservation !== undefined) {
@@ -300,7 +303,10 @@ export default class CmcdDataBuilder {
     }
 
     const precizeDeadlineMs =
-      precizeBufferLengthMs === undefined || lastObservation === undefined
+      precizeBufferLengthMs === undefined ||
+      lastObservation === undefined ||
+      !isFinite(lastObservation.speed) ||
+      lastObservation.speed <= 0
         ? undefined
         : precizeBufferLengthMs / lastObservation.speed;
 
@@ -396,7 +402,7 @@ export default class CmcdDataBuilder {
     ): void => {
       const val = props[prop];
       if (val !== undefined) {
-        const formatted = `"${val.replace("\\", "\\\\").replace('"', '\\"')}"`;
+        const formatted = `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
         const toAdd = `${prop}=${formatted},`;
         addPayload(toAdd, headerName);
       }

package/src/core/entry/README.md

@@ -1,4 +1,4 @@
-# Core Main
+# Core Entry
 
 | Consideration           | Status                                     |
 | ----------------------- | ------------------------------------------ |
@@ -11,7 +11,7 @@ any file may be directly imported.
 
 ## Overview
 
-The Core Main serves as the entry point of the `core` code, which may optionally run in a
+The Core Entry serves as the entry point of the `core` code, which may optionally run in a
 WebWorker.
 
 When in monothreading mode, files declared here may be imported directly to make the link

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

@@ -78,6 +78,16 @@ describe("CoreTextDisplayerInterface", () => {
       cdi.onPushedTrackError(error);
       await expect(promise).rejects.toThrow("push failed");
     });
+
+    it("should resolve even if the sender synchronously responds", async () => {
+      const ranges = [{ start: 0, end: 10 }];
+      messageSender = vi.fn(() => {
+        cdi.onPushedTrackSuccess(ranges);
+      });
+      cdi = new CoreTextDisplayerInterface(CONTENT_ID, messageSender);
+
+      await expect(cdi.pushTextData({} as any)).resolves.toEqual(ranges);
+    });
   });
 
   describe("remove", () => {
@@ -109,6 +119,16 @@ describe("CoreTextDisplayerInterface", () => {
       cdi.onRemoveError(error);
       await expect(promise).rejects.toThrow("remove failed");
     });
+
+    it("should resolve even if the sender synchronously responds", async () => {
+      const ranges = [{ start: 5, end: 20 }];
+      messageSender = vi.fn(() => {
+        cdi.onRemoveSuccess(ranges);
+      });
+      cdi = new CoreTextDisplayerInterface(CONTENT_ID, messageSender);
+
+      await expect(cdi.remove(5, 20)).resolves.toEqual(ranges);
+    });
   });
 
   describe("reset", () => {

package/src/core/entry/content_preparer.ts

@@ -257,11 +257,6 @@ export default class ContentPreparer {
       manifestFetcher.addEventListener(
         "error",
         (err: unknown) => {
-          sendMessage({
-            type: CoreMessageType.Error,
-            contentId,
-            value: formatErrorForSender(err),
-          });
           rej(err);
         },
         contentCanceller.signal,
@@ -336,7 +331,9 @@ export default class ContentPreparer {
       return Promise.reject(new Error("CP: No content anymore"));
     }
     this._currentContent.trackChoiceSetter.reset();
+    this._currentContent.coreTextSender?.stop("ContentPreparer MediaSource reload");
     this._currentMediaSourceCanceller = new TaskCanceller("ContentPreparer MediaSource");
+    this._currentMediaSourceCanceller.linkToSignal(this._contentCanceller.signal);
 
     const [mediaSourceInterface, segmentSinksStore, coreTextSender] =
       createMediaSourceInterfaceAndSegmentSinksStore(

package/src/core/entry/core_entry.ts

@@ -1221,6 +1221,10 @@ function sendThumbnailData(
     msg.value.time,
   ).then(
     (result) => {
+      // Multiple thumbnail requests can share the same fetched payload.
+      // Transfer a copy here so replying to one request does not detach the
+      // ArrayBuffer that still has to be sent to another requester.
+      const data = result.data.slice(0);
       sendMessage(
         {
           type: CoreMessageType.ThumbnailDataResponse,
@@ -1228,10 +1232,10 @@ function sendThumbnailData(
           value: {
             status: "success",
             requestId: msg.value.requestId,
-            data: result,
+            data: { ...result, data },
           },
         },
-        [result.data],
+        [data],
       );
     },
     (err) => {

package/src/core/entry/core_text_displayer_interface.ts

@@ -49,12 +49,12 @@ export default class CoreTextDisplayerInterface implements ITextDisplayerInterfa
    */
   public pushTextData(infos: ITextDisplayerData): Promise<IRange[]> {
     return new Promise((resolve, reject) => {
+      this._queues.pushTextData.push({ resolve, reject });
       this._messageSender({
         type: CoreMessageType.PushTextData,
         contentId: this._contentId,
         value: infos,
       });
-      this._queues.pushTextData.push({ resolve, reject });
     });
   }
 
@@ -63,12 +63,12 @@ export default class CoreTextDisplayerInterface implements ITextDisplayerInterfa
    */
   public remove(start: number, end: number): Promise<IRange[]> {
     return new Promise((resolve, reject) => {
+      this._queues.remove.push({ resolve, reject });
       this._messageSender({
         type: CoreMessageType.RemoveTextData,
         contentId: this._contentId,
         value: { start, end },
       });
-      this._queues.remove.push({ resolve, reject });
     });
   }
 
@@ -153,7 +153,7 @@ export default class CoreTextDisplayerInterface implements ITextDisplayerInterfa
   public onRemoveError(err: Error): void {
     const element = this._queues.remove.shift();
     if (element === undefined) {
-      log.error("text", "pushTextData error for inexistant operation");
+      log.error("text", "remove error for inexistant operation");
       return;
     }
     element.reject(err);

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

@@ -96,7 +96,7 @@ function makeLoadResponse(overrides: Record<string, unknown> = {}) {
   };
 }
 
-describe.skip("ManifestFetcher", () => {
+describe("ManifestFetcher", () => {
   beforeEach(() => {
     mockConfigGetCurrent.mockReturnValue(DEFAULT_CONFIG);
     mockFormatError.mockImplementation((e: unknown) => e);
@@ -488,6 +488,51 @@ describe.skip("ManifestFetcher", () => {
         expect.anything(),
       );
     });
+
+    it("updates the stored manifest URLs", async () => {
+      const manifest = new MockManifest();
+      const fetcher = new ManifestFetcher(
+        ["http://example.com/manifest"],
+        makePipelines(),
+        makeSettings({ initialManifest: manifest }),
+      );
+      fetcher.start();
+      await flushPromises();
+
+      fetcher.updateContentUrls(["http://new.com/manifest"], false);
+
+      expect(fetcher).toHaveProperty("_manifestUrls", ["http://new.com/manifest"]);
+    });
+
+    it("uses the new URL once for the next full refresh even when refreshNow is false", async () => {
+      const manifest = new MockManifest();
+      mockLoadManifest.mockResolvedValue(makeLoadResponse());
+      mockParseManifest.mockReturnValue({ manifest: new MockManifest() });
+
+      const fetcher = new ManifestFetcher(
+        ["http://example.com/manifest"],
+        makePipelines(),
+        makeSettings({ initialManifest: manifest }),
+      );
+      fetcher.start();
+      await flushPromises();
+
+      fetcher.updateContentUrls(["http://new.com/manifest"], false);
+      fetcher.scheduleManualRefresh({
+        enablePartialRefresh: false,
+        delay: 0,
+        canUseUnsafeMode: false,
+      });
+      await sleep(0);
+      await flushPromises();
+
+      expect(mockLoadManifest).toHaveBeenCalledTimes(1);
+      expect(mockLoadManifest).toHaveBeenLastCalledWith(
+        "http://new.com/manifest",
+        expect.anything(),
+        expect.anything(),
+      );
+    });
   });
 
   describe("automatic refresh scheduling", () => {
@@ -694,7 +739,9 @@ describe.skip("ManifestFetcher", () => {
       });
 
       const refreshManifest = new MockManifest();
-      mockLoadManifest.mockResolvedValue(makeLoadResponse());
+      mockLoadManifest.mockResolvedValue(
+        makeLoadResponse({ sendingTime: undefined, receivedTime: undefined }),
+      );
       mockParseManifest.mockReturnValue({ manifest: refreshManifest });
 
       const fetcher = new ManifestFetcher(
@@ -715,7 +762,9 @@ describe.skip("ManifestFetcher", () => {
       await flushPromises();
 
       // Fallback full refresh fires after FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY
-      vi.advanceTimersByTime(DEFAULT_CONFIG.FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY);
+      vi.advanceTimersByTime(
+        DEFAULT_CONFIG.FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY + 1,
+      );
       await vi.waitFor(noop, { timeout: 0 }); // real delay
       await flushPromises();
 

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

@@ -177,6 +177,12 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
    * will be triggered immediately.
    */
   public updateContentUrls(urls: string[] | undefined, refreshNow: boolean): void {
+    // Keep track of the application-provided content URLs.
+    this._manifestUrls = urls;
+    // Indicate that we want to prioritize for the next refresh.
+    // Once a refreshed Manifest has been parsed we still let the Manifest's own
+    // URL list drive subsequent refreshes (e.g. if the transport/parser updated
+    // it on purpose).
     this._prioritizedContentUrl = urls?.[0] ?? undefined;
     if (refreshNow) {
       this.scheduleManualRefresh({
@@ -608,10 +614,16 @@ export default class ManifestFetcher extends EventEmitter<IManifestFetcherEvent>
     let fullRefresh: boolean;
     let refreshURL: string | undefined;
     if (this._prioritizedContentUrl !== null) {
+      // `updateContentUrls` explicitly requested that the next refresh uses that
+      // URL. This override is one-shot on purpose.
       fullRefresh = true;
       refreshURL = this._prioritizedContentUrl;
       this._prioritizedContentUrl = null;
     } else {
+      // Outside of that explicit one-shot override, prefer the URLs currently
+      // exposed by the Manifest itself. This allows parser/content-level URL
+      // updates (e.g. redirects or manifest-provided alternatives) to stay the
+      // source of truth after the refresh completed.
       fullRefresh = !enablePartialRefresh || manifestUpdateUrl === undefined;
       refreshURL = fullRefresh ? manifest.getUrls()[0] : manifestUpdateUrl;
     }

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

@@ -277,6 +277,76 @@ describe("createThumbnailFetcher", () => {
       // p1 should reject
       await expect(p1).rejects.toBeInstanceOf(CancellationError);
     });
+
+    it("does not pass the first caller's cancellation signal to the shared loader", async () => {
+      let loadSignal: CancellationSignal | undefined;
+      let resolveRequest!: (v: IRequestedData<ArrayBuffer>) => void;
+      const pipeline = makePipeline(
+        (
+          _cdnMetadata,
+          _segment,
+          _options,
+          cancellationSignal: CancellationSignal,
+        ): Promise<IRequestedData<ArrayBuffer>> => {
+          loadSignal = cancellationSignal;
+          return new Promise((res) => {
+            resolveRequest = res;
+          });
+        },
+      );
+
+      mockScheduleRequestWithCdns.mockImplementation(
+        (
+          cdns: ICdnMetadata[] | null,
+          _cdnPrioritizer: CdnPrioritizer | null,
+          performRequest: (
+            cdn: ICdnMetadata | null,
+            cancellationSignal: CancellationSignal,
+          ) => Promise<IRequestedData<ArrayBuffer>>,
+          _options: IBackoffSettings,
+          globalCancellationSignal: CancellationSignal,
+        ): Promise<IRequestedData<ArrayBuffer>> => {
+          return performRequest(cdns?.[0] ?? null, globalCancellationSignal);
+        },
+      );
+
+      const fetcher = createThumbnailFetcher(pipeline, null);
+      const canceller1 = new TaskCanceller("test1");
+      const canceller2 = new TaskCanceller("test2");
+      const ctx = makeThumbnailContext();
+
+      const p1 = fetcher(ctx, canceller1.signal);
+      const p2 = fetcher(ctx, canceller2.signal);
+
+      expect(mockScheduleRequestWithCdns).toHaveBeenCalledTimes(1);
+      expect(loadSignal).not.toBe(canceller1.signal);
+      expect(loadSignal).not.toBe(canceller2.signal);
+
+      canceller1.cancel("only first cancels");
+      expect(loadSignal?.isCancelled()).toBe(false);
+
+      resolveRequest({
+        responseData: new Uint8Array([4, 7, 7]).buffer,
+        size: 3,
+        requestDuration: 500,
+      });
+
+      await expect(p1).rejects.toBeInstanceOf(CancellationError);
+      await expect(p2).resolves.toEqual({
+        data: new Uint8Array([4, 7, 7]).buffer,
+        mimeType: "image/png",
+        thumbnails: [
+          {
+            height: 720,
+            width: 1280,
+            offsetX: 0,
+            offsetY: 0,
+            start: 0,
+            end: Number.MAX_SAFE_INTEGER,
+          },
+        ],
+      });
+    });
   });
 
   describe("error handling", () => {