@amazon/vinyl 3.2.0 → 3.2.2

package/dist/types/ts3.7/ad/AdControllerImpl.d.ts

@@ -7,6 +7,15 @@ import { AdsProvider } from './AdsProvider';
  * The % playhead start tolerance for playback progress when emitting ad progress events.
  */
 export declare const AD_START_TOLERANCE = 0.05;
+/**
+ * When a break's X-PLAYOUT-LIMIT budget is reached, an ad whose real media end is
+ * within this many seconds is allowed to finish on its own `ended` rather than
+ * being cut. The limit is a coarse, often whole-second budget while the media's
+ * true length is fractional, so without this grace an ad effectively as long as
+ * its budget would be clipped a fraction short. The tolerance is measured against
+ * the playback-reported (media) duration, not the ad's declared duration.
+ */
+export declare const PLAYOUT_LIMIT_TOLERANCE = 1;
 export interface AdControllerImplDeps {
     readonly playbackController: ReadonlyPlaybackController;
 }
@@ -129,8 +138,15 @@ export declare class AdControllerImpl extends EventHostImpl<AdEventMap> implemen
     private emitAdProgressEvents;
     private emitTimeUpdate;
     /**
-     * Ads breaks can have a playout limit that may cut off ad playback.
-     * End the ad if that limit is reached.
+     * Enforces the break-level playout limit (X-PLAYOUT-LIMIT): a budget shared
+     * across all of the break's ads. When cumulative playout reaches it, the
+     * whole break ends, dropping any ads that have not started.
+     *
+     * This is deliberately NOT a per-ad cap. Each ad asset is its own source and
+     * ends on its media `ended` (see the 'ended' handler), which is what advances
+     * a multi-ad break. Ending an ad at its declared per-ad DURATION instead would
+     * truncate the real asset whenever a packager under-declares it — e.g. rounds
+     * a 6.732s asset down to a whole-second 6 — cutting off the fractional tail.
      */
     private enforcePlayoutLimits;
     private setPendingBreaks;

package/dist/types/ts3.7/drm/DrmControllerImpl.d.ts

@@ -12,6 +12,12 @@ import { TrackUri } from '../track/Track';
  * indicates a stalled promise result from the license provider.
  */
 export declare const LICENSE_TIMEOUT = 90;
+/**
+ * An excessive number of concurrent key sessions. Sessions are expected to be
+ * closed as tracks deactivate; a count this high signals sessions are leaking
+ * (never closing) rather than a legitimate playback need.
+ */
+export declare const EXCESSIVE_SESSION_COUNT = 20;
 /**
  * Dependencies for creating DrmController.
  */

package/dist/types/ts3.7/playback/PlaybackControllerImpl.d.ts

@@ -63,12 +63,11 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
     private _playing;
     private _seeking;
     private _waiting;
-    private _seekId;
+    private readonly seekAbortSlot;
     private stopStallDetection;
     private userVolume;
     private _pendingPlay;
     private playAbort;
-    private disposeAbort;
     readonly options: PlaybackControllerImplOptions;
     constructor(deps: PlaybackControllerImplDeps, options?: Partial<PlaybackControllerImplOptions>);
     /**
@@ -174,6 +173,13 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
     get hasMetadata(): boolean;
     get playIsPending(): boolean;
     seekTo(time: number, tolerance?: number): Promise<void>;
+    /**
+     * The body of a single {@link seekTo} attempt. Extracted so {@link seekTo}
+     * can wrap it with per-seek abort/supersession handling. `seekAbort` is
+     * aborted when a newer seek supersedes this one (or on dispose).
+     * @private
+     */
+    private doSeek;
     /**
      * Dispatches a readyStateChange event when {@link readyState} changes.
      * @private

package/dist/types/ts3.7/track/mse/MseTrack.d.ts

@@ -45,7 +45,6 @@ export declare class MseTrack extends TrackBase {
     protected readonly deps: MseTrackDeps;
     get textTrackController(): (TextTrackController | null);
     private readonly streams;
-    private readonly disposeAbort;
     private lastPreloadOptions;
     private readonly allFetchedRanges;
     private readonly _fetchedRanges;

package/dist/types/ts4.1/ad/AdControllerImpl.d.ts

@@ -7,6 +7,15 @@ import type { AdsProvider } from './AdsProvider';
  * The % playhead start tolerance for playback progress when emitting ad progress events.
  */
 export declare const AD_START_TOLERANCE = 0.05;
