@amazon/vinyl 1.1.1 → 1.2.1

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

@@ -0,0 +1,39 @@
+import { ObjectSchema } from '@amazon/vinyl-validation';
+/**
+ * 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;
+}
+export declare const defaultAudioOptions: AudioOptions;
+export declare const audioOptionsValidator: ObjectSchema<AudioOptions>;
+//# sourceMappingURL=AudioOptions.d.ts.map

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

@@ -1,8 +1,8 @@
 import { Disposable, EventHostImpl, Maybe, ReadonlyEventHost, ReadonlyRanges } from '@amazon/vinyl-util';
-import { StreamingEventMap } from '../streaming/StreamingEventMap';
-import { SegmentController } from '../streaming/SegmentController';
-import { BufferingController } from '../streaming/buffering/BufferingController';
-import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { StreamingEventMap } from './StreamingEventMap';
+import { SegmentController } from './SegmentController';
+import { BufferingController } from './buffering/BufferingController';
+import { ContentType, MediaQualityMetadata } from './MediaQualityMetadata';
 import { Factories } from '@amazon/vinyl-di';
 /**
  * Creates a new ContentStream for the given content type.

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

@@ -1,5 +1,5 @@
-import { SegmentControllerImplOptions } from '../streaming/SegmentControllerImpl';
-import { BufferingControllerImplOptions } from '../streaming/buffering/BufferingController';
+import { SegmentControllerImplOptions } from './SegmentControllerImpl';
+import { BufferingControllerImplOptions } from './buffering/BufferingController';
 export interface ContentStreamingOptions {
     /**
      * Configuration for the segment controller.

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

@@ -0,0 +1,58 @@
+import { Timestamp } from '@amazon/vinyl-util';
+import { TrackUri } from '../track/Track';
+/**
+ * The stage of the track-load journey a {@link LoadSpanMeasurement} describes.
+ *
+ * - `manifest`: fetching and parsing the DASH/HLS manifest.
+ * - `license`: the DRM license request/response exchange.
+ * - `initSegment`: fetching the initialization segment.
+ * - `firstSegment`: fetching the first media segment.
+ */
+export type LoadSpanKind = 'manifest' | '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;
+}
+/**
+ * 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/MediaQualityMetadata.d.ts

@@ -1,7 +1,7 @@
 import { Maybe, MutableDeep } from '@amazon/vinyl-util';
 import { ObjectSchema } from '@amazon/vinyl-validation';
-import { DescriptorRecord } from '../streaming/DescriptorRecord';
-import { DrmInitDataType } from '../streaming/DrmInitDataType';
+import { DescriptorRecord } from './DescriptorRecord';
+import { DrmInitDataType } from './DrmInitDataType';
 import { CencEncryptionScheme } from '../drm/CencEncryptionScheme';
 import { DrmKeySystem } from '../drm/DrmKeySystem';
 import { FrameRate } from '@amazon/vinyl-mpd-parser';

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

@@ -1,6 +1,6 @@
-import { SegmentReference } from '../streaming/SegmentReference';
-import { SegmentDataProvider } from '../streaming/SegmentDataSlot';
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { SegmentReference } from './SegmentReference';
+import { SegmentDataProvider } from './SegmentDataSlot';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 /**
  * Represents a single quality within a period, providing access to its metadata
  * and segment data.
@@ -34,9 +34,10 @@ export interface MediaTimeline {
     readonly minBufferTime: number;
     /**
      * The total duration of the media, in seconds.
-     * Returns null if duration cannot be determined.
+     * Returns `Infinity` for live streams.
+     * Rejects when there are no segments to derive a duration from.
      */
