@amazon/vinyl 1.0.0

package/dist/types/current/track/createSegmentDataProvider.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getHostname, last, networkMetricsController, normalizeHeadersInit, requestWithRetry, } from '@amazon/vinyl-util';
+import { stringifyByteRange } from '@amazon/vinyl-mpd-parser';
+export function createSegmentDataProvider(deps, options) {
+    return async (abort) => {
+        const init = {
+            ...deps.segmentRequestInit,
+        };
+        if (options.mediaRange) {
+            init.headers = {
+                ...normalizeHeadersInit(init.headers),
+                Range: `bytes=${stringifyByteRange(options.mediaRange)}`,
+            };
+        }
+        const params = {
+            input: options.url,
+            init,
+        };
+        deps.requestInterceptor(params);
+        const serviceId = options.serviceId ?? getHostname(options.url);
+        const requestStart = Date.now();
+        const response = await requestWithRetry(params.input, params.init, {
+            serviceId,
+            abort,
+        });
+        const responseEnd = Date.now();
+        const arrayBuffer = await response.arrayBuffer();
+        const contentEnd = Date.now();
+        let responseStart = null;
+        if ('getEntriesByName' in performance) {
+            const lastRequest = last(performance.getEntriesByName(params.input));
+            if (lastRequest) {
+                // Resource timing information was available, use it to get a more accurate response start time. A
+                // value of 0 means timing information was denied, likely due to a cross-origin request without
+                // Timing-Allow-Origin response headers.
+                if (lastRequest.responseStart) {
+                    responseStart =
+                        performance.timeOrigin + lastRequest.responseStart;
+                }
+            }
+        }
+        if (options.reportDownlinkMetrics) {
+            networkMetricsController.value.addDownlinkTransferEntry({
+                bytes: arrayBuffer.byteLength,
+                serviceId,
+                requestStart,
+                responseStart,
+                responseEnd,
+                contentEnd,
+            });
+        }
+        return arrayBuffer;
+    };
+}

package/dist/types/current/track/createVinylTrackFactories.d.ts

@@ -0,0 +1,19 @@
+import { type SourceObjectTrackDeps, type SourceObjectTrackLoadOptions } from '../track/source/SourceObjectTrack';
+import { type SourceTrackDeps, type SourceTrackLoadOptions } from '../track/source/SourceTrack';
+import type { TrackFactory } from '../track/TrackFactory';
+import { type DashTrackFactoryDeps, type DashTrackLoadOptions } from '../track/dash/DashTrack';
+import { type HlsTrackFactoryDeps, type HlsTrackLoadOptions } from '../track/hls/HlsTrack';
+export interface VinylTrackFactoryDeps extends SourceTrackDeps, SourceObjectTrackDeps, DashTrackFactoryDeps, HlsTrackFactoryDeps {
+}
+export type VinylTrackLoadOptions = SourceObjectTrackLoadOptions | SourceTrackLoadOptions | DashTrackLoadOptions | HlsTrackLoadOptions;
+/**
+ * Provides a map of track type id to their respective loaders.
+ * @param deps
+ */
+export declare function createVinylTrackFactories(deps: VinylTrackFactoryDeps): {
+    readonly src: TrackFactory<SourceTrackLoadOptions>;
+    readonly srcObject: TrackFactory<SourceObjectTrackLoadOptions>;
+    readonly dash: TrackFactory<DashTrackLoadOptions>;
+    readonly hls: TrackFactory<HlsTrackLoadOptions>;
+};
+//# sourceMappingURL=createVinylTrackFactories.d.ts.map

package/dist/types/current/track/createVinylTrackFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVinylTrackFactories.d.ts","sourceRoot":"","sources":["../../../../src/track/createVinylTrackFactories.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACpC,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAEH,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC9B,MAAM,4BAA4B,CAAA;AAEnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,EAEH,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAC5B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAEH,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EAC3B,MAAM,sBAAsB,CAAA;AAE7B,MAAM,WAAW,qBACb,SACI,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB;CAAG;AAE9B,MAAM,MAAM,qBAAqB,GAC3B,4BAA4B,GAC5B,sBAAsB,GACtB,oBAAoB,GACpB,mBAAmB,CAAA;AAEzB;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,qBAAqB;;;;;EAUpE"}

