@amazon/vinyl 1.0.0

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

@@ -0,0 +1,25 @@
+import type { ManifestController } from '../../streaming/ManifestController';
+import type { HlsManifestData, HlsManifestProvider } from './HlsManifestProvider';
+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

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

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

@@ -0,0 +1,5 @@
+import type { AlternativeRendition, VariantStream } from '@amazon/vinyl-hls-parser';
+import type { MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+export type HlsMediaQualityMetadataResolver = (variant: VariantStream, renditions: readonly AlternativeRendition[]) => MediaQualityMetadata;
+export declare function createDefaultHlsMediaQualityMetadataResolver(): HlsMediaQualityMetadataResolver;
+//# sourceMappingURL=HlsMediaQualityMetadataResolver.d.ts.map

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

@@ -0,0 +1,30 @@
+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 { HlsManifestController } from './HlsManifestController';
+import type { HlsManifestData } from './HlsManifestProvider';
+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';
+export interface HlsTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'hls';
+    readonly manifestProvider?: Maybe<HlsManifestProvider>;
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    readonly segmentRequestInit?: Maybe<RequestInitOptions>;
+    readonly config?: Maybe<TrackBaseOptions>;
+}
+export interface HlsTrackDeps extends MseTrackDeps {
+    readonly manifestController: HlsManifestController;
+    readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
+    readonly mediaQualityMetadataResolver: HlsMediaQualityMetadataResolver;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+}
+export type HlsTrackFactoryDeps = {
+    readonly createHlsFactories: (loadOptions: HlsTrackLoadOptions) => Factories<HlsTrackDeps>;
+};
+export declare function createHlsTrackFactory(deps: HlsTrackFactoryDeps): TrackFactory<HlsTrackLoadOptions>;
+//# sourceMappingURL=HlsTrack.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+import type { HlsMediaQualityMetadataResolver } from '../../track/hls/HlsMediaQualityMetadataResolver';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import type { CreateSegmentDataProviderDeps } from '../../track/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.
+ */
+export declare function buildHlsMediaTimeline(deps: BuildHlsMediaTimelineDeps, data: HlsManifestData): MediaTimeline;
+//# sourceMappingURL=buildHlsMediaTimeline.d.ts.map

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

@@ -0,0 +1,11 @@
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+export interface HlsManifestTransformerDeps {
+    readonly manifestController: ObservableValue<Promise<HlsManifestData>>;
+}
+/**
+ * The default HLS manifest transformer sorts variants by bandwidth descending (highest quality first).
+ * Quality and language filtering is handled by the media timeline transformer.
+ */
+export declare function createDefaultHlsManifestTransformer(deps: HlsManifestTransformerDeps): ObservableValue<Promise<HlsManifestData>>;
+//# sourceMappingURL=createDefaultHlsManifestTransformer.d.ts.map

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

