@amazon/vinyl 1.2.0 → 2.0.4

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

@@ -76,6 +76,7 @@ describe('SegmentControllerImpl', () => {
                 },
             ],
             minBufferTime: 10,
+            getAdBreaks: () => Promise.resolve([]),
             getDuration: () => Promise.resolve(100),
         };
         const mockQualitySelector = {
@@ -115,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();
@@ -231,6 +242,7 @@ describe('SegmentControllerImpl', () => {
                         },
                     ],
                     minBufferTime: 10,
+                    getAdBreaks: () => Promise.resolve([]),
                     getDuration: () => Promise.resolve(110),
                 };
                 timelineData.value = Promise.resolve(extendedTimeline);
@@ -277,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;
@@ -332,6 +356,7 @@ describe('SegmentControllerImpl', () => {
                     },
                 ],
                 minBufferTime: 10,
+                getAdBreaks: () => Promise.resolve([]),
                 getDuration: () => Promise.resolve(100),
             });
             // segmentController is for 'audio', but only 'video' qualities exist
@@ -508,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', () => {

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

@@ -639,6 +639,116 @@ describe('QualitySelectorImpl', () => {
             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, getSourceBufferQuota, 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;
@@ -226,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({
@@ -451,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(() => {
@@ -502,6 +551,65 @@ describe('BufferingControllerImpl', () => {
             });
         });
     });
+    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();
+            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');
+        });
+        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([]);
+        });
+        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 media source provided is already open', () => {
         it('polls on construction', async () => {
             await open();
@@ -543,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);
@@ -595,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');
             });
         });
     });
@@ -652,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');
             });
         });
     });

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

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { DURATION_PADDING, LIVE_DURATION, MediaSourceControllerImpl, MediaSourceError, } from '@amazon/vinyl';
-import { AbortError, Deferred } from '@amazon/vinyl-util';
+import { AbortError, Deferred, IllegalStateError, } from '@amazon/vinyl-util';
 import { flushPromises, implementEventFakes, mockEvent, MockMediaSource, MockSourceBuffer, } from '@amazon/vinyl-util/browserTestUtil';
 import { data } from '@amazon/vinyl-observable';
 var createSpy = jasmine.createSpy;
