@amazon/vinyl 3.1.0 → 3.2.1

package/dist/test/integ.js

@@ -5592,9 +5592,6 @@
   function map(arrayLike, transform, thisArg) {
     return Array.prototype.map.call(arrayLike, transform, thisArg);
   }
-  function every(arrayLike, predicate, thisArg) {
-    return Array.prototype.every.call(arrayLike, predicate, thisArg);
-  }
   function first(arrayLike) {
     if (!arrayLike) return void 0;
     return arrayLike[0];
@@ -9956,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
@@ -10446,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(
@@ -14017,6 +14021,10 @@ ${this.lastInitStack}` : "";
       __publicField(this, "bufferingTrackUri", null);
       __publicField(this, "sessionAbort", null);
       __publicField(this, "pendingMessageProps", null);
+      // Armed per track load; latches on the first session so only the
+      // critical-path session's EME/CDM setup is measured.
+      __publicField(this, "keySetupSpanArmed", true);
+      __publicField(this, "keySetupSpanStart", null);
       __publicField(this, "disposer", createDisposer());
       __publicField(this, "checkIsSupportedCached", memoize(
         async (params) => {
@@ -14182,6 +14190,7 @@ ${this.lastInitStack}` : "";
       if (!hasMimeType(drmInfo)) {
         throw new DrmError("Encrypted content must have a mimeType.");
       }
+      this.markKeySetupStart();
       const mediaKeys = await this.attachMediaKeys(drmInfo);
       this.abortIfDisposed();
       const keySystemOptions = (_a3 = this.options.keySystems[mediaKeys.keySystem]) != null ? _a3 : this.options.keySystems["*"];
@@ -14226,6 +14235,28 @@ ${this.lastInitStack}` : "";
       });
       return newSession;
     }
+    /**
+     * Captures the key-setup span start at the top of the session-creation path
+     * (before media keys are attached), latching so only the first session of
+     * the current track load is measured.
+     */
+    markKeySetupStart() {
+      if (!this.keySetupSpanArmed) return;
+      this.keySetupSpanArmed = false;
+      this.keySetupSpanStart = Date.now();
+    }
+    dispatchLoadSpan(kind, startTime, endTime, messageProps) {
+      this.dispatch("loadSpanMeasured", __spreadValues(__spreadValues({
+        kind,
+        startTime,
+        endTime,
+        mimeType: messageProps.mimeType
+      }, messageProps.trackUri != null && {
+        trackUri: messageProps.trackUri
+      }), messageProps.contentType != null && {
+        contentType: messageProps.contentType
+      }));
+    }
     initializeForPlayback(drmInfo, options) {
       var _a3;
       logDebug(this, "initializeForPlayback", drmInfo);
@@ -14249,6 +14280,8 @@ ${this.lastInitStack}` : "";
       this.drmInfo = drmInfo;
       this.bufferingTrackUri = (_a3 = options == null ? void 0 : options.trackUri) != null ? _a3 : null;
       this.sessionAbort = (_b = options == null ? void 0 : options.abort) != null ? _b : null;
+      this.keySetupSpanArmed = true;
+      this.keySetupSpanStart = null;
     }
     /**
      * If the drm metadata contains initialization data for the current key system, create a new session.
@@ -14260,6 +14293,7 @@ ${this.lastInitStack}` : "";
         this.handleError(new DrmError("DRM not supported."));
         return;
       }
+      this.markKeySetupStart();
       const mediaKeys = await this.attachMediaKeys(drmInfo);
       const drmProtection = (_a3 = drmInfo.contentProtections.find((cP) => {
         return cP.keySystem === mediaKeys.keySystem;
@@ -14398,7 +14432,9 @@ ${this.lastInitStack}` : "";
             event,
             // Captured per session, so a concurrent preloaded track's
             // license exchange keeps its own attribution.
-            trackUri
+            trackUri,
+            mimeType: drmInfo.mimeType,
+            contentType: drmInfo.contentType
           }),
           LICENSE_TIMEOUT,
           { message: LICENSE_TIMEOUT_MESSAGE }
@@ -14420,6 +14456,15 @@ ${this.lastInitStack}` : "";
       this.pendingMessageProps = messageProps;
       const keySystem = mediaKeys.keySystem;
       logDebug(this, "message", keySystem, event.message.byteLength);
+      if (this.keySetupSpanStart != null) {
+        this.dispatchLoadSpan(
+          "keySetup",
+          this.keySetupSpanStart,
+          Date.now(),
+          messageProps
+        );
+        this.keySetupSpanStart = null;
+      }
       const keySystemOptions = (_a3 = this.options.keySystems[keySystem]) != null ? _a3 : this.options.keySystems["*"];
       const licenseServerOptionsProvider = keySystemOptions == null ? void 0 : keySystemOptions.licenseServer;
       const licenseServerOptions = (_b = clone(await resolveValueProvider(licenseServerOptionsProvider))) != null ? _b : {};
@@ -14441,13 +14486,12 @@ ${this.lastInitStack}` : "";
         challenge
       );
       if (this.disposed) return;
-      this.dispatch("loadSpanMeasured", __spreadValues({
-        kind: "license",
-        startTime: licenseSpanStart,
-        endTime: Date.now()
-      }, messageProps.trackUri != null && {
-        trackUri: messageProps.trackUri
-      }));
+      this.dispatchLoadSpan(
+        "license",
+        licenseSpanStart,
+        Date.now(),
+        messageProps
+      );
       this.pendingMessageProps = null;
       if (session.disposed) return;
       logDebug(this, "update");
@@ -15177,7 +15221,7 @@ ${this.lastInitStack}` : "";
   // src/global/environment.ts
   var vinylVersion = parseVersion(
     /* istanbul ignore next */
-    "3.1.0"
+    "3.2.1"
   );
 
   // src/global/globalRef.ts
