@amazon/vinyl 3.0.0 → 3.1.0

package/dist/types/ts4.7/vinyl/createVinylFactories.d.ts

@@ -1,6 +1,6 @@
 import type { CapabilitiesImplDeps } from '../client/CapabilitiesImpl';
 import { CapabilitiesImpl } from '../client/CapabilitiesImpl';
-import type { Merge, PartialDeep, PatchedRef } from '@amazon/vinyl-util';
+import type { Merge, PartialDeep } from '@amazon/vinyl-util';
 import { noop } from '@amazon/vinyl-util';
 import type { PlaybackControllerImplDeps, PlaybackControllerImplOptions } from '../playback/PlaybackControllerImpl';
 import { PlaybackControllerImpl } from '../playback/PlaybackControllerImpl';
@@ -9,7 +9,6 @@ import { PlaybackSourceImpl } from '../playback/PlaybackSourceImpl';
 import { type VinylTrackFactoryDeps } from '../track/createVinylTrackFactories';
 import type { TrackControllerImplDeps, TrackControllerImplOptions } from '../track/TrackController';
 import { TrackControllerImpl } from '../track/TrackController';
-import type { VinylPatchOptions } from './VinylPatchOptions';
 import { type QualitySelectorImplOptions } from '../streaming/abr/QualitySelectorImpl';
 import { AdControllerImpl, type AdControllerImplDeps, type AdControllerImplOptions } from '../ad/AdControllerImpl';
 import { type MediaTextTrackProvider } from '../text/mediaTextTrackProvider';
@@ -41,11 +40,6 @@ export interface VinylDependencyOptions {
      * `'hidden'`; without one they render natively. See `TextTrackRenderer`.
      */
     readonly textTrackRenderer?: TextTrackRenderer;
-    /**
-     * Flags for patches that should be applied browser-specifically.
-     * These will be defaulted based on the user-agent.
-     */
-    readonly patches?: PartialDeep<VinylPatchOptions>;
     /**
      * Configuration for the track controller.
      */
@@ -82,12 +76,7 @@ export interface VinylDependencyOptions {
  */
 export declare function createVinylFactories(options: VinylDependencyOptions): {
     options: (_deps: import("@amazon/vinyl-util").AnyRecord, add: import("@amazon/vinyl-util").AddDisposable) => import("@amazon/vinyl-observable").MutableValue<VinylOptions>;
-    patchedMedia: () => PatchedRef<HTMLMediaElement>;
-    media: (deps: {
-        readonly patchedMedia: {
-            readonly patched: HTMLMediaElement;
-        };
-    }) => HTMLMediaElement;
+    media: () => HTMLMediaElement;
     textTrackProvider: (deps: {
         readonly media: HTMLMediaElement;
     }) => MediaTextTrackProvider;
@@ -153,7 +142,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
             readonly manifestTransformed: ObservableValue<Promise<import("..").DashManifestData>>;
             readonly options: ObservableValue<Pick<VinylOptions, "text">>;
         }) => import("..").SidecarTextTrackController;
-        options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "audio" | "text" | "abr" | "allowedContentTypes">>>;
+        options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "text" | "audio" | "abr" | "allowedContentTypes">>>;
         playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
         playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
         drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").DrmKeySystemResolver>;
@@ -165,7 +154,9 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         textTrackRenderer: import("@amazon/vinyl-di").Factory<TextTrackRenderer | null>;
         adController: import("@amazon/vinyl-di").Factory<import("..").AdController>;
     };
