@amazon/vinyl 3.0.0 → 3.1.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,12 +2,12 @@
  * 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';
+import { Abort, MediaUnsupportedError } from '@amazon/vinyl-util';
 var any = jasmine.any;
 describe('MseTrack', () => {
     useMockLogger();
@@ -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,38 @@ describe('MseTrack', () => {
             expect(track.qualities).toEqual([qualityMetadata]);
             expect(track.qualitiesUnfiltered).toEqual([qualityMetadata]);
         });
+        it('fails fast when a required content type is entirely filtered out', async () => {
+            // contentTypes (from the manifest) is {audio, video}, but the
+            // transformed timeline has only a video quality — audio was fully
+            // filtered. The audio stream could never create a source buffer, so
+            // the track must fail rather than stall on the readyToAppend wait.
+            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).toEqual(any(MediaUnsupportedError));
+            expect(track.error.code).toBe('no-playable-audio');
+        });
         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 +990,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 +1014,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/track/TrackController.test.js

@@ -480,6 +480,66 @@ describe('TrackControllerImpl', () => {
             });
         });
     });
+    describe('guards async ad continuations after dispose', () => {
+        it('does not dispatch trackEnded when disposed before the postroll resolves', async () => {
+            let resolvePostroll = () => { };
+            deps.adController.enterPostroll.and.returnValue(new Promise((res) => {
+                resolvePostroll = res;
+            }));
+            trackController.load(...createLoadOptionsList(2));
+            await clock.tick(); // activate the first track
+            const endedSpy = jasmine.createSpy('trackEnded');
+            trackController.on('trackEnded', endedSpy);
+            deps.playbackController.dispatch('ended', {}); // onEnded → enterPostroll pending
+            trackController.dispose();
+            disposed = true;
+            resolvePostroll(null); // .then guarded by interrupted()
+            await clock.tick();
+            expect(endedSpy).not.toHaveBeenCalled();
+        });
+        it('does not advance the queue when disposed within the trackEnded handler', async () => {
+            trackController.load(...createLoadOptionsList(2));
+            await clock.tick(); // activate the first track
+            trackController.on('trackEnded', () => {
+                trackController.dispose(); // interrupt before the queued next()
+                disposed = true;
+            });
+            const activatedSpy = jasmine.createSpy('trackActivated');
+            trackController.on('trackActivated', activatedSpy);
+            deps.playbackController.dispatch('ended', {});
+            await clock.tick();
+            // The queued next() is skipped: interrupted() is true in the microtask.
+            expect(activatedSpy).not.toHaveBeenCalled();
+        });
+        it('swallows a postroll rejection after dispose', async () => {
+            let rejectPostroll = () => { };
+            deps.adController.enterPostroll.and.returnValue(new Promise((_res, rej) => {
+                rejectPostroll = rej;
+            }));
+            trackController.load(...createLoadOptionsList(1));
+            await clock.tick();
+            deps.playbackController.dispatch('ended', {});
+            trackController.dispose();
+            disposed = true;
+            rejectPostroll(new Error('late')); // .catch guarded by interrupted()
+            await clock.tick();
+            expect(trackController.disposed).toBeTrue();
+        });
+        it('does not activate when disposed before the preroll rejects', async () => {
+            let rejectPreroll = () => { };
+            deps.adController.enterPreroll.and.returnValue(new Promise((_res, rej) => {
+                rejectPreroll = rej;
+            }));
+            const activatedSpy = jasmine.createSpy('trackActivated');
+            trackController.on('trackActivated', activatedSpy);
+            trackController.load(...createLoadOptionsList(1)); // activation deferred behind enterPreroll
+            trackController.dispose();
+            disposed = true;
+            rejectPreroll(new Error('late')); // .catch guarded by interrupted()
+            await clock.tick();
+            expect(activatedSpy).not.toHaveBeenCalled();
+        });
+    });
     describe('unload', () => {
         it('unloads the active track and clears the queue', () => {
             trackController.load(...createLoadOptionsList(3));
@@ -813,7 +873,7 @@ describe('TrackControllerImpl', () => {
             expect(() => trackController.reset()).not.toThrow();
         });
     });
-    describe('reset', () => {
+    describe('reset (hard)', () => {
         it('delegates a hard reset to the current track', async () => {
             trackController.load(...createLoadOptionsList(1));
             await clock.tick();
@@ -1308,6 +1368,42 @@ describe('TrackControllerImpl', () => {
             expect(trackActivated).toHaveBeenCalledWith(objectContaining({ track: objectContaining({ uri: main.uri }) }));
             expect(trackActivated).toHaveBeenCalledBefore(queueEnded);
         });
+        it('ends the track after an empty postroll where no ad ever began', async () => {
+            // An empty postroll (a break that resolves to no ads) completes
+            // without any adEntered, so the content track is never deactivated
+            // and stays active. onEnded has already deferred the trackEnded to
+            // adBreakCompleted, so this must still end the track and the queue
+            // rather than hang.
+            const [main] = createLoadOptionsList(1);
+            trackController.load(main);
+            await clock.tick(); // content activates (stays active — no ad plays)
+            expect(trackController.activeTrack.active).toBeTrue();
+            const trackEnded = createEventSpy(trackController, 'trackEnded');
+            const queueEnded = createEventSpy(trackController, 'queueEnded');
+            deps.adController.dispatch('adBreakCompleted', {
+                adBreak: adBreak('postroll'),
+                resumePosition: 0,
+            });
+            await clock.tick();
+            expect(trackEnded).toHaveBeenCalledWith(objectContaining({
+                track: objectContaining({ uri: main.uri }),
+            }));
+            expect(queueEnded).toHaveBeenCalled();
+        });
+        it('advances to the next track after an empty postroll where no ad ever began', async () => {
+            const list = createLoadOptionsList(2);
+            trackController.load(...list);
+            await clock.tick(); // content activates and stays active
+            expect(trackController.activeTrack.active).toBeTrue();
+            const trackEnded = createEventSpy(trackController, 'trackEnded');
+            deps.adController.dispatch('adBreakCompleted', {
+                adBreak: adBreak('postroll'),
+                resumePosition: 0,
+            });
+            await clock.tick();
+            expect(trackEnded).toHaveBeenCalledWith(objectContaining({ track: any(Object) }));
+            expect(trackController.activeTrack?.uri).toBe(list[1].uri);
+        });
         it('does not treat a completed midroll ad as the track ending', async () => {
             trackController.load(...createLoadOptionsList(1));
             const trackEnded = createEventSpy(trackController, 'trackEnded');

package/dist/unit/types/current/track/createSegmentDataProvider.test.js

@@ -208,6 +208,24 @@ describe('createSegmentDataProvider', () => {
                 serviceId: 'example.com',
             }));
         });
+        it('does not report transfer entry when aborted before the metrics read', async () => {
+            const abort = new Abort();
+            const response = new Response(new ArrayBuffer(10));
+            spyOn(response, 'arrayBuffer').and.callFake(() => {
+                // Abort after the fetch resolves, before the metrics read.
+                abort.abort();
+                return Promise.resolve(new ArrayBuffer(10));
+            });
+            mockRequester.request.and.resolveTo(response);
+            const provider = createSegmentDataProvider(deps, {
+                url: 'https://example.com/seg0.mp4',
+                reportDownlinkMetrics: true,
+            });
+            const promise = provider(abort);
+            await clock.tick(2);
+            await promise;
+            expect(networkMetricsControllerRef.value.addDownlinkTransferEntry).not.toHaveBeenCalled();
+        });
     });
     describe('when reportDownlinkMetrics is false', () => {
         it('does not report transfer entry', async () => {