@amazon/vinyl 1.0.0

package/dist/types/current/track/hls/HlsManifestController.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { data } from '@amazon/vinyl-observable';
+import { createAbortSlot, createDisposer, logDebug } from '@amazon/vinyl-util';
+export class HlsManifestControllerImpl {
+    manifestProvider;
+    get [Symbol.toStringTag]() {
+        return 'HlsManifestControllerImpl';
+    }
+    get logPrefix() {
+        return 'HlsManifestControllerImpl';
+    }
+    _data = data(Promise.reject(new Error('manifest not loaded')));
+    _error = null;
+    abortSlot = createAbortSlot();
+    disposer = createDisposer();
+    constructor(manifestProvider) {
+        this.manifestProvider = manifestProvider;
+        // Suppress unhandled rejection on the initial placeholder.
+        this._data.value.catch(() => { });
+        this.refresh();
+    }
+    /**
+     * The most recent error from the manifest provider, or null.
+     */
+    get error() {
+        return this._error;
+    }
+    refresh() {
+        logDebug(this, 'refresh');
+        this.abortSlot.abort();
+        this._error = null;
+        const promise = this.manifestProvider(this.abortSlot.value);
+        promise.catch((error) => {
+            this._error = error;
+        });
+        this._data.value = promise;
+    }
+    reset() {
+        logDebug(this, 'reset');
+        if (this._error) {
+            this.refresh();
+        }
+    }
+    get value() {
+        return this._data.value;
+    }
+    get changeId() {
+        return this._data.changeId;
+    }
+    getValue() {
+        return this._data.getValue();
+    }
+    onData(callback) {
+        return this._data.onData(callback);
+    }
+    map(fn) {
+        return this._data.map(fn);
+    }
+    pick(key) {
+        return this._data.pick(key);
+    }
+    get disposed() {
+        return this.disposer.disposed;
+    }
+    dispose() {
+        this.abortSlot.abort();
+        this.disposer.dispose();
+    }
+}

package/dist/types/current/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/current/track/hls/HlsManifestProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HlsManifestProvider.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/HlsManifestProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE3E,MAAM,MAAM,mBAAmB,GAAG,CAC9B,KAAK,CAAC,EAAE,aAAa,KACpB,OAAO,CAAC,eAAe,CAAC,CAAA;AAE7B,MAAM,WAAW,eAAe;IAC5B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IAEnC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;CACrE"}

package/dist/types/current/track/hls/HlsManifestProvider.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/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/current/track/hls/HlsMediaQualityMetadataResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HlsMediaQualityMetadataResolver.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/HlsMediaQualityMetadataResolver.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACR,oBAAoB,EACpB,aAAa,EAChB,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAGhF,MAAM,MAAM,+BAA+B,GAAG,CAC1C,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,SAAS,oBAAoB,EAAE,KAC1C,oBAAoB,CAAA;AAEzB,wBAAgB,4CAA4C,IAAI,+BAA+B,CA0C9F"}

package/dist/types/current/track/hls/HlsMediaQualityMetadataResolver.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { codecToContentType, contentTypeToMimeType } from '../mse/codec';
+export function createDefaultHlsMediaQualityMetadataResolver() {
+    return (variant, renditions) => {
+        const codecs = variant.codecs || null;
+        // Use the first codec to determine the primary content type.
+        const contentType = codecs
+            ? codecToContentType(codecs.split(',')[0])
+            : null;
+        // Find matching audio rendition for language.
+        const audioRendition = variant.audioGroup
+            ? renditions.find((r) => r.type === 'AUDIO' && r.groupId === variant.audioGroup)
+            : undefined;
+        // Use the variant URI as the decoderId so each quality forces a decoder
+        // re-initialization on switch.
+        return {
+            qualityId: `${variant.bandwidth}-${codecs ?? ''}`,
+            decoderId: variant.uri,
+            groupId: '0',
+            switchingGroupIds: null,
+            mimeType: contentType
+                ? contentTypeToMimeType(contentType, codecs)
+                : null,
+            contentType,
+            codecs,
+            bandwidth: null,
+            bandwidthTotal: variant.bandwidth,
+            audioSamplingRate: null,
+            width: variant.width ?? null,
+            height: variant.height ?? null,
+            frameRate: variant.frameRate
+                ? [variant.frameRate, 1]
+                : null,
+            lang: audioRendition?.language ?? null,
+            contentProtections: [],
+            encryptionScheme: null,
+            initDataType: null,
+            supplementalProperties: {},
+        };
+    };
+}