-    createHlsFactories: (deps: import("..").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => {
+    createHlsFactories: (deps: import("..").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions /**
+     * Configuration for adaptive bitrate switching.
+     */) => {
         baseContentTypesValue: typeof import("..").createHlsContentTypesValue;
         contentTypesValue: typeof import("..").createAllowedContentTypesValue;
         manifestProvider: () => import("..").HlsManifestProvider;
@@ -208,7 +199,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
             readonly manifestTransformed: ObservableValue<Promise<import("..").HlsManifestData>>;
             readonly options: ObservableValue<Pick<VinylOptions, "text">>;
         }) => import("..").SidecarTextTrackController;
-        options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "audio" | "text" | "abr" | "allowedContentTypes">>>;
+        options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "text" | "audio" | "abr" | "allowedContentTypes">>>;
         playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
         playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
         drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").DrmKeySystemResolver>;

package/dist/unit/types/current/ad/AdControllerImpl.test.js

@@ -6,11 +6,22 @@ import { AdControllerImpl } from '@amazon/vinyl';
 import { MockPlaybackController, MockTrack } from '@amazon/vinyl/vinylTestUtil';
 describe('AdControllerImpl', () => {
     let playbackController;
+    let controllers;
     beforeEach(() => {
         playbackController = new MockPlaybackController();
+        controllers = [];
+    });
+    // Dispose every controller a spec created. An activated-but-unstarted ad
+    // arms a `sleep(adLoadTimeout)` timer.
+    afterEach(() => {
+        for (const c of controllers)
+            if (!c.disposed)
+                c.dispose();
     });
     function createController() {
-        return new AdControllerImpl({ playbackController });
+        const c = new AdControllerImpl({ playbackController });
+        controllers.push(c);
+        return c;
     }
     function updateTime(time) {
         playbackController.currentTime = time;
@@ -301,6 +312,21 @@ describe('AdControllerImpl', () => {
             await flush();
             expect(c.currentAdBreak).toBeNull();
         });
+        it('ignores a late provider ad-discovery resolution after dispose', async () => {
+            const c = createController();
+            let resolveAds = () => { };
+            const track = new MockTrack();
+            track.uri = 't1';
+            track.active = true;
+            track.getAds = () => new Promise((res) => {
+                resolveAds = res;
+            });
+            c.setAdsProvider(track); // refreshAds() runs; getAds() stays pending
+            c.dispose();
+            resolveAds(trackAds(makeBreak())); // refreshAds .then: interrupted (disposed)
+            await flush();
+            expect(c.currentTrackAds).toBeNull();
+        });
     });
     it('emits currentTrackAdsChange with the TrackAds when a parent track is set', async () => {
         const c = createController();

package/dist/unit/types/current/drm/DrmControllerImpl.test.js

@@ -389,6 +389,58 @@ describe('DrmControllerImpl', () => {
             expect(errorSpy).not.toHaveBeenCalled();
             expect(mediaKeys.createSession).toHaveBeenCalledTimes(1); // reused
         });
+        it('reuses the session when a transformer alters the CDM init data', async () => {
+            // A non-identity initDataTransformer changes the bytes handed to the
+            // CDM (always the case for FairPlay, or any custom transformer). The
+            // reuse check must compare the ORIGINAL init data, not the
+            // transformed bytes — otherwise every re-appended init segment fires
+            // `encrypted` and spins up a brand-new session instead of recycling.
+            const transformed = new Uint8Array([9, 9, 9]);
+            const controller = new DrmControllerImpl(deps, {
+                licenseProvider,
+                keySystems: {
+                    [DrmKeySystem.WIDEVINE]: {
+                        initDataTransformer: () => transformed,
+                    },
+                },
+            });
+            const localErrors = createEventSpy(controller, 'error');
+            const encryptedCb = commonEme.addEncryptedListener.calls.mostRecent().args[1];
+            controller.setBufferingDrmInfo(drmInfo);
+            encryptedCb({
+                initData: new Uint8Array([1, 2, 3]),
+                initDataType: 'cenc',
+            });
+            await flushPromises();
+            expect(mediaKeys.createSession).toHaveBeenCalledTimes(1);
+            // The session stored the transformed bytes handed to the CDM.
+            expect(getSession(0).initData).toEqual(transformed);
+            // The same raw init data fires again (e.g. a quality switch
+            // re-appends the init segment) — the session must be reused.
+            encryptedCb({
+                initData: new Uint8Array([1, 2, 3]),
+                initDataType: 'cenc',
+            });
+            await flushPromises();
+            expect(localErrors).not.toHaveBeenCalled();
+            expect(mediaKeys.createSession).toHaveBeenCalledTimes(1); // reused
+            controller.dispose();
+        });
+        it('ignores encrypted events when the manifest supplies pssh', async () => {
+            // The proactive manifest-pssh path owns session creation, so in-band
+            // `encrypted` events (e.g. a re-appended init segment on an ABR
+            // switch) must not spawn a duplicate session.
+            const drmInfoWithPssh = {
+                ...drmInfo,
+                contentProtections: [
+                    { keySystem: DrmKeySystem.WIDEVINE, pssh: 'AAAA' },
+                ],
+            };
+            drmController.setBufferingDrmInfo(drmInfoWithPssh);
+            await emitEncrypted(new Uint8Array([1, 2, 3]));
+            expect(errorSpy).not.toHaveBeenCalled();
+            expect(mediaKeys.createSession).not.toHaveBeenCalled();
+        });
         describe('and the drm controller is disposed', () => {
             it('does nothing', async () => {
                 drmController.dispose();
@@ -613,6 +665,29 @@ describe('DrmControllerImpl', () => {
         });
     });
     describe('when a session message event is observed', () => {
+        it('does not update the session when disposed before the license resolves', async () => {
+            let resolveLicense = () => { };
+            licenseProvider.and.returnValue(new Promise((res) => {
+                resolveLicense = res;
+            }));
+            drmController = new DrmControllerImpl(deps, {
+                keySystems: {
+                    [DrmKeySystem.WIDEVINE]: {
+                        licenseServer: { url: 'http://example.com/widevine' },
+                    },
+                },
+                licenseProvider,
+            });
+            drmController.setBufferingDrmInfo(drmInfo);
+            await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
+            getSession(0).dispatch('message', { message: new ArrayBuffer(1) });
+            await flushPromises();
+            // License in flight — dispose, then let it resolve.
+            drmController.dispose();
+            resolveLicense(new ArrayBuffer(2));
+            await flushPromises();
+            expect(getSession(0).update).not.toHaveBeenCalled();
+        });
         it('calls the licenseProvider with resolved licenseServer options', async () => {
             drmController = new DrmControllerImpl(deps, {
                 keySystems: {
@@ -666,6 +741,24 @@ describe('DrmControllerImpl', () => {
                 }, message);
             }
         });
+        it('falls back to the wildcard key system license server', async () => {
+            drmController = new DrmControllerImpl(deps, {
+                keySystems: {
+                    // Only a wildcard entry — no per-key-system configuration.
+                    '*': {
+                        licenseServer: () => ({
+                            url: 'http://example.com/wildcard',
+                        }),
+                    },
+                },
+                licenseProvider,
+            });
+            drmController.setBufferingDrmInfo(drmInfo);
+            await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
+            const message = new ArrayBuffer(1);
+            await emitMessage(0, message);
+            expect(licenseProvider).toHaveBeenCalledOnceWith(DrmKeySystem.WIDEVINE, { url: 'http://example.com/wildcard' }, message);
+        });
         describe('when license takes too long to resolve', () => {
             it('emits an error event', async () => {
                 drmController = new DrmControllerImpl(deps, {

package/dist/unit/types/current/index.d.ts

@@ -25,10 +25,8 @@ import './global/configureVinylGlobal.test';
 import './global/environment.test';
 import './global/globalRef.test';
 import './global/PlayerRegistry.test';
-import './patch/media/MediaElementPatchOptions.test';
-import './patch/media/patches/createPreventStallsPatch.test';
-import './patch/media/patches/createUnreliablePlaybackEventsPatch.test';
-import './patch/media/patchMediaElement.test';
+import './playback/createStallDetector.test';
+import './playback/createStallMonitor.test';
 import './playback/error/InvalidSeekError.test';
 import './playback/error/ReportableMediaError.test';
 import './playback/logging/mediaErrorToJson.test';
@@ -116,6 +114,7 @@ import './util/media/codecOverrides.test';
 import './util/media/codecSupport.test';
 import './util/media/getAudioContext.test';
 import './util/media/mediaSource.test';
+import './util/media/mimeType.test';
 import './util/media/sourceBuffer.test';
 import './vinyl/createVinylFactories.test';
 import './vinyl/playerConfigFactory.test';

package/dist/unit/types/current/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../test/unit/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../test/unit/index.ts"],"names":[],"mappings":"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"}

package/dist/unit/types/current/index.js

@@ -25,10 +25,8 @@ import './global/configureVinylGlobal.test';
 import './global/environment.test';
 import './global/globalRef.test';
 import './global/PlayerRegistry.test';
-import './patch/media/MediaElementPatchOptions.test';
-import './patch/media/patches/createPreventStallsPatch.test';
-import './patch/media/patches/createUnreliablePlaybackEventsPatch.test';
-import './patch/media/patchMediaElement.test';
+import './playback/createStallDetector.test';
+import './playback/createStallMonitor.test';
 import './playback/error/InvalidSeekError.test';
 import './playback/error/ReportableMediaError.test';
 import './playback/logging/mediaErrorToJson.test';
@@ -116,6 +114,7 @@ import './util/media/codecOverrides.test';
 import './util/media/codecSupport.test';
 import './util/media/getAudioContext.test';
 import './util/media/mediaSource.test';
+import './util/media/mimeType.test';
 import './util/media/sourceBuffer.test';
 import './vinyl/createVinylFactories.test';
 import './vinyl/playerConfigFactory.test';

package/dist/unit/types/current/playback/PlaybackControllerImpl.test.js

@@ -78,6 +78,29 @@ describe('PlaybackController', () => {
                 if (!controller.disposed)
                     controller.dispose();
             });
+            describe('stall detection', () => {
+                it('does not emit stallEntered before playback is observed', async () => {
+                    const enteredSpy = createEventSpy(controller, 'stallEntered');
+                    await clock.tick(2);
+                    expect(enteredSpy).not.toHaveBeenCalled();
+                });
+                it('emits stallEntered when the play head freezes while playing and stallEnded on resume', async () => {
+                    const enteredSpy = createEventSpy(controller, 'stallEntered');
+                    const endedSpy = createEventSpy(controller, 'stallEnded');
+                    media.dispatchEvent(mockEvent('playing'));
+                    media.currentTime = 1;
+                    media.dispatchEvent(mockEvent('timeupdate'));
+                    // Frozen for the 1s default threshold.
+                    await clock.tick(1);
+                    expect(enteredSpy).toHaveBeenCalledTimes(1);
+                    expect(endedSpy).not.toHaveBeenCalled();
+                    // Play head advances -> stall ends with reason 'playing'.
+                    media.currentTime = 2;
+                    media.dispatchEvent(mockEvent('timeupdate'));
+                    expect(endedSpy).toHaveBeenCalledTimes(1);
+                    expect(endedSpy.calls.mostRecent().args[0].reason).toBe('playing');
+                });
+            });
             it('assigns properties, methods, and events directly to a media object', () => {
                 expect(controller.buffered).toBeInstanceOf(ReadonlyRangesImpl);
                 testDelegate(controller, 'currentTime', 2);
@@ -191,6 +214,135 @@ describe('PlaybackController', () => {
                         },
                     });
                 }
+                /**
+                 * Simulates WebKit reverting a seek: the first `revertCount`
+                 * seeks land at `revertTo` instead of the requested time; later
+                 * seeks land on the requested time.
+                 */
+                function enableSeekWithReverts(revertTo, revertCount) {
+                    let currentTime = 0;
+                    let reverts = revertCount;
+                    Object.defineProperty(media, 'currentTime', {
+                        get() {
+                            return currentTime;
+                        },
+                        set(value) {
+                            currentTime = reverts-- > 0 ? revertTo : value;
+                            media.dispatchEvent(mockEvent('seeking'));
+                            void (async () => {
+                                await flushPromises();
+                                media.dispatchEvent(mockEvent('seeked'));
+                            })();
+                        },
+                    });
+                }
+                /**
+                 * Simulates a WebKit cold-seek stall: `seeking` fires but
+                 * `seeked` does not for the first `stuckAttempts` attempts, then
+                 * completes.
+                 */
+                function enableStuckSeek(stuckAttempts) {
+                    let currentTime = 0;
+                    let attempt = 0;
+                    Object.defineProperty(media, 'currentTime', {
+                        get() {
+                            return currentTime;
+                        },
+                        set(value) {
+                            currentTime = value;
+                            media.dispatchEvent(mockEvent('seeking'));
+                            if (attempt++ >= stuckAttempts) {
+                                void (async () => {
+                                    await flushPromises();
+                                    media.dispatchEvent(mockEvent('seeked'));
+                                })();
+                            }
+                        },
+                    });
+                }
+                it('warms the decoder and retries when a seek stalls', async () => {
+                    enableStuckSeek(1); // first attempt hangs, retry completes
+                    setSeekable([[0, 30]]);
+                    media.paused = false;
+                    const seek = controller.seekTo(5);
+                    // Flush to arm the first attempt's seeked timeout, then
+                    // advance to fire it; the retry lands via its seeked event.
+                    await clock.tick(0, 4);
+                    await seek;
+                    // Warmed the decoder with play(), then landed on retry.
+                    expect(media.play).toHaveBeenCalled();
+                    expect(media.currentTime).toBe(5);
+                });
+                it('gives up after the retry limit when a seek never completes', async () => {
+                    enableStuckSeek(99); // never completes
+                    setSeekable([[0, 30]]);
+                    media.paused = false;
+                    const seek = controller.seekTo(5);
+                    // Leading flush arms the initial attempt's seeked timeout;
+                    // each subsequent tick fires one and arms the next retry
+                    // (initial + SEEK_RETRY_LIMIT attempts all time out).
+                    await clock.tick(0, 4, 4, 4);
+                    await seek;
+                    expect(media.play).toHaveBeenCalled();
+                });
+                it('stops retrying when a re-seek never re-enters seeking', async () => {
+                    let sets = 0;
+                    let currentTime = 0;
+                    Object.defineProperty(media, 'currentTime', {
+                        get() {
+                            return currentTime;
+                        },
+                        set(value) {
+                            currentTime = value;
+                            // Only the first attempt emits `seeking`; re-seeks to
+                            // the same position stay silent (WebKit), so their
+                            // seeking wait times out and returns null.
+                            if (sets++ === 0) {
+                                media.dispatchEvent(mockEvent('seeking'));
+                            }
+                        },
+                    });
+                    setSeekable([[0, 30]]);
+                    media.paused = false;
+                    const seek = controller.seekTo(5);
+                    await clock.tick(0, 4, 4, 4);
+                    await seek;
+                    expect(media.currentTime).toBe(5);
+                });
+                it('rejects a seek disposed while awaiting seeked', async () => {
+                    setSeekable([[0, 30]]);
+                    media.paused = false;
+                    const seek = controller.seekTo(5);
+                    media.dispatchEvent(mockEvent('seeking'));
+                    await flushPromises();
+                    controller.dispose();
+                    await expectAsync(seek).toBeRejectedWithError(AbortError);
+                });
+                it('re-seeks when WebKit lands the play head off target', async () => {
+                    enableSeekWithReverts(20, 1);
+                    setSeekable([[0, 30]]);
+                    media.paused = true;
+                    await controller.seekTo(5);
+                    expect(media.currentTime).toBeCloseTo(5);
+                });
+                it('gives up re-seeking after the retry limit', async () => {
+                    enableSeekWithReverts(20, 99);
+                    setSeekable([[0, 30]]);
+                    media.paused = true;
+                    await controller.seekTo(5);
+                    expect(media.currentTime).toBe(20);
+                });
+                it('stops re-seeking when a newer seek supersedes', async () => {
+                    enableSeekWithReverts(20, 99);
+                    setSeekable([[0, 30]]);
+                    media.paused = true;
+                    const first = controller.seekTo(5);
+                    const second = controller.seekTo(9);
+                    await Promise.allSettled([first, second]);
+                    // Both landed at the reverted position; the first stopped
+                    // re-seeking once superseded rather than fighting the newer.
+                    expect(media.currentTime).toBe(20);
+                });
                 it('waits for metadata before initiating seek', async () => {
                     enableSeekAutoComplete();
                     const seeked = controller.seekTo(3);
@@ -199,6 +351,19 @@ describe('PlaybackController', () => {
                     await seeked;
                     expect(media.currentTime).toBe(3);
                 });
+                it('fabricates a playing event if playback resumes after a seek without one', async () => {
+                    enableSeekAutoComplete();
+                    setSeekable([[0, 10]]);
+                    media.paused = false;
+                    const playingSpy = createSpy('playing');
+                    controller.on('playing', playingSpy);
+                    await controller.seekTo(3);
+                    // The play head advances but no 'playing' event fires; the
+                    // post-seek stall detector fabricates one.
+                    media.currentTime = 3.5;
+                    await clock.tick(0.25);
+                    expect(playingSpy).toHaveBeenCalled();
+                });
                 it('does not let a metadata-deferred seek clobber a newer seek', async () => {
                     // Reproduces the real race: the activate-time seek to the
                     // track start parks waiting for the `loadedmetadata` EVENT.

package/dist/unit/types/current/playback/createStallDetector.test.d.ts

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

package/dist/unit/types/current/playback/createStallDetector.test.d.ts.map

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

package/dist/unit/types/current/playback/createStallDetector.test.js

@@ -0,0 +1,163 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createStallDetector } from '@amazon/vinyl';
+import { implementEventFakes, MockHTMLAudioElement, mockEvent, MockTimeRanges, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
+describe('createStallDetector', () => {
+    const clock = useMockTime();
+    let media;
+    let fabricatePlaying;
+    let stop;
+    beforeEach(() => {
+        media = new MockHTMLAudioElement();
+        implementEventFakes(media);
+        media.play.and.returnValue(Promise.resolve());
+        media.paused = false;
+        media.ended = false;
+        media.readyState = media.HAVE_ENOUGH_DATA;
+        media.currentTime = 10;
+        media.buffered = new MockTimeRanges([[0, 100]]);
+        fabricatePlaying = jasmine.createSpy('fabricatePlaying');
+    });
+    afterEach(() => {
+        stop?.();
+    });
+    function detect(overrides = {}) {
+        stop = createStallDetector(media, { fabricatePlaying, ...overrides });
+    }
+    /** Advances the mock clock by `n` default poll intervals. */
+    async function poll(n) {
+        for (let i = 0; i < n; i++) {
+            await clock.tick(0.25);
+        }
+    }
+    describe('a stall inside ready buffered data', () => {
+        it('nudges the play head once frozen past the stall threshold', async () => {
+            detect();
+            // Threshold is 0.75s = three polls; the third nudges by stallSkip.
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('does not recover before the stall threshold', async () => {
+            detect();
+            await poll(2);
+            expect(media.currentTime).toBe(10);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('nudges even when the ready state is low (iOS reports a stale readyState)', async () => {
+            media.readyState = media.HAVE_METADATA;
+            detect();
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('keeps nudging, then gives up after maxAttempts', async () => {
+            detect();
+            // Default maxAttempts is 3, so at most three nudges (one every 3 polls).
+            await poll(12);
+            expect(media.currentTime).toBeCloseTo(10.3);
+            // Further polls do nothing; the detector has stopped.
+            await poll(6);
+            expect(media.currentTime).toBeCloseTo(10.3);
+        });
+    });
+    describe('a stall with no data at the playhead', () => {
+        it('does not recover when the playhead is outside all buffered ranges', async () => {
+            media.buffered = new MockTimeRanges([[50, 100]]);
+            detect();
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+            expect(fabricatePlaying).not.toHaveBeenCalled();
+        });
+        it('does not recover at the end of buffered data', async () => {
+            // Within the default end margin (0.5s) of the buffer end.
+            media.buffered = new MockTimeRanges([[0, 10.3]]);
+            detect();
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+        });
+        it('nudges at the end of the media (stuck end-of-track on src)', async () => {
+            // Buffer ends at the media duration: no more data is coming, so a
+            // freeze here is a stuck end-of-track and a nudge drives it to end.
+            media.buffered = new MockTimeRanges([[0, 10.3]]);
+            media.duration = 10.3;
+            detect();
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('nudges outside buffered ranges when nudgeUnbuffered is set', async () => {
+            // WebKit path: re-issue the seek even though buffered looks empty.
+            media.buffered = new MockTimeRanges([[50, 100]]);
+            detect({ nudgeUnbuffered: true });
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1);
+        });
+        it('stops when the source is emptied', async () => {
+            detect();
+            media.dispatchEvent(mockEvent('emptied'));
+            // Stopped: a later freeze in buffered data is not nudged.
+            await poll(6);
+            expect(media.currentTime).toBe(10);
+        });
+    });
+    describe('fabricating a playing event', () => {
+        it('fabricates when the head progresses without a playing event', async () => {
+            detect();
+            media.currentTime = 20;
+            await poll(1);
+            expect(fabricatePlaying).toHaveBeenCalledTimes(1);
+            // Detector stopped; a later freeze is not recovered.
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+        });
+        it('does not fabricate when a real playing event fired and it keeps progressing', async () => {
+            detect();
+            media.dispatchEvent(mockEvent('playing'));
+            media.currentTime = 20;
+            await poll(6);
+            expect(fabricatePlaying).not.toHaveBeenCalled();
+        });
+        it('fabricates after reviving a stall even if a playing event fired earlier', async () => {
+            // iOS pattern: a playing event fires, then playback stalls.
+            media.readyState = media.HAVE_METADATA;
+            detect();
+            media.dispatchEvent(mockEvent('playing'));
+            await poll(3);
+            expect(media.currentTime).toBeCloseTo(10.1); // nudged (recovered)
+            // The recovery revives playback.
+            media.currentTime = 11;
+            await poll(1);
+            expect(fabricatePlaying).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('when the element is not advancing by design', () => {
+        it('does not recover while paused', async () => {
+            media.paused = true;
+            detect();
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+            expect(media.currentTime).toBe(10);
+        });
+        it('does not recover once ended', async () => {
+            media.ended = true;
+            detect();
+            await poll(6);
+            expect(media.play).not.toHaveBeenCalled();
+            expect(media.currentTime).toBe(10);
+        });
+    });
+    it('honors provided options', async () => {
+        detect({
+            pollInterval: 0.5,
+            stallThreshold: 1,
+            bufferEndMargin: 0.2,
+            stallSkip: 0.25,
+            maxAttempts: 1,
+        });
+        // Threshold 1s = two 0.5s polls; one nudge of 0.25, then it gives up.
+        for (let i = 0; i < 6; i++)
+            await clock.tick(0.5);
+        expect(media.currentTime).toBeCloseTo(10.25);
+    });
+});

package/dist/unit/types/current/playback/createStallMonitor.test.d.ts

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

package/dist/unit/types/current/playback/createStallMonitor.test.d.ts.map

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