@amazon/vinyl 1.1.1 → 2.0.0

package/dist/types/ts4.1/track/TrackBase.d.ts

@@ -1,11 +1,13 @@
-import type { ObjectSchema } from '@amazon/vinyl-validation';
 import type { Maybe, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
 import { EventHostImpl } from '@amazon/vinyl-util';
 import type { PlaybackController } from '../playback/PlaybackController';
 import type { Track, TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from './Track';
+import type { SeekRange } from './SeekRange';
 import type { DrmController } from '../drm/DrmController';
 import type { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
-import type { DrmOptions } from '../drm/DrmOptions';
+import type { TextTrackController } from '../text/TextTrack';
+import type { TrackAds } from '../ad/AdBreakInfo';
+import type { TrackConfigOptions } from './TrackFactory';
 /**
  * Dependencies for TrackBase.
  */
@@ -19,29 +21,10 @@ export interface TrackBaseDeps {
      */
     readonly drmController: DrmController;
 }
-/**
- * General configuration for tracks set in track load options.
- */
-export interface TrackBaseOptions {
-    /**
-     * The time to seek to when the track has been activated.
-     * For MSE tracks this will affect pre-fetching.
-     */
-    readonly startTime?: Maybe<number>;
-    /**
-     * Extra application data to associate with the track.
-     */
-    readonly extra?: any;
-    /**
-     * DRM Configuration overrides for this track.
-     */
-    readonly drm?: Partial<DrmOptions>;
-}
-export declare const trackBaseOptionsValidator: ObjectSchema<TrackBaseOptions>;
 /**
  * A base class for all tracks.
  */
-export declare abstract class TrackBase<EventMap extends TrackEventMap = TrackEventMap, LoadOptionsType extends TrackBaseOptions = TrackBaseOptions> extends EventHostImpl<EventMap> implements Track<LoadOptionsType> {
+export declare abstract class TrackBase<EventMap extends TrackEventMap = TrackEventMap, ConfigType extends TrackConfigOptions = TrackConfigOptions> extends EventHostImpl<EventMap> implements Track<ConfigType> {
     /**
      * The identifier of this track, used as the key in the track cache.
      */
@@ -55,11 +38,13 @@ export declare abstract class TrackBase<EventMap extends TrackEventMap = TrackEv
     /**
      * The current load options, if this is an active track.
      */
-    protected loadOptions: LoadOptionsType | null;
+    protected loadOptions: Maybe<ConfigType>;
     protected readonly errorHandler: (error: any) => void;
     protected readonly disposer: import("@amazon/vinyl-util").Disposer;
     protected drmSessionAbort: import("@amazon/vinyl-util").AbortSlot;
     get fetchedRanges(): ReadonlyRanges;
+    get textTrackController(): (TextTrackController | null);
+    get seekRange(): (SeekRange | null);
     abstract get contentTypes(): ReadonlySet<ContentType>;
     abstract get qualities(): (readonly MediaQualityMetadata[] | null);
     abstract get qualitiesUnfiltered(): (readonly MediaQualityMetadata[] | null);
@@ -71,6 +56,7 @@ export declare abstract class TrackBase<EventMap extends TrackEventMap = TrackEv
      */
     protected _error: Error | null;
     private _active;
+    private _seekRange;
     protected constructor(
     /**
      * The identifier of this track, used as the key in the track cache.
@@ -80,31 +66,37 @@ export declare abstract class TrackBase<EventMap extends TrackEventMap = TrackEv
      * The track type.
      */
     type: TrackTypeId, deps: TrackBaseDeps);
+    toString(): string;
     get error(): (Error | null);
-    preload(_trackOptions: TrackPreloadOptions, _loadOptions: LoadOptionsType): void;
+    preload(_trackOptions: TrackPreloadOptions, _loadOptions: Maybe<ConfigType>): void;
     get extra(): any;
     get active(): boolean;
     get disposed(): boolean;
-    activate(loadOptions: LoadOptionsType): void;
+    activate(loadOptions: Maybe<ConfigType>): void;
     /**
      * The track has been activated.
      * Operations on shared resources such as the playback controller may only be done while the
      * track is currently active. For example if there is a loading operation before the
      * playback source is set, isActive must be checked before the property is changed.
      */
-    abstract onActivated(loadOptions: LoadOptionsType): void;
+    abstract onActivated(loadOptions: Maybe<ConfigType>): void;
     deactivate(): void;
     abstract onDeactivated(): void;
-    toString(): string;
-    protected closeDrmSessions(): void;
     abstract clearPrefetch(): void;
+    protected closeDrmSessions(): void;
+    /**
+     * Resolves to this track's ads.
+     * Implementations may override to provide ad breaks.
+     */
+    getAds(): Promise<TrackAds>;
+    protected setSeekRange(value: SeekRange): void;
     /**
      * Resets the track to recover from error states.
      * Base implementation does nothing.
      *
      * Overrides should dispatch 'reset' after resetting error state.
      */
-    reset(): void;
+    reset(hard?: boolean): void;
     dispose(): void;
 }
 //# sourceMappingURL=TrackBase.d.ts.map

package/dist/types/ts4.1/track/TrackController.d.ts

@@ -1,48 +1,70 @@
 import type { AnyRecord, Disposable, Maybe, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { EventHostImpl } from '@amazon/vinyl-util';
 import type { PlaybackController } from '../playback/PlaybackController';
-import type { ReadonlyTrack, TrackUri } from '../track/Track';
-import type { TrackFactory, TrackLoadOptions } from '../track/TrackFactory';
+import type { ReadonlyTrack, TrackUri } from './Track';
+import type { TrackFactory, TrackLoadOptions } from './TrackFactory';
 import type { ChangeEvent } from '../event/ChangeEvent';
+import type { AdController } from '../ad/AdController';
+import type { AdInfo } from '../ad/AdBreakInfo';
 export interface TrackControllerEventMap<TrackLoadOptionsType extends TrackLoadOptions> {
     /**
-     * Emitted when the current track is changing.
-     * This is emitted before the previous track has been deactivated and
-     * new track has been activated.
+     * A track became active. For content this may be deferred behind a preroll;
+     * for an ad it fires as the ad activates. {@link queueChange} precedes it.
      */
-    readonly currentTrackChanging: ChangeEvent<ReadonlyTrack | null>;
+    readonly trackActivated: TrackLifecycleEvent;
     /**
-     * Emitted when the current track has changed.
-     * If there is a queue change, the currentTrackChange event is always emitted first.
-     * This is emitted after the previous track has been deactivated and
-     * new track has been activated.
+     * A previously-active track was torn down (superseded or unloaded).
      */
-    readonly currentTrackChange: ChangeEvent<ReadonlyTrack | null>;
+    readonly trackDeactivated: TrackLifecycleEvent;
     /**
      * Dispatched when the queue has changed.
+     *
+     * Will be emitted before {@link trackActivated}.
      */
     readonly queueChange: ChangeEvent<readonly TrackLoadOptionsType[]>;
     /**
-     * Emitted when the last track of the playback queue has ended.
-     * When the last track in a queue has ended, the track will not change and therefore a `currentTrackChange`
-     * event will not be emitted.
+     * Emitted when the current track — including any postroll ads — has finished
+     * playing. Fires once per track: as the queue advances it precedes the
+     * resulting {@link trackActivated}, and for the final track it precedes
+     * `queueEnded`. Distinct from the media element's `ended` (which also fires
+     * for each ad) and from an individual ad's `adEnded`, so applications can act
+     * on true track completion (e.g. logging a play) without confusing it with
+     * an ad ending or the content ending before its postroll plays.
+     */
+    readonly trackEnded: TrackEndedEvent;
+    /**
+     * Emitted when the last track of the playback queue (and any of its
+     * postroll ads) have ended.
      */
     readonly queueEnded: AnyRecord;
 }
 export declare const ALL_TRACK_CONTROLLER_EVENTS: readonly [
-    "currentTrackChanging",
-    "currentTrackChange",
+    "trackActivated",
+    "trackDeactivated",
     "queueChange",
+    "trackEnded",
     "queueEnded"
 ];
+/** Payload for {@link trackActivated} / {@link trackDeactivated}. */
+export interface TrackLifecycleEvent {
+    readonly track: ReadonlyTrack;
+}
+/**
+ * Payload for the {@link TrackControllerEventMap.trackEnded} event: the load
+ * options of the track that finished playing (including any postroll ads).
+ */
+export interface TrackEndedEvent {
+    readonly track: TrackLoadOptions;
+}
 /**
  * A readonly interface to the track controller.
  */
 export interface ReadonlyTrackController<TrackLoadOptionsType extends TrackLoadOptions> extends ReadonlyEventHost<TrackControllerEventMap<TrackLoadOptionsType>> {
     /**
-     * Returns the current track.
+     * The active track, or null when the selected track has not yet activated
+     * (e.g. behind a preroll) or nothing is loaded.
      */
-    readonly currentTrack: ReadonlyTrack | null;
+    readonly activeTrack: ReadonlyTrack | null;
     /**
      * Returns the current queue of TrackLoadOptions.
      * Observe 'queueChange' for changes to this queue.
@@ -125,7 +147,7 @@ export interface TrackController<TrackLoadOptionsType extends TrackLoadOptions>
      */
     clearPrefetch(): void;
     /**
-     * Clears the track cache and unloads the current track.
+     * Clears the track cache, unloads the current track, and clears the queue.
      */
     clearTrackCache(): void;
     /**
@@ -135,25 +157,25 @@ export interface TrackController<TrackLoadOptionsType extends TrackLoadOptions>
     clearQueue(): void;
     /**
      * Resets the current track's error state.
+     *
+     * @param hard If true, the track will reset the playback state and
+     * recreate media sources.
      */
-    reset(): void;
+    reset(hard?: boolean): void;
 }
 export interface TrackControllerImplDeps<TrackLoadOptionsType extends TrackLoadOptions> {
     readonly trackFactory: TrackFactory<TrackLoadOptionsType>;
     readonly playbackController: PlaybackController;
+    readonly adController: AdController;
+    readonly adTrackLoadOptionsProvider: AdTrackLoadOptionsProvider<TrackLoadOptionsType>;
 }
+export type AdTrackLoadOptionsProvider<TrackLoadOptionsType extends TrackLoadOptions> = (adInfo: AdInfo) => Promise<TrackLoadOptionsType>;
 export interface TrackControllerImplOptions {
     /**
      * When tracks are queued, the number of tracks to prefetch ahead of the current track.
      * Default: 2
      */
     readonly trackPrefetchCount: number;
-    /**
-     * The number of seconds before load calls will time out if the first track's metadata is not loaded within
-     * this time.
-     * Default: 60
-     */
-    readonly loadTimeout: number;
     /**
      * The number of tracks that may be preloaded at one time (not counting queue prefetch).
      * This extends the track cache capacity and allows a certain number of tracks no longer in the queue to remain
@@ -176,13 +198,21 @@ export declare class TrackControllerImpl<TrackLoadOptionsType extends TrackLoadO
     get [Symbol.toStringTag](): string;
     private _autoPreloadCapacity;
     private readonly trackCache;
+    private queueIdx;
     private _queue;
     private _current;
+    private _currentTrack;
+    private adParent;
+    private currentTrackSub;
+    private readonly adTracksByParent;
     private readonly disposer;
     private _options;
-    private trackEndedTimeoutId;
     constructor(deps: TrackControllerImplDeps<TrackLoadOptionsType>, initialOptions?: Partial<TrackControllerImplOptions>);
-    private clearTrackEndedTimeout;
+    private initializeAdHandling;
+    /**
+     * The current track has ended naturally. On the next tick advance the queue or emit queue ended.
+     */
+    private onEnded;
     get options(): TrackControllerImplOptions;
     /**
      * Configures this track queue from the provided partial options.
@@ -199,7 +229,7 @@ export declare class TrackControllerImpl<TrackLoadOptionsType extends TrackLoadO
      * Returns the subset of the queue that should be prefetched.
      * @private
      */
-    private get prefetched();
+    private getPrefetched;
     isTrackCached(uri: TrackUri): boolean;
     getCachedTrack(uri: TrackUri): ReadonlyTrack | null;
     getCachedTracks(): IterableIterator<ReadonlyTrack>;
@@ -207,6 +237,16 @@ export declare class TrackControllerImpl<TrackLoadOptionsType extends TrackLoadO
     private validateLoadOptions;
     preload(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
     private _preload;
+    private preloadPrerollAds;
+    /**
+     * Warms the ad tracks for an approaching midroll/postroll break (driven by
+     * the ad controller's `adPreload`). Best-effort: an ad-list or ad-options
+     * failure is logged, not thrown. The break is imminent, so its ad tracks
+     * get a prefetch priority above the current content prefetch window.
+     */
+    private preloadBreakAds;
+    /** Preloads an ad for a parent track. Aborts if the parent track is disposed before the ad load options resolve. **/
+    private preloadAd;
     load(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
     unload(): void;
     enqueue(...loadOptionsList: readonly TrackLoadOptionsType[]): void;
@@ -219,25 +259,50 @@ export declare class TrackControllerImpl<TrackLoadOptionsType extends TrackLoadO
      * If the given track id is the current track or in the cache, returns that track.
      * Otherwise, constructs a new track, adds it to the cache, and returns it.
      *
-     * @param uri The unique resource identifier.
      * @param loadOptions
      * @private
      */
     private getOrCreateTrack;
     /**
-     * Get the current track from cache or create a new track, then activates that track.
+     * Gets the cached ad track, or creates a new one and sets it in the
+     * parent track mapping.
+     * When the parent track is disposed, this ad track will be as well.
+     *
+     * @param parentUri The URI of the parent track.
+     * @param loadOptions
+     * @private
      */
-    private activateCurrent;
-    private _currentTrack;
-    get currentTrack(): (ReadonlyTrack | null);
+    private getOrCreateAdTrack;
+    /**
+     * Sets the current track and following queue.
+     *
+     * If the given track is already current, it will be de-activated and re-activated and the
+     * trackDeactivated/trackActivated events will still be emitted. The same track may be in the
+     * queue multiple times.
+     */
+    private setQueue;
+    private get currentTrackIsAdTrack();
     /**
-     * Sets the current track. If the given track is already current, it will be de-activated and re-activated and
-     * the currentTrackChange event will still be emitted.
-     * The same track may be in the queue multiple times.
+     * Sets the active track.
+     * This may either be a content track created from `setQueue` or an ad track created from `adEntered`.
+     *
+     * @param newTrack
+     * @param options
+     * @private
      */
     private setCurrentTrack;
-    private clearCurrentTrack;
-    reset(): void;
+    /**
+     * Disposes all preloaded ad tracks belonging to the given parent content
+     * URI and drops the parent's entry from the ad map.
+     */
+    private disposeAdTracksFor;
+    /**
+     * Returns a callback that returns true if the queue has changed or the controller disposed.
+     */
+    private getQueueInterrupted;
+    get activeTrack(): (ReadonlyTrack | null);
+    reset(hard?: boolean): void;
+    get disposed(): boolean;
     dispose(): void;
 }
 //# sourceMappingURL=TrackController.d.ts.map

package/dist/types/ts4.1/track/TrackFactory.d.ts

@@ -1,6 +1,7 @@
-import type { AnyRecord, Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
+import type { Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
 import type { ObjectSchema } from '@amazon/vinyl-validation';
-import type { Track, TrackTypeId, TrackUri } from '../track/Track';
+import type { Track, TrackTypeId, TrackUri } from './Track';
+import type { DrmOptions } from '../drm/DrmOptions';
 export interface TrackLoadOptions {
     /**
      * The track type, used to map to a track factory.
@@ -13,8 +14,27 @@ export interface TrackLoadOptions {
     /**
      * The track configuration.
      */
-    readonly config?: Maybe<AnyRecord>;
+    readonly config?: Maybe<TrackConfigOptions>;
 }
+/**
+ * General configuration for tracks set in track load options.
+ */
+export interface TrackConfigOptions {
+    /**
+     * The time to seek to when the track has been activated.
+     * For MSE tracks this will affect pre-fetching.
+     */
+    readonly startTime?: Maybe<number>;
+    /**
+     * Extra application data to associate with the track.
+     */
+    readonly extra?: any;
+    /**
+     * DRM Configuration overrides for this track.
+     */
+    readonly drm?: Partial<DrmOptions>;
+}
+export declare const trackConfigOptionsValidator: ObjectSchema<TrackConfigOptions>;
 export declare const trackLoadOptionsValidator: ObjectSchema<TrackLoadOptions>;
 /**
  * Produces a new Track for the given configuration options.

package/dist/types/ts4.1/track/createVinylTrackFactories.d.ts

@@ -1,8 +1,8 @@
-import type { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from '../track/source/SourceObjectTrack';
-import type { SourceTrackDeps, SourceTrackLoadOptions } from '../track/source/SourceTrack';
-import type { TrackFactory } from '../track/TrackFactory';
-import type { DashTrackFactoryDeps, DashTrackLoadOptions } from '../track/dash/DashTrack';
-import type { HlsTrackFactoryDeps, HlsTrackLoadOptions } from '../track/hls/HlsTrack';
+import type { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from './source/SourceObjectTrack';
+import type { SourceTrackDeps, SourceTrackLoadOptions } from './source/SourceTrack';
+import type { TrackFactory } from './TrackFactory';
+import type { DashTrackFactoryDeps, DashTrackLoadOptions } from './dash/DashTrack';
+import type { HlsTrackFactoryDeps, HlsTrackLoadOptions } from './hls/HlsTrack';
 export interface VinylTrackFactoryDeps extends SourceTrackDeps, SourceObjectTrackDeps, DashTrackFactoryDeps, HlsTrackFactoryDeps {
 }
 export type VinylTrackLoadOptions = SourceObjectTrackLoadOptions | SourceTrackLoadOptions | DashTrackLoadOptions | HlsTrackLoadOptions;

package/dist/types/ts4.1/track/dash/DashManifestController.d.ts

@@ -1,39 +1,4 @@
-import type { DashManifestData, DashManifestProvider } from '../../track/dash/DashManifestProvider';
 import type { ManifestController } from '../../streaming/ManifestController';
+import type { DashManifestData } from './DashManifestProvider';
 export type DashManifestController = ManifestController<Promise<DashManifestData>>;
-export interface DashManifestControllerImplDeps {
-    /**
-     * Resolves the untransformed manifest.
-     */
-    readonly manifestProvider: DashManifestProvider;
-}
-export declare class DashManifestControllerImpl implements DashManifestController {
-    readonly deps: DashManifestControllerImplDeps;
-    get [Symbol.toStringTag](): string;
-    get logPrefix(): string;
-    private readonly _data;
-    private _error;
-    private readonly abortSlot;
-    private readonly disposer;
-    constructor(deps: DashManifestControllerImplDeps);
-    get error(): (Error | null);
-    /**
-     * Reloads the manifest. Aborts any in-flight request and clears any
-     * previous error before starting a new fetch.
-     */
-    refresh(): void;
-    /**
-     * If the manifest is in an error state, triggers a refresh.
-     */
-    reset(): void;
-    get value(): Promise<DashManifestData>;
-    get changeId(): number;
-    getValue(): Promise<DashManifestData>;
-    onData(callback: (value: Promise<DashManifestData>, previous: Promise<DashManifestData> | undefined) => void): import("@amazon/vinyl-util").Unsubscribe;
-    map<U>(transform: (value: Promise<DashManifestData>) => U): import("@amazon/vinyl-observable").MutableValue<U>;
-    pick<K extends keyof NonNullable<Promise<DashManifestData>>>(prop: K): import("@amazon/vinyl-observable").MutableValue<Promise<DashManifestData>[K]>;
-    private abort;
-    get disposed(): boolean;
-    dispose(): void;
-}
 //# sourceMappingURL=DashManifestController.d.ts.map

package/dist/types/ts4.1/track/dash/DashTrack.d.ts

@@ -1,13 +1,12 @@
-import type { TrackBaseOptions } from '../../track/TrackBase';
-import type { DashManifestProvider, DashManifestData } from './DashManifestProvider';
-import type { DashManifestController } from './DashManifestController';
-import type { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import type { DashManifestData, DashManifestProvider } from './DashManifestProvider';
+import type { TrackConfigOptions, TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
 import type { Factories } from '@amazon/vinyl-di';
-import type { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
-import type { MseTrackDeps } from '../../track/mse/MseTrack';
+import type { DashMediaQualityMetadataResolver } from './DashMediaQualityMetadataResolver';
+import type { MseTrackDeps } from '../mse/MseTrack';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import type { DashManifestController } from './DashManifestController';
 export interface DashTrackLoadOptions extends TrackLoadOptions {
     readonly type: 'dash';
     /**
@@ -30,7 +29,7 @@ export interface DashTrackLoadOptions extends TrackLoadOptions {
      * Configuration options for the DashTrack.
      * Will be set before the track is activated.
      */
-    readonly config?: Maybe<TrackBaseOptions>;
+    readonly config?: Maybe<TrackConfigOptions>;
 }
 export type DashTrackFactoryDeps = {
     readonly createDashFactories: (loadOptions: DashTrackLoadOptions) => Factories<DashTrackDeps>;

package/dist/types/ts4.1/track/dash/buildDashMediaTimeline.d.ts

@@ -1,6 +1,6 @@
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
-import type { DashSegmentProviderDeps } from '../../track/dash/timeline/DashRepresentationSegmentProvider';
+import type { DashSegmentProviderDeps } from './timeline/DashRepresentationSegmentProvider';
 export type BuildDashMediaTimelineDeps = DashSegmentProviderDeps;
 /**
  * Builds a MediaTimeline from a Dash manifest.

package/dist/types/ts4.1/track/dash/createDashContentTypesValue.d.ts

@@ -1,5 +1,5 @@
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
-import type { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import type { DashManifestData } from './DashManifestProvider';
+import type { DashMediaQualityMetadataResolver } from './DashMediaQualityMetadataResolver';
 import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 export interface DashContentTypesValueDeps {

package/dist/types/ts4.1/track/dash/createDashFactories.d.ts

@@ -1,40 +1,50 @@
-import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { DashTrackLoadOptions } from './DashTrack';
 import type { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
-import { createDefaultDashManifestTransformer } from '../../track/dash/createDefaultDashManifestTransformer';
+import { createDefaultDashManifestTransformer } from './createDefaultDashManifestTransformer';
 import { createMediaSource } from '../../util/media/mediaSource';
-import type { DashMediaQualityMetadataResolverDeps } from '../../track/dash/DashMediaQualityMetadataResolver';
+import type { DashMediaQualityMetadataResolverDeps } from './DashMediaQualityMetadataResolver';
 import type { MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
 import { MediaSourceControllerImpl } from '../../streaming/buffering/MediaSourceController';
 import type { PlaybackController } from '../../playback/PlaybackController';
-import type { DashManifestController, DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
 import type { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import type { DrmController } from '../../drm/DrmController';
 import type { Capabilities } from '../../client/Capabilities';
-import type { QualitySelectorImplOptions } from '../../streaming/abr/QualitySelectorImpl';
 import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
 import type { PlaybackSource } from '../../playback/PlaybackSource';
 import { createContentStreamFactory } from '../../streaming/ContentStream';
 import type { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
-import { createDashContentTypesValue } from '../../track/dash/createDashContentTypesValue';
+import { createDashContentTypesValue } from './createDashContentTypesValue';
+import { createAllowedContentTypesValue } from '../../streaming/createAllowedContentTypesValue';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { VinylOptions } from '../../vinyl/VinylOptions';
-import type { BuildDashMediaTimelineDeps } from '../../track/dash/buildDashMediaTimeline';
+import type { BuildDashMediaTimelineDeps } from './buildDashMediaTimeline';
 import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
+import { SidecarTextTrackController } from '../../text/SidecarTextTrackController';
+import type { AdController } from '../../ad/AdController';
+import type { ManifestControllerImplDeps } from '../../streaming/ManifestControllerImpl';
+import { ManifestControllerImpl } from '../../streaming/ManifestControllerImpl';
 /**
  * Player-level dependencies needed for the Dash-specific factories.
  */
 export interface DashFactoryDeps {
-    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 DashInitOptions = {
     readonly streaming?: Maybe<ContentStreamingOptions>;
@@ -44,21 +54,22 @@ export type DashInitOptions = {
  * a new DashTrack.
  */
 export declare function createDashFactories(options: Maybe<DashInitOptions>): (deps: DashFactoryDeps) => (loadOptions: DashTrackLoadOptions) => {
-    contentTypesValue: typeof createDashContentTypesValue;
-    baseUrlSelector: () => import("../../track/dash/util/uriResolution").BaseUrlSelector;
+    baseContentTypesValue: typeof createDashContentTypesValue;
+    contentTypesValue: typeof createAllowedContentTypesValue;
+    baseUrlSelector: () => import("./util/uriResolution").BaseUrlSelector;
     segmentRequestInit: () => Maybe<Readonly<Omit<RequestInit, "signal">>>;
     manifestProvider: (deps: {
         readonly requestInterceptor: RequestInterceptor;
-    }) => import("../../track/dash/DashManifestProvider").DashManifestProvider;
-    manifestController: (deps: DashManifestControllerImplDeps) => DashManifestController;
+    }) => import("./DashManifestProvider").DashManifestProvider;
+    manifestController: (deps: ManifestControllerImplDeps<DashManifestData>) => ManifestControllerImpl<DashManifestData>;
     mediaSourceFactory: () => typeof createMediaSource;
-    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("../../track/dash/DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
+    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("./DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
     mediaSourceController: (deps: MediaSourceControllerImplDeps) => MediaSourceControllerImpl;
-    createContentStreamFactories: (deps: import("../../track/dash/createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
+    createContentStreamFactories: (deps: import("./createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
         sourceBufferControllerFactory: (deps: import("../..").SourceBufferControllerImplDeps) => () => import("../..").SourceBufferControllerImpl;
         bufferingController: (deps: import("../..").BufferingControllerImplDeps) => import("../..").BufferingControllerImpl;
         segmentController: (deps: import("../..").SegmentControllerImplDeps) => import("../..").SegmentControllerImpl;
-        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../../streaming/buffering/MediaSourceController").MediaSourceController>;
+        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../..").MediaSourceController>;
         playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
         mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("../..").MediaTimeline>>>;
         qualitySelector: import("@amazon/vinyl-di").Factory<import("../..").QualitySelector>;
@@ -67,20 +78,36 @@ export declare function createDashFactories(options: Maybe<DashInitOptions>): (d
     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>;
     manifestTransformed: typeof createDefaultDashManifestTransformer;
     mediaTimeline: (deps: BuildDashMediaTimelineDeps & {
         readonly manifestTransformed: ObservableValue<Promise<DashManifestData>>;
     }) => 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<DashManifestData>>;
+        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=createDashFactories.d.ts.map

package/dist/types/ts4.1/track/dash/createDashManifestProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { DashTrackLoadOptions } from './DashTrack';
 import type { RequestInterceptor } from '@amazon/vinyl-util';
 /**
  * Creates a DashManifestProvider which uses the manifestProvider set on the loadOptions, or a urlDashManifestProvider