@amazon/vinyl 1.1.1 → 2.0.0

package/dist/types/ts3.7/text/discoverHlsTextTracks.d.ts

@@ -0,0 +1,19 @@
+import { HlsMainPlaylist } from '@amazon/vinyl-hls-parser';
+import { TextTrackInfo } from './TextTrack';
+/**
+ * Discovers sidecar text tracks from an HLS multivariant playlist.
+ *
+ * Per RFC 8216 §4.3.4.2, subtitle renditions are signaled with
+ * `EXT-X-MEDIA:TYPE=SUBTITLES` and (when usable as sidecar) carry a `URI`
+ * attribute pointing at a media playlist or, in the simplified single-file
+ * case, a `.vtt` file directly.
+ *
+ * Closed captions (`TYPE=CLOSED-CAPTIONS`) are intentionally excluded - they
+ * are delivered in-band with the video stream and are surfaced by the browser
+ * automatically, not through a sidecar fetch.
+ *
+ * @param mainPlaylist The parsed HLS main playlist.
+ * @param baseUrl The URL of the main playlist, used to resolve relative URIs.
+ */
+export declare function discoverHlsTextTracks(mainPlaylist: HlsMainPlaylist, baseUrl: string): readonly TextTrackInfo[];
+//# sourceMappingURL=discoverHlsTextTracks.d.ts.map

package/dist/types/ts3.7/text/parseWebVtt.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A single WebVTT cue.
+ *
+ * @see https://www.w3.org/TR/webvtt1/
+ */
+export interface WebVttCue {
+    /**
+     * Optional cue identifier, the line that appears before the timing line.
+     */
+    readonly id: string | null;
+    /**
+     * Cue start time in seconds.
+     */
+    readonly startTime: number;
+    /**
+     * Cue end time in seconds.
+     */
+    readonly endTime: number;
+    /**
+     * The cue text payload, with line breaks preserved as `\n`.
+     */
+    readonly text: string;
+}
+/**
+ * The result of parsing a WebVTT document.
+ */
+export interface WebVttDocument {
+    /**
+     * Parsed cues in document order.
+     */
+    readonly cues: readonly WebVttCue[];
+}
+/**
+ * Parses a WebVTT document into a list of cues.
+ *
+ * Implements a forgiving subset of the WebVTT 1.0 specification: header
+ * detection, comment blocks (lines starting with `NOTE`), styling/region
+ * blocks (skipped), cue identifiers, and HH:MM:SS.mmm or MM:SS.mmm timestamps.
+ * Cue settings on the timing line are tolerated and ignored.
+ *
+ * @param input The raw WebVTT document text. Both LF and CRLF line endings
+ * are supported, and a leading BOM is stripped if present.
+ * @throws ValidationError if the input is missing the WEBVTT header.
+ */
+export declare function parseWebVtt(input: string): WebVttDocument;
+//# sourceMappingURL=parseWebVtt.d.ts.map

package/dist/types/ts3.7/text/pickPreferredTextTrack.d.ts

@@ -0,0 +1,14 @@
+import { TextTrackInfo } from './TextTrack';
+/**
+ * Chooses the text track that best matches the preferred language(s), or null
+ * when none relate (or there is no preference / no tracks).
+ *
+ * Language dominates: a track is ranked first by which preference it relates to
+ * (earlier entries win) and how closely (see {@link languageRelatedness}).
+ * Within a single language, a full track is preferred over a forced-only track
+ * (a user asking for a caption language wants the full captions, not just the
+ * forced foreign-dialogue cues), and a manifest-default track breaks any
+ * remaining tie.
+ */
+export declare function pickPreferredTextTrack(tracks: readonly TextTrackInfo[], preferred: string | readonly string[] | null): TextTrackInfo | null;
+//# sourceMappingURL=pickPreferredTextTrack.d.ts.map

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

