@amazon/vinyl 1.1.1 → 2.0.0

package/dist/types/ts4.1/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/ts4.1/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/ts4.1/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/ts4.1/vinyl/ReadonlyPlaybackStreamingState.d.ts

@@ -1,5 +1,7 @@
 import type { ReadonlyEventHost } from '@amazon/vinyl-util';
-import type { TrackEventMap, ReadonlyStreamingState } from '../track/Track';
+import type { ReadonlyStreamingState } from '../track/Track';
+import type { SeekRange } from '../track/SeekRange';
+import type { StreamingEventMap } from '../streaming/StreamingEventMap';
 /**
  * Represents the streaming state of the currently active track.
  *
@@ -15,7 +17,7 @@ import type { 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/ts4.1/vinyl/VinylDeps.d.ts

@@ -7,7 +7,8 @@ import type { TrackLoadOptions } from '../track/TrackFactory';
 import type { DrmController } from '../drm/DrmController';
 import type { AutoResetController } from '../track/AutoResetController';
 import type { MutableValue } from '@amazon/vinyl-observable';
-import type { VinylOptions } from '../vinyl/VinylOptions';
+import type { VinylOptions } from './VinylOptions';
+import type { 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/ts4.1/vinyl/VinylOptions.d.ts

@@ -1,6 +1,9 @@
 import type { QualitySelectorImplOptions } from '../streaming/abr/QualitySelectorImpl';
 import type { ObjectSchema } from '@amazon/vinyl-validation';
+import type { CodecOverrides } from '../util/media/codecOverrides';
+import type { RestrictableContentType } from '../streaming/MediaQualityMetadata';
 import type { LoudnessNormalizationControllerImplOptions } from '../playback/loudness/LoudnessNormalizationControllerImplOptions';
+import type { 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/ts4.1/vinyl/VinylPlayer.d.ts

@@ -6,20 +6,39 @@ import type { PlaybackController } from '../playback/PlaybackController';
 import type { PlaybackControllerEventMap, PlaybackNetworkState, PlaybackReadyState } from '../playback/ReadonlyPlaybackController';
 import type { VinylTrackLoadOptions } from '../track/createVinylTrackFactories';
 import type { ReadonlyTrack, TrackUri } from '../track/Track';
+import type { SeekRange } from '../track/SeekRange';
 import type { TrackController, TrackControllerEventMap } from '../track/TrackController';
 import type { InferLoadOptionsFromFactory, TrackLoadOptions } from '../track/TrackFactory';
 import type { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDependencyOptions } from './createVinylFactories';
 import type { VinylDeps } from './VinylDeps';
 import type { Capabilities } from '../client/Capabilities';
 import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
-import type { ReadonlyPlaybackStreamingState } from '../vinyl/ReadonlyPlaybackStreamingState';
+import type { ReadonlyPlaybackStreamingState } from './ReadonlyPlaybackStreamingState';
 import type { StreamingEventMap } from '../streaming/StreamingEventMap';
+import type { LoadMetricEventMap } from '../streaming/LoadMetric';
 import type { InferObservableValueType } from '@amazon/vinyl-observable';
-import type { VinylOptions } from '../vinyl/VinylOptions';
+import type { VinylOptions } from './VinylOptions';
+import type { ChangeEvent } from '../event/ChangeEvent';
+import type { TextTrackEventMap, TextTrackInfo } from '../text/TextTrack';
+import type { AdEventMap } from '../ad/AdController';
+import type { 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.
+     *
+     * `current` is true when the player has hit a transient, potentially
+     * recoverable error (e.g. a network outage) and an automatic reset
+     * attempt is scheduled. `current` is false once the pending reset is
+     * emitted, the error is cleared, or all retries are exhausted.
+     *
+     * If `resetPending` becomes false while {@link VinylPlayer.error} is
+     * still non-null, all automatic reset attempts have been exhausted
+     * and playback will not recover without user action.
+     */
+    readonly resetPendingChange: ChangeEvent<boolean>;
 }
 /**
  * A Vinyl Media Player.
@@ -33,6 +52,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     private get drmController();
     private get playbackController();
     private get trackController();
+    private get autoResetController();
     /**
      * Provides information about the client, such as device and browser capabilities.
      */