package/dist/types/current/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/current/track/hls/HlsTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HlsTrack.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/HlsTrack.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAEnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAA;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAA;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAUnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IACzD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAA;IACtD,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAChD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAA;CAC5C;AAcD,MAAM,WAAW,YAAa,SAAQ,YAAY;IAC9C,QAAQ,CAAC,kBAAkB,EAAE,qBAAqB,CAAA;IAClD,QAAQ,CAAC,mBAAmB,EAAE,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAA;IACvE,QAAQ,CAAC,4BAA4B,EAAE,+BAA+B,CAAA;IACtE,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IAC/D,QAAQ,CAAC,wBAAwB,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;CAC7E;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,CACzB,WAAW,EAAE,mBAAmB,KAC/B,SAAS,CAAC,YAAY,CAAC,CAAA;CAC/B,CAAA;AAED,wBAAgB,qBAAqB,CACjC,IAAI,EAAE,mBAAmB,GAC1B,YAAY,CAAC,mBAAmB,CAAC,CAcnC"}

package/dist/types/current/track/hls/HlsTrack.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin } from '@amazon/vinyl-util';
+import { MseTrack } from '../mse/MseTrack';
+import { func, isOneOf, object, string, } from '@amazon/vinyl-validation';
+import { trackBaseOptionsValidator } from '../TrackBase';
+const loadOptionsValidator = object({
+    config: trackBaseOptionsValidator.maybe().optional(),
+    manifestProvider: func().maybe().optional(),
+    requestInit: object({}).cast().maybe().optional(),
+    segmentRequestInit: object({})
+        .cast()
+        .maybe()
+        .optional(),
+    type: isOneOf('hls'),
+    uri: string().notEmpty(),
+});
+export function createHlsTrackFactory(deps) {
+    return {
+        validate(options) {
+            loadOptionsValidator.assert(options, ErrorOrigin.API);
+        },
+        createTrack(loadOptions) {
+            return new MseTrack(loadOptions.uri, loadOptions.type, deps.createHlsFactories(loadOptions));
+        },
+    };
+}

package/dist/types/current/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/current/track/hls/buildHlsMediaTimeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildHlsMediaTimeline.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/buildHlsMediaTimeline.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,6CAA6C,CAAA;AAKlG,OAAO,KAAK,EAGR,aAAa,EAChB,MAAM,2BAA2B,CAAA;AAOlC,OAAO,EAEH,KAAK,6BAA6B,EACrC,MAAM,mCAAmC,CAAA;AAI1C,MAAM,WAAW,yBAA0B,SAAQ,6BAA6B;IAC5E,QAAQ,CAAC,4BAA4B,EAAE,+BAA+B,CAAA;CACzE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACjC,IAAI,EAAE,yBAAyB,EAC/B,IAAI,EAAE,eAAe,GACtB,aAAa,CAuJf"}

package/dist/types/current/track/hls/buildHlsMediaTimeline.js

