@amazon/vinyl 1.2.0 → 1.2.2

package/dist/types/current/ad/AdError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from '@amazon/vinyl-util';
+export declare class AdError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=AdError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AdError.d.ts","sourceRoot":"","sources":["../../../../src/ad/AdError.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAe,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAE7E,qBAAa,OAAQ,SAAQ,eAAe;IACxC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGG,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAA0B,EAClC,KAAK,GAAE,UAA6B;CAK3C"}

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

@@ -0,0 +1,14 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorLevel, ErrorOrigin, ReportableError } from '@amazon/vinyl-util';
+export class AdError extends ReportableError {
+    get [Symbol.toStringTag]() {
+        return 'AdError';
+    }
+    constructor(message, origin = ErrorOrigin.MEDIA, level = ErrorLevel.FATAL) {
+        super(message, origin, level);
+        Object.setPrototypeOf(this, AdError.prototype);
+    }
+}

package/dist/types/current/ad/AdsProvider.d.ts

@@ -0,0 +1,28 @@
+import type { AnyRecord, ReadonlyEventHost } from '@amazon/vinyl-util';
+import type { TrackAds } from './AdBreakInfo';
+/**
+ * Events dispatched by an {@link AdsProvider}.
+ */
+export interface AdsProviderEventMap {
+    /**
+     * The set of ads has changed; consumers should re-read via
+     * {@link AdsProvider.getAds}.
+     */
+    readonly adsChange: AnyRecord;
+}
+/**
+ * The minimal surface an {@link AdController} needs to source its ad breaks:
+ * a resolver for the current break list, plus an `adsChange` event to signal
+ * when that list changes. A {@link ReadonlyTrack} satisfies this directly, so
+ * the current playing track can be passed as-is; applications may also
+ * implement it to supply ads out of band (e.g. from an external ad server).
+ */
+export interface AdsProvider extends ReadonlyEventHost<AdsProviderEventMap> {
+    /**
+     * Resolves to the provider's current ad breaks. The result may change over
+     * the provider's lifetime; each `adsChange` event indicates that a
+     * subsequent call may return different breaks.
+     */
+    getAds(): Promise<TrackAds>;
+}
+//# sourceMappingURL=AdsProvider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AdsProvider.d.ts","sourceRoot":"","sources":["../../../../src/ad/AdsProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAE7C;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAChC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAY,SAAQ,iBAAiB,CAAC,mBAAmB,CAAC;IACvE;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC9B"}

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

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/ad/defaultAdLoadOptionsResolver.d.ts

