@amazon/vinyl 1.2.0 → 1.2.2

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

@@ -0,0 +1,162 @@
+import { EventHostImpl } from '@amazon/vinyl-util';
+import { AdBreakInfo, AdInfo, TrackAds } from './AdBreakInfo';
+import { AdController, AdEventMap } from './AdController';
+import { ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
+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;
+}
+export interface AdControllerImplOptions {
+    /**
+     * After an ad is set, the number of seconds to wait for playback to begin
+     * before marking the ad as failed.
+     * Default: 15
+     */
+    readonly adLoadTimeout: number;
+    /**
+     * How many seconds ahead of a midroll or postroll break to emit `adPreload`
+     * (so its ad assets can be warmed before the playhead reaches it). Used only
+     * when the break itself carries no {@link AdBreakInfo.resolutionTimeOffset};
+     * a break's own offset always takes precedence.
+     * Default: 10
+     */
+    readonly preloadAheadTime: number;
+}
+export declare const defaultAdControllerImplOptions: AdControllerImplOptions;
+/**
+ * Provider-agnostic {@link AdController}. Holds the discovered ad breaks and
+ * derives enter/exit region events from playhead time updates.
+ *
+ * This controller is the *model* for ad playback: it knows which breaks exist,
+ * which break contains the playhead, and which ad within that break is current.
+ * It does NOT create, preload, or activate any tracks — that is the
+ * responsibility of the {@link TrackController}.
+ *
+ * A break is considered active while `startTime <= currentTime < endTime`,
+ * where `endTime` is `startTime + duration`. Breaks whose duration is unknown
+ * (null) or breaks which restrict `jump` will become active at
+ * `currentTime > startTime`
+ *
+ * This class contains no HLS- or DASH-specific logic; discovery code maps its
+ * protocol's signals to {@link AdBreakInfo} exposed by an
+ * {@link AdsProvider.getAds}, which this controller reads once the provider is
+ * set via {@link AdController.setAdsProvider} (and re-reads on `adsChange`).
+ */
+export declare class AdControllerImpl extends EventHostImpl<AdEventMap> implements AdController {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    private readonly options;
+    private _trackAds;
+    private adsProviderSub;
+    private adsProvider;
+    private midrollAds;
+    private preloadableBreaks;
+    private readonly preloadedBreakIds;
+    private lastPlaybackTime;
+    private pendingAdBreaks;
+    private readonly completeAdBreakIds;
+    private readonly spentBreakIds;
+    private readonly disposer;
+    private adBreakState;
+    private loadingNext;
+    constructor(deps: AdControllerImplDeps, options?: Partial<AdControllerImplOptions>);
+    clearCompletedAds(): void;
+    private isBreakSuppressed;
+    /** The media-time the current ad has actually played, or 0 if not playing. */
+    private adElapsed;
+    /**
+     * Computes whether the current ad may be skipped and, when not yet, how many
+     * seconds remain until it can. A `skip` restriction blocks it outright;
+     * otherwise a resolved skip window gates it by the elapsed break playout, and
+     * with no window the ad is freely skippable.
+     */
+    private resolveSkipState;
+    get currentTrackAds(): (TrackAds | null);
+    private setTrackAds;
+    /**
+     * Returns a function that returns true if the ads provider has changed
+     * since the callback was created.
+     */
+    private providerInterrupted;
+    setAdsProvider(provider: AdsProvider | null): void;
+    enterPreroll(): Promise<AdBreakInfo | null>;
+    enterPostroll(): Promise<AdBreakInfo | null>;
+    private enterRoll;
+    private get hasProvider();
+    skipAdBreak(): void;
+    /**
+     * Marks an ad break as completed (or 'spent' and replayable), emits an `adBreakCompleted` event.
+     */
+    private completeAdBreak;
+    get currentAdBreak(): (AdBreakInfo | null);
+    /**
+     * Marks an ad as completed and emits an `adCompleted` event.
+     */
+    private completeAd;
+    /**
+     * Polls the next pending ad and activates it.
+     * When there are no remaining ads, activates the next ad break (if any).
+     */
+    private nextAdOrBreak;
+    get currentAd(): (AdInfo | null);
+    private get adState();
+    private startAd;
+    /**
+     * Checks if the playhead has entered a time to activate a midroll ad.
+     */
+    private onTimeUpdate;
+    /**
+     * Emits `adPreload` once for each midroll/postroll break the playhead is
+     * approaching — within (the break's {@link AdBreakInfo.resolutionTimeOffset}
+     * or, when absent, the `preloadAheadTime` option) seconds before its start —
+     * so a consumer can resolve and warm the break's assets before entry.
+     * Suppressed (played-once/spent) breaks are skipped.
+     */
+    private checkAdPreload;
+    /**
+     * Main content with ad breaks is playing, check if we have entered a midroll region.
+     */
+    private checkMidrollIngress;
+    /**
+     * Emits events for `adTimeUpdate`, `adFirstQuartile`, `adMidpoint`, and
+     * `adThirdQuartile`.
+     * (Does not emit `adCompleted`)
+     */
+    private emitAdProgressEvents;
+    private emitTimeUpdate;
+    /**
+     * 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;
+    skipAd(): void;
+    failAd(error: Error): void;
+    private endAd;
+    get disposed(): boolean;
+    /**
+     * Disposes this controller, removes all listeners.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=AdControllerImpl.d.ts.map

package/dist/types/ts3.7/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/ts3.7/ad/AdsProvider.d.ts

@@ -0,0 +1,28 @@
+import { AnyRecord, ReadonlyEventHost } from '@amazon/vinyl-util';
+import { 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/ts3.7/ad/defaultAdLoadOptionsResolver.d.ts

@@ -0,0 +1,12 @@
+import { AdInfo } from './AdBreakInfo';
+import { 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/ts3.7/ad/discoverHlsInterstitials.d.ts

@@ -0,0 +1,22 @@
+import { HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
+import { 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/ts3.7/drm/DrmControllerImpl.d.ts

@@ -11,6 +11,12 @@ import { 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/ts3.7/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/ts3.7/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/ts3.7/playback/createStallMonitor.d.ts

@@ -0,0 +1,45 @@
+import { Timestamp } from '@amazon/vinyl-util';
+import { 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/ts3.7/streaming/AudioOptions.d.ts

@@ -0,0 +1,66 @@
+import { ObjectSchema } from '@amazon/vinyl-validation';
+import { Maybe } from '@amazon/vinyl-util';
+/**
+ * Criteria used to pick which audio rendition to play.
+ */
+export interface AudioSelection {
+    /**
+     * Preferred language(s) for audio content, as RFC 5646 codes (e.g. `'en'`,
+     * `'ja'`, `'fr-CA'`). May be a single tag or an ordered list of tags —
+     * earlier entries are preferred, with the best relatedness match kept for
+     * each period (audio without a language tag is always kept). `null` (the
+     * default) is NOT "no preference": it orders by the platform's
+     * `navigator.languages`. To keep every language, this option is not the
+     * mechanism — omit language content or pass a tag matching all.
+     */
+    readonly language?: string | readonly string[] | null;
+    /**
+     * Opt in to audio-description (a.k.a. described-video / DVS) audio: audio
+     * renditions carrying an accessibility "describes video" characteristic that
+     * narrate on-screen action. `false` (the default) keeps them out of the
+     * automatic default-audio selection — they are chosen only when this is set.
+     * When `true`, a description rendition is preferred where one exists for the
+     * selected language. Changing this reselects audio immediately.
+     */
+    readonly descriptive?: boolean;
+}
+/**
+ * Declarative audio configuration. Mirrors `VinylOptions.text`: the audio
+ * rendition is chosen from {@link selection}; changing it reselects audio
+ * immediately.
+ */
+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>;
+//# sourceMappingURL=AudioOptions.d.ts.map

package/dist/types/ts3.7/streaming/LoadMetric.d.ts

@@ -0,0 +1,72 @@
+import { Timestamp } from '@amazon/vinyl-util';
+import { TrackUri } from '../track/Track';
+import { ContentType } from './MediaQualityMetadata';
+/**
+ * The stage of the track-load journey a {@link LoadSpanMeasurement} describes.
+ *
+ * - `manifest`: fetching and parsing the DASH/HLS manifest.
+ * - `keySetup`: the EME/CDM setup, from session creation to the CDM's first
+ *   license message. Precedes and is contiguous with `license`.
+ * - `license`: the DRM license request/response exchange.
+ * - `initSegment`: fetching the initialization segment.
+ * - `firstSegment`: fetching the first media segment.
+ */
+export type LoadSpanKind = 'manifest' | 'keySetup' | 'license' | 'initSegment' | 'firstSegment';
+/**
+ * A timed span for one stage of a track load.
+ *
+ * Dispatched by the controller that owns the stage. Emitters attribute the span
+ * to the track it was measured for at the source (see {@link trackUri}); the
+ * player republishes it as a {@link LoadSpanEvent}. When the emitter cannot know
+ * the owning track, `trackUri` is omitted and the span is dropped rather than
+ * misattributed.
+ */
+export interface LoadSpanMeasurement {
+    readonly kind: LoadSpanKind;
+    /**
+     * When the stage began, as a unix millisecond timestamp.
+     */
+    readonly startTime: Timestamp;
+    /**
+     * When the stage completed, as a unix millisecond timestamp.
+     */
+    readonly endTime: Timestamp;
+    /**
+     * The track this span was measured for, stamped at the source by the
+     * emitter that knows which track initiated the load. Omitted only when the
+     * initiating track is not yet known (e.g. an encrypted event handled before
+     * buffering DRM info is set).
+     */
+    readonly trackUri?: TrackUri;
+    /**
+     * The MIME type of the content this span was measured for, when known. Set
+     * for DRM `license` spans so a certificate exchange and the per-content-type
+     * license exchanges are distinguishable.
+     */
+    readonly mimeType?: string;
+    /**
+     * The content type this span was measured for, when known. Set alongside
+     * {@link mimeType} for DRM `license` spans.
+     */
+    readonly contentType?: ContentType;
+}
+/**
+ * A {@link LoadSpanMeasurement} attributed to the track it was measured for.
+ *
+ * Emitted on the player as the `loadSpan` event.
+ */
+export interface LoadSpanEvent extends LoadSpanMeasurement {
+    readonly trackUri: TrackUri;
+}
+/**
+ * Player-level load metric events.
+ */
+export interface LoadMetricEventMap {
+    /**
+     * A stage of a track load completed. Reports the time span of the stage
+     * together with the track it belongs to. Consumers measuring end-to-end
+     * load latency key on the first event per `kind` and `trackUri`.
+     */
+    readonly loadSpan: LoadSpanEvent;
+}
+//# sourceMappingURL=LoadMetric.d.ts.map

package/dist/types/ts3.7/streaming/ManifestControllerImpl.d.ts

@@ -0,0 +1,40 @@
+import { MutableValue } from '@amazon/vinyl-observable';
+import { EventHandler, SignalOptions, Unsubscribe } from '@amazon/vinyl-util';
+import { ManifestController, ManifestControllerEventMap, ManifestProvider } from './ManifestController';
+export interface ManifestControllerImplDeps<T> {
+    readonly manifestProvider: ManifestProvider<T>;
+}
+export declare class ManifestControllerImpl<T> implements ManifestController<Promise<T>> {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    get logPrefix(): string;
+    private readonly _data;
+    private _error;
+    private readonly abortSlot;
+    private readonly disposer;
+    private readonly events;
+    private manifestSpanArmed;
+    constructor(deps: ManifestControllerImplDeps<T>);
+    on<K extends keyof ManifestControllerEventMap>(type: K, handler: EventHandler<ManifestControllerEventMap[K]>, options?: SignalOptions): Unsubscribe;
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof ManifestControllerEventMap): boolean;
+    readonly __eventMapType: import("@amazon/vinyl-util").Covariant<ManifestControllerEventMap>;
+    get error(): (Error | null);
+    refresh(): void;
+    private requestManifest;
+    /**
+     * Measures the initial manifest fetch as a load span, re-arming on failure
+     * so a recovered load is still measured.
+     */
+    private measureLoadSpan;
+    reset(): void;
+    get value(): Promise<T>;
+    get changeId(): number;
+    getValue(): Promise<T>;
+    onData(callback: (value: Promise<T>, previous?: Promise<T>) => void): () => void;
+    map<U>(fn: (value: Promise<T>) => U): import("@amazon/vinyl-observable").ObservableValue<U>;
+    pick<K extends keyof NonNullable<Promise<T>>>(key: K): MutableValue<Promise<T>[K]>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=ManifestControllerImpl.d.ts.map

package/dist/types/ts3.7/streaming/buffering/codecDenylist.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Records every codec in the given mimeType as denylisted. Returns true if any
+ * codec was newly added (i.e. was not already denylisted), false if all codecs
+ * were already present. The return value lets callers bound retry loops: a
+ * repeat failure for an already-denylisted codec should not trigger another
+ * fallback attempt.
+ */
+export declare function denylistCodecsFromMimeType(mimeType: string): boolean;
+/**
+ * Returns true when any codec in the given mimeType has been denylisted.
+ */
+export declare function isMimeTypeDenylisted(mimeType: string): boolean;
+/**
+ * Returns the currently denylisted codec strings (lowercased). Primarily for
+ * diagnostics and testing.
+ */
+export declare function getDenylistedCodecs(): readonly string[];
+/**
+ * Clears the runtime codec denylist. Intended for tests and for re-detecting
+ * support (e.g. after an environment change).
+ */
+export declare function clearCodecDenylist(): void;
+//# sourceMappingURL=codecDenylist.d.ts.map

package/dist/types/ts3.7/streaming/createAllowedContentTypesValue.d.ts

@@ -0,0 +1,30 @@
+import { RestrictableContentType } from './MediaQualityMetadata';
+import { ContentTypesValue } from './ContentTypesValue';
+import { ObservableValue } from '@amazon/vinyl-observable';
+export interface AllowedContentTypesValueDeps {
+    /**
+     * The unfiltered content types present in the manifest.
+     */
+    readonly baseContentTypesValue: ContentTypesValue;
+    /**
+     * The player options. The `allowedContentTypes` allow list restricts which
+     * media content types are streamed; `null` means no restriction.
+     */
+    readonly options: ObservableValue<{
+        readonly allowedContentTypes: readonly RestrictableContentType[] | null;
+    }>;
+}
+/**
+ * Wraps a {@link ContentTypesValue} with the `allowedContentTypes` allow list
+ * from the player options. When the allow list is set, only media content
+ * types (`'audio'`, `'video'`) in the list are emitted; other media streams
+ * are ignored. When it is `null`, the underlying content types pass through
+ * unchanged. Text is never restricted by the allow list and always passes
+ * through (captions are governed by caption selection).
+ *
+ * Because the result is derived from the `allowedContentTypes` option via
+ * {@link combineData}, changing the option re-emits a newly filtered set, which
+ * reloads the track using only the allowed content types.
+ */
+export declare function createAllowedContentTypesValue(deps: AllowedContentTypesValueDeps): ContentTypesValue;
+//# sourceMappingURL=createAllowedContentTypesValue.d.ts.map

package/dist/types/ts3.7/streaming/createTimelineContentTypesValue.d.ts

@@ -0,0 +1,21 @@
+import { ContentTypesValue } from './ContentTypesValue';
+import { MediaTimeline } from './MediaTimeline';
+import { ObservableValue } from '@amazon/vinyl-observable';
+export interface TimelineContentTypesValueDeps {
+    /**
+     * The filtered, playable timeline. Content types are derived from the
+     * qualities that survive filtering, so a content type whose renditions are
+     * all filtered out (e.g. every audio rendition dropped by the sample-rate
+     * filter) is not reported — it never gates readiness and no source buffer
+     * is expected for it, so the remaining content types still play.
+     */
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+}
+/**
+ * Provides the MSE content types to create source buffers for, derived from the
+ * qualities that survive timeline filtering rather than the raw manifest. Only
+ * `'audio'`/`'video'` are reported; text is a sidecar pipeline, never an MSE
+ * source buffer.
+ */
+export declare function createTimelineContentTypesValue(deps: TimelineContentTypesValueDeps): ContentTypesValue;
+//# sourceMappingURL=createTimelineContentTypesValue.d.ts.map

package/dist/types/ts3.7/streaming/mediaTimelineAccessibilityFilter.d.ts

@@ -0,0 +1,35 @@
+import { MediaQualityMetadata } from './MediaQualityMetadata';
+import { FilterPredicate } from '@amazon/vinyl-util';
+/**
+ * Thrown if the audio-description filter ever emptied a period's audio. The
+ * filter keeps at least one audio rendition per period by design, so this is a
+ * defensive guard rather than an expected path.
+ */
+export declare function throwNoPlayableAudio(): never;
+/**
+ * Characteristics that mark an audio rendition as an audio description (a.k.a.
+ * described video / DVS) — narration of on-screen action for viewers who cannot
+ * see it. HLS signals this with the `public.accessibility.describes-video`
+ * CHARACTERISTIC; DASH with a `description` Role. Such renditions must not be
+ * chosen as the default audio; they are an accessibility opt-in.
+ */
+export declare const AUDIO_DESCRIPTION_CHARACTERISTICS: readonly string[];
+/**
+ * Whether an audio quality is an audio-description rendition.
+ */
+export declare function isAudioDescription(quality: MediaQualityMetadata): boolean;
+/**
+ * Creates a filter that keeps audio-description renditions out of (or, when
+ * opted in, restricts audio to) the audio selection.
+ *
+ * - `preferDescription: false` (default): drop audio-description renditions
+ *   from each period *when a non-description audio alternative exists*, so the
+ *   main audio is chosen by default instead of the description track. If a
+ *   period has only description audio, it is kept (playback is never stranded).
+ * - `preferDescription: true`: keep only description renditions when the period
+ *   has any; otherwise keep all (again, never strand playback).
+ *
+ * Non-audio qualities are always kept.
+ */
+export declare function createAudioDescriptionFilter(preferDescription: boolean): FilterPredicate<MediaQualityMetadata>;
+//# sourceMappingURL=mediaTimelineAccessibilityFilter.d.ts.map