+/**
+ * When a break's X-PLAYOUT-LIMIT budget is reached, an ad whose real media end is
+ * within this many seconds is allowed to finish on its own `ended` rather than
+ * being cut. The limit is a coarse, often whole-second budget while the media's
+ * true length is fractional, so without this grace an ad effectively as long as
+ * its budget would be clipped a fraction short. The tolerance is measured against
+ * the playback-reported (media) duration, not the ad's declared duration.
+ */
+export declare const PLAYOUT_LIMIT_TOLERANCE = 1;
 export interface AdControllerImplDeps {
     readonly playbackController: ReadonlyPlaybackController;
 }
@@ -129,8 +138,15 @@ export declare class AdControllerImpl extends EventHostImpl<AdEventMap> implemen
     private emitAdProgressEvents;
     private emitTimeUpdate;
     /**
-     * Ads breaks can have a playout limit that may cut off ad playback.
-     * End the ad if that limit is reached.
+     * Enforces the break-level playout limit (X-PLAYOUT-LIMIT): a budget shared
+     * across all of the break's ads. When cumulative playout reaches it, the
+     * whole break ends, dropping any ads that have not started.
+     *
+     * This is deliberately NOT a per-ad cap. Each ad asset is its own source and
+     * ends on its media `ended` (see the 'ended' handler), which is what advances
+     * a multi-ad break. Ending an ad at its declared per-ad DURATION instead would
+     * truncate the real asset whenever a packager under-declares it — e.g. rounds
+     * a 6.732s asset down to a whole-second 6 — cutting off the fractional tail.
      */
     private enforcePlayoutLimits;
     private setPendingBreaks;

package/dist/types/ts4.1/drm/DrmControllerImpl.d.ts

@@ -13,6 +13,12 @@ import type { TrackUri } from '../track/Track';
  * indicates a stalled promise result from the license provider.
  */
 export declare const LICENSE_TIMEOUT = 90;
+/**
+ * An excessive number of concurrent key sessions. Sessions are expected to be
+ * closed as tracks deactivate; a count this high signals sessions are leaking
+ * (never closing) rather than a legitimate playback need.
+ */
+export declare const EXCESSIVE_SESSION_COUNT = 20;
 /**
  * Dependencies for creating DrmController.
  */

package/dist/types/ts4.1/playback/PlaybackControllerImpl.d.ts

@@ -65,12 +65,11 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
     private _playing;
     private _seeking;
     private _waiting;
-    private _seekId;
+    private readonly seekAbortSlot;
     private stopStallDetection;
     private userVolume;
     private _pendingPlay;
     private playAbort;
-    private disposeAbort;
     readonly options: PlaybackControllerImplOptions;
     constructor(deps: PlaybackControllerImplDeps, options?: Partial<PlaybackControllerImplOptions>);
     /**
@@ -176,6 +175,13 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
     get hasMetadata(): boolean;
     get playIsPending(): boolean;
     seekTo(time: number, tolerance?: number): Promise<void>;
+    /**
+     * The body of a single {@link seekTo} attempt. Extracted so {@link seekTo}
+     * can wrap it with per-seek abort/supersession handling. `seekAbort` is
+     * aborted when a newer seek supersedes this one (or on dispose).
+     * @private
+     */
+    private doSeek;
     /**
      * Dispatches a readyStateChange event when {@link readyState} changes.
      * @private

package/dist/types/ts4.1/track/mse/MseTrack.d.ts

@@ -46,7 +46,6 @@ export declare class MseTrack extends TrackBase {
     protected readonly deps: MseTrackDeps;
     get textTrackController(): (TextTrackController | null);
     private readonly streams;
-    private readonly disposeAbort;
     private lastPreloadOptions;
     private readonly allFetchedRanges;
     private readonly _fetchedRanges;

package/dist/types/ts4.7/ad/AdControllerImpl.d.ts

@@ -7,6 +7,15 @@ import type { AdsProvider } from './AdsProvider';
  * The % playhead start tolerance for playback progress when emitting ad progress events.
  */
 export declare const AD_START_TOLERANCE = 0.05;