@@ -1,35 +1,59 @@
 import { AnyRecord, Clearable, Disposable, EventHostImpl, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { PlaybackController } from '../playback/PlaybackController';
+import { ChangeEvent } from '../event/ChangeEvent';
 export interface AutoResetControllerEventMap {
     /**
      * Notifies that playback errors should be reset and retried.
      */
     readonly reset: AnyRecord;
+    /**
+     * Dispatched when {@link AutoResetController.resetPending} changes.
+     */
+    readonly resetPendingChange: ChangeEvent<boolean>;
 }
 /**
- * Notifies when playback should be reset and retried.
+ * Notifies when playback should be reset and retried after a transient,
+ * potentially-recoverable error.
  *
- * The controller monitors for retry opportunities after an error is set:
- * - Immediately on network 'online' events
- * - After a timeout interval if online
+ * Once an eligible error is set, the controller watches for opportunities
+ * to emit a `reset` event:
+ * - Immediately when the network transitions back to online
+ * - After a timeout interval, if online and retries are not exhausted
  * - Immediately on user playback actions (play, pause, seeking, playing)
  *
- * Each error triggers a single timeout. If another error occurs after a reset,
- * setError() should be called again to schedule the next retry attempt.
+ * Each error triggers a single retry timeout. If another error occurs
+ * after a reset, {@link AutoResetController.setError} should be called again
+ * to schedule the next retry attempt.
  */
 export interface AutoResetController extends ReadonlyEventHost<AutoResetControllerEventMap>, Clearable {
     /**
-     * Sets the current playback error and begins monitoring for retry opportunities.
+     * Sets the current playback error and, if eligible, begins watching for
+     * retry opportunities.
+     *
+     * An error is eligible when it is a {@link RequestError} that did not
+     * receive an HTTP response (i.e. `response == null`), indicating a
+     * transient network failure such as connection loss or DNS failure.
+     * All other errors — including HTTP failures with a response (4xx/5xx),
+     * and non-RequestError errors — are ignored, since those are unlikely
+     * to recover on their own.
      *
-     * Only SERVICE_INTERNAL ReportableErrors are monitored. Subsequent calls while
-     * an error is already set are ignored until the error is cleared via reset or clear().
+     * Subsequent calls while an error is already set are ignored until the
+     * error is cleared via a reset emission or {@link Clearable.clear}.
      *
-     * After a reset, if another error occurs, this method should be called again
-     * to schedule the next retry attempt.
+     * After a reset, if another eligible error occurs, this method should
+     * be called again to schedule the next retry attempt.
      *
      * @param error The error to monitor for retry opportunities
      */
     setError(error: Error): void;
+    /**
+     * True while an eligible error is being watched and a `reset` event
+     * may still be emitted. Becomes false once the error is cleared, a
+     * reset is emitted, or all retries are exhausted.
+     *
+     * Listen to `resetPendingChange` events for changes.
+     */
+    readonly resetPending: boolean;
 }
 export interface AutoResetControllerImplDeps {
     readonly playbackController: PlaybackController;
@@ -74,7 +98,8 @@ export declare class AutoResetControllerImpl extends EventHostImpl<AutoResetCont
     private disposer;
     constructor(deps: AutoResetControllerImplDeps, options?: Partial<AutoResetControllerImplOptions>);
     setError(error: Error): void;
-    private setWatching;
+    get resetPending(): boolean;
+    private setResetPending;
     private reset;
     clear(): void;
     get disposed(): boolean;

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

@@ -0,0 +1,9 @@
+/**
+ * The seekable time range on the media timeline, in seconds.
+ * `end` will be `Infinity` when a live stream.
+ */
+export type SeekRange = {
+    readonly start: number;
+    readonly end: number;
+};
+//# sourceMappingURL=SeekRange.d.ts.map

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

@@ -1,11 +1,18 @@
-import { AnyRecord, Disposable, LogTarget, ReadonlyEventHost, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
+import { AnyRecord, Covariant, Disposable, EventHandler, LogTarget, Maybe, ReadonlyEventHost, ReadonlyRanges, ReadonlySet, SignalOptions, Unsubscribe } from '@amazon/vinyl-util';
 import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
 import { StreamingEventMap } from '../streaming/StreamingEventMap';
+import { ReadonlyTextTrackController, TextTrackController } from '../text/TextTrack';
+import { SeekRange } from './SeekRange';
+import { TrackAds } from '../ad/AdBreakInfo';
+import { TrackConfigOptions } from './TrackFactory';
+export { SeekRange } from './SeekRange';
 /**
  * All events a track may emit.
  * Streaming-related events are separated as they will be bubbled by the player.
  */
-export type TrackEventMap = StreamingEventMap;
+export type TrackEventMap = StreamingEventMap & {
+    readonly adsChange: AnyRecord;
+};
 /**
  * An identifier for a Track, used for referencing a track.
  */
@@ -93,10 +100,13 @@ export interface StreamingState extends ReadonlyStreamingState {
     /**
      * Resets the track to recover from error states.
      * This will reset failed segments and clear error conditions to allow streaming to resume.
+     *
+     * @param hard If true, the track will reset the playback state and
+     * recreate media sources.
      */
-    reset(): void;
+    reset(hard?: boolean): void;
 }
-export interface ReadonlyTrack extends ReadonlyStreamingState, LogTarget {
+export interface ReadonlyTrack extends ReadonlyEventHost<TrackEventMap>, ReadonlyStreamingState, LogTarget {
     /**
      * The track identifier.
      */
@@ -122,18 +132,44 @@ export interface ReadonlyTrack extends ReadonlyStreamingState, LogTarget {
      * The last error that occurred in this track, or null if no error.
      */
     readonly error: Error | null;
+    /**
+     * Controller for sidecar text tracks discovered for this track, or null
+     * if the track type does not surface text tracks.
+     */
+    readonly textTrackController: ReadonlyTextTrackController | null;
+    /**
+     * The seekable range on the media timeline, or null when not yet known
+     * (e.g. before the manifest is loaded). Based on the media timeline, not
+     * the element's native seekable ranges.
+     */
+    readonly seekRange: SeekRange | null;
+    /**
+     * Resolves to the ads for this track.
+     * The track's ads may change if the media timeline changes.
+     *
+     * @see {@link TrackEventMap} — the `adsChange` event.
+     */
+    getAds(): Promise<TrackAds>;
+    readonly __eventMapType: Covariant<TrackEventMap>;
+    hasListeners(type: keyof TrackEventMap): boolean;
+    on<K extends keyof TrackEventMap>(type: K, handler: EventHandler<TrackEventMap[K]>, options?: SignalOptions): Unsubscribe;
 }
 /**
  * One track is active on the track controller at a time.
  */
-export interface Track<LoadOptionsType extends AnyRecord = AnyRecord> extends ReadonlyTrack, StreamingState, Disposable {
+export interface Track<ConfigType extends TrackConfigOptions = TrackConfigOptions> extends ReadonlyTrack, StreamingState, Disposable {
+    /**
+     * Mutable view of {@link ReadonlyTrack.textTrackController} that allows
+     * selecting the active text track.
+     */
+    readonly textTrackController: TextTrackController | null;
     /**
      * Provides configuration to the track and begins preloading (if applicable).
      *
      * @param trackOptions Configuration provided by the TrackController.
      * @param loadOptions Configuration from `TrackLoadOptions.config`, provided by the Application.
      */
-    preload(trackOptions: TrackPreloadOptions, loadOptions: LoadOptionsType): void;
+    preload(trackOptions: TrackPreloadOptions, loadOptions: Maybe<ConfigType>): void;
     /**
      * Sets this track as active, deactivating any currently active track.
      * This should set sources on the playback source and add any listeners needed for shared
@@ -141,7 +177,7 @@ export interface Track<LoadOptionsType extends AnyRecord = AnyRecord> extends Re
      *
      * @param loadOptions Configuration from `TrackLoadOptions.config`, provided by the Application.
      */
-    activate(loadOptions: LoadOptionsType): void;
+    activate(loadOptions: Maybe<ConfigType>): void;
     /**
      * Sets this track as inactive.
      * This should unset sources, and remove any listeners. Tracks do not implement disposable,
@@ -149,5 +185,12 @@ export interface Track<LoadOptionsType extends AnyRecord = AnyRecord> extends Re
      * are no longer references to the track.
      */
     deactivate(): void;
+    /**
+     * True if this track is disposed.
+     */
+    readonly disposed: boolean;
+    readonly __eventMapType: Covariant<TrackEventMap>;
+    hasListeners(type: keyof TrackEventMap): boolean;
+    on<K extends keyof TrackEventMap>(type: K, handler: EventHandler<TrackEventMap[K]>, options?: SignalOptions): Unsubscribe;
 }
 //# sourceMappingURL=Track.d.ts.map

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

@@ -1,10 +1,12 @@
-import { ObjectSchema } from '@amazon/vinyl-validation';
 import { EventHostImpl, Maybe, ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
 import { PlaybackController } from '../playback/PlaybackController';
 import { Track, TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from './Track';
+import { SeekRange } from './SeekRange';
 import { DrmController } from '../drm/DrmController';
 import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
-import { DrmOptions } from '../drm/DrmOptions';
+import { TextTrackController } from '../text/TextTrack';
+import { TrackAds } from '../ad/AdBreakInfo';
+import { TrackConfigOptions } from './TrackFactory';
 /**
  * Dependencies for TrackBase.
  */
@@ -18,29 +20,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.
      */
@@ -54,11 +37,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);
@@ -70,6 +55,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.
@@ -79,31 +65,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/ts3.7/track/TrackController.d.ts

@@ -1,47 +1,69 @@
 import { AnyRecord, Disposable, EventHostImpl, Maybe, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { PlaybackController } from '../playback/PlaybackController';
-import { ReadonlyTrack, TrackUri } from '../track/Track';
-import { TrackFactory, TrackLoadOptions } from '../track/TrackFactory';
+import { ReadonlyTrack, TrackUri } from './Track';
+import { TrackFactory, TrackLoadOptions } from './TrackFactory';
 import { ChangeEvent } from '../event/ChangeEvent';
+import { AdController } from '../ad/AdController';
+import { 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.
@@ -124,7 +146,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;
     /**
@@ -134,25 +156,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
@@ -175,13 +197,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.
@@ -198,7 +228,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>;
@@ -206,6 +236,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;
@@ -218,25 +258,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