@@ -0,0 +1,129 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { buildSegmentTimeline } from '../../track/hls/util/hlsSegmentTime';
+import { getSegmentAtTime } from '../../streaming/util/segment';
+import { resolveUrl } from '@amazon/vinyl-util';
+import { codecToContentType, contentTypeToMimeType } from '../../track/mse/codec';
+import { createSegmentDataProvider, } from '../../track/createSegmentDataProvider';
+import { hlsByteRangeToMediaRange } from '../../track/hls/util/hlsByteRangeToMediaRange';
+import { createTransmuxer } from '@amazon/vinyl-transmux';
+/**
+ * Builds a MediaTimeline from an HLS manifest.
+ * HLS has a single implicit period spanning the full duration.
+ */
+export function buildHlsMediaTimeline(deps, data) {
+    const { mainPlaylist, baseUrl } = data;
+    const renditions = mainPlaylist.alternativeRenditions;
+    // HLS duration requires fetching a media playlist, so compute it lazily.
+    const DEFAULT_MIN_BUFFER_TIME = 10;
+    const qualities = mainPlaylist.variants.flatMap((variant) => {
+        const baseMetadata = deps.mediaQualityMetadataResolver(variant, renditions);
+        // Determine which content types this variant carries.
+        const codecs = variant.codecs?.split(',') ?? [];
+        const contentTypes = new Set(codecs
+            .map((c) => codecToContentType(c))
+            .filter((t) => t != null));
+        // If no codecs, default to audio (e.g. TS streams).
+        if (contentTypes.size === 0)
+            contentTypes.add('audio');
+        // Create one quality per content type, with narrowed mimeType.
+        return [...contentTypes].map((contentType) => {
+            const codec = codecs.find((c) => codecToContentType(c) === contentType) ??
+                null;
+            const metadata = {
+                ...baseMetadata,
+                contentType,
+                mimeType: contentTypeToMimeType(contentType, codec),
+                codecs: codec,
+            };
+            const transmuxer = createTransmuxer();
+            return {
+                metadata,
+                async getSegment(time, affordance = 0) {
+                    // For an audio quality on a variant that also carries video,
+                    // the audio is delivered through a separate rendition group
+                    // (variant URI is video-only). Use the rendition URI in that
+                    // case. Otherwise the variant URI itself contains the audio.
+                    let playlistUri = variant.uri;
+                    if (metadata.contentType === 'audio' &&
+                        variant.audioGroup &&
+                        contentTypes.has('video')) {
+                        const rendition = renditions.find((r) => r.type === 'AUDIO' &&
+                            r.groupId === variant.audioGroup &&
+                            r.uri);
+                        if (rendition?.uri)
+                            playlistUri = rendition.uri;
+                    }
+                    const playlist = await data.getMediaPlaylist(playlistUri);
+                    const playlistBaseUrl = resolveUrl(playlistUri, baseUrl);
+                    const segments = buildSegmentTimeline(deps, playlistBaseUrl, playlist.segments);
+                    const segment = getSegmentAtTime(time, segments, affordance);
+                    if (!segment)
+                        return null;
+                    // fMP4: use #EXT-X-MAP init segment directly.
+                    const hlsMap = playlist.segments[0]?.map;
+                    if (hlsMap) {
+                        return {
+                            quality: metadata,
+                            ...segment,
+                            initData: createSegmentDataProvider(deps, {
+                                url: resolveUrl(hlsMap.uri, playlistBaseUrl),
+                                mediaRange: hlsMap.byteRange
+                                    ? hlsByteRangeToMediaRange(hlsMap.byteRange)
+                                    : undefined,
+                                reportDownlinkMetrics: false,
+                            }),
+                        };
+                    }
+                    // MPEG-TS/ADTS: transmux to fMP4.
+                    const transmuxedQuality = {
+                        ...metadata,
+                        mimeType: contentTypeToMimeType(metadata.contentType, metadata.codecs),
+                    };
+                    const rawDataProvider = segment.data;
+                    return {
+                        quality: transmuxedQuality,
+                        ...segment,
+                        data: async (abort) => {
+                            const raw = await rawDataProvider(abort);
+                            return transmuxer.transmux(raw).mediaSegment;
+                        },
+                        initData: async (abort) => {
+                            const raw = await rawDataProvider(abort);
+                            return transmuxer.transmux(raw).initSegment;
+                        },
+                    };
+                },
+            };
+        });
+    });
+    const period = {
+        startTime: 0,
+        endTime: Infinity,
+        qualities,
+    };
+    let cachedDuration = null;
+    return {
+        periods: [period],
+        minBufferTime: DEFAULT_MIN_BUFFER_TIME,
+        async getDuration() {
+            if (cachedDuration != null)
+                return cachedDuration;
+            if (mainPlaylist.variants.length === 0)
+                return null;
+            try {
+                const playlist = await data.getMediaPlaylist(mainPlaylist.variants[0].uri);
+                let total = 0;
+                for (const seg of playlist.segments)
+                    total += seg.duration;
+                cachedDuration = total > 0 ? total : null;
+            }
+            catch {
+                return null;
+            }
+            return cachedDuration;
+        },
+    };
+}

