@amazon/vinyl 3.2.0 → 3.2.1

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(
@@ -15214,7 +15221,7 @@ ${this.lastInitStack}` : "";
   // src/global/environment.ts
   var vinylVersion = parseVersion(
     /* istanbul ignore next */
-    "3.2.0"
+    "3.2.1"
   );
 
   // src/global/globalRef.ts
@@ -15371,6 +15378,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 +15387,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 +15404,7 @@ ${this.lastInitStack}` : "";
       clearInterval(pollId);
       pollId = null;
     };
+    add(stopPoll);
     const startPoll = () => {
       if (pollId != null) return;
       pollId = setInterval(() => {
@@ -15410,17 +15420,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 +15439,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
@@ -24951,7 +24956,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 +24972,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 +24995,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 +27759,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 +27862,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 +27876,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 +27895,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 +27980,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 () => {
@@ -33203,10 +33325,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();
     });
@@ -55011,27 +55161,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 +55194,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 +55978,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 +56613,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"
             }
           ])