@amazon/vinyl 3.2.1 → 3.2.2

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/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/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/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/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 () => {