package/dist/types/current/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/current/track/hls/createDefaultHlsManifestTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDefaultHlsManifestTransformer.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/createDefaultHlsManifestTransformer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAEtE,MAAM,WAAW,0BAA0B;IACvC,QAAQ,CAAC,kBAAkB,EAAE,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAA;CACzE;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CAC/C,IAAI,EAAE,0BAA0B,GACjC,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAc3C"}

package/dist/types/current/track/hls/createDefaultHlsManifestTransformer.js

@@ -0,0 +1,21 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * 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 function createDefaultHlsManifestTransformer(deps) {
+    return deps.manifestController.map(async (v) => {
+        const data = await v;
+        const sorted = [...data.mainPlaylist.variants].sort((a, b) => b.bandwidth - a.bandwidth);
+        return {
+            ...data,
+            mainPlaylist: {
+                ...data.mainPlaylist,
+                variants: sorted,
+            },
+        };
+    });
+}

package/dist/types/current/track/hls/createHlsContentStreamFactories.d.ts

@@ -0,0 +1,27 @@
+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 { SourceBufferControllerImpl, type SourceBufferControllerImplDeps } from '../../streaming/buffering/SourceBufferController';
+import { BufferingControllerImpl, type BufferingControllerImplDeps } from '../../streaming/buffering/BufferingController';
+import { SegmentControllerImpl, type SegmentControllerImplDeps } 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) => NoInfer<{
+    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/current/track/hls/createHlsContentStreamFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHlsContentStreamFactories.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/createHlsContentStreamFactories.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAA;AACxF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AACnE,OAAO,EACH,0BAA0B,EAC1B,KAAK,8BAA8B,EACtC,MAAM,8CAA8C,CAAA;AACrD,OAAO,EACH,uBAAuB,EACvB,KAAK,2BAA2B,EACnC,MAAM,2CAA2C,CAAA;AAClD,OAAO,EACH,qBAAqB,EACrB,KAAK,yBAAyB,EACjC,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,KAAK,KAAK,EAAW,MAAM,oBAAoB,CAAA;AAMxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAA;AAClF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,MAAM,WAAW,yBAAyB;IACtC,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB,CAAA;IACrD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,wBAAwB,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IAC1E,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAA;CAC5C;AAED,wBAAgB,+BAA+B,CAC3C,OAAO,EAAE,KAAK,CAAC,uBAAuB,CAAC,IAE/B,MAAM,yBAAyB,oEAEjB,WAAW;0CAIN,8BAA8B;gCAEb,2BAA2B;8BAM7B,yBAAyB;;;;;IAUtE"}

package/dist/types/current/track/hls/createHlsContentStreamFactories.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SourceBufferControllerImpl, } from '../../streaming/buffering/SourceBufferController';
+import { BufferingControllerImpl, } from '../../streaming/buffering/BufferingController';
+import { SegmentControllerImpl, } from '../../streaming/SegmentControllerImpl';
+import { memoize } from '@amazon/vinyl-util';
+import { externalDependencies, validateFactories, } from '@amazon/vinyl-di';
+export function createHlsContentStreamFactories(options) {
+    return (deps) => memoize((contentType) => {
+        return validateFactories({
+            ...externalDependencies(deps),
+            sourceBufferControllerFactory: (deps) => () => new SourceBufferControllerImpl(deps, contentType),
+            bufferingController: (deps) => new BufferingControllerImpl(deps, contentType, options?.buffering),
+            segmentController: (deps) => new SegmentControllerImpl(deps, contentType, options?.segmentController),
+        });
+    }, (contentType) => contentType);
+}