@@ -15334,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;
@@ -15342,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;
@@ -15358,6 +15404,7 @@ ${this.lastInitStack}` : "";
       clearInterval(pollId);
       pollId = null;
     };
+    add(stopPoll);
     const startPoll = () => {
       if (pollId != null) return;
       pollId = setInterval(() => {
@@ -15373,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();
       })
@@ -15391,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
@@ -17743,6 +17785,86 @@ ${this.lastInitStack}` : "";
     return filtered;
   }
 
+  // src/streaming/DescriptorRecord.ts
+  function getDescriptorValue(record2, uri, id) {
+    var _a3, _b;
+    let arr = record2[uri];
+    if (!arr) return null;
+    if (id !== void 0) arr = arr.filter((descriptor) => descriptor.id === id);
+    return (_b = (_a3 = first(arr)) == null ? void 0 : _a3.value) != null ? _b : null;
+  }
+  var descriptorValidator = object({
+    id: string().maybe().optional(),
+    value: string().maybe().optional()
+  });
+  var descriptorRecordValidator = record(string(), array(descriptorValidator).readonly().orUndefined());
+
+  // src/streaming/MediaQualityMetadata.ts
+  var ALL_CONTENT_TYPES = [
+    "video",
+    "audio",
+    "text"
+  ];
+  var RESTRICTABLE_CONTENT_TYPES = [
+    "video",
+    "audio"
+  ];
+  var drmProtectionValidator = descriptorValidator.extend({
+    keySystem: enumOf(DrmKeySystem),
+    pro: string().maybe().optional(),
+    pssh: string().maybe().optional()
+  });
+  var mediaFormatMetadataValidator = object({
+    contentProtections: array(drmProtectionValidator).readonly(),
+    contentType: isOneOf("audio", "video", "text").orNull(),
+    initDataType: string().orNull(),
+    encryptionScheme: string().orNull(),
+    mimeType: string().orNull()
+  });
+  function createEmptyMediaFormatMetadata() {
+    return {
+      contentType: null,
+      mimeType: null,
+      initDataType: null,
+      encryptionScheme: null,
+      contentProtections: []
+    };
+  }
+  function createEmptyMediaQualityMetadata() {
+    return __spreadProps(__spreadValues({}, createEmptyMediaFormatMetadata()), {
+      decoderId: createShortUid(),
+      qualityId: createShortUid(),
+      codecs: null,
+      bandwidth: null,
+      bandwidthTotal: null,
+      supplementalProperties: {},
+      audioSamplingRate: null,
+      frameRate: null,
+      height: null,
+      width: null,
+      lang: null,
+      characteristics: [],
+      groupId: createShortUid(),
+      switchingGroupIds: null
+    });
+  }
+  var mediaQualityMetadataValidator = mediaFormatMetadataValidator.extend({
+    audioSamplingRate: array(number()).readonly().orNull(),
+    bandwidth: number().orNull(),
+    bandwidthTotal: number().orNull(),
+    codecs: string().orNull(),
+    decoderId: string(),
+    frameRate: tuple(number(), number()).readonly().orNull(),
+    height: number().orNull(),
+    qualityId: string(),
+    supplementalProperties: descriptorRecordValidator,
+    width: number().orNull(),
+    lang: string().orNull(),
+    characteristics: array(string()).readonly(),
+    groupId: string(),
+    switchingGroupIds: array(string()).readonly().orNull()
+  });
+
   // src/track/filters/languageFilter.ts
   function throwLanguagesUnsupported() {
     throw new MediaUnsupportedError(
@@ -18024,6 +18146,13 @@ ${this.lastInitStack}` : "";
   }
 
   // src/streaming/mediaTimelineFilter.ts
+  function assertMediaStreamsRetained(original, filtered, throwError) {
+    for (const contentType2 of RESTRICTABLE_CONTENT_TYPES) {
+      if (original.some((q) => q.metadata.contentType === contentType2) && !filtered.some((q) => q.metadata.contentType === contentType2)) {
+        throwError();
+      }
+    }
+  }
   function filterTimelineQualities(filter, throwError, timeline) {
     if (!filter) return timeline;
     const mapMetadataArray = memoize(
@@ -18035,11 +18164,9 @@ ${this.lastInitStack}` : "";
       const filtered = period.qualities.filter(
         (q, index) => filter(q.metadata, index, mapMetadataArray(period.qualities))
       );
+      assertMediaStreamsRetained(period.qualities, filtered, throwError);
       return __spreadProps(__spreadValues({}, period), { qualities: filtered });
     });