@@ -14,12 +14,14 @@ function createVodTimeline(duration = VOD_DURATION) {
     return {
         periods: [],
         minBufferTime: 0,
+        getAdBreaks: () => Promise.resolve([]),
         getDuration: () => Promise.resolve(duration),
     };
 }
 const liveTimeline = {
     periods: [],
     minBufferTime: 0,
+    getAdBreaks: () => Promise.resolve([]),
     getDuration: () => Promise.resolve(Infinity),
 };
 describe('MediaSourceControllerImpl', () => {
@@ -29,6 +31,7 @@ describe('MediaSourceControllerImpl', () => {
     let mockMediaSource;
     let deps;
     let controller;
+    let objectUrl;
     function open() {
         mockMediaSource.readyState = 'open';
         mockMediaSource.dispatchEvent(mockEvent('sourceopen'));
@@ -46,21 +49,46 @@ describe('MediaSourceControllerImpl', () => {
             contentTypesValue,
             mediaTimelineTransformed,
         };
+        // activate() now owns media source creation and the object URL, so the
+        // real URL APIs (which reject non-Blob args under Node) are stubbed.
+        spyOn(URL, 'createObjectURL').and.returnValue('blob:test-url');
+        spyOn(URL, 'revokeObjectURL');
         controller = new MediaSourceControllerImpl(deps);
+        objectUrl = controller.activate();
     });
     afterEach(() => {
         controller.dispose();
     });
-    describe('constructor', () => {
+    describe('activate', () => {
         it('creates media source using factory', () => {
             expect(mediaSourceFactory).toHaveBeenCalledOnceWith();
         });
+        it('returns an object url for the media source', () => {
+            expect(URL.createObjectURL).toHaveBeenCalledWith(mockMediaSource);
+            expect(objectUrl).toBe('blob:test-url');
+        });
     });
     describe('readyState', () => {
         it('returns media source ready state', () => {
             mockMediaSource.readyState = 'open';
             expect(controller.readyState).toBe('open');
         });
+        it("returns 'closed' when there is no active media source", () => {
+            const freshController = new MediaSourceControllerImpl(deps);
+            expect(freshController.readyState).toBe('closed');
+        });
+    });
+    describe('deactivate', () => {
+        it('returns early and does not throw when never activated', () => {
+            const freshController = new MediaSourceControllerImpl(deps);
+            expect(() => freshController.deactivate()).not.toThrow();
+            expect(URL.revokeObjectURL).not.toHaveBeenCalled();
+        });
+        it('swallows errors thrown while revoking the object url', () => {
+            ;
+            URL.revokeObjectURL.and.throwError(new Error('revoke failed'));
+            expect(() => controller.deactivate()).not.toThrow();
+        });
     });
     describe('duration', () => {
         it('sets media source duration after sourceopen', async () => {
@@ -92,6 +120,7 @@ describe('MediaSourceControllerImpl', () => {
             mediaTimelineTransformed.value = Promise.resolve({
                 periods: [],
                 minBufferTime: 0,
+                getAdBreaks: () => Promise.resolve([]),
                 getDuration: () => Promise.reject(error),
             });
             open();
@@ -106,6 +135,7 @@ describe('MediaSourceControllerImpl', () => {
             mediaTimelineTransformed.value = Promise.resolve({
                 periods: [],
                 minBufferTime: 0,
+                getAdBreaks: () => Promise.resolve([]),
                 getDuration: () => Promise.reject(new AbortError()),
             });
             open();
@@ -117,6 +147,7 @@ describe('MediaSourceControllerImpl', () => {
             mediaTimelineTransformed.value = Promise.resolve({
                 periods: [],
                 minBufferTime: 0,
+                getAdBreaks: () => Promise.resolve([]),
                 getDuration: () => deferred,
             });
             open();
@@ -186,6 +217,10 @@ describe('MediaSourceControllerImpl', () => {
                 expect(readyToAppendSpy).toHaveBeenCalledTimes(1);
             });
         });
+        it('throws IllegalStateError when not active', () => {
+            const freshController = new MediaSourceControllerImpl(deps);
+            expect(() => freshController.createSourceBuffer('audio', 'audio/mp4')).toThrowError(IllegalStateError, 'cannot create a source buffer when not active');
+        });
         it('throws MediaSourceError when addSourceBuffer fails', () => {
             const error = new Error('test error');
             mockMediaSource.addSourceBuffer.and.throwError(error);
@@ -217,14 +252,6 @@ describe('MediaSourceControllerImpl', () => {
             expect(mockMediaSource.endOfStream).toHaveBeenCalledWith('decode');
         });
     });
-    describe('createUrl', () => {
-        it('creates object URL for media source', () => {
-            spyOn(URL, 'createObjectURL').and.returnValue('blob:test-url');
-            const url = controller.createUrl();
-            expect(URL.createObjectURL).toHaveBeenCalledWith(mockMediaSource);
-            expect(url).toBe('blob:test-url');
-        });
-    });
 });
 describe('MediaSourceError', () => {
     it('creates error with message and reason', () => {

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

@@ -96,6 +96,10 @@ describe('SourceBufferControllerImpl', () => {
         await flushPromises();
         expect(controller.isBusy()).withContext('isBusy').toBeFalse();
     });
+    it('tags with the content type, not undefined', () => {
+        expect(controller[Symbol.toStringTag]).toBe('SourceBuffer_audio');
+        expect(controller.logPrefix).toMatch(/^SourceBuffer_audio\//);
+    });
     describe('enqueue', () => {
         it('enqueues a task to execute when the source buffer is next idle', async () => {
             expect(await controller.enqueue(() => Promise.resolve(3))).toBe(3);

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codecDenylist.test.d.ts.map

package/dist/unit/types/current/streaming/buffering/codecDenylist.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecDenylist.test.d.ts","sourceRoot":"","sources":["../../../../../../test/unit/streaming/buffering/codecDenylist.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { clearCodecDenylist, denylistCodecsFromMimeType, getDenylistedCodecs, isMimeTypeDenylisted, } from '@amazon/vinyl';
+describe('codecDenylist', () => {
+    afterEach(() => {
+        clearCodecDenylist();
+    });
+    describe('denylistCodecsFromMimeType', () => {
+        it('adds codecs and returns true on first denylist', () => {
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeTrue();
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+        it('returns false when all codecs are already denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"')).toBeFalse();
+        });
+        it('returns true when at least one codec is newly added', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1,ec-3"')).toBeTrue();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            expect(denylistCodecsFromMimeType('video/mp4')).toBeFalse();
+        });
+        it('stores codecs lowercased', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="HVC1.1"');
+            expect(getDenylistedCodecs()).toContain('hvc1.1');
+        });
+    });
+    describe('isMimeTypeDenylisted', () => {
+        it('returns true when a codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="hvc1.1"')).toBeTrue();
+        });
+        it('is case-insensitive', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="HVC1.1"')).toBeTrue();
+        });
+        it('returns false when no codec is denylisted', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4; codecs="avc1.64001f"')).toBeFalse();
+        });
+        it('returns false for a mimeType with no codecs', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            expect(isMimeTypeDenylisted('video/mp4')).toBeFalse();
+        });
+    });
+    describe('clearCodecDenylist', () => {
+        it('empties the denylist', () => {
+            denylistCodecsFromMimeType('video/mp4; codecs="hvc1.1"');
+            clearCodecDenylist();
+            expect(getDenylistedCodecs()).toEqual([]);
+        });
+    });
+});

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createAllowedContentTypesValue.test.d.ts.map

package/dist/unit/types/current/streaming/createAllowedContentTypesValue.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAllowedContentTypesValue.test.d.ts","sourceRoot":"","sources":["../../../../../test/unit/streaming/createAllowedContentTypesValue.test.ts"],"names":[],"mappings":""}