@@ -0,0 +1,12 @@
+import type { AdInfo } from './AdBreakInfo';
+import type { VinylTrackLoadOptions } from '../track/createVinylTrackFactories';
+import { ReportableError } from '@amazon/vinyl-util';
+export declare function defaultAdLoadOptionsResolver(adInfo: AdInfo): Promise<VinylTrackLoadOptions>;
+/**
+ * An error indicating that a method was called with illegal arguments.
+ */
+export declare class UnresolvableAdError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string);
+}
+//# sourceMappingURL=defaultAdLoadOptionsResolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultAdLoadOptionsResolver.d.ts","sourceRoot":"","sources":["../../../../src/ad/defaultAdLoadOptionsResolver.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAE3C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC/E,OAAO,EAAe,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEjE,wBAAsB,4BAA4B,CAC9C,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAShC;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,eAAe;IACpD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAEW,OAAO,EAAE,MAAM;CAI9B"}

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createTrackLoadOptionsFromUrl } from '../track/inferLoadOptionsFromUri';
+import { ErrorOrigin, ReportableError } from '@amazon/vinyl-util';
+export async function defaultAdLoadOptionsResolver(adInfo) {
+    if (!adInfo.uri)
+        throw new UnresolvableAdError('Ad with no URI cannot be played');
+    const loadOptions = await createTrackLoadOptionsFromUrl(adInfo.uri);
+    if (!loadOptions)
+        throw new UnresolvableAdError(`could not infer ad track type from uri ${adInfo.uri}`);
+    return loadOptions;
+}
+/**
+ * An error indicating that a method was called with illegal arguments.
+ */
+export class UnresolvableAdError extends ReportableError {
+    get [Symbol.toStringTag]() {
+        return 'UnresolvableAdError';
+    }
+    constructor(message) {
+        super(message, ErrorOrigin.MEDIA);
+        Object.setPrototypeOf(this, UnresolvableAdError.prototype);
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
+import type { AdBreakList } from './AdBreakInfo';
+/**
+ * Discovers HLS Interstitial ad breaks from a parsed media playlist and maps
+ * them to the provider-agnostic {@link AdBreakInfo} model.
+ *
+ * HLS Interstitials (Apple's SGAI primitive) are carried as EXT-X-DATERANGE
+ * tags with `CLASS="com.apple.hls.interstitial"`. Each such range is anchored
+ * to a wall-clock `START-DATE`; this function converts that to a media-timeline
+ * start time by correlating it with the playlist's EXT-X-PROGRAM-DATE-TIME
+ * anchor. When the playlist carries no program date-time, and the range's
+ * start-date is not otherwise resolvable, the break is anchored to the start of
+ * the timeline (pre-roll) as a best effort.
+ *
+ * @param playlist The parsed HLS media playlist.
+ * @param baseUrl  The URL of the media playlist, used to resolve relative
+ *   `X-ASSET-URI` values.
+ * @param contentDuration The total content duration in seconds, if known, used
+ *   to classify post-rolls. Pass null/undefined for live or unknown durations.
+ */
+export declare function discoverHlsInterstitials(playlist: HlsMediaPlaylist, baseUrl: string, contentDuration?: number | null): Promise<AdBreakList>;
+//# sourceMappingURL=discoverHlsInterstitials.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,248 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { HLS_INTERSTITIAL_CLASS } from '@amazon/vinyl-hls-parser';
+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.
+ */
+const ROLL_EPSILON = 0.5;
+/**
+ * Discovers HLS Interstitial ad breaks from a parsed media playlist and maps
+ * them to the provider-agnostic {@link AdBreakInfo} model.
+ *
+ * HLS Interstitials (Apple's SGAI primitive) are carried as EXT-X-DATERANGE
+ * tags with `CLASS="com.apple.hls.interstitial"`. Each such range is anchored
+ * to a wall-clock `START-DATE`; this function converts that to a media-timeline
+ * start time by correlating it with the playlist's EXT-X-PROGRAM-DATE-TIME
+ * anchor. When the playlist carries no program date-time, and the range's
+ * start-date is not otherwise resolvable, the break is anchored to the start of
+ * the timeline (pre-roll) as a best effort.
+ *
+ * @param playlist The parsed HLS media playlist.
+ * @param baseUrl  The URL of the media playlist, used to resolve relative
+ *   `X-ASSET-URI` values.
+ * @param contentDuration The total content duration in seconds, if known, used
+ *   to classify post-rolls. Pass null/undefined for live or unknown durations.
+ */
+export function discoverHlsInterstitials(playlist, baseUrl, contentDuration) {
+    const anchor = findProgramDateTimeAnchor(playlist);
+    const breaks = [];
+    for (const range of playlist.dateRanges) {
+        if (range.classId !== HLS_INTERSTITIAL_CLASS)
+            continue;
+        const startTime = resolveStartTime(range, anchor);
+        if (startTime == null)
+            continue;
+        const playoutLimit = resolvePlayoutLimit(range);
+        let duration = resolveDuration(range);
+        if (playoutLimit != null && duration != null)
+            duration = Math.min(playoutLimit, duration);
+        const cues = parseCues(range);
+        const placement = classifyPlacement(startTime, contentDuration, cues);
+        const effectiveStartTime = placement === 'preroll' ? 0 : startTime;
+        const restrictStr = range.clientAttributes['X-RESTRICT'] ?? '';
+        const restrict = parseRestrict(restrictStr);
+        // The ads and skip window share one (memoized) asset-list resolution.
+        const resolveContent = memoize(() => resolveHlsAssetContent({
+            range,
+            startTime: effectiveStartTime,
+            duration,
+            baseUrl,
+        }));
+        breaks.push({
+            id: range.id,
+            startTime: effectiveStartTime,
+            duration,
+            placement,
+            once: cues.has('ONCE'),
+            resumeOffset: parseResumeOffset(range),
+            resolutionTimeOffset: parseResolutionTimeOffset(range),
+            playoutLimit,
+            ads: async () => (await resolveContent()).ads,
+            skipControl: async () => (await resolveContent()).skipControl,
+            restrict,
+        });
+    }
+    breaks.sort((a, b) => a.startTime - b.startTime);
+    // Discovery is synchronous; ad assets resolve lazily via each break's
+    // `ads` ValueProvider. The Promise return keeps the provider-agnostic
+    // contract stable for future async discovery (e.g. DASH).
+    return Promise.resolve(breaks);
+}
+function findProgramDateTimeAnchor(playlist) {
+    let mediaTime = 0;
+    for (const seg of playlist.segments) {
+        if (seg.programDateTime) {
+            const epochMs = Date.parse(seg.programDateTime);
+            if (!Number.isNaN(epochMs)) {
+                return { epochMs, mediaTime };
+            }
+        }
+        mediaTime += seg.duration;
+    }
+    return null;
+}
+/**
+ * Converts a range's wall-clock START-DATE to a media-timeline start time.
+ * Returns 0 when there is no program-date-time anchor but the start-date is
+ * present (best-effort pre-roll), or null when the start-date is unusable.
+ */
+function resolveStartTime(range, anchor) {
+    if (!range.startDate) {
+        // END-ON-NEXT ranges may omit START-DATE; without an anchor we cannot
+        // place them, so skip.
+        return null;
+    }
+    const epochMs = Date.parse(range.startDate);
+    if (Number.isNaN(epochMs))
+        return null;
+    if (!anchor) {
+        // No program-date-time to correlate against. Treat as a pre-roll.
+        return 0;
+    }
+    const startTime = anchor.mediaTime + (epochMs - anchor.epochMs) / 1000;
+    // Clamp tiny negatives from clock rounding to 0.
+    return startTime < 0 && startTime > -ROLL_EPSILON ? 0 : startTime;
+}
+/**
+ * Determines a break's duration in seconds. Uses DURATION, else END-DATE span, else
+ * PLANNED-DURATION, else null.
+ */
+function resolveDuration(range) {
+    if (range.duration != null && !Number.isNaN(range.duration)) {
+        return range.duration;
+    }
+    if (range.endDate && range.startDate) {
+        const start = Date.parse(range.startDate);
+        const end = Date.parse(range.endDate);
+        if (!Number.isNaN(start) && !Number.isNaN(end) && end >= start) {
+            return (end - start) / 1000;
+        }
+    }
+    if (range.plannedDuration != null && !Number.isNaN(range.plannedDuration)) {
+        return range.plannedDuration;
+    }
+    return null;
+}
+function resolvePlayoutLimit(range) {
+    const playoutLimit = parseFloat(range.clientAttributes['X-PLAYOUT-LIMIT'] ?? '');
+    if (Number.isFinite(playoutLimit) && playoutLimit > 0) {
+        return playoutLimit;
+    }
+    return null;
+}
+/**
+ * Tokenizes the DATERANGE `CUE` attribute, an enumerated-string list of trigger
+ * identifiers (e.g. `"PRE,ONCE"`), into an uppercased, trimmed Set. Unknown
+ * tokens are preserved but ignored by callers.
+ */
+function parseCues(range) {
+    return new Set((range.clientAttributes['CUE'] ?? '')
+        .split(',')
+        .map((token) => token.trim().toUpperCase())
+        .filter(Boolean));
+}
+/**
+ * Parses the signed `X-RESUME-OFFSET` (seconds). Returns null when the attribute
+ * is absent (so the controller substitutes the actual playout duration) — a
+ * present value of 0 is distinct from absent and is returned as 0.
+ */
+function parseResumeOffset(range) {
+    if (!('X-RESUME-OFFSET' in range.clientAttributes))
+        return null;
+    const value = parseFloat(range.clientAttributes['X-RESUME-OFFSET']);
+    return Number.isFinite(value) ? value : null;
+}
+/**
+ * Parses the `X-RESOLUTION-TIME-OFFSET` (seconds) — how far ahead of the break
+ * the client should resolve/preload its assets. Returns null when absent or not
+ * a finite non-negative number, so the controller falls back to its configured
+ * `preloadAheadTime`.
+ */
+function parseResolutionTimeOffset(range) {
+    if (!('X-RESOLUTION-TIME-OFFSET' in range.clientAttributes))
+        return null;
+    const value = parseFloat(range.clientAttributes['X-RESOLUTION-TIME-OFFSET']);
+    return Number.isFinite(value) && value >= 0 ? value : null;
+}
+function classifyPlacement(startTime, contentDuration, cues) {
+    // PRE/POST trigger identifiers are authoritative over the proximity
+    // heuristic (they may fire outside the range's START-DATE/duration). PRE
+    // wins the illegal PRE+POST combination.
+    if (cues.has('PRE'))
+        return 'preroll';
+    if (cues.has('POST'))
+        return 'postroll';
+    if (startTime <= ROLL_EPSILON)
+        return 'preroll';
+    if (contentDuration != null &&
+        Number.isFinite(contentDuration) &&
+        startTime >= contentDuration - ROLL_EPSILON) {
+        return 'postroll';
+    }
+    return 'midroll';
+}
+function resolveHlsAssetContent({ range, startTime, duration, baseUrl, }) {
+    const assetUri = range.clientAttributes['X-ASSET-URI'];
+    if (assetUri) {
+        // A single inline asset carries no skip window.
+        return {
+            ads: [
+                {
+                    id: `${range.id}-0`,
+                    startTime,
+                    duration,
+                    uri: resolveUrl(assetUri, baseUrl),
+                },
+            ],
+            skipControl: null,
+        };
+    }
+    const assetListUrl = range.clientAttributes['X-ASSET-LIST'];
+    if (assetListUrl) {
+        return resolveHlsAssetList({
+            assetListUrl,
+            rangeId: range.id,
+            startTime,
+            baseUrl,
+        });
+    }
+    return { ads: [], skipControl: null };
+}
+async function resolveHlsAssetList({ assetListUrl, rangeId, startTime, baseUrl, }) {
+    const url = resolveUrl(assetListUrl, baseUrl);
+    const response = await requestWithRetry(url);
+    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,
+            // 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']) };
+}
+/**
+ * Maps an X-ASSET-LIST `SKIP-CONTROL` object to a {@link SkipControl}, or null
+ * when absent or missing a usable offset.
+ */
+function parseSkipControl(control) {
+    if (!control)
+        return null;
+    const offset = Number(control.OFFSET);
+    if (!Number.isFinite(offset) || offset < 0)
+        return null;
+    return { offset, duration: control.DURATION ?? null };
+}
+function parseRestrict(str) {
+    const skip = str.includes('SKIP');
+    const jump = str.includes('JUMP');
+    return { skip, jump };
+}

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, isSilentError, logDebug, logVerbose, memoize, noop, normalizeHeadersInit, 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);
             });
@@ -243,6 +255,16 @@ export class DrmControllerImpl extends EventHostImpl {
             }
             else if (contentType === 'audio') {
                 config.audioCapabilities = [capability];
+                if (getUserAgentInfo().os?.name === Os.CHROME_OS) {
+                    // Add videoCapabilities to get ChromeOS to enable verified media path
+                    logDebug(this, 'Adding video avc1 drm capabilities for VMP');
+                    config.videoCapabilities = [
+                        {
+                            contentType: `video/mp4; codecs="avc1.4d401f"`,
+                            robustness: 'SW_SECURE_DECODE',
+                        },
+                    ];
+                }
             }
             return {
                 keySystem,

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

@@ -41,7 +41,7 @@ export declare const defaultPlaybackControllerImplOptions: {
  * Firefox can but if the playhead reaches the end of track before the media stream is closed, an 'ended' event
  * will never fire.
  */
-export declare function getMinSeekableBufferDefault(): 2 | 5;
+export declare function getMinSeekableBufferDefault(): 5 | 2;
 export interface PlaybackControllerImplDeps {
     readonly media: HTMLMediaElement;
     readonly loudnessNormalizationController: LoudnessNormalizationController;

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;
+}