-    if (periods.some((p) => p.qualities.length === 0)) {
-      throwError();
-    }
     return __spreadProps(__spreadValues({}, timeline), { periods });
   }
   async function filterTimelineQualitiesAsync(filter, throwError, timeline) {
@@ -18057,11 +18184,9 @@ ${this.lastInitStack}` : "";
           filtered.push(period.qualities[i]);
         }
       }
+      assertMediaStreamsRetained(period.qualities, filtered, throwError);
       periods.push(__spreadProps(__spreadValues({}, period), { qualities: filtered }));
     }
-    if (periods.some((p) => p.qualities.length === 0)) {
-      throwError();
-    }
     return __spreadProps(__spreadValues({}, timeline), { periods });
   }
 
@@ -18135,23 +18260,28 @@ ${this.lastInitStack}` : "";
     if (metadata.contentType !== "audio") return true;
     const samplingRate = last(metadata.audioSamplingRate);
     if (!samplingRate) return true;
+    const { minSampleRate } = options;
+    const maxSampleRate = (_a3 = options.maxSampleRate) != null ? _a3 : options.capabilities.sampleRate;
     const audioRates = () => map(
       array2,
       (item) => item.contentType === "audio" ? last(item.audioSamplingRate) : void 0
     ).filter((rate) => rate != null);
-    const { minSampleRate } = options;
+    const outOfBandFallback = () => {
+      const rates = audioRates();
+      const inBand = (rate) => (minSampleRate == null || rate >= minSampleRate) && (!maxSampleRate || rate <= maxSampleRate);
+      if (rates.some(inBand)) return void 0;
+      const decodable = maxSampleRate ? rates.filter((rate) => rate <= maxSampleRate) : rates;
+      return decodable.length ? max(decodable) : min(rates);
+    };
     if (minSampleRate != null && samplingRate < minSampleRate) {
-      const rates2 = audioRates();
-      return every(rates2, (rate) => rate < minSampleRate) && samplingRate === max(rates2);
+      return samplingRate === outOfBandFallback();
     }
-    const maxSampleRate = (_a3 = options.maxSampleRate) != null ? _a3 : options.capabilities.sampleRate;
     if (!maxSampleRate) return true;
     if (hasBrowser("Firefox" /* FIREFOX */)) {
       return samplingRate <= 48e3;
     }
     if (samplingRate <= maxSampleRate) return true;
-    const rates = audioRates();
-    return every(rates, (rate) => rate > maxSampleRate) && samplingRate === min(rates);
+    return samplingRate === outOfBandFallback();
   }
 
   // src/util/media/codecOverrides.ts
@@ -18238,20 +18368,6 @@ ${this.lastInitStack}` : "";
     });
   }
 
-  // src/streaming/DescriptorRecord.ts
-  function getDescriptorValue(record2, uri, id) {
-    var _a3, _b;
-    let arr = record2[uri];
-    if (!arr) return null;
-    if (id !== void 0) arr = arr.filter((descriptor) => descriptor.id === id);
-    return (_b = (_a3 = first(arr)) == null ? void 0 : _a3.value) != null ? _b : null;
-  }
-  var descriptorValidator = object({
-    id: string().maybe().optional(),
-    value: string().maybe().optional()
-  });
-  var descriptorRecordValidator = record(string(), array(descriptorValidator).readonly().orUndefined());
-
   // src/streaming/ManifestControllerImpl.ts
   var ManifestControllerImpl = class {
     constructor(deps) {
@@ -18351,72 +18467,6 @@ ${this.lastInitStack}` : "";
     }
   };
 
