@amazon/vinyl 3.0.0 → 3.1.0

package/dist/unit/types/current/track/dash/DashMediaQualityMetadataResolver.test.js

@@ -422,7 +422,7 @@ describe('getPeriodSortedBandwidths', () => {
     });
 });
 describe('estimatePeakBandwidth', () => {
-    it('pairs proportionally when video has more qualities than audio', () => {
+    it('pairs each tier with the cheapest peer in its bucket', () => {
         // language=XML
         const m = parseDashManifest(`<?xml version="1.0" ?>
             <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
@@ -441,20 +441,51 @@ describe('estimatePeakBandwidth', () => {
             </MPD>`);
         const as0 = m.MPD.Period[0].AdaptationSet[0];
         const as1 = m.MPD.Period[0].AdaptationSet[1];
-        // video sorted: [4000, 3000, 2000, 1000], audio sorted: [200, 100]
-        // v1 pos=0/3=0.00 → audio index round(0.00*1)=0 → 200. total=4200
+        // video sorted: [4000, 3000, 2000, 1000], audio sorted: [200, 100].
+        // Video's two audio buckets: v1,v2 → a1(200); v3,v4 → a2(100).
         expect(estimatePeakBandwidth(as0.Representation[0], 'video')).toBe(4200);
-        // v2 pos=1/3=0.33 → audio index round(0.33*1)=0 → 200. total=3200
         expect(estimatePeakBandwidth(as0.Representation[1], 'video')).toBe(3200);
-        // v3 pos=2/3=0.67 → audio index round(0.67*1)=1 → 100. total=2100
         expect(estimatePeakBandwidth(as0.Representation[2], 'video')).toBe(2100);
-        // v4 pos=3/3=1.00 → audio index round(1.00*1)=1 → 100. total=1100
         expect(estimatePeakBandwidth(as0.Representation[3], 'video')).toBe(1100);
-        // a1 pos=0/1=0 → video index round(0*3)=0 → 4000. total=4200
-        expect(estimatePeakBandwidth(as1.Representation[0], 'audio')).toBe(4200);
-        // a2 pos=1/1=1 → video index round(1*3)=3 → 1000. total=1100
+        // Audio's two video buckets: a1's bucket is v1,v2 so it pairs with the
+        // cheapest of those (v2=3000); a2's bucket is v3,v4 (cheapest v4=1000).
+        expect(estimatePeakBandwidth(as1.Representation[0], 'audio')).toBe(3200);
         expect(estimatePeakBandwidth(as1.Representation[1], 'audio')).toBe(1100);
     });
+    it('does not pin a small stream to its lowest tier across a finer peer', () => {
+        // 2 audio tiers alongside 10 video tiers: the top audio must stay
+        // affordable across the whole top half of video, not only at the very
+        // top. (Regression: it was priced with the single top video.)
+        // language=XML
+        const m = parseDashManifest(`<?xml version="1.0" ?>
+            <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
+                <Period>
+                    <AdaptationSet mimeType="video/mp4" codecs="avc1.640015">
+                        <Representation bandwidth="10000" id="v1"/>
+                        <Representation bandwidth="9000" id="v2"/>
+                        <Representation bandwidth="8000" id="v3"/>
+                        <Representation bandwidth="7000" id="v4"/>
+                        <Representation bandwidth="6000" id="v5"/>
+                        <Representation bandwidth="5000" id="v6"/>
+                        <Representation bandwidth="4000" id="v7"/>
+                        <Representation bandwidth="3000" id="v8"/>
+                        <Representation bandwidth="2000" id="v9"/>
+                        <Representation bandwidth="1000" id="v10"/>
+                    </AdaptationSet>
+                    <AdaptationSet mimeType="audio/mp4" codecs="mp4a.40.2">
+                        <Representation bandwidth="200" id="a1"/>
+                        <Representation bandwidth="100" id="a2"/>
+                    </AdaptationSet>
+                </Period>
+            </MPD>`);
+        const audio = m.MPD.Period[0].AdaptationSet[1];
+        // Top audio's bucket is video[0..4]; it pairs with the cheapest of those
+        // (video[4]=6000), NOT video[0]=10000. So its total is 6200, keeping it
+        // affordable for the top half of video tiers.
+        expect(estimatePeakBandwidth(audio.Representation[0], 'audio')).toBe(6200);
+        // Bottom audio's bucket is video[5..9]; cheapest video[9]=1000 → 1100.
+        expect(estimatePeakBandwidth(audio.Representation[1], 'audio')).toBe(1100);
+    });
     it('returns bandwidth as-is for single content type periods', () => {
         // language=XML
         const m = parseDashManifest(`<?xml version="1.0" ?>
@@ -482,7 +513,7 @@ describe('estimatePeakBandwidth', () => {
             </MPD>`);
         expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[0].Representation[0], 'text')).toBe(50000);
     });
-    it('pairs proportionally with three content types', () => {
+    it('pairs with the cheapest peer bucket across three content types', () => {
         // language=XML
         const m = parseDashManifest(`<?xml version="1.0" ?>
             <MPD minBufferTime="PT0S" profiles="" xmlns="urn:mpeg:dash:schema:mpd:2011">
@@ -500,12 +531,13 @@ describe('estimatePeakBandwidth', () => {
                     </AdaptationSet>
                 </Period>
             </MPD>`);
-        // v1 pos=0 → audio[0]=200, text[0]=10. total=2210
+        // v1 → cheapest audio in its bucket (200) + cheapest text (10). total=2210
         expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[0].Representation[0], 'video')).toBe(2210);
-        // v2 pos=1 → audio[1]=100, text[0]=10. total=1110
+        // v2 → audio bucket cheapest (100) + text (10). total=1110
         expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[0].Representation[1], 'video')).toBe(1110);
-        // t1 pos=0 (only 1 text) → video[0]=2000, audio[0]=200. total=2210
-        expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[2].Representation[0], 'text')).toBe(2210);
+        // t1 is the only text tier, so its bucket spans every peer — it pairs
+        // with the cheapest video (1000) and cheapest audio (100). total=1110
+        expect(estimatePeakBandwidth(m.MPD.Period[0].AdaptationSet[2].Representation[0], 'text')).toBe(1110);
     });
     it('handles single quality per content type', () => {
         // language=XML

package/dist/unit/types/current/track/dash/createSegmentControllerFactory.test.js

@@ -22,5 +22,6 @@ describe('createSegmentControllerFactory', () => {
         });
         expect(controller).toEqual(jasmine.any(Object));
         expect(controller.options).toEqual(objectContaining({ prefetchActive: 100 }));
+        controller.dispose();
     });
 });

