@amazon/vinyl 3.0.1 → 3.2.0

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, {
@@ -857,28 +950,70 @@ describe('DrmControllerImpl', () => {
             drmController.setBufferingDrmInfo(drmInfo);
             await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
             await emitMessage(0, new ArrayBuffer(1));
-            expect(spy).toHaveBeenCalledOnceWith(objectContaining({
+            expect(spy).toHaveBeenCalledWith(objectContaining({
                 kind: 'license',
                 startTime: any(Number),
                 endTime: any(Number),
             }));
         });
+        it('measures the key setup, contiguous with and before the license', async () => {
+            licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
+            const spy = createEventSpy(drmController, 'loadSpanMeasured');
+            drmController.setBufferingDrmInfo(drmInfo, { trackUri: 'track-a' });
+            await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
+            await emitMessage(0, new ArrayBuffer(1));
+            const spans = spy.calls.all().map((call) => call.args[0]);
+            expect(spans.map((span) => span.kind)).toEqual([
+                'keySetup',
+                'license',
+            ]);
+            const [keySetup, license] = spans;
+            expect(keySetup.trackUri).toEqual('track-a');
+            expect(keySetup.endTime).toEqual(license.startTime);
+        });
+        it('carries the content mime and content type on the license span', async () => {
+            licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
+            const spy = createEventSpy(drmController, 'loadSpanMeasured');
+            drmController.setBufferingDrmInfo(drmInfo);
+            await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
+            await emitMessage(0, new ArrayBuffer(1));
+            expect(spy).toHaveBeenCalledWith(objectContaining({
+                kind: 'license',
+                mimeType: 'audio/mp4',
+                contentType: 'audio',
+            }));
+        });
         it('does not measure a failed license exchange', async () => {
             licenseProvider.and.rejectWith(new Error('license failed'));
             const spy = createEventSpy(drmController, 'loadSpanMeasured');
             drmController.setBufferingDrmInfo(drmInfo);
             await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
             await emitMessage(0, new ArrayBuffer(1));
-            expect(spy).not.toHaveBeenCalled();
+            // Setup completed at the message, so keySetup is still measured.
+            expect(spy).not.toHaveBeenCalledWith(objectContaining({ kind: 'license' }));
             errorSpy.calls.reset();
         });
+        it('measures key setup only for the first session of a track load', async () => {
+            licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
+            const spy = createEventSpy(drmController, 'loadSpanMeasured');
+            drmController.setBufferingDrmInfo(drmInfo, { trackUri: 'track-a' });
+            await emitEncrypted(new Uint8Array([1]), 'cenc');
+            await emitEncrypted(new Uint8Array([2]), 'cenc');
+            expect(mediaKeys.createSession).toHaveBeenCalledTimes(2);
+            await emitMessage(0, new ArrayBuffer(1));
+            await emitMessage(1, new ArrayBuffer(1));
+            const keySetupSpans = spy.calls
+                .all()
+                .filter((call) => call.args[0].kind === 'keySetup');
+            expect(keySetupSpans.length).toEqual(1);
+        });
         it('attributes the license span to the buffering track uri', async () => {
             licenseProvider.and.resolveTo(new Uint8Array([1]).buffer);
             const spy = createEventSpy(drmController, 'loadSpanMeasured');
             drmController.setBufferingDrmInfo(drmInfo, { trackUri: 'track-a' });
             await emitEncrypted(new Uint8Array([1, 2, 3]), 'cenc');
             await emitMessage(0, new ArrayBuffer(1));
-            expect(spy).toHaveBeenCalledOnceWith(objectContaining({
+            expect(spy).toHaveBeenCalledWith(objectContaining({
                 kind: 'license',
                 trackUri: 'track-a',
             }));
@@ -912,12 +1047,14 @@ describe('DrmControllerImpl', () => {
             // on the controller's current buffering track.
             await emitMessage(1, new ArrayBuffer(1));
             await emitMessage(0, new ArrayBuffer(1));
-            expect(spy).toHaveBeenCalledTimes(2);
-            expect(spy).toHaveBeenCalledWith(objectContaining({
-                kind: 'license',
-                trackUri: 'track-preloaded',
-            }));
-            expect(spy).toHaveBeenCalledWith(objectContaining({ kind: 'license', trackUri: 'track-active' }));
+            const licenseTrackUris = spy.calls
+                .all()
+                .map((call) => call.args[0])
+                .filter((span) => span.kind === 'license')
+                .map((span) => span.trackUri);
+            expect(licenseTrackUris.length).toEqual(2);
+            expect(licenseTrackUris).toContain('track-preloaded');
+            expect(licenseTrackUris).toContain('track-active');
         });
     });
     describe('serverCertificate', () => {

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