@amazon/vinyl 1.1.1 → 2.0.0

package/dist/unit/types/current/track/hls/buildHlsMediaTimeline.test.js

@@ -2,8 +2,10 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { buildHlsMediaTimeline, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
+import { buildHlsMediaTimeline, createDefaultMediaTimelineTransformer, createEmptyMediaQualityMetadata, } from '@amazon/vinyl';
 import { noop } from '@amazon/vinyl-util';
+import { data } from '@amazon/vinyl-observable';
+import { MockCapabilities, MockDrmController, } from '@amazon/vinyl/vinylTestUtil';
 describe('buildHlsMediaTimeline', () => {
     function createVariant(uri, bandwidth) {
         return {
@@ -12,9 +14,10 @@ describe('buildHlsMediaTimeline', () => {
             codecs: 'mp4a.40.2',
         };
     }
-    function createMediaPlaylist(durations) {
+    function createMediaPlaylist(durations, ended = true) {
         return {
-            targetDuration: Math.max(...durations),
+            targetDuration: durations.length ? Math.max(...durations) : 0,
+            ended,
             segments: durations.map((d, i) => ({
                 duration: d,
                 uri: `seg${i}.m4s`,
@@ -57,6 +60,13 @@ describe('buildHlsMediaTimeline', () => {
         const timeline = buildHlsMediaTimeline(deps, data);
         expect(await timeline.getDuration()).toBe(12);
     });
+    it('returns Infinity for live playlists (no EXT-X-ENDLIST)', async () => {
+        const variant = createVariant('v1.m3u8', 128000);
+        const playlist = createMediaPlaylist([4, 4], false);
+        const data = createManifestData([variant], playlist);
+        const timeline = buildHlsMediaTimeline(deps, data);
+        expect(await timeline.getDuration()).toBe(Infinity);
+    });
     it('creates one quality per variant', () => {
         const v1 = createVariant('v1.m3u8', 128000);
         const v2 = createVariant('v2.m3u8', 256000);
@@ -91,23 +101,42 @@ describe('buildHlsMediaTimeline', () => {
         expect(timeline.periods[0].qualities.length).toBe(0);
         expect(timeline.periods[0].endTime).toBe(Infinity);
     });
-    it('uses variant URI for audio when variant is audio-only with audioGroup', async () => {
-        const variant = {
-            ...createVariant('flac.m3u8', 2_000_000),
-            codecs: 'flac',
-            audioGroup: 'audio-group',
-        };
+    it('creates one audio quality per rendition for an audio-only multi-language stream', async () => {
+        // Shaka's audio-only shape: each language is both an audio-only variant
+        // (referencing the group) and a rendition pointing at the same playlist.
+        // Demuxed audio is modeled per rendition, one quality per language.
         const playlist = createMediaPlaylist([5, 5]);
         const requestedUris = [];
         const manifestData = {
             mainPlaylist: {
-                variants: [variant],
+                variants: [
+                    {
+                        bandwidth: 128000,
+                        uri: 'audio_en.m3u8',
+                        codecs: 'mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                    {
+                        bandwidth: 129000,
+                        uri: 'audio_fr.m3u8',
+                        codecs: 'mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                ],
                 alternativeRenditions: [
                     {
                         type: 'AUDIO',
-                        groupId: 'audio-group',
-                        uri: 'aac.m3u8',
+                        groupId: 'audio',
+                        uri: 'audio_en.m3u8',
                         language: 'en',
+                        name: 'en',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio_fr.m3u8',
+                        language: 'fr',
+                        name: 'fr',
                     },
                 ],
             },
@@ -118,10 +147,144 @@ describe('buildHlsMediaTimeline', () => {
             },
         };
         const timeline = buildHlsMediaTimeline(deps, manifestData);
-        const segment = await timeline.periods[0].qualities[0].getSegment(2);
-        expect(segment).not.toBeNull();
-        expect(requestedUris).toContain('flac.m3u8');
-        expect(requestedUris).not.toContain('aac.m3u8');
+        const audio = timeline.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        expect(audio
+            .map((q) => q.metadata.lang)
+            .sort((a, b) => String(a).localeCompare(String(b)))).toEqual(['en', 'fr']);
+        // Fetching an audio quality uses its own rendition playlist.
+        await audio.find((q) => q.metadata.lang === 'fr').getSegment(2);
+        expect(requestedUris).toContain('audio_fr.m3u8');
+    });
+    it('skips audio renditions with no URI, a duplicate URI, or an unreferenced group', () => {
+        const playlist = createMediaPlaylist([5, 5]);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 5_000_000,
+                        uri: 'video.m3u8',
+                        codecs: 'avc1.640015,mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                ],
+                alternativeRenditions: [
+                    // No URI: nothing to fetch, skipped.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        language: 'en',
+                        name: 'en',
+                    },
+                    // First real rendition for this URI is kept.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio.m3u8',
+                        language: 'en',
+                        name: 'en',
+                    },
+                    // Duplicate URI: deduped away.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio.m3u8',
+                        language: 'en-dup',
+                        name: 'en-dup',
+                    },
+                    // Group referenced by no variant: no codec to play with.
+                    {
+                        type: 'AUDIO',
+                        groupId: 'orphan',
+                        uri: 'orphan.m3u8',
+                        language: 'de',
+                        name: 'de',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audio = timeline.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        expect(audio.map((q) => q.metadata.lang)).toEqual(['en']);
+    });
+    it('gives same-language audio renditions distinct ids and carries characteristics', () => {
+        const playlist = createMediaPlaylist([5, 5]);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 5_000_000,
+                        uri: 'video.m3u8',
+                        codecs: 'avc1.640015,mp4a.40.2',
+                        audioGroup: 'audio',
+                    },
+                ],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'main.m3u8',
+                        language: 'en-US',
+                        name: 'English',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'dvs.m3u8',
+                        language: 'en-US',
+                        name: 'English (DVS)',
+                        characteristics: [
+                            'public.accessibility.describes-video',
+                        ],
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audio = timeline.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        expect(audio.length).toBe(2);
+        // Same group + language would otherwise collide; names disambiguate.
+        expect(new Set(audio.map((q) => q.metadata.qualityId)).size).toBe(2);
+        const dvs = audio.find((q) => q.metadata.characteristics.includes('public.accessibility.describes-video'));
+        const main = audio.find((q) => q.metadata.characteristics.length === 0);
+        expect(dvs).toBeDefined();
+        expect(main).toBeDefined();
+    });
+    it('handles an audio rendition with no language and a variant with no audio codec', () => {
+        const playlist = createMediaPlaylist([5, 5]);
+        const manifestData = {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 5_000_000,
+                        uri: 'video.m3u8',
+                        // Video-only codecs: the demuxed audio has no codec.
+                        codecs: 'avc1.640015',
+                        audioGroup: 'audio',
+                    },
+                ],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'audio',
+                        uri: 'audio.m3u8',
+                        // No language: the quality id falls back to the name and
+                        // lang is null.
+                        name: 'commentary',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const audio = timeline.periods[0].qualities.find((q) => q.metadata.contentType === 'audio');
+        expect(audio.metadata.lang).toBeNull();
+        expect(audio.metadata.codecs).toBeNull();
+        expect(audio.metadata.qualityId).toBe('audio-audio-commentary');
     });
     it('uses rendition URI for audio when variant carries both video and audio', async () => {
         const variant = {
@@ -159,6 +322,97 @@ describe('buildHlsMediaTimeline', () => {
         await audioQuality.getSegment(2);
         expect(requestedUris).toEqual(['audio.m3u8']);
     });
+    // Shaka's mixed-codec shape: a single audio group whose renditions are
+    // different codecs (aac/opus/flac), each paired with an audio-only variant
+    // whose CODECS describes that one rendition. The flac variant is first, so
+    // resolving the codec from "the first variant of the group" would mislabel
+    // every rendition as flac.
+    function createMixedCodecAudioManifest(playlist) {
+        return {
+            mainPlaylist: {
+                variants: [
+                    {
+                        bandwidth: 141296,
+                        uri: 'flac.m3u8',
+                        codecs: 'flac',
+                        audioGroup: 'default-audio-group',
+                    },
+                    {
+                        bandwidth: 96017,
+                        uri: 'opus.m3u8',
+                        codecs: 'opus',
+                        audioGroup: 'default-audio-group',
+                    },
+                    {
+                        bandwidth: 51205,
+                        uri: 'aac.m3u8',
+                        codecs: 'mp4a.40.2',
+                        audioGroup: 'default-audio-group',
+                    },
+                ],
+                alternativeRenditions: [
+                    {
+                        type: 'AUDIO',
+                        groupId: 'default-audio-group',
+                        uri: 'flac.m3u8',
+                        name: 'stream_flac',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'default-audio-group',
+                        uri: 'opus.m3u8',
+                        name: 'stream_opus',
+                    },
+                    {
+                        type: 'AUDIO',
+                        groupId: 'default-audio-group',
+                        uri: 'aac.m3u8',
+                        name: 'stream_aac',
+                    },
+                ],
+            },
+            baseUrl: 'https://example.com/',
+            getMediaPlaylist: () => Promise.resolve(playlist),
+        };
+    }
+    it('assigns each rendition its own codec in a mixed-codec audio group', () => {
+        const manifestData = createMixedCodecAudioManifest(createMediaPlaylist([5, 5]));
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const byUri = (uri) => timeline.periods[0].qualities.find((q) => q.metadata.decoderId === uri).metadata;
+        expect(byUri('aac.m3u8').codecs).toBe('mp4a.40.2');
+        expect(byUri('aac.m3u8').mimeType).toBe('audio/mp4; codecs="mp4a.40.2"');
+        expect(byUri('opus.m3u8').codecs).toBe('opus');
+        expect(byUri('opus.m3u8').mimeType).toBe('audio/mp4; codecs="opus"');
+        expect(byUri('flac.m3u8').codecs).toBe('flac');
+        expect(byUri('flac.m3u8').mimeType).toBe('audio/mp4; codecs="flac"');
+    });
+    it('keeps the AAC rendition playable when the browser rejects opus and flac', async () => {
+        const capabilities = new MockCapabilities();
+        // Safari-like: only AAC is playable via MSE.
+        capabilities.canPlayTypeMse.and.callFake((type) => type.includes('mp4a'));
+        capabilities.sampleRate = 192_000;
+        const drmController = new MockDrmController();
+        drmController.isSupported.and.resolveTo({
+            supported: true,
+            persistentState: false,
+        });
+        const manifestData = createMixedCodecAudioManifest(createMediaPlaylist([5, 5]));
+        const timeline = buildHlsMediaTimeline(deps, manifestData);
+        const result = await createDefaultMediaTimelineTransformer({
+            capabilities,
+            drmController,
+            mediaTimeline: data(Promise.resolve(timeline)),
+            options: data({
+                preferredAudioLanguage: null,
+                codecOverrides: {},
+                preferDescriptiveAudio: false,
+            }),
+        }).value;
+        const audio = result.periods[0].qualities.filter((q) => q.metadata.contentType === 'audio');
+        // Only the AAC rendition survives; the period is not emptied, so no
+        // MediaUnsupportedError is thrown.
+        expect(audio.map((q) => q.metadata.codecs)).toEqual(['mp4a.40.2']);
+    });
     it('uses transmux path when no EXT-X-MAP is present', async () => {
         const variant = createVariant('v1.m3u8', 128000);
         const playlist = {
@@ -209,7 +463,7 @@ describe('buildHlsMediaTimeline', () => {
         // codecs should fall back to metadata.codecs
         expect(segment.quality.codecs).toBeNull();
     });
-    it('getDuration returns null when getMediaPlaylist fails', async () => {
+    it('getDuration rejects when getMediaPlaylist fails', async () => {
         const variant = createVariant('v1.m3u8', 128000);
         const manifestData = {
             mainPlaylist: {
@@ -220,7 +474,7 @@ describe('buildHlsMediaTimeline', () => {
             getMediaPlaylist: () => Promise.reject(new Error('disposed')),
         };
         const timeline = buildHlsMediaTimeline(deps, manifestData);
-        expect(await timeline.getDuration()).toBeNull();
+        await expectAsync(timeline.getDuration()).toBeRejected();
     });
     it('getDuration caches the result', async () => {
         const variant = createVariant('v1.m3u8', 128000);
@@ -242,12 +496,12 @@ describe('buildHlsMediaTimeline', () => {
         expect(await timeline.getDuration()).toBe(10);
         expect(calls).toBe(1);
     });
-    it('getDuration returns null for empty segments', async () => {
+    it('getDuration throws for empty segments in a complete playlist', async () => {
         const variant = createVariant('v1.m3u8', 128000);
         const playlist = createMediaPlaylist([]);
         const manifestData = createManifestData([variant], playlist);
         const timeline = buildHlsMediaTimeline(deps, manifestData);
-        expect(await timeline.getDuration()).toBeNull();
+        await expectAsync(timeline.getDuration()).toBeRejectedWithError(/no segments/i);
     });
     it('passes byteRange from map to createSegmentDataProvider as mediaRange', async () => {
         const variant = createVariant('v1.m3u8', 128000);
@@ -289,9 +543,9 @@ describe('buildHlsMediaTimeline', () => {
         expect(initCall[1]?.headers).toEqual(jasmine.objectContaining({ Range: 'bytes=0-499' }));
         fetchSpy.and.callThrough();
     });
-    it('getDuration returns null when no variants', async () => {
+    it('getDuration throws when no variants', async () => {
         const manifestData = createManifestData([], createMediaPlaylist([]));
         const timeline = buildHlsMediaTimeline(deps, manifestData);
-        expect(await timeline.getDuration()).toBeNull();
+        await expectAsync(timeline.getDuration()).toBeRejectedWithError(/no variants/i);
     });
 });

package/dist/unit/types/current/track/hls/createHlsContentStreamFactories.test.js

@@ -9,7 +9,12 @@ import { data } from '@amazon/vinyl-observable';
 var any = jasmine.any;
 describe('createHlsContentStreamFactories', () => {
     let deps;
-    const emptyTimeline = { periods: [], minBufferTime: 0 };
+    const emptyTimeline = {
+        periods: [],
+        minBufferTime: 0,
+        getAdBreaks: () => Promise.resolve([]),
+        getDuration: () => Promise.resolve(Infinity),
+    };
     beforeEach(() => {
         deps = {
             mediaSourceController: new MockMediaSourceController(),

package/dist/unit/types/current/track/hls/createHlsFactories.test.js

@@ -2,9 +2,9 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createHlsFactories, HlsManifestControllerImpl, MediaSourceControllerImpl, QualitySelectorImpl, } from '@amazon/vinyl';
+import { createHlsFactories, ManifestControllerImpl, MediaSourceControllerImpl, QualitySelectorImpl, } from '@amazon/vinyl';
 import { createMockVinylDependencies } from '@amazon/vinyl/vinylTestUtil';
-import { mockHlsManifestData } from '@amazon/vinyl/vinylTestUtil';
+import { mockHlsManifestData, mockMediaPlaylist, } from '@amazon/vinyl/vinylTestUtil';
 import { createContainer } from '@amazon/vinyl-di';
 import { MockMediaSource, MockMediaSourceGlobal, } from '@amazon/vinyl-util/browserTestUtil';
 var objectContaining = jasmine.objectContaining;
@@ -39,7 +39,7 @@ describe('createHlsFactories', () => {
         const deps = createContainer(factories).dependencies;
         expect(deps).toEqual(objectContaining({
             segmentRequestInit: undefined,
-            manifestController: any(HlsManifestControllerImpl),
+            manifestController: any(ManifestControllerImpl),
             mediaSourceFactory: any(Function),
             mediaQualityMetadataResolver: any(Function),
             mediaSourceController: any(MediaSourceControllerImpl),
@@ -48,6 +48,39 @@ describe('createHlsFactories', () => {
             qualitySelector: any(QualitySelectorImpl),
         }));
     });
+    it('wires per-track option observables from the player options', () => {
+        const factoryCreator = createHlsFactories(null);
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const options = hlsFactoryDeps.options.value;
+        expect(deps.preferredAudioLanguage.value).toBe(options.preferredAudioLanguage);
+        expect(deps.allowedContentTypes.value).toBe(options.allowedContentTypes);
+        expect(deps.preferDescriptiveAudio.value).toBe(options.preferDescriptiveAudio);
+        expect(deps.abr.value).toBe(options.abr);
+    });
+    it('exposes the shared adController without owning it', () => {
+        const factoryCreator = createHlsFactories(null);
+        // Make the shared controller Disposable: if the track container owned
+        // it, container.dispose() would tear it down. Marking it external must
+        // prevent that. Otherwise a codec-recovery reloadCurrentTrack would
+        // dispose the player-level ad controller.
+        const disposeSpy = createSpy('dispose');
+        hlsFactoryDeps.adController.dispose = disposeSpy;
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider,
+        });
+        const container = createContainer(factories);
+        // The track resolves the same shared player-level controller.
+        expect(container.dependencies.adController).toBe(hlsFactoryDeps.adController);
+        container.dispose();
+        expect(disposeSpy).not.toHaveBeenCalled();
+    });
     it('provides streaming options to createContentStreamFactories', () => {
         const factoryCreator = createHlsFactories({
             streaming: {
@@ -71,6 +104,151 @@ describe('createHlsFactories', () => {
             type: 'hls',
         });
         const deps = createContainer(factories).dependencies;
-        expect(deps.manifestController).toEqual(any(HlsManifestControllerImpl));
+        expect(deps.manifestController).toEqual(any(ManifestControllerImpl));
+    });
+    it('creates a sidecar text track controller and populates from manifest', async () => {
+        const factoryCreator = createHlsFactories(null);
+        const subtitleManifest = {
+            ...mockHlsManifestData,
+            mainPlaylist: {
+                ...mockHlsManifestData.mainPlaylist,
+                alternativeRenditions: [
+                    {
+                        type: 'SUBTITLES',
+                        groupId: 'subs',
+                        name: 'English',
+                        language: 'en',
+                        uri: 'subs/en.vtt',
+                    },
+                ],
+            },
+        };
+        const provider = createSpy('subtitleProvider').and.resolveTo(subtitleManifest);
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider: provider,
+        });
+        const deps = createContainer(factories).dependencies;
+        // Resolve textTrackController first so it subscribes to
+        // manifestTransformed before the manifest promise resolves.
+        const controller = deps.textTrackController;
+        await deps.manifestTransformed.value;
+        await new Promise((r) => setTimeout(r, 0));
+        expect(controller).toBeDefined();
+        expect(controller.textTracks.length).toBe(1);
+        expect(controller.textTracks[0].language).toBe('en');
+    });
+    it('text track controller swallows manifest fetch errors', async () => {
+        const factoryCreator = createHlsFactories(null);
+        const provider = createSpy('failing').and.rejectWith(new Error('manifest down'));
+        const factories = factoryCreator(hlsFactoryDeps)({
+            uri: 'https://example.com/main.m3u8',
+            type: 'hls',
+            manifestProvider: provider,
+        });
+        const deps = createContainer(factories).dependencies;
+        const controller = deps.textTrackController;
+        // Trigger the transform; the promise will reject but the
+        // textTrackController must not throw.
+        await deps.manifestTransformed.value.catch(() => undefined);
+        await new Promise((r) => setTimeout(r, 0));
+        expect(controller.textTracks).toEqual([]);
+    });
+    describe('ad interstitial discovery', () => {
+        function interstitialManifest(overrides = {}) {
+            const media = {
+                ...mockMediaPlaylist,
+                dateRanges: [
+                    {
+                        id: 'ad1',
+                        classId: 'com.apple.hls.interstitial',
+                        startDate: '2024-01-01T00:00:00.000Z',
+                        duration: 5,
+                        clientAttributes: {
+                            'X-ASSET-URI': 'https://ads.example.com/ad.m3u8',
+                        },
+                    },
+                ],
+                ...overrides,
+            };
+            return {
+                ...mockHlsManifestData,
+                getMediaPlaylist: () => Promise.resolve(media),
+            };
+        }
+        it('attaches discovered ad breaks to the media timeline', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('adProvider').and.resolveTo(interstitialManifest());
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            const adBreaks = await timeline.getAdBreaks();
+            expect(adBreaks.length).toBe(1);
+            expect(adBreaks[0].id).toBe('ad1');
+        });
+        it('omits ad breaks when the playlist has none', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            expect(await timeline.getAdBreaks()).toEqual([]);
+        });
+        it('discovers ads against a live (non-ended) playlist', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('liveProvider').and.resolveTo(interstitialManifest({ ended: false }));
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            expect((await timeline.getAdBreaks()).length).toBe(1);
+        });
+        it('returns no ad breaks when there are no variants', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('noVariants').and.resolveTo({
+                ...mockHlsManifestData,
+                mainPlaylist: {
+                    ...mockHlsManifestData.mainPlaylist,
+                    variants: [],
+                },
+            });
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            expect(await timeline.getAdBreaks()).toEqual([]);
+        });
+        it('surfaces media playlist fetch errors from getAdBreaks', async () => {
+            const factoryCreator = createHlsFactories(null);
+            const provider = createSpy('throwingMedia').and.resolveTo({
+                ...mockHlsManifestData,
+                getMediaPlaylist: () => Promise.reject(new Error('media down')),
+            });
+            const factories = factoryCreator(hlsFactoryDeps)({
+                uri: 'https://example.com/main.m3u8',
+                type: 'hls',
+                manifestProvider: provider,
+            });
+            const deps = createContainer(factories).dependencies;
+            const timeline = await deps.mediaTimeline.value;
+            // Discovery is now lazy: getAdBreaks() rejects on a failed media
+            // playlist fetch, leaving error handling to the caller (e.g.
+            // MseTrack swallows it via its errorHandler).
+            await expectAsync(timeline.getAdBreaks()).toBeRejectedWithError('media down');
+        });
     });
 });

package/dist/unit/types/current/track/hls/createUrlHlsManifestProvider.test.js

@@ -113,4 +113,23 @@ describe('fetchMediaPlaylist', () => {
         expect(playlist.segments.length).toBe(1);
         expect(String(mockRequester.request.calls.argsFor(0)[0])).toBe('https://example.com/path/audio.m3u8');
     });
+    it('resolves EXT-X-DEFINE:QUERYPARAM from the playlist URL query string', async () => {
+        mockRequester.request.and.callFake(() => Promise.resolve(new Response([
+            '#EXTM3U',
+            '#EXT-X-TARGETDURATION:6',
+            '#EXT-X-PLAYLIST-TYPE:VOD',
+            '#EXT-X-DEFINE:QUERYPARAM="tok"',
+            '#EXTINF:6.0,',
+            'segment0.aac?t={$tok}',
+            '#EXT-X-ENDLIST',
+        ].join('\n'))));
+        const playlist = await fetchMediaPlaylist({
+            uri: 'audio.m3u8?tok=xyz',
+            baseUrl: 'https://example.com/path/main.m3u8',
+            defines: undefined,
+        });
+        // The QUERYPARAM token from the playlist URL is substituted into the
+        // segment URI (relative resolution happens later, in the timeline).
+        expect(playlist.segments[0].uri).toBe('segment0.aac?t=xyz');
+    });
 });

package/dist/unit/types/current/track/inferLoadOptionsFromUri.test.d.ts

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

package/dist/unit/types/current/track/inferLoadOptionsFromUri.test.d.ts.map

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