@amazon/vinyl 1.1.1 → 1.2.1

package/dist/unit/types/current/text/pickPreferredTextTrack.test.js

@@ -0,0 +1,78 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { pickPreferredTextTrack } from '@amazon/vinyl';
+import { setMockNavigator, spyOnPropertySafe, } from '@amazon/vinyl-util/testUtil';
+let nextId = 0;
+function track(overrides = {}) {
+    return {
+        id: `t${nextId++}`,
+        kind: 'subtitles',
+        language: 'en',
+        label: '',
+        default: false,
+        forced: false,
+        characteristics: [],
+        uri: 'x.vtt',
+        mimeType: null,
+        ...overrides,
+    };
+}
+describe('pickPreferredTextTrack', () => {
+    it('falls back to navigator.languages when the preference is null', () => {
+        setMockNavigator().languages = ['en'];
+        const en = track({ id: 'en', language: 'en' });
+        expect(pickPreferredTextTrack([en], null)).toBe(en);
+    });
+    it('returns null when no track relates to navigator.languages', () => {
+        setMockNavigator().languages = ['en'];
+        expect(pickPreferredTextTrack([track({ language: 'ja' })], null)).toBeNull();
+    });
+    it('returns null for a null preference when navigator is unavailable', () => {
+        spyOnPropertySafe(global, 'navigator').and.returnValue(undefined);
+        expect(pickPreferredTextTrack([track()], null)).toBeNull();
+    });
+    it('returns null when there are no tracks', () => {
+        expect(pickPreferredTextTrack([], 'en')).toBeNull();
+    });
+    it('selects the track matching the preferred language', () => {
+        const en = track({ id: 'en', language: 'en' });
+        const es = track({ id: 'es', language: 'es' });
+        expect(pickPreferredTextTrack([es, en], 'en')).toBe(en);
+    });
+    it('returns null when no track relates to the preference', () => {
+        expect(pickPreferredTextTrack([track({ language: 'es' })], 'ja')).toBeNull();
+    });
+    it('ignores tracks without a language tag', () => {
+        expect(pickPreferredTextTrack([track({ language: null })], 'en')).toBeNull();
+    });
+    it('prefers a full track over a forced-only track of the same language', () => {
+        const forced = track({ id: 'forced', language: 'en', forced: true });
+        const full = track({ id: 'full', language: 'en', forced: false });
+        expect(pickPreferredTextTrack([forced, full], 'en')).toBe(full);
+    });
+    it('breaks a remaining tie by the manifest-default flag', () => {
+        const a = track({ id: 'a', language: 'en', default: false });
+        const b = track({ id: 'b', language: 'en', default: true });
+        expect(pickPreferredTextTrack([a, b], 'en')).toBe(b);
+    });
+    it('honors preference order, earlier entries winning', () => {
+        const en = track({ id: 'en', language: 'en' });
+        const fr = track({ id: 'fr', language: 'fr' });
+        expect(pickPreferredTextTrack([en, fr], ['fr', 'en'])).toBe(fr);
+        expect(pickPreferredTextTrack([en, fr], ['en', 'fr'])).toBe(en);
+    });
+    it('matches a related language when no exact match exists', () => {
+        const enUs = track({ id: 'en-US', language: 'en-US' });
+        const es = track({ id: 'es', language: 'es' });
+        // 'en' is the parent of 'en-US' — related, so it should be chosen.
+        expect(pickPreferredTextTrack([es, enUs], 'en')).toBe(enUs);
+    });
+    it('prefers a closer language match over a more distant one', () => {
+        const enUs = track({ id: 'en-US', language: 'en-US' });
+        const enGb = track({ id: 'en-GB', language: 'en-GB' });
+        // Exact 'en-US' (relatedness 4) beats sibling 'en-GB' (relatedness 2).
+        expect(pickPreferredTextTrack([enGb, enUs], 'en-US')).toBe(enUs);
+    });
+});

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

@@ -3,10 +3,25 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AutoResetControllerImpl, } from '@amazon/vinyl';
-import { ErrorOrigin, ReportableError, networkState, DisposedError, } from '@amazon/vinyl-util';
+import { networkState, DisposedError, RequestError } from '@amazon/vinyl-util';
 import { MockPlaybackController } from '@amazon/vinyl/vinylTestUtil';
