@amazon/vinyl 1.2.0 → 2.0.0

package/dist/types/ts3.7/track/hls/createHlsFactories.d.ts

@@ -1,10 +1,11 @@
 import { HlsTrackLoadOptions } from './HlsTrack';
 import { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+import { AdController } from '../../ad/AdController';
 import { createMediaSource } from '../../util/media/mediaSource';
 import { MediaSourceControllerImpl, MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
-import { HlsManifestControllerImpl } from './HlsManifestController';
 import { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
 import { createHlsContentTypesValue } from './createHlsContentTypesValue';
+import { createAllowedContentTypesValue } from '../../streaming/createAllowedContentTypesValue';
 import { createContentStreamFactory } from '../../streaming/ContentStream';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { PlaybackController } from '../../playback/PlaybackController';
@@ -12,31 +13,41 @@ import { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import { DrmController } from '../../drm/DrmController';
 import { Capabilities } from '../../client/Capabilities';
 import { PlaybackSource } from '../../playback/PlaybackSource';
-import { QualitySelectorImplOptions } from '../../streaming/abr/QualitySelectorImpl';
 import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
 import { VinylOptions } from '../../vinyl/VinylOptions';
 import { createDefaultHlsManifestTransformer } from './createDefaultHlsManifestTransformer';
 import { BuildHlsMediaTimelineDeps } from './buildHlsMediaTimeline';
 import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
-import { HlsManifestData } from './HlsManifestProvider';
+import { HlsManifestData } from './HlsManifestData';
+import { SidecarTextTrackController } from '../../text/SidecarTextTrackController';
+import { ManifestControllerImpl, ManifestControllerImplDeps } from '../../streaming/ManifestControllerImpl';
 export interface HlsFactoryDeps {
-    readonly options: ObservableValue<{
-        readonly abr: QualitySelectorImplOptions;
-        readonly preferredAudioLanguage: string | null;
-    }>;
+    readonly options: ObservableValue<Pick<VinylOptions, 'abr' | 'preferredAudioLanguage' | 'allowedContentTypes' | 'preferDescriptiveAudio' | 'preferredTextLanguage' | 'textCueStyle'>>;
     readonly playbackController: PlaybackController;
     readonly playbackSource: PlaybackSource;
     readonly drmKeySystemResolver: DrmKeySystemResolver;
     readonly requestInterceptor: RequestInterceptor;
     readonly drmController: DrmController;
     readonly capabilities: Capabilities;
+    /**
+     * The HTML media element. Required to attach sidecar text tracks via
+     * `media.addTextTrack`.
+     */
+    readonly media: HTMLMediaElement;
+    /**
+     * The player-level ad controller. MseTrack sets discovered ad breaks on it
+     * when the media timeline resolves.
+     */
+    readonly adController: AdController;
 }
 export type HlsInitOptions = {
     readonly streaming?: Maybe<ContentStreamingOptions>;
 };
 export declare function createHlsFactories(options: Maybe<HlsInitOptions>): (deps: HlsFactoryDeps) => (loadOptions: HlsTrackLoadOptions) => {
-    contentTypesValue: typeof createHlsContentTypesValue;
-    manifestController: () => HlsManifestControllerImpl;
+    baseContentTypesValue: typeof createHlsContentTypesValue;
+    contentTypesValue: typeof createAllowedContentTypesValue;
+    manifestProvider: () => import("./createHlsManifestProvider").HlsManifestProvider;
+    manifestController: (deps: ManifestControllerImplDeps<HlsManifestData>) => ManifestControllerImpl<HlsManifestData>;
     manifestTransformed: typeof createDefaultHlsManifestTransformer;
     mediaQualityMetadataResolver: () => import("./HlsMediaQualityMetadataResolver").HlsMediaQualityMetadataResolver;
     mediaSourceFactory: () => typeof createMediaSource;
@@ -55,19 +66,35 @@ export declare function createHlsFactories(options: Maybe<HlsInitOptions>): (dep
     qualitySelector: (deps: {
         options: ObservableValue<Pick<VinylOptions, "abr">>;
     }) => QualitySelectorImpl;
+    preferredAudioLanguage: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "preferredAudioLanguage">>;
+    }) => ObservableValue<string | readonly string[] | null>;
+    allowedContentTypes: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "allowedContentTypes">>;
+    }) => ObservableValue<readonly import("../..").RestrictableContentType[] | null>;
+    preferDescriptiveAudio: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "preferDescriptiveAudio">>;
+    }) => ObservableValue<boolean>;
+    abr: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "abr">>;
+    }) => ObservableValue<import("../..").QualitySelectorImplOptions>;
     mediaTimeline: (deps: BuildHlsMediaTimelineDeps & {
         readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
     }) => ObservableValue<Promise<import("../..").MediaTimeline>>;
     mediaTimelineTransformed: typeof createDefaultMediaTimelineTransformer;