package/dist/unit/types/current/track/dash/timeline/DashRepresentationSegmentProvider.test.js

@@ -277,6 +277,120 @@ describe('createDashRepresentationSegmentProvider', () => {
             });
         });
     });
+    describe('when SegmentBase is a WebM stream', () => {
+        // Minimal EBML builders for a synthetic WebM init + Cues.
+        const vintSize = (n) => n < 0x80 ? [0x80 | n] : [0x40 | (n >> 8), n & 0xff];
+        const el = (id, content) => [
+            ...id,
+            ...vintSize(content.length),
+            ...content,
+        ];
+        const bytesToArrayBuffer = (bytes) => new Uint8Array(bytes).buffer;
+        // EBML header (5 bytes) then Segment(Info > TimecodeScale=1_000_000);
+        // the Segment data starts at offset 10, so cue positions are + 10.
+        const initBuffer = bytesToArrayBuffer([
+            ...el([0x1a, 0x45, 0xdf, 0xa3], []),
+            ...el([0x18, 0x53, 0x80, 0x67], el([0x15, 0x49, 0xa9, 0x66], el([0x2a, 0xd7, 0xb1], [0x0f, 0x42, 0x40]))),
+        ]);
+        const cuePoint = (time, pos) => el([0xbb], [
+            ...el([0xb3], time),
+            ...el([0xb7], [...el([0xf7], [0x01]), ...el([0xf1], pos)]),
+        ]);
+        // Cue 0 @ t=0 → cluster pos 100; cue 1 @ t=2000ms → cluster pos 200.
+        const cuesBuffer = bytesToArrayBuffer(el([0x1c, 0x53, 0xbb, 0x6b], [
+            ...cuePoint([0x00], [0x00, 0x64]),
+            ...cuePoint([0x07, 0xd0], [0x00, 0xc8]),
+        ]));
+        beforeEach(() => {
+            // WebM Cues don't carry the last segment's end, so a period end is
+            // required (VOD defines one).
+            manifest.MPD.mediaPresentationDuration = 60;
+            representation.BaseURL = [
+                { _content: 'https://example.com/v.webm' },
+            ];
+            representation.mimeType = 'video/webm';
+            representation.codecs = 'vp9';
+            representation.SegmentBase = {
+                indexRangeExact: false,
+                indexRange: [100, 199],
+                timescale: 1000000,
+                Initialization: { range: [0, 99] },
+            };
+            // The provider fetches the init and Cues ranges in parallel; return
+            // the matching buffer per Range header.
+            mockRequesterRef.value.request.and.callFake(((_input, init) => {
+                const range = init?.headers?.['Range'];
+                const body = range === 'bytes=0-99'
+                    ? initBuffer
+                    : range === 'bytes=100-199'
+                        ? cuesBuffer
+                        : new ArrayBuffer(0);
+                return Promise.resolve(new Response(body));
+            }));
+        });
+        it('creates a timeline from the WebM Cues', async () => {
+            const timeline = createTimeline();
+            // Prime the timeline (fetch init + Cues), then assert the segments.
+            await timeline.getSegment(0);
+            clearRequestCalls();
+            const info = await getSegmentRequestData(timeline);
+            expect(info).toEqual({
+                init: {
+                    qualityId: any(String),
+                    decoderId: any(String),
+                    mimeType: 'video/webm; codecs="vp9"',
+                    href: 'https://example.com/v.webm',
+                    serviceId: 'example.com',
+                    range: 'bytes=0-99',
+                },
+                segments: [
+                    {
+                        startTime: 0,
+                        endTime: 2,
+                        timestampOffset: 0,
+                        href: 'https://example.com/v.webm',
+                        serviceId: 'example.com',
+                        // segmentDataStart(10) + cue positions 100..200.
+                        range: 'bytes=110-209',
+                    },
+                    {
+                        startTime: 2,
+                        endTime: 60,
+                        timestampOffset: 2,
+                        href: 'https://example.com/v.webm',
+                        serviceId: 'example.com',
+                        // Last cluster runs open-ended to end of file.
+                        range: 'bytes=210-',
+                    },
+                ],
+            });
+        });
+        it('indexes WebM without an explicit SegmentBase timescale', async () => {
+            delete representation.SegmentBase
+                .timescale;
+            const timeline = createTimeline();
+            const segment = await timeline.getSegment(0);
+            expect(segment).not.toBeNull();
+            // Cue 0 at ticks 0 → 0s (TimecodeScale-derived ticks-per-second).
+            expect(segment.startTime).toBe(0);
+        });
+        it('throws when the period has no determinable end', () => {
+            delete manifest.MPD
+                .mediaPresentationDuration;
+            const timeline = createTimeline();
+            return expectAsync(timeline.getSegment(0)).toBeRejectedWithError(/mediaPresentationDuration or Period\.duration required/);
+        });
+        it('throws when the Cues contain no cue points', () => {
+            // A Cues element whose only CuePoint lacks a cluster position.
+            const emptyCues = bytesToArrayBuffer(el([0x1c, 0x53, 0xbb, 0x6b], el([0xbb], el([0xb3], [0x00]))));
+            mockRequesterRef.value.request.and.callFake(((_input, init) => {
+                const range = init?.headers?.['Range'];
+                return Promise.resolve(new Response(range === 'bytes=0-99' ? initBuffer : emptyCues));
+            }));
+            const timeline = createTimeline();
+            return expectAsync(timeline.getSegment(0)).toBeRejectedWithError(/Cues contained no cue points/);
+        });
+    });
     describe('when SegmentList is defined', () => {
         let segmentList;
         beforeEach(() => {

package/dist/unit/types/current/track/dash/util/mpd.test.js

@@ -146,6 +146,31 @@ describe('mpd utils', () => {
                 expect(calculatePeriodStart(manifest.MPD.Period[0])).toEqual(0);
             });
         });
+        describe('when period.start is absent but periods have durations', () => {
+            it('derives the start from the preceding period durations', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+</MPD>`);
+                expect(manifest.MPD.Period.map(calculatePeriodStart)).toEqual([
+                    0, 888.053, 1776.106,
+                ]);
+            });
+            it('inherits the previous start when the previous period has no duration', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+  <Period/>
+</MPD>`);
+                // The first period has neither start nor duration, so the
+                // second period cannot advance and inherits start 0.
+                expect(calculatePeriodStart(manifest.MPD.Period[1])).toEqual(0);
+            });
+        });
     });
     describe('getPeriodAtTime', () => {
         it('returns the period spanning the given presentation time', () => {
@@ -331,6 +356,18 @@ describe('mpd utils', () => {
                 expect(calculateDuration(manifest)).toBe(50);
             });
         });
+        describe('when only per-period durations are present', () => {
+            it('sums the period durations across the presentation', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" type="static" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+  <Period duration="888.053"/>
+</MPD>`);
+                expect(calculateDuration(manifest)).toBeCloseTo(2664.159, 3);
+            });
+        });
         describe('when MPD type is dynamic', () => {
             it('returns Infinity for live presentations', () => {
                 // language=XML

package/dist/unit/types/current/track/filters/resourceTypeFilter.test.js

@@ -22,6 +22,13 @@ describe('canPlayMimeType', () => {
         expect(canPlayMimeType({ capabilities }, metadata)).toBe(true);
         expect(capabilities.canPlayTypeMse).toHaveBeenCalledWith('audio/mp4; codecs="opus"');
     });
+    it('supports WebM when the browser reports support', () => {
+        capabilities.canPlayTypeMse.and.returnValue(true);
+        const metadata = createEmptyMediaQualityMetadata();
+        metadata.mimeType = 'video/webm; codecs="vp9"';
+        expect(canPlayMimeType({ capabilities }, metadata)).toBe(true);
+        expect(capabilities.canPlayTypeMse).toHaveBeenCalledWith('video/webm; codecs="vp9"');
+    });
     it('returns false for null mime type', () => {
         capabilities.canPlayTypeMse.and.returnValue(true);
         const metadata = createEmptyMediaQualityMetadata();

package/dist/unit/types/current/track/filters/sampleRateFilter.test.js

@@ -2,56 +2,61 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { supportsAudioSamplingRate, createEmptyMediaQualityMetadata, throwSamplingRatesUnsupported, } from '@amazon/vinyl';
+import { withinAudioSampleRateRange, createEmptyMediaQualityMetadata, throwSamplingRatesUnsupported, } from '@amazon/vinyl';
 import { MockCapabilities } from '@amazon/vinyl/vinylTestUtil';
 import { setUserAgent } from '@amazon/vinyl-util';
-describe('supportsAudioSamplingRate', () => {
+describe('withinAudioSampleRateRange', () => {
     let capabilities;
     beforeEach(() => {
         capabilities = new MockCapabilities();
         capabilities.sampleRate = 48_000;
     });
+    // The filter only gates audio content types, so gated fixtures must declare
+    // contentType 'audio' (the empty metadata defaults it to null).
+    function audioQuality(rate) {
+        const quality = createEmptyMediaQualityMetadata();
+        quality.contentType = 'audio';
+        quality.audioSamplingRate = rate;
+        return quality;
+    }
     describe('when browser is Firefox', () => {
         beforeEach(() => {
             setUserAgent('Firefox');
         });
         it('returns false when sample rate is above supported', () => {
-            const metadata = createEmptyMediaQualityMetadata();
-            metadata.audioSamplingRate = [96_000];
-            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+            const metadata = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, metadata, 0, [
                 metadata,
             ])).toBe(false);
         });
         it('returns false when sample rate is above 48kHz even if capabilities allows it', () => {
             capabilities.sampleRate = 96_000;
-            const metadata = createEmptyMediaQualityMetadata();
-            metadata.audioSamplingRate = [96_000];
-            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+            const metadata = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, metadata, 0, [
                 metadata,
             ])).toBe(false);
         });
         it('returns false even when all rates are above 48kHz (no fallback to lowest)', () => {
-            const low = createEmptyMediaQualityMetadata();
-            low.audioSamplingRate = [88_200];
-            const high = createEmptyMediaQualityMetadata();
-            high.audioSamplingRate = [96_000];
-            expect(supportsAudioSamplingRate({ capabilities }, low, 0, [low, high])).toBe(false);
-            expect(supportsAudioSamplingRate({ capabilities }, high, 1, [
+            const low = audioQuality([88_200]);
+            const high = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, low, 0, [
+                low,
+                high,
+            ])).toBe(false);
+            expect(withinAudioSampleRateRange({ capabilities }, high, 1, [
                 low,
                 high,
             ])).toBe(false);
         });
         it('returns true when sample rate is at or below supported', () => {
-            const metadata = createEmptyMediaQualityMetadata();
-            metadata.audioSamplingRate = [48_000];
-            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+            const metadata = audioQuality([48_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, metadata, 0, [
                 metadata,
             ])).toBe(true);
         });
         it('returns true when sample rate is not set', () => {
-            const metadata = createEmptyMediaQualityMetadata();
-            metadata.audioSamplingRate = null;
-            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+            const metadata = audioQuality(null);
+            expect(withinAudioSampleRateRange({ capabilities }, metadata, 0, [
                 metadata,
             ])).toBe(true);
         });
@@ -61,33 +66,82 @@ describe('supportsAudioSamplingRate', () => {
             setUserAgent('Chrome');
         });
         it('returns true when sample rate is at or below supported', () => {
-            const metadata = createEmptyMediaQualityMetadata();
-            metadata.audioSamplingRate = [48_000];
-            expect(supportsAudioSamplingRate({ capabilities }, metadata, 0, [
+            const metadata = audioQuality([48_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, metadata, 0, [
+                metadata,
+            ])).toBe(true);
+        });
+        it('keeps everything when there is no platform max to gauge support', () => {
+            capabilities.sampleRate = null;
+            const metadata = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, metadata, 0, [
                 metadata,
             ])).toBe(true);
         });
         it('returns false when sample rate is above supported and others are below', () => {
-            const low = createEmptyMediaQualityMetadata();
-            low.audioSamplingRate = [44_100];
-            const high = createEmptyMediaQualityMetadata();
-            high.audioSamplingRate = [96_000];
-            expect(supportsAudioSamplingRate({ capabilities }, high, 1, [
+            const low = audioQuality([44_100]);
+            const high = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, high, 1, [
                 low,
                 high,
             ])).toBe(false);
         });
         it('keeps lowest sample rate when all are above supported', () => {
-            const low = createEmptyMediaQualityMetadata();
-            low.audioSamplingRate = [88_200];
-            const high = createEmptyMediaQualityMetadata();
-            high.audioSamplingRate = [96_000];
-            expect(supportsAudioSamplingRate({ capabilities }, low, 0, [low, high])).toBe(true);
-            expect(supportsAudioSamplingRate({ capabilities }, high, 1, [
+            const low = audioQuality([88_200]);
+            const high = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, low, 0, [
+                low,
+                high,
+            ])).toBe(true);
+            expect(withinAudioSampleRateRange({ capabilities }, high, 1, [
                 low,
                 high,
             ])).toBe(false);
         });
+        it('an explicit maxSampleRate takes precedence — raising it keeps a higher rate', () => {
+            // AudioContext reports 48kHz, which would drop the 96kHz rendition.
+            capabilities.sampleRate = 48_000;
+            const low = audioQuality([48_000]);
+            const high = audioQuality([96_000]);
+            // Without an override, 96kHz is dropped (a 48kHz alternative exists).
+            expect(withinAudioSampleRateRange({ capabilities }, high, 1, [
+                low,
+                high,
+            ])).toBe(false);
+            // With maxSampleRate = 96kHz, it is kept.
+            expect(withinAudioSampleRateRange({ capabilities, maxSampleRate: 96_000 }, high, 1, [low, high])).toBe(true);
+        });
+        it('an explicit maxSampleRate takes precedence — lowering it drops a rate the platform allows', () => {
+            // AudioContext reports 192kHz, which would keep the 96kHz rendition.
+            capabilities.sampleRate = 192_000;
+            const low = audioQuality([48_000]);
+            const high = audioQuality([96_000]);
+            expect(withinAudioSampleRateRange({ capabilities }, high, 1, [
+                low,
+                high,
+            ])).toBe(true);
+            // Capping at 48kHz drops the 96kHz rendition and keeps the 48kHz one.
+            expect(withinAudioSampleRateRange({ capabilities, maxSampleRate: 48_000 }, high, 1, [low, high])).toBe(false);
+            expect(withinAudioSampleRateRange({ capabilities, maxSampleRate: 48_000 }, low, 0, [low, high])).toBe(true);
+        });
+        it('ignores non-audio qualities and keeps audio above the device rate', () => {
+            // Output device runs at 44.1kHz while the audio is standard 48kHz.
+            capabilities.sampleRate = 44_100;
+            const audio = audioQuality([48_000]);
+            // A co-present video quality is never gated and must not influence
+            // the audio keep-lowest fallback.
+            const video = createEmptyMediaQualityMetadata();
+            video.contentType = 'video';
+            video.audioSamplingRate = null;
+            expect(withinAudioSampleRateRange({ capabilities }, audio, 0, [
+                audio,
+                video,
+            ])).toBe(true);
+            expect(withinAudioSampleRateRange({ capabilities }, video, 1, [
+                audio,
+                video,
+            ])).toBe(true);
+        });
     });
     it('throws correct error', () => {
         try {
@@ -100,3 +154,51 @@ describe('supportsAudioSamplingRate', () => {
         }
     });
 });
+describe('withinAudioSampleRateRange minSampleRate floor', () => {
+    let capabilities;
+    beforeEach(() => {
+        capabilities = new MockCapabilities();
+        // High enough that the upper bound never interferes with these tests.
+        capabilities.sampleRate = 192_000;
+    });
+    function audioQuality(rate) {
+        const quality = createEmptyMediaQualityMetadata();
+        quality.contentType = 'audio';
+        quality.audioSamplingRate = rate;
+        return quality;
+    }
+    // minSampleRate is passed via the options arg alongside capabilities.
+    function withinMin(metadata, index, array) {
+        return withinAudioSampleRateRange({ capabilities, minSampleRate: 48_000 }, metadata, index, array);
+    }
+    it('passes through non-audio qualities', () => {
+        const video = createEmptyMediaQualityMetadata();
+        video.contentType = 'video';
+        expect(withinMin(video, 0, [video])).toBe(true);
+    });
+    it('keeps qualities with no sampling rate', () => {
+        const quality = audioQuality(null);
+        expect(withinMin(quality, 0, [quality])).toBe(true);
+    });
+    it('drops rates below the floor when a rate at or above it exists', () => {
+        const low = audioQuality([24_000]);
+        const high = audioQuality([48_000]);
+        expect(withinMin(high, 1, [low, high])).toBe(true);
+        expect(withinMin(low, 0, [low, high])).toBe(false);
+    });
+    it('keeps the highest when every rate is below the floor', () => {
+        const low = audioQuality([16_000]);
+        const mid = audioQuality([24_000]);
+        expect(withinMin(mid, 1, [low, mid])).toBe(true);
+        expect(withinMin(low, 0, [low, mid])).toBe(false);
+    });
+    it('ignores non-audio qualities in the floor fallback', () => {
+        const audio = audioQuality([24_000]); // below the floor
+        const video = createEmptyMediaQualityMetadata();
+        video.contentType = 'video';
+        video.audioSamplingRate = null;
+        // Below the 48kHz floor but the only audio → kept; video is ignored.
+        expect(withinMin(audio, 0, [audio, video])).toBe(true);
+        expect(withinMin(video, 1, [audio, video])).toBe(true);
+    });
+});

package/dist/unit/types/current/track/source/SourceObjectTrack.test.js

@@ -66,7 +66,7 @@ describe('SourceObjectTrack', () => {
         });
     });
 });
-describe('createSourceTrackFactory', () => {
+describe('createSourceTrackFactory (object)', () => {
     let trackFactory;
     beforeEach(() => {
         trackFactory = createSourceObjectTrackFactory({