@amazon/vinyl 3.1.0 → 3.2.0

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];
@@ -14017,6 +14014,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 +14183,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 +14228,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 +14273,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 +14286,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 +14425,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 +14449,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 +14479,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 +15214,7 @@ ${this.lastInitStack}` : "";
   // src/global/environment.ts
   var vinylVersion = parseVersion(
     /* istanbul ignore next */
-    "3.1.0"
+    "3.2.0"
   );
 
   // src/global/globalRef.ts
@@ -17743,6 +17780,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 +18141,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 +18159,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 +18179,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 +18255,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 +18363,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 +18462,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 +20574,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 +20675,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 +24098,7 @@ ${this.lastInitStack}` : "";
       playerRegistryRef.value.addPlayer(this);
       this.redispatchSubControllerEvents();
       this.redispatchCurrentTrackEvents();
+      this.initializeLoadSpanLogging();
       this.initializeAutoResetHandling();
     }
     get [Symbol.toStringTag]() {
@@ -24098,6 +24116,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(
@@ -31554,7 +31592,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 +31600,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 +31687,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", () => {
@@ -38396,105 +38471,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 +38574,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 +39432,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 +39457,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 +47986,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 +48014,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 +53507,7 @@ x`);
     let depFactories;
     let player;
     let mockOptions;
+    const loggerRef2 = useMockLogger();
     polyfillCustomEvent();
     beforeEach(() => {
       mockOptions = { media: new MockHTMLAudioElement() };
@@ -53571,6 +53732,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;