-  // src/streaming/MediaQualityMetadata.ts
-  var ALL_CONTENT_TYPES = [
-    "video",
-    "audio",
-    "text"
-  ];
-  var RESTRICTABLE_CONTENT_TYPES = [
-    "video",
-    "audio"
-  ];
-  var drmProtectionValidator = descriptorValidator.extend({
-    keySystem: enumOf(DrmKeySystem),
-    pro: string().maybe().optional(),
-    pssh: string().maybe().optional()
-  });
-  var mediaFormatMetadataValidator = object({
-    contentProtections: array(drmProtectionValidator).readonly(),
-    contentType: isOneOf("audio", "video", "text").orNull(),
-    initDataType: string().orNull(),
-    encryptionScheme: string().orNull(),
-    mimeType: string().orNull()
-  });
-  function createEmptyMediaFormatMetadata() {
-    return {
-      contentType: null,
-      mimeType: null,
-      initDataType: null,
-      encryptionScheme: null,
-      contentProtections: []
-    };
-  }
-  function createEmptyMediaQualityMetadata() {
-    return __spreadProps(__spreadValues({}, createEmptyMediaFormatMetadata()), {
-      decoderId: createShortUid(),
-      qualityId: createShortUid(),
-      codecs: null,
-      bandwidth: null,
-      bandwidthTotal: null,
-      supplementalProperties: {},
-      audioSamplingRate: null,
-      frameRate: null,
-      height: null,
-      width: null,
-      lang: null,
-      characteristics: [],
-      groupId: createShortUid(),
-      switchingGroupIds: null
-    });
-  }
-  var mediaQualityMetadataValidator = mediaFormatMetadataValidator.extend({
-    audioSamplingRate: array(number()).readonly().orNull(),
-    bandwidth: number().orNull(),
-    bandwidthTotal: number().orNull(),
-    codecs: string().orNull(),
-    decoderId: string(),
-    frameRate: tuple(number(), number()).readonly().orNull(),
-    height: number().orNull(),
-    qualityId: string(),
-    supplementalProperties: descriptorRecordValidator,
-    width: number().orNull(),
-    lang: string().orNull(),
-    characteristics: array(string()).readonly(),
-    groupId: string(),
-    switchingGroupIds: array(string()).readonly().orNull()
-  });
-
   // src/streaming/MediaTimeline.ts
   function getMediaPeriodAtTime(timeline, time) {
     const index = sortedInsertionIndex(timeline.periods, time, (time2, period2) => {
@@ -20529,10 +20579,7 @@ ${this.lastInitStack}` : "";
       this.deps = deps;
       add(
         deps.contentTypesValue.onData((contentTypesPromise) => {
-          contentTypesPromise.then((value) => {
-            this.setContentTypes(value);
-            this.validateRequiredContentTypesPlayable();
-          }).catch(this.errorHandler);
+          contentTypesPromise.then((value) => this.setContentTypes(value)).catch(this.errorHandler);
         })
       );
       this.on("streamingQualityChange", (event) => {
@@ -20633,33 +20680,8 @@ ${this.lastInitStack}` : "";
             });
           }
         }
-        this.validateRequiredContentTypesPlayable();
       });
     }
