@amazon/vinyl 1.1.1 → 2.0.0

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

@@ -1,5 +1,5 @@
 import type { ObservableValue } from '@amazon/vinyl-observable';
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
 import type { AdaptationSetType, RepresentationType } from '@amazon/vinyl-mpd-parser';
 import type { Comparator } from '@amazon/vinyl-util';
 export interface DashManifestTransformerDeps {

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

@@ -2,14 +2,9 @@ import type { ReadonlyPlaybackController } from '../../playback/ReadonlyPlayback
 import type { SegmentControllerImplOptions } from '../../streaming/SegmentControllerImpl';
 import { SegmentControllerImpl } from '../../streaming/SegmentControllerImpl';
 import type { ContentType } from '../../streaming/MediaQualityMetadata';
-import type { SegmentController } from '../../streaming/SegmentController';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
 import type { QualitySelector } from '../../streaming/abr/QualitySelector';
-export type SegmentControllerFactory = (deps: {
-    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
-    readonly qualitySelector: QualitySelector;
-}) => SegmentController;
 export interface SegmentControllerFactoryDeps {
     readonly playbackController: ReadonlyPlaybackController;
 }

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

@@ -1,5 +1,5 @@
 import type { AdaptationSetType, DashManifest, RepresentationType } from '@amazon/vinyl-mpd-parser';
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { Comparator, FilterPredicate, MaybePromise } from '@amazon/vinyl-util';
 /**

package/dist/types/ts4.1/track/dash/timeline/DashRepresentationSegmentProvider.d.ts

@@ -1,9 +1,9 @@
 import type { RepresentationType } from '@amazon/vinyl-mpd-parser';
-import type { DashUriResolveDeps } from '../../../track/dash/util/uriResolution';
-import type { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import type { DashUriResolveDeps } from '../util/uriResolution';
+import type { CreateSegmentDataProviderDeps } from '../../createSegmentDataProvider';
 import type { SegmentReference } from '../../../streaming/SegmentReference';
 import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import type { DashMediaQualityMetadataResolver } from '../../../track/dash/DashMediaQualityMetadataResolver';
+import type { DashMediaQualityMetadataResolver } from '../DashMediaQualityMetadataResolver';
 export interface DashSegmentProviderDeps extends DashUriResolveDeps, CreateSegmentDataProviderDeps {
     /**
      * Produces abstract metadata from a dash representation.

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

@@ -1,7 +1,7 @@
 import type { Maybe } from '@amazon/vinyl-util';
 import type { RequestInitOptions } from '@amazon/vinyl-util';
 import type { RequestInterceptor } from '@amazon/vinyl-util';
-import type { DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import type { DashManifestProvider } from './DashManifestProvider';
 /**
  * Creates a DashManifestProvider which performs a request to retrieve a dash manifest.
  * Can be a relative path.

package/dist/types/ts4.1/track/dash/util/mpd.d.ts

@@ -72,9 +72,20 @@ export declare function getPeriodAtTime(manifest: DashManifest, time: number): P
  * Flattens representations across all adaptation sets for the given Period.
  */
 export declare function flattenRepresentations(period: PeriodType): RepresentationType[];
+/**
+ * Flattens the representations across all adaptation sets for the given Period
+ * that the MSE media pipeline can play, i.e. `audio` and `video`.
+ *
+ * Text adaptation sets (e.g. `contentType="text"` WebVTT sidecar subtitles) are
+ * excluded: they are surfaced through the sidecar text-track pipeline
+ * (`discoverDashTextTracks`), not buffered through MSE, so including them here
+ * would create an unplayable text SourceBuffer and stall playback.
+ */
+export declare function flattenMediaRepresentations(period: PeriodType): RepresentationType[];
 /**
  * Calculates the manifest duration, either from the mediaPresentationDuration or the last period end time.
- * @param manifest
+ * Returns `Infinity` for live (dynamic) presentations.
+ * Throws if duration cannot be determined.
  */
-export declare function calculateDuration(manifest: DashManifest): number | null;
+export declare function calculateDuration(manifest: DashManifest): number;
 //# sourceMappingURL=mpd.d.ts.map

package/dist/types/ts4.1/track/hls/HlsManifestController.d.ts

@@ -1,25 +1,4 @@
 import type { ManifestController } from '../../streaming/ManifestController';
-import type { HlsManifestData, HlsManifestProvider } from './HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestData';
 export type HlsManifestController = ManifestController<Promise<HlsManifestData>>;
-export declare class HlsManifestControllerImpl implements HlsManifestController {
-    private readonly manifestProvider;
-    get [Symbol.toStringTag](): string;
-    get logPrefix(): string;
-    private readonly _data;
-    private _error;
-    private readonly abortSlot;
-    private readonly disposer;
-    constructor(manifestProvider: HlsManifestProvider);
-    get error(): (Error | null);
-    refresh(): void;
-    reset(): void;
-    get value(): Promise<HlsManifestData>;
-    get changeId(): number;
-    getValue(): Promise<HlsManifestData>;
-    onData(callback: (value: Promise<HlsManifestData>, previous?: Promise<HlsManifestData>) => void): () => void;
-    map<U>(fn: (value: Promise<HlsManifestData>) => U): import("@amazon/vinyl-observable").MutableValue<U>;
-    pick<K extends keyof NonNullable<Promise<HlsManifestData>>>(key: K): import("@amazon/vinyl-observable").MutableValue<Promise<HlsManifestData>[K]>;
-    get disposed(): boolean;
-    dispose(): void;
-}
 //# sourceMappingURL=HlsManifestController.d.ts.map

package/dist/types/ts4.1/track/hls/{HlsManifestProvider.d.ts → HlsManifestData.d.ts}

@@ -1,12 +1,10 @@
-import type { ReadonlyAbort } from '@amazon/vinyl-util';
-import type { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
-export type HlsManifestProvider = (abort?: ReadonlyAbort) => Promise<HlsManifestData>;
+import type { HlsMainPlaylist, HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
 export interface HlsManifestData {
     /**
      * The main HLS playlist manifest.
      * Use getMediaPlaylist to resolve bitrate manifests.
      */
-    readonly mainPlaylist: MainPlaylist;
+    readonly mainPlaylist: HlsMainPlaylist;
     /**
      * The URL to be used for relative requests. Guaranteed to be absolute.
      *
@@ -16,6 +14,6 @@ export interface HlsManifestData {
     /**
      * Lazily fetches and caches a media playlist by variant URI.
      */
-    readonly getMediaPlaylist: (uri: string) => Promise<MediaPlaylist>;
+    readonly getMediaPlaylist: (uri: string) => Promise<HlsMediaPlaylist>;
 }
-//# sourceMappingURL=HlsManifestProvider.d.ts.map
+//# sourceMappingURL=HlsManifestData.d.ts.map

package/dist/types/ts4.1/track/hls/HlsTrack.d.ts

@@ -1,20 +1,19 @@
 import type { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
-import type { TrackLoadOptions, TrackFactory } from '../TrackFactory';
-import type { TrackBaseOptions } from '../TrackBase';
-import type { HlsManifestProvider } from './HlsManifestProvider';
+import type { TrackConfigOptions, TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import type { HlsManifestController } from './HlsManifestController';
-import type { HlsManifestData } from './HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestData';
 import type { HlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
 import type { MseTrackDeps } from '../mse/MseTrack';
 import type { Factories } from '@amazon/vinyl-di';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import type { ManifestProvider } from '../../streaming/ManifestController';
 export interface HlsTrackLoadOptions extends TrackLoadOptions {
     readonly type: 'hls';
-    readonly manifestProvider?: Maybe<HlsManifestProvider>;
+    readonly manifestProvider?: Maybe<ManifestProvider<HlsManifestData>>;
     readonly requestInit?: Maybe<RequestInitOptions>;
     readonly segmentRequestInit?: Maybe<RequestInitOptions>;
-    readonly config?: Maybe<TrackBaseOptions>;
+    readonly config?: Maybe<TrackConfigOptions>;
 }
 export interface HlsTrackDeps extends MseTrackDeps {
     readonly manifestController: HlsManifestController;

package/dist/types/ts4.1/track/hls/buildHlsMediaTimeline.d.ts

@@ -1,13 +1,20 @@
-import type { HlsManifestData } from '../../track/hls/HlsManifestProvider';
-import type { HlsMediaQualityMetadataResolver } from '../../track/hls/HlsMediaQualityMetadataResolver';
+import type { HlsManifestData } from './HlsManifestData';
+import type { HlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
-import type { CreateSegmentDataProviderDeps } from '../../track/createSegmentDataProvider';
+import type { CreateSegmentDataProviderDeps } from '../createSegmentDataProvider';
 export interface BuildHlsMediaTimelineDeps extends CreateSegmentDataProviderDeps {
     readonly mediaQualityMetadataResolver: HlsMediaQualityMetadataResolver;
 }
 /**
  * Builds a MediaTimeline from an HLS manifest.
  * HLS has a single implicit period spanning the full duration.
+ *
+ * Audio is modeled per source: a variant that carries muxed audio (no separate
+ * AUDIO rendition group) contributes an audio quality on its own playlist, while
+ * a variant with a demuxed audio group contributes video only — one audio
+ * quality is created per AUDIO rendition in the group, each carrying that
+ * rendition's language and playlist. Modeling every language as its own audio
+ * quality is what lets the timeline's language filter select among them.
  */
 export declare function buildHlsMediaTimeline(deps: BuildHlsMediaTimelineDeps, data: HlsManifestData): MediaTimeline;
 //# sourceMappingURL=buildHlsMediaTimeline.d.ts.map

package/dist/types/ts4.1/track/hls/createDefaultHlsManifestTransformer.d.ts

@@ -1,5 +1,5 @@
 import type { ObservableValue } from '@amazon/vinyl-observable';
-import type { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestData';
 export interface HlsManifestTransformerDeps {
     readonly manifestController: ObservableValue<Promise<HlsManifestData>>;
 }

package/dist/types/ts4.1/track/hls/createHlsContentTypesValue.d.ts

@@ -1,6 +1,6 @@
 import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
 import type { ObservableValue } from '@amazon/vinyl-observable';
-import type { HlsManifestData } from './HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestData';
 export interface HlsContentTypesValueDeps {
     readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
 }

package/dist/types/ts4.1/track/hls/createHlsFactories.d.ts

@@ -1,11 +1,12 @@
 import type { HlsTrackLoadOptions } from './HlsTrack';
 import type { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+import type { AdController } from '../../ad/AdController';
 import { createMediaSource } from '../../util/media/mediaSource';
 import type { MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
 import { MediaSourceControllerImpl } from '../../streaming/buffering/MediaSourceController';
-import { HlsManifestControllerImpl } from './HlsManifestController';
 import type { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
 import { createHlsContentTypesValue } from './createHlsContentTypesValue';
+import { createAllowedContentTypesValue } from '../../streaming/createAllowedContentTypesValue';
 import { createContentStreamFactory } from '../../streaming/ContentStream';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { PlaybackController } from '../../playback/PlaybackController';
@@ -13,31 +14,42 @@ import type { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import type { DrmController } from '../../drm/DrmController';
 import type { Capabilities } from '../../client/Capabilities';
 import type { PlaybackSource } from '../../playback/PlaybackSource';
-import type { QualitySelectorImplOptions } from '../../streaming/abr/QualitySelectorImpl';
 import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
 import type { VinylOptions } from '../../vinyl/VinylOptions';
 import { createDefaultHlsManifestTransformer } from './createDefaultHlsManifestTransformer';
 import type { BuildHlsMediaTimelineDeps } from './buildHlsMediaTimeline';
 import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
-import type { HlsManifestData } from './HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestData';
+import { SidecarTextTrackController } from '../../text/SidecarTextTrackController';
+import type { ManifestControllerImplDeps } from '../../streaming/ManifestControllerImpl';
+import { ManifestControllerImpl } 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;
@@ -56,19 +68,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/ts4.1/track/hls/createHlsManifestProvider.d.ts

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

package/dist/types/ts4.1/track/hls/createUrlHlsManifestProvider.d.ts

@@ -1,6 +1,6 @@
-import type { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+import type { HlsMainPlaylist, HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
 import type { Maybe, ReadonlyAbort, RequestInitOptions } from '@amazon/vinyl-util';
-import type { HlsManifestProvider } from './HlsManifestProvider';
+import type { 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/ts4.1/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/ts4.1/track/hls/util/hlsSegmentTime.d.ts

@@ -1,7 +1,7 @@
 import type { HlsSegment } from '@amazon/vinyl-hls-parser';
 import type { MediaSegmentReference } from '../../../streaming/SegmentReference';
 import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import type { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import type { CreateSegmentDataProviderDeps } from '../../createSegmentDataProvider';
 /**
  * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
  * segment list. Cumulative durations are used to compute start/end times.

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

@@ -0,0 +1,15 @@
+import type { 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/ts4.1/track/mse/MseTrack.d.ts

@@ -1,7 +1,7 @@
-import type { TrackBaseDeps, TrackBaseOptions } from '../../track/TrackBase';
-import { TrackBase } from '../../track/TrackBase';
-import type { ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
-import type { TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import type { TrackBaseDeps } from '../TrackBase';
+import { TrackBase } from '../TrackBase';
+import type { Maybe, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import type { TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import type { Factories } from '@amazon/vinyl-di';
 import type { ContentStream } from '../../streaming/ContentStream';
@@ -11,6 +11,19 @@ import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
 import type { ManifestController } from '../../streaming/ManifestController';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import type { TextTrackController } from '../../text/TextTrack';
+import type { TrackConfigOptions } from '../TrackFactory';
+import type { TrackAds } from '../../ad/AdBreakInfo';
+import type { 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;
@@ -19,6 +32,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.
@@ -26,10 +54,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;
@@ -38,23 +67,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;
@@ -68,8 +118,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;
@@ -81,6 +131,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/ts4.1/track/source/FixedPlaybackQuality.d.ts

@@ -1,4 +1,4 @@
-import type { TrackEventMap } from '../../track/Track';
+import type { TrackEventMap } from '../Track';
 import type { ReadonlySet } from '@amazon/vinyl-util';
 import { EventHostImpl } from '@amazon/vinyl-util';
 import type { PlaybackController } from '../../playback/PlaybackController';

package/dist/types/ts4.1/track/source/SourceObjectTrack.d.ts

@@ -1,10 +1,10 @@
 import type { PlaybackSource } from '../../playback/PlaybackSource';
-import type { TrackTypeId, TrackUri } from '../../track/Track';
-import type { TrackBaseDeps } from '../../track/TrackBase';
-import type { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import type { TrackTypeId, TrackUri } from '../Track';
+import type { TrackBaseDeps } from '../TrackBase';
+import type { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import type { Maybe } from '@amazon/vinyl-util';
-import type { SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
-import { SourceTrackBase } from '../../track/source/SourceTrackBase';
+import type { SourceTrackConfigOptions } from './SourceTrackBase';
+import { SourceTrackBase } from './SourceTrackBase';
 /**
  * Dependencies for a SourceObjectTrack.
  */
@@ -21,7 +21,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/ts4.1/track/source/SourceTrack.d.ts

@@ -1,9 +1,9 @@
-import type { TrackTypeId, TrackUri } from '../../track/Track';
-import type { TrackBaseDeps } from '../../track/TrackBase';
-import type { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import type { TrackTypeId, TrackUri } from '../Track';
+import type { TrackBaseDeps } from '../TrackBase';
+import type { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import type { Maybe } from '@amazon/vinyl-util';
-import type { SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
-import { SourceTrackBase } from '../../track/source/SourceTrackBase';
+import type { SourceTrackConfigOptions } from './SourceTrackBase';
+import { SourceTrackBase } from './SourceTrackBase';
 import type { PlaybackSource } from '../../playback/PlaybackSource';
 /**
  * Dependencies for a SourceTrack.
@@ -22,7 +22,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/ts4.1/track/source/SourceTrackBase.d.ts

@@ -1,24 +1,26 @@
-import type { TrackBaseDeps, TrackBaseOptions } from '../../track/TrackBase';
-import { TrackBase } from '../../track/TrackBase';
-import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import type { TrackBaseDeps } from '../TrackBase';
+import { TrackBase } from '../TrackBase';
+import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import type { Maybe, ReadonlySet } from '@amazon/vinyl-util';
 import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import type { ObjectSchema } from '@amazon/vinyl-validation';
-export interface SourceTrackBaseOptions extends TrackBaseOptions {
+import type { 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);