-    options: import("@amazon/vinyl-di").Factory<ObservableValue<{
-        readonly abr: QualitySelectorImplOptions;
-        readonly preferredAudioLanguage: string | null;
-    }>>;
+    textTrackController: (deps: {
+        readonly media: HTMLMediaElement;
+        readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
+        readonly options: ObservableValue<Pick<VinylOptions, "preferredTextLanguage" | "textCueStyle">>;
+    }) => SidecarTextTrackController;
+    options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "abr" | "preferredAudioLanguage" | "preferredTextLanguage" | "preferDescriptiveAudio" | "allowedContentTypes" | "textCueStyle">>>;
     playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
     playbackSource: import("@amazon/vinyl-di").Factory<PlaybackSource>;
     drmKeySystemResolver: import("@amazon/vinyl-di").Factory<DrmKeySystemResolver>;
     requestInterceptor: import("@amazon/vinyl-di").Factory<RequestInterceptor>;
     drmController: import("@amazon/vinyl-di").Factory<DrmController>;
     capabilities: import("@amazon/vinyl-di").Factory<Capabilities>;
+    media: import("@amazon/vinyl-di").Factory<HTMLMediaElement>;
+    adController: import("@amazon/vinyl-di").Factory<AdController>;
 };
 //# sourceMappingURL=createHlsFactories.d.ts.map

package/dist/types/ts3.7/track/hls/createHlsManifestProvider.d.ts

@@ -0,0 +1,6 @@
+import { HlsTrackLoadOptions } from './HlsTrack';
+import { ManifestProvider } from '../../streaming/ManifestController';
+import { HlsManifestData } from './HlsManifestData';
+export declare function createHlsManifestProvider(loadOptions: HlsTrackLoadOptions): HlsManifestProvider;
+export type HlsManifestProvider = ManifestProvider<HlsManifestData>;
+//# sourceMappingURL=createHlsManifestProvider.d.ts.map

package/dist/types/ts3.7/track/hls/createUrlHlsManifestProvider.d.ts