-    /**
-     * Fails fast when a media content type the manifest declared (audio/video)
-     * has no playable qualities left after timeline filtering. Its stream can
-     * never create a source buffer, so without this the track waits forever for
-     * a source buffer that never arrives, surfacing only as an opaque
-     * `readyToAppend` timeout. Runs once both the required content types and the
-     * filtered timeline qualities are known (either order).
-     */
-    validateRequiredContentTypesPlayable() {
-      const qualities = this._qualities;
-      if (!qualities) return;
-      const present = new Set(qualities.map((q) => q.contentType));
-      for (const contentType2 of this._contentTypes) {
-        if (!present.has(contentType2)) {
-          this.errorHandler(
-            new MediaUnsupportedError(
-              `No playable ${contentType2} rendition`,
-              `no-playable-${contentType2}`
-            )
-          );
-          return;
-        }
-      }
-    }
     async getAds() {
       const timeline = await this.deps.mediaTimeline.value;
       return {
@@ -24081,6 +24103,7 @@ ${this.lastInitStack}` : "";
       playerRegistryRef.value.addPlayer(this);
       this.redispatchSubControllerEvents();
       this.redispatchCurrentTrackEvents();
+      this.initializeLoadSpanLogging();
       this.initializeAutoResetHandling();
     }
     get [Symbol.toStringTag]() {
@@ -24098,6 +24121,26 @@ ${this.lastInitStack}` : "";
     get autoResetController() {
       return this.deps.autoResetController;
     }
+    /**
+     * Logs each republished load span once at the verbose level, formatting its
+     * bounds as ISO date strings and its duration in milliseconds.
+     */
+    initializeLoadSpanLogging() {
+      this.disposer.add(
+        this.on("loadSpan", (span) => {
+          if (getLogLevel() > 0 /* VERBOSE */) return;
+          logVerbose(this, "loadSpan", {
+            kind: span.kind,
+            trackUri: span.trackUri,
+            mimeType: span.mimeType,
+            contentType: span.contentType,
+            startTime: new Date(span.startTime).toISOString(),
+            endTime: new Date(span.endTime).toISOString(),
+            durationMs: (span.endTime - span.startTime).toFixed(2)
+          });
+        })
+      );
+    }
     redispatchSubControllerEvents() {
       const add = this.disposer.add;
       add(
@@ -24913,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`,
@@ -24928,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
@@ -24947,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
@@ -27707,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",
@@ -27811,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,
@@ -27825,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"
                 },
                 {
@@ -27843,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;
@@ -27884,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 () => {
@@ -31554,7 +31714,7 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         drmController.setBufferingDrmInfo(drmInfo);
         await emitEncrypted(new Uint8Array([1, 2, 3]), "cenc");
         await emitMessage(0, new ArrayBuffer(1));
-        expect(spy).toHaveBeenCalledOnceWith(
+        expect(spy).toHaveBeenCalledWith(
           objectContaining2({
             kind: "license",
             startTime: any4(Number),
@@ -31562,22 +31722,65 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
           })
         );
       });
+      it("measures the key setup, contiguous with and before the license", async () => {
+        licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
+        const spy = createEventSpy(drmController, "loadSpanMeasured");
+        drmController.setBufferingDrmInfo(drmInfo, { trackUri: "track-a" });
+        await emitEncrypted(new Uint8Array([1, 2, 3]), "cenc");
+        await emitMessage(0, new ArrayBuffer(1));
+        const spans = spy.calls.all().map((call) => call.args[0]);
+        expect(spans.map((span) => span.kind)).toEqual([
+          "keySetup",
+          "license"
+        ]);
+        const [keySetup, license] = spans;
+        expect(keySetup.trackUri).toEqual("track-a");
+        expect(keySetup.endTime).toEqual(license.startTime);
+      });
+      it("carries the content mime and content type on the license span", async () => {
+        licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
+        const spy = createEventSpy(drmController, "loadSpanMeasured");
+        drmController.setBufferingDrmInfo(drmInfo);
+        await emitEncrypted(new Uint8Array([1, 2, 3]), "cenc");
+        await emitMessage(0, new ArrayBuffer(1));
+        expect(spy).toHaveBeenCalledWith(
+          objectContaining2({
+            kind: "license",
+            mimeType: "audio/mp4",
+            contentType: "audio"
+          })
+        );
+      });
       it("does not measure a failed license exchange", async () => {
         licenseProvider.and.rejectWith(new Error("license failed"));
         const spy = createEventSpy(drmController, "loadSpanMeasured");
         drmController.setBufferingDrmInfo(drmInfo);
         await emitEncrypted(new Uint8Array([1, 2, 3]), "cenc");
         await emitMessage(0, new ArrayBuffer(1));
-        expect(spy).not.toHaveBeenCalled();
+        expect(spy).not.toHaveBeenCalledWith(
+          objectContaining2({ kind: "license" })
+        );
         errorSpy.calls.reset();
       });
+      it("measures key setup only for the first session of a track load", async () => {
+        licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
+        const spy = createEventSpy(drmController, "loadSpanMeasured");
+        drmController.setBufferingDrmInfo(drmInfo, { trackUri: "track-a" });
+        await emitEncrypted(new Uint8Array([1]), "cenc");
+        await emitEncrypted(new Uint8Array([2]), "cenc");
+        expect(mediaKeys.createSession).toHaveBeenCalledTimes(2);
+        await emitMessage(0, new ArrayBuffer(1));
+        await emitMessage(1, new ArrayBuffer(1));
+        const keySetupSpans = spy.calls.all().filter((call) => call.args[0].kind === "keySetup");
+        expect(keySetupSpans.length).toEqual(1);
+      });
       it("attributes the license span to the buffering track uri", async () => {
         licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
         const spy = createEventSpy(drmController, "loadSpanMeasured");
         drmController.setBufferingDrmInfo(drmInfo, { trackUri: "track-a" });
         await emitEncrypted(new Uint8Array([1, 2, 3]), "cenc");
         await emitMessage(0, new ArrayBuffer(1));
-        expect(spy).toHaveBeenCalledOnceWith(
+        expect(spy).toHaveBeenCalledWith(
           objectContaining2({
             kind: "license",
             trackUri: "track-a"
@@ -31606,16 +31809,10 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         expect(mediaKeys.createSession).toHaveBeenCalledTimes(2);
         await emitMessage(1, new ArrayBuffer(1));
         await emitMessage(0, new ArrayBuffer(1));
-        expect(spy).toHaveBeenCalledTimes(2);
-        expect(spy).toHaveBeenCalledWith(
-          objectContaining2({
-            kind: "license",
-            trackUri: "track-preloaded"
-          })
-        );
-        expect(spy).toHaveBeenCalledWith(
-          objectContaining2({ kind: "license", trackUri: "track-active" })
-        );
+        const licenseTrackUris = spy.calls.all().map((call) => call.args[0]).filter((span) => span.kind === "license").map((span) => span.trackUri);
+        expect(licenseTrackUris.length).toEqual(2);
+        expect(licenseTrackUris).toContain("track-preloaded");
+        expect(licenseTrackUris).toContain("track-active");
       });
     });
     describe("serverCertificate", () => {
@@ -33128,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();
     });
@@ -38396,105 +38621,101 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
       getSegment: () => Promise.resolve(null)
     };
   }
-  describe("filterTimelineQualities", () => {
-    const timeline = {
-      periods: [
-        {
-          startTime: 0,
-          endTime: 10,
-          qualities: [
-            createQuality2("audio", 128e3),
-            createQuality2("audio", 256e3),
-            createQuality2("video", 5e5)
-          ]
-        }
-      ],
+  function timelineOf2(qualities) {
+    return {
+      periods: [{ startTime: 0, endTime: 10, qualities: [...qualities] }],
       minBufferTime: 2,
       getAdBreaks: () => Promise.resolve([]),
       getDuration: () => Promise.resolve(Infinity)
     };
+  }
+  function contentTypesOf(timeline) {
+    return new Set(
+      timeline.periods[0].qualities.map((q) => q.metadata.contentType)
+    );
+  }
+  function throwEmpty() {
+    throw new Error("no qualities");
+  }
+  describe("filterTimelineQualities", () => {
+    const timeline = timelineOf2([
+      createQuality2("audio", 128e3),
+      createQuality2("audio", 256e3),
+      createQuality2("video", 5e5)
+    ]);
     it("returns the timeline unchanged when the filter is null", () => {
-      const result = filterTimelineQualities(
-        null,
-        () => {
-          throw new Error("empty");
-        },
-        timeline
-      );
+      const result = filterTimelineQualities(null, throwEmpty, timeline);
       expect(result).toBe(timeline);
     });
-    it("filters qualities by predicate", () => {
+    it("filters qualities by predicate while keeping every present stream", () => {
       const result = filterTimelineQualities(
-        (q) => q.contentType === "audio",
-        () => {
-          throw new Error("empty");
-        },
+        (q) => q.bandwidth !== 256e3,
+        throwEmpty,
         timeline
       );
       expect(result.periods[0].qualities.length).toBe(2);
-      expect(
-        result.periods[0].qualities.every(
-          (q) => q.metadata.contentType === "audio"
-        )
-      ).toBeTrue();
+      expect(contentTypesOf(result)).toEqual(/* @__PURE__ */ new Set(["audio", "video"]));
     });
     it("preserves minBufferTime", () => {
-      const result = filterTimelineQualities(
-        () => true,
-        () => {
-          throw new Error("empty");
-        },
-        timeline
-      );
+      const result = filterTimelineQualities(() => true, throwEmpty, timeline);
       expect(result.minBufferTime).toBe(2);
     });
     it("throws when filtering removes all qualities", () => {
+      expect(
+        () => filterTimelineQualities(() => false, throwEmpty, timeline)
+      ).toThrowError("no qualities");
+    });
+    it("throws when filtering drops a present video stream to zero", () => {
       expect(
         () => filterTimelineQualities(
-          () => false,
-          () => {
-            throw new Error("no qualities");
-          },
+          (q) => q.contentType === "audio",
+          throwEmpty,
           timeline
         )
       ).toThrowError("no qualities");
     });
+    it("throws when filtering drops a present audio stream to zero", () => {
+      expect(
+        () => filterTimelineQualities(
+          (q) => q.contentType === "video",
+          throwEmpty,
+          timeline
+        )
+      ).toThrowError("no qualities");
+    });
+    it("does not throw when losing only an optional text sidecar stream", () => {
+      const withText = timelineOf2([
+        createQuality2("audio", 128e3),
+        createQuality2("video", 5e5),
+        createQuality2("text", 1e3)
+      ]);
+      const result = filterTimelineQualities(
+        (q) => q.contentType !== "text",
+        throwEmpty,
+        withText
+      );
+      expect(contentTypesOf(result)).toEqual(/* @__PURE__ */ new Set(["audio", "video"]));
+    });
   });
   describe("filterTimelineQualitiesAsync", () => {
-    const timeline = {
-      periods: [
-        {
-          startTime: 0,
-          endTime: 10,
-          qualities: [
-            createQuality2("audio", 128e3),
-            createQuality2("video", 5e5)
-          ]
-        }
-      ],
-      minBufferTime: 2,
-      getAdBreaks: () => Promise.resolve([]),
-      getDuration: () => Promise.resolve(Infinity)
-    };
-    it("filters qualities by async predicate", async () => {
+    const timeline = timelineOf2([
+      createQuality2("audio", 128e3),
+      createQuality2("audio", 256e3),
+      createQuality2("video", 5e5)
+    ]);
+    it("filters qualities by async predicate while keeping every present stream", async () => {
       const result = await filterTimelineQualitiesAsync(
-        (q) => Promise.resolve(q.contentType === "audio"),
-        () => {
-          throw new Error("empty");
-        },
+        (q) => Promise.resolve(q.bandwidth !== 256e3),
+        throwEmpty,
         timeline
       );
-      expect(result.periods[0].qualities.length).toBe(1);
-      expect(result.periods[0].qualities[0].metadata.contentType).toBe(
-        "audio"
-      );
+      expect(result.periods[0].qualities.length).toBe(2);
+      expect(contentTypesOf(result)).toEqual(/* @__PURE__ */ new Set(["audio", "video"]));
     });
     it("preserves minBufferTime", async () => {
       const result = await filterTimelineQualitiesAsync(
         () => Promise.resolve(true),
-        () => {
-          throw new Error("empty");
-        },
+        throwEmpty,
         timeline
       );
       expect(result.minBufferTime).toBe(2);
@@ -38503,13 +38724,33 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
       await expectAsync(
         filterTimelineQualitiesAsync(
           () => Promise.resolve(false),
-          () => {
-            throw new Error("no qualities");
-          },
+          throwEmpty,
+          timeline
+        )
+      ).toBeRejectedWithError("no qualities");
+    });
+    it("throws when filtering drops a present video stream to zero", async () => {
+      await expectAsync(
+        filterTimelineQualitiesAsync(
+          (q) => Promise.resolve(q.contentType === "audio"),
+          throwEmpty,
           timeline
         )
       ).toBeRejectedWithError("no qualities");
     });
+    it("does not throw when losing only an optional text sidecar stream", async () => {
+      const withText = timelineOf2([
+        createQuality2("audio", 128e3),
+        createQuality2("video", 5e5),
+        createQuality2("text", 1e3)
+      ]);
+      const result = await filterTimelineQualitiesAsync(
+        (q) => Promise.resolve(q.contentType !== "text"),
+        throwEmpty,
+        withText
+      );
+      expect(contentTypesOf(result)).toEqual(/* @__PURE__ */ new Set(["audio", "video"]));
+    });
   });
 
   // test/unit/streaming/mediaTimelineLanguageFilter.test.ts
@@ -39341,7 +39582,8 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         expect(track2.qualities).toEqual([qualityMetadata]);
         expect(track2.qualitiesUnfiltered).toEqual([qualityMetadata]);
       });
-      it("fails fast when a required content type is entirely filtered out", async () => {
+      it("plays the surviving content type when another is entirely filtered out", async () => {
+        deps.contentTypesValue.value = Promise.resolve(/* @__PURE__ */ new Set(["video"]));
         const videoQuality2 = __spreadProps(__spreadValues({}, createEmptyMediaQualityMetadata()), {
           contentType: "video",
           qualityId: "v1"
@@ -39365,10 +39607,10 @@ ${(_a3 = this.failedResult.failedExpectations[0]) == null ? void 0 : _a3.message
         });
         track2 = createTrack();
         await flushPromises();
-        expect(track2.error).toEqual(any14(MediaUnsupportedError));
-        expect(track2.error.code).toBe(
-          "no-playable-audio"
-        );
+        expect(track2.error).toBeNull();
+        expect(track2.contentTypes).toEqual(/* @__PURE__ */ new Set(["video"]));
+        expect(getStream("video")).not.toBeNull();
+        expect(getStream("audio")).toBeNull();
       });
       it("reads qualities from the filtered timeline but qualitiesUnfiltered from the raw one", async () => {
         const makeTimeline = (qualities) => ({
@@ -47894,6 +48136,25 @@ x`);
       expect(withinMin(mid, 1, [low, mid])).toBe(true);
       expect(withinMin(low, 0, [low, mid])).toBe(false);
     });
+    it("keeps the highest when every rate (of three) is below the floor", () => {
+      const low = audioQuality2([16e3]);
+      const mid = audioQuality2([24e3]);
+      const high = audioQuality2([32e3]);
+      expect(withinMin(high, 2, [low, mid, high])).toBe(true);
+      expect(withinMin(mid, 1, [low, mid, high])).toBe(false);
+      expect(withinMin(low, 0, [low, mid, high])).toBe(false);
+    });
+    it("keeps the highest below-floor rate when no platform max is reported", () => {
+      capabilities.sampleRate = null;
+      const low = audioQuality2([16e3]);
+      const high = audioQuality2([32e3]);
+      expect(withinMin(high, 1, [low, high])).toBe(true);
+      expect(withinMin(low, 0, [low, high])).toBe(false);
+    });
+    it("keeps a single audio rendition below the floor", () => {
+      const only = audioQuality2([24e3]);
+      expect(withinMin(only, 0, [only])).toBe(true);
+    });
     it("ignores non-audio qualities in the floor fallback", () => {
       const audio = audioQuality2([24e3]);
       const video = createEmptyMediaQualityMetadata();
@@ -47903,6 +48164,55 @@ x`);
       expect(withinMin(video, 1, [audio, video])).toBe(true);
     });
   });
+  describe("withinAudioSampleRateRange straddling an empty band", () => {
+    let capabilities;
+    beforeEach(() => {
+      setUserAgent("Chrome");
+      capabilities = new MockCapabilities();
+      capabilities.sampleRate = 48e3;
+    });
+    function audioQuality2(rate) {
+      const quality = createEmptyMediaQualityMetadata();
+      quality.contentType = "audio";
+      quality.audioSamplingRate = rate;
+      return quality;
+    }
+    function within(metadata, index, array2) {
+      return withinAudioSampleRateRange(
+        { capabilities, minSampleRate: 44100 },
+        metadata,
+        index,
+        array2
+      );
+    }
+    it("keeps the highest decodable rate when one is below the floor and one above the ceiling", () => {
+      const low = audioQuality2([22050]);
+      const high = audioQuality2([96e3]);
+      expect(within(low, 0, [low, high])).toBe(true);
+      expect(within(high, 1, [low, high])).toBe(false);
+    });
+    it("keeps the below-floor rate when the ceiling matches the output device rate", () => {
+      capabilities.sampleRate = 44100;
+      const low = audioQuality2([22050]);
+      const high = audioQuality2([48e3]);
+      expect(within(low, 0, [low, high])).toBe(true);
+      expect(within(high, 1, [low, high])).toBe(false);
+    });
+    it("still prefers an in-band rate over the straddle fallback", () => {
+      const low = audioQuality2([22050]);
+      const mid = audioQuality2([44100]);
+      const high = audioQuality2([96e3]);
+      expect(within(mid, 1, [low, mid, high])).toBe(true);
+      expect(within(low, 0, [low, mid, high])).toBe(false);
+      expect(within(high, 2, [low, mid, high])).toBe(false);
+    });
+    it("keeps the lowest when every rate is above the ceiling", () => {
+      const low = audioQuality2([88200]);
+      const high = audioQuality2([96e3]);
+      expect(within(low, 0, [low, high])).toBe(true);
+      expect(within(high, 1, [low, high])).toBe(false);
+    });
+  });
 
   // test/unit/track/hls/buildHlsMediaTimeline.test.ts
   describe("buildHlsMediaTimeline", () => {
@@ -53347,6 +53657,7 @@ x`);
     let depFactories;
     let player;
     let mockOptions;
+    const loggerRef2 = useMockLogger();
     polyfillCustomEvent();
     beforeEach(() => {
       mockOptions = { media: new MockHTMLAudioElement() };
@@ -53571,6 +53882,40 @@ x`);
         });
         expect(spy).not.toHaveBeenCalled();
       });
+      it("logs each republished span at the verbose level with formatted times", () => {
+        loggerRef2.value.logLevel = 0 /* VERBOSE */;
+        deps.drmController.dispatch("loadSpanMeasured", {
+          kind: "license",
+          startTime: 1e3,
+          endTime: 3500,
+          trackUri: "track-a",
+          mimeType: "audio/mp4",
+          contentType: "audio"
+        });
+        expect(loggerRef2.value.verbose).toHaveBeenCalledOnceWith(
+          player,
+          "loadSpan",
+          {
+            kind: "license",
+            trackUri: "track-a",
+            mimeType: "audio/mp4",
+            contentType: "audio",
+            startTime: (/* @__PURE__ */ new Date(1e3)).toISOString(),
+            endTime: (/* @__PURE__ */ new Date(3500)).toISOString(),
+            durationMs: "2500.00"
+          }
+        );
+      });
+      it("does not format or log a span when the verbose level is off", () => {
+        loggerRef2.value.logLevel = 1 /* DEBUG */;
+        deps.drmController.dispatch("loadSpanMeasured", {
+          kind: "license",
+          startTime: 1e3,
+          endTime: 3500,
+          trackUri: "track-a"
+        });
+        expect(loggerRef2.value.verbose).not.toHaveBeenCalled();
+      });
     });
     it("reloads the current track on a codecUnsupported event", () => {
       const trackController = deps.trackController;
@@ -54816,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"
@@ -54845,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);
       });
     });
   });
@@ -55574,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();
@@ -56208,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"
             }
           ])