@amazon/vinyl 3.2.0 → 3.2.2

package/dist/test/integ.js

@@ -9953,6 +9953,7 @@ ${this.lastInitStack}` : "";
 
   // src/ad/AdControllerImpl.ts
   var AD_START_TOLERANCE = 0.05;
+  var PLAYOUT_LIMIT_TOLERANCE = 1;
   var defaultAdControllerImplOptions = {
     adLoadTimeout: 15,
     preloadAheadTime: 10
@@ -10443,23 +10444,29 @@ ${this.lastInitStack}` : "";
       });
     }
     /**
-     * Ads breaks can have a playout limit that may cut off ad playback.
-     * End the ad if that limit is reached.
+     * Enforces the break-level playout limit (X-PLAYOUT-LIMIT): a budget shared
+     * across all of the break's ads. When cumulative playout reaches it, the
+     * whole break ends, dropping any ads that have not started.
+     *
+     * This is deliberately NOT a per-ad cap. Each ad asset is its own source and
+     * ends on its media `ended` (see the 'ended' handler), which is what advances
+     * a multi-ad break. Ending an ad at its declared per-ad DURATION instead would
+     * truncate the real asset whenever a packager under-declares it — e.g. rounds
+     * a 6.732s asset down to a whole-second 6 — cutting off the fractional tail.
      */
     enforcePlayoutLimits(adState) {
+      if (!adState.started) return;
+      const { parentBreak } = adState;
+      const limit = parentBreak.adBreak.playoutLimit;
+      if (limit == null) return;
       const pC = this.deps.playbackController;
-      const { ad, parentBreak } = adState;
-      if (adState.started) {
-        const elapsed = Math.max(0, pC.currentTime - adState.timeStart);
-        const adBreak = parentBreak.adBreak;
-        const limit = adBreak.playoutLimit;
-        if (limit != null && parentBreak.playoutElapsed + elapsed >= limit) {
-          parentBreak.clear();
-          this.endAd(adState);
-        } else if (ad.duration != null && elapsed >= ad.duration) {
-          this.endAd(adState);
-        }
+      const elapsed = Math.max(0, pC.currentTime - adState.timeStart);
+      if (parentBreak.playoutElapsed + elapsed < limit) return;
+      if (isFinite(pC.duration) && pC.duration > 0 && pC.duration - pC.currentTime <= PLAYOUT_LIMIT_TOLERANCE) {
+        return;
       }
+      parentBreak.clear();
+      this.endAd(adState);
     }
     setPendingBreaks(newPending) {
       this.pendingAdBreaks = newPending.filter(
@@ -14000,6 +14007,7 @@ ${this.lastInitStack}` : "";
   // src/drm/DrmControllerImpl.ts
   var LICENSE_TIMEOUT = 90;
   var LICENSE_TIMEOUT_MESSAGE = "License provider timed out after {time}s";
+  var EXCESSIVE_SESSION_COUNT = 20;
   var DrmControllerImpl = class extends EventHostImpl {
     constructor(deps, options) {
       super();
@@ -14216,6 +14224,13 @@ ${this.lastInitStack}` : "";
         trackUri
       });
       this.sessions.push(newSession);
+      logVerbose(this, `total sessions: ${this.sessions.length}`);
+      if (this.sessions.length === EXCESSIVE_SESSION_COUNT + 1) {
+        logWarn(
+          this,
+          `${this.sessions.length} open key sessions exceeds ${EXCESSIVE_SESSION_COUNT}; sessions may be leaking (not closing on track deactivation)`
+        );
+      }
       this.dispatch("sessionCreate", {
         initDataType: newSession.initDataType,
         mimeType: newSession.mimeType
@@ -15214,7 +15229,7 @@ ${this.lastInitStack}` : "";
   // src/global/environment.ts
   var vinylVersion = parseVersion(
     /* istanbul ignore next */
-    "3.2.0"
+    "3.2.2"
   );
 
   // src/global/globalRef.ts
@@ -15371,6 +15386,7 @@ ${this.lastInitStack}` : "";
   ];
 
   // src/playback/createStallMonitor.ts
+  var PROGRESS_EPSILON = 1e-6;
   function createStallMonitor(controller, callbacks, options = {}) {
     var _a3, _b;
     const stallThresholdMs = ((_a3 = options.stallThreshold) != null ? _a3 : 1) * 1e3;
@@ -15379,6 +15395,7 @@ ${this.lastInitStack}` : "";
     let lastProgressAt = Date.now();
     let inStall = false;
     let pollId = null;
+    const { add, dispose } = createDisposer();
     const endStall = (reason) => {
       if (!inStall) return;
       inStall = false;
@@ -15395,6 +15412,7 @@ ${this.lastInitStack}` : "";
       clearInterval(pollId);
       pollId = null;
     };
+    add(stopPoll);
     const startPoll = () => {
       if (pollId != null) return;
       pollId = setInterval(() => {
@@ -15410,17 +15428,18 @@ ${this.lastInitStack}` : "";
       observedPlaying = false;
       stopPoll();
     };
-    const { add, dispose } = createDisposer();
     add(
       controller.on("playing", () => {
         if (inStall) endStall("playing" /* PLAYING */);
-        else lastProgressAt = Date.now();
+        lastProgressAt = Date.now();
         observedPlaying = true;
         startPoll();
       })
     );
     add(
-      controller.on("timeUpdate", () => {
+      controller.on("timeUpdate", ({ previous, current }) => {
+        if (previous != null && current - previous <= PROGRESS_EPSILON)
+          return;
         if (inStall) endStall("playing" /* PLAYING */);
         lastProgressAt = Date.now();
       })
@@ -15428,13 +15447,7 @@ ${this.lastInitStack}` : "";
     add(controller.on("pause", () => suspend("pause" /* PAUSE */)));
     add(controller.on("seeking", () => suspend("seeking" /* SEEKING */)));
     add(controller.on("emptied", () => suspend("emptied" /* EMPTIED */)));
-    let stopped = false;
-    return () => {
-      if (stopped) return;
-      stopped = true;
-      stopPoll();
-      dispose();
-    };
+    return dispose;
   }
 
   // src/playback/error/InvalidSeekError.ts
@@ -15710,15 +15723,13 @@ ${this.lastInitStack}` : "";
       __publicField(this, "_playing", false);
       __publicField(this, "_seeking", false);
       __publicField(this, "_waiting", false);
-      // Monotonic counter identifying the most recent seekTo call.
-      __publicField(this, "_seekId", 0);
+      __publicField(this, "seekAbortSlot", createAbortSlot());
       // Stops the stall detector started after the last seek, if any.
       __publicField(this, "stopStallDetection", null);
       // default user volume (0.0 to 1.0 scale)
       __publicField(this, "userVolume", 1);
       __publicField(this, "_pendingPlay", null);
       __publicField(this, "playAbort", null);
-      __publicField(this, "disposeAbort", new Abort());
       __publicField(this, "options");
       this.options = __spreadValues(__spreadProps(__spreadValues({}, defaultPlaybackControllerImplOptions), {
         minSeekableBuffer: getMinSeekableBufferDefault()
@@ -15729,8 +15740,7 @@ ${this.lastInitStack}` : "";
       const { add } = this.disposer;
       add(() => {
         var _a3;
-        this.disposeAbort.abort();
-        this.disposeAbort.dispose();
+        this.seekAbortSlot.abort();
         (_a3 = this.stopStallDetection) == null ? void 0 : _a3.call(this);
       });
       this.domEvents = add(
@@ -16143,14 +16153,10 @@ ${this.lastInitStack}` : "";
     async seekTo(time, tolerance = 0.5) {
       var _a3;
       logDebug(this, `seekTo: ${time}`);
-      const seekId = ++this._seekId;
       (_a3 = this.stopStallDetection) == null ? void 0 : _a3.call(this);
       this.stopStallDetection = null;
-      const superseded = () => {
-        if (this._seekId === seekId) return false;
-        logDebug(this, `seekTo: ${time} superseded by a newer seek`);
-        return true;
-      };
+      this.seekAbortSlot.abort();
+      const seekAbort = this.seekAbortSlot.value;
       const nextEvent = (type, options) => {
         var _a4;
         return nextEventAsPromise(this, type, {
@@ -16158,12 +16164,25 @@ ${this.lastInitStack}` : "";
           timeoutMessage: `seek timed out on ${type} event after {time}s`,
           timeoutOrigin: ErrorOrigin.INTERNAL,
           timeoutLevel: "warn" /* WARN */,
-          abort: this.disposeAbort
+          abort: seekAbort
         });
       };
+      try {
+        await this.doSeek(time, tolerance, seekAbort, nextEvent);
+      } catch (error) {
+        if (seekAbort.aborted() && !this.disposed) return;
+        throw error;
+      }
+    }
+    /**
+     * The body of a single {@link seekTo} attempt. Extracted so {@link seekTo}
+     * can wrap it with per-seek abort/supersession handling. `seekAbort` is
+     * aborted when a newer seek supersedes this one (or on dispose).
+     * @private
+     */
+    async doSeek(time, tolerance, seekAbort, nextEvent) {
       if (!this.hasMetadata) {
         await nextEvent("loadedMetadata");
-        if (superseded()) return;
       }
       const seekable = this.seekable;
       const range = seekable.getRangeAt(
@@ -16194,7 +16213,7 @@ ${this.lastInitStack}` : "";
         );
       } else {
         const nullIfStuck = (error) => {
-          if (this.disposeAbort.aborted()) throw error;
+          if (this.disposed) throw error;
           return null;
         };
         const seekOnce = async (reSeeking) => {
@@ -16208,7 +16227,7 @@ ${this.lastInitStack}` : "";
           }).catch(nullIfStuck);
         };
         let seekedEvent = await seekOnce(false);