@@ -1,6 +1,6 @@
-import { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+import { HlsMainPlaylist, HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
 import { Maybe, ReadonlyAbort, RequestInitOptions } from '@amazon/vinyl-util';
-import { HlsManifestProvider } from './HlsManifestProvider';
+import { HlsManifestProvider } from './createHlsManifestProvider';
 export declare function createUrlHlsManifestProvider(url: string, requestInit?: RequestInitOptions): HlsManifestProvider;
 export interface FetchMediaPlaylistOptions {
     /** The variant URI to resolve against the base URL. */
@@ -8,7 +8,7 @@ export interface FetchMediaPlaylistOptions {
     /** The base URL for resolving relative URIs. */
     readonly baseUrl: string;
     /** Variable definitions from the main playlist. */
-    readonly defines: MainPlaylist['defines'];
+    readonly defines: HlsMainPlaylist['defines'];
     /** Optional request configuration. */
     readonly requestInit?: Maybe<RequestInitOptions>;
     /** Optional abort signal. */
@@ -17,5 +17,5 @@ export interface FetchMediaPlaylistOptions {
 /**
  * Fetches and parses an HLS media playlist from a variant URI.
  */
-export declare function fetchMediaPlaylist(options: FetchMediaPlaylistOptions): Promise<MediaPlaylist>;
+export declare function fetchMediaPlaylist(options: FetchMediaPlaylistOptions): Promise<HlsMediaPlaylist>;
 //# sourceMappingURL=createUrlHlsManifestProvider.d.ts.map

package/dist/types/ts3.7/track/hls/index.d.ts

@@ -1,4 +1,4 @@
-export * from './HlsManifestProvider';
+export * from './HlsManifestData';
 export * from './createUrlHlsManifestProvider';
 export * from './HlsManifestController';
 export * from './HlsMediaQualityMetadataResolver';

package/dist/types/ts3.7/track/inferLoadOptionsFromUri.d.ts

@@ -0,0 +1,15 @@
+import { VinylTrackLoadOptions } from './createVinylTrackFactories';
+/**
+ * The built-in track types Vinyl can infer from a URI.
+ */
+export type TrackType = 'hls' | 'dash' | 'src';
+/**
+ * Infers the track type from a URI based first on its file extension
+ * then mime type.
+ *
+ * Returns null if the type cannot be determined.
+ */
+export declare function inferTrackTypeFromUrl(url: string): Promise<TrackType | null>;
+export declare function inferTrackTypeFromUrlPath(url: string): TrackType | null;
+export declare function createTrackLoadOptionsFromUrl(url: string): Promise<VinylTrackLoadOptions | null>;
+//# sourceMappingURL=inferLoadOptionsFromUri.d.ts.map

package/dist/types/ts3.7/track/mse/MseTrack.d.ts

@@ -1,5 +1,5 @@
-import { TrackBase, TrackBaseDeps, TrackBaseOptions } from '../TrackBase';
-import { ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import { TrackBase, TrackBaseDeps } from '../TrackBase';
+import { Maybe, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
 import { TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import { Factories } from '@amazon/vinyl-di';
@@ -10,6 +10,19 @@ import { ContentTypesValue } from '../../streaming/ContentTypesValue';
 import { ManifestController } from '../../streaming/ManifestController';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { MediaTimeline } from '../../streaming/MediaTimeline';
+import { TextTrackController } from '../../text/TextTrack';
+import { TrackConfigOptions } from '../TrackFactory';
+import { TrackAds } from '../../ad/AdBreakInfo';
+import { VinylOptions } from '../../vinyl/VinylOptions';
+/**
+ * How long to wait after all streams have data before checking whether a seek
+ * is still stuck, in seconds.
+ */
+export declare const SEEKING_STALL_TIME_CHECK = 0.1;
+/**
+ * How far to nudge the playhead, in seconds, to recover a stuck seek.
+ */
+export declare const PLAYHEAD_NUDGE = 0.05;
 export type MseTrackDeps = TrackBaseDeps & {
     readonly contentTypesValue: ContentTypesValue;
     readonly contentStreamFactory: (contentType: ContentType) => ContentStream;
@@ -18,6 +31,21 @@ export type MseTrackDeps = TrackBaseDeps & {
     readonly playbackSource: PlaybackSource;
     readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
     readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    /**
+     * Optional sidecar text track controller for this track. When provided,
+     * the controller is exposed via {@link MseTrack.textTrackController} and
+     * disposed when the track itself is disposed.
+     */
+    readonly textTrackController?: TextTrackController | null;
+    /**
+     * Player options that re-select this track's audio/streams. A change (not
+     * the initial value) is applied to this track immediately so it takes
+     * effect without waiting for the buffered media to drain.
+     */
+    readonly preferredAudioLanguage: ObservableValue<VinylOptions['preferredAudioLanguage']>;
+    readonly allowedContentTypes: ObservableValue<VinylOptions['allowedContentTypes']>;
+    readonly preferDescriptiveAudio: ObservableValue<VinylOptions['preferDescriptiveAudio']>;
+    readonly abr: ObservableValue<VinylOptions['abr']>;
 };
 /**
  * An MseTrack uses media source extensions for streaming.
@@ -25,10 +53,11 @@ export type MseTrackDeps = TrackBaseDeps & {
 export declare class MseTrack extends TrackBase {
     get [Symbol.toStringTag](): string;
     protected readonly deps: MseTrackDeps;
+    get textTrackController(): (TextTrackController | null);
     private readonly streams;
+    private stallNudgeTimer;
     private readonly disposeAbort;
     private lastPreloadOptions;
-    private activateOptions;
     private readonly allFetchedRanges;
     private readonly _fetchedRanges;
     private _contentTypes;
@@ -37,23 +66,44 @@ export declare class MseTrack extends TrackBase {
     private timeUpdateSub;
     private _cachedPeriod;
     constructor(uri: TrackUri, type: TrackTypeId, dependencyFactories: Factories<MseTrackDeps>);
+    /**
+     * Clears this track's buffers and rebuilds its streams so a changed
+     * audio/language/content-type selection applies immediately.
+     * {@link reset} with `hard` safely no-ops the rebuild for an inactive
+     * (cached) track.
+     */
+    private reloadStreams;
+    /**
+     * Re-dispatches a sub-controller's load span stamped with this track's uri,
+     * so the span attributes to the track that owns it at the source.
+     */
+    private dispatchLoadSpan;
     /**
      * Updates the cached qualities list from the transformed timeline for the current period.
      */
     private updateQualities;
+    getAds(): Promise<TrackAds>;
     /**
      * Updates the cached unfiltered qualities list from the raw timeline for the current period.
      */
     private updateQualitiesUnfiltered;
+    private updateSeekRanges;
+    /**
+     * Invokes a callback when the given timeline promise resolves and was not
+     * interrupted by that timeline changing or the track being disposed.
+     *
+     * Pass `mediaTimelineTransformed` for the playable (filtered) view or
+     * `mediaTimeline` for the raw, unfiltered view.
+     */
+    private withTimeline;
     /**
      * Creates and adds a content stream for the given content type.
      *
      * @param contentType
      */
     protected createStream(contentType: ContentType): void;
-    preload(trackOptions: TrackPreloadOptions, loadOptions: TrackBaseOptions): void;
+    preload(trackOptions: TrackPreloadOptions, loadOptions: Maybe<TrackConfigOptions>): void;
     get contentTypes(): ReadonlySet<ContentType>;
-    set contentTypes(value: ReadonlySet<ContentType>);
     get qualities(): (readonly MediaQualityMetadata[] | null);
     get qualitiesUnfiltered(): (readonly MediaQualityMetadata[] | null);
     get fetchedRanges(): ReadonlyRanges;
@@ -67,8 +117,8 @@ export declare class MseTrack extends TrackBase {
      * Resets the track to recover from error states.
      * Resets both the segment controller and buffering controller to clear failed segments and error conditions.
      */
-    reset(): void;
-    onActivated(loadOptions: TrackBaseOptions): void;
+    reset(hard?: boolean): void;
+    onActivated(loadOptions: Maybe<TrackConfigOptions>): void;
     onDeactivated(): void;
     getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
     getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
@@ -80,6 +130,14 @@ export declare class MseTrack extends TrackBase {
     private getStream;
     private clearStreams;
     get bufferingEnded(): boolean;
+    /**
+     * A seek only completes once every stream has data at the target, but on
+     * some platforms the element can stay stuck `seeking` even after that. Once
+     * all streams hold data, if we're still seeking a moment later, nudge the
+     * playhead to prod the element into completing the seek.
+     */
+    private checkStalledSeek;
+    private setContentTypes;
     dispose(): void;
 }
 //# sourceMappingURL=MseTrack.d.ts.map

package/dist/types/ts3.7/track/source/SourceObjectTrack.d.ts

@@ -3,7 +3,7 @@ import { TrackTypeId, TrackUri } from '../Track';
 import { TrackBaseDeps } from '../TrackBase';
 import { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import { Maybe } from '@amazon/vinyl-util';
-import { SourceTrackBase, SourceTrackBaseOptions } from './SourceTrackBase';
+import { SourceTrackBase, SourceTrackConfigOptions } from './SourceTrackBase';
 /**
  * Dependencies for a SourceObjectTrack.
  */
@@ -20,7 +20,7 @@ export interface SourceObjectTrackLoadOptions extends TrackLoadOptions {
      * Configuration options for the SourceObjectTrack.
      * Will be provided on preload and activate.
      */
-    readonly config?: Maybe<SourceTrackBaseOptions>;
+    readonly config?: Maybe<SourceTrackConfigOptions>;
 }
 export declare function createSourceObjectTrackFactory(deps: SourceObjectTrackDeps): TrackFactory<SourceObjectTrackLoadOptions>;
 export declare class SourceObjectTrack extends SourceTrackBase<MediaStream> {

package/dist/types/ts3.7/track/source/SourceTrack.d.ts

@@ -2,7 +2,7 @@ import { TrackTypeId, TrackUri } from '../Track';
 import { TrackBaseDeps } from '../TrackBase';
 import { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import { Maybe } from '@amazon/vinyl-util';
-import { SourceTrackBase, SourceTrackBaseOptions } from './SourceTrackBase';
+import { SourceTrackBase, SourceTrackConfigOptions } from './SourceTrackBase';
 import { PlaybackSource } from '../../playback/PlaybackSource';
 /**
  * Dependencies for a SourceTrack.
@@ -21,7 +21,7 @@ export interface SourceTrackLoadOptions extends TrackLoadOptions {
      * Configuration options for the SourceTrack.
      * Will be provided on preload and activate.
      */
-    readonly config?: Maybe<SourceTrackBaseOptions>;
+    readonly config?: Maybe<SourceTrackConfigOptions>;
 }
 export declare function createSourceTrackFactory(deps: SourceTrackDeps): TrackFactory<SourceTrackLoadOptions>;
 export declare class SourceTrack extends SourceTrackBase<string> {

package/dist/types/ts3.7/track/source/SourceTrackBase.d.ts

@@ -1,23 +1,25 @@
-import { TrackBase, TrackBaseDeps, TrackBaseOptions } from '../TrackBase';
+import { TrackBase, TrackBaseDeps } from '../TrackBase';
 import { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import { Maybe, ReadonlySet } from '@amazon/vinyl-util';
 import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import { ObjectSchema } from '@amazon/vinyl-validation';
-export interface SourceTrackBaseOptions extends TrackBaseOptions {
+import { TrackConfigOptions } from '../TrackFactory';
+export interface SourceTrackConfigOptions extends TrackConfigOptions {
     /**
      * Quality metadata.
      * May be used to configure DRM (for native HLS), codec, or other track metadata.
      */
     readonly qualityMetadata?: Maybe<Partial<MediaQualityMetadata>>;
 }
-export declare const sourceTrackBaseOptionsValidator: ObjectSchema<SourceTrackBaseOptions>;
-export declare abstract class SourceTrackBase<SrcType, EventMap extends TrackEventMap = TrackEventMap, LoadOptionsType extends SourceTrackBaseOptions = SourceTrackBaseOptions> extends TrackBase<EventMap, LoadOptionsType> {
+export declare const sourceTrackBaseOptionsValidator: ObjectSchema<SourceTrackConfigOptions>;
+export declare abstract class SourceTrackBase<SrcType, EventMap extends TrackEventMap = TrackEventMap, TrackConfigOptions extends SourceTrackConfigOptions = SourceTrackConfigOptions> extends TrackBase<EventMap, TrackConfigOptions> {
     readonly src: Promise<SrcType>;
     protected readonly deps: TrackBaseDeps;
     private readonly fixedPlaybackQuality;
     private _resolvedSrc;
+    private activeSub;
     protected constructor(uri: TrackUri, type: TrackTypeId, src: Promise<SrcType>, deps: TrackBaseDeps);
-    preload(trackOptions: TrackPreloadOptions, loadOptions: LoadOptionsType): void;
+    preload(trackOptions: TrackPreloadOptions, loadOptions: Maybe<TrackConfigOptions>): void;
     get contentTypes(): ReadonlySet<ContentType>;
     get qualities(): (readonly MediaQualityMetadata[] | null);
     get qualitiesUnfiltered(): (readonly MediaQualityMetadata[] | null);

package/dist/types/ts3.7/util/media/codecOverrides.d.ts

@@ -0,0 +1,33 @@
+/**
+ * An explicit application-provided decision to allow or deny a codec,
+ * bypassing the browser's support detection.
+ *
+ *  - `'allow'` forces the codec to be treated as supported even if the browser
+ *    reports it unsupported (e.g. to opt in to a codec the app knows the
+ *    platform can decode via an external path).
+ *  - `'deny'` forces the codec to be treated as unsupported even if the browser
+ *    reports it supported (e.g. to work around a browser that falsely claims
+ *    support, or to exclude a codec by policy).
+ */
+export type CodecOverride = 'allow' | 'deny';
+/**
+ * Explicit codec allow/deny overrides. Keys are RFC 6381 codec strings or
+ * prefixes (matched case-insensitively against the start of each codec in a
+ * mimeType's `codecs=` list, so `"hvc1"` matches `"hvc1.2.20000000.L123.B0"`).
+ *
+ * An override supersedes the browser's support detection entirely. When a
+ * mimeType contains multiple codecs, a `'deny'` on any of them denies the
+ * mimeType; an `'allow'` applies only when no codec is denied.
+ */
+export type CodecOverrides = Readonly<Record<string, CodecOverride>>;
+/**
+ * Resolves the effective override decision for a mimeType against a set of
+ * {@link CodecOverrides}, or undefined when no override applies (in which case
+ * the caller should fall back to normal support detection).
+ *
+ * A `'deny'` on any contained codec wins over an `'allow'` on another, so an
+ * explicit deny is never silently overridden by an allow elsewhere in the
+ * mimeType.
+ */
+export declare function resolveCodecOverride(mimeType: string, overrides: CodecOverrides | undefined): CodecOverride | undefined;
+//# sourceMappingURL=codecOverrides.d.ts.map

package/dist/types/ts3.7/util/media/codecSupport.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extracts the individual codec strings from a mimeType's `codecs=` parameter.
+ * Returns an empty array when no codecs parameter is present.
+ */
+export declare function extractCodecs(mimeType: string): string[];
+//# sourceMappingURL=codecSupport.d.ts.map

package/dist/types/ts3.7/util/media/mediaSource.d.ts

@@ -9,6 +9,11 @@ declare global {
 export declare function supportsMse(): boolean;
 /**
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaSource/isTypeSupported_static)
+ *
+ * Delegates to the browser's native support check. False-positive codecs
+ * (where the browser reports support but decode fails at runtime) are handled
+ * by the decode-failure recovery path rather than a static denylist, so this
+ * function reflects the browser's own answer.
  */
 export declare function isTypeSupported(type: string): boolean;
 /**

package/dist/types/ts3.7/vinyl/ReadonlyPlaybackStreamingState.d.ts

@@ -1,5 +1,7 @@
 import { ReadonlyEventHost } from '@amazon/vinyl-util';
-import { TrackEventMap, ReadonlyStreamingState } from '../track/Track';
+import { ReadonlyStreamingState } from '../track/Track';
+import { SeekRange } from '../track/SeekRange';
+import { StreamingEventMap } from '../streaming/StreamingEventMap';
 /**
  * Represents the streaming state of the currently active track.
  *
@@ -15,7 +17,7 @@ import { TrackEventMap, ReadonlyStreamingState } from '../track/Track';
  * - `bufferingQualityChange`
  * - `playbackQualityChange`
  */
-export interface ReadonlyPlaybackStreamingState extends ReadonlyEventHost<TrackEventMap>, ReadonlyStreamingState {
+export interface ReadonlyPlaybackStreamingState extends ReadonlyEventHost<StreamingEventMap>, ReadonlyStreamingState {
     /**
      * Returns the time of the prefetch end.
      * If no data has been prefetched for the current track, 0 will be returned.
@@ -30,5 +32,10 @@ export interface ReadonlyPlaybackStreamingState extends ReadonlyEventHost<TrackE
      * @return A number between 0-1
      */
     readonly fetchedTimePercent: number;
+    /**
+     * The seekable range on the media timeline for the current track, or null
+     * when no track is loaded or the timeline is not yet resolved.
+     */
+    readonly seekRange: SeekRange | null;
 }
 //# sourceMappingURL=ReadonlyPlaybackStreamingState.d.ts.map

package/dist/types/ts3.7/vinyl/VinylDeps.d.ts

@@ -8,6 +8,7 @@ import { DrmController } from '../drm/DrmController';
 import { AutoResetController } from '../track/AutoResetController';
 import { MutableValue } from '@amazon/vinyl-observable';
 import { VinylOptions } from './VinylOptions';
+import { AdController } from '../ad/AdController';
 export interface VinylDeps<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions, OptionsType = VinylOptions> {
     /**
      * A mutable provider for configuration options.
@@ -37,5 +38,9 @@ export interface VinylDeps<TrackLoadOptionsType extends TrackLoadOptions = Vinyl
      * Notifies when playback can automatically reset after a failure.
      */
     readonly autoResetController: AutoResetController;
+    /**
+     * Manages ad break state and playback sequencing.
+     */
+    readonly adController: AdController;
 }
 //# sourceMappingURL=VinylDeps.d.ts.map

package/dist/types/ts3.7/vinyl/VinylOptions.d.ts

@@ -1,6 +1,9 @@
 import { QualitySelectorImplOptions } from '../streaming/abr/QualitySelectorImpl';
 import { ObjectSchema } from '@amazon/vinyl-validation';
+import { CodecOverrides } from '../util/media/codecOverrides';
+import { RestrictableContentType } from '../streaming/MediaQualityMetadata';
 import { LoudnessNormalizationControllerImplOptions } from '../playback/loudness/LoudnessNormalizationControllerImplOptions';
+import { VttCueStyle } from '../text/VttCueStyle';
 export interface VinylOptions {
     /**
      * Configuration for the default adaptive bitrate selector.
@@ -8,11 +11,72 @@ export interface VinylOptions {
     readonly abr: QualitySelectorImplOptions;
     readonly loudnessNormalization: LoudnessNormalizationControllerImplOptions;
     /**
-     * Preferred language for audio content, using a code as defined by RFC 5646 (e.g. 'en', 'ja').
-     * When set, only adaptation sets / variants matching this language (or without a language tag)
-     * are kept. Null means no language preference (all languages are kept).
+     * 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 preferredAudioLanguage: string | null;
+    readonly preferredAudioLanguage: string | readonly string[] | null;
+    /**
+     * Preferred language(s) for text tracks (subtitles / closed captions), 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 chosen among the discovered text tracks. When set, the
+     * matching text track is selected automatically and the choice carries
+     * across track changes (e.g. across an ad break), mirroring how
+     * {@link preferredAudioLanguage} drives audio selection.
+     *
+     * Unlike audio, `null` (the default) means *no caption preference*: it does
+     * NOT fall back to `navigator.languages` and does NOT force captions on —
+     * forced narrative subtitles still auto-display as usual. Setting it to a
+     * language turns captions on in that language; setting it back to `null`
+     * after a prior selection turns captions off.
+     */
+    readonly preferredTextLanguage: 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 preferDescriptiveAudio: boolean;
+    /**
+     * Explicit codec allow/deny overrides that bypass browser support
+     * detection. Keys are RFC 6381 codec strings or prefixes (e.g. `"hvc1"`),
+     * values are `'allow'` or `'deny'`. An `'allow'` forces a codec to be
+     * treated as supported; a `'deny'` forces it to be treated as unsupported.
+     * Empty by default (support is determined solely by the browser and the
+     * known-false-report list).
+     */
+    readonly codecOverrides: CodecOverrides;
+    /**
+     * Allow list restricting which media content types (`'audio'`, `'video'`)
+     * are streamed. When set, only streams whose content type is in the list
+     * are created; all other media streams are ignored. For example,
+     * `['audio']` streams audio but never video. Changing this reloads the
+     * track using only the allowed content types. Null (the default) means no
+     * restriction (all available media content types are streamed).
+     *
+     * Text tracks (subtitles / closed captions) are not affected by this allow
+     * list; they are governed by caption selection and always remain
+     * available.
+     */
+    readonly allowedContentTypes: readonly RestrictableContentType[] | null;
+    /**
+     * Layout style applied to rendered WebVTT cues (the settable `VTTCue`
+     * positioning properties: size, line, position, align, etc.). Applied to
+     * each cue as it is added, on platforms that support `VTTCue`.
+     *
+     * Defaults to `{ size: 90 }`, insetting the cue box from the full video
+     * width so long lines don't clip at the screen edges in fullscreen (which
+     * `::cue` CSS cannot fix). Set to `null` to keep the browser defaults.
+     */
+    readonly textCueStyle: VttCueStyle | null;
 }
 export declare const defaultVinylOptions: VinylOptions;
 export declare const vinylOptionsValidator: ObjectSchema<VinylOptions>;

package/dist/types/ts3.7/vinyl/VinylPlayer.d.ts

@@ -5,6 +5,7 @@ import { PlaybackController } from '../playback/PlaybackController';
 import { PlaybackControllerEventMap, PlaybackNetworkState, PlaybackReadyState } from '../playback/ReadonlyPlaybackController';
 import { VinylTrackLoadOptions } from '../track/createVinylTrackFactories';
 import { ReadonlyTrack, TrackUri } from '../track/Track';
+import { SeekRange } from '../track/SeekRange';
 import { TrackController, TrackControllerEventMap } from '../track/TrackController';
 import { InferLoadOptionsFromFactory, TrackLoadOptions } from '../track/TrackFactory';
 import { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDependencyOptions } from './createVinylFactories';
@@ -13,13 +14,17 @@ import { Capabilities } from '../client/Capabilities';
 import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
 import { ReadonlyPlaybackStreamingState } from './ReadonlyPlaybackStreamingState';
 import { StreamingEventMap } from '../streaming/StreamingEventMap';
+import { LoadMetricEventMap } from '../streaming/LoadMetric';
 import { InferObservableValueType } from '@amazon/vinyl-observable';
 import { VinylOptions } from './VinylOptions';
 import { ChangeEvent } from '../event/ChangeEvent';
+import { TextTrackEventMap, TextTrackInfo } from '../text/TextTrack';
+import { AdEventMap } from '../ad/AdController';
+import { AdBreakInfo, AdInfo, TrackAds } from '../ad/AdBreakInfo';
 /**
  * Events the Vinyl Player emits.
  */
-export interface VinylPlayerEventMap<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions> extends PlaybackControllerEventMap, TrackControllerEventMap<TrackLoadOptionsType>, StreamingEventMap {
+export interface VinylPlayerEventMap<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions> extends PlaybackControllerEventMap, TrackControllerEventMap<TrackLoadOptionsType>, StreamingEventMap, TextTrackEventMap, AdEventMap, LoadMetricEventMap {
     /**
      * Dispatched when {@link VinylPlayer.resetPending} changes.
      *
@@ -67,7 +72,6 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
      */
     protected redispatchCurrentTrackEvents(): void;
     private initializeAutoResetHandling;
-    private initializePreferredLanguageHandling;
     get options(): OptionsType;
     /**
      * Sets options on this player.
@@ -105,6 +109,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     set preservesPitch(value: boolean);
     get readyState(): PlaybackReadyState;
     get seekable(): ReadonlyRanges;
+    get seekRange(): (SeekRange | null);
     get seeking(): boolean;
     get volume(): number;
     set volume(value: number);
@@ -112,8 +117,8 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     pause(): void;
     play(): Promise<void>;
     seekTo(time: number, tolerance?: number): Promise<void>;
-    reset(): void;
-    get currentTrack(): (ReadonlyTrack | null);
+    reset(hard?: boolean): void;
+    get activeTrack(): (ReadonlyTrack | null);
     get queue(): readonly TrackLoadOptionsType[];
     preload(...loadOptionsList: TrackLoadOptionsType[]): void;
     load(...loadOptionsList: TrackLoadOptionsType[]): void;
@@ -149,6 +154,30 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
      * The currently playing quality, or null if no media is playing.
      */
     getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    get textTracks(): readonly TextTrackInfo[];
+    get activeTextTrack(): (TextTrackInfo | null);
+    /**
+     * Selects the text track with the given id, or clears the active text
+     * track when called with null. No-op when the current track does not
+     * surface text tracks or the id is unknown.
+     */
+    setActiveTextTrack(id: string | null): void;
+    private emitTextTrackChangeEventsFor;
+    get currentTrackAds(): (TrackAds | null);
+    get currentAdBreak(): (AdBreakInfo | null);
+    get currentAd(): (AdInfo | null);
+    /**
+     * Skips the currently playing ad. If there are more ads in the break,
+     * the next ad begins; otherwise the break ends and content resumes.
+     * No-op when no ad break is active.
+     */
+    skipAd(): void;
+    /**
+     * Skips the entire active ad break, advancing past all remaining ads
+     * and resuming content playback.
+     * No-op when no ad break is active.
+     */
+    skipAdBreak(): void;
     get disposed(): boolean;
     /**
      * Disposes this player and sub-systems.