-    getDuration?(): Promise<number | null>;
+    getDuration(): Promise<number>;
 }
 /**
  * Gets the period spanning the given presentation time.

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

@@ -1,7 +1,7 @@
 import { AnyRecord, Disposable, ReadonlyAbort, ReadonlyEventHost, ReadonlyRanges } from '@amazon/vinyl-util';
-import { SegmentReference } from '../streaming/SegmentReference';
+import { SegmentReference } from './SegmentReference';
 import { ChangeEvent } from '../event/ChangeEvent';
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 /**
  * Forward-snap tolerance, in seconds, applied when looking up a segment by time.
  *
@@ -48,11 +48,6 @@ export interface ReadonlySegmentController extends ReadonlyEventHost<SegmentCont
      * The most recently requested quality metadata.
      */
     readonly streamingQuality: MediaQualityMetadata | null;
-    /**
-     * The duration of the media, in seconds.
-     * Returns null if duration cannot be determined.
-     */
-    getDuration(): Promise<number | null>;
     /**
      * Returns a Promise for a segment covering the given time, with quality chosen by
      * the configured `QualitySelector`. Resolves to `null` if no media exists at that

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

@@ -1,11 +1,11 @@
 import { EventHostImpl, ReadonlyAbort, ReadonlyRanges } from '@amazon/vinyl-util';
 import { ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
-import { PrefetchOptions, SegmentController, SegmentControllerEventMap } from '../streaming/SegmentController';
-import { SegmentReference } from '../streaming/SegmentReference';
-import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { PrefetchOptions, SegmentController, SegmentControllerEventMap } from './SegmentController';
+import { SegmentReference } from './SegmentReference';
+import { ContentType, MediaQualityMetadata } from './MediaQualityMetadata';
 import { ObservableValue } from '@amazon/vinyl-observable';
-import { MediaTimeline } from '../streaming/MediaTimeline';
-import { QualitySelector } from '../streaming/abr/QualitySelector';
+import { MediaTimeline } from './MediaTimeline';
+import { QualitySelector } from './abr/QualitySelector';
 /**
  * The interval to check if additional segments should be prefetched.
  */
@@ -73,7 +73,6 @@ export declare class SegmentControllerImpl extends EventHostImpl<SegmentControll
     private _cachedPeriod;
     constructor(deps: SegmentControllerImplDeps, contentType: ContentType, options?: Partial<SegmentControllerImplOptions>);
     get error(): (Error | null);
-    getDuration(): Promise<number | null>;
     /**
      * Gets the period at the given time, using a cache for the last returned period.
      */

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