package/dist/types/current/track/createVinylTrackFactories.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createSourceObjectTrackFactory, } from '../track/source/SourceObjectTrack';
+import { createSourceTrackFactory, } from '../track/source/SourceTrack';
+import { createDashTrackFactory, } from '../track/dash/DashTrack';
+import { createHlsTrackFactory, } from '../track/hls/HlsTrack';
+/**
+ * Provides a map of track type id to their respective loaders.
+ * @param deps
+ */
+export function createVinylTrackFactories(deps) {
+    return {
+        src: createSourceTrackFactory(deps),
+        srcObject: createSourceObjectTrackFactory(deps),
+        dash: createDashTrackFactory(deps),
+        hls: createHlsTrackFactory(deps),
+    };
+}

package/dist/types/current/track/dash/DashManifestController.d.ts

@@ -0,0 +1,43 @@
+import type { DashManifestData, DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import type { ManifestController } from '../../streaming/ManifestController';
+export type DashManifestController = ManifestController<Promise<DashManifestData>>;
+export interface DashManifestControllerImplDeps {
+    /**
+     * Resolves the untransformed manifest.
+     */
+    readonly manifestProvider: DashManifestProvider;
+}
+export declare class DashManifestControllerImpl implements DashManifestController {
+    readonly deps: DashManifestControllerImplDeps;
+    get [Symbol.toStringTag](): string;
+    get logPrefix(): string;
+    private readonly _data;
+    private _error;
+    private readonly abortSlot;
+    private readonly disposer;
+    constructor(deps: DashManifestControllerImplDeps);
+    /**
+     * The most recent error from the manifest provider, or null.
+     * This may be a silent error, such as an AbortError.
+     */
+    get error(): Error | null;
+    /**
+     * Reloads the manifest. Aborts any in-flight request and clears any
+     * previous error before starting a new fetch.
+     */
+    refresh(): void;
+    /**
+     * If the manifest is in an error state, triggers a refresh.
+     */
+    reset(): void;
+    get value(): Promise<DashManifestData>;
+    get changeId(): number;
+    getValue(): Promise<DashManifestData>;
+    onData(callback: (value: Promise<DashManifestData>, previous: Promise<DashManifestData> | undefined) => void): import("@amazon/vinyl-util").Unsubscribe;
+    map<U>(transform: (value: Promise<DashManifestData>) => U): import("@amazon/vinyl-observable").MutableValue<U>;
+    pick<K extends keyof NonNullable<Promise<DashManifestData>>>(prop: K): import("@amazon/vinyl-observable").MutableValue<Promise<DashManifestData>[K]>;
+    private abort;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=DashManifestController.d.ts.map

package/dist/types/current/track/dash/DashManifestController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashManifestController.d.ts","sourceRoot":"","sources":["../../../../../src/track/dash/DashManifestController.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACR,gBAAgB,EAChB,oBAAoB,EACvB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAExE,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CACnD,OAAO,CAAC,gBAAgB,CAAC,CAC5B,CAAA;AAED,MAAM,WAAW,8BAA8B;IAC3C;;OAEG;IACH,QAAQ,CAAC,gBAAgB,EAAE,oBAAoB,CAAA;CAClD;AAED,qBAAa,0BAA2B,YAAW,sBAAsB;IAgBzD,QAAQ,CAAC,IAAI,EAAE,8BAA8B;IAfzD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,OAAO,CAAC,QAAQ,CAAC,KAAK,CAErB;IACD,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;gBAEvB,IAAI,EAAE,8BAA8B;IAMzD;;;OAGG;IACH,IAAI,KAAK,IAAI,KAAK,GAAG,IAAI,CAExB;IAED;;;OAGG;IACH,OAAO;IAWP;;OAEG;IACH,KAAK;IAOL,IAAI,KAAK,8BAER;IAED,IAAI,QAAQ,WAEX;IAED,QAAQ;IAIR,MAAM,CACF,QAAQ,EAAE,CACN,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,EAChC,QAAQ,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,SAAS,KAC9C,IAAI;IAKb,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC;IAIzD,IAAI,CAAC,CAAC,SAAS,MAAM,WAAW,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IAIpE,OAAO,CAAC,KAAK;IAIb,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO;CAIV"}

package/dist/types/current/track/dash/DashManifestController.js

@@ -0,0 +1,83 @@
+/*
+ * 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 DashManifestControllerImpl {
+    deps;
+    get [Symbol.toStringTag]() {
+        return 'DashManifestControllerImpl';
+    }
+    get logPrefix() {
+        return 'DashManifestControllerImpl';
+    }
+    _data = data(Promise.reject(new Error('manifest not loaded')));
+    _error = null;
+    abortSlot = createAbortSlot();
+    disposer = createDisposer();
+    constructor(deps) {
+        this.deps = deps;
+        // Suppress unhandled rejection on the initial placeholder.
+        this._data.value.catch(() => { });
+        this.refresh();
+    }
+    /**
+     * The most recent error from the manifest provider, or null.
+     * This may be a silent error, such as an AbortError.
+     */
+    get error() {
+        return this._error;
+    }
+    /**
+     * Reloads the manifest. Aborts any in-flight request and clears any
+     * previous error before starting a new fetch.
+     */
+    refresh() {
+        logDebug(this, 'refresh');
+        this.abort();
+        this._error = null;
+        const promise = this.deps.manifestProvider(this.abortSlot.value);
+        promise.catch((error) => {
+            this._error = error;
+        });
+        this._data.value = promise;
+    }
+    /**
+     * If the manifest is in an error state, triggers a refresh.
+     */
+    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(transform) {
+        return this._data.map(transform);
+    }
+    pick(prop) {
+        return this._data.pick(prop);
+    }
+    abort() {
+        this.abortSlot.abort();
+    }
+    get disposed() {
+        return this.disposer.disposed;
+    }
+    dispose() {
+        this.abort();
+        this.disposer.dispose();
+    }
+}

package/dist/types/current/track/dash/DashManifestProvider.d.ts

@@ -0,0 +1,19 @@
+import type { ReadonlyAbort } from '@amazon/vinyl-util';
+import type { DashManifest } from '@amazon/vinyl-mpd-parser';
+/**
+ * Provides a dash manifest.
+ */
+export type DashManifestProvider = (abort?: ReadonlyAbort) => Promise<DashManifestData>;
+export interface DashManifestData {
+    /**
+     * The Dash manifest.
+     */
+    readonly manifest: DashManifest;
+    /**
+     * 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;
+}
+//# sourceMappingURL=DashManifestProvider.d.ts.map

package/dist/types/current/track/dash/DashManifestProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashManifestProvider.d.ts","sourceRoot":"","sources":["../../../../../src/track/dash/DashManifestProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAC/B,KAAK,CAAC,EAAE,aAAa,KACpB,OAAO,CAAC,gBAAgB,CAAC,CAAA;AAE9B,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAE/B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAC3B"}

package/dist/types/current/track/dash/DashManifestProvider.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/dash/DashMediaQualityMetadataResolver.d.ts

@@ -0,0 +1,43 @@
+import { type ContentProtection, type PeriodType, type RepresentationType } from '@amazon/vinyl-mpd-parser';
+import type { ContentType, DrmProtection, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
+import { type DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
+/**
+ * DASH supplemental property scheme URI for adaptation set switching.
+ * @see https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf Section 3.8
+ */
+export declare const ADAPTATION_SET_SWITCHING_SCHEME = "urn:mpeg:dash:adaptation-set-switching:2016";
+/**
+ * Creates abstract MediaQualityMetadata from a Dash Representation.
+ */
+export type DashMediaQualityMetadataResolver = (representation: RepresentationType) => MediaQualityMetadata;
+/**
+ * Returns a dash metadata resolver that calculates media encoding metadata from the representation.
+ * The most recently used representations will return cached results.
+ */
+export declare function createDefaultDashMediaQualityMetadataResolver(deps: DashMediaQualityMetadataResolverDeps): DashMediaQualityMetadataResolver;
+export interface DashMediaQualityMetadataResolverDeps {
+    readonly drmKeySystemResolver: DrmKeySystemResolver;
+}
+export declare function createMediaQualityMetadataFromDashRepresentation(representation: RepresentationType, deps: DashMediaQualityMetadataResolverDeps): MediaQualityMetadata;
+/**
+ * Estimates the total bandwidth a representation would use when paired with
+ * proportionally matched qualities from sibling content types.
+ *
+ * For each sibling content type, the representation's relative position within its own
+ * content type's sorted bandwidth list is mapped to the corresponding position in the
+ * sibling's list. This produces realistic pairings — e.g. with video [v1,v2,v3,v4] and
+ * audio [a1,a2], v1 pairs with a1, v2 with a1, v3 with a2, v4 with a2.
+ */
+export declare function estimatePeakBandwidth(representation: RepresentationType, contentType: ContentType): number;
+/**
+ * Returns sorted (descending) bandwidth arrays per content type for a period.
+ * Bandwidths within 10% of an existing entry are collapsed to reduce noise
+ * from near-duplicate quality tiers.
+ * Cached by period reference.
+ */
+export declare const getPeriodSortedBandwidths: import("@amazon/vinyl-util").MemoizedFunction & ((period: PeriodType) => ReadonlyMap<ContentType, readonly number[]>);
+/**
+ * Converts a Dash ContentProtection element to a list of DrmProtection metadata.
+ */
+export declare function contentProtectionToMetadata(contentProtection: ContentProtection, deps: DashMediaQualityMetadataResolverDeps): readonly DrmProtection[];
+//# sourceMappingURL=DashMediaQualityMetadataResolver.d.ts.map

package/dist/types/current/track/dash/DashMediaQualityMetadataResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashMediaQualityMetadataResolver.d.ts","sourceRoot":"","sources":["../../../../../src/track/dash/DashMediaQualityMetadataResolver.ts"],"names":[],"mappings":"AAeA,OAAO,EAEH,KAAK,iBAAiB,EAGtB,KAAK,UAAU,EAEf,KAAK,kBAAkB,EAC1B,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EACR,WAAW,EACX,aAAa,EACb,oBAAoB,EACvB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAStE;;;GAGG;AACH,eAAO,MAAM,+BAA+B,gDACK,CAAA;AAEjD;;GAEG;AACH,MAAM,MAAM,gCAAgC,GAAG,CAC3C,cAAc,EAAE,kBAAkB,KACjC,oBAAoB,CAAA;AAEzB;;;GAGG;AACH,wBAAgB,6CAA6C,CACzD,IAAI,EAAE,oCAAoC,GAC3C,gCAAgC,CAUlC;AAED,MAAM,WAAW,oCAAoC;IACjD,QAAQ,CAAC,oBAAoB,EAAE,oBAAoB,CAAA;CACtD;AAED,wBAAgB,gDAAgD,CAC5D,cAAc,EAAE,kBAAkB,EAClC,IAAI,EAAE,oCAAoC,GAC3C,oBAAoB,CA0FtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACjC,cAAc,EAAE,kBAAkB,EAClC,WAAW,EAAE,WAAW,GACzB,MAAM,CAqBR;AAED;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,4DACzB,UAAU,KAAG,WAAW,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC,CA0BpE,CAAA;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACvC,iBAAiB,EAAE,iBAAiB,EACpC,IAAI,EAAE,oCAAoC,GAC3C,SAAS,aAAa,EAAE,CAS1B"}

package/dist/types/current/track/dash/DashMediaQualityMetadataResolver.js

@@ -0,0 +1,184 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin, getOrSet, getOrSetProp, memoize, sortedInsertionIndex, ValidationError, } from '@amazon/vinyl-util';
+import { ContentProtectionScheme, } from '@amazon/vinyl-mpd-parser';
+import { getRepresentationMimeInfo } from '../../track/dash/util/mimeType';
+import { parseCencEncryptionScheme, } from '../../drm/CencEncryptionScheme';
+/**
+ * DASH supplemental property scheme URI for adaptation set switching.
+ * @see https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf Section 3.8
+ */
+export const ADAPTATION_SET_SWITCHING_SCHEME = 'urn:mpeg:dash:adaptation-set-switching:2016';
+/**
+ * Returns a dash metadata resolver that calculates media encoding metadata from the representation.
+ * The most recently used representations will return cached results.
+ */
+export function createDefaultDashMediaQualityMetadataResolver(deps) {
+    return memoize((representation) => createMediaQualityMetadataFromDashRepresentation(representation, deps), (representation) => representation, 30);
+}
+export function createMediaQualityMetadataFromDashRepresentation(representation, deps) {
+    const { contentType, mimeType } = getRepresentationMimeInfo(representation);
+    if (!contentType || !mimeType)
+        throw new ValidationError('mimeType cannot be inferred', ErrorOrigin.MEDIA);
+    const adaptationSet = representation.parent;
+    const period = adaptationSet.parent;
+    const mpd = period.parent;
+    const periodId = period.id ?? `$${mpd.Period.indexOf(period)}`;
+    const adaptationSetId = adaptationSet.id ?? `$${period.AdaptationSet.indexOf(adaptationSet)}`;
+    const qualityId = `${periodId}_${adaptationSetId}_${representation.id}`;
+    // Representations within the same adaptation set where bitstreamSwitching is true can be changed without
+    // reinitializing the decoder.
+    let decoderId = `${periodId}_${adaptationSetId}`;
+    const bitstreamSwitching = adaptationSet.bitstreamSwitching ?? period.bitstreamSwitching;
+    if (!bitstreamSwitching)
+        decoderId += `_${representation.id}`;
+    // Resolve the adaptation set switching group. Adaptation sets that declare
+    // urn:mpeg:dash:adaptation-set-switching:2016 with each other's IDs form a switching group,
+    // meaning their representations are permitted to switch between each other.
+    const groupId = `${periodId}_${adaptationSetId}`;
+    const switchingGroupIds = resolveAdaptationSetSwitchingGroupIds(adaptationSet, periodId, adaptationSetId);
+    // Pick a representation base property which may be inherited from the adaptation set.
+    function pick(key) {
+        return representation[key] ?? adaptationSet[key] ?? null;
+    }
+    function mergeDescriptors(key) {
+        const arr1 = adaptationSet[key] ?? [];
+        const arr2 = representation[key] ?? [];
+        return mapDescriptors([...arr1, ...arr2]);
+    }
+    const contentProtections = [
+        ...(adaptationSet.ContentProtection ?? []),
+        ...(representation.ContentProtection ?? []),
+    ];
+    // Get the encryption scheme from the parsed CENC ContentProtection value.
+    let initDataType = null;
+    let encryptionScheme = null;
+    for (let i = contentProtections.length - 1; i >= 0; i--) {
+        const cP = contentProtections[i];
+        if (cP.schemeIdUri === ContentProtectionScheme.CENC) {
+            initDataType = 'cenc';
+            encryptionScheme =
+                parseCencEncryptionScheme(cP.value)?.scheme ?? null;
+            break;
+        }
+    }
+    return {
+        qualityId,
+        decoderId,
+        groupId,
+        switchingGroupIds,
+        mimeType,
+        contentType,
+        codecs: pick('codecs'),
+        bandwidth: representation.bandwidth,
+        bandwidthTotal: estimatePeakBandwidth(representation, contentType),
+        audioSamplingRate: pick('audioSamplingRate'),
+        frameRate: pick('frameRate'),
+        width: pick('width'),
+        height: pick('height'),
+        lang: adaptationSet.lang ?? null,
+        contentProtections: contentProtections.flatMap((cP) => contentProtectionToMetadata(cP, deps)),
+        encryptionScheme,
+        initDataType,
+        supplementalProperties: mergeDescriptors('SupplementalProperty'),
+    };
+}
+/**
+ * Estimates the total bandwidth a representation would use when paired with
+ * proportionally matched qualities from sibling content types.
+ *
+ * For each sibling content type, the representation's relative position within its own
+ * content type's sorted bandwidth list is mapped to the corresponding position in the
+ * sibling's list. This produces realistic pairings — e.g. with video [v1,v2,v3,v4] and
+ * audio [a1,a2], v1 pairs with a1, v2 with a1, v3 with a2, v4 with a2.
+ */
+export function estimatePeakBandwidth(representation, contentType) {
+    const sortedByType = getPeriodSortedBandwidths(representation.parent.parent);
+    const own = sortedByType.get(contentType);
+    if (!own || own.length === 0)
+        return representation.bandwidth;
+    // Find the closest match in the descending-sorted array. indexOf would return -1
+    // when the representation's bandwidth was collapsed by the 10% dedup threshold.
+    const ownIndex = Math.max(0, sortedInsertionIndex(own, representation.bandwidth, (a, b) => b - a) - 1);
+    const position = own.length <= 1 ? 0 : ownIndex / (own.length - 1);
+    let total = representation.bandwidth;
+    for (const [ct, bandwidths] of sortedByType) {
+        if (ct === contentType)
+            continue;
+        const peerIndex = Math.min(Math.round(position * (bandwidths.length - 1)), bandwidths.length - 1);
+        total += bandwidths[peerIndex];
+    }
+    return total;
+}
+/**
+ * Returns sorted (descending) bandwidth arrays per content type for a period.
+ * Bandwidths within 10% of an existing entry are collapsed to reduce noise
+ * from near-duplicate quality tiers.
+ * Cached by period reference.
+ */
+export const getPeriodSortedBandwidths = memoize((period) => {
+    const byType = new Map();
+    for (const as of period.AdaptationSet ?? []) {
+        for (const rep of as.Representation ?? []) {
+            const contentType = getRepresentationMimeInfo(rep).contentType;
+            if (!contentType)
+                continue;
+            const arr = getOrSet(byType, contentType, () => []);
+            if (!arr.some((existing) => Math.abs(existing - rep.bandwidth) / existing < 0.1)) {
+                const index = sortedInsertionIndex(arr, rep.bandwidth, (a, b) => b - a);
+                arr.splice(index, 0, rep.bandwidth);
+            }
+        }
+    }
+    return byType;
+}, (period) => period, 5);
+/**
+ * Converts a Dash ContentProtection element to a list of DrmProtection metadata.
+ */
+export function contentProtectionToMetadata(contentProtection, deps) {
+    const keySystems = deps.drmKeySystemResolver(contentProtection.schemeIdUri);
+    return keySystems.map((keySystem) => {
+        return {
+            keySystem,
+            pssh: contentProtection.pssh?._content ?? null,
+            pro: contentProtection.pro?._content ?? null,
+        };
+    });
+}
+/**
+ * Creates a DescriptorRecord from the Dash list of DescriptorType objects.
+ * @param descriptors
+ */
+function mapDescriptors(descriptors) {
+    const out = {};
+    for (const descriptor of descriptors) {
+        const arr = getOrSetProp(out, descriptor.schemeIdUri, () => []);
+        arr.push({
+            id: descriptor.id ?? null,
+            value: descriptor.value ?? null,
+        });
+    }
+    return out;
+}
+/**
+ * Resolves the group IDs that the given adaptation set is permitted to switch to.
+ *
+ * Per DASH spec, adaptation sets declare `urn:mpeg:dash:adaptation-set-switching:2016` with a
+ * comma-separated list of other adaptation set IDs they can switch to.
+ *
+ * Always includes the adaptation set's own groupId. If no switching property is present,
+ * returns only the adaptation set's own groupId.
+ */
+function resolveAdaptationSetSwitchingGroupIds(adaptationSet, periodId, adaptationSetId) {
+    const selfGroupId = `${periodId}_${adaptationSetId}`;
+    const switchingProp = adaptationSet.SupplementalProperty?.find((p) => p.schemeIdUri === ADAPTATION_SET_SWITCHING_SCHEME);
+    if (!switchingProp)
+        return [selfGroupId];
+    const value = switchingProp.value?.trim();
+    if (!value)
+        return [selfGroupId];
+    const targetIds = value.split(',').map((s) => s.trim());
+    return [selfGroupId, ...targetIds.map((id) => `${periodId}_${id}`)];
+}

package/dist/types/current/track/dash/DashTrack.d.ts

@@ -0,0 +1,46 @@
+import { type TrackBaseOptions } from '../../track/TrackBase';
+import { type DashManifestProvider, type DashManifestData } from './DashManifestProvider';
+import type { DashManifestController } from './DashManifestController';
+import type { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import { type Maybe, type RequestInitOptions } from '@amazon/vinyl-util';
+import { type Factories } from '@amazon/vinyl-di';
+import type { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { type MseTrackDeps } from '../../track/mse/MseTrack';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+export interface DashTrackLoadOptions extends TrackLoadOptions {
+    readonly type: 'dash';
+    /**
+     * If set, will be used to resolve the dash manifest.
+     * Otherwise, the uri will be assumed to represent a URL to an MPD.
+     * The manifest provider is not expected to cache results.
+     */
+    readonly manifestProvider?: Maybe<DashManifestProvider>;
+    /**
+     * If a manifest provider is not set, the uri will be used to fetch a manifest.
+     * This can be set to provide Request initialization options such as headers or request method.
+     */
+    readonly requestInit?: Maybe<RequestInitOptions>;
+    /**
+     * Request initialization options for segment requests, such as headers.
+     * Range headers set by the player for byte-range requests will not be overridden.
+     */
+    readonly segmentRequestInit?: Maybe<RequestInitOptions>;
+    /**
+     * Configuration options for the DashTrack.
+     * Will be set before the track is activated.
+     */
+    readonly config?: Maybe<TrackBaseOptions>;
+}
+export type DashTrackFactoryDeps = {
+    readonly createDashFactories: (loadOptions: DashTrackLoadOptions) => Factories<DashTrackDeps>;
+};
+export declare function createDashTrackFactory(deps: DashTrackFactoryDeps): TrackFactory<DashTrackLoadOptions>;
+export interface DashTrackDeps extends MseTrackDeps {
+    readonly manifestController: DashManifestController;
+    readonly mediaQualityMetadataResolver: DashMediaQualityMetadataResolver;
+    readonly manifestTransformed: ObservableValue<Promise<DashManifestData>>;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
+}
+//# sourceMappingURL=DashTrack.d.ts.map

package/dist/types/current/track/dash/DashTrack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DashTrack.d.ts","sourceRoot":"","sources":["../../../../../src/track/dash/DashTrack.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,KAAK,gBAAgB,EAExB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACH,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACxB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAEH,KAAK,KAAK,EACV,KAAK,kBAAkB,EAC1B,MAAM,oBAAoB,CAAA;AAS3B,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAA;AACrG,OAAO,EAAY,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAA;IAEvD;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAEhD;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAEvD;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAA;CAC5C;AAcD,MAAM,MAAM,oBAAoB,GAAG;IAC/B,QAAQ,CAAC,mBAAmB,EAAE,CAC1B,WAAW,EAAE,oBAAoB,KAChC,SAAS,CAAC,aAAa,CAAC,CAAA;CAChC,CAAA;AAED,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,oBAAoB,GAC3B,YAAY,CAAC,oBAAoB,CAAC,CAcpC;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,sBAAsB,CAAA;IACnD,QAAQ,CAAC,4BAA4B,EAAE,gCAAgC,CAAA;IACvE,QAAQ,CAAC,mBAAmB,EAAE,eAAe,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAA;IACxE,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"}

package/dist/types/current/track/dash/DashTrack.js

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

package/dist/types/current/track/dash/buildDashMediaTimeline.d.ts

@@ -0,0 +1,9 @@
+import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { MediaTimeline } from '../../streaming/MediaTimeline';
+import { type DashSegmentProviderDeps } from '../../track/dash/timeline/DashRepresentationSegmentProvider';
+export type BuildDashMediaTimelineDeps = DashSegmentProviderDeps;
+/**
+ * Builds a MediaTimeline from a Dash manifest.
+ */
+export declare function buildDashMediaTimeline(deps: BuildDashMediaTimelineDeps, data: DashManifestData): MediaTimeline;
+//# sourceMappingURL=buildDashMediaTimeline.d.ts.map

package/dist/types/current/track/dash/buildDashMediaTimeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildDashMediaTimeline.d.ts","sourceRoot":"","sources":["../../../../../src/track/dash/buildDashMediaTimeline.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,KAAK,EAGR,aAAa,EAChB,MAAM,2BAA2B,CAAA;AAQlC,OAAO,EAEH,KAAK,uBAAuB,EAC/B,MAAM,yDAAyD,CAAA;AAEhE,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,CAAA;AAEhE;;GAEG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,0BAA0B,EAChC,IAAI,EAAE,gBAAgB,GACvB,aAAa,CA8Bf"}

package/dist/types/current/track/dash/buildDashMediaTimeline.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { calculateDuration, calculatePeriodEnd, calculatePeriodStart, flattenRepresentations, } from '../../track/dash/util/mpd';
+import { createDashRepresentationSegmentProvider, } from '../../track/dash/timeline/DashRepresentationSegmentProvider';
+/**
+ * Builds a MediaTimeline from a Dash manifest.
+ */
+export function buildDashMediaTimeline(deps, data) {
+    const { manifest, baseUrl } = data;
+    const periods = manifest.MPD.Period.map((period) => {
+        const startTime = calculatePeriodStart(period);
+        const endTime = calculatePeriodEnd(period) ?? Infinity;
+        const representations = flattenRepresentations(period);
+        const qualities = representations.map((representation) => {
+            const metadata = deps.mediaQualityMetadataResolver(representation);
+            const segmentProvider = createDashRepresentationSegmentProvider(deps, baseUrl, representation);
+            return {
+                metadata,
+                getSegment: (time, affordance) => segmentProvider.getSegment(time, affordance),
+            };
+        });
+        return { startTime, endTime, qualities };
+    });
+    const duration = calculateDuration(manifest);
+    return {
+        periods,
+        minBufferTime: manifest.MPD.minBufferTime,
+        getDuration: () => Promise.resolve(duration),
+    };
+}