+/**
+ * When a break's X-PLAYOUT-LIMIT budget is reached, an ad whose real media end is
+ * within this many seconds is allowed to finish on its own `ended` rather than
+ * being cut. The limit is a coarse, often whole-second budget while the media's
+ * true length is fractional, so without this grace an ad effectively as long as
+ * its budget would be clipped a fraction short. The tolerance is measured against
+ * the playback-reported (media) duration, not the ad's declared duration.
+ */
+export declare const PLAYOUT_LIMIT_TOLERANCE = 1;
 export interface AdControllerImplDeps {
     readonly playbackController: ReadonlyPlaybackController;
 }
@@ -129,8 +138,15 @@ export declare class AdControllerImpl extends EventHostImpl<AdEventMap> implemen
     private emitAdProgressEvents;
     private emitTimeUpdate;
     /**
-     * Ads breaks can have a playout limit that may cut off ad playback.
-     * End the ad if that limit is reached.
+     * Enforces the break-level playout limit (X-PLAYOUT-LIMIT): a budget shared
+     * across all of the break's ads. When cumulative playout reaches it, the
+     * whole break ends, dropping any ads that have not started.
+     *
+     * This is deliberately NOT a per-ad cap. Each ad asset is its own source and
+     * ends on its media `ended` (see the 'ended' handler), which is what advances
+     * a multi-ad break. Ending an ad at its declared per-ad DURATION instead would
+     * truncate the real asset whenever a packager under-declares it — e.g. rounds
+     * a 6.732s asset down to a whole-second 6 — cutting off the fractional tail.
      */
     private enforcePlayoutLimits;
     private setPendingBreaks;

package/dist/types/ts4.7/drm/DrmControllerImpl.d.ts

@@ -12,6 +12,12 @@ import type { TrackUri } from '../track/Track';
  * indicates a stalled promise result from the license provider.
  */
 export declare const LICENSE_TIMEOUT = 90;
+/**
+ * An excessive number of concurrent key sessions. Sessions are expected to be
+ * closed as tracks deactivate; a count this high signals sessions are leaking
+ * (never closing) rather than a legitimate playback need.
+ */
+export declare const EXCESSIVE_SESSION_COUNT = 20;
 /**
  * Dependencies for creating DrmController.
  */

package/dist/types/ts4.7/playback/PlaybackControllerImpl.d.ts

@@ -63,12 +63,11 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
     private _playing;
     private _seeking;
     private _waiting;
-    private _seekId;
+    private readonly seekAbortSlot;
     private stopStallDetection;
     private userVolume;
     private _pendingPlay;
     private playAbort;