@@ -53,7 +73,6 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
      */
     protected redispatchCurrentTrackEvents(): void;
     private initializeAutoResetHandling;
-    private initializePreferredLanguageHandling;
     get options(): OptionsType;
     /**
      * Sets options on this player.
@@ -75,6 +94,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     get duration(): number;
     get ended(): boolean;
     get error(): (Error | null);
+    get resetPending(): boolean;
     get hasMetadata(): boolean;
     get loop(): boolean;
     set loop(value: boolean);
@@ -90,6 +110,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);
@@ -97,8 +118,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;
@@ -134,6 +155,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.

package/dist/types/ts4.1/vinyl/createVinylFactories.d.ts

@@ -11,6 +11,8 @@ import type { TrackControllerImplDeps, TrackControllerImplOptions } from '../tra
 import { TrackControllerImpl } from '../track/TrackController';
 import type { VinylPatchOptions } from './VinylPatchOptions';
 import type { QualitySelectorImplOptions } from '../streaming/abr/QualitySelectorImpl';
+import type { AdControllerImplDeps, AdControllerImplOptions } from '../ad/AdControllerImpl';
+import { AdControllerImpl } from '../ad/AdControllerImpl';
 import type { DrmOptions } from '../drm/DrmOptions';
 import { commonEmeFactory } from '../drm/commonEme/CommonEmeFactory';
 import type { DrmControllerImplDeps } from '../drm/DrmControllerImpl';
@@ -20,8 +22,9 @@ import type { AutoResetControllerImplDeps, AutoResetControllerImplOptions } from
 import { AutoResetControllerImpl } from '../track/AutoResetController';
 import type { Dependencies, Factories } from '@amazon/vinyl-di';
 import type { ContentStreamingOptions } from '../streaming/ContentStreamingOptions';
-import type { VinylOptions } from '../vinyl/VinylOptions';
+import type { VinylOptions } from './VinylOptions';
 import type { ObservableValue } from '@amazon/vinyl-observable';
+import { defaultAdLoadOptionsResolver } from '../ad/defaultAdLoadOptionsResolver';
 /**
  * Configuration used by the default dependency factories for Vinyl.
  *
@@ -62,6 +65,10 @@ export interface VinylDependencyOptions {
      * Configuration for auto-reset behavior.
      */
     readonly autoReset?: Partial<AutoResetControllerImplOptions>;
