@amazon/vinyl 1.2.1 → 1.2.2

package/dist/types/current/ad/AdBreakInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdBreakInfo.d.ts","sourceRoot":"","sources":["../../../../src/ad/AdBreakInfo.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,WAAW,QAAQ;IACrB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAE3B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;CACjC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAA;AAEjE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IAEvB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IACxB;;;OAGG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAEhC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAA;IAEpC;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAEnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAEhC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IAEtB;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAEpC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAEpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IAE5C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CAC1D;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,WAAW,EAAE,CAAA;AAGhD;;GAEG;AACH,MAAM,WAAW,MAAM;IACnB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IAEnB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAA;CAChC;AAED,MAAM,MAAM,MAAM,GAAG,SAAS,MAAM,EAAE,CAAA"}
+{"version":3,"file":"AdBreakInfo.d.ts","sourceRoot":"","sources":["../../../../src/ad/AdBreakInfo.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,WAAW,QAAQ;IACrB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAE3B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;CACjC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAA;AAEjE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IAEvB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IACxB;;;OAGG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAEhC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAA;IAEpC;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAEnC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAEhC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IAEtB;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAEpC;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAEpC;;;;;;;;OAQG;IACH,QAAQ,CAAC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAA;IAE5C;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CAC1D;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,WAAW,EAAE,CAAA;AAEhD;;GAEG;AACH,MAAM,WAAW,MAAM;IACnB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IAEnB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAE1B,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAEhC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAA;CAChC;AAED,MAAM,MAAM,MAAM,GAAG,SAAS,MAAM,EAAE,CAAA"}

package/dist/types/current/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/current/ad/AdControllerImpl.d.ts.map

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

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

@@ -8,6 +8,15 @@ import { AdError } from './AdError';
  * The % playhead start tolerance for playback progress when emitting ad progress events.
  */
 export 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 const PLAYOUT_LIMIT_TOLERANCE = 1;
 export const defaultAdControllerImplOptions = {
     adLoadTimeout: 15,
     preloadAheadTime: 10,
@@ -173,7 +182,7 @@ export class AdControllerImpl extends EventHostImpl {
      */
     providerInterrupted() {
         const provider = this.adsProvider;
-        return () => provider !== this.adsProvider;
+        return () => this.disposed || provider !== this.adsProvider;
     }
     setAdsProvider(provider) {
         if (this.adsProvider === provider)
@@ -331,8 +340,16 @@ export class AdControllerImpl extends EventHostImpl {
                 // The break may have been completed or swapped out (a content
                 // change, skip, or playout-limit) while its ads were resolving;
                 // don't start an ad for an abandoned break.
-                if (this.disposed || adBreakState.completedReason)
+                if (this.disposed)
+                    return;
+                if (adBreakState.completedReason) {
+                    // Whoever completed it could not advance (this call still
+                    // holds `loadingNext`), and nothing else drains the pending
+                    // list — a non-empty list blocks midroll ingress outright.
+                    if (!this.adBreakState)
+                        await nextBreak();
                     return;
+                }
                 if (ad) {
                     this.startAd(ad);
                 }
@@ -508,16 +525,19 @@ export class AdControllerImpl extends EventHostImpl {
             if (!adState.quartile.first &&
                 currProgress > 0.25 &&
                 progressStart < AD_START_TOLERANCE) {
+                adState.quartile.first = true;
                 this.dispatch('adFirstQuartile', createAdProgressEvent(adState));
             }
             if (!adState.quartile.midpoint &&
                 currProgress > 0.5 &&
                 progressStart < 0.25 + AD_START_TOLERANCE) {
+                adState.quartile.midpoint = true;
                 this.dispatch('adMidpoint', createAdProgressEvent(adState));
             }
             if (!adState.quartile.third &&
                 currProgress > 0.75 &&
                 progressStart < 0.5 + AD_START_TOLERANCE) {
+                adState.quartile.third = true;
                 this.dispatch('adThirdQuartile', createAdProgressEvent(adState));
             }
             // adEnded is not on progress but on a call to `endAd()`.
@@ -560,30 +580,43 @@ export class AdControllerImpl extends EventHostImpl {
         });
     }
     /**
-     * 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.
      */
     enforcePlayoutLimits(adState) {
+        if (!adState.started)
+            return;
+        const { parentBreak } = adState;
+        // Enforce independent of a finite content duration so live ads with a
+        // declared playout limit are still bounded.
+        const limit = parentBreak.adBreak.playoutLimit;
+        if (limit == null)
+            return;
         const pC = this.deps.playbackController;
-        const { ad, parentBreak } = adState;
-        // Enforce playout limits independent of a finite content duration so
-        // live ads with a declared playout limit are still bounded.
-        if (adState.started) {
-            const elapsed = Math.max(0, pC.currentTime - adState.timeStart);
-            const adBreak = parentBreak.adBreak;
-            const limit = adBreak.playoutLimit;
-            if (limit != null &&
-                parentBreak.playoutElapsed + elapsed >= limit) {
-                // The break's total playout limit is reached: end the whole
-                // break, dropping any ads that have not started.
-                parentBreak.clear();
-                this.endAd(adState);
-            }
-            else if (ad.duration != null && elapsed >= ad.duration) {
-                // This ad reached its declared duration: advance to the next.
-                this.endAd(adState);
-            }
+        const elapsed = Math.max(0, pC.currentTime - adState.timeStart);
+        if (parentBreak.playoutElapsed + elapsed < limit)
+            return;
+        // Budget reached — but if the current ad is essentially at its natural
+        // media end (within PLAYOUT_LIMIT_TOLERANCE of the playback-reported
+        // duration), let it finish on its own `ended` rather than clipping the
+        // tail. A known finite, positive duration is required; an unknown (0) or
+        // non-finite duration (e.g. live) enforces the limit strictly.
+        if (isFinite(pC.duration) &&
+            pC.duration > 0 &&
+            pC.duration - pC.currentTime <= PLAYOUT_LIMIT_TOLERANCE) {
+            return;
         }
+        // The break's total playout limit is reached: end the whole break,
+        // dropping any ads that have not started.
+        parentBreak.clear();
+        this.endAd(adState);
     }
     setPendingBreaks(newPending) {
         this.pendingAdBreaks = newPending.filter((adBreak) => !this.isBreakSuppressed(adBreak));
@@ -623,6 +656,9 @@ export class AdControllerImpl extends EventHostImpl {
      */
     dispose() {
         super.dispose();
+        // Tear down the ads-provider subscription so a late adsChange can't
+        // re-run ad discovery (and log) after dispose.
+        this.adsProviderSub?.();
         this.disposer.dispose();
         // Detach any active break so currentAd/currentAdBreak read null after
         // dispose, even if a break's ad list resolves late (startAd is already

package/dist/types/current/ad/discoverHlsInterstitials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discoverHlsInterstitials.d.ts","sourceRoot":"","sources":["../../../../src/ad/discoverHlsInterstitials.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAgB,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAS9E,OAAO,KAAK,EAER,WAAW,EAMd,MAAM,eAAe,CAAA;AActB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACpC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,MAAM,EACf,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAChC,OAAO,CAAC,WAAW,CAAC,CAmDtB"}
+{"version":3,"file":"discoverHlsInterstitials.d.ts","sourceRoot":"","sources":["../../../../src/ad/discoverHlsInterstitials.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAgB,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAU9E,OAAO,KAAK,EAER,WAAW,EAMd,MAAM,eAAe,CAAA;AActB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACpC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,MAAM,EACf,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAChC,OAAO,CAAC,WAAW,CAAC,CAmDtB"}

package/dist/types/current/ad/discoverHlsInterstitials.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { HLS_INTERSTITIAL_CLASS } from '@amazon/vinyl-hls-parser';
-import { memoize, requestWithRetry, resolveUrl, } from '@amazon/vinyl-util';
+import { memoize, readResponseBody, requestWithRetry, resolveUrl, } from '@amazon/vinyl-util';
 /**
  * How close to the start or end of content a break must be to be classified as
  * a pre-roll or post-roll rather than a mid-roll, in seconds.
@@ -215,14 +215,16 @@ function resolveHlsAssetContent({ range, startTime, duration, baseUrl, }) {
 async function resolveHlsAssetList({ assetListUrl, rangeId, startTime, baseUrl, }) {
     const url = resolveUrl(assetListUrl, baseUrl);
     const response = await requestWithRetry(url);
-    const json = await response.json();
+    const json = await readResponseBody(response, 'json');
     const assets = json.ASSETS ?? [];
     const ads = assets.map((asset, i) => {
         return {
             id: `${rangeId}-${i}`,
             startTime,
             duration: asset.DURATION ?? null,
-            uri: resolveUrl(asset.URI, baseUrl),
+            // Relative to the asset list, which need not sit alongside the
+            // media playlist.
+            uri: resolveUrl(asset.URI, url),
         };
     });
     return { ads, skipControl: parseSkipControl(json['SKIP-CONTROL']) };

package/dist/types/current/drm/DrmControllerImpl.d.ts

@@ -11,6 +11,12 @@ import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
  * 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/current/drm/DrmControllerImpl.d.ts.map

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

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

@@ -2,7 +2,7 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AbortError, base64ToByteArray, buffersEqual, bufferToByteArray, clone, compareBy, createDisposer, ErrorOrigin, EventHostImpl, getUserAgentInfo, isSilentError, logDebug, logVerbose, memoize, noop, normalizeHeadersInit, Os, remove, resolveValueProvider, withTimeout, } from '@amazon/vinyl-util';
+import { AbortError, base64ToByteArray, buffersEqual, bufferToByteArray, clone, compareBy, createDisposer, ErrorOrigin, EventHostImpl, getUserAgentInfo, isSilentError, logDebug, logVerbose, logWarn, memoize, noop, normalizeHeadersInit, Os, remove, resolveValueProvider, withTimeout, } from '@amazon/vinyl-util';
 import { instanceOf, object } from '@amazon/vinyl-validation';
 import { DrmRobustness, } from './DrmOptions';
 import { DrmError } from './error/DrmError';
@@ -20,6 +20,12 @@ import { createFairPlaySessionInitData } from './util/createFairPlaySessionInitD
  */
 export const LICENSE_TIMEOUT = 90;
 const LICENSE_TIMEOUT_MESSAGE = 'License provider timed out after {time}s';
+/**
+ * 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 const EXCESSIVE_SESSION_COUNT = 20;
 export class DrmControllerImpl extends EventHostImpl {
     deps;
     get [Symbol.toStringTag]() {
@@ -152,12 +158,18 @@ export class DrmControllerImpl extends EventHostImpl {
         else {
             const newSession = await this.createNewSession(licenseServerOptions.serverCertificate, mediaKeys, initData, initDataType, drmInfo, keySystemOptions?.initDataTransformer);
             this.sessions.push(newSession);
+            logVerbose(this, `total sessions: ${this.sessions.length}`);
+            if (this.sessions.length === EXCESSIVE_SESSION_COUNT + 1) {
+                logWarn(this, `${this.sessions.length} open key sessions exceeds ${EXCESSIVE_SESSION_COUNT}; sessions may be leaking (not closing on track deactivation)`);
+            }
             this.dispatch('sessionCreate', {
                 initDataType: newSession.initDataType,
                 mimeType: newSession.mimeType,
             });
             newSession.on('closed', () => this.closeSession(newSession));
             abort?.onAborted(() => {
+                if (this.disposed)
+                    return;
                 logDebug(this, 'abort session');
                 this.closeSession(newSession);
             });

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

@@ -0,0 +1,43 @@
+export interface StallDetectorOptions {
+    /**
+     * Called when playback resumes without emitting a `playing` event (or after the detector
+     * revived it), so the caller can announce playback.
+     */
+    readonly fabricatePlaying: () => void;
+    /** Poll interval in seconds. Default: 0.25 */
+    readonly pollInterval?: number;
+    /** Seconds the play head must be frozen before recovering. Default: 0.75 */
+    readonly stallThreshold?: number;
+    /**
+     * Don't nudge this close to the end of buffered data; a freeze there is a
+     * legitimate wait for more data. Seconds. Default: 0.5
+     */
+    readonly bufferEndMargin?: number;
+    /** Seconds to nudge the play head forward to prod a resume. Default: 0.1 */
+    readonly stallSkip?: number;
+    /** Max recovery attempts before giving up. Default: 3 */
+    readonly maxAttempts?: number;
+    /**
+     * Nudge even when the playhead isn't inside a buffered range. Some WebKit versions leave a
+     * seek perpetually pending (no `seeked`) with a stale empty `buffered` even though data is
+     * appended; re-issuing the seek via a nudge can complete it. Off by default (only nudge over
+     * genuinely buffered data). Default: false
+     */
+    readonly nudgeUnbuffered?: boolean;
+}
+/**
+ * Watches a media element after a seek/play and drives it back into a playing state. Some WebKit
+ * versions stall: the play head freezes inside buffered data and playback never resumes (often with
+ * a stale low readyState). This polls the play head and, while the element should be advancing:
+ *
+ * - if it's frozen inside buffered data, nudges currentTime forward to prod a resume;
+ * - if there's no data at the playhead, waits (it's legitimately buffering, or between sources).
+ *
+ * When the play head progresses it calls {@link StallDetectorOptions.fabricatePlaying} if playback
+ * resumed without a `playing` event (or after the detector revived it), then stops. It also stops
+ * on pause/ended/emptied or after {@link StallDetectorOptions.maxAttempts}.
+ *
+ * Start it after a seek or play only when playback is intended — a paused element won't advance.
+ */
+export declare function createStallDetector(media: HTMLMediaElement, options: StallDetectorOptions): () => void;
+//# sourceMappingURL=createStallDetector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createStallDetector.d.ts","sourceRoot":"","sources":["../../../../src/playback/createStallDetector.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,oBAAoB;IACjC;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,IAAI,CAAA;IACrC,8CAA8C;IAC9C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAChC;;;OAGG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CACrC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAC/B,KAAK,EAAE,gBAAgB,EACvB,OAAO,EAAE,oBAAoB,GAC9B,MAAM,IAAI,CAgEZ"}

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Watches a media element after a seek/play and drives it back into a playing state. Some WebKit
+ * versions stall: the play head freezes inside buffered data and playback never resumes (often with
+ * a stale low readyState). This polls the play head and, while the element should be advancing:
+ *
+ * - if it's frozen inside buffered data, nudges currentTime forward to prod a resume;
+ * - if there's no data at the playhead, waits (it's legitimately buffering, or between sources).
+ *
+ * When the play head progresses it calls {@link StallDetectorOptions.fabricatePlaying} if playback
+ * resumed without a `playing` event (or after the detector revived it), then stops. It also stops
+ * on pause/ended/emptied or after {@link StallDetectorOptions.maxAttempts}.
+ *
+ * Start it after a seek or play only when playback is intended — a paused element won't advance.
+ */
+export function createStallDetector(media, options) {
+    const { fabricatePlaying } = options;
+    const pollInterval = options.pollInterval ?? 0.25;
+    const stallThreshold = options.stallThreshold ?? 0.75;
+    const bufferEndMargin = options.bufferEndMargin ?? 0.5;
+    const stallSkip = options.stallSkip ?? 0.1;
+    const maxAttempts = options.maxAttempts ?? 3;
+    const nudgeUnbuffered = options.nudgeUnbuffered ?? false;
+    let lastTime = media.currentTime;
+    let stalledFor = 0;
+    let attempts = 0;
+    let sawPlaying = false;
+    let recovered = false;
+    const onPlaying = () => {
+        sawPlaying = true;
+    };
+    // A cleared source (track unload) means there's nothing to recover.
+    const onEmptied = () => stop();
+    media.addEventListener('playing', onPlaying);
+    media.addEventListener('emptied', onEmptied);
+    const stop = () => {
+        clearInterval(id);
+        media.removeEventListener('playing', onPlaying);
+        media.removeEventListener('emptied', onEmptied);
+    };
+    const id = setInterval(() => {
+        // Only a playing element is expected to advance.
+        if (media.paused || media.ended)
+            return stop();
+        if (media.currentTime !== lastTime) {
+            lastTime = media.currentTime;
+            // Progressing. Announce playback if it resumed without a `playing`
+            // event, or if the detector had to revive it (a prior `playing` was
+            // cleared by the intervening stall).
+            if (!sawPlaying || recovered)
+                fabricatePlaying();
+            return stop();
+        }
+        // Frozen. Recover only over buffered data; otherwise it's legitimately
+        // waiting to buffer (or between sources) and nudging can disrupt
+        // loading — except on platforms whose `buffered` is unreliable here
+        // ({@link nudgeUnbuffered}), where re-issuing the seek is the recovery.
+        if (!nudgeUnbuffered && !withinBufferedData(media, bufferEndMargin)) {
+            stalledFor = 0;
+            return;
+        }
+        stalledFor += pollInterval;
+        if (stalledFor < stallThreshold)
+            return;
+        stalledFor = 0;
+        if (attempts++ >= maxAttempts)
+            return stop();
+        recovered = true;
+        // Data is buffered at the playhead — a small nudge prods a resume.
+        // (iOS can sit here reporting a stale low readyState even though the
+        // range around the playhead is buffered.)
+        media.currentTime += stallSkip;
+        lastTime = media.currentTime;
+    }, pollInterval * 1000);
+    return stop;
+}
+/**
+ * True when the play head sits inside a buffered range, clear of its end by
+ * {@link endMargin} — i.e. there is data to keep playing.
+ *
+ * A range that ends at the end of the media is treated as nudgeable up to its
+ * end: no more data is coming, so a freeze there is a stuck end-of-track (seen
+ * on progressive `src` tracks), and a nudge pushes the element to `ended`.
+ */
+function withinBufferedData(media, endMargin) {
+    const t = media.currentTime;
+    const duration = media.duration;
+    const buffered = media.buffered;
+    for (let i = 0; i < buffered.length; i++) {
+        const end = buffered.end(i);
+        const isEndOfMedia = Number.isFinite(duration) &&
+            duration > 0 &&
+            end >= duration - endMargin;
+        if (t >= buffered.start(i) && (t < end - endMargin || isEndOfMedia))
+            return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,45 @@
+import { type Timestamp } from '@amazon/vinyl-util';
+import type { ReadonlyPlaybackController } from './ReadonlyPlaybackController';
+import { StallEndedReason } from './ReadonlyPlaybackController';
+export interface StallMonitorOptions {
+    /**
+     * Seconds the play head must be frozen (no `timeUpdate`) while playing before a stall is
+     * reported. Default: 1
+     */
+    readonly stallThreshold?: number;
+    /**
+     * How often (seconds) the play head freeze is checked. Default: 0.25
+     */
+    readonly pollInterval?: number;
+}
+export interface StallEndedInfo {
+    /** Time of the last `timeUpdate` observed before the play head froze. */
+    readonly started: Timestamp;
+    /** Time the stall ended. */
+    readonly ended: Timestamp;
+    /** Total seconds the play head was frozen. */
+    readonly duration: number;
+    /** Why the stall ended. */
+    readonly reason: StallEndedReason;
+}
+export interface StallMonitorCallbacks {
+    /** Called when a stall is first detected. */
+    readonly onStallEntered: () => void;
+    /** Called when a detected stall ends. */
+    readonly onStallEnded: (info: StallEndedInfo) => void;
+}
+/**
+ * Watches a {@link ReadonlyPlaybackController} for stalls while playing: the play head freezing
+ * (no `timeUpdate`) for longer than {@link StallMonitorOptions.stallThreshold} seconds.
+ *
+ * Detection only runs once playback has actually been observed (a `playing` event) and is
+ * suspended on `pause`/`seeking`/`emptied` until playback is observed again — so a stall is never
+ * reported during initial loading or while awaiting a seek. A detected stall ends when the play
+ * head advances again (`playing`) or playback stops for another reason (`pause`/`seeking`/
+ * `emptied`); {@link StallEndedInfo.duration} is measured from the last `timeUpdate` before the
+ * freeze, so it reflects the full frozen time rather than only the time past the threshold.
+ *
+ * Returns a function that stops the monitor.
+ */
+export declare function createStallMonitor(controller: ReadonlyPlaybackController, callbacks: StallMonitorCallbacks, options?: StallMonitorOptions): () => void;
+//# sourceMappingURL=createStallMonitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createStallMonitor.d.ts","sourceRoot":"","sources":["../../../../src/playback/createStallMonitor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAE/D,MAAM,WAAW,mBAAmB;IAChC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAEhC;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CACjC;AAED,MAAM,WAAW,cAAc;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAA;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;CACpC;AAED,MAAM,WAAW,qBAAqB;IAClC,6CAA6C;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,IAAI,CAAA;IACnC,yCAAyC;IACzC,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAA;CACxD;AASD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,UAAU,EAAE,0BAA0B,EACtC,SAAS,EAAE,qBAAqB,EAChC,OAAO,GAAE,mBAAwB,GAClC,MAAM,IAAI,CA+EZ"}

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

@@ -0,0 +1,99 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDisposer } from '@amazon/vinyl-util';
+import { StallEndedReason } from './ReadonlyPlaybackController';
+/**
+ * Minimum forward `currentTime` change (seconds) that counts as real progress. Guards the
+ * progress check against floating-point jitter so a negligible advance isn't mistaken for the
+ * play head moving.
+ */
+const PROGRESS_EPSILON = 1e-6;
+/**
+ * Watches a {@link ReadonlyPlaybackController} for stalls while playing: the play head freezing
+ * (no `timeUpdate`) for longer than {@link StallMonitorOptions.stallThreshold} seconds.
+ *
+ * Detection only runs once playback has actually been observed (a `playing` event) and is
+ * suspended on `pause`/`seeking`/`emptied` until playback is observed again — so a stall is never
+ * reported during initial loading or while awaiting a seek. A detected stall ends when the play
+ * head advances again (`playing`) or playback stops for another reason (`pause`/`seeking`/
+ * `emptied`); {@link StallEndedInfo.duration} is measured from the last `timeUpdate` before the
+ * freeze, so it reflects the full frozen time rather than only the time past the threshold.
+ *
+ * Returns a function that stops the monitor.
+ */
+export function createStallMonitor(controller, callbacks, options = {}) {
+    const stallThresholdMs = (options.stallThreshold ?? 1) * 1000;
+    const pollIntervalMs = (options.pollInterval ?? 0.25) * 1000;
+    // Only detect once playback has been observed; gates out initial load and post-seek buffering.
+    let observedPlaying = false;
+    // Wall-clock time of the last `timeUpdate` — the reference start of any freeze.
+    let lastProgressAt = Date.now();
+    let inStall = false;
+    let pollId = null;
+    const { add, dispose } = createDisposer();
+    const endStall = (reason) => {
+        if (!inStall)
+            return;
+        inStall = false;
+        const ended = Date.now();
+        callbacks.onStallEnded({
+            started: lastProgressAt,
+            ended,
+            duration: (ended - lastProgressAt) / 1000,
+            reason,
+        });
+    };
+    const stopPoll = () => {
+        if (pollId == null)
+            return;
+        clearInterval(pollId);
+        pollId = null;
+    };
+    add(stopPoll);
+    const startPoll = () => {
+        if (pollId != null)
+            return;
+        pollId = setInterval(() => {
+            if (inStall || !observedPlaying)
+                return;
+            if (Date.now() - lastProgressAt >= stallThresholdMs) {
+                inStall = true;
+                callbacks.onStallEntered();
+            }
+        }, pollIntervalMs);
+    };
+    // Playback stopped for a non-resume reason: close any open stall and suspend detection until
+    // playback is observed again.
+    const suspend = (reason) => {
+        endStall(reason);
+        observedPlaying = false;
+        stopPoll();
+    };
+    add(controller.on('playing', () => {
+        // Resuming from a stall closes it (using the pre-resume freeze start for its duration).
+        if (inStall)
+            endStall(StallEndedReason.PLAYING);
+        // Whether resuming or freshly starting, the play head is advancing again, so restart the
+        // freeze clock. Without this the poll could immediately re-detect a stall from the stale
+        // pre-freeze timestamp before the first post-resume `timeUpdate` resets it.
+        lastProgressAt = Date.now();
+        observedPlaying = true;
+        startPoll();
+    }));
+    add(controller.on('timeUpdate', ({ previous, current }) => {
+        // Browsers emit `timeUpdate` while frozen (unchanged/backward `currentTime`); only a
+        // forward advance is progress, else a stall is ended and re-detected, doubling events.
+        if (previous != null && current - previous <= PROGRESS_EPSILON)
+            return;
+        // The play head advanced: close any open stall, then reset the freeze clock.
+        if (inStall)
+            endStall(StallEndedReason.PLAYING);
+        lastProgressAt = Date.now();
+    }));
+    add(controller.on('pause', () => suspend(StallEndedReason.PAUSE)));
+    add(controller.on('seeking', () => suspend(StallEndedReason.SEEKING)));
+    add(controller.on('emptied', () => suspend(StallEndedReason.EMPTIED)));
+    return dispose;
+}

package/dist/types/current/streaming/AudioOptions.d.ts

@@ -1,4 +1,5 @@
 import type { ObjectSchema } from '@amazon/vinyl-validation';
+import type { Maybe } from '@amazon/vinyl-util';
 /**
  * Criteria used to pick which audio rendition to play.
  */
@@ -33,6 +34,32 @@ export interface AudioOptions {
      * The audio selection criteria (language / descriptive).
      */
     readonly selection?: AudioSelection;
+    /**
+     * When `true`, disables the audio sampling-rate support filter, so audio
+     * renditions whose sampling rate exceeds what the platform reports (via the
+     * `AudioContext` output rate) are kept and offered to playback anyway.
+     * `false` (the default) applies the filter. Changing this re-filters the
+     * timeline immediately.
+     */
+    readonly disableSampleRateFilter?: boolean;
+    /**
+     * The maximum audio sampling rate (Hz) the sampling-rate filter treats as
+     * supported. When set, it takes precedence over the platform's
+     * `AudioContext`-reported output rate. Ignored when
+     * {@link disableSampleRateFilter} is `true`. Changing this re-filters the
+     * timeline immediately. `null`/`undefined` falls back to the reported rate.
+     */
+    readonly maxSampleRate?: Maybe<number>;
+    /**
+     * The minimum audio sampling rate (Hz) the sampling-rate filter treats as
+     * supported. When set, renditions below it are filtered out as a soft floor
+     * (if every audio rendition is below it, the highest is kept so playback is
+     * never stranded). Applied alongside the max cap whenever the filter runs,
+     * regardless of how the max was determined; ignored when
+     * {@link disableSampleRateFilter} is `true`. Changing this re-filters the
+     * timeline immediately.
+     */
+    readonly minSampleRate?: Maybe<number>;
 }
 export declare const defaultAudioOptions: AudioOptions;
 export declare const audioOptionsValidator: ObjectSchema<AudioOptions>;