-        for (let attempt = 0; !superseded() && attempt < SEEK_RETRY_LIMIT && (seekedEvent === null || seekedEvent.reason === "seeked" && !closeTo(clampedTime, this.currentTime, tolerance)); attempt++) {
+        for (let attempt = 0; !seekAbort.aborted() && attempt < SEEK_RETRY_LIMIT && (seekedEvent === null || seekedEvent.reason === "seeked" && !closeTo(clampedTime, this.currentTime, tolerance)); attempt++) {
           if (seekedEvent === null) void this.media.play().catch(noop);
           logDebug(this, `seekTo: re-seeking to ${clampedTime}`);
           seekedEvent = await seekOnce(true);
@@ -16216,7 +16235,7 @@ ${this.lastInitStack}` : "";
         if ((seekedEvent == null ? void 0 : seekedEvent.reason) === "emptied") {
           throw new AbortError();
         }
-        if (!this.paused) this.startStallDetection();
+        if (!this.paused && !seekAbort.aborted()) this.startStallDetection();
       }
     }
     /**
@@ -20556,7 +20575,6 @@ ${this.lastInitStack}` : "";
       const deps = depsContainer.dependencies;
       super(uri, type, deps);
       __publicField(this, "streams", []);
-      __publicField(this, "disposeAbort", new Abort());
       __publicField(this, "lastPreloadOptions", null);
       __publicField(this, "allFetchedRanges", []);
       __publicField(this, "_fetchedRanges", new IntersectionRanges(
@@ -20581,7 +20599,7 @@ ${this.lastInitStack}` : "";
         if (this.active) {
           this.deps.drmController.initializeForPlayback(event.current, {
             trackUri: this.uri,
-            abort: this.disposeAbort
+            abort: this.drmSessionAbort.value
           });
         }
       });
@@ -20589,7 +20607,7 @@ ${this.lastInitStack}` : "";
         if (event.current == null) return;
         this.deps.drmController.setBufferingDrmInfo(event.current, {
           trackUri: this.uri,
-          abort: this.disposeAbort
+          abort: this.drmSessionAbort.value
         });
       });
       add(
@@ -20827,7 +20845,7 @@ ${this.lastInitStack}` : "";
       this.streams.forEach((stream) => {
         this.deps.drmController.initializeForPlayback(
           stream.streamingQuality,
-          { trackUri: this.uri, abort: this.disposeAbort }
+          { trackUri: this.uri, abort: this.drmSessionAbort.value }
         );
       });
       this.deps.playbackSource.src = this.deps.mediaSourceController.activate();
@@ -20853,7 +20871,7 @@ ${this.lastInitStack}` : "";
       this.callOnStreams("deactivate");
       this.deps.drmController.setBufferingDrmInfo(null, {
         trackUri: this.uri,
-        abort: this.disposeAbort
+        abort: this.drmSessionAbort.value
       });
       (_b = this.deps.textTrackController) == null ? void 0 : _b.deactivate();
       this.deps.playbackSource.src = null;
@@ -24951,7 +24969,8 @@ ${this.lastInitStack}` : "";
   var vinylTestAssets = {
     prog: {
       libmp3lame_60s_2ch_16bit_44100Hz_48kbps: `https://assets.dev.vinyl.music.amazon.dev/prog/libmp3lame_60s_2ch_16bit_44100Hz_48kbps.mp3`,
-      libmp3lame_1800s_2ch_16bit_44100Hz_48kbps: `https://assets.dev.vinyl.music.amazon.dev/prog/libmp3lame_1800s_2ch_16bit_44100Hz_48kbps.mp3`
+      libmp3lame_1800s_2ch_16bit_44100Hz_48kbps: `https://assets.dev.vinyl.music.amazon.dev/prog/libmp3lame_1800s_2ch_16bit_44100Hz_48kbps.mp3`,
+      libmp3lame_1s_2ch_16bit_44100Hz_48kbps: `https://assets.dev.vinyl.music.amazon.dev/prog/libmp3lame_1s_2ch_16bit_44100Hz_48kbps.mp3`
     },
     dash: {
       live_static_aac_opus_flac_60s_segmentTemplate: `https://assets.dev.vinyl.music.amazon.dev/dash/live_static_aac_opus_flac_60s_segmentTemplate/manifest.mpd`,
@@ -24966,6 +24985,10 @@ ${this.lastInitStack}` : "";
       live_static_aac_opus_flac_60s_segmentBase_widevine_cl10: `https://assets.dev.vinyl.music.amazon.dev/dash/live_static_aac_opus_flac_60s_segmentBase_widevine_cl10/manifest.mpd`,
       live_static_aac_opus_flac_60s_segmentBase_widevine: `https://assets.dev.vinyl.music.amazon.dev/dash/live_static_aac_opus_flac_60s_segmentBase_widevine/manifest.mpd`,
       live_static_aac_1800s_segmentBase_widevine_cl30: `https://assets.dev.vinyl.music.amazon.dev/dash/live_static_aac_1800s_segmentBase_widevine_cl30/manifest.mpd`,
+      // Edge-case tracks: ultra-short 1s assets (audio-only + video), no
+      // captions or translations.
+      edge_static_aac_1s_segmentTemplate: `https://assets.dev.vinyl.music.amazon.dev/dash/edge_static_aac_1s_segmentTemplate/manifest.mpd`,
+      edge_static_video_1s_segmentTemplate: `https://assets.dev.vinyl.music.amazon.dev/dash/edge_static_video_1s_segmentTemplate/manifest.mpd`,
       // Ad-break assets (see DMTestAssetBuilder src/adBreaks): a ~3-min
       // labeled ABR ladder with five-language narration, full + forced
       // captions. Base content only — DASH ad-break scenarios are not
@@ -24985,6 +25008,10 @@ ${this.lastInitStack}` : "";
       live_static_video_60s_4s_mpegts: `https://assets.dev.vinyl.music.amazon.dev/hls/live_static_video_60s_4s_mpegts/main.m3u8`,
       live_static_video_audio_60s_2s_mpegts: `https://assets.dev.vinyl.music.amazon.dev/hls/live_static_video_audio_60s_2s_mpegts/main.m3u8`,
       live_static_video_audio_60s_4s_mpegts: `https://assets.dev.vinyl.music.amazon.dev/hls/live_static_video_audio_60s_4s_mpegts/main.m3u8`,
+      // Edge-case tracks: ultra-short 1s assets (audio-only + video), no
+      // captions or translations.
+      edge_static_aac_1s: `https://assets.dev.vinyl.music.amazon.dev/hls/edge_static_aac_1s/main.m3u8`,
+      edge_static_video_1s: `https://assets.dev.vinyl.music.amazon.dev/hls/edge_static_video_1s/main.m3u8`,
       // Ad-break assets: base content + HLS Interstitial scenario variants.
       // `*_av` = video+audio, `*_audio` = audio-only; each `__<scenario>`
       // injects a different ad-break configuration. See DMTestAssetBuilder
@@ -27745,7 +27772,6 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
             makeBreak({
               startTime: 10,
               duration: 20,
-              // Null per-ad duration so the per-ad cap does not end it.
               ads: [
                 {
                   id: "a1",
@@ -27849,8 +27875,8 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
       });
     });
     describe("ad duration and playout limits", () => {
-      it("advances to the next ad when one reaches its declared duration", async () => {
-        var _a3, _b;
+      it("advances to the next ad on the ad media ended, not its declared duration", async () => {
+        var _a3, _b, _c;
         const c = createController();
         await setContent(
           c,
@@ -27863,6 +27889,7 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
                   id: "a1",
                   startTime: 0,
                   duration: 5,
+                  // declared, server-rounded
                   uri: "ad1.m3u8"
                 },
                 {
@@ -27881,7 +27908,51 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         playbackController.dispatch("playing", {});
         updateTime(6);
         await flush();
-        expect((_b = c.currentAd) == null ? void 0 : _b.id).toBe("a2");
+        expect((_b = c.currentAd) == null ? void 0 : _b.id).toBe("a1");
+        playbackController.dispatch("ended", {
+          previous: false,
+          current: true
+        });
+        await flush();
+        expect((_c = c.currentAd) == null ? void 0 : _c.id).toBe("a2");
+      });
+      it("does not cut the final/only ad at its declared duration; it ends on media ended", async () => {
+        var _a3, _b;
+        const c = createController();
+        const ended = [];
+        c.on("adEnded", (e) => ended.push(e.ad.id));
+        await setContent(
+          c,
+          trackAds(
+            makeBreak({
+              startTime: 0,
+              duration: 30,
+              ads: [
+                {
+                  id: "a1",
+                  startTime: 0,
+                  duration: 6,
+                  // declared, server-rounded
+                  uri: "ad1.m3u8"
+                }
+              ]
+            })
+          )
+        );
+        updateTime(0);
+        await flush();
+        expect((_a3 = c.currentAd) == null ? void 0 : _a3.id).toBe("a1");
+        playbackController.dispatch("playing", {});
+        updateTime(6.5);
+        await flush();
+        expect((_b = c.currentAd) == null ? void 0 : _b.id).toBe("a1");
+        expect(ended).toEqual([]);
+        playbackController.dispatch("ended", {
+          previous: false,
+          current: true
+        });
+        expect(ended).toEqual(["a1"]);
+        expect(c.currentAdBreak).toBeNull();
       });
       it("ends the whole break when the playout limit is reached, dropping remaining ads", async () => {
         var _a3;
@@ -27922,6 +27993,70 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         expect(c.currentAdBreak).toBeNull();
         expect(resumes.at(-1)).toBe(0);
       });
+      it("does not cut at the playout limit when the ad is within tolerance of its media end", async () => {
+        var _a3;
+        const c = createController();
+        await setContent(
+          c,
+          trackAds(
+            makeBreak({
+              startTime: 0,
+              duration: null,
+              playoutLimit: 8,
+              ads: [
+                {
+                  id: "a1",
+                  startTime: 0,
+                  duration: 20,
+                  uri: "ad1.m3u8"
+                }
+              ]
+            })
+          )
+        );
+        updateTime(0);
+        await flush();
+        playbackController.dispatch("playing", {});
+        playbackController.duration = 8.5;
+        updateTime(8);
+        await flush();
+        expect(c.currentAdBreak).not.toBeNull();
+        expect((_a3 = c.currentAd) == null ? void 0 : _a3.id).toBe("a1");
+        playbackController.dispatch("ended", {
+          previous: false,
+          current: true
+        });
+        await flush();
+        expect(c.currentAdBreak).toBeNull();
+      });
+      it("cuts at the playout limit when the ad has more than the tolerance of media left", async () => {
+        const c = createController();
+        await setContent(
+          c,
+          trackAds(
+            makeBreak({
+              startTime: 0,
+              duration: null,
+              playoutLimit: 8,
+              ads: [
+                {
+                  id: "a1",
+                  startTime: 0,
+                  duration: 20,
+                  uri: "ad1.m3u8"
+                }
+              ]
+            })
+          )
+        );
+        updateTime(0);
+        await flush();
+        playbackController.dispatch("playing", {});
+        playbackController.duration = 20;
+        updateTime(8);
+        await flush();
+        expect(c.currentAdBreak).toBeNull();
+      });
     });
     describe("CUE=ONCE and replay", () => {
       it("replays a non-ONCE break after the playhead seeks back before it", async () => {
@@ -32017,6 +32152,23 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         expect(drmController.isEmeSupported()).toBeFalse();
       });
     });
+    describe("excessive sessions", () => {
+      it("warns once when the open session count exceeds the threshold", async () => {
+        drmController.setBufferingDrmInfo(drmInfo);
+        for (let i = 0; i < EXCESSIVE_SESSION_COUNT; i++) {
+          await emitEncrypted(new Uint8Array([i]));
+        }
+        expect(drmController.activeSessions).toBe(EXCESSIVE_SESSION_COUNT);
+        expect(logger.value.warn).not.toHaveBeenCalled();
+        await emitEncrypted(new Uint8Array([EXCESSIVE_SESSION_COUNT]));
+        expect(drmController.activeSessions).toBe(
+          EXCESSIVE_SESSION_COUNT + 1
+        );
+        expect(logger.value.warn).toHaveBeenCalledTimes(1);
+        await emitEncrypted(new Uint8Array([EXCESSIVE_SESSION_COUNT + 1]));
+        expect(logger.value.warn).toHaveBeenCalledTimes(1);
+      });
+    });
     describe("closeSessions", () => {
       it("clears active sessions", async () => {
         const sessionCloseSpy = createEventSpy(
@@ -33203,10 +33355,38 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
       expect(onStallEntered).toHaveBeenCalledTimes(2);
       expect(onStallEnded).toHaveBeenCalledTimes(2);
     });
+    it("does not end and re-detect a stall on a non-advancing timeUpdate", async () => {
+      monitor();
+      host.dispatch("playing", {});
+      host.dispatch("timeUpdate", { previous: 4, current: 5 });
+      await poll2(4);
+      expect(onStallEntered).toHaveBeenCalledTimes(1);
+      host.dispatch("timeUpdate", { previous: 5, current: 5 });
+      host.dispatch("timeUpdate", { previous: 5, current: 4.99 });
+      host.dispatch("timeUpdate", { previous: 5, current: 5 + 1e-9 });
+      await poll2(4);
+      expect(onStallEnded).not.toHaveBeenCalled();
+      expect(onStallEntered).toHaveBeenCalledTimes(1);
+      host.dispatch("timeUpdate", { previous: 5, current: 6 });
+      expect(onStallEnded).toHaveBeenCalledTimes(1);
+      expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it("does not re-detect a stall immediately after resuming via a playing event", async () => {
+      monitor();
+      host.dispatch("playing", {});
+      host.dispatch("timeUpdate", { previous: 0, current: 1 });
+      await poll2(4);
+      expect(onStallEntered).toHaveBeenCalledTimes(1);
+      host.dispatch("playing", {});
+      expect(onStallEnded).toHaveBeenCalledTimes(1);
+      await poll2(3);
+      expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
     it("stops reporting after disposal", async () => {
       monitor();
       host.dispatch("playing", {});
       stop();
+      stop = void 0;
       await poll2(8);
       expect(onStallEntered).not.toHaveBeenCalled();
     });
@@ -33957,6 +34137,13 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
             await clock.tick(controller.options.seekTimeout);
             await seekExpectation;
           });
+          it("resolves a superseded seek at once when its seeking event never fires", async () => {
+            setSeekable([[0, 100]]);
+            const first2 = controller.seekTo(50);
+            const second = controller.seekTo(60);
+            await expectAsync(first2).toBeResolved();
+            second.catch(() => void 0);
+          });
           it("times out pending seeks after seekTimeout", async () => {
             const pendingSeekExpectation = expectAsync(
               controller.seekTo(60)
@@ -39067,6 +39254,16 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
           abort: any14(Abort)
         });
       });
+      it("aborts the drm session abort so key sessions close", async () => {
+        track2 = createTrack();
+        await awaitContentTypes();
+        getAudioStream().streamingQuality = createEmptyMediaQualityMetadata();
+        track2.activate({});
+        const { abort } = deps.drmController.initializeForPlayback.calls.mostRecent().args[1];
+        expect(abort.aborted()).toBeFalse();
+        track2.deactivate();
+        expect(abort.aborted()).toBeTrue();
+      });
     });
     describe("error", () => {
       it("returns the first emitted error", async () => {
@@ -55011,27 +55208,31 @@ x`);
       if (!supportsMse()) pending("MSE not supported");
     });
     const suite = createVinylSuite();
+    async function arrangeStall() {
+      const player = suite.player;
+      const stallEnteredSpy = createEventSpy(player, "stallEntered");
+      const stallEndedSpy = createEventSpy(player, "stallEnded");
+      const mediaSource = new ControlledMediaSource();
+      player.load({
+        type: "src",
+        uri: URL.createObjectURL(await mediaSource.getMediaSource())
+      });
+      void player.play();
+      await mediaSource.appendNext();
+      await mediaSource.appendNext();
+      await onPlaying(player);
+      expect(stallEnteredSpy).not.toHaveBeenCalled();
+      const entered = stallEnteredSpy.next(
+        30,
+        "stallEntered after hitting end of buffer timed out after {timeout}s"
+      );
+      await player.seekTo(5);
+      await entered;
+      return { player, mediaSource, stallEnteredSpy, stallEndedSpy };
+    }
     describe("when the play head freezes mid-playback", () => {
       it("emits stallEntered then stallEnded when playback resumes", async () => {
-        const player = suite.player;
-        const stallEnteredSpy = createEventSpy(player, "stallEntered");
-        const stallEndedSpy = createEventSpy(player, "stallEnded");
-        const mediaSource = new ControlledMediaSource();
-        player.load({
-          type: "src",
-          uri: URL.createObjectURL(await mediaSource.getMediaSource())
-        });
-        void player.play();
-        await mediaSource.appendNext();
-        await mediaSource.appendNext();
-        await onPlaying(player);
-        expect(stallEnteredSpy).not.toHaveBeenCalled();
-        const nextEntered = stallEnteredSpy.next(
-          30,
-          "stallEntered after hitting end of buffer timed out after {timeout}s"
-        );
-        await player.seekTo(5);
-        await nextEntered;
+        const { player, mediaSource, stallEnteredSpy, stallEndedSpy } = await arrangeStall();
         const nextEnded = stallEndedSpy.next(
           10,
           "stallEnded after data buffered timed out after {timeout}s"
@@ -55040,7 +55241,62 @@ x`);
         const ended = await nextEnded;
         expect(ended.reason).toBe("playing");
         expect(stallEnteredSpy).toHaveBeenCalledTimes(1);
+        expect(stallEndedSpy).toHaveBeenCalledTimes(1);
         expect(ended.duration).toBeGreaterThan(0.5);
+        for (let i = 0; i < 5; i++) await onTimeUpdate(player);
+        expect(stallEnteredSpy).toHaveBeenCalledTimes(1);
+        expect(stallEndedSpy).toHaveBeenCalledTimes(1);
+      });
+      it('ends the stall with reason "seeking" when the user seeks away mid-stall', async () => {
+        const { player, stallEnteredSpy, stallEndedSpy } = await arrangeStall();
+        const nextEnded = stallEndedSpy.next(
+          10,
+          "stallEnded after seeking away timed out after {timeout}s"
+        );
+        await player.seekTo(1);
+        const ended = await nextEnded;
+        expect(ended.reason).toBe("seeking");
+        expect(stallEnteredSpy).toHaveBeenCalledTimes(1);
+        expect(stallEndedSpy).toHaveBeenCalledTimes(1);
+      });
+      it('ends the stall with reason "emptied" when the track is unloaded mid-stall', async () => {
+        const { player, stallEnteredSpy, stallEndedSpy } = await arrangeStall();
+        const nextEnded = stallEndedSpy.next(
+          10,
+          "stallEnded after unload timed out after {timeout}s"
+        );
+        player.unload();
+        const ended = await nextEnded;
+        expect(ended.reason).toBe("emptied");
+        expect(stallEnteredSpy).toHaveBeenCalledTimes(1);
+        expect(stallEndedSpy).toHaveBeenCalledTimes(1);
+      });
+      it("reports each distinct freeze exactly once", async () => {
+        const { player, mediaSource, stallEnteredSpy, stallEndedSpy } = await arrangeStall();
+        const firstEnded = stallEndedSpy.next(
+          10,
+          "stallEnded for freeze 1 timed out after {timeout}s"
+        );
+        await mediaSource.appendNext();
+        expect((await firstEnded).reason).toBe("playing");
+        expect(stallEnteredSpy).toHaveBeenCalledTimes(1);
+        expect(stallEndedSpy).toHaveBeenCalledTimes(1);
+        const secondEntered = stallEnteredSpy.next(
+          30,
+          "stallEntered for freeze 2 timed out after {timeout}s"
+        );
+        await player.seekTo(15);
+        await secondEntered;
+        expect(stallEnteredSpy).toHaveBeenCalledTimes(2);
+        const secondEnded = stallEndedSpy.next(
+          10,
+          "stallEnded for freeze 2 timed out after {timeout}s"
+        );
+        await mediaSource.appendNext();
+        expect((await secondEnded).reason).toBe("playing");
+        for (let i = 0; i < 5; i++) await onTimeUpdate(player);
+        expect(stallEnteredSpy).toHaveBeenCalledTimes(2);
+        expect(stallEndedSpy).toHaveBeenCalledTimes(2);
       });
     });
   });
@@ -55769,6 +56025,7 @@ x`);
   var ANCHOR_MS = Date.parse(ANCHOR_ISO);
   var CONTENT_ASSET = vinylTestAssets.hls.live_static_video_audio_60s_4s;
   var AD_ASSET = vinylTestAssets.hls.live_static_video_audio_60s_2s;
+  var SHORT_AD_ASSET = vinylTestAssets.hls.edge_static_video_1s;
   function injectingManifestProvider(mainUrl, interstitials) {
     return async () => {
       const mainText = await (await fetch(mainUrl)).text();
@@ -56403,8 +56660,8 @@ x`);
               id: "postroll-1",
               startTime: 0,
               duration: 4,
-              // Short ad so the break ends quickly on its own.
-              assetList: [{ uri: AD_ASSET, duration: 3 }],
+              // A 1s ad so the break ends quickly on its own `ended`.
+              assetList: [{ uri: SHORT_AD_ASSET, duration: 1 }],
               cue: "POST"
             }
           ])