@@ -0,0 +1,30 @@
+import type { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
+import type { PlaybackController } from '../../playback/PlaybackController';
+import type { QualitySelector } from '../../streaming/abr/QualitySelector';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+import type { SourceBufferControllerImplDeps } from '../../streaming/buffering/SourceBufferController';
+import { SourceBufferControllerImpl } from '../../streaming/buffering/SourceBufferController';
+import type { BufferingControllerImplDeps } from '../../streaming/buffering/BufferingController';
+import { BufferingControllerImpl } from '../../streaming/buffering/BufferingController';
+import type { SegmentControllerImplDeps } from '../../streaming/SegmentControllerImpl';
+import { SegmentControllerImpl } from '../../streaming/SegmentControllerImpl';
+import type { Maybe } from '@amazon/vinyl-util';
+import type { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+export interface HlsContentStreamTrackDeps {
+    readonly mediaSourceController: MediaSourceController;
+    readonly playbackController: PlaybackController;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+    readonly qualitySelector: QualitySelector;
+}
+export declare function createHlsContentStreamFactories(options: Maybe<ContentStreamingOptions>): (deps: HlsContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: ContentType) => {
+    sourceBufferControllerFactory: (deps: SourceBufferControllerImplDeps) => () => SourceBufferControllerImpl;
+    bufferingController: (deps: BufferingControllerImplDeps) => BufferingControllerImpl;
+    segmentController: (deps: SegmentControllerImplDeps) => SegmentControllerImpl;
+    mediaSourceController: import("@amazon/vinyl-di").Factory<MediaSourceController>;
+    playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
+    mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<MediaTimeline>>>;
+    qualitySelector: import("@amazon/vinyl-di").Factory<QualitySelector>;
+});
+//# sourceMappingURL=createHlsContentStreamFactories.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { HlsManifestData } from './HlsManifestProvider';
+export interface HlsContentTypesValueDeps {
+    readonly manifestTransformed: ObservableValue<Promise<HlsManifestData>>;
+}
+/**
+ * Creates an ObservableValue for the content types present in the HLS manifest.
+ *
+ * Per RFC 8216 §4.3.4.2, content types are determined from:
+ * 1. The CODECS attribute on EXT-X-STREAM-INF (variant streams)
+ * 2. The TYPE attribute on EXT-X-MEDIA (alternative renditions)
+ */
+export declare function createHlsContentTypesValue(deps: HlsContentTypesValueDeps): ContentTypesValue;
+//# sourceMappingURL=createHlsContentTypesValue.d.ts.map

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

@@ -0,0 +1,74 @@
+import type { HlsTrackLoadOptions } from './HlsTrack';
+import type { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+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 { createContentStreamFactory } from '../../streaming/ContentStream';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { PlaybackController } from '../../playback/PlaybackController';
+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';
+export interface HlsFactoryDeps {
+    readonly options: ObservableValue<{
+        readonly abr: QualitySelectorImplOptions;
+        readonly preferredAudioLanguage: string | null;
+    }>;
+    readonly playbackController: PlaybackController;
+    readonly playbackSource: PlaybackSource;
+    readonly drmKeySystemResolver: DrmKeySystemResolver;
+    readonly requestInterceptor: RequestInterceptor;
+    readonly drmController: DrmController;
+    readonly capabilities: Capabilities;
+}
+export type HlsInitOptions = {
+    readonly streaming?: Maybe<ContentStreamingOptions>;
+};
+export declare function createHlsFactories(options: Maybe<HlsInitOptions>): (deps: HlsFactoryDeps) => (loadOptions: HlsTrackLoadOptions) => {
+    contentTypesValue: typeof createHlsContentTypesValue;
+    manifestController: () => HlsManifestControllerImpl;
+    manifestTransformed: typeof createDefaultHlsManifestTransformer;
+    mediaQualityMetadataResolver: () => import("./HlsMediaQualityMetadataResolver").HlsMediaQualityMetadataResolver;
+    mediaSourceFactory: () => typeof createMediaSource;
+    mediaSourceController: (deps: MediaSourceControllerImplDeps) => MediaSourceControllerImpl;
+    segmentRequestInit: () => Maybe<Readonly<Omit<RequestInit, "signal">>>;
+    createContentStreamFactories: (deps: import("./createHlsContentStreamFactories").HlsContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
+        sourceBufferControllerFactory: (deps: import("../..").SourceBufferControllerImplDeps) => () => import("../..").SourceBufferControllerImpl;
+        bufferingController: (deps: import("../..").BufferingControllerImplDeps) => import("../..").BufferingControllerImpl;
+        segmentController: (deps: import("../..").SegmentControllerImplDeps) => import("../..").SegmentControllerImpl;
+        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../..").MediaSourceController>;
+        playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
+        mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("../..").MediaTimeline>>>;
+        qualitySelector: import("@amazon/vinyl-di").Factory<import("../..").QualitySelector>;
+    });
+    contentStreamFactory: typeof createContentStreamFactory;
+    qualitySelector: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "abr">>;
+    }) => QualitySelectorImpl;
+    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;
+    }>>;
+    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>;
+};
+//# sourceMappingURL=createHlsFactories.d.ts.map

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