package/dist/types/current/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/current/track/hls/createHlsContentTypesValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHlsContentTypesValue.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/createHlsContentTypesValue.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAI5D,MAAM,WAAW,wBAAwB;IACrC,QAAQ,CAAC,mBAAmB,EAAE,eAAe,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAA;CAC1E;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACtC,IAAI,EAAE,wBAAwB,GAC/B,iBAAiB,CAInB"}

package/dist/types/current/track/hls/createHlsContentTypesValue.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { codecsToContentTypes } from '../mse/codec';
+/**
+ * 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 function createHlsContentTypesValue(deps) {
+    return deps.manifestTransformed.map(async (manifestData) => {
+        return getContentTypes((await manifestData).mainPlaylist);
+    });
+}
+function getContentTypes(mainPlaylist) {
+    const contentTypes = new Set();
+    // Derive content types from variant CODECS attributes.
+    // Only audio and video are relevant for MSE; text (subtitles/CC) is not
+    // appended via SourceBuffer in HLS.
+    for (const variant of mainPlaylist.variants) {
+        if (variant.codecs) {
+            for (const type of codecsToContentTypes(variant.codecs)) {
+                if (type === 'audio' || type === 'video') {
+                    contentTypes.add(type);
+                }
+            }
+        }
+    }
+    // Add audio/video from separate renditions not already covered by variant codecs.
+    for (const rendition of mainPlaylist.alternativeRenditions) {
+        if (rendition.type === 'AUDIO')
+            contentTypes.add('audio');
+        if (rendition.type === 'VIDEO')
+            contentTypes.add('video');
+    }
+    return contentTypes;
+}

package/dist/types/current/track/hls/createHlsFactories.d.ts

@@ -0,0 +1,73 @@
+import type { HlsTrackLoadOptions } from './HlsTrack';
+import type { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
+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 { 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) => NoInfer<{
+    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) => NoInfer<{
+        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/current/track/hls/createHlsFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHlsFactories.d.ts","sourceRoot":"","sources":["../../../../../src/track/hls/createHlsFactories.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAgB,MAAM,YAAY,CAAA;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,EACH,yBAAyB,EACzB,KAAK,6BAA6B,EACrC,MAAM,iDAAiD,CAAA;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAOnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAA;AACtF,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAEzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAA;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAA;AACzF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAA;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAA;AAC3F,OAAO,EAEH,KAAK,yBAAyB,EACjC,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,qCAAqC,EAAE,MAAM,uDAAuD,CAAA;AAC7G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAE5D,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;QAC9B,QAAQ,CAAC,GAAG,EAAE,0BAA0B,CAAA;QACxC,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAA;KACjD,CAAC,CAAA;IACF,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAA;IACvC,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,CAAA;IACnD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;IACrC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;CACtC;AAED,MAAM,MAAM,cAAc,GAAG;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,uBAAuB,CAAC,CAAA;CACtD,CAAA;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,KAAK,CAAC,cAAc,CAAC,IACrD,MAAM,cAAc,MAChB,aAAa,mBAAmB;;;;;;kCAuBF,6BAA6B;;;;;;;;;;;;4BAUnC;QACpB,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC,CAAA;KACtD;0BAMS,yBAAyB,GAAG;QAC9B,QAAQ,CAAC,mBAAmB,EAAE,eAAe,CACzC,OAAO,CAAC,eAAe,CAAC,CAC3B,CAAA;KACJ;;;sBA9DC,0BAA0B;yCACP,MAAM,GAAG,IAAI;;;;;;;;GAuErD"}