@amazon/vinyl 1.2.0 → 2.0.4

package/dist/types/ts4.7/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.7/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, type TrackFactory, type 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.7/track/hls/buildHlsMediaTimeline.d.ts

@@ -1,4 +1,4 @@
-import type { HlsManifestData } from './HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestData';
 import type { HlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
 import { type CreateSegmentDataProviderDeps } from '../createSegmentDataProvider';
@@ -8,6 +8,13 @@ export interface BuildHlsMediaTimelineDeps extends CreateSegmentDataProviderDeps
 /**
  * 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.7/track/hls/createDefaultHlsManifestTransformer.d.ts

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

package/dist/types/ts4.7/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.7/track/hls/createHlsFactories.d.ts

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

package/dist/types/ts4.7/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.7/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.7/track/hls/index.d.ts

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

package/dist/types/ts4.7/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.7/track/mse/MseTrack.d.ts

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

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

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

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

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

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

@@ -1,23 +1,25 @@
-import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../TrackBase';
+import { TrackBase, type TrackBaseDeps } from '../TrackBase';
 import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import { type Maybe, type ReadonlySet } from '@amazon/vinyl-util';
 import { type ContentType, type 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;

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

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

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

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

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

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

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

@@ -8,6 +8,7 @@ import type { DrmController } from '../drm/DrmController';
 import type { AutoResetController } from '../track/AutoResetController';
 import type { MutableValue } from '@amazon/vinyl-observable';
 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