@@ -0,0 +1,21 @@
+import type { MainPlaylist, MediaPlaylist } from '@amazon/vinyl-hls-parser';
+import type { Maybe, ReadonlyAbort, RequestInitOptions } from '@amazon/vinyl-util';
+import type { HlsManifestProvider } from './HlsManifestProvider';
+export declare function createUrlHlsManifestProvider(url: string, requestInit?: RequestInitOptions): HlsManifestProvider;
+export interface FetchMediaPlaylistOptions {
+    /** The variant URI to resolve against the base URL. */
+    readonly uri: string;
+    /** The base URL for resolving relative URIs. */
+    readonly baseUrl: string;
+    /** Variable definitions from the main playlist. */
+    readonly defines: MainPlaylist['defines'];
+    /** Optional request configuration. */
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    /** Optional abort signal. */
+    readonly abort?: Maybe<ReadonlyAbort>;
+}
+/**
+ * Fetches and parses an HLS media playlist from a variant URI.
+ */
+export declare function fetchMediaPlaylist(options: FetchMediaPlaylistOptions): Promise<MediaPlaylist>;
+//# sourceMappingURL=createUrlHlsManifestProvider.d.ts.map

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

@@ -0,0 +1,10 @@
+export * from './HlsManifestProvider';
+export * from './createUrlHlsManifestProvider';
+export * from './HlsManifestController';
+export * from './HlsMediaQualityMetadataResolver';
+export * from './createHlsContentTypesValue';
+export * from './createHlsFactories';
+export * from './createHlsContentStreamFactories';
+export * from './HlsTrack';
+export * from './util/hlsSegmentTime';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ts4.1/track/hls/util/hlsByteRangeToMediaRange.d.ts

@@ -0,0 +1,5 @@
+import type { ByteRange } from '@amazon/vinyl-mpd-parser';
+import type { HlsByteRange } from '@amazon/vinyl-hls-parser';
+/** Converts an HLS byte range (`{offset, length}`) to a `ByteRange` (`[start, end]`). */
+export declare function hlsByteRangeToMediaRange(byteRange: HlsByteRange): ByteRange;
+//# sourceMappingURL=hlsByteRangeToMediaRange.d.ts.map

package/dist/types/ts4.1/track/hls/util/hlsSegmentTime.d.ts

@@ -0,0 +1,10 @@
+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';
+/**
+ * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
+ * segment list. Cumulative durations are used to compute start/end times.
+ */
+export declare function buildSegmentTimeline(deps: CreateSegmentDataProviderDeps, baseUrl: string, segments: readonly HlsSegment[]): readonly MediaSegmentReference<SegmentDataProvider>[];
+//# sourceMappingURL=hlsSegmentTime.d.ts.map

package/dist/types/ts4.1/track/mse/MseTrack.d.ts