-    private disposeAbort;
     readonly options: PlaybackControllerImplOptions;
     constructor(deps: PlaybackControllerImplDeps, options?: Partial<PlaybackControllerImplOptions>);
     /**
@@ -174,6 +173,13 @@ export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackContro
     get hasMetadata(): boolean;
     get playIsPending(): boolean;
     seekTo(time: number, tolerance?: number): Promise<void>;
+    /**
+     * The body of a single {@link seekTo} attempt. Extracted so {@link seekTo}
+     * can wrap it with per-seek abort/supersession handling. `seekAbort` is
+     * aborted when a newer seek supersedes this one (or on dispose).
+     * @private
+     */
+    private doSeek;
     /**
      * Dispatches a readyStateChange event when {@link readyState} changes.
      * @private

package/dist/types/ts4.7/track/mse/MseTrack.d.ts

@@ -45,7 +45,6 @@ export declare class MseTrack extends TrackBase {
     protected readonly deps: MseTrackDeps;
     get textTrackController(): TextTrackController | null;
     private readonly streams;
-    private readonly disposeAbort;
     private lastPreloadOptions;
     private readonly allFetchedRanges;
     private readonly _fetchedRanges;

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

@@ -896,7 +896,6 @@ describe('AdControllerImpl', () => {
             await setContent(c, trackAds(makeBreak({
                 startTime: 10,
                 duration: 20,
-                // Null per-ad duration so the per-ad cap does not end it.
                 ads: [
                     {
                         id: 'a1',
@@ -990,7 +989,11 @@ describe('AdControllerImpl', () => {
         });
     });
     describe('ad duration and playout limits', () => {
-        it('advances to the next ad when one reaches its declared duration', async () => {
+        it('advances to the next ad on the ad media ended, not its declared duration', async () => {
+            // Each ad asset is its own source; a non-final ad advances on its own
+            // media `ended`. The declared per-ad duration must NOT end it early —
+            // a packager may under-declare it (whole-second rounding), which would
+            // otherwise truncate the real asset.
             const c = createController();
             await setContent(c, trackAds(makeBreak({
                 startTime: 0,
@@ -999,7 +1002,7 @@ describe('AdControllerImpl', () => {
                     {
                         id: 'a1',
                         startTime: 0,
-                        duration: 5,
+                        duration: 5, // declared, server-rounded
                         uri: 'ad1.m3u8',
                     },
                     {
@@ -1014,10 +1017,54 @@ describe('AdControllerImpl', () => {
             await flush();
             expect(c.currentAd?.id).toBe('a1');
             playbackController.dispatch('playing', {}); // timeStart = 0
-            updateTime(6); // elapsed 6 >= a1.duration 5 → advance
+            // Past the declared 5s, still within a1's real content — must NOT advance.
+            updateTime(6);
+            await flush();
+            expect(c.currentAd?.id).toBe('a1');
+            // a1's media ends -> advance to a2.
+            playbackController.dispatch('ended', {
+                previous: false,
+                current: true,
+            });
             await flush();
             expect(c.currentAd?.id).toBe('a2');
         });
+        it('does not cut the final/only ad at its declared duration; it ends on media ended', async () => {
+            // The ad server declares DURATION in whole seconds, but the asset's
+            // real content is longer (6.732s here). The only ad must play to its
+            // media `ended`, not be truncated at the rounded declared duration.
+            const c = createController();
+            const ended = [];
+            c.on('adEnded', (e) => ended.push(e.ad.id));
+            await setContent(c, trackAds(makeBreak({
+                startTime: 0,
+                duration: 30,
+                ads: [
+                    {
+                        id: 'a1',
+                        startTime: 0,
+                        duration: 6, // declared, server-rounded
+                        uri: 'ad1.m3u8',
+                    },
+                ],
+            })));
+            updateTime(0);
+            await flush();
+            expect(c.currentAd?.id).toBe('a1');
+            playbackController.dispatch('playing', {}); // timeStart = 0
+            // Past the declared 6s, into the real content — must NOT end yet.
+            updateTime(6.5);
+            await flush();
+            expect(c.currentAd?.id).toBe('a1');
+            expect(ended).toEqual([]);
+            // Real media end at 6.732 ends the ad.
+            playbackController.dispatch('ended', {
+                previous: false,
+                current: true,
+            });
+            expect(ended).toEqual(['a1']);
+            expect(c.currentAdBreak).toBeNull();
+        });
         it('ends the whole break when the playout limit is reached, dropping remaining ads', async () => {
             const c = createController();
             const resumes = [];
@@ -1053,6 +1100,65 @@ describe('AdControllerImpl', () => {
             // content still resumes at the cue point (0), not startTime + playout.
             expect(resumes.at(-1)).toBe(0);
         });
+        it('does not cut at the playout limit when the ad is within tolerance of its media end', async () => {
+            // The budget is reached, but the ad's real media end is <1s away, so
+            // it should finish on its own `ended` rather than be clipped. The
+            // tolerance keys off the playback-reported duration, not ad.duration.
+            const c = createController();
+            await setContent(c, trackAds(makeBreak({
+                startTime: 0,
+                duration: null,
+                playoutLimit: 8,
+                ads: [
+                    {
+                        id: 'a1',
+                        startTime: 0,
+                        duration: 20,
+                        uri: 'ad1.m3u8',
+                    },
+                ],
+            })));
+            updateTime(0);
+            await flush();
+            playbackController.dispatch('playing', {}); // timeStart = 0
+            // Media is 8.5s long; at the 8s budget only 0.5s of media remains.
+            playbackController.duration = 8.5;
+            updateTime(8); // cumulative 8 >= limit 8, but within 1s of media end
+            await flush();
+            expect(c.currentAdBreak).not.toBeNull();
+            expect(c.currentAd?.id).toBe('a1');
+            // It finishes on its own media `ended`.
+            playbackController.dispatch('ended', {
+                previous: false,
+                current: true,
+            });
+            await flush();
+            expect(c.currentAdBreak).toBeNull();
+        });
+        it('cuts at the playout limit when the ad has more than the tolerance of media left', async () => {
+            const c = createController();
+            await setContent(c, trackAds(makeBreak({
+                startTime: 0,
+                duration: null,
+                playoutLimit: 8,
+                ads: [
+                    {
+                        id: 'a1',
+                        startTime: 0,
+                        duration: 20,
+                        uri: 'ad1.m3u8',
+                    },
+                ],
+            })));
+            updateTime(0);
+            await flush();
+            playbackController.dispatch('playing', {}); // timeStart = 0
+            // Media is 20s long; at the 8s budget 12s of media remains → cut.
+            playbackController.duration = 20;
+            updateTime(8);
+            await flush();
+            expect(c.currentAdBreak).toBeNull();
+        });
     });
     describe('CUE=ONCE and replay', () => {
         it('replays a non-ONCE break after the playhead seeks back before it', async () => {

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

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { createEmptyMediaQualityMetadata, DrmControllerImpl, DrmError, DrmKeySystem, DrmRobustness, LICENSE_TIMEOUT, ReportableMediaError, } from '@amazon/vinyl';
+import { createEmptyMediaQualityMetadata, DrmControllerImpl, DrmError, DrmKeySystem, DrmRobustness, EXCESSIVE_SESSION_COUNT, LICENSE_TIMEOUT, ReportableMediaError, } from '@amazon/vinyl';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
 import { Abort, base64ToByteArray, bufferToBase64, Deferred, ErrorLevel, ErrorOrigin, never, nextEventAsPromise, ReportableError, setUserAgent, utf16ToUint16Array, } from '@amazon/vinyl-util';
 import { flushPromises, implementEventFakes, MockHTMLAudioElement, MockMediaError, useMockTime, } from '@amazon/vinyl-util/browserTestUtil';
@@ -1321,6 +1321,24 @@ describe('DrmControllerImpl', () => {
             expect(drmController.isEmeSupported()).toBeFalse();
         });
     });
+    describe('excessive sessions', () => {
+        it('warns once when the open session count exceeds the threshold', async () => {
+            drmController.setBufferingDrmInfo(drmInfo);
+            // Distinct init data per event so each opens its own session.
+            for (let i = 0; i < EXCESSIVE_SESSION_COUNT; i++) {
+                await emitEncrypted(new Uint8Array([i]));
+            }
+            expect(drmController.activeSessions).toBe(EXCESSIVE_SESSION_COUNT);
+            expect(logger.value.warn).not.toHaveBeenCalled();
+            // Crossing the threshold warns.
+            await emitEncrypted(new Uint8Array([EXCESSIVE_SESSION_COUNT]));
+            expect(drmController.activeSessions).toBe(EXCESSIVE_SESSION_COUNT + 1);
+            expect(logger.value.warn).toHaveBeenCalledTimes(1);
+            // Further sessions past the threshold don't re-warn.
+            await emitEncrypted(new Uint8Array([EXCESSIVE_SESSION_COUNT + 1]));
+            expect(logger.value.warn).toHaveBeenCalledTimes(1);
+        });
+    });
     describe('closeSessions', () => {
         it('clears active sessions', async () => {
             const sessionCloseSpy = createEventSpy(drmController, 'sessionClose');

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

@@ -496,6 +496,21 @@ describe('PlaybackController', () => {
                     await clock.tick(controller.options.seekTimeout);
                     await seekExpectation;
                 });
+                it('resolves a superseded seek at once when its seeking event never fires', async () => {
+                    // A source swap can leave the original seek's `seeking`
+                    // event unfired (the default mock never emits it). A newer
+                    // seek supersedes it; the stale one must resolve immediately
+                    // rather than hang for the full seekTimeout.
+                    setSeekable([[0, 100]]);
+                    const first = controller.seekTo(50);
+                    const second = controller.seekTo(60);
+                    // No clock tick: the newer seek's abort resolves `first` now.
+                    // (A full-timeout hang would require clock.tick(seekTimeout).)
+                    await expectAsync(first).toBeResolved();
+                    // `second`'s own `seeking` never fires either; park its
+                    // rejection (settled on dispose) so it isn't unhandled.
+                    second.catch(() => undefined);
+                });
                 it('times out pending seeks after seekTimeout', async () => {
                     const pendingSeekExpectation = expectAsync(controller.seekTo(60)).toBeRejectedWithError('seek timed out on seeking event after 30s');
                     setSeekable([[0, 100]]);

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

@@ -115,10 +115,48 @@ describe('createStallMonitor', () => {
         expect(onStallEntered).toHaveBeenCalledTimes(2);
         expect(onStallEnded).toHaveBeenCalledTimes(2);
     });
+    it('does not end and re-detect a stall on a non-advancing timeUpdate', async () => {
+        // Browsers emit `timeUpdate` even while the play head is frozen, with an unchanged (or
+        // briefly backward) currentTime. These must not be treated as progress, or the stall is
+        // ended and immediately re-detected, doubling the reported events.
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 4, current: 5 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // Still frozen: currentTime hasn't advanced (unchanged, backward, or sub-epsilon jitter).
+        host.dispatch('timeUpdate', { previous: 5, current: 5 });
+        host.dispatch('timeUpdate', { previous: 5, current: 4.99 });
+        host.dispatch('timeUpdate', { previous: 5, current: 5 + 1e-9 });
+        await poll(4);
+        expect(onStallEnded).not.toHaveBeenCalled();
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // A real forward advance ends the stall exactly once.
+        host.dispatch('timeUpdate', { previous: 5, current: 6 });
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
+    it('does not re-detect a stall immediately after resuming via a playing event', async () => {
+        // Resuming via `playing` must restart the freeze clock. Otherwise the poll, still seeing
+        // the stale pre-freeze progress time, immediately re-enters a stall before the first
+        // post-resume timeUpdate arrives — an extra, spurious stall.
+        monitor();
+        host.dispatch('playing', {});
+        host.dispatch('timeUpdate', { previous: 0, current: 1 });
+        await poll(4); // freeze 1s -> stallEntered
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+        // Resume with a 'playing' event and no timeUpdate yet.
+        host.dispatch('playing', {});
+        expect(onStallEnded).toHaveBeenCalledTimes(1);
+        // The freeze clock reset on resume, so a sub-threshold gap is not a new stall.
+        await poll(3); // 0.75s < 1s threshold
+        expect(onStallEntered).toHaveBeenCalledTimes(1);
+    });
     it('stops reporting after disposal', async () => {
         monitor();
         host.dispatch('playing', {});
         stop();
+        stop = undefined; // disposal is single-shot; don't dispose again in afterEach
         await poll(8);
         expect(onStallEntered).not.toHaveBeenCalled();
     });

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

@@ -224,6 +224,21 @@ describe('MseTrack', () => {
                 abort: any(Abort),
             });
         });
+        it('aborts the drm session abort so key sessions close', async () => {
+            // Regression: MSE key sessions must be tied to the per-activation
+            // drmSessionAbort (fired by closeDrmSessions on deactivate), not a
+            // separate abort that never fires — otherwise sessions leak.
+            track = createTrack();
+            await awaitContentTypes();
+            getAudioStream().streamingQuality =
+                createEmptyMediaQualityMetadata();
+            track.activate({});
+            const { abort } = deps.drmController.initializeForPlayback.calls.mostRecent()
+                .args[1];
+            expect(abort.aborted()).toBeFalse();
+            track.deactivate();
+            expect(abort.aborted()).toBeTrue();
+        });
     });
     describe('error', () => {
         it('returns the first emitted error', async () => {