+    /**
+     * Configuration for the ad controller.
+     */
+    readonly adController?: Partial<AdControllerImplOptions>;
 }
 /**
  * Creates the dependency factories for a standard player.
@@ -83,22 +90,23 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
     }) => LoudnessNormalizationControllerImpl;
     capabilities: (deps: CapabilitiesImplDeps) => CapabilitiesImpl;
     requestInterceptor: () => typeof noop;
-    trackFactory: (deps: VinylTrackFactoryDeps) => import("../track/TrackFactory").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
+    trackFactory: (deps: VinylTrackFactoryDeps) => import("..").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
+    adTrackLoadOptionsProvider: () => typeof defaultAdLoadOptionsResolver;
     trackController: (deps: TrackControllerImplDeps<any>) => TrackControllerImpl<any>;
-    drmKeySystemResolver: () => import("../drm/DrmKeySystemResolver").DrmKeySystemResolver;
+    drmKeySystemResolver: () => import("..").DrmKeySystemResolver;
     drmController: (deps: DrmControllerImplDeps) => DrmControllerImpl;
     commonEme: typeof commonEmeFactory;
     autoResetController: (deps: AutoResetControllerImplDeps) => AutoResetControllerImpl;
-    createDashFactories: (deps: import("../track/dash/createDashFactories").DashFactoryDeps) => (/**
-     * Configuration for segmented streaming tracks (hls / dash).
-     */ loadOptions: import("..").DashTrackLoadOptions) => {
-        contentTypesValue: typeof import("..").createDashContentTypesValue;
+    adController: (deps: AdControllerImplDeps) => AdControllerImpl;
+    createDashFactories: (deps: import("..").DashFactoryDeps) => (loadOptions: import("..").DashTrackLoadOptions) => {
+        baseContentTypesValue: typeof import("..").createDashContentTypesValue;
+        contentTypesValue: typeof import("..").createAllowedContentTypesValue;
         baseUrlSelector: () => import("..").BaseUrlSelector;
         segmentRequestInit: () => import("@amazon/vinyl-util").Maybe<Readonly<Omit<RequestInit, "signal">>>;
         manifestProvider: (deps: {
             readonly requestInterceptor: import("@amazon/vinyl-util").RequestInterceptor;
         }) => import("..").DashManifestProvider;
-        manifestController: (deps: import("..").DashManifestControllerImplDeps) => import("..").DashManifestController;
+        manifestController: (deps: import("..").ManifestControllerImplDeps<import("..").DashManifestData>) => import("..").ManifestControllerImpl<import("..").DashManifestData>;
         mediaSourceFactory: () => typeof import("..").createMediaSource;
         mediaQualityMetadataResolver: (deps: import("..").DashMediaQualityMetadataResolverDeps) => import("..").DashMediaQualityMetadataResolver;
         mediaSourceController: (deps: import("..").MediaSourceControllerImplDeps) => import("..").MediaSourceControllerImpl;
@@ -114,26 +122,44 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         contentStreamFactory: typeof import("..").createContentStreamFactory;
         qualitySelector: (deps: {
             options: ObservableValue<Pick<VinylOptions, "abr">>;
-        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        }) => import("..").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<QualitySelectorImplOptions>;
         manifestTransformed: typeof import("..").createDefaultDashManifestTransformer;
         mediaTimeline: (deps: import("..").BuildDashMediaTimelineDeps & {
             readonly manifestTransformed: ObservableValue<Promise<import("..").DashManifestData>>;
         }) => ObservableValue<Promise<import("..").MediaTimeline>>;
         mediaTimelineTransformed: typeof import("..").createDefaultMediaTimelineTransformer;
-        options: import("@amazon/vinyl-di").Factory<ObservableValue<{
-            readonly abr: QualitySelectorImplOptions;
-            readonly preferredAudioLanguage: string | null;
-        }>>;
+        textTrackController: (deps: {
+            readonly media: HTMLMediaElement;
+            readonly manifestTransformed: ObservableValue<Promise<import("..").DashManifestData>>;
+            readonly options: ObservableValue<Pick<VinylOptions, "preferredTextLanguage" | "textCueStyle">>;
+        }) => import("..").SidecarTextTrackController;
+        options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "abr" | "preferredAudioLanguage" | "preferredTextLanguage" | "preferDescriptiveAudio" | "allowedContentTypes" | "textCueStyle">>>;
         playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
         playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
-        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("../drm/DrmKeySystemResolver").DrmKeySystemResolver>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").DrmKeySystemResolver>;
         requestInterceptor: import("@amazon/vinyl-di").Factory<import("@amazon/vinyl-util").RequestInterceptor>;
         drmController: import("@amazon/vinyl-di").Factory<import("..").DrmController>;
         capabilities: import("@amazon/vinyl-di").Factory<import("..").Capabilities>;
+        media: import("@amazon/vinyl-di").Factory<HTMLMediaElement>;
+        adController: import("@amazon/vinyl-di").Factory<import("..").AdController>;
     };
-    createHlsFactories: (deps: import("../track/hls/createHlsFactories").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => {
-        contentTypesValue: typeof import("..").createHlsContentTypesValue;
-        manifestController: () => import("..").HlsManifestControllerImpl;
+    createHlsFactories: (deps: import("..").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => {
+        baseContentTypesValue: typeof import("..").createHlsContentTypesValue;
+        contentTypesValue: typeof import("..").createAllowedContentTypesValue;
+        manifestProvider: () => import("..").HlsManifestProvider;
+        manifestController: (deps: import("..").ManifestControllerImplDeps<import("..").HlsManifestData>) => import("..").ManifestControllerImpl<import("..").HlsManifestData>;
         manifestTransformed: typeof import("..").createDefaultHlsManifestTransformer;
         mediaQualityMetadataResolver: () => import("..").HlsMediaQualityMetadataResolver;
         mediaSourceFactory: () => typeof import("..").createMediaSource;
@@ -151,21 +177,37 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         contentStreamFactory: typeof import("..").createContentStreamFactory;
         qualitySelector: (deps: {
             options: ObservableValue<Pick<VinylOptions, "abr">>;
-        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        }) => import("..").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<QualitySelectorImplOptions>;
         mediaTimeline: (deps: import("..").BuildHlsMediaTimelineDeps & {
             readonly manifestTransformed: ObservableValue<Promise<import("..").HlsManifestData>>;
         }) => ObservableValue<Promise<import("..").MediaTimeline>>;
         mediaTimelineTransformed: typeof import("..").createDefaultMediaTimelineTransformer;
-        options: import("@amazon/vinyl-di").Factory<ObservableValue<{
-            readonly abr: QualitySelectorImplOptions;
-            readonly preferredAudioLanguage: string | null;
-        }>>;
+        textTrackController: (deps: {
+            readonly media: HTMLMediaElement;
+            readonly manifestTransformed: ObservableValue<Promise<import("..").HlsManifestData>>;
+            readonly options: ObservableValue<Pick<VinylOptions, "preferredTextLanguage" | "textCueStyle">>;
+        }) => import("..").SidecarTextTrackController;
+        options: import("@amazon/vinyl-di").Factory<ObservableValue<Pick<VinylOptions, "abr" | "preferredAudioLanguage" | "preferredTextLanguage" | "preferDescriptiveAudio" | "allowedContentTypes" | "textCueStyle">>>;
         playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
         playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
-        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("../drm/DrmKeySystemResolver").DrmKeySystemResolver>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").DrmKeySystemResolver>;
         requestInterceptor: import("@amazon/vinyl-di").Factory<import("@amazon/vinyl-util").RequestInterceptor>;
         drmController: import("@amazon/vinyl-di").Factory<import("..").DrmController>;
         capabilities: import("@amazon/vinyl-di").Factory<import("..").Capabilities>;
+        media: import("@amazon/vinyl-di").Factory<HTMLMediaElement>;
+        adController: import("@amazon/vinyl-di").Factory<import("..").AdController>;
     };
 };
 /**

package/dist/types/ts4.7/ad/AdBreakInfo.d.ts

@@ -0,0 +1,160 @@
+import type { TrackUri } from '../track/Track';
+import type { ValueProvider } from '@amazon/vinyl-util';
+export interface TrackAds {
+    /**
+     * The URI of the parent track.
+     */
+    readonly trackUri: TrackUri;
+    /**
+     * An array of the ad breaks for this track.
+     */
+    readonly adBreaks: AdBreakList;
+}
+/**
+ * Where an ad break is scheduled relative to the main content.
+ *
+ *  - `preroll`  - before content playback begins (start time at or near 0).
+ *  - `midroll`  - during content playback.
+ *  - `postroll` - at the end of content playback.
+ */
+export type AdBreakPlacement = 'preroll' | 'midroll' | 'postroll';
+/**
+ * Restrictions on user interaction during an ad break.
+ */
+export interface AdRestriction {
+    /**
+     * When true, the user should not be allowed to skip this ad.
+     *
+     * This is not enforced by the player; the application is expected
+     * to respect this flag when showing ad skip controls.
+     */
+    readonly skip?: boolean;
+    /**
+     * When true, the user should not be allowed to seek past this ad.
+     */
+    readonly jump?: boolean;
+}
+/**
+ * A provider-agnostic description of a single ad break on the media timeline.
+ *
+ * An ad break is a span of the presentation that carries advertising rather
+ * than primary content. The same shape is produced from HLS Interstitials
+ * (EXT-X-DATERANGE with `CLASS="com.apple.hls.interstitial"`) and, in the
+ * future, from DASH SCTE-35 splice signals, so applications observe one
+ * interface regardless of the streaming protocol.
+ *
+ * Times are expressed on the player's media timeline, in seconds, so they can
+ * be compared directly against the media's current time.
+ */
+export interface AdBreakInfo {
+    /**
+     * A stable identifier for this ad break, unique within the current media
+     * presentation. Derived from the source signal (e.g. the HLS DATERANGE ID).
+     */
+    readonly id: string;
+    /**
+     * The start time of the ad break on the media timeline, in seconds.
+     */
+    readonly startTime: number;
+    /**
+     * The duration of the ad break in seconds, or null when unknown (e.g. a
+     * still-open live break that has not yet resolved its end).
+     */
+    readonly duration: number | null;
+    /**
+     * The scheduled placement of the break relative to primary content.
+     */
+    readonly placement: AdBreakPlacement;
+    /**
+     * The individual ad assets that make up this break, in playback order.
+     */
+    readonly ads: ValueProvider<AdList>;
+    /**
+     * Restrictions on user interaction during this ad break.
+     */
+    readonly restrict: AdRestriction;
+    /**
+     * When true, this break plays at most once for the presentation and is not
+     * replayed even if the playhead re-crosses it (e.g. after a seek back). When
+     * false, the break may replay each time the playhead re-enters its region.
+     *
+     * (An HLS interstitial sets this from a `CUE=ONCE` hint.)
+     */
+    readonly once: boolean;
+    /**
+     * The offset, in seconds, from this break's scheduled {@link startTime} at
+     * which primary content resumes after the break. A signed value: 0 resumes
+     * in place (the break is purely additive). `null` means no resume offset was
+     * specified, in which case content resumes advanced by the break's actual
+     * playout duration (i.e. the break replaces that much primary content) —
+     * this is distinct from an explicit 0.
+     *
+     * (An HLS interstitial sets this from `X-RESUME-OFFSET`.)
+     */
+    readonly resumeOffset: number | null;
+    /**
+     * The maximum total playout time of the whole break, in seconds, summed
+     * across all of its ads, or `null` when the break's playout is uncapped.
+     * Distinct from {@link duration} (the break's timeline span) and from an
+     * individual {@link AdInfo.duration}.
+     *
+     * (An HLS interstitial sets this from `X-PLAYOUT-LIMIT`.)
+     */
+    readonly playoutLimit: number | null;
+    /**
+     * How far ahead of this break's {@link startTime}, in seconds, the player
+     * should resolve and preload the break's ad assets so they are ready when
+     * the playhead reaches it. `null` when the source specifies no offset, in
+     * which case the controller falls back to its `preloadAheadTime` option.
+     * Applies to midroll and postroll breaks; prerolls are preloaded up front.
+     *
+     * (An HLS interstitial sets this from `X-RESOLUTION-TIME-OFFSET`.)
+     */
+    readonly resolutionTimeOffset: number | null;
+    /**
+     * The window during which the user may skip this break, or a provider
+     * resolving to `null` when the break carries no skip window (skippability is
+     * then governed by {@link AdRestriction.skip}). Resolved lazily because, like
+     * {@link ads}, it may require fetching the break's asset list.
+     *
+     * (An HLS interstitial sets this from the `X-ASSET-LIST` `SKIP-CONTROL`.)
+     */
+    readonly skipControl: ValueProvider<SkipControl | null>;
+}
+/**
+ * Describes when a user may skip an ad break: skipping becomes available
+ * {@link offset} seconds into the break and remains offered for {@link duration}
+ * seconds (or the rest of the break when null).
+ */
+export interface SkipControl {
+    /** Seconds from the break start at which skipping becomes available. */
+    readonly offset: number;
+    /**
+     * Seconds the skip control remains offered after {@link offset}, or `null`
+     * to offer it for the remainder of the break.
+     */
+    readonly duration: number | null;
+}
+/**
+ * An ad break list, sorted by start time ascendingly.
+ */
+export type AdBreakList = readonly AdBreakInfo[];
+/**
+ * A single ad within an {@link AdBreakInfo}.
+ */
+export interface AdInfo {
+    /** A stable identifier for this ad within its break. */
+    readonly id: string;
+    /** The start time of this ad on the media timeline, in seconds. */
+    readonly startTime: number;
+    /** The duration of this ad in seconds, or null when unknown. */
+    readonly duration: number | null;
+    /**
+     * The URI of the ad asset, when the source signal provides one directly
+     * (e.g. an HLS interstitial `X-ASSET-URI`). Null when the ad is described
+     * only indirectly.
+     */
+    readonly uri: TrackUri | null;
+}
+export type AdList = readonly AdInfo[];
+//# sourceMappingURL=AdBreakInfo.d.ts.map