@@ -0,0 +1,86 @@
+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 { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import type { Factories } from '@amazon/vinyl-di';
+import type { ContentStream } from '../../streaming/ContentStream';
+import type { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
+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';
+export type MseTrackDeps = TrackBaseDeps & {
+    readonly contentTypesValue: ContentTypesValue;
+    readonly contentStreamFactory: (contentType: ContentType) => ContentStream;
+    readonly manifestController: ManifestController<unknown>;
+    readonly mediaSourceController: MediaSourceController;
+    readonly playbackSource: PlaybackSource;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+};
+/**
+ * An MseTrack uses media source extensions for streaming.
+ */
+export declare class MseTrack extends TrackBase {
+    get [Symbol.toStringTag](): string;
+    protected readonly deps: MseTrackDeps;
+    private readonly streams;
+    private readonly disposeAbort;
+    private lastPreloadOptions;
+    private activateOptions;
+    private readonly allFetchedRanges;
+    private readonly _fetchedRanges;
+    private _contentTypes;
+    private _qualities;
+    private _qualitiesUnfiltered;
+    private timeUpdateSub;
+    private _cachedPeriod;
+    constructor(uri: TrackUri, type: TrackTypeId, dependencyFactories: Factories<MseTrackDeps>);
+    /**
+     * Updates the cached qualities list from the transformed timeline for the current period.
+     */
+    private updateQualities;
+    /**
+     * Updates the cached unfiltered qualities list from the raw timeline for the current period.
+     */
+    private updateQualitiesUnfiltered;
+    /**
+     * Creates and adds a content stream for the given content type.
+     *
+     * @param contentType
+     */
+    protected createStream(contentType: ContentType): void;
+    preload(trackOptions: TrackPreloadOptions, loadOptions: TrackBaseOptions): void;
+    get contentTypes(): ReadonlySet<ContentType>;
+    set contentTypes(value: ReadonlySet<ContentType>);
+    get qualities(): (readonly MediaQualityMetadata[] | null);
+    get qualitiesUnfiltered(): (readonly MediaQualityMetadata[] | null);
+    get fetchedRanges(): ReadonlyRanges;
+    /**
+     * Clears all fetched fragments and source buffers. Streaming will resume.
+     * This should be called if a change has been made where the user would expect an immediate change,
+     * for example, changing streaming quality from SD to HD.
+     */
+    clearPrefetch(): void;
+    /**
+     * 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;
+    onDeactivated(): void;
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    /**
+     * Calls the specified method on all streams with the provided arguments.
+     */
+    private callOnStreams;
+    private getStream;
+    private clearStreams;
+    get bufferingEnded(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=MseTrack.d.ts.map

package/dist/types/ts4.1/track/mse/codec.d.ts

@@ -0,0 +1,16 @@
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+/**
+ * Returns the ContentType for a single RFC 6381 codec string, or null if
+ * unrecognized.
+ */
+export declare function codecToContentType(codec: string): ContentType | null;
+/**
+ * Splits a comma-separated CODECS attribute value and returns the set of
+ * ContentType values present.
+ */
+export declare function codecsToContentTypes(codecs: string): Set<ContentType>;
+/**
+ * Returns the full MIME type string for a content type, optionally with codecs.
+ */
+export declare function contentTypeToMimeType(contentType: ContentType, codecs: string | null): string;
+//# sourceMappingURL=codec.d.ts.map

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

@@ -0,0 +1,39 @@
+import type { TrackEventMap } from '../../track/Track';
+import type { ReadonlySet } from '@amazon/vinyl-util';
+import { EventHostImpl } from '@amazon/vinyl-util';
+import type { PlaybackController } from '../../playback/PlaybackController';
+import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+/**
+ * FixedPlaybackQuality has a singular quality for selection.
+ *
+ * streamingQuality will always be the fixed quality.
+ *
+ * bufferingQuality will be the fixed quality when active, otherwise null.
+ *
+ * playbackQuality will be the fixed quality when active and data is buffered, otherwise null.
+ */
+export declare class FixedPlaybackQuality extends EventHostImpl<Pick<TrackEventMap, 'streamingQualityChange' | 'bufferingQualityChange' | 'playbackQualityChange'>> {
+    private readonly deps;
+    private _fixedQuality;
+    private _contentTypes;
+    private _isActive;
+    get active(): boolean;
+    constructor(fixedQuality: MediaQualityMetadata, deps: {
+        readonly playbackController: PlaybackController;
+    });
+    get contentTypes(): ReadonlySet<ContentType>;
+    get fixedQuality(): MediaQualityMetadata;
+    set fixedQuality(value: MediaQualityMetadata);
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private _bufferingQuality;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private set bufferingQuality(value);
+    private _playbackQuality;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    private set playbackQuality(value);
+    private readyStateChangeSub;
+    activate(): void;
+    deactivate(): void;
+    private onReadyStateChange;
+}
+//# sourceMappingURL=FixedPlaybackQuality.d.ts.map

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

@@ -0,0 +1,34 @@
+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 { Maybe } from '@amazon/vinyl-util';
+import type { SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import { SourceTrackBase } from '../../track/source/SourceTrackBase';
+/**
+ * Dependencies for a SourceObjectTrack.
+ */
+export interface SourceObjectTrackDeps extends TrackBaseDeps {
+    readonly playbackSource: PlaybackSource;
+}
+export interface SourceObjectTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'srcObject';
+    /**
+     * A function to produce a MediaStream, or Promise<MediaStream>.
+     */
+    readonly srcObjectProvider: (uri: TrackUri) => Promise<MediaStream> | MediaStream;
+    /**
+     * Configuration options for the SourceObjectTrack.
+     * Will be provided on preload and activate.
+     */
+    readonly config?: Maybe<SourceTrackBaseOptions>;
+}
+export declare function createSourceObjectTrackFactory(deps: SourceObjectTrackDeps): TrackFactory<SourceObjectTrackLoadOptions>;
+export declare class SourceObjectTrack extends SourceTrackBase<MediaStream> {
+    protected readonly deps: SourceObjectTrackDeps;
+    get [Symbol.toStringTag](): string;
+    constructor(uri: TrackUri, type: TrackTypeId, srcObject: Promise<MediaStream>, deps: SourceObjectTrackDeps);
+    protected setSrc(src: MediaStream): void;
+    protected clearSrc(): void;
+}
+//# sourceMappingURL=SourceObjectTrack.d.ts.map

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

@@ -0,0 +1,35 @@
+import type { TrackTypeId, TrackUri } from '../../track/Track';
+import type { TrackBaseDeps } from '../../track/TrackBase';
+import type { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import type { Maybe } from '@amazon/vinyl-util';
+import type { SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import { SourceTrackBase } from '../../track/source/SourceTrackBase';
+import type { PlaybackSource } from '../../playback/PlaybackSource';
+/**
+ * Dependencies for a SourceTrack.
+ */
+export interface SourceTrackDeps extends TrackBaseDeps {
+    readonly playbackSource: PlaybackSource;
+}
+export interface SourceTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'src';
+    /**
+     * If set, will be called to provide the track src.
+     * Otherwise, the uri will be used.
+     */
+    readonly srcProvider?: Maybe<(uri: TrackUri) => Promise<string> | string>;
+    /**
+     * Configuration options for the SourceTrack.
+     * Will be provided on preload and activate.
+     */
+    readonly config?: Maybe<SourceTrackBaseOptions>;
+}
+export declare function createSourceTrackFactory(deps: SourceTrackDeps): TrackFactory<SourceTrackLoadOptions>;
+export declare class SourceTrack extends SourceTrackBase<string> {
+    protected readonly deps: SourceTrackDeps;
+    get [Symbol.toStringTag](): string;
+    constructor(uri: TrackUri, type: TrackTypeId, src: Promise<string>, deps: SourceTrackDeps);
+    protected setSrc(src: string): void;
+    protected clearSrc(): void;
+}
+//# sourceMappingURL=SourceTrack.d.ts.map

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

@@ -0,0 +1,34 @@
+import type { TrackBaseDeps, TrackBaseOptions } from '../../track/TrackBase';
+import { TrackBase } from '../../track/TrackBase';
+import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/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 {
+    /**
+     * 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> {
+    readonly src: Promise<SrcType>;
+    protected readonly deps: TrackBaseDeps;
+    private readonly fixedPlaybackQuality;
+    private _resolvedSrc;
+    protected constructor(uri: TrackUri, type: TrackTypeId, src: Promise<SrcType>, deps: TrackBaseDeps);
+    preload(trackOptions: TrackPreloadOptions, loadOptions: LoadOptionsType): void;
+    get contentTypes(): ReadonlySet<ContentType>;
+    get qualities(): (readonly MediaQualityMetadata[] | null);
+    get qualitiesUnfiltered(): (readonly MediaQualityMetadata[] | null);
+    getStreamingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getBufferingQuality(contentType: ContentType): MediaQualityMetadata | null;
+    getPlaybackQuality(contentType: ContentType): MediaQualityMetadata | null;
+    onActivated(): void;
+    protected abstract setSrc(src: SrcType): void;
+    protected abstract clearSrc(): void;
+    onDeactivated(): void;
+    clearPrefetch(): void;
+}
+//# sourceMappingURL=SourceTrackBase.d.ts.map

package/dist/types/ts4.1/util/media/getAudioContext.d.ts

@@ -0,0 +1,22 @@
+type MaybeAudioContext = typeof AudioContext | undefined;
+declare global {
+    var webkitAudioContext: MaybeAudioContext;
+}
+/**
+ * Creates a new AudioContext.
+ * Returns null if not supported on this platform.
+ */
+export declare function createAudioContext(): AudioContext | null;
+/**
+ * The audio context global reference.
+ */
+export declare const audioContextRef: import("@amazon/vinyl-util").GlobalRef<AudioContext | null>;
+/**
+ * Returns an AudioContext singleton, or returns null if not supported on this platform.
+ *
+ * If the first time this is called is outside a user gesture, the AudioContext will be unable to start in a
+ * running state.
+ */
+export declare function getAudioContext(): AudioContext | null;
+export {};
+//# sourceMappingURL=getAudioContext.d.ts.map

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

@@ -0,0 +1,40 @@
+import type { Unsubscribe } from '@amazon/vinyl-util';
+import type { SignalOptions } from '@amazon/vinyl-util';
+declare global {
+    var ManagedMediaSource: typeof MediaSource | undefined;
+}
+/**
+ * Returns true if the UA supports media source extensions.
+ */
+export declare function supportsMse(): boolean;
+/**
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MediaSource/isTypeSupported_static)
+ */
+export declare function isTypeSupported(type: string): boolean;
+/**
+ * Constructs a new ManagedMediaSource or MediaSource.
+ */
+export declare function createMediaSource(): MediaSource;
+/**
+ * Throws a MediaUnsupportedError if MSE is not supported.
+ */
+export declare function assertMseSupported(): void;
+/**
+ * Invokes a callback when the media source is open.
+ * The callback will be invoked immediately if already open.
+ */
+export declare function onMediaSourceOpen(mediaSource: MediaSource, callback: () => void, options?: SignalOptions): Unsubscribe;
+/**
+ * Invokes a callback when the media source is next ended.
+ * The callback will be invoked immediately if already ended.
+ */
+export declare function onMediaSourceEnded(mediaSource: MediaSource, callback: () => void, options?: SignalOptions): Unsubscribe;
+/**
+ * Returns a Promise that resolves when the media source is next in an 'ended' state.
+ *
+ * @param mediaSource
+ * @param timeout The number of seconds before rejecting with a TimeoutError.
+ * @param timeoutMessage
+ */
+export declare function nextMediaSourceEnded(mediaSource: MediaSource, timeout?: number, timeoutMessage?: string): Promise<void>;
+//# sourceMappingURL=mediaSource.d.ts.map

package/dist/types/ts4.1/util/media/sourceBuffer.d.ts

@@ -0,0 +1,9 @@
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * Returns a promise that resolves when the given source buffer is next idle.
+ * If the source buffer errs, the promise will be rejected with a {@link SourceBufferError}.
+ *
+ * @param sourceBuffer
+ */
+export declare function nextSourceBufferIdle(sourceBuffer: Maybe<SourceBuffer>): Promise<void>;
+//# sourceMappingURL=sourceBuffer.d.ts.map