@@ -1,4 +1,4 @@
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 export interface MediaSegmentMetadata {
     /**
      * The timestamp offset of the segment.

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

@@ -1,5 +1,5 @@
 import { ChangeEvent } from '../event/ChangeEvent';
-import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { ContentType, MediaQualityMetadata } from './MediaQualityMetadata';
 import { BasicErrorEvent } from '../event/BasicErrorEvent';
 import { AnyRecord } from '@amazon/vinyl-util';
 /**

package/dist/types/ts3.7/streaming/abr/QualitySelector.d.ts

@@ -1,4 +1,4 @@
-import { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { MediaQualityMetadata } from '../MediaQualityMetadata';
 export interface PrefetchState {
     /**
      * The number of seconds currently prefetched.

package/dist/types/ts3.7/streaming/abr/QualitySelectorImpl.d.ts

@@ -1,7 +1,7 @@
-import { PrefetchState, QualitySelector } from '../../streaming/abr/QualitySelector';
-import { Disposable, LogTarget } from '@amazon/vinyl-util';
+import { PrefetchState, QualitySelector } from './QualitySelector';
+import { Disposable, LogTarget, Maybe } from '@amazon/vinyl-util';
 import { ObjectSchema } from '@amazon/vinyl-validation';
-import { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { MediaQualityMetadata } from '../MediaQualityMetadata';
 import { ObservableValue } from '@amazon/vinyl-observable';
 export interface QualitySelectorImplOptions {
     /**
@@ -52,6 +52,20 @@ export interface QualitySelectorImplOptions {
      * Default: false
      */
     readonly restrictDecoderChangeOnAudioAbrUp?: boolean;
+    /**
+     * Maximum bandwidth in bits per second a quality may use to be selectable.
+     *
+     * Soft cap: if no qualities fit within the limit (including when set to 0),
+     * the quality with the lowest bandwidth is selected so playback is still
+     * possible.
+     *
+     * Has no effect when {@link strategy} is {@link AbrStrategy.LOWEST} or
+     * {@link AbrStrategy.HIGHEST}, since those strategies pin the selection
+     * regardless of bandwidth.
+     *
+     * Default: null (no limit).
+     */
+    readonly maxBandwidth?: Maybe<number>;
 }
 export declare enum AbrStrategy {
     /**
@@ -82,6 +96,7 @@ export declare const defaultQualitySelectorImplOptions: {
     readonly bandwidthMultiplierLow: 0.4;
     readonly bandwidthMultiplierHigh: 0.9;
     readonly restrictDecoderChangeOnAudioAbrUp: false;
+    readonly maxBandwidth: null;
 };
 export interface QualitySelectorImplDeps {
     readonly options: ObservableValue<QualitySelectorImplOptions>;

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

@@ -1,17 +1,11 @@
 import { AnyRecord, Clearable, Disposable, EventHostImpl, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { ReadonlyPlaybackController } from '../../playback/ReadonlyPlaybackController';
 import { SourceBufferController } from './SourceBufferController';
-import { ReadonlySegmentController } from '../../streaming/SegmentController';
+import { ReadonlySegmentController } from '../SegmentController';
 import { BasicErrorEvent } from '../../event/BasicErrorEvent';
 import { ChangeEvent } from '../../event/ChangeEvent';
-import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
-import { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
-/**
- * Chrome 52 has decoding errors when duration is set to the mediaPresentationDuration.
- * Adds a slight padding as a workaround.
- * @private
- */
-export declare const DURATION_PADDING = 0.1;
+import { ContentType, MediaQualityMetadata } from '../MediaQualityMetadata';
+import { MediaSourceController } from './MediaSourceController';
 /**
  * The interval to throttle polling the buffer.
  * Reset after a seek.
@@ -167,10 +161,6 @@ export declare class BufferingControllerImpl extends EventHostImpl<BufferingCont
     deactivate(): void;
     reset(): void;
     get busy(): boolean;
-    /**
-     * Enqueues a duration update.
-     */
-    private refreshDuration;
     /**
      * Resets the throttle and polls the buffer on the next frame.
      */

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

@@ -1,7 +1,15 @@
 import { AnyRecord, Disposable, EventHostImpl, Json, LogTarget, ReadonlyEventHost, ReportableError } from '@amazon/vinyl-util';
-import { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { ContentTypesValue } from '../ContentTypesValue';
 import { BasicErrorEvent } from '../../event/BasicErrorEvent';
-import { ContentType } from '../../streaming/MediaQualityMetadata';
+import { ContentType } from '../MediaQualityMetadata';
+import { MediaTimeline } from '../MediaTimeline';
+/**
+ * Chrome 52 has decoding errors when duration is set to the mediaPresentationDuration.
+ * Adds a slight padding as a workaround.
+ * @private
+ */
+export declare const DURATION_PADDING = 0.1;
 export interface SourceBufferRef extends Disposable {
     /**
      * The source buffer.
@@ -22,7 +30,8 @@ export interface MediaSourceControllerEventMap {
      */
     readonly sourceOpen: AnyRecord;
     /**
-     * All source buffers have been created and data may be appended.
+     * All source buffers have been created, the media source duration has been set, and data
+     * may be appended.
      */
     readonly readyToAppend: AnyRecord;
     /**
@@ -35,20 +44,12 @@ export interface ReadonlyMediaSourceController extends ReadonlyEventHost<MediaSo
      * Returns the parent media source ready state.
      */
     readonly readyState: ReadyState;
-    /**
-     * Gets the media source's duration.
-     */
-    readonly duration: number;
     /**
      * True if all source buffers have been created and data may be appended.
      */
     readonly readyToAppend: boolean;
 }
 export interface MediaSourceController extends ReadonlyMediaSourceController {
-    /**
-     * Sets/gets the media source's duration.
-     */
-    duration: number;
     /**
      * Constructs a new SourceBuffer with the given content type and mime type.
      */
@@ -72,21 +73,46 @@ export interface MediaSourceControllerImplDeps {
      * Provides the streams that must be created before appending.
      */
     readonly contentTypesValue: ContentTypesValue;
+    /**
+     * The media timeline used to determine duration.
+     */
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
 }
 export declare class MediaSourceControllerImpl extends EventHostImpl<MediaSourceControllerEventMap> implements MediaSourceController, LogTarget {
+    private readonly deps;
     get [Symbol.toStringTag](): string;
-    private sourceBufferCount;
+    private readonly sourceBuffers;
     private readonly mediaSource;
     private readonly disposer;
     private contentTypes;
+    private durationSet;
+    /**
+     * Token for the in-flight duration update; used to discard stale results when
+     * the timeline changes or the source closes mid-fetch.
+     */
+    private durationToken;
     constructor(deps: MediaSourceControllerImplDeps);
+    private get sourceBufferCount();
+    private readonly errorHandler;
+    /**
+     * Subscription to mediaTimelineTransformed; only attached while the media source is open
+     * so the timeline pipeline isn't forced to evaluate before the source has opened.
+     */
+    private timelineSub;
     private initializeEvents;
-    get duration(): number;
-    set duration(value: number);
+    /**
+     * Sets the duration on the media source from the current media timeline.
+     * Live streams use LIVE_DURATION since not all browsers support +Infinity duration.
+     *
+     * MSE throws InvalidStateError if duration is set while any source buffer is updating,
+     * so we wait for all tracked source buffers to be idle first.
+     */
+    private refreshDuration;
     get readyState(): ReadyState;
     createSourceBuffer(contentType: ContentType, mimeType: string): SourceBufferRef;
     /**
-     * Emits a 'readyToAppend' event if all source buffers have been created.
+     * Emits a 'readyToAppend' event if all source buffers have been created and the duration
+     * has been applied to the media source.
      */
     private readonly checkReady;
     endOfStream(error?: EndOfStreamError): void;

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

@@ -1,6 +1,6 @@
 import { Disposable, LogTarget, ReadonlyRanges, Task } from '@amazon/vinyl-util';
 import { MediaSourceController } from './MediaSourceController';
-import { ContentType } from '../../streaming/MediaQualityMetadata';
+import { ContentType } from '../MediaQualityMetadata';
 export declare const APPEND_WINDOW_START_OFFSET = 0.05;
 export declare const APPEND_WINDOW_END_OFFSET = 0.01;
 export declare const READY_TO_APPEND_TIMEOUT = 30;

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/createDefaultMediaTimelineTransformer.d.ts

@@ -1,7 +1,7 @@
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { Capabilities } from '../client/Capabilities';
 import { DrmController } from '../drm/DrmController';
-import { MediaTimeline } from '../streaming/MediaTimeline';
+import { MediaTimeline } from './MediaTimeline';
 export interface DefaultMediaTimelineTransformerDeps {
     readonly capabilities: Capabilities;
     readonly drmController: DrmController;

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

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

@@ -1,5 +1,5 @@
-import { MediaTimeline } from '../streaming/MediaTimeline';
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { MediaTimeline } from './MediaTimeline';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 import { FilterPredicate, FilterPredicateAsync, Maybe } from '@amazon/vinyl-util';
 /**
  * Filters qualities in a MediaTimeline using a synchronous predicate.
@@ -14,5 +14,5 @@ export declare function filterTimelineQualitiesAsync(filter: FilterPredicateAsyn
 /**
  * Creates a language filter predicate for use with filterTimelineQualities.
  */
-export { createLanguageFilter } from '../streaming/mediaTimelineLanguageFilter';
+export { createLanguageFilter } from './mediaTimelineLanguageFilter';
 //# sourceMappingURL=mediaTimelineFilter.d.ts.map

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

@@ -1,4 +1,4 @@
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 import { FilterPredicate } from '@amazon/vinyl-util';
 /**
  * Creates a filter predicate that keeps qualities matching the preferred language.

package/dist/types/ts3.7/streaming/util/segment.d.ts

@@ -1,4 +1,4 @@
-import { MediaSegmentMetadata } from '../../streaming/SegmentReference';
+import { MediaSegmentMetadata } from '../SegmentReference';
 /**
  * Returns the segment whose range covers `time` (`startTime <= time < endTime`), or
  * — when `affordance > 0` — the next segment if `time` falls within `affordance`

package/dist/types/ts3.7/text/HtmlTextTrackRenderer.d.ts

@@ -0,0 +1,60 @@
+import { Disposable } from '@amazon/vinyl-util';
+import { TextTrackRenderer } from './TextTrackRenderer';
+/**
+ * The subset of a `VTTCue`'s positioning properties {@link computeCueLayout}
+ * reads. A native `VTTCue` satisfies this; a plain `TextTrackCue` (platforms
+ * without `VTTCue`) leaves them undefined and falls back to defaults.
+ */
+export interface CueGeometry {
+    readonly align?: string | null;
+    readonly line?: number | AutoKeyword;
+    readonly lineAlign?: LineAlignSetting;
+    readonly position?: number | AutoKeyword;
+    readonly positionAlign?: PositionAlignSetting;
+    readonly size?: number;
+    readonly snapToLines?: boolean;
+    readonly vertical?: DirectionSetting;
+}
+/** Inline styles (camelCase CSS properties) to apply to a rendered cue box. */
+export type CueLayout = Record<string, string>;
+/**
+ * Maps a cue's WebVTT positioning settings to inline CSS. Pure and DOM-free so
+ * the (branchy) placement logic is unit-testable in isolation.
+ *
+ * A cue with neither `line` nor `position` set flows in the renderer's
+ * bottom-anchored, centered container (the common subtitle case). Otherwise it
+ * is absolutely positioned: `size` → width, `position`/`positionAlign` →
+ * horizontal, `line`/`lineAlign`/`snapToLines` → vertical (percentage lines, or
+ * whole rows counted from the bottom for negative integers), `align` → text
+ * alignment, `vertical` → writing mode.
+ */
+export declare function computeCueLayout(cue: CueGeometry): CueLayout;
+/**
+ * Renders a cue's text payload as safe HTML. Text is escaped (so it can't
+ * inject nodes); newlines become `<br>`; and WebVTT cue tags are converted:
+ * `<c.foo>`→`<span class="foo">`, `<i>/<b>/<u>/<ruby>/<rt>` pass through,
+ * `<v Name>`→`<span title>`, `<lang xx>`→`<span lang>`, timestamp tags are
+ * dropped. Class-based styling requires matching app CSS (STYLE blocks in the
+ * VTT are not applied).
+ */
+export declare function renderCueText(text: string): string;
+/**
+ * A {@link TextTrackRenderer} that paints cues as HTML into {@link element}.
+ * Mount `element` over the video; it stacks cues at the bottom, centered, and
+ * positions any cue that carries explicit WebVTT settings. The DOM track is
+ * expected to be `'hidden'` so only this renderer paints.
+ */
+export declare class HtmlTextTrackRenderer implements TextTrackRenderer, Disposable {
+    /** The overlay container to mount over the video. */
+    readonly element: HTMLElement;
+    private track;
+    private readonly styleElement;
+    private readonly onCueChange;
+    constructor();
+    setTextTrack(track: TextTrack | null): void;
+    setStyles(styles: readonly string[]): void;
+    dispose(): void;
+    private renderActiveCues;
+    private createCueBox;
+}
+//# sourceMappingURL=HtmlTextTrackRenderer.d.ts.map