-import { createEventSpy, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
+import { createEventSpy, emptyInternalError, emptyResponseError, MockNetworkState, overrideGlobalInit, } from '@amazon/vinyl-util/testUtil';
 import { mockEvent, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
+/**
+ * Creates a RequestError representing a transient network failure (no response received).
+ * These are the only errors that AutoResetController watches for retry opportunities.
+ */
+function createNetworkRequestError() {
+    return new RequestError(null, emptyInternalError);
+}
+/**
+ * Creates a RequestError that received an HTTP response. These should be ignored by
+ * the AutoResetController, since a service that responded is unlikely to recover
+ * on its own.
+ */
+function createResponseRequestError() {
+    return new RequestError(new Response(null, { status: 500 }), emptyResponseError);
+}
 describe('AutoResetControllerImpl', () => {
     let deps;
     let controller;
@@ -47,32 +62,35 @@ describe('AutoResetControllerImpl', () => {
             expect(playbackController.on).toHaveBeenCalledWith('seeking', jasmine.any(Function));
             expect(playbackController.on).toHaveBeenCalledWith('playing', jasmine.any(Function));
         });
+        it('starts with resetPending false', () => {
+            controller = new AutoResetControllerImpl(deps);
+            expect(controller.resetPending).toBeFalse();
+        });
     });
     describe('setError', () => {
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
         });
-        it('ignores non-ReportableError', () => {
+        it('ignores non-RequestError', () => {
             const error = new Error('test error');
             controller.setError(error);
             expect(mockNetworkState.on).not.toHaveBeenCalled();
+            expect(controller.resetPending).toBeFalse();
         });
-        it('ignores ReportableError with non-SERVICE_INTERNAL origin', () => {
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_EXTERNAL);
-            controller.setError(error);
+        it('ignores RequestError with a response (HTTP failure)', () => {
+            controller.setError(createResponseRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
+            expect(controller.resetPending).toBeFalse();
         });
-        it('sets error and starts watching for SERVICE_INTERNAL ReportableError', () => {
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+        it('sets error and starts watching for transient network RequestError', () => {
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).toHaveBeenCalledWith('online', jasmine.any(Function));
+            expect(controller.resetPending).toBeTrue();
         });
         it('ignores subsequent errors when already in error state', () => {
-            const error1 = new ReportableError('test1', ErrorOrigin.SERVICE_INTERNAL);
-            const error2 = new ReportableError('test2', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error1);
+            controller.setError(createNetworkRequestError());
             mockNetworkState.on.calls.reset();
-            controller.setError(error2);
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
         });
     });
@@ -82,7 +100,7 @@ describe('AutoResetControllerImpl', () => {
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
             resetSpy = createEventSpy(controller, 'reset');
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('emits reset event when network comes online', () => {
             controller.setError(error);
@@ -160,7 +178,7 @@ describe('AutoResetControllerImpl', () => {
         let resetSpy;
         let error;
         beforeEach(() => {
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('retries at specified interval when online', async () => {
             controller = new AutoResetControllerImpl(deps, { retryInterval: 5 });
@@ -197,12 +215,109 @@ describe('AutoResetControllerImpl', () => {
                 expect(resetSpy).toHaveBeenCalledTimes(3);
             }
         });
+        it('clears resetPending when max retries are exhausted', async () => {
+            controller = new AutoResetControllerImpl(deps, {
+                retryInterval: 1,
+                maxRetries: 1,
+            });
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+            // First retry succeeds (resets) and re-arms on next setError
+            await clock.tick(1);
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+            // Second retry exhausts the budget — interval fires but no reset emitted,
+            // and resetPending should transition to false.
+            await clock.tick(1);
+            expect(controller.resetPending).toBeFalse();
+        });
+    });
+    describe('resetPending', () => {
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            error = createNetworkRequestError();
+        });
+        it('is false initially', () => {
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes true when an eligible error is set', () => {
+            controller.setError(error);
+            expect(controller.resetPending).toBeTrue();
+        });
+        it('remains false when a non-eligible error is set', () => {
+            controller.setError(new Error('not eligible'));
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes false after a reset is emitted', () => {
+            controller.setError(error);
+            playbackController.dispatch('play', {});
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('becomes false when cleared', () => {
+            controller.setError(error);
+            controller.clear();
+            expect(controller.resetPending).toBeFalse();
+        });
+        it('is false when the controller is disabled', () => {
+            controller = new AutoResetControllerImpl(deps, { enabled: false });
+            controller.setError(error);
+            expect(controller.resetPending).toBeFalse();
+        });
+    });
+    describe('resetPendingChange event', () => {
+        let resetPendingChangeSpy;
+        let error;
+        beforeEach(() => {
+            controller = new AutoResetControllerImpl(deps);
+            resetPendingChangeSpy = createEventSpy(controller, 'resetPendingChange');
+            error = createNetworkRequestError();
+        });
+        it('dispatches when resetPending becomes true', () => {
+            controller.setError(error);
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: false,
+                current: true,
+            });
+        });
+        it('dispatches when resetPending becomes false via reset', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            playbackController.dispatch('play', {});
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: true,
+                current: false,
+            });
+        });
+        it('dispatches when resetPending becomes false via clear', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            controller.clear();
+            expect(resetPendingChangeSpy).toHaveBeenCalledOnceWith({
+                previous: true,
+                current: false,
+            });
+        });
+        it('does not dispatch when setError is called with an in-progress error', () => {
+            controller.setError(error);
+            resetPendingChangeSpy.calls.reset();
+            controller.setError(error);
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
+        it('does not dispatch when clear is called with no error', () => {
+            controller.clear();
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
+        it('does not dispatch when an ineligible error is set', () => {
+            controller.setError(new Error('not eligible'));
+            expect(resetPendingChangeSpy).not.toHaveBeenCalled();
+        });
     });
     describe('clear', () => {
         let error;
         beforeEach(() => {
             controller = new AutoResetControllerImpl(deps);
-            error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
+            error = createNetworkRequestError();
         });
         it('clears error state and stops watching', () => {
             controller.setError(error);
@@ -229,8 +344,7 @@ describe('AutoResetControllerImpl', () => {
     describe('dispose', () => {
         it('clears error state and disposes resources', () => {
             controller = new AutoResetControllerImpl(deps);
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             controller.dispose();
             // Should not emit reset after disposing
             const resetSpy = createEventSpy(controller, 'reset');
@@ -250,15 +364,13 @@ describe('AutoResetControllerImpl', () => {
     describe('disabled behavior', () => {
         it('does not watch for errors when disabled', () => {
             controller = new AutoResetControllerImpl(deps, { enabled: false });
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             expect(mockNetworkState.on).not.toHaveBeenCalled();
         });
         it('does not emit reset events when disabled', () => {
             controller = new AutoResetControllerImpl(deps, { enabled: false });
             const resetSpy = createEventSpy(controller, 'reset');
-            const error = new ReportableError('test', ErrorOrigin.SERVICE_INTERNAL);
-            controller.setError(error);
+            controller.setError(createNetworkRequestError());
             playbackController.dispatch('play', {});
             expect(resetSpy).not.toHaveBeenCalled();
         });

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

@@ -12,7 +12,11 @@ describe('createDashContentStreamFactories', () => {
     let mediaSourceController;
     let playbackController;
     let qualitySelector;
-    const emptyTimeline = { periods: [], minBufferTime: 0 };
+    const emptyTimeline = {
+        periods: [],
+        minBufferTime: 0,
+        getDuration: () => Promise.resolve(Infinity),
+    };
     beforeEach(() => {
         mediaSourceController = new MockMediaSourceController();
         playbackController = new MockPlaybackController();

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

@@ -9,7 +9,11 @@ var objectContaining = jasmine.objectContaining;
 describe('createSegmentControllerFactory', () => {
     it('creates SegmentControllerImpl with merged dependencies', () => {
         const playbackController = new MockPlaybackController();
-        const emptyTimeline = { periods: [], minBufferTime: 0 };
+        const emptyTimeline = {
+            periods: [],
+            minBufferTime: 0,
+            getDuration: () => Promise.resolve(Infinity),
+        };
         const factory = createSegmentControllerFactory({ playbackController }, 'audio', { prefetchActive: 100 });
         const controller = factory({
             mediaTimelineTransformed: data(Promise.resolve(emptyTimeline)),

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

@@ -308,5 +308,34 @@ describe('mpd utils', () => {
                 expect(calculateDuration(manifest)).toBe(50);
             });
         });
+        describe('when MPD type is dynamic', () => {
+            it('returns Infinity for live presentations', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD type="dynamic" minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-live:2011" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+</MPD>`);
+                expect(calculateDuration(manifest)).toBe(Infinity);
+            });
+        });
+        describe('when there are no periods', () => {
+            it('throws', () => {
+                const manifest = clone(mockDashManifest);
+                delete manifest.MPD
+                    .mediaPresentationDuration;
+                manifest.MPD.Period = [];
+                expect(() => calculateDuration(manifest)).toThrowError(/no periods/i);
+            });
+        });
+        describe('when the last period has no determinable end', () => {
+            it('throws', () => {
+                // language=XML
+                const manifest = parseDashManifest(`<?xml version="1.0" ?>
+<MPD minBufferTime="PT0.0S" profiles="urn:mpeg:dash:profile:isoff-live:2011" xmlns="urn:mpeg:dash:schema:mpd:2011">
+  <Period/>
+</MPD>`);
+                expect(() => calculateDuration(manifest)).toThrowError(/Unable to determine/);
+            });
+        });
     });
 });

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

@@ -12,9 +12,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 +58,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);
@@ -209,7 +217,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 +228,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 +250,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 +297,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,11 @@ import { data } from '@amazon/vinyl-observable';
 var any = jasmine.any;
 describe('createHlsContentStreamFactories', () => {
     let deps;
-    const emptyTimeline = { periods: [], minBufferTime: 0 };
+    const emptyTimeline = {
+        periods: [],
+        minBufferTime: 0,
+        getDuration: () => Promise.resolve(Infinity),
+    };
     beforeEach(() => {
         deps = {
             mediaSourceController: new MockMediaSourceController(),

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":""}

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

@@ -0,0 +1,165 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createTrackLoadOptionsFromUrl, inferTrackTypeFromUrl, inferTrackTypeFromUrlPath, } from '@amazon/vinyl';
+import { requesterWithRetryRef } from '@amazon/vinyl-util';
+import { MockRequester, overrideGlobalInit } from '@amazon/vinyl-util/testUtil';
+describe('inferTrackTypeFromUrlPath', () => {
+    it('returns hls for .m3u8 extension', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/stream.m3u8')).toBe('hls');
+    });
+    it('returns hls for .m3u8 with query params', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/stream.m3u8?token=abc')).toBe('hls');
+    });
+    it('returns dash for .mpd extension', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/manifest.mpd')).toBe('dash');
+    });
+    it('returns dash for .mpd with query params', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/manifest.mpd?v=1')).toBe('dash');
+    });
+    it('returns src for common media extensions', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.mp3')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.mp4')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.aac')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.webm')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.ogg')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.wav')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.m4a')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.m4v')).toBe('src');
+        expect(inferTrackTypeFromUrlPath('https://example.com/audio.opus')).toBe('src');
+    });
+    it('returns src for media extensions with query params', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/video.mp4?quality=high')).toBe('src');
+    });
+    it('returns null for unrecognized URIs', () => {
+        expect(inferTrackTypeFromUrlPath('https://example.com/api/stream')).toBeNull();
+        expect(inferTrackTypeFromUrlPath('https://example.com/data.json')).toBeNull();
+    });
+});
+/**
+ * Builds a minimal `fetch` Response stand-in that satisfies `requestWithRetry`
+ * (which reads `ok`/`status`/`headers` and rejects on non-ok responses).
+ */
+function contentTypeResponse(contentType) {
+    return {
+        ok: true,
+        status: 200,
+        headers: {
+            get: (header) => header === 'content-type' ? contentType : null,
+        },
+    };
+}
+function notFoundResponse() {
+    return {
+        ok: false,
+        status: 404,
+        headers: { get: () => null },
+    };
+}
+describe('inferTrackTypeFromUrl', () => {
+    it('resolves from the extension without a network request', async () => {
+        const origFetch = globalThis.fetch;
+        const fetchSpy = jasmine.createSpy('fetch');
+        globalThis.fetch = fetchSpy;
+        try {
+            expect(await inferTrackTypeFromUrl('https://example.com/a.m3u8')).toBe('hls');
+            expect(fetchSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+    it('falls through to a HEAD probe for extension-less URLs', async () => {
+        const origFetch = globalThis.fetch;
+        const fetchSpy = jasmine
+            .createSpy('fetch')
+            .and.resolveTo(contentTypeResponse('video/mp4'));
+        globalThis.fetch = fetchSpy;
+        try {
+            expect(await inferTrackTypeFromUrl('https://example.com/probe-fallthru')).toBe('src');
+            expect(fetchSpy).toHaveBeenCalledTimes(1);
+            expect(fetchSpy.calls.argsFor(0)[1]).toEqual(jasmine.objectContaining({ method: 'HEAD' }));
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+});
+describe('probeType (via inferTrackTypeFromUrl)', () => {
+    // Each spec uses a DISTINCT URL because probeType is memoized by URL, so a
+    // shared URL would leak a cached result into later specs.
+    async function probe(url, response) {
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = jasmine.createSpy('fetch').and.resolveTo(response);
+        try {
+            return await inferTrackTypeFromUrl(url);
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    }
+    it('maps application/dash+xml to dash', async () => {
+        expect(await probe('https://example.com/probe-dash', contentTypeResponse('application/dash+xml'))).toBe('dash');
+    });
+    it('maps an mpegurl content-type to hls', async () => {
+        expect(await probe('https://example.com/probe-hls', contentTypeResponse('application/vnd.apple.mpegurl'))).toBe('hls');
+    });
+    it('maps video/* content-types to src', async () => {
+        expect(await probe('https://example.com/probe-video', contentTypeResponse('video/mp4'))).toBe('src');
+    });
+    it('maps audio/* content-types to src', async () => {
+        expect(await probe('https://example.com/probe-audio', contentTypeResponse('audio/mpeg'))).toBe('src');
+    });
+    it('returns null for an unrecognized content-type', async () => {
+        expect(await probe('https://example.com/probe-unknown', contentTypeResponse('application/json'))).toBeNull();
+    });
+    it('returns null when the content-type header is missing', async () => {
+        expect(await probe('https://example.com/probe-no-content-type', contentTypeResponse(null))).toBeNull();
+    });
+    it('returns null for a non-ok response', async () => {
+        expect(await probe('https://example.com/probe-not-found', notFoundResponse())).toBeNull();
+    });
+    it('returns null when the request throws', async () => {
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = jasmine
+            .createSpy('fetch')
+            .and.rejectWith(new Error('network down'));
+        try {
+            expect(await inferTrackTypeFromUrl('https://example.com/probe-throws')).toBeNull();
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+});
+describe('probeType (non-ok resolved response)', () => {
+    // The real requester rejects non-ok responses, so it can never resolve one
+    // to probeType. Override it with a mock that resolves a non-ok Response to
+    // exercise probeType's `!res.ok` guard.
+    const mockRequesterRef = overrideGlobalInit(requesterWithRetryRef, () => new MockRequester());
+    it('returns null when the request resolves a non-ok response', async () => {
+        mockRequesterRef.value.request.and.resolveTo(new Response(null, { status: 404 }));
+        expect(await inferTrackTypeFromUrl('https://example.com/probe-resolved-not-ok')).toBeNull();
+    });
+});
+describe('createTrackLoadOptionsFromUrl', () => {
+    it('returns uri and type for a typeable URL', async () => {
+        expect(await createTrackLoadOptionsFromUrl('https://example.com/create.m3u8')).toEqual({ uri: 'https://example.com/create.m3u8', type: 'hls' });
+    });
+    it('returns null for an empty string', async () => {
+        expect(await createTrackLoadOptionsFromUrl('')).toBeNull();
+    });
+    it('returns null for an untypeable URL', async () => {
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = jasmine
+            .createSpy('fetch')
+            .and.resolveTo(contentTypeResponse('application/json'));
+        try {
+            expect(await createTrackLoadOptionsFromUrl('https://example.com/create-untypeable')).toBeNull();
+        }
+        finally {
+            globalThis.fetch = origFetch;
+        }
+    });
+});