@amazon/vinyl 1.1.1 → 2.0.0

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

@@ -76,6 +76,8 @@ describe('SegmentControllerImpl', () => {
                 },
             ],
             minBufferTime: 10,
+            getAdBreaks: () => Promise.resolve([]),
+            getDuration: () => Promise.resolve(100),
         };
         const mockQualitySelector = {
             selectQuality: () => 0,
@@ -114,6 +116,16 @@ describe('SegmentControllerImpl', () => {
         expect(segmentProvider.options).toEqual(expectedOptions);
         segmentProvider.dispose();
     });
+    it('tags its logPrefix with the content type, not undefined', () => {
+        // Regression: the tag reads a param-property assigned after super(), so
+        // logPrefix is set in the constructor body, not an eager _undefined.
+        const audio = new SegmentControllerImpl(mockDeps, 'audio');
+        const video = new SegmentControllerImpl(mockDeps, 'video');
+        expect(audio.logPrefix).toMatch(/^Segment_audio\//);
+        expect(video.logPrefix).toMatch(/^Segment_video\//);
+        audio.dispose();
+        video.dispose();
+    });
     describe('activate and deactivate', () => {
         it('changes active state', () => {
             segmentController.activate();
@@ -230,6 +242,8 @@ describe('SegmentControllerImpl', () => {
                         },
                     ],
                     minBufferTime: 10,
+                    getAdBreaks: () => Promise.resolve([]),
+                    getDuration: () => Promise.resolve(110),
                 };
                 timelineData.value = Promise.resolve(extendedTimeline);
                 await fillPrefetch();
@@ -275,6 +289,18 @@ describe('SegmentControllerImpl', () => {
                 await clock.tick(PREFETCH_POLL_THROTTLE);
                 expect(segmentProvider.getSegment).not.toHaveBeenCalled();
             });
+            describe('but the controller is disposed', () => {
+                it('does not log the error or set the error state', () => {
+                    // A prefetch error can settle after teardown, e.g. when
+                    // dispose() runs between the failure resolving and this
+                    // handler being invoked. A disposed controller should stay
+                    // quiet rather than log a now-irrelevant failure.
+                    segmentController.dispose();
+                    segmentController['prefetchErrorHandler'](error);
+                    expect(loggerRef.value.error).not.toHaveBeenCalled();
+                    expect(segmentController.error).toBeNull();
+                });
+            });
         });
         describe('and the error is silent', () => {
             let mockSegmentReference;
@@ -330,6 +356,8 @@ describe('SegmentControllerImpl', () => {
                     },
                 ],
                 minBufferTime: 10,
+                getAdBreaks: () => Promise.resolve([]),
+                getDuration: () => Promise.resolve(100),
             });
             // segmentController is for 'audio', but only 'video' qualities exist
             expect(await segmentController.getSegment(5)).toBeNull();
@@ -505,6 +533,47 @@ describe('SegmentControllerImpl', () => {
             });
         });
     });
