@amazon/vinyl 3.0.1 → 3.2.0

package/dist/unit/types/current/playback/createStallMonitor.test.js

@@ -0,0 +1,125 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createStallMonitor, StallEndedReason, } from '@amazon/vinyl';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import { useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+describe('createStallMonitor', () => {
+    const clock = useMockTime();
+    let host;
+    let onStallEntered;
+    let onStallEnded;
+    let stop;
+    beforeEach(() => {
+        host = new EventHostImpl();
+        onStallEntered = jasmine.createSpy('onStallEntered');
+        onStallEnded = jasmine.createSpy('onStallEnded');
+    });
+    afterEach(() => stop?.());
+    function monitor(overrides = {}) {
+        stop = createStallMonitor(host, { onStallEntered, onStallEnded }, overrides);
+    }
+    /** Advances the mock clock by `n` default (0.25s) poll intervals. */
+    async function poll(n) {
+        for (let i = 0; i < n; i++)
+            await clock.tick(0.25);
+    }
+    it('does not report a stall before playback is observed', async () => {
+        monitor();
+        // No 'playing' has been observed (e.g. initial load / awaiting a seek).
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+    it('reports a stall once the play head is frozen past the threshold', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(3); // 0.75s < 1s threshold
+        expect(onStallEntered).not.toHaveBeenCalled();
+        await poll(1); // 1s
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('honors a configurable threshold', async () => {
+        monitor({ stallThreshold: 2 });
+        host.dispatch('playing', {});
+        await poll(4); // 1s < 2s
+        expect(onStallEntered).not.toHaveBeenCalled();
+        await poll(4); // 2s
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('does not report a stall while timeUpdates keep arriving', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        for (let i = 0; i < 10; i++) {
+            await poll(2); // 0.5s, under the threshold
+            host.dispatch('timeUpdate', { previous: i, current: i + 1 });
+        }
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+    it('ends a stall with reason "playing" when the play head advances, measuring from the last timeUpdate', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 0, current: 1 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        await poll(4); // frozen another 1s (total 2s)
+        host.dispatch('timeUpdate', { previous: 1, current: 2 }); // resume
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        const info = onStallEnded.calls.mostRecent().args[0];
+        expect(info.reason).toBe(StallEndedReason.PLAYING);
+        expect(info.duration).toBeCloseTo(2, 1);
+    });
+    for (const [event, reason] of [
+        ['pause', StallEndedReason.PAUSE],
+        ['seeking', StallEndedReason.SEEKING],
+        ['emptied', StallEndedReason.EMPTIED],
+    ]) {
+        it(`ends a stall with reason "${reason}" on ${event}`, async () => {
+            monitor();
+            host.dispatch('playing', {});
+            await poll(4); // stallEntered
+            expect(onStallEntered).toHaveBeenCalledTimes(1);
+            host.dispatch(event, {});
+            expect(onStallEnded).toHaveBeenCalledTimes(1);
+            expect(onStallEnded.calls.mostRecent().args[0].reason).toBe(reason);
+        });
+    }
+    it('ends a stall with reason "playing" when a playing event fires (resume without a timeUpdate)', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(4); // stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // A 'playing' event (rather than a timeUpdate) signals the resume.
+        host.dispatch('playing', {});
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        expect(onStallEnded.calls.mostRecent().args[0].reason).toBe(StallEndedReason.PLAYING);
+    });
+    it('suspends detection after a seek until playback is observed again', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('seeking', {}); // suspends; observedPlaying = false
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+        // Once playback is observed again, detection resumes.
+        host.dispatch('playing', {});
+        await poll(4);
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('reports each stall/recovery cycle', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        await poll(4);
+        host.dispatch('timeUpdate', { previous: 0, current: 1 }); // resume 1
+        await poll(4);
+        host.dispatch('timeUpdate', { previous: 1, current: 2 }); // resume 2
+        expect(onStallEntered).toHaveBeenCalledTimes(2);
+        expect(onStallEnded).toHaveBeenCalledTimes(2);
+    });
+    it('stops reporting after disposal', async () => {
+        monitor();
+        host.dispatch('playing', {});
+        stop();
+        await poll(8);
+        expect(onStallEntered).not.toHaveBeenCalled();
+    });
+});

package/dist/unit/types/current/streaming/ContentStream.test.js

@@ -58,17 +58,6 @@ describe('ContentStreamImpl', () => {
             bufferingController.dispatch('error', { error, target });
             expect(spy).toHaveBeenCalledWith({ error, target });
         });
-        it('redispatches hasDataChange from bufferingController', () => {
-            const spy = createEventSpy(contentStream, 'hasDataChange');
-            const event = { previous: false, current: true };
-            bufferingController.dispatch('hasDataChange', event);
-            expect(spy).toHaveBeenCalledWith(event);
-        });
-        it('exposes hasData from the bufferingController', () => {
-            expect(contentStream.hasData).toBeFalse();
-            bufferingController.hasData = true;
-            expect(contentStream.hasData).toBeTrue();
-        });
     });
     describe('preload', () => {
         it('configures segmentController with startTime and prefetchPriority', () => {

package/dist/unit/types/current/streaming/MseTrack.test.js

@@ -2,10 +2,10 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, MseTrack, PLAYHEAD_NUDGE, SEEKING_STALL_TIME_CHECK, } from '@amazon/vinyl';
+import { createEmptyMediaQualityMetadata, MseTrack, } from '@amazon/vinyl';
 import { createMockDashDependencies, } from '@amazon/vinyl/vinylTestUtil';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
-import { flushPromises, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+import { flushPromises } from '@amazon/vinyl-util/browserTestUtil';
 import { externalDependencies } from '@amazon/vinyl-di';
 import { Abort } from '@amazon/vinyl-util';
 var any = jasmine.any;
@@ -413,73 +413,6 @@ describe('MseTrack', () => {
             expect(track.bufferingEnded).toBe(false);
         });
     });
-    describe('stalled-seek recovery nudge', () => {
-        const clock = useMockTime();
-        function fillStream(stream) {
-            stream.hasData = true;
-            stream.dispatch('hasDataChange', { previous: false, current: true });
-        }
-        async function setup() {
-            deps.playbackController.seekTo.and.resolveTo(void 0);
-            track = createTrack();
-            await awaitContentTypes();
-            return { audio: getAudioStream(), video: getVideoStream() };
-        }
-        it('nudges the playhead when all streams have data but the seek is still stuck', async () => {
-            const { audio, video } = await setup();
-            deps.playbackController.seeking = true;
-            deps.playbackController.currentTime = 30;
-            fillStream(audio);
-            // Only one stream has data — nothing scheduled yet.
-            fillStream(video);
-            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
-            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
-            expect(deps.playbackController.seekTo).toHaveBeenCalledOnceWith(30 + PLAYHEAD_NUDGE, 0);
-        });
-        it('does not nudge if the seek completes before the check fires', async () => {
-            const { audio, video } = await setup();
-            deps.playbackController.seeking = true;
-            fillStream(audio);
-            fillStream(video);
-            deps.playbackController.seeking = false;
-            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
-            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
-        });
-        it('does not nudge until every stream has data', async () => {
-            const { audio } = await setup();
-            deps.playbackController.seeking = true;
-            fillStream(audio);
-            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
-            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
-        });
-        it('does not nudge if a stream loses its data before the check fires', async () => {
-            const { audio, video } = await setup();
-            deps.playbackController.seeking = true;
-            fillStream(audio);
-            fillStream(video);
-            // A stream's buffer was cleared during the wait window.
-            video.hasData = false;
-            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
-            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
-        });
-        it('does not nudge when not seeking', async () => {
-            const { audio, video } = await setup();
-            deps.playbackController.seeking = false;
-            fillStream(audio);
-            fillStream(video);
-            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
-            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
-        });
-        it('does not nudge after the track is disposed', async () => {
-            const { audio, video } = await setup();
-            deps.playbackController.seeking = true;
-            fillStream(audio);
-            fillStream(video);
-            track.dispose();
-            await clock.tick(SEEKING_STALL_TIME_CHECK * 1000);
-            expect(deps.playbackController.seekTo).not.toHaveBeenCalled();
-        });
-    });
     describe('checkBufferingEnded', () => {
         it('calls endOfStream and dispatches bufferingEnded when all streams are done', async () => {
             track = createTrack();
@@ -652,6 +585,41 @@ describe('MseTrack', () => {
             expect(track.qualities).toEqual([qualityMetadata]);
             expect(track.qualitiesUnfiltered).toEqual([qualityMetadata]);
         });
+        it('plays the surviving content type when another is entirely filtered out', async () => {
+            // The content types now come from the FILTERED timeline: with every
+            // audio rendition filtered, only 'video' is required. No audio stream
+            // is created, so the load is never stranded waiting for an audio
+            // source buffer that will never arrive, and the track does not error.
+            deps.contentTypesValue.value = Promise.resolve(new Set(['video']));
+            const videoQuality = {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: 'video',
+                qualityId: 'v1',
+            };
+            setTimeline({
+                periods: [
+                    {
+                        startTime: 0,
+                        endTime: 100,
+                        qualities: [
+                            {
+                                metadata: videoQuality,
+                                getSegment: () => Promise.resolve(null),
+                            },
+                        ],
+                    },
+                ],
+                minBufferTime: 2,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(Infinity),
+            });
+            track = createTrack();
+            await flushPromises();
+            expect(track.error).toBeNull();
+            expect(track.contentTypes).toEqual(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 () => {
             // The transformed timeline is filtered (e.g. by preferred audio
             // language) down to one quality; the raw timeline keeps them all.
@@ -1025,10 +993,6 @@ describe('MseTrack', () => {
                 name: 'audio language',
                 apply: () => (deps.audio.value = jaAudio),
             },
-            {
-                name: 'allowedContentTypes',
-                apply: () => (deps.allowedContentTypes.value = allowed),
-            },
             {
                 name: 'audio descriptive',
                 apply: () => (deps.audio.value = descriptiveAudio),
@@ -1053,6 +1017,18 @@ describe('MseTrack', () => {
                 });
             });
         }
+        describe('when allowedContentTypes changes', () => {
+            // It only affects the content-type set, which flows through
+            // contentTypesValue -> setContentTypes. Reloading directly here too
+            // would double hard-reset and seek to 0.
+            it('does not reload directly', () => {
+                const clearSpy = spyOn(track, 'clearPrefetch');
+                const resetSpy = spyOn(track, 'reset');
+                deps.allowedContentTypes.value = allowed;
+                expect(clearSpy).not.toHaveBeenCalled();
+                expect(resetSpy).not.toHaveBeenCalled();
+            });
+        });
         describe('when abr resolution restrictions change', () => {
             it('clears prefetch (without a rebuild) when maxHeight changes', () => {
                 const clearSpy = spyOn(track, 'clearPrefetch');

package/dist/unit/types/current/streaming/abr/QualitySelectorImpl.test.js

@@ -333,7 +333,7 @@ describe('QualitySelectorImpl', () => {
             });
         });
     });
-    describe('when options change', () => {
+    describe('when options change after construction', () => {
         it('merges set options with defaults', () => {
             options.value = {
                 highBufferThreshold: 32,

package/dist/unit/types/current/streaming/buffering/BufferingController.test.js

@@ -226,27 +226,6 @@ describe('BufferingControllerImpl', () => {
             expect(sourceBufferController.buffered.ranges).toEqual([[40, 60]]);
         });
     });
-    describe('hasData', () => {
-        beforeEach(() => {
-            bufferingController = createBufferingController();
-            bufferingController.activate();
-        });
-        it('flips true when the buffer fills and false when cleared', async () => {
-            const spy = createEventSpy(bufferingController, 'hasDataChange');
-            expect(bufferingController.hasData).toBeFalse();
-            setSegmentList([1]);
-            await open();
-            expect(bufferingController.hasData).toBeTrue();
-            expect(spy).toHaveBeenCalledWith({ previous: false, current: true });
-            // Stop the segment provider so the post-clear re-poll can't re-fill.
-            segmentController.getSegment.and.returnValue(Promise.resolve(null));
-            spy.calls.reset();
-            bufferingController.clear();
-            await nextPollImmediate();
-            expect(bufferingController.hasData).toBeFalse();
-            expect(spy).toHaveBeenCalledWith({ previous: true, current: false });
-        });
-    });
     describe('when segments exceed max append size', () => {
         beforeEach(() => {
             bufferingController = createBufferingController({

package/dist/unit/types/current/streaming/createDefaultMediaTimelineTransformer.test.js

@@ -4,6 +4,7 @@
  */
 import { createDefaultMediaTimelineTransformer, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
 import { data } from '@amazon/vinyl-observable';
+import { setUserAgent } from '@amazon/vinyl-util';
 import { MockCapabilities, MockDrmController, } from '@amazon/vinyl/vinylTestUtil';
 function createQuality(overrides) {
     return {
@@ -332,6 +333,138 @@ describe('createDefaultMediaTimelineTransformer', () => {
         expect(result.periods[0].qualities[0].metadata.qualityId).toBe('ja');
         unsub();
     });
+    it('disables the sampling-rate filter via audio options at runtime', async () => {
+        // Output device at 44.1kHz: the 96kHz rendition is normally dropped
+        // (a 44.1kHz alternative exists, so the keep-lowest fallback declines).
+        capabilities.sampleRate = 44_100;
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'a44',
+                            audioSamplingRate: [44_100],
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'a96',
+                            audioSamplingRate: [96_000],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const options = data({ audio: { disableSampleRateFilter: false } });
+        const transformed = createDefaultMediaTimelineTransformer({
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options,
+        });
+        const unsub = transformed.onData(() => { });
+        const ids = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        // Filter on: the 96kHz rendition is dropped.
+        expect(ids(await transformed.value)).toEqual(['a44']);
+        // Filter off: both renditions are kept.
+        options.value = { audio: { disableSampleRateFilter: true } };
+        expect(ids(await transformed.value)).toEqual(['a44', 'a96']);
+        unsub();
+    });
+    it('honors audio.maxSampleRate over the reported rate at runtime', async () => {
+        // Non-Firefox: Firefox hard-caps at 48kHz regardless of maxSampleRate.
+        setUserAgent('Chrome');
+        // AudioContext reports 48kHz, so the 96kHz rendition is dropped.
+        capabilities.sampleRate = 48_000;
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'a48',
+                            audioSamplingRate: [48_000],
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'a96',
+                            audioSamplingRate: [96_000],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const options = data({ audio: {} });
+        const transformed = createDefaultMediaTimelineTransformer({
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options,
+        });
+        const unsub = transformed.onData(() => { });
+        const ids = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        expect(ids(await transformed.value)).toEqual(['a48']);
+        // Raise the cap to 96kHz: the 96kHz rendition is now kept.
+        options.value = { audio: { maxSampleRate: 96_000 } };
+        expect(ids(await transformed.value)).toEqual(['a48', 'a96']);
+        unsub();
+    });
+    it('applies audio.minSampleRate as a soft floor at runtime', async () => {
+        capabilities.sampleRate = 192_000; // max cap drops nothing
+        const timeline = {
+            periods: [
+                {
+                    startTime: 0,
+                    endTime: 100,
+                    qualities: [
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'a48',
+                            audioSamplingRate: [48_000],
+                        }),
+                        createQuality({
+                            contentType: 'audio',
+                            mimeType: 'audio/mp4',
+                            qualityId: 'a24',
+                            audioSamplingRate: [24_000],
+                        }),
+                    ],
+                },
+            ],
+            minBufferTime: 2,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(Infinity),
+        };
+        const options = data({ audio: {} });
+        const transformed = createDefaultMediaTimelineTransformer({
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options,
+        });
+        const unsub = transformed.onData(() => { });
+        const ids = (t) => t.periods[0].qualities.map((q) => q.metadata.qualityId);
+        expect(ids(await transformed.value)).toEqual(['a48', 'a24']);
+        // Floor at 48kHz: the 24kHz rendition is dropped.
+        options.value = { audio: { minSampleRate: 48_000 } };
+        expect(ids(await transformed.value)).toEqual(['a48']);
+        unsub();
+    });
     it('preserves minBufferTime', async () => {
         const timeline = {
             periods: [

package/dist/unit/types/current/streaming/mediaTimelineFilter.test.js

@@ -13,81 +13,87 @@ function createQuality(contentType, bandwidth) {
         getSegment: () => Promise.resolve(null),
     };
 }
-describe('filterTimelineQualities', () => {
-    const timeline = {
-        periods: [
-            {
-                startTime: 0,
-                endTime: 10,
-                qualities: [
-                    createQuality('audio', 128000),
-                    createQuality('audio', 256000),
-                    createQuality('video', 500000),
-                ],
-            },
-        ],
+function timelineOf(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 = timelineOf([
+        createQuality('audio', 128000),
+        createQuality('audio', 256000),
+        createQuality('video', 500000),
+    ]);
     it('returns the timeline unchanged when the filter is null', () => {
         // A null predicate (e.g. no language preference) is a no-op.
-        const result = filterTimelineQualities(null, () => {
-            throw new Error('empty');
-        }, timeline);
+        const result = filterTimelineQualities(null, throwEmpty, timeline);
         expect(result).toBe(timeline);
     });
-    it('filters qualities by predicate', () => {
-        const result = filterTimelineQualities((q) => q.contentType === 'audio', () => {
-            throw new Error('empty');
-        }, timeline);
+    it('filters qualities by predicate while keeping every present stream', () => {
+        const result = filterTimelineQualities((q) => q.bandwidth !== 256000, 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(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, () => {
-            throw new Error('no qualities');
-        }, timeline)).toThrowError('no qualities');
+        expect(() => filterTimelineQualities(() => false, throwEmpty, timeline)).toThrowError('no qualities');
+    });
+    it('throws when filtering drops a present video stream to zero', () => {
+        expect(() => filterTimelineQualities((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 = timelineOf([
+            createQuality('audio', 128000),
+            createQuality('video', 500000),
+            createQuality('text', 1000),
+        ]);
+        const result = filterTimelineQualities((q) => q.contentType !== 'text', throwEmpty, withText);
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
 });
 describe('filterTimelineQualitiesAsync', () => {
-    const timeline = {
-        periods: [
-            {
-                startTime: 0,
-                endTime: 10,
-                qualities: [
-                    createQuality('audio', 128000),
-                    createQuality('video', 500000),
-                ],
-            },
-        ],
-        minBufferTime: 2,
-        getAdBreaks: () => Promise.resolve([]),
-        getDuration: () => Promise.resolve(Infinity),
-    };
-    it('filters qualities by async predicate', async () => {
-        const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType === 'audio'), () => {
-            throw new Error('empty');
-        }, timeline);
-        expect(result.periods[0].qualities.length).toBe(1);
-        expect(result.periods[0].qualities[0].metadata.contentType).toBe('audio');
+    const timeline = timelineOf([
+        createQuality('audio', 128000),
+        createQuality('audio', 256000),
+        createQuality('video', 500000),
+    ]);
+    it('filters qualities by async predicate while keeping every present stream', async () => {
+        const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.bandwidth !== 256000), throwEmpty, timeline);
+        expect(result.periods[0].qualities.length).toBe(2);
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
     it('preserves minBufferTime', async () => {
-        const result = await filterTimelineQualitiesAsync(() => Promise.resolve(true), () => {
-            throw new Error('empty');
-        }, timeline);
+        const result = await filterTimelineQualitiesAsync(() => Promise.resolve(true), throwEmpty, timeline);
         expect(result.minBufferTime).toBe(2);
     });
     it('throws when filtering removes all qualities', async () => {
-        await expectAsync(filterTimelineQualitiesAsync(() => Promise.resolve(false), () => {
-            throw new Error('no qualities');
-        }, timeline)).toBeRejectedWithError('no qualities');
+        await expectAsync(filterTimelineQualitiesAsync(() => Promise.resolve(false), 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 = timelineOf([
+            createQuality('audio', 128000),
+            createQuality('video', 500000),
+            createQuality('text', 1000),
+        ]);
+        const result = await filterTimelineQualitiesAsync((q) => Promise.resolve(q.contentType !== 'text'), throwEmpty, withText);
+        expect(contentTypesOf(result)).toEqual(new Set(['audio', 'video']));
     });
 });