+    describe('load span metrics', () => {
+        it('measures the first init and media segment fetch', async () => {
+            const spy = createEventSpy(segmentController, 'loadSpanMeasured');
+            await segmentController.getSegment(0);
+            await flushPromises();
+            expect(spy).toHaveBeenCalledWith(objectContaining({
+                kind: 'initSegment',
+                startTime: any(Number),
+                endTime: any(Number),
+            }));
+            expect(spy).toHaveBeenCalledWith(objectContaining({
+                kind: 'firstSegment',
+                startTime: any(Number),
+                endTime: any(Number),
+            }));
+        });
+        it('measures each span only once', async () => {
+            const spy = createEventSpy(segmentController, 'loadSpanMeasured');
+            await segmentController.getSegment(0);
+            await segmentController.getSegment(20);
+            await flushPromises();
+            const kinds = spy.calls.allArgs().map(([span]) => span.kind);
+            expect(kinds.filter((k) => k === 'initSegment').length).toBe(1);
+            expect(kinds.filter((k) => k === 'firstSegment').length).toBe(1);
+        });
+        it('re-arms after a failed fetch so a recovered load is measured', async () => {
+            let failCount = 0;
+            mockSegmentDataProvider.and.callFake(() => ++failCount <= 2
+                ? Promise.reject(new Error('failed segment'))
+                : Promise.resolve(new ArrayBuffer(0)));
+            const spy = createEventSpy(segmentController, 'loadSpanMeasured');
+            await expectAsync(segmentController.getSegment(0)).toBeRejected();
+            await flushPromises();
+            expect(spy).not.toHaveBeenCalled();
+            segmentController.reset();
+            await segmentController.getSegment(0);
+            await flushPromises();
+            expect(spy).toHaveBeenCalledWith(objectContaining({ kind: 'initSegment' }));
+            expect(spy).toHaveBeenCalledWith(objectContaining({ kind: 'firstSegment' }));
+        });
+    });
     describe('minBufferTime', () => {
         describe('when the requested time is within minBufferTime of the segment end', () => {
             describe('and there is a next segment', () => {
@@ -582,39 +651,6 @@ describe('SegmentControllerImpl', () => {
             expect(segmentController.startTime).toBe(4);
         });
     });
-    describe('duration', () => {
-        it('delegates to the media timeline', async () => {
-            expect(await segmentController.getDuration()).toBe(100);
-        });
-        it('returns null for empty timeline', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [],
-                minBufferTime: 0,
-            });
-            expect(await segmentController.getDuration()).toBeNull();
-        });
-        it('returns null when last period has Infinity endTime', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [
-                    {
-                        startTime: 0,
-                        endTime: Infinity,
-                        qualities: [],
-                    },
-                ],
-                minBufferTime: 0,
-            });
-            expect(await segmentController.getDuration()).toBeNull();
-        });
-        it('uses getDuration from timeline when provided', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [],
-                minBufferTime: 0,
-                getDuration: () => Promise.resolve(42),
-            });
-            expect(await segmentController.getDuration()).toBe(42);
-        });
-    });
     describe('fetchedTime', () => {
         it('returns the number of seconds currently prefetched', async () => {
             segmentController.configure(defaultConfigOptions);

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

@@ -3,8 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { expectTypeStrictlyEquals } from '@amazon/vinyl-util/browserTestUtil';
-describe('ALL_TRACK_EVENTS', () => {
-    it('provides a comprehensive list of all track events', () => {
+describe('ALL_STREAMING_EVENTS', () => {
+    it('provides a comprehensive list of all streaming events', () => {
         expectTypeStrictlyEquals(true);
     });
 });

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

@@ -566,6 +566,189 @@ describe('QualitySelectorImpl', () => {
             expect(selector.selectQuality(videoQualities, videoState)).toEqual(0);
         });
     });
+    describe('maxBandwidth', () => {
+        const qualities = [
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 1000,
+                bandwidthTotal: 1000,
+                qualityId: '0',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 500,
+                bandwidthTotal: 500,
+                qualityId: '1',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 100,
+                bandwidthTotal: 100,
+                qualityId: '2',
+            },
+        ];
+        const prefetchState = {
+            fetchedTime: 0,
+            previousQuality: null,
+            active: false,
+        };
+        beforeEach(() => {
+            // Plenty of bandwidth for the highest quality.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 5000;
+        });
+        it('caps the selectable quality to the configured bandwidth', () => {
+            options.value = { ...options.value, maxBandwidth: 500 };
+            // Highest quality at or below the cap is index 1 (500).
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(1);
+        });
+        it('falls back to the lowest quality when all exceed the cap', () => {
+            options.value = { ...options.value, maxBandwidth: 50 };
+            // No quality fits — selectQuality falls back to the last (lowest) entry.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(2);
+        });
+        it('pins to the lowest quality when set to 0', () => {
+            options.value = { ...options.value, maxBandwidth: 0 };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(2);
+        });
+        it('treats null as no cap', () => {
+            options.value = { ...options.value, maxBandwidth: null };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(0);
+        });
+        it('does not raise the bandwidth budget above the network estimate', () => {
+            // Network estimate is well below the cap; cap should not raise it.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 600;
+            options.value = { ...options.value, maxBandwidth: 100_000 };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(1);
+        });
+        it('has no effect when strategy is LOWEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.LOWEST,
+                maxBandwidth: 100_000,
+            };
+            // LOWEST always returns the last index, regardless of the cap.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(qualities.length - 1);
+        });
+        it('has no effect when strategy is HIGHEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.HIGHEST,
+                maxBandwidth: 50,
+            };
+            // HIGHEST always returns 0, regardless of the cap.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(0);
+        });
+    });
+    describe('maxHeight / maxWidth', () => {
+        const videoQualities = [
+            {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: 'video',
+                bandwidth: 1000,
+                bandwidthTotal: 1000,
+                width: 1920,
+                height: 1080,
+                qualityId: '1080p',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: 'video',
+                bandwidth: 500,
+                bandwidthTotal: 500,
+                width: 1280,
+                height: 720,
+                qualityId: '720p',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                contentType: 'video',
+                bandwidth: 100,
+                bandwidthTotal: 100,
+                width: 640,
+                height: 360,
+                qualityId: '360p',
+            },
+        ];
+        const prefetchState = {
+            fetchedTime: 0,
+            previousQuality: null,
+            active: false,
+        };
+        beforeEach(() => {
+            // Plenty of bandwidth for the highest quality.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 5000;
+        });
+        it('excludes video qualities above the max height', () => {
+            options.value = { ...options.value, maxHeight: 720 };
+            // 1080p is excluded; highest remaining is 720p (index 1).
+            expect(selector.selectQuality(videoQualities, prefetchState)).toEqual(1);
+        });
+        it('excludes video qualities above the max width', () => {
+            options.value = { ...options.value, maxWidth: 1280 };
+            // 1920-wide is excluded; highest remaining is 1280-wide (index 1).
+            expect(selector.selectQuality(videoQualities, prefetchState)).toEqual(1);
+        });
+        it('applies both width and height caps together', () => {
+            options.value = { ...options.value, maxWidth: 700, maxHeight: 400 };
+            // Only 360p (640x360) fits both caps.
+            expect(selector.selectQuality(videoQualities, prefetchState)).toEqual(2);
+        });
+        it('keeps the smallest quality when none fit within the cap', () => {
+            options.value = { ...options.value, maxHeight: 100 };
+            // No video fits; falls back to the smallest (last) quality so video
+            // still plays.
+            expect(selector.selectQuality(videoQualities, prefetchState)).toEqual(2);
+        });
+        it('treats null as no cap', () => {
+            options.value = {
+                ...options.value,
+                maxHeight: null,
+                maxWidth: null,
+            };
+            expect(selector.selectQuality(videoQualities, prefetchState)).toEqual(0);
+        });
+        it('does not restrict audio qualities by resolution', () => {
+            const audioQualities = videoQualities.map((q) => ({
+                ...q,
+                contentType: 'audio',
+                width: null,
+                height: null,
+            }));
+            options.value = { ...options.value, maxHeight: 100 };
+            // Audio ignores the resolution cap; highest is selected.
+            expect(selector.selectQuality(audioQualities, prefetchState)).toEqual(0);
+        });
+        it('treats qualities with unknown dimensions as within the cap', () => {
+            const unknownDims = videoQualities.map((q) => ({
+                ...q,
+                width: null,
+                height: null,
+            }));
+            options.value = { ...options.value, maxHeight: 100 };
+            // Unknown height cannot be filtered out; highest is selected.
+            expect(selector.selectQuality(unknownDims, prefetchState)).toEqual(0);
+        });
+        it('has no effect when strategy is HIGHEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.HIGHEST,
+                maxHeight: 100,
+            };
+            // HIGHEST always returns 0, regardless of the cap.
+            expect(selector.selectQuality(videoQualities, prefetchState)).toEqual(0);
+        });
+        it('does not pin the previous quality when it exceeds a lowered cap', () => {
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 5000;
+            options.value = { ...options.value, maxHeight: 720 };
+            // Previously on 1080p with ample buffer; the lowered cap forces a
+            // switch down rather than pinning the now-too-large previous quality.
+            expect(selector.selectQuality(videoQualities, {
+                fetchedTime: 100, // >= highBufferThreshold
+                previousQuality: videoQualities[0], // 1080p
+                active: true,
+            })).toEqual(1);
+        });
+    });
     describe('toString', () => {
         it('returns a string', () => {
             expect(selector.toString()).toContain('QualitySelectorImpl');

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

@@ -4,7 +4,7 @@
  */
 import { flushPromises, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
 import { MockMediaSourceController, MockPlaybackController, MockSegmentController, MockSourceBufferController, } from '@amazon/vinyl/vinylTestUtil';
-import { BufferingControllerImpl, clearSourceBufferQuota, createEmptyMediaQualityMetadata, DEFAULT_MAX_APPEND_SIZE, DURATION_PADDING, getSourceBufferQuota, LIVE_DURATION, MIN_APPEND_SIZE, POLL_BUFFER_THROTTLE, QUOTA_REACHED_SCALE, SEGMENT_START_AFFORDANCE, } from '@amazon/vinyl';
+import { BufferingControllerImpl, clearCodecDenylist, clearSourceBufferQuota, createEmptyMediaQualityMetadata, DEFAULT_MAX_APPEND_SIZE, getDenylistedCodecs, getSourceBufferQuota, MIN_APPEND_SIZE, POLL_BUFFER_THROTTLE, QUOTA_REACHED_SCALE, SEGMENT_START_AFFORDANCE, SourceBufferError, } from '@amazon/vinyl';
 import { Abort, AbortError, Deferred, floorToNearest, LogLevel, } from '@amazon/vinyl-util';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
 var any = jasmine.any;
@@ -86,7 +86,6 @@ describe('BufferingControllerImpl', () => {
     }
     beforeEach(() => {
         mediaSourceController = new MockMediaSourceController();
-        mediaSourceController.duration = Number.NaN;
         playbackController = new MockPlaybackController();
         segmentController = new MockSegmentController();
         segmentController.getSegment.and.callFake((time) => {
@@ -227,6 +226,27 @@ 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({
@@ -452,6 +472,34 @@ describe('BufferingControllerImpl', () => {
                 expect(segmentController.getSegment).toHaveBeenCalledTimes(1);
             });
         });
+        describe('then seeking to an unbuffered position', () => {
+            it('reopens buffering and appends from the new position', async () => {
+                // Replace the default controller with one that buffers ahead.
+                bufferingController.dispose();
+                // Buffer two segments, then the stream ends.
+                setSegmentList([1, 1]);
+                bufferingController = createBufferingController({
+                    minBuffer: 100,
+                });
+                bufferingController.activate();
+                await open();
+                await clock.tick(0, 0, 0, 0);
+                expect(bufferingController.bufferingEnded).toBeTrue();
+                expect(sourceBufferController.buffered.ranges).toEqual([
+                    [0, 20],
+                ]);
+                // More content becomes available; seek beyond the buffered range.
+                segmentController.getSegment.and.callFake((time) => Promise.resolve(createMockSegment(time)));
+                segmentController.getSegment.calls.reset();
+                playbackController.currentTime = 50;
+                playbackController.dispatch('seeking', {});
+                await clock.tick(0, 0, 0, 0);
+                // The reopen flag lets buffering resume despite the ended state.
+                expect(bufferingController.bufferingEnded).toBeFalse();
+                expect(segmentController.getSegment).toHaveBeenCalled();
+                expect(sourceBufferController.buffered.getRangeAt(50, 0.5)).not.toBeNull();
+            });
+        });
     });
     describe('when append throws a QuotaExceededError', () => {
         afterEach(() => {
@@ -503,52 +551,72 @@ describe('BufferingControllerImpl', () => {
             });
         });
     });
-    describe('when media source provided is already open', () => {
-        it('polls on construction', async () => {
-            await open();
+    describe('when append fails to decode a codec (SourceBufferError)', () => {
+        afterEach(() => {
+            clearCodecDenylist();
+        });
+        /**
+         * Configures segments whose quality carries the given mimeType so the
+         * codec-fallback path (which reads bufferingQuality.mimeType) can run.
+         */
+        function setSegmentsWithMimeType(mimeType) {
+            const segments = Array.from({ length: 20 }, (_, i) => {
+                const segment = createMockSegment(i * 10, 1);
+                segment.quality.contentType = 'video';
+                segment.quality.mimeType = mimeType;
+                return Promise.resolve(segment);
+            });
+            segmentController.getSegment.and.returnValues(...segments, Promise.resolve(null));
+            segmentController.dispatch('change', {});
+        }
+        it('denylists the codec and emits codecUnsupported instead of erroring', async () => {
+            const mimeType = 'video/mp4; codecs="hvc1.1"';
+            setSegmentsWithMimeType(mimeType);
             bufferingController = createBufferingController();
             bufferingController.activate();
-            await nextPollImmediate();
-            expect(bufferingController.getBufferedTime()).toBe(10);
+            const codecUnsupported = createEventSpy(bufferingController, 'codecUnsupported');
+            sourceBufferController.append.and.rejectWith(new SourceBufferError());
+            await open();
+            expect(bufferingController.error).toBeNull();
+            expect(codecUnsupported).toHaveBeenCalledOnceWith({
+                mimeType,
+                contentType: 'video',
+            });
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
         });
-    });
-    describe('duration', () => {
-        beforeEach(() => {
+        it('errors when the failing quality has no mimeType', async () => {
+            // Default segments carry no mimeType, so the fallback cannot
+            // identify a codec and the error is fatal.
+            setSegmentList(Array(20).fill(1), 0, 'video');
             bufferingController = createBufferingController();
             bufferingController.activate();
+            sourceBufferController.append.and.rejectWith(new SourceBufferError());
+            await open();
+            expect(bufferingController.error).toBeInstanceOf(SourceBufferError);
+            expect(getDenylistedCodecs()).toEqual([]);
         });
-        describe('when the media source is open and the segment controller is not updating', () => {
-            it('is set to the segment controller provided value', async () => {
-                segmentController.getDuration.and.resolveTo(33);
-                await open();
-                expect(mediaSourceController.duration).toEqual(33 + DURATION_PADDING);
-            });
-            describe('when segment controller duration resolves to null', () => {
-                it('sets mediaSource duration to LIVE_DURATION', async () => {
-                    segmentController.getDuration.and.resolveTo(null);
-                    await open();
-                    expect(mediaSourceController.duration).toEqual(LIVE_DURATION);
-                });
-            });
+        it('errors when the codec is already denylisted (no alternative)', async () => {
+            const mimeType = 'video/mp4; codecs="hvc1.1"';
+            setSegmentsWithMimeType(mimeType);
+            bufferingController = createBufferingController();
+            bufferingController.activate();
+            sourceBufferController.append.and.rejectWith(new SourceBufferError());
+            // First failure: recoverable (denylist + codecUnsupported).
+            await open();
+            expect(bufferingController.error).toBeNull();
+            // A repeat failure for the same, already-denylisted codec is not
+            // recoverable and falls through to the error state.
+            await clock.tick(...Array(5).fill(0));
+            expect(bufferingController.error).toBeInstanceOf(SourceBufferError);
         });
-        describe('when segment controller emits a change event', () => {
-            it('refreshes duration', async () => {
-                segmentController.getDuration.and.resolveTo(42);
-                await open();
-                expect(mediaSourceController.duration).toEqual(42 + DURATION_PADDING);
-                segmentController.getDuration.and.resolveTo(54);
-                segmentController.dispatch('change', {});
-                await nextPollImmediate();
-                expect(mediaSourceController.duration).toEqual(54 + DURATION_PADDING);
-            });
-            describe('and mediaSource is not open', () => {
-                it('does nothing', () => {
-                    // Closed
-                    segmentController.getDuration.and.resolveTo(52);
-                    segmentController.dispatch('change', {});
-                    expect(mediaSourceController.duration).toBeNaN();
-                });
-            });
+    });
+    describe('when media source provided is already open', () => {
+        it('polls on construction', async () => {
+            await open();
+            bufferingController = createBufferingController();
+            bufferingController.activate();
+            await nextPollImmediate();
+            expect(bufferingController.getBufferedTime()).toBe(10);
         });
     });
     describe('playbackQuality', () => {
@@ -583,11 +651,13 @@ describe('BufferingControllerImpl', () => {
                 expect(bufferingController.playbackQuality?.qualityId).toBe('q1');
                 expect(playbackQualityChange).toHaveBeenCalledTimes(1);
                 playbackQualityChange.calls.reset();
-                // time < 20 will still be q1
-                await setTime(12);
+                // Playback advances while buffering stays ahead of the playhead
+                // (a playhead that outruns the buffer is treated as a disconnect
+                // and clears). time < 20 will still be q1.
+                await setTime(9);
                 expect(playbackQualityChange).not.toHaveBeenCalled();
                 // 20-30s will now be buffered but q1 is still playing
-                await setTime(19);
+                await setTime(18);
                 expect(playbackQualityChange).not.toHaveBeenCalled();
                 // now moving onto q2
                 await setTime(20);
@@ -635,12 +705,14 @@ describe('BufferingControllerImpl', () => {
                     }),
                 });
                 playbackQualityChange.calls.reset();
-                // Change back to the q1
+                // A backwards seek to a buffered position keeps the buffered
+                // data and does not trigger a quality change.
                 await setTime(changeTime - 1);
                 // A backwards time update can only happen after a seek
                 playbackController.dispatch('seeking', {});
                 await nextPollImmediate();
-                expect(bufferingController.playbackQuality?.qualityId).toBe('q1');
+                expect(playbackQualityChange).not.toHaveBeenCalled();
+                expect(bufferingController.playbackQuality?.qualityId).toBe('q2');
             });
         });
     });
@@ -692,25 +764,15 @@ describe('BufferingControllerImpl', () => {
                     }),
                 });
                 bufferingQualityChange.calls.reset();
-                // Go back to time 0, buffering first quality
+                // A backwards seek to time 0 keeps the buffered data (no clear).
+                // The buffering frontier is unchanged, so bufferingQuality stays
+                // q2 and no change event fires.
                 playbackController.currentTime = 0;
                 playbackController.dispatch('seeking', {});
                 await flushPromises();
-                expect(bufferingQualityChange).toHaveBeenCalledOnceWith({
-                    previous: objectContaining({
-                        qualityId: 'q2',
-                    }),
-                    current: null,
-                });
-                bufferingQualityChange.calls.reset();
                 await nextPollImmediate();
-                expect(bufferingQualityChange).toHaveBeenCalledOnceWith({
-                    previous: null,
-                    current: objectContaining({
-                        qualityId: 'q1',
-                    }),
-                });
-                expect(bufferingController.bufferingQuality?.qualityId).toBe('q1');
+                expect(bufferingQualityChange).not.toHaveBeenCalled();
+                expect(bufferingController.bufferingQuality?.qualityId).toBe('q2');
             });
         });
     });